@copilotz/billing 0.0.0-stage → 1.0.0-rc.35

package/credits/views/web/composer.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * The note above where you type (kind `billing.composer`, chat's
+ * `composerNotes`): so people know before they send. Nothing at all while it
+ * asks, when there's nothing to say, or if it can't ask. Stopped, it says the
+ * org is out of credits or at its budget: with a way to Billing for those who
+ * run it, and who can help for everyone else; that one can't be put away. Low,
+ * for those who run it, what's left and a way to add more, which they can put
+ * away for this visit. It asks when it appears, when the page comes back, and
+ * when agents finish working (`hints.working`), which is when it changes.
+ */
+import { useEffect, useState } from "react";
+import { Button, IconButton, Notice } from "copilotz/web";
+import { useStanding } from "copilotz/plugins/interfaces/contract";
+import { noticeKey, noticeSaid } from "./numbers.js";
+import { STYLE } from "./style.js";
+const BILLING = "/org?tab=billing";
+/** Where dismissing is kept: for this visit, this org. */
+const keyOf = (org, said) => `billing-note-away:${org}:${noticeKey(said)}`;
+const away = (key) => {
+    try {
+        return sessionStorage.getItem(key) === "1";
+    }
+    catch {
+        return false;
+    }
+};
+export const composerNoteView = (_, ctx) => (_jsxs(_Fragment, { children: [_jsx("style", { href: "billing-web", precedence: "copilotz", children: STYLE }), _jsx(Note, { call: ctx.call, working: ctx.hints.working === true })] }));
+function Note({ call, working }) {
+    // The org it's in (spaces' `org.me`, where the app serves many): its notes are kept apart.
+    const here = useStanding(call)?.org;
+    const [said, setSaid] = useState(null);
+    const [gone, setGone] = useState();
+    useEffect(() => {
+        if (working)
+            return;
+        let current = true;
+        const ask = () => call("billing.notice", {}).then((answer) => current && setSaid(answer), 
+        // A failure to ask says nothing: the real thing decides when someone sends.
+        () => { });
+        const again = () => document.visibilityState === "visible" && void ask();
+        void ask();
+        document.addEventListener("visibilitychange", again);
+        return () => {
+            current = false;
+            document.removeEventListener("visibilitychange", again);
+        };
+    }, [working]);
+    if (!said)
+        return null;
+    const key = keyOf(here?.id ?? "", said);
+    if (said.tone === "low" && (gone === key || away(key)))
+        return null;
+    const words = noticeSaid(said, here?.kind === "personal");
+    const stop = said.tone === "stop";
+    return (_jsxs(Notice, { tone: stop ? "warning" : "neutral", role: "status", className: "billing-note", action: _jsxs(_Fragment, { children: [said.runs
+                    ? (_jsx(Button, { size: "sm", variant: stop ? "primary" : "outline", href: BILLING, children: stop ? "Go to Billing" : said.why === "budget" ? "Change budget" : "Add credits" }))
+                    : null, stop ? null : (_jsx(IconButton, { icon: "close", size: "sm", label: "Not now", onClick: () => {
+                        try {
+                            sessionStorage.setItem(key, "1");
+                        }
+                        catch { /* It stays away for this page only. */ }
+                        setGone(key);
+                    } }))] }), children: [_jsxs("b", { children: [words.title, words.more ? "." : ""] }), words.more ? ` ${words.more}` : ""] }));
+}

package/credits/views/web/history.d.ts

@@ -0,0 +1,12 @@
+/**
+ * What came in, newest first: credits (what they were, why, how much, when, and
+ * when they lapse) and payments (what for, how much, when). A long list shows
+ * its first few, the rest a press away. Nothing yet says what will show here.
+ * Staff also see a payment's reference and what the channel kept, marked as
+ * theirs; the org's people never see that.
+ */
+import { type ReactNode } from "react";
+import { type BillingState } from "./numbers.js";
+export declare function History({ state }: {
+    state: BillingState;
+}): ReactNode;

package/credits/views/web/history.js

@@ -0,0 +1,55 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * What came in, newest first: credits (what they were, why, how much, when, and
+ * when they lapse) and payments (what for, how much, when). A long list shows
+ * its first few, the rest a press away. Nothing yet says what will show here.
+ * Staff also see a payment's reference and what the channel kept, marked as
+ * theirs; the org's people never see that.
+ */
+import { useState } from "react";
+import { Button, Card, EmptyState, Icon, Tabs } from "copilotz/web";
+import { dayShown, dollars, inCurrency, kindSaid, money, newestFirst, purposeSaid, whenShown, } from "./numbers.js";
+const FIRST = 8;
+export function History({ state }) {
+    const credits = newestFirst(state.history ?? []);
+    const payments = newestFirst(state.payments ?? []);
+    const [which, setWhich] = useState("credits");
+    const [all, setAll] = useState(false);
+    const rows = which === "credits" ? credits : payments;
+    const shown = all ? rows : rows.slice(0, FIRST);
+    return (_jsxs(Card, { as: "section", className: "billing-card billing-history", "aria-labelledby": "billing-history", children: [_jsxs("header", { className: "billing-card-head billing-history-head", children: [_jsx("h3", { id: "billing-history", children: "History" }), _jsx(Tabs, { label: "Which history", value: which, onChange: (next) => {
+                            setWhich(next);
+                            setAll(false);
+                        }, tabs: [
+                            { value: "credits", label: "Credits", count: credits.length || undefined },
+                            { value: "payments", label: "Payments", count: payments.length || undefined },
+                        ] })] }), rows.length
+                ? (_jsx("ul", { className: "billing-rows", children: which === "credits"
+                        ? shown.map((row) => _jsx(CreditLine, { row: row }, row._id))
+                        : shown.map((row) => (_jsx(PaymentLine, { row: row, staff: state.staff }, row._id))) }))
+                : (_jsx(EmptyState, { icon: which === "credits" ? "star" : "note", heading: "h3", title: which === "credits" ? "No credits yet" : "No payments yet", className: "billing-none", children: which === "credits"
+                        ? "Credits show here as they're added."
+                        : "What this org pays shows here, as it's paid." })), rows.length > FIRST
+                ? (_jsx(Button, { size: "sm", variant: "ghost", className: "billing-more", onClick: () => setAll(!all), children: all ? "Show fewer" : `Show all ${rows.length}` }))
+                : null] }));
+}
+function CreditLine({ row }) {
+    // A plan's credits and a trial note the plan they came from; anything else, why it was given.
+    const ofPlan = row.kind === "plan" || row.kind === "trial";
+    const more = [
+        row.note ? (ofPlan ? `${row.note} plan` : row.note) : null,
+        row.expires ? `Lapses ${dayShown(row.expires)}` : null,
+    ].filter(Boolean).join(" · ");
+    return (_jsxs("li", { className: "billing-row", children: [_jsxs("span", { className: "billing-row-text", children: [_jsx("b", { children: kindSaid(row.kind) }), more ? _jsx("span", { className: "billing-row-note", children: more }) : null] }), _jsxs("span", { className: "billing-row-end", children: [_jsx("span", { className: "billing-row-amount", "data-way": row.amount < 0 ? "out" : "in", children: row.amount < 0 ? money(row.amount) : `+${money(row.amount)}` }), _jsx("small", { children: whenShown(row.at) })] })] }));
+}
+function PaymentLine({ row, staff }) {
+    const more = [
+        row.note,
+        row.credits
+            ? `${dollars(Math.abs(row.credits))} of credits${row.credits < 0 ? " taken back" : ""}`
+            : null,
+    ].filter(Boolean).join(" · ");
+    return (_jsxs("li", { className: "billing-row", children: [_jsxs("span", { className: "billing-row-text", children: [_jsx("b", { children: purposeSaid(row.purpose) }), more ? _jsx("span", { className: "billing-row-note", children: more }) : null, staff
+                        ? (_jsxs("span", { className: "billing-row-staff", children: [_jsx(Icon, { name: "shield", size: 11 }), row.channel, ": ", row.ref, row.fee !== undefined ? ` · kept ${inCurrency(row.fee, row.currency)}` : "", row.rate !== undefined ? ` · ${row.rate} USD each` : ""] }))
+                        : null] }), _jsxs("span", { className: "billing-row-end", children: [_jsx("span", { className: "billing-row-amount", "data-way": row.amount < 0 ? "out" : "paid", children: inCurrency(row.amount, row.currency) }), _jsx("small", { children: whenShown(row.at) })] })] }));
+}

package/credits/views/web/numbers.d.ts

@@ -0,0 +1,256 @@
+/**
+ * Billing as the web says it: what `billing.state` answers, in words and
+ * numbers people read. Money to the cent, so a balance can be trusted; a day
+ * as the calendar has it, wherever you are (the backend's days are UTC);
+ * credits by what they are and in the order they're spent; what a plan
+ * includes and what it comes to for the org's seats; why the org is stopped
+ * or running low; how far along the month's budget is; an amount as typed; and
+ * whether what was just paid has landed. Only prices: never a cost or a fee.
+ */
+/** A pile of credits, as the walk leaves it: what it was, what's left, when it lapses. */
+export type Bucket = {
+    id: string;
+    kind: string;
+    amount: number;
+    left: number;
+    expires?: string;
+};
+/** A credit in the org's history. */
+export type CreditRow = {
+    _id: string;
+    kind: string;
+    amount: number;
+    at: string;
+    expires?: string;
+    note?: string;
+};
+/** Money that came in. */
+export type PaymentRow = {
+    _id: string;
+    channel: string;
+    ref: string;
+    amount: number;
+    currency: string;
+    purpose: string;
+    credits?: number;
+    note?: string;
+    fee?: number;
+    rate?: number;
+    at: string;
+};
+export type Seat = {
+    price: number;
+    currency: string;
+};
+export type CreditTerms = {
+    once?: number;
+    monthly?: number;
+    perSeat?: number;
+};
+export type Terms = {
+    title: string;
+    seat?: Seat;
+    credits?: CreditTerms;
+    prices?: string;
+    /** Which orgs may be on it; none: any. */
+    for?: "personal" | "team";
+    /** The model tier its agents use while the org hasn't chosen one. */
+    models?: string;
+};
+/** A waiver: why, by whom, until when; for seats, whose. */
+export type Waiver = {
+    from: string;
+    reason: string;
+    until?: string;
+    by?: string;
+    people?: string[];
+};
+export type Plan = {
+    name: string;
+    terms: Terms;
+    since: string;
+    channel?: string;
+    status?: string;
+    customer?: string;
+    subscription?: string;
+    fixedSeats?: number;
+    waived?: {
+        usage?: Waiver;
+        seats?: Waiver;
+    };
+};
+/** A plan the org can move to by itself. */
+export type Offer = {
+    name: string;
+    title: string;
+    seat: Seat;
+    credits?: CreditTerms;
+    for?: "personal" | "team";
+};
+export type Pay = {
+    topUps: number[];
+    min: number;
+    max: number;
+    /** Those it can move to, its own kind of org's first. */
+    plans: Offer[];
+    /** Those only another kind of org can have (a team's, for a personal org). */
+    elsewhere?: Offer[];
+    manage: boolean;
+};
+export type Month = {
+    start: string;
+    end: string;
+    spent: number;
+    limit?: number;
+};
+/** What `billing.state` answers. People who don't run the org get only the first few. */
+export type BillingState = {
+    on: boolean;
+    runs: boolean;
+    staff: boolean;
+    ok?: boolean;
+    why?: "credits" | "budget";
+    message?: string;
+    low?: boolean;
+    plan?: Plan | null;
+    seats?: number;
+    /** Those a seat is charged for: all but those waived. */
+    billedSeats?: number;
+    /** What it's running low on. */
+    lowOn?: "credits" | "budget";
+    period?: {
+        start: string;
+        end: string;
+    };
+    balance?: number;
+    buckets?: Bucket[];
+    debt?: number;
+    waived?: boolean;
+    month?: Month;
+    history?: CreditRow[];
+    payments?: PaymentRow[];
+    pay?: Pay | null;
+    plans?: Record<string, Terms>;
+};
+/** Dollars to the cent: "$1,234.50", "$0.00"; "<$0.01" for crumbs; a minus sign below zero. */
+export declare function money(n: number): string;
+/** Dollars, cents only when there are some: "$25", "$12.50", "$1,000". */
+export declare function dollars(n: number): string;
+/** An amount in its currency: "$25", "R$ 100.50"; a code it doesn't know stands as it is. */
+export declare function inCurrency(n: number, currency: string): string;
+/** A day as the calendar has it ("Dec 1"; its year when it isn't this one), wherever you are. */
+export declare function dayShown(day: string, now?: number): string;
+/** The day before: a period's last, since the backend's `end` is the first day after it. */
+export declare const dayBefore: (day: string) => string;
+/** A period's dates, its last day included: "Nov 1 to Nov 30". */
+export declare const periodShown: (period: {
+    start: string;
+    end: string;
+}, now?: number) => string;
+/** When something happened, where you are: "Nov 1", with its year when it isn't this one. */
+export declare function whenShown(at: string, now?: number): string;
+/** What a credit is, in words. */
+export declare const kindSaid: (kind: string) => string;
+/** What a payment was for, in words. */
+export declare const purposeSaid: (purpose: string) => string;
+/** A credit's expiry, for a row: when it lapses, or that it doesn't. */
+export declare const lapseSaid: (expires: string | undefined, now?: number) => string;
+/**
+ * Credits as they read: those of one kind that lapse alike are one pile, and
+ * the order they'll be spent in stays.
+ */
+export declare function pilesOf(buckets: Bucket[]): Bucket[];
+/** Newest first, however it came. */
+export declare const newestFirst: <T extends {
+    at: string;
+}>(rows: T[]) => T[];
+/**
+ * What a plan's terms give, in sentences' pieces, and for this many seats. A
+ * personal org is one person: its seat isn't worth saying.
+ */
+export declare function includes(terms: Pick<Terms, "credits">, seats?: number, personal?: boolean): string[];
+/** "1 seat", "3 seats". */
+export declare const seatsSaid: (n: number) => string;
+/**
+ * What a plan comes to, per seat and for the org's: what's asked before they
+ * go. A personal org's is just a month's price.
+ */
+export declare function priceFor(seat: Seat, seats: number | undefined, personal?: boolean): {
+    each?: string;
+    total: string;
+};
+/**
+ * This period's plan credits: what came, what's left of it, and the day they
+ * end (the period's end, when what's left lapses); none when none came.
+ */
+export declare function planCredits(s: Pick<BillingState, "period" | "history" | "buckets">): {
+    amount: number;
+    left: number;
+    until: string;
+} | undefined;
+/** What a plan's credits for this period come to, in words: "$4.20 of this month's credits, until Dec 3". */
+export declare function planCreditsSaid(c: {
+    amount: number;
+    left: number;
+    until: string;
+}, renews: boolean, now?: number): {
+    title: string;
+    more: string;
+};
+/** What it says the org is running low on. */
+export declare const lowOn: (s: BillingState) => "credits" | "budget" | undefined;
+/** How the month stands against its limit: the meter's fill, and fine, near or at it. */
+export declare function budgetStand(s: Pick<BillingState, "month" | "ok" | "why" | "low" | "buckets" | "balance" | "waived">): {
+    limit?: number;
+    spent: number;
+    left?: number;
+    share: number;
+    tone: "none" | "fine" | "near" | "at";
+};
+/** An amount as typed: "$1,000.50" is 1000.5. None for what isn't one. */
+export declare function amountOf(typed: string): number | undefined;
+/** Whether a typed top-up can be bought, and what to say if not. */
+export declare function topUpOf(typed: string, limits: Pick<Pay, "min" | "max">): {
+    amount: number;
+} | {
+    error: string;
+};
+/** What the org's balance comes to after adding this (any debt is paid first). */
+export declare const balanceAfter: (balance: number, adding: number) => number;
+/** What's kept on leaving for a payment page, to tell on coming back what's new. */
+export type Before = {
+    payments: string[];
+    plan?: string;
+    subscription?: string;
+};
+export declare const beforeOf: (s: BillingState) => Before;
+/**
+ * What landed, if it has, from a payment just made: words to thank them with,
+ * or none while it hasn't. Only what the state shows counts, never that they
+ * came back.
+ */
+export declare function landed(s: BillingState, paid: "credits" | "plan", before: Before | undefined, now?: number): string | undefined;
+/** What `?paid=` says was just paid, if anything we know. */
+export declare const paidIn: (search: string) => "credits" | "plan" | undefined;
+/** The address without `?paid=`, so reading it again doesn't confirm it again. */
+export declare function withoutPaid(search: string): string;
+/** Who to ask when nothing can be bought: the app's team, by the name the page's title ends with. */
+export declare function teamOf(title: string): string;
+/** A contract's id, from its title: "Acme & Co" is `acme-co`. */
+export declare const slug: (title: string) => string;
+/** A date field's day, as the moment it starts (UTC): when a waiver or a code ends. */
+export declare const startOfDay: (day: string) => string;
+/** The stop or low notice above the composer, in words (`billing.notice`'s answer). */
+export type Notice = {
+    tone: "stop" | "low";
+    why: "credits" | "budget";
+    left?: number;
+    runs: boolean;
+};
+/** Which low notice this is, so dismissing one says nothing of the other. */
+export declare const noticeKey: (n: Notice) => string;
+/** What the note above the composer says. */
+export declare function noticeSaid(n: Notice, personal?: boolean): {
+    title: string;
+    more?: string;
+};

package/credits/views/web/numbers.js

@@ -0,0 +1,291 @@
+/**
+ * Billing as the web says it: what `billing.state` answers, in words and
+ * numbers people read. Money to the cent, so a balance can be trusted; a day
+ * as the calendar has it, wherever you are (the backend's days are UTC);
+ * credits by what they are and in the order they're spent; what a plan
+ * includes and what it comes to for the org's seats; why the org is stopped
+ * or running low; how far along the month's budget is; an amount as typed; and
+ * whether what was just paid has landed. Only prices: never a cost or a fee.
+ */
+const MINUS = "−";
+const DAY = 86_400_000;
+/** Dollars to the cent: "$1,234.50", "$0.00"; "<$0.01" for crumbs; a minus sign below zero. */
+export function money(n) {
+    if (n < 0)
+        return `${MINUS}${money(-n)}`;
+    if (n > 0 && n < 0.005)
+        return "<$0.01";
+    return n.toLocaleString("en-US", { style: "currency", currency: "USD" });
+}
+/** Dollars, cents only when there are some: "$25", "$12.50", "$1,000". */
+export function dollars(n) {
+    if (n < 0)
+        return `${MINUS}${dollars(-n)}`;
+    const cents = Math.round(n * 100) % 100 !== 0;
+    return n.toLocaleString("en-US", {
+        style: "currency",
+        currency: "USD",
+        minimumFractionDigits: cents ? 2 : 0,
+        maximumFractionDigits: 2,
+    });
+}
+/** An amount in its currency: "$25", "R$ 100.50"; a code it doesn't know stands as it is. */
+export function inCurrency(n, currency) {
+    const code = currency.toUpperCase();
+    if (code === "USD")
+        return dollars(n);
+    const cents = Math.round(Math.abs(n) * 100) % 100 !== 0;
+    try {
+        return n.toLocaleString("en-US", {
+            style: "currency",
+            currency: code,
+            minimumFractionDigits: cents ? 2 : 0,
+            maximumFractionDigits: 2,
+        });
+    }
+    catch {
+        return `${n.toFixed(2)} ${code}`;
+    }
+}
+/** A day as the calendar has it ("Dec 1"; its year when it isn't this one), wherever you are. */
+export function dayShown(day, now = Date.now()) {
+    const date = new Date(`${day.slice(0, 10)}T00:00:00Z`);
+    if (Number.isNaN(date.getTime()))
+        return day;
+    const year = date.getUTCFullYear() !== new Date(now).getUTCFullYear();
+    return date.toLocaleDateString("en-US", {
+        timeZone: "UTC",
+        month: "short",
+        day: "numeric",
+        ...(year ? { year: "numeric" } : {}),
+    });
+}
+/** The day before: a period's last, since the backend's `end` is the first day after it. */
+export const dayBefore = (day) => new Date(Date.parse(`${day.slice(0, 10)}T00:00:00Z`) - DAY).toISOString().slice(0, 10);
+/** A period's dates, its last day included: "Nov 1 to Nov 30". */
+export const periodShown = (period, now = Date.now()) => `${dayShown(period.start, now)} to ${dayShown(dayBefore(period.end), now)}`;
+/** When something happened, where you are: "Nov 1", with its year when it isn't this one. */
+export function whenShown(at, now = Date.now()) {
+    const date = new Date(at);
+    if (Number.isNaN(date.getTime()))
+        return at;
+    const year = date.getFullYear() !== new Date(now).getFullYear();
+    return date.toLocaleDateString("en-US", {
+        month: "short",
+        day: "numeric",
+        ...(year ? { year: "numeric" } : {}),
+    });
+}
+const KINDS = {
+    trial: "Trial credits",
+    plan: "Plan credits",
+    gift: "Gift",
+    referral: "Referral",
+    purchase: "Purchased",
+    waived: "Usage given back",
+    adjustment: "Adjustment",
+};
+/** What a credit is, in words. */
+export const kindSaid = (kind) => KINDS[kind] ?? kind[0].toUpperCase() + kind.slice(1);
+const PURPOSES = {
+    seats: "Plan",
+    credits: "Credits",
+    contract: "Contract",
+    refund: "Refund",
+};
+/** What a payment was for, in words. */
+export const purposeSaid = (purpose) => PURPOSES[purpose] ?? purpose;
+/** A credit's expiry, for a row: when it lapses, or that it doesn't. */
+export const lapseSaid = (expires, now = Date.now()) => expires ? `Lapses ${dayShown(expires, now)}` : "Doesn't lapse";
+/**
+ * Credits as they read: those of one kind that lapse alike are one pile, and
+ * the order they'll be spent in stays.
+ */
+export function pilesOf(buckets) {
+    const piles = new Map();
+    for (const bucket of buckets) {
+        const key = `${bucket.kind}:${bucket.expires ?? ""}`;
+        const pile = piles.get(key);
+        if (pile) {
+            pile.left += bucket.left;
+            pile.amount += bucket.amount;
+        }
+        else
+            piles.set(key, { ...bucket });
+    }
+    return [...piles.values()];
+}
+/** Newest first, however it came. */
+export const newestFirst = (rows) => [...rows].sort((a, b) => b.at.localeCompare(a.at));
+/**
+ * What a plan's terms give, in sentences' pieces, and for this many seats. A
+ * personal org is one person: its seat isn't worth saying.
+ */
+export function includes(terms, seats, personal = false) {
+    const c = terms.credits ?? {};
+    const said = [];
+    if (c.once)
+        said.push(`${dollars(c.once)} of credits to start`);
+    if (c.monthly)
+        said.push(`${dollars(c.monthly)} of credits each month`);
+    if (c.perSeat && personal)
+        said.push(`${dollars(c.perSeat)} of credits each month`);
+    else if (c.perSeat) {
+        const all = seats && seats > 1 ? ` (${dollars(c.perSeat * seats)} for ${seats} seats)` : "";
+        said.push(`${dollars(c.perSeat)} of credits a seat each month${all}`);
+    }
+    return said;
+}
+/** "1 seat", "3 seats". */
+export const seatsSaid = (n) => `${n.toLocaleString("en-US")} seat${n === 1 ? "" : "s"}`;
+/**
+ * What a plan comes to, per seat and for the org's: what's asked before they
+ * go. A personal org's is just a month's price.
+ */
+export function priceFor(seat, seats, personal = false) {
+    if (personal)
+        return { total: `${inCurrency(seat.price, seat.currency)} a month` };
+    const count = Math.max(seats ?? 1, 1);
+    return {
+        each: `${inCurrency(seat.price, seat.currency)} a seat, each month`,
+        total: `${inCurrency(seat.price * count, seat.currency)} a month for ${seatsSaid(count)}`,
+    };
+}
+/**
+ * This period's plan credits: what came, what's left of it, and the day they
+ * end (the period's end, when what's left lapses); none when none came.
+ */
+export function planCredits(s) {
+    const until = s.period?.end;
+    if (!until)
+        return undefined;
+    const ours = (c) => c.kind === "plan" && c.expires === until;
+    const amount = (s.history ?? []).filter(ours).reduce((sum, c) => sum + c.amount, 0);
+    if (amount <= 0)
+        return undefined;
+    const left = (s.buckets ?? []).filter(ours).reduce((sum, b) => sum + b.left, 0);
+    return { amount, left: Math.min(Math.max(left, 0), amount), until };
+}
+/** What a plan's credits for this period come to, in words: "$4.20 of this month's credits, until Dec 3". */
+export function planCreditsSaid(c, renews, now = Date.now()) {
+    const day = dayShown(c.until, now);
+    if (c.left < 0.005) {
+        return {
+            title: `This month's ${dollars(c.amount)} of credits are used up`,
+            more: renews
+                ? `More come with the plan on ${day}. Until then, any other credits are used.`
+                : "Any other credits are used now.",
+        };
+    }
+    return {
+        title: `${money(c.left)} of this month's credits, until ${day}`,
+        more: `Of ${dollars(c.amount)}. What's left on ${day} doesn't carry over; credits you buy never lapse.`,
+    };
+}
+/** What it says the org is running low on. */
+export const lowOn = (s) => s.low ? s.lowOn ?? "credits" : undefined;
+/** How the month stands against its limit: the meter's fill, and fine, near or at it. */
+export function budgetStand(s) {
+    const spent = s.month?.spent ?? 0;
+    const limit = s.month?.limit;
+    if (limit === undefined)
+        return { spent, share: 0, tone: "none" };
+    const at = (s.ok === false && s.why === "budget") || spent >= limit;
+    const share = limit > 0 ? Math.min(spent / limit, 1) : 1;
+    const near = share >= 0.8 || lowOn({ on: true, runs: true, staff: false, ...s }) === "budget";
+    return {
+        limit,
+        spent,
+        left: Math.max(limit - spent, 0),
+        share: at ? 1 : share,
+        tone: at ? "at" : near ? "near" : "fine",
+    };
+}
+/** An amount as typed: "$1,000.50" is 1000.5. None for what isn't one. */
+export function amountOf(typed) {
+    const plain = typed.trim().replace(/^\$\s*/, "").replace(/,/g, "");
+    if (!/^(\d+(\.\d*)?|\.\d+)$/.test(plain))
+        return undefined;
+    return Math.round(Number(plain) * 100) / 100;
+}
+/** Whether a typed top-up can be bought, and what to say if not. */
+export function topUpOf(typed, limits) {
+    const range = `Between ${dollars(limits.min)} and ${dollars(limits.max)}.`;
+    const amount = amountOf(typed);
+    if (amount === undefined || amount < limits.min || amount > limits.max)
+        return { error: range };
+    return { amount };
+}
+/** What the org's balance comes to after adding this (any debt is paid first). */
+export const balanceAfter = (balance, adding) => balance + adding;
+export const beforeOf = (s) => ({
+    payments: (s.payments ?? []).map((p) => p._id),
+    ...(s.plan?.name ? { plan: s.plan.name } : {}),
+    ...(s.plan?.subscription ? { subscription: s.plan.subscription } : {}),
+});
+/** How long back a payment counts as this one, when nothing was kept on leaving (another tab). */
+const RECENT = 60 * 60_000;
+/**
+ * What landed, if it has, from a payment just made: words to thank them with,
+ * or none while it hasn't. Only what the state shows counts, never that they
+ * came back.
+ */
+export function landed(s, paid, before, now = Date.now()) {
+    if (paid === "plan") {
+        const plan = s.plan;
+        if (!plan?.subscription)
+            return undefined;
+        if (before && plan.subscription === before.subscription && plan.name === before.plan) {
+            return undefined;
+        }
+        return `You're on the ${plan.terms.title} plan.`;
+    }
+    const fresh = (s.payments ?? []).filter((p) => p.purpose === "credits" && p.amount > 0 &&
+        (before ? !before.payments.includes(p._id) : now - Date.parse(p.at) < RECENT));
+    if (!fresh.length)
+        return undefined;
+    const bought = fresh.reduce((sum, p) => sum + (p.credits ?? 0), 0);
+    return bought > 0 ? `${money(bought)} of credits added.` : "Your credits are in.";
+}
+/** What `?paid=` says was just paid, if anything we know. */
+export const paidIn = (search) => {
+    const paid = new URLSearchParams(search).get("paid");
+    return paid === "credits" || paid === "plan" ? paid : undefined;
+};
+/** The address without `?paid=`, so reading it again doesn't confirm it again. */
+export function withoutPaid(search) {
+    const params = new URLSearchParams(search);
+    params.delete("paid");
+    const rest = params.toString();
+    return rest ? `?${rest}` : "";
+}
+/** Who to ask when nothing can be bought: the app's team, by the name the page's title ends with. */
+export function teamOf(title) {
+    const app = title.split(" · ").pop()?.trim();
+    return app ? `the ${app} team` : "the team";
+}
+/** A contract's id, from its title: "Acme & Co" is `acme-co`. */
+export const slug = (title) => title.toLowerCase().normalize("NFKD").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+/** A date field's day, as the moment it starts (UTC): when a waiver or a code ends. */
+export const startOfDay = (day) => `${day}T00:00:00.000Z`;
+/** Which low notice this is, so dismissing one says nothing of the other. */
+export const noticeKey = (n) => `${n.tone}:${n.why}`;
+/** What the note above the composer says. */
+export function noticeSaid(n, personal = false) {
+    const org = personal ? "You're" : "This org is";
+    const has = personal ? "You've" : "This org has";
+    if (n.tone === "stop") {
+        return n.why === "budget"
+            ? {
+                title: `${has} reached the month's budget`,
+                ...(n.runs ? {} : { more: "Its owners and admins can raise it." }),
+            }
+            : {
+                title: `${org} out of credits`,
+                ...(n.runs ? {} : { more: "Its owners and admins can add more." }),
+            };
+    }
+    return n.why === "budget"
+        ? { title: `${money(n.left ?? 0)} left of this month's budget` }
+        : { title: `${money(n.left ?? 0)} of credits left` };
+}