@mohasinac/appkit 4.34.1 → 4.35.0

package/dist/_internal/client/features/lottery/LotteryAdminEditView.js

@@ -96,8 +96,38 @@ export function LotteryAdminEditView({ eventId, initialData, onSubmit, }) {
  * `audit-code-quality`'s DEEP_NESTING rule exists to stop.
  */
 function SlotTable({ slots, showPrice, onSlotsChange, }) {
-    const addSlot = () => onSlotsChange([...slots, { slotNumber: slots.length + 1, name: "", price: 0 }]);
-    const removeSlot = (idx) => onSlotsChange(slots.filter((_, i) => i !== idx).map((s, i) => ({ ...s, slotNumber: i + 1 })));
+    /**
+     * Next number is max+1, not length+1.
+     *
+     * Now that removeSlot preserves numbering, `slots.length + 1` collides: delete
+     * slot 1 of 25 and you hold 24 slots numbered 2..25, so length+1 is 25 — a
+     * duplicate, which the write schema rejects outright (slot numbers must be
+     * unique). Deriving from the highest number in use is stable under any gaps.
+     */
+    const addSlot = () => onSlotsChange([
+        ...slots,
+        { slotNumber: slots.reduce((max, s) => Math.max(max, s.slotNumber), 0) + 1, name: "", price: 0 },
+    ]);
+    /**
+     * 🛑 Remove the slot. Do NOT renumber the survivors.
+     *
+     * `slotNumber` is the stable identity a booking is attached to, and renumbering
+     * silently defeated the server's own protection. `mergeLotteryConfig` refuses a
+     * save that drops a BOOKED slot by checking `isBooked && !incoming.has(slotNumber)`
+     * — but this function used to renumber the remaining slots to `i + 1`, so deleting
+     * slot 1 of 25 sent back numbers 1..24. Every booked number (1–5) still *appeared*
+     * in that set, the check found nothing to refuse, and the save went through.
+     *
+     * The damage was worse than the deletion: the merge re-attaches bookings by
+     * slotNumber, so the buyer of the deleted slot 1 had their booking moved onto
+     * whatever prize now occupied number 1. That is precisely the hazard the schema
+     * header describes — "hands slot 7's buyer the prize that used to be slot 8".
+     *
+     * Numbers may therefore be non-contiguous after a delete (2..25), which the write
+     * schema allows: it requires slot numbers to be UNIQUE, not gapless, and totalSlots
+     * is derived from slots.length rather than from the highest number.
+     */
+    const removeSlot = (idx) => onSlotsChange(slots.filter((_, i) => i !== idx));
     const updateSlot = (idx, field, value) => onSlotsChange(slots.map((s, i) => i === idx
         ? {
             ...s,

package/dist/features/tester/components/TesterChecklistStepRow.d.ts

@@ -1,10 +1,18 @@
 import React from "react";
-import type { TesterAnswer } from "../schemas/firestore";
+import type { TesterAnswer, TesterCaseRole } from "../schemas/firestore";
 export interface TesterChecklistStepItem {
     checklistItemId: string;
     label: string;
     description?: string;
     href?: string;
+    roles?: TesterCaseRole[];
+    startPage?: string;
+    steps?: string[];
+    inputs?: Record<string, string | number | boolean>;
+    expectedBehaviour?: string;
+    expectedUiState?: string;
+    expectedData?: Record<string, string | number | boolean>;
+    endResult?: string;
     answer: TesterAnswer | null;
     comment?: string;
     screenshotUrl?: string;

package/dist/features/tester/components/TesterChecklistStepRow.js

@@ -1,10 +1,34 @@
 "use client";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import React from "react";
-import { Anchor, Button, Div, FieldTextarea, Row, Stack, Text } from "../../../ui";
+import { Anchor, Button, Details, Div, FieldTextarea, Li, Ol, Row, Stack, Summary, Text } from "../../../ui";
 import { MediaUploadField } from "../../media/upload/MediaUploadField";
 import { useMediaUpload } from "../../media/hooks/useMedia";
 import { ACTIONS } from "../../../_internal/shared/actions/action-registry";
+/** Human-facing labels for the role chip. `seller` is specifically the listing's OWNER. */
+const ROLE_LABEL = {
+    guest: "Signed out",
+    buyer: "As a buyer",
+    seller: "As the owning seller",
+    admin: "As an admin",
+    employee: "As an employee",
+};
+/**
+ * `inputs` / `expectedData` as a two-column list.
+ *
+ * Rendered as key/value rather than pretty-printed JSON because the reader is a
+ * person about to type these into a form — braces and quotes are noise, and a
+ * value they have to mentally unescape is a value they will get wrong.
+ *
+ * Renders nothing at all when the case has no such data, which is the common case:
+ * a read-only page enters nothing and has nothing checkable behind the screen.
+ */
+function KeyValueBlock({ label, data, }) {
+    const entries = Object.entries(data ?? {});
+    if (!entries.length)
+        return null;
+    return (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: label }), entries.map(([k, v]) => (_jsxs(Row, { gap: "xs", align: "baseline", wrap: true, children: [_jsx(Text, { size: "sm", color: "muted", children: k }), _jsx(Text, { size: "sm", weight: "medium", numeric: typeof v === "number", children: String(v) })] }, k)))] }));
+}
 export function TesterChecklistStepRow({ item, testerDisplayName, onAnswer, onSaveNote, }) {
     const [expanded, setExpanded] = React.useState(false);
     const [comment, setComment] = React.useState(item.comment ?? "");
@@ -25,5 +49,10 @@ export function TesterChecklistStepRow({ item, testerDisplayName, onAnswer, onSa
             setSaving(false);
         }
     };
-    return (_jsxs(Stack, { gap: "xs", padding: "sm", border: "default", rounded: "md", children: [_jsxs(Row, { gap: "sm", justify: "between", align: "center", wrap: true, children: [_jsxs(Stack, { gap: "none", className: "min-w-0", children: [_jsx(Text, { weight: "medium", children: item.label }), item.description && (_jsx(Text, { size: "xs", color: "muted", children: item.description })), item.href && (_jsx(Anchor, { href: item.href, tone: "brand", underline: "hover", target: "_blank", rel: "noopener noreferrer", children: "Go test this \u2192" }))] }), _jsxs(Row, { gap: "xs", children: [_jsx(Button, { type: "button", size: "sm", variant: item.answer === "yes" ? "primary" : "outline", onClick: () => onAnswer(item.checklistItemId, "yes"), children: "Yes" }), _jsx(Button, { type: "button", size: "sm", variant: item.answer === "no" ? "danger" : "outline", onClick: () => onAnswer(item.checklistItemId, "no"), children: "No" }), _jsx(Button, { type: "button", size: "sm", variant: "ghost", onClick: () => setExpanded((v) => !v), children: expanded ? "Hide note" : "Add note" })] })] }), expanded && (_jsx(Div, { padding: "t-sm", border: "default", className: "border-t", children: _jsxs(Stack, { gap: "sm", children: [_jsx(FieldTextarea, { name: `comment-${item.checklistItemId}`, label: "Comment", value: comment, onChange: setComment, placeholder: "What did you notice? Colors, styles, readability, bugs..." }), _jsx(MediaUploadField, { label: "Screenshot (optional)", value: screenshotUrl, onChange: setScreenshotUrl, onUpload: handleUpload, kind: "image" }), _jsx(Row, { children: _jsx(Button, { type: "button", action: ACTIONS.TESTER["save-note"], isLoading: saving, onClick: handleSave }) })] }) }))] }));
+    return (_jsxs(Stack, { gap: "xs", padding: "sm", border: "default", rounded: "md", children: [_jsxs(Row, { gap: "sm", justify: "between", align: "center", wrap: true, children: [_jsxs(Stack, { gap: "none", className: "min-w-0", children: [_jsxs(Row, { gap: "xs", align: "center", wrap: true, children: [item.roles?.map((r) => (_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: ROLE_LABEL[r] }, r))), _jsx(Text, { weight: "medium", children: item.label })] }), item.description && (_jsx(Text, { size: "xs", color: "muted", children: item.description })), item.href && (_jsx(Anchor, { href: item.href, tone: "brand", underline: "hover", target: "_blank", rel: "noopener noreferrer", children: "Go test this \u2192" }))] }), _jsxs(Row, { gap: "xs", children: [_jsx(Button, { type: "button", size: "sm", variant: item.answer === "yes" ? "primary" : "outline", onClick: () => onAnswer(item.checklistItemId, "yes"), children: "Yes" }), _jsx(Button, { type: "button", size: "sm", variant: item.answer === "no" ? "danger" : "outline", onClick: () => onAnswer(item.checklistItemId, "no"), children: "No" }), _jsx(Button, { type: "button", size: "sm", variant: "ghost", onClick: () => setExpanded((v) => !v), children: expanded ? "Hide note" : "Add note" })] })] }), (item.steps?.length ||
+                item.expectedBehaviour ||
+                item.expectedUiState ||
+                item.endResult ||
+                item.inputs ||
+                item.expectedData) && (_jsxs(Details, { tone: "card", padding: "sm", defaultOpen: false, children: [_jsx(Summary, { children: item.steps?.length ? `Steps (${item.steps.length})` : "Expected result" }), _jsxs(Stack, { gap: "sm", children: [item.startPage && (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "Start" }), _jsx(Text, { size: "sm", children: item.startPage })] })), item.steps?.length ? (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "Steps" }), _jsx(Ol, { marker: "decimal", indent: "md", spacing: "tight", size: "sm", children: item.steps.map((step, i) => (_jsx(Li, { children: step }, i))) })] })) : null, _jsx(KeyValueBlock, { label: "Enter exactly", data: item.inputs }), item.expectedBehaviour && (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "Expected behaviour" }), _jsx(Text, { size: "sm", children: item.expectedBehaviour })] })), item.expectedUiState && (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "Expected UI state" }), _jsx(Text, { size: "sm", children: item.expectedUiState })] })), _jsx(KeyValueBlock, { label: "Values that must be correct", data: item.expectedData }), item.endResult && (_jsxs(Stack, { gap: "none", children: [_jsx(Text, { size: "xs", weight: "semibold", color: "muted", children: "After reload" }), _jsx(Text, { size: "sm", children: item.endResult })] }))] })] })), expanded && (_jsx(Div, { padding: "t-sm", border: "default", className: "border-t", children: _jsxs(Stack, { gap: "sm", children: [_jsx(FieldTextarea, { name: `comment-${item.checklistItemId}`, label: "Comment", value: comment, onChange: setComment, placeholder: "What did you notice? Colors, styles, readability, bugs..." }), _jsx(MediaUploadField, { label: "Screenshot (optional)", value: screenshotUrl, onChange: setScreenshotUrl, onUpload: handleUpload, kind: "image" }), _jsx(Row, { children: _jsx(Button, { type: "button", action: ACTIONS.TESTER["save-note"], isLoading: saving, onClick: handleSave }) })] }) }))] }));
 }

package/dist/features/tester/components/TesterHubView.js

@@ -25,6 +25,14 @@ function TesterChecklistPageSection({ page, testerDisplayName, onAnswer, onSaveN
                             label: item.label,
                             description: item.description,
                             href: item.href,
+                            roles: item.roles,
+                            startPage: item.startPage,
+                            steps: item.steps,
+                            inputs: item.inputs,
+                            expectedBehaviour: item.expectedBehaviour,
+                            expectedUiState: item.expectedUiState,
+                            expectedData: item.expectedData,
+                            endResult: item.endResult,
                             answer: item.answer,
                             comment: item.comment,
                             screenshotUrl: item.screenshotUrl,

package/dist/features/tester/schemas/firestore.d.ts

@@ -13,6 +13,101 @@ export interface TesterChecklistItemDocument extends BaseDocument {
     pageLabel: string;
     label: string;
     description?: string;
+    /**
+     * WHICH ROLES this case affects. Not decoration — it changes what "correct" means.
+     *
+     * The same page is a different page per role: /products/<slug> shows a buyer
+     * Add to Cart and Make Offer, shows the OWNING seller Edit listing and no Make
+     * Offer (you cannot bid on your own listing), shows an admin moderation
+     * controls, and shows a guest a sign-in prompt. So `expectedUiState` is
+     * meaningless without this, and a case omitting it is really three untested
+     * cases wearing one label.
+     *
+     * 🛑 A LIST, because the interesting content is usually the DIFFERENCE between
+     * roles — "the owning seller must NOT see Make Offer where a buyer does" is one
+     * case, not two, and splitting it loses the comparison that is the whole point.
+     * Where roles differ, `expectedBehaviour` and `expectedUiState` say so in prose
+     * ("Buyer: … Owning seller: …"). Deliberately NOT a parallel per-role structure:
+     * that would be four more fields to keep in sync for something a sentence
+     * expresses perfectly well.
+     *
+     * Also drives which session the automated harness browses with.
+     */
+    roles?: TesterCaseRole[];
+    /** WHERE the tester begins. One unambiguous URL, unprefixed (/products, not /en/products). */
+    startPage?: string;
+    /**
+     * WHAT the tester does. One action per entry, concrete fixtures named, literal
+     * values ("Enter 780", not "enter an amount below the listed price") so two
+     * runs are comparable and a regression can be spotted by diffing.
+     *
+     * 🛑 No assertions in here — they belong in the three expectation fields. A
+     * step reading "click Save and confirm it worked" is two things wearing one
+     * number, and the confirming half silently goes unchecked.
+     *
+     * Length varies with the case. "This page renders" is one honest step; a
+     * multi-role negotiation is fifteen. There is no target, and padding toward one
+     * produces the mechanical "Open X. Verify Y." shape that fills the field while
+     * encoding nothing the label did not already say.
+     */
+    steps?: string[];
+    /**
+     * The exact data the tester enters or selects, as flat key/value pairs.
+     *
+     * 🛑 WHY THIS IS NOT JUST PROSE
+     *
+     * "Enter 780, the listed price is 999" reads fine and still lets two testers type
+     * two different numbers, and gives an automated runner nothing to consume but a
+     * sentence. The steps say WHAT TO DO; this says WITH WHAT — so the procedure is
+     * repeatable by construction and a runner can fill a form from it directly.
+     *
+     * Flat and scalar on purpose: nested objects invite a shape nobody validates, and
+     * every real value here is a string, number or boolean.
+     *
+     * Omitted entirely by a case that enters nothing — a read-only page has no inputs.
+     */
+    inputs?: Record<string, string | number | boolean>;
+    /**
+     * What the system must DO — the functional outcome, including side effects no
+     * screen shows (a notification sent, stock decremented, an order created).
+     *
+     * Kept apart from `expectedUiState` because the gap between them is a real bug
+     * class: the write succeeds and the screen never updates.
+     */
+    expectedBehaviour?: string;
+    /**
+     * What the tester must SEE — exact on-screen text and control states.
+     *
+     * Quote the screen ("the button reads 'Offer sent'"), never "the UI updates
+     * correctly", which cannot be checked against a screenshot. This is what makes
+     * the mandatory screenshot reviewable: the image is compared to a written
+     * claim instead of to a guess about what "works" looked like.
+     */
+    expectedUiState?: string;
+    /**
+     * The values that must be CORRECT afterwards, as flat key/value pairs.
+     *
+     * `expectedUiState` settles what the screen looks like; this settles whether the
+     * data behind it is right. The two are different questions, and a screen can be
+     * entirely plausible over a wrong number — which is most of this codebase's bug
+     * history, where a defect returns HTTP 200 with believable rows.
+     *
+     * Machine-readable so a runner asserts against it rather than re-reading English,
+     * and so "it looked right" becomes a comparison.
+     *
+     * Omitted by a case with nothing checkable behind the screen.
+     */
+    expectedData?: Record<string, string | number | boolean>;
+    /**
+     * What is still true after a RELOAD — the persistence oracle.
+     *
+     * Several of the worst bugs here returned a normal 200, rendered
+     * optimistically, and wrote nothing (the grouped-listing rename, the dropped
+     * address landmark). Reloading is the only thing that catches them. Where a
+     * case genuinely persists nothing, say so explicitly rather than leaving the
+     * field to mean two different things.
+     */
+    endResult?: string;
     href?: string;
     order: number;
     phase: number;
@@ -48,6 +143,20 @@ export interface BugHunterLeaderboardEntry {
 }
 export declare function slugifyChecklistLabel(label: string): string;
 export declare function createChecklistItemId(groupKey: string, pageKey: string, label: string): string;
+/**
+ * Whose point of view a checklist case is written from.
+ *
+ * `guest` is a real role, not the absence of one — a signed-out visitor sees a
+ * sign-in prompt where a buyer sees a wishlist heart, and that path had never
+ * been exercised before this field existed.
+ *
+ * `seller` means the seller who OWNS the listing under test. A different
+ * seller looking at someone else's listing is a `buyer` for that case — the
+ * distinction matters because the owning seller is precisely who must NOT see
+ * Make Offer.
+ */
+export declare const TESTER_CASE_ROLES: readonly ["guest", "buyer", "seller", "admin", "employee"];
+export type TesterCaseRole = (typeof TESTER_CASE_ROLES)[number];
 export type TesterAnswer = "yes" | "no";
 export type TesterFeedbackStatus = "new" | "reviewed";
 export interface TesterChecklistResponseDocument extends BaseDocument {

package/dist/features/tester/schemas/firestore.js

@@ -42,6 +42,20 @@ export function slugifyChecklistLabel(label) {
 export function createChecklistItemId(groupKey, pageKey, label) {
     return generateChecklistItemId({ groupKey, pageKey, label });
 }
+// --- Checklist response (tester answers) --------------------------------------
+/**
+ * Whose point of view a checklist case is written from.
+ *
+ * `guest` is a real role, not the absence of one — a signed-out visitor sees a
+ * sign-in prompt where a buyer sees a wishlist heart, and that path had never
+ * been exercised before this field existed.
+ *
+ * `seller` means the seller who OWNS the listing under test. A different
+ * seller looking at someone else's listing is a `buyer` for that case — the
+ * distinction matters because the owning seller is precisely who must NOT see
+ * Make Offer.
+ */
+export const TESTER_CASE_ROLES = ["guest", "buyer", "seller", "admin", "employee"];
 export const TESTER_CHECKLIST_RESPONSE_COLLECTION = "testerChecklistResponses";
 export const TESTER_CHECKLIST_RESPONSE_INDEXED_FIELDS = [
     "testerId",

package/dist/features/tester/seed-data/_money-flows.d.ts

@@ -0,0 +1,23 @@
+import type { TesterCaseRole } from "../schemas";
+interface MoneyFlowCase {
+    key: string;
+    label: string;
+    /** Every role the case affects; per-role detail goes inline in the expectations. */
+    roles: TesterCaseRole[];
+    startPage?: string;
+    steps: string[];
+    inputs?: Record<string, string | number | boolean>;
+    expectedBehaviour: string;
+    expectedUiState: string;
+    expectedData?: Record<string, string | number | boolean>;
+    endResult: string;
+    href?: string;
+}
+interface MoneyFlowPage {
+    pageKey: string;
+    pageLabel: string;
+    href?: string;
+    cases: MoneyFlowCase[];
+}
+export declare const moneyFlowsPages: MoneyFlowPage[];
+export {};