@wocart/storefront 1.19.0 → 1.21.0

package/dist/review-media.d.ts

@@ -1,8 +1,9 @@
 /**
- * `@wocart/storefront/review-media` — what a theme's review form does in the
- * browser before a photo or a voice note is sent, so it arrives small on a
- * slow mobile connection:
+ * `@wocart/storefront/review-media` — a review form in the browser.
  *
+ *   createReviewSession  proves the purchase, sends each photo or voice note
+ *                        as it is added (progress, retries), and submits the
+ *                        review; every refusal comes back as a code
  *   prepareReviewPhoto   shrinks a photo to 1600 px at most and re-encodes it
  *                        (WebP, else JPEG) — a phone photo of several MB
  *                        becomes a few hundred KB, and its EXIF (the phone's
@@ -12,76 +13,8 @@
  *                        itself at the store's limit
  *
  * Browser-only, and kept off the main entry point: a theme that takes no
- * media pays nothing for it. Each takes its browser dependencies as an
- * optional last argument, for tests and unusual hosts.
+ * reviews pays nothing for it.
  */
-export interface PhotoOptions {
-    /** Longest edge in pixels. Default 1600 (what the server keeps). */
-    maxEdge?: number;
-    /** Encoder quality, 0–1. Default 0.82. */
-    quality?: number;
-}
-/** The size a photo is drawn at: its own, or scaled so its longest edge is `maxEdge`. */
-export declare function photoTargetSize(width: number, height: number, maxEdge: number): {
-    width: number;
-    height: number;
-};
-export interface PhotoDeps {
-    createImageBitmap: (image: Blob, options?: ImageBitmapOptions) => Promise<ImageBitmap>;
-    /** A canvas of the given size that can encode itself. */
-    createCanvas: (width: number, height: number) => {
-        getContext(type: "2d"): Pick<CanvasRenderingContext2D, "drawImage"> | null;
-        toBlob(type: string, quality: number): Promise<Blob | null>;
-    };
-}
-/**
- * A photo ready to send: drawn upright (the camera's orientation applied),
- * no larger than `maxEdge`, re-encoded as WebP (JPEG where WebP cannot be
- * written). When the browser cannot do it, the photo is sent as it is — the
- * server still converts it and drops its EXIF.
- */
-export declare function prepareReviewPhoto(photo: Blob, options?: PhotoOptions, deps?: PhotoDeps | null): Promise<Blob>;
-/** Formats in the order a recorder is tried: Opus where it can be written, AAC on iPhone. */
-export declare const VOICE_MIME_TYPES: readonly ["audio/webm;codecs=opus", "audio/ogg;codecs=opus", "audio/mp4;codecs=mp4a.40.2", "audio/mp4", "audio/webm"];
-/** The first format this browser can record, or null when it cannot record voice. */
-export declare function pickVoiceMimeType(isTypeSupported: (type: string) => boolean): string | null;
-export interface RecordedVoice {
-    blob: Blob;
-    /** As measured while recording; send it with the upload. */
-    durationMs: number;
-    mimeType: string;
-}
-export interface VoiceRecorderOptions {
-    /** Stops by itself after this many seconds (the store's limit). */
-    maxSeconds: number;
-    /** About every 250 ms while recording, with the time recorded so far. */
-    onTick?: (elapsedMs: number) => void;
-    /** When it stopped by itself at the limit. */
-    onLimit?: (voice: RecordedVoice) => void;
-}
-export interface VoiceRecorder {
-    /** Asks for the microphone and starts. Rejects when it is refused or unavailable. */
-    start(): Promise<void>;
-    /** Stops and gives the recording. */
-    stop(): Promise<RecordedVoice>;
-    /** Stops and throws the recording away. */
-    cancel(): void;
-    readonly state: "idle" | "recording" | "stopped";
-}
-export interface VoiceDeps {
-    getUserMedia: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
-    MediaRecorder: {
-        new (stream: MediaStream, options?: MediaRecorderOptions): MediaRecorder;
-        isTypeSupported(type: string): boolean;
-    };
-    now: () => number;
-    setInterval: (fn: () => void, ms: number) => unknown;
-    clearInterval: (id: unknown) => void;
-}
-/** Whether this browser can record a voice note at all (hide the record button when not). */
-export declare function canRecordVoice(deps?: VoiceDeps | null): boolean;
-/**
- * A recorder for one voice note: speech at about 32 kb/s, mono, with the
- * phone's echo cancellation and noise suppression — 60 s is about 240 KB.
- */
-export declare function createVoiceRecorder(options: VoiceRecorderOptions, deps?: VoiceDeps | null): VoiceRecorder;
+export * from "./review-capture.js";
+export { createReviewSession } from "./review-session.js";
+export type { ReviewDraft, ReviewFindResult, ReviewRefusal, ReviewSession, ReviewSessionDeps, ReviewSessionOptions, ReviewSessionRoutes, ReviewSubmission, ReviewUpload, ReviewUploadOptions, ReviewUploadRequest, ReviewUploadResult, } from "./review-session.js";

package/dist/review-media.js

@@ -1,8 +1,9 @@
 /**
- * `@wocart/storefront/review-media` — what a theme's review form does in the
- * browser before a photo or a voice note is sent, so it arrives small on a
- * slow mobile connection:
+ * `@wocart/storefront/review-media` — a review form in the browser.
  *
+ *   createReviewSession  proves the purchase, sends each photo or voice note
+ *                        as it is added (progress, retries), and submits the
+ *                        review; every refusal comes back as a code
  *   prepareReviewPhoto   shrinks a photo to 1600 px at most and re-encodes it
  *                        (WebP, else JPEG) — a phone photo of several MB
  *                        becomes a few hundred KB, and its EXIF (the phone's
@@ -12,171 +13,7 @@
  *                        itself at the store's limit
  *
  * Browser-only, and kept off the main entry point: a theme that takes no
- * media pays nothing for it. Each takes its browser dependencies as an
- * optional last argument, for tests and unusual hosts.
+ * reviews pays nothing for it.
  */
-/** The size a photo is drawn at: its own, or scaled so its longest edge is `maxEdge`. */
-export function photoTargetSize(width, height, maxEdge) {
-    const longest = Math.max(width, height);
-    if (longest <= maxEdge || longest === 0)
-        return { width, height };
-    const scale = maxEdge / longest;
-    return { width: Math.max(1, Math.round(width * scale)), height: Math.max(1, Math.round(height * scale)) };
-}
-function browserPhotoDeps() {
-    if (typeof createImageBitmap !== "function" || typeof document === "undefined")
-        return null;
-    return {
-        createImageBitmap: (image, options) => createImageBitmap(image, options),
-        createCanvas: (width, height) => {
-            const canvas = document.createElement("canvas");
-            canvas.width = width;
-            canvas.height = height;
-            return {
-                getContext: () => canvas.getContext("2d"),
-                toBlob: (type, quality) => new Promise((resolve) => canvas.toBlob(resolve, type, quality)),
-            };
-        },
-    };
-}
-/**
- * A photo ready to send: drawn upright (the camera's orientation applied),
- * no larger than `maxEdge`, re-encoded as WebP (JPEG where WebP cannot be
- * written). When the browser cannot do it, the photo is sent as it is — the
- * server still converts it and drops its EXIF.
- */
-export async function prepareReviewPhoto(photo, options = {}, deps = browserPhotoDeps()) {
-    if (!deps)
-        return photo;
-    const maxEdge = options.maxEdge ?? 1600;
-    const quality = options.quality ?? 0.82;
-    let bitmap;
-    try {
-        bitmap = await deps.createImageBitmap(photo, { imageOrientation: "from-image" });
-    }
-    catch {
-        return photo;
-    }
-    try {
-        const size = photoTargetSize(bitmap.width, bitmap.height, maxEdge);
-        const canvas = deps.createCanvas(size.width, size.height);
-        const context = canvas.getContext("2d");
-        if (!context)
-            return photo;
-        context.drawImage(bitmap, 0, 0, size.width, size.height);
-        for (const type of ["image/webp", "image/jpeg"]) {
-            const blob = await canvas.toBlob(type, quality);
-            if (blob && blob.type === type && blob.size > 0)
-                return blob;
-        }
-        return photo;
-    }
-    catch {
-        return photo;
-    }
-    finally {
-        bitmap.close?.();
-    }
-}
-/** Formats in the order a recorder is tried: Opus where it can be written, AAC on iPhone. */
-export const VOICE_MIME_TYPES = ["audio/webm;codecs=opus", "audio/ogg;codecs=opus", "audio/mp4;codecs=mp4a.40.2", "audio/mp4", "audio/webm"];
-/** The first format this browser can record, or null when it cannot record voice. */
-export function pickVoiceMimeType(isTypeSupported) {
-    return VOICE_MIME_TYPES.find((type) => {
-        try {
-            return isTypeSupported(type);
-        }
-        catch {
-            return false;
-        }
-    }) ?? null;
-}
-function browserVoiceDeps() {
-    if (typeof navigator === "undefined" || !navigator.mediaDevices?.getUserMedia || typeof MediaRecorder === "undefined")
-        return null;
-    return {
-        getUserMedia: (constraints) => navigator.mediaDevices.getUserMedia(constraints),
-        MediaRecorder,
-        now: () => performance.now(),
-        setInterval: (fn, ms) => setInterval(fn, ms),
-        clearInterval: (id) => clearInterval(id),
-    };
-}
-/** Whether this browser can record a voice note at all (hide the record button when not). */
-export function canRecordVoice(deps = browserVoiceDeps()) {
-    return Boolean(deps && pickVoiceMimeType((type) => deps.MediaRecorder.isTypeSupported(type)));
-}
-/**
- * A recorder for one voice note: speech at about 32 kb/s, mono, with the
- * phone's echo cancellation and noise suppression — 60 s is about 240 KB.
- */
-export function createVoiceRecorder(options, deps = browserVoiceDeps()) {
-    let state = "idle";
-    let recorder = null;
-    let stream = null;
-    let chunks = [];
-    let startedAt = 0;
-    let ticker = null;
-    let finished = null;
-    const release = () => {
-        if (ticker !== null)
-            deps?.clearInterval(ticker);
-        ticker = null;
-        stream?.getTracks().forEach((track) => track.stop());
-        stream = null;
-    };
-    return {
-        get state() {
-            return state;
-        },
-        async start() {
-            if (!deps)
-                throw new Error("This browser cannot record voice notes");
-            if (state === "recording")
-                return;
-            const mimeType = pickVoiceMimeType((type) => deps.MediaRecorder.isTypeSupported(type));
-            if (!mimeType)
-                throw new Error("This browser cannot record voice notes");
-            stream = await deps.getUserMedia({ audio: { channelCount: 1, echoCancellation: true, noiseSuppression: true } });
-            chunks = [];
-            recorder = new deps.MediaRecorder(stream, { mimeType, audioBitsPerSecond: 32_000 });
-            const active = recorder;
-            finished = new Promise((resolve) => {
-                active.ondataavailable = (event) => {
-                    if (event.data.size > 0)
-                        chunks.push(event.data);
-                };
-                active.onstop = () => {
-                    const type = (active.mimeType || mimeType).split(";")[0];
-                    resolve({ blob: new Blob(chunks, { type }), durationMs: Math.round(deps.now() - startedAt), mimeType: type });
-                };
-            });
-            startedAt = deps.now();
-            recorder.start(1000);
-            state = "recording";
-            ticker = deps.setInterval(() => {
-                const elapsed = deps.now() - startedAt;
-                options.onTick?.(elapsed);
-                if (elapsed >= options.maxSeconds * 1000 && state === "recording") {
-                    void this.stop().then((voice) => options.onLimit?.(voice));
-                }
-            }, 250);
-        },
-        async stop() {
-            if (state !== "recording" || !recorder || !finished)
-                throw new Error("Not recording");
-            state = "stopped";
-            recorder.stop();
-            const voice = await finished;
-            release();
-            return voice;
-        },
-        cancel() {
-            if (recorder && state === "recording")
-                recorder.stop();
-            state = "stopped";
-            chunks = [];
-            release();
-        },
-    };
-}
+export * from "./review-capture.js";
+export { createReviewSession } from "./review-session.js";

package/dist/review-session.d.ts

@@ -0,0 +1,97 @@
+import type { ReviewRefusalCode } from "./reviews.js";
+import type { ReviewEligibility, ReviewSubmitResult } from "./types.js";
+/** The theme's review routes (`createStorefrontRoutes()`): `reviewEligibility`, `reviewUpload`, `reviewSubmit`. */
+export interface ReviewSessionRoutes {
+    eligibility: string;
+    upload: string;
+    submit: string;
+}
+export interface ReviewSessionOptions {
+    routes: ReviewSessionRoutes;
+    /** Tries per upload, the first included. Default 3: two retries, after 2 s and then 4 s. */
+    attempts?: number;
+}
+/** A refusal: one of `REVIEW_REFUSAL_CODES` (or a code from a newer server), or null when no answer came. */
+export interface ReviewRefusal {
+    status: "refused";
+    code: ReviewRefusalCode | (string & {}) | null;
+}
+export type ReviewFindResult = {
+    status: "found";
+    eligibility: ReviewEligibility;
+} | ReviewRefusal;
+export type ReviewSubmission = {
+    status: "submitted";
+    result: ReviewSubmitResult;
+} | ReviewRefusal;
+/** `cancelled`: `cancel()` was called, or the session was reset; nothing more happens. */
+export type ReviewUploadResult = {
+    status: "sent";
+    uploadId: string;
+} | ReviewRefusal | {
+    status: "cancelled";
+};
+export interface ReviewUploadOptions {
+    /** A photo is shrunk before it is sent; a voice note is sent as recorded. */
+    kind: "image" | "audio";
+    /** A voice note's length, as the recorder reported it. */
+    durationMs?: number;
+    /** The share sent so far, 0–1, for a progress bar. */
+    onProgress?: (share: number) => void;
+}
+export interface ReviewUpload {
+    readonly result: Promise<ReviewUploadResult>;
+    cancel(): void;
+}
+export interface ReviewDraft {
+    productId: string;
+    /** 1–5. */
+    rating: number;
+    body: string;
+    title?: string;
+    /** The `uploadId`s of what was sent; the grant goes with them. */
+    uploads?: readonly string[];
+}
+export interface ReviewSession {
+    /** The order `find` proved, until `reset`. */
+    readonly eligibility: ReviewEligibility | null;
+    /** Prove the purchase with the order's number and the phone it was placed with. */
+    find(proof: {
+        orderNumber: string;
+        phone: string;
+    }): Promise<ReviewFindResult>;
+    /** Send one photo or voice note under the grant `find` got. */
+    upload(file: Blob, options: ReviewUploadOptions): ReviewUpload;
+    /** Submit the review for one of the order's products. */
+    submit(draft: ReviewDraft): Promise<ReviewSubmission>;
+    /** Forget the order and cancel what is still sending: the shopper changes order. */
+    reset(): void;
+}
+/** One request with upload progress, as `XMLHttpRequest` gives it. */
+export interface ReviewUploadRequest {
+    open(method: string, url: string): void;
+    setRequestHeader(name: string, value: string): void;
+    send(body: Blob): void;
+    abort(): void;
+    readonly status: number;
+    readonly responseText: string;
+    readonly upload: {
+        onprogress: ((event: {
+            lengthComputable: boolean;
+            loaded: number;
+            total: number;
+        }) => void) | null;
+    };
+    onload: (() => void) | null;
+    onerror: (() => void) | null;
+    ontimeout: (() => void) | null;
+    onabort: (() => void) | null;
+}
+/** What the session uses of the page; the page's own by default. */
+export interface ReviewSessionDeps {
+    fetch: typeof fetch;
+    createRequest: () => ReviewUploadRequest;
+    wait: (ms: number) => Promise<void>;
+    preparePhoto: (photo: Blob) => Promise<Blob>;
+}
+export declare function createReviewSession(options: ReviewSessionOptions, deps?: ReviewSessionDeps): ReviewSession;

package/dist/review-session.js

@@ -0,0 +1,157 @@
+/**
+ * Writing a review from the browser, through the theme's review routes: prove
+ * the purchase, send each photo or voice note as soon as it is added, then
+ * submit a review that only names what already arrived.
+ *
+ * Every rule is the server's. The session keeps the proof and the upload
+ * grant between the steps, sends a photo shrunk (`prepareReviewPhoto`), shows
+ * an upload's progress, tries again when the connection drops or the server
+ * fails, and answers every refusal with its code (`REVIEW_REFUSAL_CODES`) for
+ * the form to word. It never throws.
+ */
+import { isOrderNumber } from "./order-number.js";
+import { prepareReviewPhoto } from "./review-capture.js";
+function browserDeps() {
+    return {
+        fetch: (input, init) => globalThis.fetch(input, init),
+        createRequest: () => new XMLHttpRequest(),
+        wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        preparePhoto: (photo) => prepareReviewPhoto(photo),
+    };
+}
+const refused = (code) => ({ status: "refused", code: typeof code === "string" && code !== "" ? code : null });
+const isObject = (value) => typeof value === "object" && value !== null;
+async function postJson(deps, url, body) {
+    try {
+        const response = await deps.fetch(url, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+        const json = await response.json().catch(() => ({}));
+        return { ok: response.ok, json: isObject(json) ? json : {} };
+    }
+    catch {
+        return null;
+    }
+}
+export function createReviewSession(options, deps = browserDeps()) {
+    const attempts = Math.max(1, options.attempts ?? 3);
+    let proof = null;
+    let eligibility = null;
+    let generation = 0;
+    const pending = new Set();
+    function send(file, headers, onProgress, register) {
+        return new Promise((resolve) => {
+            const request = deps.createRequest();
+            request.open("PUT", options.routes.upload);
+            for (const [name, value] of Object.entries(headers))
+                request.setRequestHeader(name, value);
+            request.upload.onprogress = (event) => {
+                if (event.lengthComputable && event.total > 0)
+                    onProgress?.(Math.min(1, event.loaded / event.total));
+            };
+            request.onload = () => {
+                let json = {};
+                try {
+                    json = JSON.parse(request.responseText);
+                }
+                catch {
+                    json = {};
+                }
+                resolve({ status: request.status, json: isObject(json) ? json : {} });
+            };
+            request.onerror = request.ontimeout = request.onabort = () => resolve({ status: 0, json: {} });
+            register(() => request.abort());
+            request.send(file);
+        });
+    }
+    return {
+        get eligibility() {
+            return eligibility;
+        },
+        async find(given) {
+            const orderNumber = given.orderNumber.trim();
+            const phone = given.phone.trim();
+            if (!isOrderNumber(orderNumber) || phone === "")
+                return refused("VALIDATION_FAILED");
+            const asked = generation;
+            const answer = await postJson(deps, options.routes.eligibility, { orderNumber, phone });
+            if (answer === null)
+                return refused(null);
+            if (!answer.ok)
+                return refused(answer.json.code);
+            const data = answer.json.data;
+            if (!isObject(data) || !Array.isArray(data.products))
+                return refused(null);
+            if (asked === generation) {
+                proof = { orderNumber, phone };
+                eligibility = data;
+            }
+            return { status: "found", eligibility: data };
+        },
+        upload(file, uploadOptions) {
+            let cancelled = false;
+            let abort = null;
+            const cancel = () => {
+                cancelled = true;
+                abort?.();
+                pending.delete(cancel);
+            };
+            pending.add(cancel);
+            const grant = eligibility?.media?.grant;
+            const result = (async () => {
+                if (!grant)
+                    return refused(eligibility ? "REVIEW_MEDIA_LIMIT" : "REVIEW_UPLOAD_GRANT_INVALID");
+                const body = uploadOptions.kind === "image" ? await deps.preparePhoto(file).catch(() => file) : file;
+                const headers = { "Content-Type": "application/octet-stream", "X-Review-Grant": grant };
+                if (uploadOptions.durationMs !== undefined && uploadOptions.durationMs > 0)
+                    headers["X-Media-Duration-Ms"] = String(Math.round(uploadOptions.durationMs));
+                for (let attempt = 1;; attempt++) {
+                    if (cancelled)
+                        return { status: "cancelled" };
+                    const answer = await send(body, headers, uploadOptions.onProgress, (stop) => (abort = stop));
+                    abort = null;
+                    if (cancelled)
+                        return { status: "cancelled" };
+                    if (answer.status >= 200 && answer.status < 300) {
+                        const data = answer.json.data;
+                        const uploadId = isObject(data) && typeof data.uploadId === "string" && data.uploadId !== "" ? data.uploadId : null;
+                        return uploadId === null ? refused(null) : { status: "sent", uploadId };
+                    }
+                    const transient = answer.status === 0 || answer.status >= 500;
+                    if (!transient || attempt >= attempts)
+                        return refused(answer.json.code);
+                    await deps.wait(1000 * 2 ** attempt);
+                }
+            })().finally(() => pending.delete(cancel));
+            return { result, cancel };
+        },
+        async submit(draft) {
+            if (proof === null)
+                return refused("ORDER_NOT_FOUND");
+            const uploads = draft.uploads ?? [];
+            const title = draft.title?.trim();
+            const answer = await postJson(deps, options.routes.submit, {
+                orderNumber: proof.orderNumber,
+                phone: proof.phone,
+                productId: draft.productId,
+                rating: draft.rating,
+                body: draft.body.trim(),
+                ...(title ? { title } : {}),
+                ...(uploads.length > 0 && eligibility?.media ? { grant: eligibility.media.grant, uploads: [...uploads] } : {}),
+            });
+            if (answer === null)
+                return refused(null);
+            if (!answer.ok)
+                return refused(answer.json.code);
+            const data = answer.json.data;
+            if (!isObject(data) || typeof data.id !== "string")
+                return refused(null);
+            return { status: "submitted", result: data };
+        },
+        reset() {
+            generation++;
+            proof = null;
+            eligibility = null;
+            for (const cancel of [...pending])
+                cancel();
+        },
+    };
+}

package/dist/reviews.d.ts

@@ -0,0 +1,33 @@
+/**
+ * What a review form needs to know of the platform's rules without asking:
+ * how long its text may be, and every code a refusal can carry. The rules
+ * themselves are the server's — these let a form say them in its own words.
+ */
+/** The lengths the server accepts: a title up to `titleMax`; a body of `bodyMin`–`bodyMax` characters, or shorter with a voice note. */
+export declare const REVIEW_TEXT_LIMITS: {
+    readonly titleMax: 150;
+    readonly bodyMin: 10;
+    readonly bodyMax: 2000;
+};
+/**
+ * Every code the server refuses a review step with. A newer server may send
+ * another; a form then shows its general sentence.
+ *
+ * - `VALIDATION_FAILED`: the order number is not one (`isOrderNumber`), or the
+ *   text is too short without a voice note.
+ * - `ORDER_NOT_FOUND`: no order has this number and phone — the same answer
+ *   for either being wrong.
+ * - `REVIEWS_DISABLED`: the store takes no reviews.
+ * - `REVIEW_ORDER_NOT_DELIVERED`: the order has not reached the shopper yet.
+ * - `REVIEW_RATE_LIMITED`: too many attempts for this order; try in a minute.
+ * - `ORDER_ALREADY_REVIEWED`: this product was reviewed from this order.
+ * - `PRODUCT_NOT_IN_ORDER`: the product is not one the order kept.
+ * - `REVIEW_UPLOAD_GRANT_INVALID`: the permission to send files expired; find
+ *   the order again.
+ * - `REVIEW_UPLOAD_NOT_FOUND`: a file the review names never arrived.
+ * - `REVIEW_MEDIA_LIMIT`: more photos or voice notes than the store takes.
+ * - `INVALID_FILE_TYPE`: not a photo or a voice note the store reads.
+ * - `FILE_TOO_LARGE`: the file is over the store's size.
+ */
+export declare const REVIEW_REFUSAL_CODES: readonly ["VALIDATION_FAILED", "ORDER_NOT_FOUND", "REVIEWS_DISABLED", "REVIEW_ORDER_NOT_DELIVERED", "REVIEW_RATE_LIMITED", "ORDER_ALREADY_REVIEWED", "PRODUCT_NOT_IN_ORDER", "REVIEW_UPLOAD_GRANT_INVALID", "REVIEW_UPLOAD_NOT_FOUND", "REVIEW_MEDIA_LIMIT", "INVALID_FILE_TYPE", "FILE_TOO_LARGE"];
+export type ReviewRefusalCode = (typeof REVIEW_REFUSAL_CODES)[number];

package/dist/reviews.js

@@ -0,0 +1,41 @@
+/**
+ * What a review form needs to know of the platform's rules without asking:
+ * how long its text may be, and every code a refusal can carry. The rules
+ * themselves are the server's — these let a form say them in its own words.
+ */
+/** The lengths the server accepts: a title up to `titleMax`; a body of `bodyMin`–`bodyMax` characters, or shorter with a voice note. */
+export const REVIEW_TEXT_LIMITS = { titleMax: 150, bodyMin: 10, bodyMax: 2000 };
+/**
+ * Every code the server refuses a review step with. A newer server may send
+ * another; a form then shows its general sentence.
+ *
+ * - `VALIDATION_FAILED`: the order number is not one (`isOrderNumber`), or the
+ *   text is too short without a voice note.
+ * - `ORDER_NOT_FOUND`: no order has this number and phone — the same answer
+ *   for either being wrong.
+ * - `REVIEWS_DISABLED`: the store takes no reviews.
+ * - `REVIEW_ORDER_NOT_DELIVERED`: the order has not reached the shopper yet.
+ * - `REVIEW_RATE_LIMITED`: too many attempts for this order; try in a minute.
+ * - `ORDER_ALREADY_REVIEWED`: this product was reviewed from this order.
+ * - `PRODUCT_NOT_IN_ORDER`: the product is not one the order kept.
+ * - `REVIEW_UPLOAD_GRANT_INVALID`: the permission to send files expired; find
+ *   the order again.
+ * - `REVIEW_UPLOAD_NOT_FOUND`: a file the review names never arrived.
+ * - `REVIEW_MEDIA_LIMIT`: more photos or voice notes than the store takes.
+ * - `INVALID_FILE_TYPE`: not a photo or a voice note the store reads.
+ * - `FILE_TOO_LARGE`: the file is over the store's size.
+ */
+export const REVIEW_REFUSAL_CODES = [
+    "VALIDATION_FAILED",
+    "ORDER_NOT_FOUND",
+    "REVIEWS_DISABLED",
+    "REVIEW_ORDER_NOT_DELIVERED",
+    "REVIEW_RATE_LIMITED",
+    "ORDER_ALREADY_REVIEWED",
+    "PRODUCT_NOT_IN_ORDER",
+    "REVIEW_UPLOAD_GRANT_INVALID",
+    "REVIEW_UPLOAD_NOT_FOUND",
+    "REVIEW_MEDIA_LIMIT",
+    "INVALID_FILE_TYPE",
+    "FILE_TOO_LARGE",
+];

package/dist/routes.d.ts

@@ -26,6 +26,8 @@ export declare const STOREFRONT_PAGE_PATHS: {
     readonly landing: "/lp/:slug";
     readonly checkout: "/checkout";
     readonly thankYou: "/thank-you";
+    /** Where a shopper follows an order by its number and phone; `?order=<number>` fills the number in. */
+    readonly trackOrder: "/track-order";
 };
 /** What a storefront URL means. */
 export type StorefrontPageType = keyof typeof STOREFRONT_PAGE_PATHS;

package/dist/routes.js

@@ -9,6 +9,8 @@ export const STOREFRONT_PAGE_PATHS = {
     landing: "/lp/:slug",
     checkout: "/checkout",
     thankYou: "/thank-you",
+    /** Where a shopper follows an order by its number and phone; `?order=<number>` fills the number in. */
+    trackOrder: "/track-order",
 };
 /**
  * The public path of a page type, its parameter encoded:
@@ -65,6 +67,7 @@ const WIDGET_SURFACE = {
     landing: "landing",
     checkout: "checkout",
     thankYou: "thankYou",
+    trackOrder: "pages",
 };
 /**
  * @deprecated Use `STOREFRONT_PAGE_PATHS` (every page type, the home and the