@evinvest/kitstart 0.10.0 → 0.11.0

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-text.d.ts

@@ -41,7 +41,7 @@ export interface LeadCaptureText extends Partial<LeadCaptureFlowText> {
     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;
@@ -98,8 +98,32 @@ export interface LeadCaptureFlowText {
     bookSubmit: string;
     /** The in-card success of a priced lead; `{price}` the server's. */
     sentPrice: string;
-    /** After a priced lead: the slot is set by a call (no booking provider yet). */
+    /** 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;

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

@@ -8,6 +8,21 @@ const FR_FLOW = {
     bookSubmit: "Réserver",
     sentPrice: "Demande enregistrée au prix de {price}.",
     slotCallback: "Nous vous rappelons pour fixer le créneau.",
+    priceChanged: "Le prix a changé : {price} au lieu de {shown}. Confirmez pour envoyer votre demande à ce prix.",
+    priceChangedGeneric: "Le prix a changé depuis l’affichage de la page. Vérifiez le nouveau prix et confirmez.",
+    bookCta: "Choisir un créneau",
+    bookPhoneHint: "Indiquez le même numéro de téléphone en réservant : il relie le créneau à votre demande.",
+    bookNote: "Sinon, nous vous rappelons pour fixer le créneau.",
+    booked: "Créneau réservé. Merci !",
+    preferTitle: "Une préférence pour le créneau ? (facultatif)",
+    preferDay: "Jour",
+    preferPart: "Moment de la journée",
+    partMorning: "Matin",
+    partAfternoon: "Après-midi",
+    partEvening: "Soir",
+    preferSubmit: "Envoyer ma préférence",
+    preferSent: "Préférence notée : nous en tenons compte en vous rappelant.",
+    preferFailed: "Votre préférence n’a pas pu être envoyée. Nous vous rappelons quand même pour fixer le créneau.",
     photosTitle: "Envoyez des photos",
     photosLede: "Pour ce besoin, quelques photos nous permettent de vous donner un prix juste.",
     photosCta: "Envoyer des photos sur WhatsApp",
@@ -23,6 +38,21 @@ const EN_FLOW = {
     bookSubmit: "Book",
     sentPrice: "Request saved at {price}.",
     slotCallback: "We will call you to set the slot.",
+    priceChanged: "The price has changed: {price} instead of {shown}. Confirm to send your request at this price.",
+    priceChangedGeneric: "The price has changed since the page was shown. Check the new price and confirm.",
+    bookCta: "Pick a slot",
+    bookPhoneHint: "Enter the same phone number when you book: it links the slot to your request.",
+    bookNote: "Otherwise we will call you to set the slot.",
+    booked: "Slot booked. Thank you!",
+    preferTitle: "A preferred slot? (optional)",
+    preferDay: "Day",
+    preferPart: "Time of day",
+    partMorning: "Morning",
+    partAfternoon: "Afternoon",
+    partEvening: "Evening",
+    preferSubmit: "Send my preference",
+    preferSent: "Noted: we will keep it in mind when we call.",
+    preferFailed: "Your preference could not be sent. We will still call you to set the slot.",
     photosTitle: "Send photos",
     photosLede: "For this job, a few photos let us give you a fair price.",
     photosCta: "Send photos on WhatsApp",
@@ -45,7 +75,7 @@ const FR = {
     fieldInvalid: "Vérifiez ce champ.",
     formInvalid: "Votre demande n’a pas pu être envoyée. Vérifiez le formulaire.",
     sending: "Envoi…",
-    networkError: "Pas de connexion : votre demande n’est pas partie. Vérifiez le réseau et réessayez.",
+    networkError: "Pas de réponse du serveur. Vérifiez votre connexion et réessayez : votre demande ne sera pas envoyée deux fois.",
     timeoutError: "Le serveur ne répond pas. Réessayez : votre demande ne sera pas envoyée deux fois.",
     retry: "Réessayer",
     nameLabel: "Nom",
@@ -84,7 +114,7 @@ const EN = {
     fieldInvalid: "Check this field.",
     formInvalid: "Your request could not be sent. Check the form.",
     sending: "Sending…",
-    networkError: "No connection: your request was not sent. Check the network and try again.",
+    networkError: "No answer from the server. Check your connection and try again: your request will not be sent twice.",
     timeoutError: "The server is not answering. Try again: your request will not be sent twice.",
     retry: "Try again",
     nameLabel: "Name",

package/dist/core/lead.d.ts

@@ -109,6 +109,39 @@ export declare const SUBMISSION_FIELD = "submission_id";
 export declare const SUBMISSION_ID: RegExp;
 /** The query a refused submission is sent back to the form with: `?lead_error=<field>`. */
 export declare const LEAD_ERROR_PARAM = "lead_error";
+/** A refusal the server sent back: which of the card's forms, and the field it is about. */
+export interface LeadError {
+    channel: LeadChannel;
+    field: string;
+}
+/** What a refused field may be named: a slug, never markup. */
+export declare const LEAD_ERROR_FIELD: RegExp;
+/**
+ * The query naming where a refusal lands — the anchor the 303 points at,
+ * `<card>` or `<card>-callback` — because the fragment never reaches the
+ * server, and a page may draw more than one card.
+ */
+export declare const LEAD_CARD_PARAM = "lead_card";
+/** A refusal as a page reads it from its query: the card it is for, when the URL names one. */
+export interface PageLeadError extends LeadError {
+    card: string | null;
+}
+/**
+ * The refusal a 303 brought the visitor back with, read from a page's
+ * `searchParams` on the server — `LeadCapture`'s `initialError`, so the card
+ * says why without a script. Only a page that reads its query can: one built
+ * for ISR does not, and there the card's script says it. `card` is the anchor
+ * the route named (`lead_card`), which each card matches against its own id;
+ * a URL from before it was named leaves it `null`, and then the consent is
+ * the callback's and every other field the form's.
+ */
+export declare function leadErrorOf(searchParams: Readonly<Record<string, string | readonly string[] | undefined>>): PageLeadError | null;
+/**
+ * The refusal card `id` draws: one whose `card` is this card's form or its
+ * callback, there; one naming no card (an older URL), as it reads; one for
+ * another card, none.
+ */
+export declare function leadErrorFor(error: LeadError | PageLeadError | null, id: string): LeadError | null;
 /**
  * The card's id, posted so a refusal lands back on it (`#devis`, not a
  * hard-coded `#quote`). Only a slug is ever echoed into the redirect.

package/dist/core/lead.js

@@ -25,6 +25,49 @@ export const SUBMISSION_FIELD = "submission_id";
 export const SUBMISSION_ID = /^[A-Za-z0-9-]{16,64}$/;
 /** The query a refused submission is sent back to the form with: `?lead_error=<field>`. */
 export const LEAD_ERROR_PARAM = "lead_error";
+/** What a refused field may be named: a slug, never markup. */
+export const LEAD_ERROR_FIELD = /^[a-z][a-z0-9_]{0,31}$/;
+/**
+ * The query naming where a refusal lands — the anchor the 303 points at,
+ * `<card>` or `<card>-callback` — because the fragment never reaches the
+ * server, and a page may draw more than one card.
+ */
+export const LEAD_CARD_PARAM = "lead_card";
+const LEAD_CARD = /^[a-z0-9-]{1,80}$/;
+const first = (raw) => (typeof raw === "string" ? raw : raw?.[0]);
+/**
+ * The refusal a 303 brought the visitor back with, read from a page's
+ * `searchParams` on the server — `LeadCapture`'s `initialError`, so the card
+ * says why without a script. Only a page that reads its query can: one built
+ * for ISR does not, and there the card's script says it. `card` is the anchor
+ * the route named (`lead_card`), which each card matches against its own id;
+ * a URL from before it was named leaves it `null`, and then the consent is
+ * the callback's and every other field the form's.
+ */
+export function leadErrorOf(searchParams) {
+    const field = first(searchParams[LEAD_ERROR_PARAM]);
+    if (field === undefined || !LEAD_ERROR_FIELD.test(field))
+        return null;
+    const card = first(searchParams[LEAD_CARD_PARAM]);
+    return { channel: field === "consent" ? "callback" : "form", field, card: card !== undefined && LEAD_CARD.test(card) ? card : null };
+}
+/**
+ * The refusal card `id` draws: one whose `card` is this card's form or its
+ * callback, there; one naming no card (an older URL), as it reads; one for
+ * another card, none.
+ */
+export function leadErrorFor(error, id) {
+    if (!error)
+        return null;
+    const card = "card" in error ? error.card : null;
+    if (card === null)
+        return { channel: error.channel, field: error.field };
+    if (card === id)
+        return { channel: "form", field: error.field };
+    if (card === `${id}-callback`)
+        return { channel: "callback", field: error.field };
+    return null;
+}
 /**
  * The card's id, posted so a refusal lands back on it (`#devis`, not a
  * hard-coded `#quote`). Only a slug is ever echoed into the redirect.

package/dist/core/phone.d.ts

@@ -7,7 +7,9 @@
  * `0033 6 …`, a mobile typed without its trunk zero (`6 12 34 56 78`) — all
  * become `+33612345678`. Any other international number is a plausible E.164,
  * 8 to 15 digits after the `+`, compacted (`+44 7911 123456` →
- * `+447911123456`). Full-width digits read as digits; a run of one digit
+ * `+447911123456`) — and, for the plans a visitor here most often dials
+ * from (`NATIONAL_LENGTH`), as long as that plan's numbers are, so `+12345678`
+ * is not a number. Full-width digits read as digits; a run of one digit
  * (`00 00 00 00 00`, `06 66 66 66 66`) is a refusal to give a number, not one.
  */
 export declare function normalizePhone(raw: string): string | null;

package/dist/core/phone.js

@@ -1,3 +1,27 @@
+/**
+ * The national number's length, after the country code, for the plans the
+ * vertical's visitors most often come from — bounds wide enough for every
+ * real number (Germany and Italy vary by area), short of a library. A plan
+ * not listed keeps E.164's 8 to 15 digits in all.
+ */
+const NATIONAL_LENGTH = {
+    "1": [10, 10],
+    "32": [8, 9],
+    "34": [9, 9],
+    "39": [6, 11],
+    "41": [9, 9],
+    "44": [9, 10],
+    "49": [7, 13],
+};
+function fitsPlan(e164) {
+    const digits = e164.slice(1);
+    for (const code of [digits.slice(0, 1), digits.slice(0, 2)]) {
+        const bounds = NATIONAL_LENGTH[code];
+        if (bounds)
+            return digits.length - code.length >= bounds[0] && digits.length - code.length <= bounds[1];
+    }
+    return true;
+}
 /**
  * A phone number as the funnel reads it: E.164 when the typed value is a
  * number someone can be reached on, otherwise `null`.
@@ -7,7 +31,9 @@
  * `0033 6 …`, a mobile typed without its trunk zero (`6 12 34 56 78`) — all
  * become `+33612345678`. Any other international number is a plausible E.164,
  * 8 to 15 digits after the `+`, compacted (`+44 7911 123456` →
- * `+447911123456`). Full-width digits read as digits; a run of one digit
+ * `+447911123456`) — and, for the plans a visitor here most often dials
+ * from (`NATIONAL_LENGTH`), as long as that plan's numbers are, so `+12345678`
+ * is not a number. Full-width digits read as digits; a run of one digit
  * (`00 00 00 00 00`, `06 66 66 66 66`) is a refusal to give a number, not one.
  */
 export function normalizePhone(raw) {
@@ -27,7 +53,7 @@ export function normalizePhone(raw) {
             e164 = `+33${trunk[1]}`;
         else if (/^[1-9]\d{8}$/.test(s))
             e164 = `+33${s}`;
-        else if (/^\+[1-9]\d{7,14}$/.test(s))
+        else if (/^\+[1-9]\d{7,14}$/.test(s) && fitsPlan(s))
             e164 = s;
     }
     if (e164 === null)

package/dist/core/place/live.d.ts

@@ -1,3 +1,4 @@
+import type { BookingConfig, BookingRules } from "../booking/model.js";
 import type { Geo, OpeningHours, Place, PostalAddress, Rating, ServiceArea } from "./types.js";
 /**
  * The live half of a place, as `GET <source>/locations/<slug>` answers it.
@@ -16,12 +17,15 @@ export interface PlaceLive<L extends string> {
     serviceArea?: readonly ServiceArea[];
     hours?: readonly OpeningHours[];
     rating?: Rating;
+    /** Validated with the site's Cal.com hosts; one that does not validate is dropped, the baked one kept. */
+    booking?: BookingConfig;
 }
 /**
  * Drops what does not validate instead of failing the page on one bad field.
- * A landmark counts only when it is given in every one of `locales`.
+ * A landmark counts only when it is given in every one of `locales`; a
+ * `cal_com` booking only on one of `rules.calComHosts` (the site's).
  */
-export declare function parsePlaceLive<L extends string>(body: unknown, locales: readonly L[]): PlaceLive<L>;
+export declare function parsePlaceLive<L extends string>(body: unknown, locales: readonly L[], rules?: BookingRules): PlaceLive<L>;
 /**
  * The live fields over the baked ones. A service-area place takes none of the
  * storefront's: an address, a pin or a photo from the source would give it a

package/dist/core/place/live.js

@@ -1,3 +1,4 @@
+import { BookingConfigError, parseBookingConfig } from "../booking/validate.js";
 import { parseInstant } from "./rating.js";
 const DAYS = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"];
 const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
@@ -60,11 +61,24 @@ function landmark(v, locales) {
 function isComplete(record, locales) {
     return locales.every(locale => typeof record[locale] === "string");
 }
+function booking(v, rules) {
+    if (v === undefined || v === null)
+        return undefined;
+    try {
+        return parseBookingConfig(v, rules);
+    }
+    catch (error) {
+        if (error instanceof BookingConfigError)
+            return undefined;
+        throw error;
+    }
+}
 /**
  * Drops what does not validate instead of failing the page on one bad field.
- * A landmark counts only when it is given in every one of `locales`.
+ * A landmark counts only when it is given in every one of `locales`; a
+ * `cal_com` booking only on one of `rules.calComHosts` (the site's).
  */
-export function parsePlaceLive(body, locales) {
+export function parsePlaceLive(body, locales, rules = {}) {
     if (!isObject(body))
         throw new Error("live location: body is not an object");
     const live = {};
@@ -104,6 +118,9 @@ export function parsePlaceLive(body, locales) {
     const r = rating(body.rating);
     if (r)
         live.rating = r;
+    const b = booking(body.booking, rules);
+    if (b)
+        live.booking = b;
     return live;
 }
 /**
@@ -113,6 +130,7 @@ export function parsePlaceLive(body, locales) {
  */
 export function mergeLive(baked, live) {
     const front = baked.presence;
+    const booking = live.booking ?? baked.booking;
     return {
         ...baked,
         presence: front.kind === "storefront"
@@ -128,5 +146,6 @@ export function mergeLive(baked, live) {
         serviceArea: live.serviceArea ?? baked.serviceArea,
         hours: live.hours ?? baked.hours,
         rating: live.rating ?? baked.rating,
+        ...(booking ? { booking } : {}),
     };
 }

package/dist/core/place/types.d.ts

@@ -1,3 +1,4 @@
+import type { BookingConfig } from "../booking/model.js";
 /**
  * The place model. Three words, one each:
  *
@@ -79,6 +80,11 @@ export interface Place<L extends string> {
     hours: readonly OpeningHours[] | null;
     /** Live only. */
     rating: Rating | null;
+    /**
+     * How a priced lead's slot is set (`PlaceLive.booking`, the panel's place
+     * settings); absent → `DEFAULT_BOOKING`, a call (`bookingOf`).
+     */
+    booking?: BookingConfig;
 }
 /** The storefront half of a place, or `null` for a service-area business. */
 export declare function storefrontOf<L extends string>(place: Place<L>): Extract<Presence<L>, {

package/dist/core/place/types.js

@@ -1,16 +1,3 @@
-/**
- * The place model. Three words, one each:
- *
- * - **Place** — the aggregate: one point of the business, baked config merged
- *   with the live source;
- * - **Presence** — how the place exists for a visitor: a storefront with an
- *   address, or a service area with none;
- * - **ServiceArea** — where the van goes.
- *
- * A service-area business has no address *in the type*, so no builder can
- * render one for it by accident — schema.org, the map and the footer all have
- * to ask `presence.kind` first.
- */
 /** The storefront half of a place, or `null` for a service-area business. */
 export function storefrontOf(place) {
     return place.presence.kind === "storefront" ? place.presence : null;

package/dist/core/routing.d.ts

@@ -66,8 +66,9 @@ export declare function parseGoneHeader(value: string | null): {
 };
 /**
  * The routes every landing has outside `[locale]`, which pass untouched: the
- * form target, the OG card, the probe, the sitemap and robots. Anything else
- * without a language but `/_next/…` and the site's `publicFiles` is `gone`.
+ * form target, its booking request (`bookingRoute`) and its price
+ * confirmation (`confirmRoute`), the OG card, the probe, the sitemap and robots. Anything else without a language but
+ * `/_next/…` and the site's `publicFiles` is `gone`.
  */
 export declare const NON_PAGE_ROUTES: readonly string[];
 /** @deprecated The same list as {@link NON_PAGE_ROUTES}, under its old name. */

package/dist/core/routing.js

@@ -70,10 +70,11 @@ export function parseGoneHeader(value) {
 }
 /**
  * The routes every landing has outside `[locale]`, which pass untouched: the
- * form target, the OG card, the probe, the sitemap and robots. Anything else
- * without a language but `/_next/…` and the site's `publicFiles` is `gone`.
+ * form target, its booking request (`bookingRoute`) and its price
+ * confirmation (`confirmRoute`), the OG card, the probe, the sitemap and robots. Anything else without a language but
+ * `/_next/…` and the site's `publicFiles` is `gone`.
  */
-export const NON_PAGE_ROUTES = ["/quote", "/og", "/health", "/sitemap.xml", "/robots.txt"];
+export const NON_PAGE_ROUTES = ["/quote", "/quote/booking", "/quote/confirm", "/og", "/health", "/sitemap.xml", "/robots.txt"];
 /** @deprecated The same list as {@link NON_PAGE_ROUTES}, under its old name. */
 export const PASS_PATHS = NON_PAGE_ROUTES;
 function isInfrastructure(pathname, publicFiles) {