Skip to main content

max / makenotwork

35.9 KB · 914 lines History Blame Raw
1 //! The public fee calculator at `/pricing`, described.
2 //!
3 //! `1e35bc8a`. The first screen on `base.html` to own its whole document, and
4 //! the first described screen this server serves to a reader with no session.
5 //! Both firsts are consequences of the page rather than goals: `/pricing` is a
6 //! marketing page with no writes on it, so there is no session to resolve and
7 //! nothing for the Askama half to keep.
8 //!
9 //! It replaces `templates/pages/pricing.html`, `templates/partials/fee_calculator.html`,
10 //! `landing::pricing_page`, `landing::pricing_compare` and the `<mnw-price-mode>`
11 //! custom element with its island script. The arithmetic is untouched:
12 //! [`crate::fee_calculator`] still computes every number from
13 //! `docs/business/assumptions.toml`, and nothing about the fee model runs in
14 //! the browser now any more than it did before.
15 //!
16 //! # The recompute is the region's, not a dial's
17 //!
18 //! `Slot::consults` (quasicoherent `cb62a9dc`). The calculator region names the
19 //! route, the wait and the region the answer lands in; the values it sends are
20 //! the questions it contains, gathered by containment. That is the whole of the
21 //! shipped `hx-trigger` block -- five `input changed delay:300ms from:#id`
22 //! clauses and an `hx-include` listing the same five ids again -- said once,
23 //! with nothing naming a dial.
24 //!
25 //! It also decides what `<mnw-price-mode>` was. That element swapped the two
26 //! `data-price-*` values on four radios in the DOM and re-fired the recompute,
27 //! so the browser held a price the server also knew. Under a region consult it
28 //! is one more dial inside the region: a two-option question, sent with the
29 //! rest, and [`compare`] computes on the founder price or the list price. No
30 //! custom element, no DOM rewriting, and one place that knows what a tier
31 //! costs.
32 //!
33 //! # The tier radio sends a tier, not a price
34 //!
35 //! The shipped radio's `value` was the price in dollars, which was the only
36 //! thing that could work while a script rewrote it. With the mode as its own
37 //! dial the price is a function of both, so the value is the tier's own name
38 //! and [`Dials`] resolves the pair. An old shared link carrying `?tier=16`
39 //! still lands where it did: a `tier` that parses as a number is read as
40 //! dollars, which is what it meant.
41 //!
42 //! # What the results panel says now, and what it stopped saying
43 //!
44 //! The partial hand-drew a two-segment bar with a marker, a crossover tick, an
45 //! axis and a legend, and `fee_calculator::Scale` existed to compute the four
46 //! percentages it positioned them with. All of it said one thing: where the
47 //! reader's volume sits against the crossover. That is a proportion of a set,
48 //! which is [`Meter`] -- with the reader's sales as `done` and the crossover as
49 //! `total`, so passing it overflows the bar, which
50 //! [`layout::Meter::done`] names as the case worth drawing. `Scale` goes with
51 //! the partial.
52 //!
53 //! # Two deliberate parity differences
54 //!
55 //! - **The footer's two script-driven links are not here.** `base.html`'s
56 //! footer ends with "What's new" and "Shortcuts", both `<a href="#"
57 //! data-action=..>` bound by `actions-pages.js`. A described act names a
58 //! route or a host behaviour the description can state, and "run the function
59 //! registered under this string" is neither. Both are reachable from every
60 //! other page on the site; `9f2ac7d1` is the vocabulary question.
61 //! - **The dials carry `USD` rather than a leading `$`.** `Field::unit` is
62 //! drawn after the value in every renderer, and `10 $` is the reading to
63 //! avoid. makeover-layout 0.33.0 ruled a unit is a fact about the value and
64 //! not part of the label, so the symbol does not move into the question's
65 //! name; a leading unit is still unsaid, which is filed rather than worked
66 //! around here.
67
68 use std::time::Duration;
69
70 use makeover_layout as layout;
71 use quasi_router::{
72 Action, Cell, Cells, Choice, Column, Consult, Document, Field, Meter, Node, RegionKind,
73 Request, Response, RouteError, Row, Screen, Slot,
74 };
75 use quasi_webview::Webview;
76
77 use crate::Billing;
78 use crate::fee_calculator::{self, Inputs, Outcome, Verdict};
79 use crate::tier_prices::TierPrices;
80
81 /// The address the screen answers, and the one `landing::pricing_page` gives up.
82 pub const PATH: &str = "/pricing";
83
84 /// The route the calculator asks when a dial moves, as the reader's browser
85 /// spells it. The router inside the nest sees it with [`PATH`] taken off.
86 const COMPARE: &str = "/pricing/compare";
87
88 /// The region that holds every dial and the results panel.
89 ///
90 /// Its id is what the shipped markup called it, and nothing outside this module
91 /// reaches for it: the include list it used to need is gone.
92 const CALCULATOR: &str = "pricing-calculator";
93
94 /// The region holding the whole page, and what the skip link jumps to.
95 const PAGE: &str = "pricing-page";
96
97 /// How wide the page runs. `pricing.html` said it as `centered-page`; it is a
98 /// described property now, and the renderer turns it back into that class.
99 const MEASURE: layout::Measure = layout::Measure::Contained;
100
101 /// The region a recompute replaces.
102 ///
103 /// `pub` so the tests name the constant rather than transcribing it.
104 pub const RESULTS: &str = "results-panel";
105
106 /// How long a dial must stand still before the calculator is re-asked.
107 ///
108 /// The shipped `delay:300ms`, unchanged. It is the description's for
109 /// [`Consult::after`]'s reason: how expensive a question is to ask is the
110 /// route's own fact, and no renderer can know it.
111 const SETTLES: Duration = Duration::from_millis(300);
112
113 // The names every dial submits under. `item_price`, `sales`, `other_pct` and
114 // `other_per_sale` are what the shipped inputs were named and what a shared
115 // calculator URL carries, so they are kept exactly.
116 const ITEM_PRICE: &str = "item_price";
117 const SALES: &str = "sales";
118 const TIER: &str = "tier";
119 const PRICE_MODE: &str = "price_mode";
120 const OTHER_PCT: &str = "other_pct";
121 const OTHER_PER_SALE: &str = "other_per_sale";
122
123 /// Calculate on the half-price founder rate.
124 const FOUNDER: &str = "founder";
125 /// Calculate on the standing list rate.
126 const LIST: &str = "list";
127
128 /// The state one `/pricing` request is answered against.
129 ///
130 /// Not [`super::Viewer`]: that factory resolves a session and refuses without
131 /// one, which is right for every screen behind a login and wrong for a
132 /// marketing page. Nothing here is per-reader, so the adapter holds one of
133 /// these for the life of the process rather than building one per request.
134 pub struct Pricing {
135 /// Stripe's published rates, the tier table and the calculator's opening
136 /// positions, all derived from `assumptions.toml` at startup.
137 pub billing: Billing,
138 /// Whether the half-price founder window is open. Decides whether the mode
139 /// question is asked at all, and which rate the page opens on.
140 pub founder_window_open: bool,
141 /// Whether `/changelog` resolves, which is the one conditional link in the
142 /// site footer.
143 pub changelog_published: bool,
144 }
145
146 /// Where every dial sits for one request.
147 ///
148 /// The query string merged over the configured defaults, then clamped. This is
149 /// `landing::PricingCompareQuery::resolve` moved intact, less the two display
150 /// strings the template needed: a described field carries its own value.
151 struct Dials {
152 inputs: Inputs,
153 /// Which tier is picked, by name. The price it resolves to is on `inputs`.
154 tier: &'static str,
155 /// Which rate the tier prices are read at.
156 mode: &'static str,
157 }
158
159 impl Dials {
160 /// Read the dials out of what the control was offered under.
161 fn read(state: &Pricing, carried: &quasi_router::Params) -> Self {
162 let prices = &state.billing.tier_prices;
163 let number = |name: &str| {
164 carried
165 .get(name)
166 .map(str::trim)
167 .and_then(|v| v.parse::<f64>().ok())
168 };
169
170 // With the window shut there is one rate and no question about it, so a
171 // mode arriving in the query is ignored rather than honoured: a shared
172 // link should not be able to price a window that has closed.
173 let mode = match (state.founder_window_open, carried.get(PRICE_MODE)) {
174 (false, _) => LIST,
175 (true, Some(LIST)) => LIST,
176 (true, _) => FOUNDER,
177 };
178
179 // A `tier` that parses as a number is a link written before the tier
180 // radio sent a name, when the value was the price itself. Honoured as
181 // dollars so those links land where they did.
182 let (tier, tier_cost) = match carried.get(TIER) {
183 Some(raw) => match raw.trim().parse::<f64>() {
184 Ok(dollars) if dollars >= 0.0 => (Tier::BASIC.key, dollars),
185 _ => {
186 let tier = Tier::named(raw).unwrap_or(Tier::BASIC);
187 (tier.key, f64::from(tier.price(prices, mode)))
188 }
189 },
190 None => (Tier::BASIC.key, f64::from(Tier::BASIC.price(prices, mode))),
191 };
192
193 let mut inputs = state
194 .billing
195 .fee_calculator
196 .default_inputs(f64::from(prices.basic_std));
197 if let Some(v) = number(ITEM_PRICE) {
198 inputs.item_price = v;
199 }
200 if let Some(v) = number(SALES) {
201 inputs.sales_per_month = v;
202 }
203 // Typed as a whole percent and held as a fraction, which is the one
204 // conversion this page does. The dial multiplies back out when it
205 // renders, so the reader sees what they typed.
206 if let Some(v) = number(OTHER_PCT) {
207 inputs.other_pct = v / 100.0;
208 }
209 if let Some(v) = number(OTHER_PER_SALE) {
210 inputs.other_per_sale = v;
211 }
212 inputs.tier_cost = tier_cost;
213
214 Self {
215 inputs: state.billing.fee_calculator.sanitize(inputs),
216 tier,
217 mode,
218 }
219 }
220
221 /// What the calculator makes of these positions.
222 fn outcome(&self, state: &Pricing) -> Outcome {
223 state.billing.fee_calculator.compute(self.inputs)
224 }
225 }
226
227 /// One tier, as the radio needs it.
228 ///
229 /// The four are a table here rather than eight branches in a template: the
230 /// shipped markup spelled every price twice, once as the radio's value and once
231 /// as the card's display, and a `{% if founder_window_open %}` around each.
232 struct Tier {
233 /// What the radio sends, and what a shared link carries.
234 key: &'static str,
235 /// What the card reads.
236 label: &'static str,
237 /// What the tier is for, in the reader's terms. The envelope comes off
238 /// [`TierPrices`] and is spliced in.
239 fits: &'static str,
240 }
241
242 impl Tier {
243 const BASIC: Self = Self {
244 key: "basic",
245 label: "Basic",
246 fits: "Fits text, blogs, newsletters.",
247 };
248 const SMALL_FILES: Self = Self {
249 key: "small_files",
250 label: "Small Files",
251 fits: "Fits audio, plugins, binaries.",
252 };
253 const BIG_FILES: Self = Self {
254 key: "big_files",
255 label: "Big Files",
256 fits: "Fits video, games, large software.",
257 };
258 const EVERYTHING: Self = Self {
259 key: "everything",
260 label: "Everything",
261 fits: "Big Files envelope plus first access to high-cost features as they ship.",
262 };
263
264 /// The four, in the order the cards are read.
265 const ALL: [Self; 4] = [
266 Self::BASIC,
267 Self::SMALL_FILES,
268 Self::BIG_FILES,
269 Self::EVERYTHING,
270 ];
271
272 /// The tier this key names, if it names one.
273 fn named(key: &str) -> Option<Self> {
274 Self::ALL.into_iter().find(|tier| tier.key == key)
275 }
276
277 /// What it costs a month at this rate.
278 fn price(&self, prices: &TierPrices, mode: &str) -> i32 {
279 let founder = mode == FOUNDER;
280 match self.key {
281 "small_files" => {
282 if founder {
283 prices.small_files_founder
284 } else {
285 prices.small_files_std
286 }
287 }
288 "big_files" => {
289 if founder {
290 prices.big_files_founder
291 } else {
292 prices.big_files_std
293 }
294 }
295 "everything" => {
296 if founder {
297 prices.everything_founder
298 } else {
299 prices.everything_std
300 }
301 }
302 // Basic, and the arm a tier added upstream lands in: the cheapest
303 // envelope is a wrong price rather than a panic on a public page.
304 _ => {
305 if founder {
306 prices.basic_founder
307 } else {
308 prices.basic_std
309 }
310 }
311 }
312 }
313
314 /// The second line under the tier's name: what it costs, what it holds and
315 /// what that suits.
316 fn detail(&self, prices: &TierPrices, mode: &str) -> String {
317 let price = self.price(prices, mode);
318 match self.key {
319 "small_files" => format!(
320 "${price}/mo. {}/file, {} total. {}",
321 prices.small_files_per_file, prices.small_files_total, self.fits
322 ),
323 "big_files" => format!(
324 "${price}/mo. {}/file, {} total. {}",
325 prices.big_files_per_file, prices.big_files_total, self.fits
326 ),
327 // Everything's envelope is Big Files', which its own sentence says,
328 // so it names no caps of its own.
329 "everything" => format!("${price}/mo. {}", self.fits),
330 _ => format!(
331 "${price}/mo. {}/file, {} total. {}",
332 prices.basic_per_file, prices.basic_total, self.fits
333 ),
334 }
335 }
336 }
337
338 /// The whole page.
339 pub fn screen(state: &Pricing, request: Request) -> Result<Response, RouteError> {
340 // The bag is moved out of the request rather than borrowed from it: the
341 // handler signature is quasi's, so the request arrives owned and nothing
342 // else here reads it.
343 let carried = request.carried;
344 let dials = Dials::read(state, &carried);
345 Ok(page(state, &dials).into())
346 }
347
348 /// A recompute: the results panel and nothing else.
349 ///
350 /// Pure arithmetic over the dials, no session and no state change, which is why
351 /// it is a GET and why the screen it belongs to needs no token.
352 pub fn compare(state: &Pricing, request: Request) -> Result<Response, RouteError> {
353 let carried = request.carried;
354 let dials = Dials::read(state, &carried);
355 Ok(Response::fragment(
356 RESULTS,
357 Node::Region(results(&dials.outcome(state))),
358 ))
359 }
360
361 /// The described document, top to bottom.
362 fn page(state: &Pricing, dials: &Dials) -> Screen {
363 Screen::list_detail("Pricing Calculator - Makenotwork", false)
364 .measured(MEASURE)
365 // What `pricing.html` said as `class="centered-page"`, read off the
366 // measure declared on the line above rather than off a route table.
367 //
368 // On the screen and not on the shell (quasicoherent `ee1882e0`). The
369 // shell is built once and `Arc`'d at adapter construction, so a class
370 // set there is a constant for every screen that adapter ever serves --
371 // which is right for one page and silently wrong for the second, and
372 // the second is what the conversion is producing. The empty slice is
373 // `pricing.html` carrying nothing beside the measure, which is why this
374 // screen needed no mapping at all.
375 .documented(Document::default().classed(crate::shell::body_class(MEASURE, &[])))
376 // The whole of what `base.html` put in `<meta name="description">`,
377 // including the fee sentence, because this one string is now all three
378 // tags: the social pair and the plain one. It carried only the first
379 // sentence while the plain tag was appended separately.
380 .summarised(
381 "Work out what you keep on every sale here, against whatever the \
382 platform you sell on now deducts. 0% platform fee, only the \
383 payment processor's ~3%.",
384 )
385 .with(
386 Slot::new(PAGE, RegionKind::Pane)
387 .with(Node::page("Pricing Calculator"))
388 .with(Node::text("See what you keep on every sale."))
389 .with(Node::Region(calculator(state, dials)))
390 .with(Node::act("Join the Alpha", Action::get("/join")))
391 .with(Node::List {
392 rows: vec![
393 Row::new("Home").activate(Action::get("/")),
394 Row::new("Browse as guest").activate(Action::get("/discover")),
395 ],
396 more: None,
397 })
398 .with(Node::Region(footer(state))),
399 )
400 }
401
402 /// Every dial, and the panel they recompute.
403 fn calculator(state: &Pricing, dials: &Dials) -> Slot {
404 let prices = &state.billing.tier_prices;
405 let inputs = dials.inputs;
406
407 let mut slot = Slot::group(CALCULATOR)
408 .consulting(Consult::new(Action::get(COMPARE).replacing(RESULTS)).after(SETTLES))
409 .with(Node::section("What you sell"))
410 .with(Node::field(dial(
411 ITEM_PRICE,
412 "Price per item",
413 inputs.item_price,
414 fee_calculator::MAX_ITEM_PRICE,
415 "1",
416 "USD",
417 )))
418 .with(Node::field(dial(
419 SALES,
420 "Sales per month",
421 inputs.sales_per_month,
422 fee_calculator::MAX_SALES,
423 "1",
424 "/mo",
425 )));
426
427 // Same wording as the landing tagline, because it is the same offer.
428 if state.founder_window_open {
429 slot = slot.with(Node::banner(
430 layout::Tone::Success,
431 "Founder pricing open. Half off creator tiers, locked for life. The \
432 calculator is using founder prices.",
433 ));
434 }
435
436 slot = slot
437 .with(Node::section("Your content tier"))
438 .with(Node::text(
439 "Every tier is the complete platform: profile, project pages, forum, \
440 discovery, memberships, analytics, full data export. The tier picks \
441 the file-size envelope, not the feature set.",
442 ));
443
444 // Only while there are two rates to choose between. With the window shut
445 // the page is what it was before either the toggle or this question
446 // existed.
447 if state.founder_window_open {
448 slot = slot.with(Node::field(
449 Field::radio(
450 PRICE_MODE,
451 "Calculate with",
452 vec![
453 Choice::new(FOUNDER, "Founder price"),
454 Choice::new(LIST, "List price"),
455 ],
456 )
457 .value(dials.mode),
458 ));
459 }
460
461 slot = slot
462 .with(Node::field(
463 Field::radio(
464 TIER,
465 "Content tier",
466 Tier::ALL
467 .iter()
468 .map(|tier| {
469 Choice::new(tier.key, tier.label).detailing(tier.detail(prices, dials.mode))
470 })
471 .collect(),
472 )
473 .value(dials.tier),
474 ))
475 .with(Node::section("Wherever else you sell"))
476 .with(Node::text(
477 "Fill in what the other platform takes. Use its total deduction, its \
478 own cut plus any payment processing it adds, which is the figure you \
479 can read off a payout. We hold no rates for anyone but ourselves, so \
480 nothing here can go stale or be picked to flatter us.",
481 ))
482 .with(Node::field(dial(
483 OTHER_PCT,
484 "Their cut",
485 inputs.other_pct * 100.0,
486 fee_calculator::MAX_OTHER_PCT * 100.0,
487 "0.1",
488 "%",
489 )))
490 .with(Node::field(dial(
491 OTHER_PER_SALE,
492 "Their fee per sale",
493 inputs.other_per_sale,
494 fee_calculator::MAX_OTHER_PER_SALE,
495 "0.05",
496 "USD",
497 )))
498 .with(Node::Region(results(&dials.outcome(state))));
499
500 slot
501 }
502
503 /// A dial: a bounded number holding what it holds, in the unit it is measured
504 /// in.
505 ///
506 /// `min` and `max` are set on the struct rather than through a builder because
507 /// `Field::range` is the slider's constructor and these are typed boxes: the
508 /// bounds are a rule the answer is checked against, not the control itself.
509 /// They are `fee_calculator`'s own constants, so the box refuses what
510 /// `FeeCalculator::sanitize` would clamp instead of silently disagreeing with
511 /// it.
512 fn dial(
513 name: &'static str,
514 label: &'static str,
515 value: f64,
516 max: f64,
517 step: &'static str,
518 unit: &'static str,
519 ) -> Field {
520 let mut field = Field::new(layout::FieldKind::Number, name, label)
521 .value(fmt_dial(value))
522 .step(step)
523 .unit(unit);
524 field.min = Some("0".to_string());
525 field.max = Some(fmt_dial(max));
526 field
527 }
528
529 /// The panel the recompute replaces.
530 ///
531 /// Returns the [`Slot`] rather than a [`Node`] so the screen can nest it and
532 /// [`compare`] can answer with it, which is the one thing both paths have to
533 /// agree about.
534 fn results(outcome: &Outcome) -> Slot {
535 let mut slot = Slot::new(RESULTS, RegionKind::Pane)
536 .with(Node::banner(tone(outcome.verdict), &outcome.headline))
537 .with(Node::Table {
538 columns: vec![
539 Column::new("Monthly")
540 .width(layout::Width::Fill)
541 .priority(layout::Priority::Essential),
542 Column::new("Here")
543 .width(layout::Width::Content)
544 .priority(layout::Priority::Essential),
545 Column::new("The other platform")
546 .width(layout::Width::Content)
547 .priority(layout::Priority::Essential),
548 ],
549 rows: vec![
550 Cells::new([
551 Cell::new("You sell"),
552 Cell::new(outcome.gross.clone()),
553 Cell::new(outcome.gross.clone()),
554 ]),
555 Cells::new([
556 Cell::new("You keep"),
557 Cell::new(outcome.mnw_keep.clone()),
558 Cell::new(outcome.other_keep.clone()),
559 ]),
560 Cells::new([
561 Cell::new("Total fees"),
562 Cell::new(outcome.mnw_rate.clone()),
563 Cell::new(outcome.other_rate.clone()),
564 ]),
565 ],
566 more: None,
567 });
568
569 // Where the reader's volume sits against the crossover, which is the whole
570 // of what the hand-drawn two-segment bar said. Absent when there is no
571 // crossover, because there is then no set to be a proportion of, and the
572 // note below says why in words.
573 if let Some(crossover) = outcome.crossover_sales {
574 slot = slot
575 .with(Node::section("Where each one wins"))
576 .with(Node::Meter(
577 Meter::new(
578 outcome.sales_per_month.round().max(0.0) as u32,
579 crossover.ceil().max(1.0) as u32,
580 )
581 .tone(tone(outcome.verdict))
582 .label("sales a month to the crossover"),
583 ));
584 }
585
586 if let Some(note) = &outcome.crossover_note {
587 slot = slot.with(Node::text(note));
588 }
589
590 slot.with(Node::text(
591 "Our side of this uses the payment processor's published US card rates. \
592 Yours is whatever you type in, so check it against a real payout rather \
593 than a pricing page: some platforms quote their cut before processing \
594 and some after.",
595 ))
596 .with(Node::text(
597 "Selling small-ticket items? Payment processors charge a fixed fee per \
598 sale (~$0.30) that hits harder on $1-5 items. That is an industry-wide \
599 constraint and it applies wherever you sell. Bundling items into \
600 collections lets fans buy in groups at a single transaction cost \
601 instead of paying per-item processing.",
602 ))
603 }
604
605 /// What a verdict means, as every renderer already draws it.
606 ///
607 /// The template branched on `Verdict::css_class`, three class names this
608 /// server's own stylesheet defined. A tone says the same thing in a word every
609 /// host has.
610 const fn tone(verdict: Verdict) -> layout::Tone {
611 match verdict {
612 Verdict::MnwAhead => layout::Tone::Success,
613 Verdict::Even => layout::Tone::Neutral,
614 Verdict::OtherAheadForNow | Verdict::OtherAhead => layout::Tone::Warning,
615 }
616 }
617
618 /// The site footer, described.
619 ///
620 /// Here rather than in `base.html` because this screen owns its document. It
621 /// stays in this module while it is the only such screen; the second one moves
622 /// it out, and moving it is the cheaper half of that conversion.
623 fn footer(state: &Pricing) -> Slot {
624 let mut rows = vec![
625 Row::new("Pricing").activate(Action::get("/pricing")),
626 Row::new("Creators").activate(Action::get("/creators")),
627 Row::new("Docs").activate(Action::get("/docs")),
628 Row::new("Legal").activate(Action::get("/policy")),
629 Row::new("Credits").activate(Action::get("/docs/credits")),
630 ];
631 // Linked only while a published changelog project exists; the route 404s
632 // otherwise. See `crate::changelog`.
633 if state.changelog_published {
634 rows.push(Row::new("Changelog").activate(Action::get("/changelog")));
635 }
636 rows.push(Row::new("Contact").activate(Action::external("mailto:info@makenot.work")));
637 rows.push(Row::new("Status").activate(Action::get("/health")));
638
639 Slot::new("site-footer", RegionKind::Pane)
640 .with(Node::List { rows, more: None })
641 .with(Node::text("(c) 2026 Make Creative, LLC"))
642 }
643
644 /// Render a dial's value: no trailing zeros on a whole number, at most two
645 /// decimals otherwise. `12.6`, `0.30` and `25` all read as typed.
646 ///
647 /// `landing::fmt_dial`, moved with the two dials that needed it.
648 fn fmt_dial(v: f64) -> String {
649 let s = format!("{v:.2}");
650 s.trim_end_matches('0').trim_end_matches('.').to_string()
651 }
652
653 /// The document this screen is drawn in.
654 ///
655 /// Everything from `<!doctype>` to `</html>`, which is the part `base.html`
656 /// owned for every other page on this site. Three things it has to carry that
657 /// a region-sized screen never did:
658 ///
659 /// 1. **The body class.** `pricing.html` wrote
660 /// `class="{{ shell::measure(Measure::Contained) }}"`, and the measure is a
661 /// described property now ([`Screen::measured`]), so the class is read off
662 /// the screen rather than off a route table. That is what `2790e5c4` asks
663 /// for, answered from the description instead of from a mapping this server
664 /// would have to keep in step with 74 templates.
665 /// 2. **The head.** [`crate::shell`] already owns it for the Askama pages, and
666 /// the same [`quasi_webview::Shell`] builds it here, so the two documents
667 /// cannot drift.
668 /// 3. **The tail.** `base.html` ends with a toast container and seven classic
669 /// script shims that the `data-action` dispatcher resolves through. They are
670 /// markup no description will name -- a script tag, and a container another
671 /// script writes into -- which is what `Shell::with_body_last` is for.
672 #[must_use]
673 pub fn renderer() -> Webview {
674 let shell = crate::shell::described()
675 .with_body_first(crate::shell::skip_link(PAGE))
676 .with_body_last(crate::shell::body_last())
677 // What this site offers from everywhere, which today is one key
678 // (`e0c0d991`). On the shell rather than on a screen because that is
679 // the whole claim chrome makes: an affordance reachable from every
680 // screen is not a fact about any one of them, and every screen
681 // converted after this inherits it with no further work.
682 //
683 // It is also what gives `Outcome::Over` somewhere to land -- a renderer
684 // emits the overlay container for an app that declares chrome, and an
685 // app that declares none gets a swap that does nothing.
686 .with_chrome(crate::quasi::shortcuts::chrome());
687 // The `Shell::head` append that stood here is gone as of quasi 0.80
688 // (quasicoherent `a0e16839`). It wrote the plain `<meta name="description">`
689 // by hand because `Screen::summarised` reached `og:description` and
690 // `twitter:description` and stopped; it reaches all three now, off the one
691 // string the screen already declares. An escape hatch spending itself on
692 // something a described property carries is the escape hatch going unused.
693 //
694 Webview::new().with_shell(shell)
695 }
696
697 #[cfg(test)]
698 mod tests {
699 use super::*;
700
701 /// A calculator built from the canonical assumptions, at either rate.
702 ///
703 /// The real table and the real Stripe fees, because the thing under test is
704 /// which of them a dial reaches rather than what they are: a fixture with
705 /// invented prices would pass while the tier lookup read the wrong column.
706 fn state(founder_window_open: bool) -> Pricing {
707 crate::tier_prices::TierPrices::install_test_default();
708 Pricing {
709 billing: Billing {
710 payments: None,
711 payment_caps: crate::payments::PaymentCapabilities::default(),
712 tier_prices: crate::tier_prices::TierPrices::global().clone(),
713 runway_config: crate::tier_prices::RunwayConfig {
714 quarters: 0,
715 last_updated_iso: String::new(),
716 },
717 fee_calculator: crate::fee_calculator::FeeCalculator::load(
718 "docs/business/assumptions.toml",
719 ),
720 },
721 founder_window_open,
722 changelog_published: false,
723 }
724 }
725
726 fn carrying(pairs: &[(&str, &str)]) -> quasi_router::Params {
727 pairs.iter().copied().collect()
728 }
729
730 /// A dial position, spelled with a tolerance so `float_cmp` stays happy.
731 /// The same helper `fee_calculator::tests` uses, for its reason.
732 fn approx(got: f64, want: f64, what: &str) {
733 assert!((got - want).abs() < 1e-9, "{what}: got {got}, want {want}");
734 }
735
736 /// The whole of the shipped `hx-trigger`/`hx-include` block, said once.
737 ///
738 /// Five `input changed delay:300ms from:#id` clauses and five ids listed
739 /// again to be sent. Here the region names the route, the wait and the
740 /// landing place, and names no dial at all.
741 #[test]
742 fn the_region_asks_and_nothing_names_a_dial() {
743 let state = state(true);
744 let screen = page(&state, &Dials::read(&state, &carrying(&[])));
745
746 let asking = screen.consulting();
747 assert_eq!(asking.len(), 1, "one panel recomputes, not several");
748 let consult = &asking[0].consults[0];
749 assert_eq!(consult.action.route(), Some(COMPARE));
750 assert_eq!(consult.after, SETTLES);
751 assert!(
752 consult.sends.is_empty(),
753 "a dial inside the region rides along by containment, so nothing \
754 should be named: {:?}",
755 consult.sends
756 );
757 }
758
759 /// Every dial the recompute needs is inside the region that asks, which is
760 /// what containment means here. Six with the window open, because the mode
761 /// is a dial like any other.
762 #[test]
763 fn the_region_contains_every_dial_the_route_reads() {
764 let state = state(true);
765 let screen = page(&state, &Dials::read(&state, &carrying(&[])));
766 let names: Vec<&str> = screen.consulting()[0]
767 .questions()
768 .iter()
769 .map(|field| field.name.as_str())
770 .collect();
771
772 assert_eq!(
773 names,
774 [
775 ITEM_PRICE,
776 SALES,
777 PRICE_MODE,
778 TIER,
779 OTHER_PCT,
780 OTHER_PER_SALE
781 ]
782 );
783 }
784
785 /// With the window shut there is one rate, so there is no question to ask
786 /// about it and no control that does nothing.
787 #[test]
788 fn the_mode_is_not_asked_once_the_window_shuts() {
789 let state = state(false);
790 let screen = page(&state, &Dials::read(&state, &carrying(&[])));
791 let names: Vec<&str> = screen.consulting()[0]
792 .questions()
793 .iter()
794 .map(|field| field.name.as_str())
795 .collect();
796
797 assert!(!names.contains(&PRICE_MODE), "{names:?}");
798 }
799
800 /// The mode reaches the arithmetic. This is what `<mnw-price-mode>` did in
801 /// the DOM, and the whole reason it could be deleted.
802 #[test]
803 fn the_mode_picks_which_rate_the_tier_costs() {
804 let state = state(true);
805 let prices = &state.billing.tier_prices;
806 assert_ne!(
807 prices.basic_founder, prices.basic_std,
808 "the assumptions make this vacuous if the two rates are equal"
809 );
810
811 let founder = Dials::read(&state, &carrying(&[(TIER, "basic")]));
812 let list = Dials::read(&state, &carrying(&[(TIER, "basic"), (PRICE_MODE, LIST)]));
813
814 approx(
815 founder.inputs.tier_cost,
816 f64::from(prices.basic_founder),
817 "founder rate",
818 );
819 approx(
820 list.inputs.tier_cost,
821 f64::from(prices.basic_std),
822 "list rate",
823 );
824 }
825
826 /// A shut window prices at list whatever a shared link says, so a link
827 /// cannot resurrect an offer that has ended.
828 #[test]
829 fn a_link_cannot_price_a_window_that_has_closed() {
830 let state = state(false);
831 let dials = Dials::read(&state, &carrying(&[(TIER, "basic"), (PRICE_MODE, FOUNDER)]));
832
833 assert_eq!(dials.mode, LIST);
834 approx(
835 dials.inputs.tier_cost,
836 f64::from(state.billing.tier_prices.basic_std),
837 "a shut window prices at list",
838 );
839 }
840
841 /// The radio's value used to be the price itself, so a link written then
842 /// carries dollars where a tier name goes now.
843 #[test]
844 fn an_older_link_carrying_a_price_is_read_as_dollars() {
845 let state = state(true);
846 let dials = Dials::read(&state, &carrying(&[(TIER, "24"), (SALES, "100")]));
847
848 approx(dials.inputs.tier_cost, 24.0, "the price the link carried");
849 approx(dials.inputs.sales_per_month, 100.0, "sales");
850 }
851
852 /// The cut is typed as a whole percent and held as a fraction, which is the
853 /// one conversion this page does.
854 #[test]
855 fn the_cut_is_typed_whole_and_held_as_a_fraction() {
856 let state = state(false);
857 let dials = Dials::read(&state, &carrying(&[(OTHER_PCT, "12.6")]));
858
859 approx(dials.inputs.other_pct, 0.126, "12.6% as a fraction");
860 }
861
862 /// The class `pricing.html` carried, still on `<body>` and now the
863 /// screen's rather than the adapter's.
864 ///
865 /// quasicoherent `ee1882e0`. Asserted on the screen rather than on the
866 /// emitted markup because that is where the change is: the renderer folding
867 /// a document into a `<body>` tag is quasi-webview's own test, and this
868 /// server does not link `quasi-http` to call `Serves::screen` here.
869 #[test]
870 fn the_document_carries_the_class_the_template_carried() {
871 let screen = page(&state(false), &Dials::read(&state(false), &carrying(&[])));
872
873 assert_eq!(
874 screen.document.body_class.as_deref(),
875 Some(crate::shell::body_class(MEASURE, &[]).as_str())
876 );
877 assert_eq!(screen.document.body_class.as_deref(), Some("centered-page"));
878 }
879
880 /// Where the reader sits against the crossover, drawn only when there is a
881 /// crossover to sit against.
882 #[test]
883 fn the_panel_meters_the_crossover_only_when_there_is_one() {
884 let state = state(false);
885 let calculator = &state.billing.fee_calculator;
886
887 let ahead = calculator.compute(Inputs {
888 item_price: 25.0,
889 sales_per_month: 40.0,
890 tier_cost: 16.0,
891 other_pct: 0.126,
892 other_per_sale: 0.30,
893 });
894 assert!(has_meter(&results(&ahead)), "a crossover with no meter");
895
896 // Their cut is below our processing, so no volume closes the gap and
897 // there is no set for a proportion to be of.
898 let never = calculator.compute(Inputs {
899 item_price: 5.0,
900 sales_per_month: 500.0,
901 tier_cost: 16.0,
902 other_pct: 0.01,
903 other_per_sale: 0.0,
904 });
905 assert!(!has_meter(&results(&never)), "metered against nothing");
906 }
907
908 fn has_meter(slot: &Slot) -> bool {
909 slot.body
910 .iter()
911 .any(|placed| matches!(placed.node, Node::Meter(_)))
912 }
913 }
914