@stapel/listings-react 0.1.0

package/dist/model/status.d.ts

@@ -0,0 +1,117 @@
+/**
+ * TWO AXES, BOTH ON SCREEN, NEITHER STANDING IN FOR THE OTHER.
+ *
+ * `status` (nine states) is the lifecycle and the ONLY thing that decides
+ * whether a listing is public: `Listing.objects.published()` filters on it
+ * alone, `INDEXED_STATUSES` is `{published}`, and the model says so out loud
+ * ("no visibility-reads-moderation_status coupling", `models.py`).
+ * `moderation_status` (four states) is the content verdict and decides
+ * NOTHING about visibility.
+ *
+ * Since stapel-listings 0.5.0 the two genuinely diverge, and that divergence
+ * is the reason this file exists:
+ *
+ *   first publication      status draft   → PENDING,   moderation → pending
+ *                          (nothing public until a verdict arrives)
+ *   editing a LIVE listing status published (UNCHANGED), moderation → pending
+ *                          (the edit is visible immediately; a rejecting
+ *                           verdict later lands as PUBLISHED → BLOCKED)
+ *
+ * A dashboard that computed "under re-review" from `status` would show
+ * nothing at all for the second row — the listing looks exactly as it did —
+ * and the owner would never learn their edit is being screened. A dashboard
+ * that computed "visible" from `moderation_status` would tell them their live
+ * listing is offline while strangers are reading it. Both mistakes are one
+ * `if` away, which is why the sentence a person reads is produced HERE, from
+ * BOTH fields, once.
+ *
+ * Everything below is pure: no React, no antd, no fetch. `test/status.test.ts`
+ * asserts the whole 9 × 4 table, so a state added upstream is a red test and
+ * not a bare enum value on a page.
+ */
+import type { ListingLifecycleStatus, ListingModerationStatus } from "../api/types.js";
+/**
+ * How a status should READ, independent of the words: neutral (nothing is
+ * happening), waiting (something is in progress and needs no action), good
+ * (live), warning (the owner has something to do), stopped (the listing is
+ * over, by choice or by verdict).
+ *
+ * A tone rather than a colour: `/default` maps it to antd tags, another skin
+ * maps it to whatever it maps it to, and the token layer stays the only place
+ * a hex exists.
+ */
+export type ListingStatusTone = "neutral" | "waiting" | "good" | "warning" | "stopped";
+/** The lifecycle half of what a person is told. */
+export interface LifecycleCaption {
+    readonly status: ListingLifecycleStatus;
+    readonly labelKey: string;
+    readonly tone: ListingStatusTone;
+    /** Is the listing readable by a stranger right now? `published` and
+     * nothing else — the same predicate the queryset uses. */
+    readonly publiclyVisible: boolean;
+}
+/** The lifecycle caption for one status. */
+export declare function lifecycleCaption(status: ListingLifecycleStatus): LifecycleCaption;
+/**
+ * Is this listing readable by someone who is not its owner?
+ *
+ * One predicate, one field, matching the server's. Exported because the
+ * DETAIL read needs it and cannot get it from a 404: `GET /listings/{pk}/`
+ * has no `published()` filter on its queryset, so a draft answers 200 to a
+ * stranger who knows the id (upstream note in MODULE.md). The pair reports
+ * the fact instead of rendering a draft as if it were a shop window.
+ */
+export declare function isPubliclyVisible(status: ListingLifecycleStatus): boolean;
+/** The owner-facing note about the moderation axis, when there is one. */
+export interface ModerationNotice {
+    readonly moderationStatus: ListingModerationStatus;
+    readonly messageKey: string;
+    readonly tone: ListingStatusTone;
+    /**
+     * Is the listing live WHILE this verdict is pending? True only for the
+     * re-moderation row — a published listing whose edit is being screened.
+     * The sentence differs from a first submission's precisely here.
+     */
+    readonly liveDuringReview: boolean;
+}
+/**
+ * What to say about the moderation axis, given BOTH fields.
+ *
+ * `undefined` means "nothing to add": an approved listing needs no note, and
+ * neither does a draft nobody has submitted. Every other combination has a
+ * sentence, including the ones that look contradictory — those are the ones
+ * worth naming.
+ */
+export declare function moderationNotice(status: ListingLifecycleStatus, moderationStatus: ListingModerationStatus): ModerationNotice | undefined;
+/** Both halves at once — what a dashboard row and a detail header render. */
+export interface ListingStatusView {
+    readonly lifecycle: LifecycleCaption;
+    readonly moderation: ModerationNotice | undefined;
+    /** True when the two axes disagree in the way 0.5.0 made possible: live to
+     * the public, under review for its owner. The one combination a host is
+     * most likely to get wrong, so it is a named boolean and not an inference
+     * a caller repeats. */
+    readonly liveUnderReview: boolean;
+    /** What the owner can do next, in lifecycle terms — see
+     * {@link LISTING_TRANSITIONS}. */
+    readonly allowedTransitions: readonly ListingLifecycleStatus[];
+}
+export declare function listingStatusView(status: ListingLifecycleStatus, moderationStatus: ListingModerationStatus): ListingStatusView;
+/**
+ * The dashboard tabs, and the statuses each one folds together.
+ *
+ * The grouping is the SERVER's (`views.my_counters`), copied here so a tab's
+ * caption and its count cannot describe different sets: `active` includes
+ * PENDING beside PUBLISHED, and `drafts` includes REJECTED beside DRAFT —
+ * both because a listing in those states is something the owner is still
+ * working on. A client that grouped them its own way would show "3 active"
+ * over two rows.
+ */
+export declare const MY_LISTINGS_TABS: readonly ["active", "drafts", "archived"];
+export type MyListingsTab = (typeof MY_LISTINGS_TABS)[number];
+export declare const MY_LISTINGS_TAB_STATUSES: Readonly<Record<MyListingsTab, readonly ListingLifecycleStatus[]>>;
+/** Which tab a listing belongs to, or `undefined` for BLOCKED — the one
+ * status `my/counters` counts in no tab at all. A dashboard that silently
+ * dropped it would hide exactly the listing whose owner most needs to know. */
+export declare function tabOf(status: ListingLifecycleStatus): MyListingsTab | undefined;
+//# sourceMappingURL=status.d.ts.map

package/dist/model/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/model/status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,KAAK,EACV,sBAAsB,EACtB,uBAAuB,EACxB,MAAM,iBAAiB,CAAC;AAIzB;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GACzB,SAAS,GACT,SAAS,GACT,MAAM,GACN,SAAS,GACT,SAAS,CAAC;AAEd,mDAAmD;AACnD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC;8DAC0D;IAC1D,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;CACnC;AAoDD,4CAA4C;AAC5C,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,sBAAsB,GAC7B,gBAAgB,CAElB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAEzE;AAED,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,gBAAgB,EAAE,uBAAuB,CAAC;IACnD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,IAAI,EAAE,iBAAiB,CAAC;IACjC;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;CACpC;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,sBAAsB,EAC9B,gBAAgB,EAAE,uBAAuB,GACxC,gBAAgB,GAAG,SAAS,CA0D9B;AAED,6EAA6E;AAC7E,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,gBAAgB,CAAC;IACrC,QAAQ,CAAC,UAAU,EAAE,gBAAgB,GAAG,SAAS,CAAC;IAClD;;;2BAGuB;IACvB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC;sCACkC;IAClC,QAAQ,CAAC,kBAAkB,EAAE,SAAS,sBAAsB,EAAE,CAAC;CAChE;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,sBAAsB,EAC9B,gBAAgB,EAAE,uBAAuB,GACxC,iBAAiB,CAQnB;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,gBAAgB,2CAA4C,CAAC;AAE1E,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAE9D,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAC7C,MAAM,CAAC,aAAa,EAAE,SAAS,sBAAsB,EAAE,CAAC,CAKzD,CAAC;AAEF;;+EAE+E;AAC/E,wBAAgB,KAAK,CACnB,MAAM,EAAE,sBAAsB,GAC7B,aAAa,GAAG,SAAS,CAK3B"}

package/dist/model/status.js

@@ -0,0 +1,164 @@
+import { LISTING_TRANSITIONS } from "./transitions.js";
+import { LISTINGS_I18N_KEYS } from "../i18n/keys.js";
+const LIFECYCLE = {
+    draft: {
+        labelKey: LISTINGS_I18N_KEYS.statusDraft,
+        tone: "neutral",
+        publiclyVisible: false,
+    },
+    pending: {
+        labelKey: LISTINGS_I18N_KEYS.statusPending,
+        tone: "waiting",
+        publiclyVisible: false,
+    },
+    published: {
+        labelKey: LISTINGS_I18N_KEYS.statusPublished,
+        tone: "good",
+        publiclyVisible: true,
+    },
+    paused: {
+        labelKey: LISTINGS_I18N_KEYS.statusPaused,
+        tone: "neutral",
+        publiclyVisible: false,
+    },
+    expired: {
+        labelKey: LISTINGS_I18N_KEYS.statusExpired,
+        tone: "warning",
+        publiclyVisible: false,
+    },
+    sold: {
+        labelKey: LISTINGS_I18N_KEYS.statusSold,
+        tone: "stopped",
+        publiclyVisible: false,
+    },
+    rejected: {
+        labelKey: LISTINGS_I18N_KEYS.statusRejected,
+        tone: "warning",
+        publiclyVisible: false,
+    },
+    blocked: {
+        labelKey: LISTINGS_I18N_KEYS.statusBlocked,
+        tone: "stopped",
+        publiclyVisible: false,
+    },
+    archived: {
+        labelKey: LISTINGS_I18N_KEYS.statusArchived,
+        tone: "neutral",
+        publiclyVisible: false,
+    },
+};
+/** The lifecycle caption for one status. */
+export function lifecycleCaption(status) {
+    return { status, ...LIFECYCLE[status] };
+}
+/**
+ * Is this listing readable by someone who is not its owner?
+ *
+ * One predicate, one field, matching the server's. Exported because the
+ * DETAIL read needs it and cannot get it from a 404: `GET /listings/{pk}/`
+ * has no `published()` filter on its queryset, so a draft answers 200 to a
+ * stranger who knows the id (upstream note in MODULE.md). The pair reports
+ * the fact instead of rendering a draft as if it were a shop window.
+ */
+export function isPubliclyVisible(status) {
+    return LIFECYCLE[status].publiclyVisible;
+}
+/**
+ * What to say about the moderation axis, given BOTH fields.
+ *
+ * `undefined` means "nothing to add": an approved listing needs no note, and
+ * neither does a draft nobody has submitted. Every other combination has a
+ * sentence, including the ones that look contradictory — those are the ones
+ * worth naming.
+ */
+export function moderationNotice(status, moderationStatus) {
+    const live = status === "published";
+    if (moderationStatus === "approved") {
+        // A takedown keeps `approved` on the moderation axis in some flows (the
+        // lifecycle moved, the verdict did not), so an approved BLOCKED listing
+        // still owes its owner an explanation — and it is the lifecycle's.
+        return undefined;
+    }
+    if (moderationStatus === "pending") {
+        if (live) {
+            return {
+                moderationStatus,
+                messageKey: LISTINGS_I18N_KEYS.moderationLiveEditPending,
+                tone: "waiting",
+                liveDuringReview: true,
+            };
+        }
+        if (status === "pending") {
+            return {
+                moderationStatus,
+                messageKey: LISTINGS_I18N_KEYS.moderationFirstReview,
+                tone: "waiting",
+                liveDuringReview: false,
+            };
+        }
+        // A draft/archived/sold row carrying a pending verdict: the submission
+        // was overtaken by a lifecycle move. Say that, rather than promising a
+        // review that will not put it back on the shelf.
+        return {
+            moderationStatus,
+            messageKey: LISTINGS_I18N_KEYS.moderationPendingOffline,
+            tone: "neutral",
+            liveDuringReview: false,
+        };
+    }
+    if (moderationStatus === "needs_review") {
+        return {
+            moderationStatus,
+            messageKey: live
+                ? LISTINGS_I18N_KEYS.moderationLiveNeedsReview
+                : LISTINGS_I18N_KEYS.moderationNeedsReview,
+            tone: "waiting",
+            liveDuringReview: live,
+        };
+    }
+    // rejected — and it matters whether the lifecycle followed the verdict.
+    return {
+        moderationStatus,
+        messageKey: live
+            ? LISTINGS_I18N_KEYS.moderationRejectedStillLive
+            : LISTINGS_I18N_KEYS.moderationRejected,
+        tone: "warning",
+        liveDuringReview: live,
+    };
+}
+export function listingStatusView(status, moderationStatus) {
+    const moderation = moderationNotice(status, moderationStatus);
+    return {
+        lifecycle: lifecycleCaption(status),
+        moderation,
+        liveUnderReview: moderation?.liveDuringReview === true,
+        allowedTransitions: LISTING_TRANSITIONS[status],
+    };
+}
+/**
+ * The dashboard tabs, and the statuses each one folds together.
+ *
+ * The grouping is the SERVER's (`views.my_counters`), copied here so a tab's
+ * caption and its count cannot describe different sets: `active` includes
+ * PENDING beside PUBLISHED, and `drafts` includes REJECTED beside DRAFT —
+ * both because a listing in those states is something the owner is still
+ * working on. A client that grouped them its own way would show "3 active"
+ * over two rows.
+ */
+export const MY_LISTINGS_TABS = ["active", "drafts", "archived"];
+export const MY_LISTINGS_TAB_STATUSES = {
+    active: ["published", "pending"],
+    drafts: ["draft", "rejected"],
+    archived: ["archived", "paused", "expired", "sold"],
+};
+/** Which tab a listing belongs to, or `undefined` for BLOCKED — the one
+ * status `my/counters` counts in no tab at all. A dashboard that silently
+ * dropped it would hide exactly the listing whose owner most needs to know. */
+export function tabOf(status) {
+    for (const tab of MY_LISTINGS_TABS) {
+        if (MY_LISTINGS_TAB_STATUSES[tab].includes(status))
+            return tab;
+    }
+    return undefined;
+}
+//# sourceMappingURL=status.js.map

package/dist/model/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","sourceRoot":"","sources":["../../src/model/status.ts"],"names":[],"mappings":"AAmCA,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AA6BrD,MAAM,SAAS,GAEX;IACF,KAAK,EAAE;QACL,QAAQ,EAAE,kBAAkB,CAAC,WAAW;QACxC,IAAI,EAAE,SAAS;QACf,eAAe,EAAE,KAAK;KACvB;IACD,OAAO,EAAE;QACP,QAAQ,EAAE,kBAAkB,CAAC,aAAa;QAC1C,IAAI,EAAE,SAAS;QACf,eAAe,EAAE,KAAK;KACvB;IACD,SAAS,EAAE;QACT,QAAQ,EAAE,kBAAkB,CAAC,eAAe;QAC5C,IAAI,EAAE,MAAM;QACZ,eAAe,EAAE,IAAI;KACtB;IACD,MAAM,EAAE;QACN,QAAQ,EAAE,kBAAkB,CAAC,YAAY;QACzC,IAAI,EAAE,SAAS;QACf,eAAe,EAAE,KAAK;KACvB;IACD,OAAO,EAAE;QACP,QAAQ,EAAE,kBAAkB,CAAC,aAAa;QAC1C,IAAI,EAAE,SAAS;QACf,eAAe,EAAE,KAAK;KACvB;IACD,IAAI,EAAE;QACJ,QAAQ,EAAE,kBAAkB,CAAC,UAAU;QACvC,IAAI,EAAE,SAAS;QACf,eAAe,EAAE,KAAK;KACvB;IACD,QAAQ,EAAE;QACR,QAAQ,EAAE,kBAAkB,CAAC,cAAc;QAC3C,IAAI,EAAE,SAAS;QACf,eAAe,EAAE,KAAK;KACvB;IACD,OAAO,EAAE;QACP,QAAQ,EAAE,kBAAkB,CAAC,aAAa;QAC1C,IAAI,EAAE,SAAS;QACf,eAAe,EAAE,KAAK;KACvB;IACD,QAAQ,EAAE;QACR,QAAQ,EAAE,kBAAkB,CAAC,cAAc;QAC3C,IAAI,EAAE,SAAS;QACf,eAAe,EAAE,KAAK;KACvB;CACF,CAAC;AAEF,4CAA4C;AAC5C,MAAM,UAAU,gBAAgB,CAC9B,MAA8B;IAE9B,OAAO,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;AAC1C,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAA8B;IAC9D,OAAO,SAAS,CAAC,MAAM,CAAC,CAAC,eAAe,CAAC;AAC3C,CAAC;AAeD;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAA8B,EAC9B,gBAAyC;IAEzC,MAAM,IAAI,GAAG,MAAM,KAAK,WAAW,CAAC;IAEpC,IAAI,gBAAgB,KAAK,UAAU,EAAE,CAAC;QACpC,wEAAwE;QACxE,wEAAwE;QACxE,mEAAmE;QACnE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,IAAI,gBAAgB,KAAK,SAAS,EAAE,CAAC;QACnC,IAAI,IAAI,EAAE,CAAC;YACT,OAAO;gBACL,gBAAgB;gBAChB,UAAU,EAAE,kBAAkB,CAAC,yBAAyB;gBACxD,IAAI,EAAE,SAAS;gBACf,gBAAgB,EAAE,IAAI;aACvB,CAAC;QACJ,CAAC;QACD,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YACzB,OAAO;gBACL,gBAAgB;gBAChB,UAAU,EAAE,kBAAkB,CAAC,qBAAqB;gBACpD,IAAI,EAAE,SAAS;gBACf,gBAAgB,EAAE,KAAK;aACxB,CAAC;QACJ,CAAC;QACD,uEAAuE;QACvE,uEAAuE;QACvE,iDAAiD;QACjD,OAAO;YACL,gBAAgB;YAChB,UAAU,EAAE,kBAAkB,CAAC,wBAAwB;YACvD,IAAI,EAAE,SAAS;YACf,gBAAgB,EAAE,KAAK;SACxB,CAAC;IACJ,CAAC;IAED,IAAI,gBAAgB,KAAK,cAAc,EAAE,CAAC;QACxC,OAAO;YACL,gBAAgB;YAChB,UAAU,EAAE,IAAI;gBACd,CAAC,CAAC,kBAAkB,CAAC,yBAAyB;gBAC9C,CAAC,CAAC,kBAAkB,CAAC,qBAAqB;YAC5C,IAAI,EAAE,SAAS;YACf,gBAAgB,EAAE,IAAI;SACvB,CAAC;IACJ,CAAC;IAED,wEAAwE;IACxE,OAAO;QACL,gBAAgB;QAChB,UAAU,EAAE,IAAI;YACd,CAAC,CAAC,kBAAkB,CAAC,2BAA2B;YAChD,CAAC,CAAC,kBAAkB,CAAC,kBAAkB;QACzC,IAAI,EAAE,SAAS;QACf,gBAAgB,EAAE,IAAI;KACvB,CAAC;AACJ,CAAC;AAgBD,MAAM,UAAU,iBAAiB,CAC/B,MAA8B,EAC9B,gBAAyC;IAEzC,MAAM,UAAU,GAAG,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC9D,OAAO;QACL,SAAS,EAAE,gBAAgB,CAAC,MAAM,CAAC;QACnC,UAAU;QACV,eAAe,EAAE,UAAU,EAAE,gBAAgB,KAAK,IAAI;QACtD,kBAAkB,EAAE,mBAAmB,CAAC,MAAM,CAAC;KAChD,CAAC;AACJ,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAU,CAAC;AAI1E,MAAM,CAAC,MAAM,wBAAwB,GAEjC;IACF,MAAM,EAAE,CAAC,WAAW,EAAE,SAAS,CAAC;IAChC,MAAM,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC;IAC7B,QAAQ,EAAE,CAAC,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,CAAC;CACpD,CAAC;AAEF;;+EAE+E;AAC/E,MAAM,UAAU,KAAK,CACnB,MAA8B;IAE9B,KAAK,MAAM,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACnC,IAAI,wBAAwB,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC;YAAE,OAAO,GAAG,CAAC;IACjE,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC"}

package/dist/model/transitions.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The lifecycle whitelist, mirrored from `stapel_listings.models
+ * .LISTING_TRANSITIONS`.
+ *
+ * ── A mirror, not a verdict ────────────────────────────────────────────────
+ *
+ * The server decides. `transition_to` raises `TransitionError` and the view
+ * answers **409 `error.409.invalid_listing_transition`** with
+ * `params.from_status`, and that refusal is rendered as the named sentence it
+ * is. What the mirror buys is the difference between a button that is there
+ * and does nothing and a button that is switched off WITH its reason: "you
+ * cannot mark a draft sold — publish it first" beats a 409 toast after the
+ * click, and beats a hidden control (which teaches nothing) by the whole
+ * private-space canon §6.3.
+ *
+ * The mirror is deliberately CONSERVATIVE in one direction only: it may never
+ * block something the server would allow. That is why it is a copy of the
+ * table rather than a hand-written summary of it, and why `test/status.test
+ * .ts` walks every source state.
+ *
+ * Two entries look odd and are correct:
+ *  - `published → blocked` exists, but the owner API has no route to it: only
+ *    `apply_moderation("rejected")` walks it. It is in the table because the
+ *    table is the model's, and leaving it out would make the mirror a
+ *    paraphrase.
+ *  - `blocked → published` is reinstatement after a successful appeal, also
+ *    moderation-driven. `archive` and `complete` are the only two transitions
+ *    this pair's API can actually request.
+ */
+import type { ListingLifecycleStatus } from "../api/types.js";
+export declare const LISTING_TRANSITIONS: Readonly<Record<ListingLifecycleStatus, readonly ListingLifecycleStatus[]>>;
+/** Would the server accept this move? A same-status move is a no-op the
+ * server returns early on, so it counts as allowed. */
+export declare function canTransition(from: ListingLifecycleStatus, to: ListingLifecycleStatus): boolean;
+/**
+ * Deleting is not a transition and has its own rule
+ * (`views.destroy`): a PUBLISHED or PENDING listing is refused with
+ * `error.409.listing_cannot_delete_active` — archive it first.
+ */
+export declare function canDelete(status: ListingLifecycleStatus): boolean;
+//# sourceMappingURL=transitions.d.ts.map

package/dist/model/transitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transitions.d.ts","sourceRoot":"","sources":["../../src/model/transitions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAC;AAE9D,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CACxC,MAAM,CAAC,sBAAsB,EAAE,SAAS,sBAAsB,EAAE,CAAC,CAWlE,CAAC;AAEF;uDACuD;AACvD,wBAAgB,aAAa,CAC3B,IAAI,EAAE,sBAAsB,EAC5B,EAAE,EAAE,sBAAsB,GACzB,OAAO,CAET;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,sBAAsB,GAAG,OAAO,CAEjE"}

package/dist/model/transitions.js

@@ -0,0 +1,25 @@
+export const LISTING_TRANSITIONS = {
+    draft: ["pending", "archived"],
+    pending: ["published", "rejected", "draft", "archived"],
+    published: ["paused", "expired", "sold", "blocked", "archived"],
+    blocked: ["published", "draft", "archived"],
+    paused: ["published", "archived", "expired"],
+    expired: ["pending", "published", "archived"],
+    sold: ["archived", "published"],
+    rejected: ["draft", "archived"],
+    archived: ["draft"],
+};
+/** Would the server accept this move? A same-status move is a no-op the
+ * server returns early on, so it counts as allowed. */
+export function canTransition(from, to) {
+    return from === to || LISTING_TRANSITIONS[from].includes(to);
+}
+/**
+ * Deleting is not a transition and has its own rule
+ * (`views.destroy`): a PUBLISHED or PENDING listing is refused with
+ * `error.409.listing_cannot_delete_active` — archive it first.
+ */
+export function canDelete(status) {
+    return status !== "published" && status !== "pending";
+}
+//# sourceMappingURL=transitions.js.map

package/dist/model/transitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transitions.js","sourceRoot":"","sources":["../../src/model/transitions.ts"],"names":[],"mappings":"AA+BA,MAAM,CAAC,MAAM,mBAAmB,GAE5B;IACF,KAAK,EAAE,CAAC,SAAS,EAAE,UAAU,CAAC;IAC9B,OAAO,EAAE,CAAC,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,UAAU,CAAC;IACvD,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,CAAC;IAC/D,OAAO,EAAE,CAAC,WAAW,EAAE,OAAO,EAAE,UAAU,CAAC;IAC3C,MAAM,EAAE,CAAC,WAAW,EAAE,UAAU,EAAE,SAAS,CAAC;IAC5C,OAAO,EAAE,CAAC,SAAS,EAAE,WAAW,EAAE,UAAU,CAAC;IAC7C,IAAI,EAAE,CAAC,UAAU,EAAE,WAAW,CAAC;IAC/B,QAAQ,EAAE,CAAC,OAAO,EAAE,UAAU,CAAC;IAC/B,QAAQ,EAAE,CAAC,OAAO,CAAC;CACpB,CAAC;AAEF;uDACuD;AACvD,MAAM,UAAU,aAAa,CAC3B,IAA4B,EAC5B,EAA0B;IAE1B,OAAO,IAAI,KAAK,EAAE,IAAI,mBAAmB,CAAC,IAAI,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;AAC/D,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,MAA8B;IACtD,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,KAAK,SAAS,CAAC;AACxD,CAAC"}

package/dist/model/validation.d.ts

@@ -0,0 +1,135 @@
+/**
+ * What the composer knows before it asks, and what it does with the answer.
+ *
+ * Three jobs, and the boundaries between them are the point:
+ *
+ * 1. **The mirror.** Feature values are mirrored by
+ *    `@stapel/attributes-react`'s `mirrorValidate` — the engine's own rules,
+ *    the engine's own error keys, one implementation. This module adds only
+ *    the checks that belong to LISTINGS rather than to a value type: the
+ *    description length bounds and the price shape. Nothing here is a
+ *    verdict; the server re-runs all of it.
+ *
+ * 2. **The split of the publish 400.** `POST /{pk}/publish/` answers a bad
+ *    draft with a BARE `ValidationBatchResult` — no `localizable_error`, no
+ *    envelope — so core wraps it as `stapel.http.400` with the batch sitting
+ *    on `StapelApiError.body`. A promotion that fails afterwards answers the
+ *    ordinary envelope (`error.400.publish_validation_failed`, or
+ *    `error.400.image_required` where the deployment requires a photo). Two
+ *    different 400s that mean different things; `publishRefusal` is the one
+ *    place that tells them apart.
+ *
+ * 3. **Routing a refusal onto the control that caused it.**
+ *    `featureErrorsBySlug` (attributes-react) adds the `field` param the
+ *    fleet's `useFieldError` convention routes on — the engine sends
+ *    `{feature, slug}` and never `field`. Listing-level rows (the
+ *    description, which the batch carries under the slug `"description"`)
+ *    are lifted out to their own control here.
+ *
+ * ── The mirror's ceilings are CONFIGURABLE, and that is not a nicety ───────
+ *
+ * `DESCRIPTION_MIN_LENGTH` / `DESCRIPTION_MAX_LENGTH` are `STAPEL_LISTINGS`
+ * settings a deployment moves (`conf.py`). A hardcoded 4/500 would refuse a
+ * perfectly valid submission on a host that widened them — and the server
+ * would never even hear about the refusal, so there would be nothing to
+ * appeal to. Same rule the cdn pair wrote down: **the mirror may not refuse
+ * what the server would accept.**
+ */
+import { StapelApiError } from "@stapel/core";
+import type { FlowError } from "@stapel/core";
+import type { FeatureDef, FeaturesDto, FeatureValidationResult, ValidationBatchResult } from "@stapel/attributes-react";
+import type { ListingDraftValues } from "./draft.js";
+/**
+ * The deployment's own ceilings, mirrored client-side.
+ *
+ * Defaults are the LIBRARY defaults from `stapel_listings/conf.py`; a host
+ * whose settings differ passes its own through `createListingsRuntime`.
+ */
+export interface ListingDraftLimits {
+    /** `STAPEL_LISTINGS["DESCRIPTION_MIN_LENGTH"]`. */
+    readonly descriptionMin: number;
+    /** `STAPEL_LISTINGS["DESCRIPTION_MAX_LENGTH"]`. */
+    readonly descriptionMax: number;
+    /** `Listing.title` is `max_length=255` — a MODEL constraint, so it moves
+     * only with a migration, but mirrored from the schema all the same. */
+    readonly titleMax: number;
+    /** How many photos a gallery may carry. stapel-cdn has no opinion and
+     * stapel-listings stores an unbounded list; the storefront's ceiling is 10
+     * (spec §4.1), which makes it the PAIR's rule — hence a setting and not a
+     * constant, and hence a refusal in this pair's own namespace. */
+    readonly maxImages: number;
+    /** `STAPEL_LISTINGS["REQUIRE_IMAGE_ON_PUBLISH"]` — library default `True`.
+     * The server raises a bare `ValidationError` for it, which the view turns
+     * into `error.400.publish_validation_failed`; mirroring it lets the
+     * composer say WHICH thing is missing before the round trip. */
+    readonly requireImageOnPublish: boolean;
+}
+export declare const DEFAULT_DRAFT_LIMITS: ListingDraftLimits;
+/** The slug the description's refusal is filed under — the engine files it
+ * the same way (`validate_description` returns a `FeatureValidationResult`
+ * whose slug is not a feature's), so the composer has one routing table. */
+export declare const DESCRIPTION_FIELD = "description";
+export declare const TITLE_FIELD = "title";
+export declare const PRICE_FIELD = "price";
+export declare const IMAGES_FIELD = "images";
+export declare const CATEGORY_FIELD = "category_id";
+/**
+ * The listing-level half of the mirror: everything that is not a feature
+ * value. Returns refusals keyed by control, empty when nothing is wrong.
+ *
+ * Note what is NOT judged: a missing title, a missing price and a missing
+ * location. The server accepts a published listing without any of them
+ * (`publish_listing` promotes `title_draft or title` and leaves the rest),
+ * so refusing them here would block a submission the backend would take. A
+ * skin may still *encourage* them; that is copy, not a gate.
+ */
+export declare function mirrorListingFields(values: ListingDraftValues, limits: ListingDraftLimits): Readonly<Record<string, FlowError>>;
+/**
+ * The whole mirror: listing fields + feature values, in one routing table.
+ *
+ * Feature refusals go through `featureErrorsBySlug`, so a mirrored "too long"
+ * and a server "too long" render the SAME sentence from the SAME key — they
+ * are the same key, because the mirror speaks the engine's vocabulary.
+ */
+export declare function mirrorDraft(values: ListingDraftValues, features: readonly FeatureDef[], featuresDto: FeaturesDto, limits: ListingDraftLimits): Readonly<Record<string, FlowError>>;
+/** Is this batch clean? `valid` is the server's own summary; a caller that
+ * recomputed it from `results` could disagree with the field the API sends. */
+export declare function isBatchValid(batch: ValidationBatchResult): boolean;
+/** What a failed publish actually was. */
+export type PublishRefusal = {
+    /** The draft did not validate: per-control refusals, already routed. */
+    readonly kind: "invalid_draft";
+    readonly batch: ValidationBatchResult;
+    readonly fieldErrors: Readonly<Record<string, FlowError>>;
+} | {
+    /** Anything else the server said, in the ordinary error dialect — a
+     * missing photo, a 403 on somebody else's listing, a 503. */
+    readonly kind: "error";
+    readonly error: StapelApiError;
+};
+/**
+ * Split a thrown publish failure into its two meanings.
+ *
+ * The check is on the BODY, not on the status: a 400 whose body is a batch is
+ * a per-field verdict, and a 400 whose body is an envelope is a sentence. A
+ * caller that branched on `status === 400` alone would put
+ * `error.400.image_required` under a feature control.
+ */
+export declare function publishRefusal(thrown: unknown): PublishRefusal;
+/**
+ * A server batch → refusals keyed by CONTROL.
+ *
+ * One call, because the server already keys everything the way the composer
+ * does. `services.publish.validate_draft` inserts `validate_description`'s
+ * row at the FRONT of the same list, and that row's slug is literally
+ * `"description"` (`stapel_attributes/validation.py:726`) — the same key
+ * {@link DESCRIPTION_FIELD} names and the same key the mirror files its own
+ * length refusal under. So the description's control receives the server's
+ * verdict and the mirror's through one lookup, and neither can land in a
+ * page-level banner because nothing routed it.
+ */
+export declare function listingFieldErrors(batch: ValidationBatchResult): Readonly<Record<string, FlowError>>;
+/** The rows of a batch that failed, in the order the server sent them —
+ * for a summary line above the form ("3 details need attention"). */
+export declare function failedResults(batch: ValidationBatchResult): readonly FeatureValidationResult[];
+//# sourceMappingURL=validation.d.ts.map

package/dist/model/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/model/validation.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,OAAO,EAAE,cAAc,EAAoB,MAAM,cAAc,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EACX,uBAAuB,EACvB,qBAAqB,EACtB,MAAM,0BAA0B,CAAC;AAOlC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAErD;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IACjC,mDAAmD;IACnD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,mDAAmD;IACnD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC;2EACuE;IACvE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;qEAGiE;IACjE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;oEAGgE;IAChE,QAAQ,CAAC,qBAAqB,EAAE,OAAO,CAAC;CACzC;AAED,eAAO,MAAM,oBAAoB,EAAE,kBAMlC,CAAC;AAEF;;4EAE4E;AAC5E,eAAO,MAAM,iBAAiB,gBAAgB,CAAC;AAC/C,eAAO,MAAM,WAAW,UAAU,CAAC;AACnC,eAAO,MAAM,WAAW,UAAU,CAAC;AACnC,eAAO,MAAM,YAAY,WAAW,CAAC;AACrC,eAAO,MAAM,cAAc,gBAAgB,CAAC;AAU5C;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,kBAAkB,GACzB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAmDrC;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,SAAS,UAAU,EAAE,EAC/B,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,kBAAkB,GACzB,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAKrC;AAED;+EAC+E;AAC/E,wBAAgB,YAAY,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAElE;AAQD,0CAA0C;AAC1C,MAAM,MAAM,cAAc,GACtB;IACE,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;IACtC,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;CAC3D,GACD;IACE;iEAC6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,cAAc,CAAC;CAChC,CAAC;AAEN;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,OAAO,GAAG,cAAc,CAoB9D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,qBAAqB,GAC3B,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,CAErC;AAED;qEACqE;AACrE,wBAAgB,aAAa,CAC3B,KAAK,EAAE,qBAAqB,GAC3B,SAAS,uBAAuB,EAAE,CAEpC"}