@evinvest/kitstart 0.9.0 → 0.11.0

package/dist/core/booking/model.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Booking, provider-agnostic: how a place's slot is set once a priced lead is
+ * stored. The vocabulary is the panel's (snake_case, closed sets) and the
+ * fixtures in `test/fixtures/booking/` are the contract it mirrors: a new
+ * provider extends the closed set with its own URL rule, and nothing else on
+ * either side changes.
+ */
+/**
+ * - `manual`: no external page — the site promises a call to set the slot, and
+ *   the operator records it in the panel. Always available; carries no URL.
+ * - `link`: any external booking page (strict https), opened with
+ *   `ref=<leadRef>` in its query.
+ * - `google_calendar`: a Google appointment schedule, opened as is — it takes
+ *   no parameter, so the panel matches its bookings by contact and time.
+ * - `cal_com`: a Cal.com event, opened with the name, the phone and
+ *   `metadata[ref]=<leadRef>` prefilled.
+ */
+export declare const BOOKING_PROVIDERS: readonly ["manual", "link", "google_calendar", "cal_com"];
+export type BookingProvider = (typeof BOOKING_PROVIDERS)[number];
+/** The providers with a page to open — every one but `manual`. */
+export type PageProvider = Exclude<BookingProvider, "manual">;
+/**
+ * A place's booking, as `PlaceLive.booking` serves it and the panel's place
+ * settings edit it: the providers it has a page on, and the one it offers by
+ * default — `manual` or one of them. An experiment (`booking_provider`) may
+ * pick another of the place's providers (`bookingOf`).
+ */
+export interface BookingConfig {
+    default: BookingProvider;
+    providers: Readonly<Partial<Record<PageProvider, {
+        url: string;
+    }>>>;
+}
+/** The booking one page offers: the provider chosen for this visitor, and its page. */
+export type BookingChoice = {
+    provider: "manual";
+} | {
+    provider: PageProvider;
+    url: string;
+};
+/**
+ * A choice a brand's own adapter makes sense of — what `LeadBooking` takes.
+ * Every `BookingChoice` is one; the closed set is what the place settings
+ * and `booking.requested@1` accept.
+ */
+export interface OpenBookingConfig {
+    provider: string;
+    url?: string;
+}
+/** A place with no booking of its own — baked or live — promises a call. */
+export declare const DEFAULT_BOOKING: BookingConfig;
+/** The experiment whose variant names the provider a visitor is offered, the same key on every brand. */
+export declare const BOOKING_EXPERIMENT = "booking_provider";
+/** A lead's booking, as the panel's projection tracks it; the site only ever says `requested`. */
+export declare const BOOKING_STATUSES: readonly ["none", "requested", "booked", "canceled", "done", "no_show"];
+export type BookingStatus = (typeof BOOKING_STATUSES)[number];
+/** The part of the day a visitor may prefer for a `manual` slot. */
+export declare const PREFERRED_PARTS: readonly ["morning", "afternoon", "evening"];
+export type PreferredPart = (typeof PREFERRED_PARTS)[number];
+/**
+ * The site's `booking.requested@1`: a lead asked for a slot. A provider with
+ * a page sends it when the page is opened; `manual` when the visitor sends
+ * the (optional) preference — which only `manual` carries.
+ */
+export interface BookingRequest {
+    /** The lead's public reference (`leadRef`) — the panel's lead id. */
+    leadRef: string;
+    provider: BookingProvider;
+    /** `YYYY-MM-DD`; `manual` only. */
+    preferredDate?: string;
+    /** `manual` only. */
+    preferredPart?: PreferredPart;
+}
+/** `booking.requested@1`'s properties as the panel reads them. */
+export interface BookingRequestedProperties {
+    lead_ref: string;
+    provider: BookingProvider;
+    preferred_date?: string;
+    preferred_part?: PreferredPart;
+}
+/** The Cal.com hosts a `cal_com` URL may point at unless the site names its own: ours, and the hosted cloud. */
+export declare const DEFAULT_CAL_COM_HOSTS: readonly string[];
+/** What a validator is told besides the value: the site's (or brand's) Cal.com hosts. */
+export interface BookingRules {
+    /** Exact hostnames, lowercase; a subdomain is another host. Default `DEFAULT_CAL_COM_HOSTS`. */
+    calComHosts?: readonly string[];
+}
+export declare const BOOKING_LIMITS: {
+    readonly maxUrl: 2048;
+    /** A Cal.com username or event slug: one path segment, no dot segment. */
+    readonly calComSegment: RegExp;
+};
+export declare function isLeadRef(value: unknown): value is string;
+export declare function isBookingProvider(value: unknown): value is BookingProvider;
+export declare function isPageProvider(value: unknown): value is PageProvider;
+export declare function isPreferredPart(value: unknown): value is PreferredPart;
+/**
+ * The one entry point for which booking a visitor is offered: the provider
+ * the experiment's variant (`booking_provider`) names, when the place has it
+ * (`manual` it always has), else the place's default. The chosen provider is
+ * what `booking.requested@1` and `lead_booking_open/done` report, so the arms
+ * compare.
+ */
+export declare function bookingOf(place: {
+    booking?: BookingConfig | undefined;
+}, variant?: string | null): BookingChoice;

package/dist/core/booking/model.js

@@ -0,0 +1,66 @@
+/**
+ * Booking, provider-agnostic: how a place's slot is set once a priced lead is
+ * stored. The vocabulary is the panel's (snake_case, closed sets) and the
+ * fixtures in `test/fixtures/booking/` are the contract it mirrors: a new
+ * provider extends the closed set with its own URL rule, and nothing else on
+ * either side changes.
+ */
+/**
+ * - `manual`: no external page — the site promises a call to set the slot, and
+ *   the operator records it in the panel. Always available; carries no URL.
+ * - `link`: any external booking page (strict https), opened with
+ *   `ref=<leadRef>` in its query.
+ * - `google_calendar`: a Google appointment schedule, opened as is — it takes
+ *   no parameter, so the panel matches its bookings by contact and time.
+ * - `cal_com`: a Cal.com event, opened with the name, the phone and
+ *   `metadata[ref]=<leadRef>` prefilled.
+ */
+export const BOOKING_PROVIDERS = ["manual", "link", "google_calendar", "cal_com"];
+/** A place with no booking of its own — baked or live — promises a call. */
+export const DEFAULT_BOOKING = { default: "manual", providers: {} };
+/** The experiment whose variant names the provider a visitor is offered, the same key on every brand. */
+export const BOOKING_EXPERIMENT = "booking_provider";
+/** A lead's booking, as the panel's projection tracks it; the site only ever says `requested`. */
+export const BOOKING_STATUSES = ["none", "requested", "booked", "canceled", "done", "no_show"];
+/** The part of the day a visitor may prefer for a `manual` slot. */
+export const PREFERRED_PARTS = ["morning", "afternoon", "evening"];
+/** The Cal.com hosts a `cal_com` URL may point at unless the site names its own: ours, and the hosted cloud. */
+export const DEFAULT_CAL_COM_HOSTS = ["cal.evinvest.ltd", "cal.com"];
+export const BOOKING_LIMITS = {
+    maxUrl: 2048,
+    /** A Cal.com username or event slug: one path segment, no dot segment. */
+    calComSegment: /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/,
+};
+/** `lead-<row>-<8 hex>`, as `leadRef` mints it. */
+const LEAD_REF = /^lead-[1-9]\d{0,14}-[0-9a-f]{8}$/;
+export function isLeadRef(value) {
+    return typeof value === "string" && LEAD_REF.test(value);
+}
+export function isBookingProvider(value) {
+    return BOOKING_PROVIDERS.some(p => p === value);
+}
+export function isPageProvider(value) {
+    return value !== "manual" && isBookingProvider(value);
+}
+export function isPreferredPart(value) {
+    return PREFERRED_PARTS.some(p => p === value);
+}
+/**
+ * The one entry point for which booking a visitor is offered: the provider
+ * the experiment's variant (`booking_provider`) names, when the place has it
+ * (`manual` it always has), else the place's default. The chosen provider is
+ * what `booking.requested@1` and `lead_booking_open/done` report, so the arms
+ * compare.
+ */
+export function bookingOf(place, variant) {
+    const booking = place.booking ?? DEFAULT_BOOKING;
+    const pick = (provider) => {
+        if (provider === "manual")
+            return { provider };
+        if (!isPageProvider(provider))
+            return null;
+        const page = booking.providers[provider];
+        return page ? { provider, url: page.url } : null;
+    };
+    return pick(variant) ?? pick(booking.default) ?? { provider: "manual" };
+}

package/dist/core/booking/url.d.ts

@@ -0,0 +1,17 @@
+import type { BookingChoice } from "./model.js";
+/** What the page knows of the lead when the visitor asks for a slot. */
+export interface BookingPrefill {
+    leadRef: string;
+    /** As typed; `cal_com` only. */
+    name?: string | null | undefined;
+    /** As typed; `cal_com` only, and only as a number `normalizePhone` reads (E.164). */
+    phone?: string | null | undefined;
+}
+/**
+ * The page a click opens, or `null` for `manual`. The lead's reference goes
+ * in the QUERY, never the fragment: `link` as `ref=<leadRef>` (and nothing
+ * else — an arbitrary host gets no personal data); `cal_com` as
+ * `metadata[ref]` with the name and the phone. `google_calendar` takes no
+ * parameter: its URL as is, and the panel matches by contact and time.
+ */
+export declare function bookingHref(choice: BookingChoice, prefill: BookingPrefill): string | null;

package/dist/core/booking/url.js

@@ -0,0 +1,53 @@
+import { normalizePhone } from "../phone.js";
+function keyOf(pair) {
+    const key = pair.split("=", 1)[0] ?? "";
+    try {
+        return decodeURIComponent(key.replaceAll("+", " "));
+    }
+    catch {
+        return key;
+    }
+}
+/**
+ * `url` with `pairs` in its query, each replacing any pair of the same key
+ * the URL already had; the rest of the query is kept byte for byte. Keys go
+ * as written (`metadata[ref]`, as Cal.com documents it), values encoded.
+ */
+function withQuery(url, pairs) {
+    const u = new URL(url);
+    const keys = new Set(pairs.map(([k]) => k));
+    const kept = u.search
+        .slice(1)
+        .split("&")
+        .filter(p => p !== "" && !keys.has(keyOf(p)));
+    u.search = [...kept, ...pairs.map(([k, v]) => `${k}=${encodeURIComponent(v)}`)].join("&");
+    return u.toString();
+}
+/**
+ * The page a click opens, or `null` for `manual`. The lead's reference goes
+ * in the QUERY, never the fragment: `link` as `ref=<leadRef>` (and nothing
+ * else — an arbitrary host gets no personal data); `cal_com` as
+ * `metadata[ref]` with the name and the phone. `google_calendar` takes no
+ * parameter: its URL as is, and the panel matches by contact and time.
+ */
+export function bookingHref(choice, prefill) {
+    const name = prefill.name?.trim();
+    const phone = prefill.phone ? normalizePhone(prefill.phone) : null;
+    switch (choice.provider) {
+        case "manual":
+            return null;
+        case "link":
+            return withQuery(choice.url, [["ref", prefill.leadRef]]);
+        case "google_calendar":
+            return choice.url;
+        case "cal_com": {
+            const pairs = [];
+            if (name)
+                pairs.push(["name", name]);
+            if (phone)
+                pairs.push(["attendeePhoneNumber", phone]);
+            pairs.push(["metadata[ref]", prefill.leadRef]);
+            return withQuery(choice.url, pairs);
+        }
+    }
+}

package/dist/core/booking/validate.d.ts

@@ -0,0 +1,27 @@
+import { type BookingConfig, type BookingRequest, type BookingRequestedProperties, type BookingRules } from "./model.js";
+/** A booking config that does not validate, with every reason found. */
+export declare class BookingConfigError extends Error {
+    readonly problems: readonly string[];
+    readonly name = "BookingConfigError";
+    constructor(problems: readonly string[]);
+}
+/**
+ * Every reason `value` is not a place's booking, or none. Unknown fields are
+ * refused, not ignored — `manual` has no page entry — so the site and the
+ * panel never disagree on what a config says.
+ */
+export declare function bookingConfigProblems(value: unknown, rules?: BookingRules): string[];
+/** The config `value` is, rebuilt from what was checked; throws `BookingConfigError` with every problem. */
+export declare function parseBookingConfig(value: unknown, rules?: BookingRules): BookingConfig;
+/** Every reason a host list is not one a site may allow Cal.com on. */
+export declare function calComHostsProblems(hosts: readonly string[]): string[];
+/**
+ * Every reason `value` is not `booking.requested@1`'s properties, or none:
+ * a `lead_ref`, a provider of the closed set and, with `manual` only, an
+ * optional day and part of the day. No free text — nothing a person typed.
+ */
+export declare function bookingRequestProblems(value: unknown): string[];
+/** The request `value` is; throws `BookingConfigError` with every problem. */
+export declare function parseBookingRequest(value: unknown): BookingRequest;
+/** A request as `booking.requested@1`'s properties: snake_case, absent fields left out. */
+export declare function bookingRequestedProperties(request: BookingRequest): BookingRequestedProperties;

package/dist/core/booking/validate.js

@@ -0,0 +1,219 @@
+import { BOOKING_LIMITS as LIMIT, DEFAULT_CAL_COM_HOSTS, isBookingProvider, isLeadRef, isPageProvider, isPreferredPart, } from "./model.js";
+/** A booking config that does not validate, with every reason found. */
+export class BookingConfigError extends Error {
+    problems;
+    name = "BookingConfigError";
+    constructor(problems) {
+        super(`booking: ${problems.join("; ")}`);
+        this.problems = problems;
+    }
+}
+const isObject = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function unknownKeys(path, v, allowed) {
+    return Object.keys(v)
+        .filter(key => !allowed.includes(key))
+        .map(key => `${path}.${key}: unknown field`);
+}
+// Printable ASCII only: the URL parser would quietly drop a tab or a line
+// break and re-encode the rest, so what was checked would not be what opens.
+const PRINTABLE_ASCII = /^[\x21-\x7e]+$/;
+const LABEL = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?$/;
+// A last label that is a number (or `0x…`) makes the WHATWG parser read the
+// host as an IPv4 address: `https://0x7f000001/` is 127.0.0.1.
+const NUMERIC_LABEL = /^(?:\d+|0x[0-9a-f]*)$/i;
+/**
+ * Every reason `value` is not a booking URL. The rules are the panel's too
+ * (`test/fixtures/booking/README.md`): a literal lowercase `https://`, a
+ * dotted DNS name for a host — no userinfo, no port, no IP literal — no
+ * fragment, printable ASCII, at most 2048 characters.
+ */
+function urlProblems(path, value) {
+    const fail = (why) => ({ problems: [`${path}: ${why}`], url: null, rawPath: "" });
+    if (typeof value !== "string")
+        return fail("a URL string");
+    if (value.length > LIMIT.maxUrl)
+        return fail(`at most ${LIMIT.maxUrl} characters`);
+    if (!PRINTABLE_ASCII.test(value))
+        return fail("printable ASCII only, no spaces or control characters");
+    if (!value.startsWith("https://"))
+        return fail('must start with "https://"');
+    if (value.includes("#"))
+        return fail("no fragment");
+    if (value.includes("\\"))
+        return fail("no backslash");
+    const rest = value.slice("https://".length);
+    const end = rest.search(/[/?]/);
+    const authority = end === -1 ? rest : rest.slice(0, end);
+    if (authority.includes("@"))
+        return fail("no userinfo");
+    if (authority.includes(":") || authority.startsWith("["))
+        return fail("no port and no IP literal");
+    const labels = authority.split(".");
+    if (labels.length < 2 || authority.length > 253 || !labels.every(l => LABEL.test(l)))
+        return fail("the host must be a dotted DNS name");
+    if (NUMERIC_LABEL.test(labels[labels.length - 1] ?? ""))
+        return fail("the host must not be an IP literal");
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return fail("not a URL");
+    }
+    const query = rest.indexOf("?");
+    const rawPath = end === -1 ? "" : rest.slice(end, query === -1 ? undefined : query);
+    return { problems: [], url, rawPath };
+}
+function calComProblems(path, url, rawPath, rules) {
+    const hosts = rules.calComHosts ?? DEFAULT_CAL_COM_HOSTS;
+    const out = [];
+    if (!hosts.includes(url.hostname))
+        out.push(`${path}: the host must be one of ${hosts.join(", ")}`);
+    const segments = rawPath.split("/").slice(1);
+    if (!rawPath.startsWith("/") || segments.length !== 2 || !segments.every(s => LIMIT.calComSegment.test(s))) {
+        out.push(`${path}: the path must be /<user>/<event>`);
+    }
+    return out;
+}
+/** A non-empty path: a page on the host, not the host's home. */
+const hasPath = (rawPath) => rawPath !== "" && rawPath !== "/";
+const GOOGLE_SHORT = "calendar.app.google";
+const GOOGLE_LONG = "calendar.google.com";
+const GOOGLE_PATH = "/calendar/appointments/";
+/** The provider's own rule over the URL rule every provider shares. */
+function providerProblems(path, provider, url, rawPath, rules) {
+    switch (provider) {
+        case "link":
+            return [];
+        case "google_calendar":
+            if (url.hostname === GOOGLE_SHORT)
+                return hasPath(rawPath) ? [] : [`${path}: the path must name a schedule`];
+            if (url.hostname === GOOGLE_LONG)
+                return rawPath.startsWith(GOOGLE_PATH) && rawPath.length > GOOGLE_PATH.length ? [] : [`${path}: the path must be ${GOOGLE_PATH}…`];
+            return [`${path}: the host must be ${GOOGLE_SHORT} or ${GOOGLE_LONG}`];
+        case "cal_com":
+            return calComProblems(path, url, rawPath, rules);
+    }
+}
+function check(value, rules) {
+    if (!isObject(value))
+        return { problems: ["booking: an object"], config: null };
+    const problems = unknownKeys("booking", value, ["default", "providers"]);
+    const providers = {};
+    if (!isObject(value.providers))
+        problems.push("booking.providers: an object by provider");
+    else {
+        for (const [name, page] of Object.entries(value.providers)) {
+            const path = `booking.providers.${name}`;
+            if (name === "manual") {
+                problems.push(`${path}: manual has no page — it is always available`);
+                continue;
+            }
+            if (!isPageProvider(name)) {
+                problems.push(`${path}: not a provider (link, google_calendar, cal_com)`);
+                continue;
+            }
+            if (!isObject(page)) {
+                problems.push(`${path}: an object, { url }`);
+                continue;
+            }
+            problems.push(...unknownKeys(path, page, ["url"]));
+            if (!Object.hasOwn(page, "url")) {
+                problems.push(`${path}.url: missing`);
+                continue;
+            }
+            const parsed = urlProblems(`${path}.url`, page.url);
+            problems.push(...parsed.problems);
+            if (parsed.url)
+                problems.push(...providerProblems(`${path}.url`, name, parsed.url, parsed.rawPath, rules));
+            if (typeof page.url === "string")
+                providers[name] = { url: page.url };
+        }
+    }
+    const fallback = value.default;
+    if (!isBookingProvider(fallback))
+        problems.push("booking.default: one of manual, link, google_calendar, cal_com");
+    else if (fallback !== "manual" && !Object.hasOwn(providers, fallback))
+        problems.push(`booking.default: "${fallback}" is not one of the providers`);
+    if (problems.length > 0 || !isBookingProvider(fallback))
+        return { problems, config: null };
+    return { problems: [], config: { default: fallback, providers } };
+}
+/**
+ * Every reason `value` is not a place's booking, or none. Unknown fields are
+ * refused, not ignored — `manual` has no page entry — so the site and the
+ * panel never disagree on what a config says.
+ */
+export function bookingConfigProblems(value, rules = {}) {
+    return check(value, rules).problems;
+}
+/** The config `value` is, rebuilt from what was checked; throws `BookingConfigError` with every problem. */
+export function parseBookingConfig(value, rules = {}) {
+    const { problems, config } = check(value, rules);
+    if (!config)
+        throw new BookingConfigError(problems);
+    return config;
+}
+/** Every reason a host list is not one a site may allow Cal.com on. */
+export function calComHostsProblems(hosts) {
+    return hosts.flatMap((host, i) => {
+        const labels = host.split(".");
+        const dns = host === host.toLowerCase() && labels.length >= 2 && labels.every(l => LABEL.test(l)) && !NUMERIC_LABEL.test(labels[labels.length - 1] ?? "");
+        return dns ? [] : [`calComHosts[${i}]: a lowercase dotted DNS name, not ${JSON.stringify(host)}`];
+    });
+}
+/** `YYYY-MM-DD`, and a day the calendar has. */
+function isDay(v) {
+    if (typeof v !== "string" || !/^\d{4}-\d{2}-\d{2}$/.test(v))
+        return false;
+    const day = new Date(`${v}T00:00:00Z`);
+    return !Number.isNaN(day.getTime()) && day.toISOString().slice(0, 10) === v;
+}
+function checkRequest(value) {
+    if (!isObject(value))
+        return { problems: ["booking.requested: an object"], request: null };
+    const problems = unknownKeys("booking.requested", value, ["lead_ref", "provider", "preferred_date", "preferred_part"]);
+    const { lead_ref: leadRef, provider, preferred_date: date, preferred_part: part } = value;
+    if (!isLeadRef(leadRef))
+        problems.push("booking.requested.lead_ref: lead-<row>-<8 hex>");
+    if (!isBookingProvider(provider))
+        problems.push("booking.requested.provider: one of manual, link, google_calendar, cal_com");
+    if (date !== undefined && !isDay(date))
+        problems.push("booking.requested.preferred_date: a date, YYYY-MM-DD");
+    if (part !== undefined && !isPreferredPart(part))
+        problems.push("booking.requested.preferred_part: morning, afternoon or evening");
+    if ((date !== undefined || part !== undefined) && provider !== "manual")
+        problems.push("booking.requested: a preference only with manual");
+    if (problems.length > 0 || !isLeadRef(leadRef) || !isBookingProvider(provider))
+        return { problems, request: null };
+    const request = { leadRef, provider };
+    if (typeof date === "string")
+        request.preferredDate = date;
+    if (isPreferredPart(part))
+        request.preferredPart = part;
+    return { problems: [], request };
+}
+/**
+ * Every reason `value` is not `booking.requested@1`'s properties, or none:
+ * a `lead_ref`, a provider of the closed set and, with `manual` only, an
+ * optional day and part of the day. No free text — nothing a person typed.
+ */
+export function bookingRequestProblems(value) {
+    return checkRequest(value).problems;
+}
+/** The request `value` is; throws `BookingConfigError` with every problem. */
+export function parseBookingRequest(value) {
+    const { problems, request } = checkRequest(value);
+    if (!request)
+        throw new BookingConfigError(problems);
+    return request;
+}
+/** A request as `booking.requested@1`'s properties: snake_case, absent fields left out. */
+export function bookingRequestedProperties(request) {
+    return {
+        lead_ref: request.leadRef,
+        provider: request.provider,
+        ...(request.preferredDate !== undefined ? { preferred_date: request.preferredDate } : {}),
+        ...(request.preferredPart !== undefined ? { preferred_part: request.preferredPart } : {}),
+    };
+}

package/dist/core/lead-capture-format.d.ts

@@ -4,3 +4,9 @@ import type { Opening } from "./place/hours.js";
 export declare function fillText(template: string, values: Readonly<Record<string, string>>): string;
 /** The promise of the next opening, from real hours — or `null`, never an invented one. */
 export declare function openingText(opening: Opening | null, text: Pick<LeadCaptureText, "openingToday" | "openingTomorrow" | "openingLater">, locale: string): string | null;
+/**
+ * Cents as the page's language writes euros: `84 €`, `84,50 €`, `€84.50`.
+ * Whole euros drop the cents a rounded price never has; a signed line of a
+ * breakdown is `+8,50 €` / `−9,35 €`.
+ */
+export declare function formatCents(cents: number, locale: string, signed?: boolean): string;

package/dist/core/lead-capture-format.js

@@ -30,3 +30,16 @@ export function openingText(opening, text, locale) {
         return fillText(text.openingTomorrow, { time });
     return fillText(text.openingLater, { time, day: weekdayText(opening.day, locale) });
 }
+/**
+ * Cents as the page's language writes euros: `84 €`, `84,50 €`, `€84.50`.
+ * Whole euros drop the cents a rounded price never has; a signed line of a
+ * breakdown is `+8,50 €` / `−9,35 €`.
+ */
+export function formatCents(cents, locale, signed = false) {
+    const digits = cents % 100 === 0 ? 0 : 2;
+    const format = new Intl.NumberFormat(locale, { style: "currency", currency: "EUR", minimumFractionDigits: digits, maximumFractionDigits: digits });
+    const text = format.format(Math.abs(cents) / 100);
+    if (!signed)
+        return cents < 0 ? `−${text}` : text;
+    return `${cents < 0 ? "−" : "+"}${text}`;
+}

package/dist/core/lead-capture-text.d.ts

@@ -7,8 +7,12 @@
  * The kit ships French and English (`LEAD_CAPTURE_TEXT`) so every brand asks
  * in the same words and an experiment's arms differ only in what it tests; a
  * brand overrides a key by spreading: `{ ...LEAD_CAPTURE_TEXT.fr, submit: "…" }`.
+ *
+ * The flows' words (`LeadCaptureFlowText`) are optional here so a brand's own
+ * text object written before them still type-checks; a key left out falls
+ * back to the kit's, in the page's language (`flowTextOf`).
  */
-export interface LeadCaptureText {
+export interface LeadCaptureText extends Partial<LeadCaptureFlowText> {
     title: string;
     lede: string;
     needLabel: string;
@@ -37,7 +41,7 @@ export interface LeadCaptureText {
     formInvalid: string;
     /** On the submit while the script posts the form. */
     sending: string;
-    /** The post never reached the server: nothing was sent, the form is as typed. */
+    /** The post got no answer — the lead may be stored already: a retry cannot make a second one. */
     networkError: string;
     /** No answer in time: it may have arrived — a retry cannot make a second lead. */
     timeoutError: string;
@@ -78,4 +82,55 @@ export interface LeadCaptureText {
     /** The honeypot's label — read only by a bot filling every field. */
     honeypotLabel: string;
 }
+/** What the `estimate` and `fixed` flows, the photos ask and the booking print. */
+export interface LeadCaptureFlowText {
+    /** Heads the live price. */
+    priceTitle: string;
+    /** In place of the price until every input is answered. */
+    pricePending: string;
+    /** Under the price: what it includes and when it is paid. */
+    priceNote: string;
+    /** The breakdown's first line: the need's base. */
+    priceBase: string;
+    priceRounding: string;
+    priceMinimum: string;
+    /** The submit of a priced need. */
+    bookSubmit: string;
+    /** The in-card success of a priced lead; `{price}` the server's. */
+    sentPrice: string;
+    /** After a priced lead with a `manual` booking: the slot is set by a call. */
+    slotCallback: string;
+    /** The price changed under the form: `{price}` the fresh one, `{shown}` the one shown; the submit confirms it. */
+    priceChanged: string;
+    /** The same, without a script — the page shows the fresh price for the answers given again. */
+    priceChangedGeneric: string;
+    /** Opens the place's booking page (`link`, `cal_com`). */
+    bookCta: string;
+    /** Under it, for a provider the number cannot be handed to (Google): type the same one there. */
+    bookPhoneHint: string;
+    /** Under it: the call still comes if the visitor books nothing. */
+    bookNote: string;
+    /** Once the provider says the slot is booked. */
+    booked: string;
+    /** `manual`: the optional preference, its day and part of the day. */
+    preferTitle: string;
+    preferDay: string;
+    preferPart: string;
+    partMorning: string;
+    partAfternoon: string;
+    partEvening: string;
+    preferSubmit: string;
+    /** After the preference is sent. */
+    preferSent: string;
+    /** The preference did not reach the site; the call is still coming. */
+    preferFailed: string;
+    /** A `quote` need that is priced from photos: the ask, and its WhatsApp link. */
+    photosTitle: string;
+    photosLede: string;
+    photosCta: string;
+    /** The WhatsApp message, `{need}` the need's label. */
+    photosMessage: string;
+}
 export declare const LEAD_CAPTURE_TEXT: Readonly<Record<"fr" | "en", LeadCaptureText>>;
+/** The flows' words for a page: the brand's, else the kit's in its language (English for `en*`, French otherwise). */
+export declare function flowTextOf(text: LeadCaptureText, locale: string): LeadCaptureFlowText;