@evinvest/sites-contract 0.0.0-stage → 0.1.1

package/dist/phone.js

@@ -0,0 +1,76 @@
+/**
+ * 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`.
+ *
+ * Only the French national plan is read closely (every brand of the vertical
+ * is in France): ten digits from `0[1-9]` — `06 12 34 56 78`, `+33 (0)6 …`,
+ * `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`) — 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) {
+    // A Japanese or Chinese keyboard types full-width digits and `＋`, and a
+    // pasted number may carry no-break spaces.
+    const folded = raw.replace(/[\uff10-\uff19\uff0b]/g, c => (c === "\uff0b" ? "+" : String(c.charCodeAt(0) - 0xff10))).replace(/\p{White_Space}/gu, " ");
+    let s = folded.replace(/\(0\)/g, "").replace(/[ .\-()/]/g, "");
+    if (s.startsWith("00"))
+        s = `+${s.slice(2)}`;
+    let e164 = null;
+    if (s.startsWith("+33")) {
+        const national = /^\+330?([1-9]\d{8})$/.exec(s);
+        e164 = national ? `+33${national[1]}` : null;
+    }
+    else {
+        const trunk = /^0([1-9]\d{8})$/.exec(s);
+        if (trunk)
+            e164 = `+33${trunk[1]}`;
+        else if (/^[1-9]\d{8}$/.test(s))
+            e164 = `+33${s}`;
+        else if (/^\+[1-9]\d{7,14}$/.test(s) && fitsPlan(s))
+            e164 = s;
+    }
+    if (e164 === null)
+        return null;
+    // The subscriber's digits: past `+33` for a French number, past `+` otherwise.
+    const subscriber = e164.startsWith("+33") ? e164.slice(3) : e164.slice(1);
+    return /^(\d)\1+$/.test(subscriber) ? null : e164;
+}
+/**
+ * What is wrong with a typed number, or `null`: `required` when nothing was
+ * typed, `invalid` when it is not a number we can call. The form blocks on it
+ * in the page's words and the server refuses on it — one rule, so a number
+ * the form lets through is never refused behind the visitor's back.
+ */
+export function phoneProblem(raw) {
+    if (raw.trim() === "")
+        return "required";
+    return normalizePhone(raw) === null ? "invalid" : null;
+}

package/dist/place.d.ts

@@ -0,0 +1,23 @@
+import type { BookingCode, PlaceCode } from "./generated/codes.js";
+import type { PlaceLive } from "./generated/types.js";
+/** One thing wrong with a place's settings: its path (`phone`, `hours[0].opens`, `booking.providers.cal_com.url`) and why. */
+export interface PlaceProblem {
+    path: string;
+    code: PlaceCode | BookingCode;
+}
+/**
+ * An RFC 3339 instant: `YYYY-MM-DDTHH:MM:SS`, an optional fraction of 1 to 9 digits, and `Z`
+ * or `±HH:MM` — on a day the calendar has, at a time the clock has (no leap second), at an
+ * offset of less than a day.
+ */
+export declare function isInstant(s: string): boolean;
+/**
+ * A place's live settings checked field by field (`contracts/vectors/place.json`): the fields
+ * that pass, and every problem of those that do not. The panel refuses settings with any
+ * problem; a site keeps what passed and serves its baked config for the rest. A field set to
+ * `null` is left out, as if absent.
+ */
+export declare function checkPlaceLive(body: unknown): {
+    live: PlaceLive;
+    problems: PlaceProblem[];
+};

package/dist/place.js

@@ -0,0 +1,280 @@
+import { checkBookingConfig } from "./booking.js";
+import { DAYS, MESSENGERS, PLACE_LIMITS as LIMIT } from "./generated/place.js";
+import { at, charCount, hasControl, hasWhitespace, isDate, isObject, trim } from "./text.js";
+const E164 = new RegExp(LIMIT.e164);
+const TELEGRAM_BOT = new RegExp(LIMIT.telegramBot);
+const TIME = new RegExp(LIMIT.time);
+class Check {
+    problems = [];
+    fail(path, code) {
+        this.problems.push({ path, code });
+    }
+    /** `f`'s value when it added no problem. */
+    clean(f) {
+        const before = this.problems.length;
+        const out = f();
+        return this.problems.length === before ? out : undefined;
+    }
+    /** A line of text, trimmed: not blank, at most `max` characters, no control characters. */
+    text(path, v, max) {
+        if (typeof v !== "string") {
+            this.fail(path, "type");
+            return "";
+        }
+        const s = trim(v);
+        if (s === "")
+            this.fail(path, "blank");
+        else if (charCount(s) > max)
+            this.fail(path, "too_long");
+        else if (hasControl(s))
+            this.fail(path, "control");
+        return s;
+    }
+    /** A text whose only fault is a `code` of its own: trimmed, and held to `ok`. */
+    word(path, v, max, code, ok) {
+        const s = typeof v === "string" ? trim(v) : "";
+        if (s === "" || charCount(s) > max || hasControl(s) || !ok(s))
+            this.fail(path, code);
+        return s;
+    }
+    /** An object with exactly `keys`; every other key and every missing one named. */
+    object(path, v, keys) {
+        if (!isObject(v)) {
+            this.fail(path, "shape");
+            return null;
+        }
+        const before = this.problems.length;
+        for (const k of Object.keys(v))
+            if (!keys.includes(k))
+                this.fail(at(path, k), "unknown_field");
+        for (const k of keys)
+            if (!Object.hasOwn(v, k))
+                this.fail(at(path, k), "required");
+        return this.problems.length === before ? v : null;
+    }
+    /** A list of 1 to `max` entries. */
+    list(path, v, max) {
+        if (!Array.isArray(v))
+            this.fail(path, "shape");
+        else if (v.length === 0)
+            this.fail(path, "empty");
+        else if (v.length > max)
+            this.fail(path, "too_many");
+        else
+            return v;
+        return [];
+    }
+}
+/** The host of an absolute `https://` URL without userinfo or whitespace, lowercase. */
+function httpsHost(s) {
+    if (!s.startsWith("https://"))
+        return null;
+    const authority = s.slice("https://".length).split(/[/?#]/, 1)[0] ?? "";
+    const ok = authority !== "" && !authority.startsWith(":") && !authority.startsWith(".") && !authority.includes("@") && !hasWhitespace(s);
+    return ok ? authority.toLowerCase() : null;
+}
+/**
+ * An RFC 3339 instant: `YYYY-MM-DDTHH:MM:SS`, an optional fraction of 1 to 9 digits, and `Z`
+ * or `±HH:MM` — on a day the calendar has, at a time the clock has (no leap second), at an
+ * offset of less than a day.
+ */
+export function isInstant(s) {
+    const m = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):(\d{2})(?:\.\d{1,9})?(?:Z|[+-](\d{2}):(\d{2}))$/.exec(s);
+    if (!m || !isDate(m[1]))
+        return false;
+    const [hour, minute, second, offsetHours, offsetMinutes] = m.slice(2).map(n => (n === undefined ? 0 : Number(n)));
+    return hour <= 23 && minute <= 59 && second <= 59 && offsetHours <= 23 && offsetMinutes <= 59;
+}
+const isDay = (v) => DAYS.some(d => d === v);
+const isMessenger = (v) => MESSENGERS.some(m => m === v);
+function hours(c, path, v) {
+    const out = [];
+    for (const [i, row] of c.list(path, v, LIMIT.maxHours).entries()) {
+        const there = at(path, i);
+        const m = c.object(there, row, ["days", "opens", "closes"]);
+        if (!m)
+            continue;
+        const days = c.clean(() => {
+            const seen = [];
+            for (const [j, d] of c.list(at(there, "days"), m.days, DAYS.length).entries()) {
+                if (!isDay(d))
+                    c.fail(at(at(there, "days"), j), "day");
+                else if (seen.includes(d))
+                    c.fail(at(at(there, "days"), j), "duplicate");
+                else
+                    seen.push(d);
+            }
+            return DAYS.filter(d => seen.includes(d));
+        });
+        const time = (key) => c.clean(() => {
+            const t = m[key];
+            if (typeof t === "string" && TIME.test(t))
+                return t;
+            c.fail(at(there, key), "time");
+            return "";
+        });
+        const opens = time("opens");
+        const closes = time("closes");
+        if (days === undefined || opens === undefined || closes === undefined)
+            continue;
+        // HH:MM sorts as the time it names.
+        if (closes <= opens)
+            c.fail(at(there, "closes"), "closes_before_opens");
+        else
+            out.push({ days, opens, closes });
+    }
+    return out;
+}
+function serviceArea(c, path, v) {
+    const out = [];
+    for (const [i, n] of c.list(path, v, LIMIT.maxArea).entries()) {
+        const name = c.clean(() => c.text(at(path, i), n, LIMIT.maxText));
+        if (name === undefined)
+            continue;
+        if (out.some(o => o.toLowerCase() === name.toLowerCase()))
+            c.fail(at(path, i), "duplicate");
+        else
+            out.push(name);
+    }
+    return out;
+}
+function address(c, path, v) {
+    const m = c.object(path, v, ["street", "postalCode", "locality"]);
+    if (!m)
+        return null;
+    return {
+        street: c.text(at(path, "street"), m.street, LIMIT.maxText),
+        postalCode: c.word(at(path, "postalCode"), m.postalCode, 5, "postal_code", p => /^\d{5}$/.test(p)),
+        locality: c.text(at(path, "locality"), m.locality, LIMIT.maxText),
+    };
+}
+function geo(c, path, v) {
+    const m = c.object(path, v, ["lat", "lng"]);
+    if (!m)
+        return null;
+    const coord = (key, limit) => {
+        const x = m[key];
+        if (typeof x === "number" && Math.abs(x) <= limit)
+            return x;
+        c.fail(at(path, key), "coordinate");
+        return 0;
+    };
+    return { lat: coord("lat", 90), lng: coord("lng", 180) };
+}
+function landmark(c, path, v) {
+    if (!isObject(v)) {
+        c.fail(path, "shape");
+        return {};
+    }
+    const entries = Object.entries(v);
+    if (entries.length === 0)
+        c.fail(path, "empty");
+    else if (entries.length > LIMIT.maxLocales)
+        c.fail(path, "too_many");
+    const out = {};
+    for (const [locale, text] of entries) {
+        if (!/^[a-z]{2}$/.test(locale))
+            c.fail(at(path, locale), "locale");
+        else
+            out[locale] = c.text(at(path, locale), text, LIMIT.maxText);
+    }
+    return out;
+}
+function rating(c, path, v) {
+    const m = c.object(path, v, ["value", "count", "fetchedAt"]);
+    if (!m)
+        return null;
+    const { value, count, fetchedAt } = m;
+    const valueOk = typeof value === "number" && value >= 1 && value <= 5;
+    const countOk = typeof count === "number" && Number.isSafeInteger(count) && count >= 0;
+    const atOk = typeof fetchedAt === "string" && isInstant(fetchedAt);
+    if (!valueOk)
+        c.fail(at(path, "value"), "rating_value");
+    if (!countOk)
+        c.fail(at(path, "count"), "rating_count");
+    if (!atOk)
+        c.fail(at(path, "fetchedAt"), "instant");
+    return valueOk && countOk && atOk ? { value, count, fetchedAt } : null;
+}
+function messengers(c, path, v) {
+    if (!isObject(v)) {
+        c.fail(path, "shape");
+        return {};
+    }
+    const out = {};
+    for (const [k, on] of Object.entries(v)) {
+        if (!isMessenger(k))
+            c.fail(at(path, k), "messenger_unknown");
+        else if (typeof on !== "boolean")
+            c.fail(at(path, k), "boolean");
+        else
+            out[k] = on;
+    }
+    return out;
+}
+/**
+ * A place's live settings checked field by field (`contracts/vectors/place.json`): the fields
+ * that pass, and every problem of those that do not. The panel refuses settings with any
+ * problem; a site keeps what passed and serves its baked config for the rest. A field set to
+ * `null` is left out, as if absent.
+ */
+export function checkPlaceLive(body) {
+    const c = new Check();
+    const live = {};
+    if (!isObject(body))
+        return { live, problems: [{ path: "", code: "object" }] };
+    const set = (key, value) => {
+        if (value !== undefined && value !== null)
+            live[key] = value;
+    };
+    for (const [name, v] of Object.entries(body)) {
+        if (v === null)
+            continue;
+        switch (name) {
+            case "phone":
+            case "whatsapp":
+                set(name, c.clean(() => c.word(name, v, 16, "e164", s => E164.test(s))));
+                break;
+            case "telegram":
+                set(name, c.clean(() => c.word(name, v, 32, "telegram_bot", s => TELEGRAM_BOT.test(s))));
+                break;
+            case "messengers":
+                set(name, c.clean(() => messengers(c, name, v)));
+                break;
+            case "hours":
+                set(name, c.clean(() => hours(c, name, v)));
+                break;
+            case "serviceArea":
+                set(name, c.clean(() => serviceArea(c, name, v)));
+                break;
+            case "address":
+                set(name, c.clean(() => address(c, name, v)));
+                break;
+            case "geo":
+                set(name, c.clean(() => geo(c, name, v)));
+                break;
+            case "storefrontPhoto":
+                set(name, c.clean(() => c.word(name, v, LIMIT.maxUrl, "https_url", s => httpsHost(s) !== null)));
+                break;
+            case "landmark":
+                set(name, c.clean(() => landmark(c, name, v)));
+                break;
+            case "rating":
+                set(name, c.clean(() => rating(c, name, v)));
+                break;
+            case "booking": {
+                const { problems, config } = checkBookingConfig(v);
+                for (const p of problems)
+                    c.fail(p.path === "" ? name : at(name, p.path), p.code);
+                set(name, config);
+                break;
+            }
+            case "reviewUrl":
+                set(name, c.clean(() => c.word(name, v, LIMIT.maxUrl, "review_url", s => LIMIT.reviewHosts.some(h => h === httpsHost(s)))));
+                break;
+            default:
+                c.fail(name, "unknown_field");
+        }
+    }
+    return { live, problems: c.problems };
+}

package/dist/pricing.d.ts

@@ -0,0 +1,72 @@
+import type { PricingCode } from "./generated/codes.js";
+import { type PricingInputKind } from "./generated/pricing.js";
+import type { PricingInput, PricingModel } from "./generated/types.js";
+/**
+ * One thing wrong with a model: its path from the model's root (`inputs[0].options[2].addCents`,
+ * `""` for the model itself), the code the panel names it by too, and what the code's words
+ * need (`{ min, max }`, `{ id }`, `{ locale }`).
+ */
+export interface PricingProblem {
+    path: string;
+    code: PricingCode;
+    vars: Readonly<Record<string, string | number>>;
+}
+/** The answers to an estimate's inputs: input id → option id. */
+export type PricingInputs = Readonly<Record<string, string>>;
+/** The labels of an input or an option, by locale. */
+export type PricingLabels = PricingInput["labels"];
+/**
+ * Every reason `value` is not a pricing model, and the model rebuilt from what was checked when
+ * there is none: taken whole or not at all, unknown fields refused rather than ignored. With
+ * `locales`, a model a site can show: every input and option labelled in each of them.
+ */
+export declare function checkPricingModel(value: unknown, locales?: readonly string[]): {
+    problems: PricingProblem[];
+    model: PricingModel | null;
+};
+/**
+ * `cents × bp / 10 000`, rounded half up to the cent. Integers throughout: the product is exact
+ * (the model's limits keep it under 2^53), and the division is done on the remainder.
+ */
+export declare function mulBp(cents: number, bp: number): number;
+/** Half up to a multiple of `step` (≥ 1). */
+export declare function roundTo(cents: number, step: number): number;
+/**
+ * One line of how a price was reached; `cents` is what the line changed, so the lines add up to
+ * the total. `base` is the need's base (or the fixed price); `rounding` and `minimum` appear only
+ * when they changed something.
+ */
+export type PriceLine = {
+    kind: "base";
+    cents: number;
+} | {
+    kind: PricingInputKind;
+    input: string;
+    option: string;
+    cents: number;
+} | {
+    kind: "rounding";
+    cents: number;
+} | {
+    kind: "minimum";
+    cents: number;
+};
+export interface Price {
+    cents: number;
+    breakdown: readonly PriceLine[];
+}
+/**
+ * What a need costs for these answers (`contracts/vectors/pricing/README.md`, normative):
+ *
+ * 1. the need's base, plus every `add` input, in the need's input order;
+ * 2. times every `multiply` input, in order, each product rounded half up to the cent at once;
+ * 3. every `discount` input, in order, as a multiplication by `10 000 − discountBp`, rounded the
+ *    same way;
+ * 4. the total rounded half up to a multiple of `roundToCents`;
+ * 5. raised to `minimumCents`.
+ *
+ * A `fixed` need is its price, as is. `null`: the need is not priced, or an input is unanswered
+ * or answered with an option it does not have — never a guess. Answers to inputs the need does
+ * not ask are ignored.
+ */
+export declare function priceOf(model: PricingModel, need: string, inputs: PricingInputs): Price | null;