@stapel/reviews-react 0.1.0

package/dist/model/list.js

@@ -0,0 +1,60 @@
+/**
+ * Flatten the pages of the infinite list into one newest-first run.
+ *
+ * Deliberately takes `InfiniteData | undefined` and answers `undefined` for
+ * "not loaded", never `[]`: an empty array here is a claim that the target
+ * has no reviews, and the caller must get that claim from a READY load state
+ * (`stapel/no-flattened-load-state` — the rule exists because a total outage
+ * once rendered as "you have no workspaces").
+ */
+export function reviewsFromPages(data) {
+    if (data === undefined)
+        return undefined;
+    return data.pages.flatMap((page) => page.items);
+}
+/**
+ * A review's visibility, narrowed — with a fourth arm for a state this build
+ * does not know.
+ *
+ * `status` is a bare `string` on the wire. A build that met a new upstream
+ * state and silently rendered it as published would be showing something the
+ * server may have hidden; one that crashed on it would take the page down.
+ * `"unknown"` is neither: the skin shows the row with an explicit "this
+ * version does not know this state" badge, the same shape attributes-react
+ * uses for an unsupported feature type.
+ */
+export function reviewVisibility(status) {
+    return status === "published" || status === "pending" || status === "hidden"
+        ? status
+        : "unknown";
+}
+/** Is this row one a moderator sees only because they asked for `include=all`? */
+export function isModeratedOut(review) {
+    return reviewVisibility(review.status) !== "published";
+}
+/**
+ * The viewer's own review of this target, if it is in the loaded rows.
+ *
+ * THIS IS AN OPTIMISTIC PRE-CHECK, AND IT HAS A KNOWN HOLE — recorded here
+ * because the hole is in the contract, not in the code. The list a
+ * non-moderator reads is published-only, so under `moderation: "pre"` the
+ * author's own review is INVISIBLE TO ITS AUTHOR while it waits: this
+ * function answers `undefined`, the form offers itself again, and the server
+ * refuses the second attempt with `error.400.reviews_duplicate_review`.
+ *
+ * That is why the refusal is a first-class outcome of the form
+ * (`headless/ReviewForm.tsx`) rather than something the pre-check was
+ * supposed to prevent. The pre-check saves a pointless round trip in the
+ * common (post-moderation) case; it is never the authority.
+ *
+ * `viewerId` must be the id the backend puts in `author_id` — the user id,
+ * NOT a profile id. A host that passes the wrong one gets `undefined`, i.e.
+ * the form offered where it need not have been, and the server still holds
+ * the line.
+ */
+export function findOwnReview(reviews, viewerId) {
+    if (reviews === undefined || !viewerId)
+        return undefined;
+    return reviews.find((review) => review.author_id === viewerId);
+}
+//# sourceMappingURL=list.js.map

package/dist/model/list.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.js","sourceRoot":"","sources":["../../src/model/list.ts"],"names":[],"mappings":"AAOA;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAA8D;IAE9D,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACzC,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,gBAAgB,CAC9B,MAAc;IAEd,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,KAAK,SAAS,IAAI,MAAM,KAAK,QAAQ;QAC1E,CAAC,CAAC,MAAM;QACR,CAAC,CAAC,SAAS,CAAC;AAChB,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,cAAc,CAAC,MAAc;IAC3C,OAAO,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,WAAW,CAAC;AACzD,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,aAAa,CAC3B,OAAsC,EACtC,QAAmC;IAEnC,IAAI,OAAO,KAAK,SAAS,IAAI,CAAC,QAAQ;QAAE,OAAO,SAAS,CAAC;IACzD,OAAO,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,SAAS,KAAK,QAAQ,CAAC,CAAC;AACjE,CAAC"}

package/dist/model/mutations.d.ts

@@ -0,0 +1,32 @@
+import type { UseMutationResult } from "@tanstack/react-query";
+import type { StapelApiError } from "@stapel/core";
+import type { Review, ReviewTarget } from "../api/types.js";
+/** What {@link useSubmitReview} is called with. */
+export interface SubmitReviewVariables {
+    /** Inside the deployment's `[RATING_MIN, RATING_MAX]`; the server decides. */
+    readonly rating: number;
+    /** Optional — a rating with no words is a complete review here. */
+    readonly body?: string;
+}
+/**
+ * Write a review of a target (frontend-standard §2 — mutations invalidate on
+ * success).
+ *
+ * ── Why the answer is invalidated rather than spliced in ───────────────────
+ *
+ * The created row comes back with its `status`, and under the module's
+ * default (`MODERATION_DEFAULT: "post"`) that is `published` — so pushing it
+ * into the cached window would be correct. Under `moderation: "pre"` it is
+ * `pending`, and the SAME row must NOT appear in the list, because the list
+ * this reader sees is published-only and a locally-spliced pending review
+ * would vanish on the next refetch with no explanation.
+ *
+ * One behaviour for both policies, and the policy is not visible to the
+ * client (no endpoint reports it): invalidate, let the server say what is
+ * visible, and carry the created row separately as the SUBMISSION's outcome
+ * (`headless/ReviewForm.tsx` renders "sent, awaiting moderation" off its
+ * `status`). The aggregate moves for the same reason and is invalidated with
+ * it — `avg` and `count` only count published rows.
+ */
+export declare function useSubmitReview(target: ReviewTarget): UseMutationResult<Review, StapelApiError, SubmitReviewVariables>;
+//# sourceMappingURL=mutations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.d.ts","sourceRoot":"","sources":["../../src/model/mutations.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAsB,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AACnF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAI5D,mDAAmD;AACnD,MAAM,WAAW,qBAAqB;IACpC,8EAA8E;IAC9E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,mEAAmE;IACnE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,eAAe,CAC7B,MAAM,EAAE,YAAY,GACnB,iBAAiB,CAAC,MAAM,EAAE,cAAc,EAAE,qBAAqB,CAAC,CAwBlE"}

package/dist/model/mutations.js

@@ -0,0 +1,44 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { useReviewsApi } from "./context.js";
+import { reviewsQueryKeys } from "./queryKeys.js";
+/**
+ * Write a review of a target (frontend-standard §2 — mutations invalidate on
+ * success).
+ *
+ * ── Why the answer is invalidated rather than spliced in ───────────────────
+ *
+ * The created row comes back with its `status`, and under the module's
+ * default (`MODERATION_DEFAULT: "post"`) that is `published` — so pushing it
+ * into the cached window would be correct. Under `moderation: "pre"` it is
+ * `pending`, and the SAME row must NOT appear in the list, because the list
+ * this reader sees is published-only and a locally-spliced pending review
+ * would vanish on the next refetch with no explanation.
+ *
+ * One behaviour for both policies, and the policy is not visible to the
+ * client (no endpoint reports it): invalidate, let the server say what is
+ * visible, and carry the created row separately as the SUBMISSION's outcome
+ * (`headless/ReviewForm.tsx` renders "sent, awaiting moderation" off its
+ * `status`). The aggregate moves for the same reason and is invalidated with
+ * it — `avg` and `count` only count published rows.
+ */
+export function useSubmitReview(target) {
+    const api = useReviewsApi();
+    const queryClient = useQueryClient();
+    const options = {
+        mutationFn: (vars) => api.createReview({
+            targetType: target.targetType,
+            targetKey: target.targetKey,
+            rating: vars.rating,
+            ...(vars.body !== undefined ? { body: vars.body } : {}),
+        }),
+        onSuccess: () => {
+            // Both scopes of the list: a moderator's `include=all` window holds the
+            // pending row this write may just have created.
+            void queryClient.invalidateQueries({
+                queryKey: reviewsQueryKeys.target(target),
+            });
+        },
+    };
+    return useMutation(options);
+}
+//# sourceMappingURL=mutations.js.map

package/dist/model/mutations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutations.js","sourceRoot":"","sources":["../../src/model/mutations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAIpE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAUlD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,eAAe,CAC7B,MAAoB;IAEpB,MAAM,GAAG,GAAG,aAAa,EAAE,CAAC;IAC5B,MAAM,WAAW,GAAG,cAAc,EAAE,CAAC;IACrC,MAAM,OAAO,GAIT;QACF,UAAU,EAAE,CAAC,IAAI,EAAE,EAAE,CACnB,GAAG,CAAC,YAAY,CAAC;YACf,UAAU,EAAE,MAAM,CAAC,UAAU;YAC7B,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,GAAG,CAAC,IAAI,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACxD,CAAC;QACJ,SAAS,EAAE,GAAG,EAAE;YACd,wEAAwE;YACxE,gDAAgD;YAChD,KAAK,WAAW,CAAC,iBAAiB,CAAC;gBACjC,QAAQ,EAAE,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC;aAC1C,CAAC,CAAC;QACL,CAAC;KACF,CAAC;IACF,OAAO,WAAW,CAAC,OAAO,CAAC,CAAC;AAC9B,CAAC"}

package/dist/model/queries.d.ts

@@ -0,0 +1,65 @@
+import type { InfiniteData, UseInfiniteQueryResult, UseQueryResult } from "@tanstack/react-query";
+import type { StapelApiError } from "@stapel/core";
+import type { ReviewAggregate, ReviewPage, ReviewTarget } from "../api/types.js";
+/**
+ * Read hooks over the reviews API.
+ *
+ * ── Both reads are ANONYMOUS, and both still wait for the session ─────────
+ *
+ * Since stapel-reviews 0.3.0 a guest reads the list (`IsAuthenticatedOrReadOnly`)
+ * and the aggregate (`AllowAny`), so a public listing page shows its reviews
+ * to a visitor who will never sign in. Neither hook carries a
+ * "sign in first" state any more — that is now only true of the write.
+ *
+ * They are still gated on {@link useActiveSessionReady}, and the reason got
+ * STRONGER rather than weaker with the permission change. What the server
+ * returns depends on who is asking: a moderator of the target gets pending
+ * and hidden rows for `include=all`, everyone else is silently narrowed to
+ * published. A read that races a still-bootstrapping session would therefore
+ * succeed — as a guest — and CACHE that answer under a key that does not
+ * mention identity. Before 0.3.0 the same race produced a 401, which was at
+ * least visible; a silently narrowed page is not. `useActiveSessionReady()`
+ * returns `true` the instant the session settles into any of
+ * authenticated / anonymous / unauthenticated, and immediately when no
+ * session-owning module is mounted at all — so a purely public storefront
+ * waits for nothing.
+ */
+/** Default page size for the review list — one screenful. */
+export declare const REVIEWS_PAGE = 20;
+export interface UseReviewListOptions {
+    /**
+     * Ask for pending/hidden rows too — honoured only for a moderator/owner of
+     * the target, and narrowed to published for anyone else WITHOUT an error.
+     * Part of the query key, because it selects a different set of rows.
+     */
+    readonly include?: "all";
+    readonly limit?: number;
+    /** Set `false` to hold the read (e.g. the target id is not resolved yet). */
+    readonly enabled?: boolean;
+}
+/**
+ * A target's reviews as an infinite (load-more) list, newest first.
+ *
+ * Pages are core's `AnchorPagination` envelope — which the schema does not
+ * declare (`api/types.ts`) — and the cursor is the previous page's
+ * `next_anchor`, a `created_at` timestamp. `has_next` is the authority on
+ * whether another page exists; a `next_anchor` is only read when it says yes,
+ * because the paginator leaves the anchor `null` on the last page and a
+ * cursor derived from the last row instead would re-request it forever.
+ */
+export declare function useReviewList(target: ReviewTarget, options?: UseReviewListOptions): UseInfiniteQueryResult<InfiniteData<ReviewPage, string | undefined>, StapelApiError>;
+/**
+ * The module-owned aggregate for one target.
+ *
+ * NOT the way to put a rating on every card of a search result: that is one
+ * request per card against an endpoint that computes an `AVG` each time. The
+ * batch read exists (`reviews.aggregates_by_keys`) but it is a comm Function
+ * for a server-side projection, not an HTTP endpoint — a storefront gets
+ * per-card ratings from the composite's projection, embedded in the rows its
+ * catalogue module already serves, and renders them with
+ * {@link ratingSummary} without calling this at all.
+ */
+export declare function useReviewAggregate(target: ReviewTarget, options?: {
+    readonly enabled?: boolean;
+}): UseQueryResult<ReviewAggregate, StapelApiError>;
+//# sourceMappingURL=queries.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queries.d.ts","sourceRoot":"","sources":["../../src/model/queries.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,YAAY,EACZ,sBAAsB,EACtB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAE/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AACnD,OAAO,KAAK,EACV,eAAe,EACf,UAAU,EACV,YAAY,EACb,MAAM,iBAAiB,CAAC;AAIzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,6DAA6D;AAC7D,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE,oBAAyB,GACjC,sBAAsB,CACvB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC,EAC5C,cAAc,CACf,CAwBA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,YAAY,EACpB,OAAO,GAAE;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAO,GAC3C,cAAc,CAAC,eAAe,EAAE,cAAc,CAAC,CAUjD"}

package/dist/model/queries.js

@@ -0,0 +1,80 @@
+import { useInfiniteQuery, useQuery } from "@tanstack/react-query";
+import { useActiveSessionReady } from "@stapel/core";
+import { useReviewsApi } from "./context.js";
+import { reviewsQueryKeys } from "./queryKeys.js";
+/**
+ * Read hooks over the reviews API.
+ *
+ * ── Both reads are ANONYMOUS, and both still wait for the session ─────────
+ *
+ * Since stapel-reviews 0.3.0 a guest reads the list (`IsAuthenticatedOrReadOnly`)
+ * and the aggregate (`AllowAny`), so a public listing page shows its reviews
+ * to a visitor who will never sign in. Neither hook carries a
+ * "sign in first" state any more — that is now only true of the write.
+ *
+ * They are still gated on {@link useActiveSessionReady}, and the reason got
+ * STRONGER rather than weaker with the permission change. What the server
+ * returns depends on who is asking: a moderator of the target gets pending
+ * and hidden rows for `include=all`, everyone else is silently narrowed to
+ * published. A read that races a still-bootstrapping session would therefore
+ * succeed — as a guest — and CACHE that answer under a key that does not
+ * mention identity. Before 0.3.0 the same race produced a 401, which was at
+ * least visible; a silently narrowed page is not. `useActiveSessionReady()`
+ * returns `true` the instant the session settles into any of
+ * authenticated / anonymous / unauthenticated, and immediately when no
+ * session-owning module is mounted at all — so a purely public storefront
+ * waits for nothing.
+ */
+/** Default page size for the review list — one screenful. */
+export const REVIEWS_PAGE = 20;
+/**
+ * A target's reviews as an infinite (load-more) list, newest first.
+ *
+ * Pages are core's `AnchorPagination` envelope — which the schema does not
+ * declare (`api/types.ts`) — and the cursor is the previous page's
+ * `next_anchor`, a `created_at` timestamp. `has_next` is the authority on
+ * whether another page exists; a `next_anchor` is only read when it says yes,
+ * because the paginator leaves the anchor `null` on the last page and a
+ * cursor derived from the last row instead would re-request it forever.
+ */
+export function useReviewList(target, options = {}) {
+    const api = useReviewsApi();
+    const sessionReady = useActiveSessionReady();
+    const limit = options.limit ?? REVIEWS_PAGE;
+    const addressable = target.targetType.length > 0 && target.targetKey.length > 0;
+    return useInfiniteQuery({
+        queryKey: reviewsQueryKeys.list(target, options.include),
+        queryFn: ({ pageParam, signal }) => api.reviews({
+            ...target,
+            ...(options.include !== undefined ? { include: options.include } : {}),
+            direction: "next",
+            limit,
+            ...(pageParam !== undefined ? { anchor: pageParam } : {}),
+        }, { signal }),
+        initialPageParam: undefined,
+        getNextPageParam: (last) => last.has_next ? (last.next_anchor ?? undefined) : undefined,
+        enabled: sessionReady && addressable && (options.enabled ?? true),
+    });
+}
+/**
+ * The module-owned aggregate for one target.
+ *
+ * NOT the way to put a rating on every card of a search result: that is one
+ * request per card against an endpoint that computes an `AVG` each time. The
+ * batch read exists (`reviews.aggregates_by_keys`) but it is a comm Function
+ * for a server-side projection, not an HTTP endpoint — a storefront gets
+ * per-card ratings from the composite's projection, embedded in the rows its
+ * catalogue module already serves, and renders them with
+ * {@link ratingSummary} without calling this at all.
+ */
+export function useReviewAggregate(target, options = {}) {
+    const api = useReviewsApi();
+    const sessionReady = useActiveSessionReady();
+    const addressable = target.targetType.length > 0 && target.targetKey.length > 0;
+    return useQuery({
+        queryKey: reviewsQueryKeys.aggregate(target),
+        queryFn: ({ signal }) => api.aggregate(target, { signal }),
+        enabled: sessionReady && addressable && (options.enabled ?? true),
+    });
+}
+//# sourceMappingURL=queries.js.map

package/dist/model/queries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queries.js","sourceRoot":"","sources":["../../src/model/queries.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAMnE,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAOrD,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,6DAA6D;AAC7D,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,CAAC;AAc/B;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAC3B,MAAoB,EACpB,UAAgC,EAAE;IAKlC,MAAM,GAAG,GAAG,aAAa,EAAE,CAAC;IAC5B,MAAM,YAAY,GAAG,qBAAqB,EAAE,CAAC;IAC7C,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,IAAI,YAAY,CAAC;IAC5C,MAAM,WAAW,GACf,MAAM,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IAC9D,OAAO,gBAAgB,CAAC;QACtB,QAAQ,EAAE,gBAAgB,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC;QACxD,OAAO,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAE,EAAE,EAAE,CACjC,GAAG,CAAC,OAAO,CACT;YACE,GAAG,MAAM;YACT,GAAG,CAAC,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;YACtE,SAAS,EAAE,MAAM;YACjB,KAAK;YACL,GAAG,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SAC1D,EACD,EAAE,MAAM,EAAE,CACX;QACH,gBAAgB,EAAE,SAA+B;QACjD,gBAAgB,EAAE,CAAC,IAAI,EAAE,EAAE,CACzB,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;QAC7D,OAAO,EAAE,YAAY,IAAI,WAAW,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC;KAClE,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAoB,EACpB,UAA0C,EAAE;IAE5C,MAAM,GAAG,GAAG,aAAa,EAAE,CAAC;IAC5B,MAAM,YAAY,GAAG,qBAAqB,EAAE,CAAC;IAC7C,MAAM,WAAW,GACf,MAAM,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,MAAM,GAAG,CAAC,CAAC;IAC9D,OAAO,QAAQ,CAAC;QACd,QAAQ,EAAE,gBAAgB,CAAC,SAAS,CAAC,MAAM,CAAC;QAC5C,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC;QAC1D,OAAO,EAAE,YAAY,IAAI,WAAW,IAAI,CAAC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC;KAClE,CAAC,CAAC;AACL,CAAC"}

package/dist/model/queryKeys.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Namespaced TanStack Query keys (frontend-standard §2). Everything under the
+ * `"reviews"` root so a host can invalidate the whole module, one target, or
+ * one read.
+ *
+ * THE TARGET IS TWO STRINGS, AND BOTH ARE IN THE KEY. `target_key` alone is
+ * not an identity: the module groups by the PAIR, and two deployments'
+ * registries can key different things with the same opaque string (a listing
+ * `"42"` and a course `"42"`). A key built from `target_key` only would serve
+ * one target's reviews for the other.
+ *
+ * `include` is part of the list key for the same reason: `include=all` is a
+ * DIFFERENT set of rows (pending and hidden ones), and folding it into the
+ * published-only entry would let a moderator's window overwrite what every
+ * other reader sees.
+ */
+import type { ReviewTarget } from "../api/types.js";
+export declare const reviewsQueryKeys: {
+    readonly all: readonly ["reviews"];
+    /** Everything cached about one target. */
+    target(target: ReviewTarget): readonly ["reviews", string, string];
+    /** The anchor-paginated list window for one target and one visibility scope. */
+    list(target: ReviewTarget, include?: "all"): readonly ["reviews", string, string, "list", string];
+    /** The module-owned aggregate for one target. */
+    aggregate(target: ReviewTarget): readonly ["reviews", string, string, "aggregate"];
+};
+//# sourceMappingURL=queryKeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queryKeys.d.ts","sourceRoot":"","sources":["../../src/model/queryKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAIpD,eAAO,MAAM,gBAAgB,EAAE;IAC7B,QAAQ,CAAC,GAAG,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;IACnC,0CAA0C;IAC1C,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACnE,gFAAgF;IAChF,IAAI,CACF,MAAM,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE,KAAK,GACd,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACxD,iDAAiD;IACjD,SAAS,CACP,MAAM,EAAE,YAAY,GACnB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;CAYtD,CAAC"}

package/dist/model/queryKeys.js

@@ -0,0 +1,14 @@
+const ROOT = "reviews";
+export const reviewsQueryKeys = {
+    all: [ROOT],
+    target: (target) => [ROOT, target.targetType, target.targetKey],
+    list: (target, include) => [
+        ROOT,
+        target.targetType,
+        target.targetKey,
+        "list",
+        include ?? "published",
+    ],
+    aggregate: (target) => [ROOT, target.targetType, target.targetKey, "aggregate"],
+};
+//# sourceMappingURL=queryKeys.js.map

package/dist/model/queryKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queryKeys.js","sourceRoot":"","sources":["../../src/model/queryKeys.ts"],"names":[],"mappings":"AAkBA,MAAM,IAAI,GAAG,SAAkB,CAAC;AAEhC,MAAM,CAAC,MAAM,gBAAgB,GAazB;IACF,GAAG,EAAE,CAAC,IAAI,CAAC;IACX,MAAM,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,SAAS,CAAC;IAC/D,IAAI,EAAE,CAAC,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC;QACzB,IAAI;QACJ,MAAM,CAAC,UAAU;QACjB,MAAM,CAAC,SAAS;QAChB,MAAM;QACN,OAAO,IAAI,WAAW;KACvB;IACD,SAAS,EAAE,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC;CAChF,CAAC"}

package/dist/model/rating.d.ts

@@ -0,0 +1,57 @@
+/**
+ * What a rating MEANS, kept in one pure module so a card, a panel and a
+ * seller header cannot each decide differently.
+ *
+ * The whole file exists for one line of the contract: `avg` is `0.0` when
+ * `count` is `0` (`services.aggregate`, and `AggregateResponse`'s own
+ * description says so). Rendered naively that is a zero-star rating — the
+ * worst possible score — printed over a target nobody has rated yet. It is the
+ * same class of defect as `data ?? []`: a value that was never measured
+ * displayed as if it had been measured and found to be nothing.
+ *
+ * So {@link ratingSummary} answers `rated: false` for that case and the star
+ * row has nothing to draw. There is no way to get an `avg` out of this module
+ * without also getting the flag that says whether it means anything.
+ */
+import type { RatingAggregate } from "../api/types.js";
+/** An aggregate, read. */
+export type RatingSummary = {
+    /** Nobody has published a review of this target. */
+    readonly rated: false;
+    readonly count: 0;
+    /** Deliberately absent: there is no average of an empty set. */
+    readonly avg?: undefined;
+    readonly rounded?: undefined;
+} | {
+    readonly rated: true;
+    readonly count: number;
+    /** Mean over published reviews, as the server computed it (3 decimals). */
+    readonly avg: number;
+    /** The same mean at display precision — one decimal, half-up. */
+    readonly rounded: number;
+};
+/**
+ * Read an aggregate — from this module's own `GET /reviews/aggregate`, or from
+ * the composite's `shop.listing_review_summary` projection, which answers the
+ * same two field names on purpose (`stapel_shop/projections.py`: "the owner's
+ * names ARE the contract shape here").
+ *
+ * A `count` of 0 is "not rated", whatever `avg` says. A negative or
+ * non-finite `count` is treated the same way rather than trusted: this is the
+ * one place a bad number can enter the display layer.
+ */
+export declare function ratingSummary(aggregate: RatingAggregate | null | undefined): RatingSummary;
+/**
+ * How many whole, half and empty stars a `rounded` average draws, for a skin
+ * that renders stars rather than a number.
+ *
+ * `max` is the deployment's `RATING_MAX` (the runtime's `ratingBounds.max`),
+ * not a hardcoded five — a 1..10 deployment draws ten.
+ */
+export interface StarBreakdown {
+    readonly full: number;
+    readonly half: 0 | 1;
+    readonly empty: number;
+}
+export declare function starBreakdown(rounded: number, max: number): StarBreakdown;
+//# sourceMappingURL=rating.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rating.d.ts","sourceRoot":"","sources":["../../src/model/rating.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,0BAA0B;AAC1B,MAAM,MAAM,aAAa,GACrB;IACE,oDAAoD;IACpD,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;IAClB,gEAAgE;IAChE,QAAQ,CAAC,GAAG,CAAC,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;CAC9B,GACD;IACE,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAYN;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC3B,SAAS,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,GAC5C,aAAa,CAaf;AAED;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,aAAa,CAczE"}

package/dist/model/rating.js

@@ -0,0 +1,47 @@
+/**
+ * Round half-up to one decimal for display. `Math.round` is already half-up
+ * for positives and ratings are positive, but the float dance is written out
+ * so 4.25 → 4.3 rather than 4.2 (binary representation makes
+ * `Math.round(4.25 * 10)` unreliable across engines otherwise).
+ */
+function oneDecimal(value) {
+    return Math.round((value + Number.EPSILON) * 10) / 10;
+}
+/**
+ * Read an aggregate — from this module's own `GET /reviews/aggregate`, or from
+ * the composite's `shop.listing_review_summary` projection, which answers the
+ * same two field names on purpose (`stapel_shop/projections.py`: "the owner's
+ * names ARE the contract shape here").
+ *
+ * A `count` of 0 is "not rated", whatever `avg` says. A negative or
+ * non-finite `count` is treated the same way rather than trusted: this is the
+ * one place a bad number can enter the display layer.
+ */
+export function ratingSummary(aggregate) {
+    const count = aggregate?.count;
+    if (aggregate === null ||
+        aggregate === undefined ||
+        typeof count !== "number" ||
+        !Number.isFinite(count) ||
+        count <= 0) {
+        return { rated: false, count: 0 };
+    }
+    const avg = Number.isFinite(aggregate.avg) ? aggregate.avg : 0;
+    return { rated: true, count, avg, rounded: oneDecimal(avg) };
+}
+export function starBreakdown(rounded, max) {
+    const clamped = Math.min(Math.max(rounded, 0), max);
+    const full = Math.floor(clamped);
+    const remainder = clamped - full;
+    // A remainder of a quarter or more is a half star; anything less rounds
+    // away. The alternative — a partial-width star — is a skin's business, and
+    // this breakdown stays a count so a non-antd skin can use it too.
+    const half = remainder >= 0.25 && remainder < 0.75 ? 1 : 0;
+    const rounded_up = remainder >= 0.75 ? 1 : 0;
+    return {
+        full: full + rounded_up,
+        half,
+        empty: max - full - rounded_up - half,
+    };
+}
+//# sourceMappingURL=rating.js.map

package/dist/model/rating.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rating.js","sourceRoot":"","sources":["../../src/model/rating.ts"],"names":[],"mappings":"AAoCA;;;;;GAKG;AACH,SAAS,UAAU,CAAC,KAAa;IAC/B,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC;AACxD,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAC3B,SAA6C;IAE7C,MAAM,KAAK,GAAG,SAAS,EAAE,KAAK,CAAC;IAC/B,IACE,SAAS,KAAK,IAAI;QAClB,SAAS,KAAK,SAAS;QACvB,OAAO,KAAK,KAAK,QAAQ;QACzB,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC;QACvB,KAAK,IAAI,CAAC,EACV,CAAC;QACD,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;IACpC,CAAC;IACD,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/D,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;AAC/D,CAAC;AAeD,MAAM,UAAU,aAAa,CAAC,OAAe,EAAE,GAAW;IACxD,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IACpD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACjC,MAAM,SAAS,GAAG,OAAO,GAAG,IAAI,CAAC;IACjC,wEAAwE;IACxE,2EAA2E;IAC3E,kEAAkE;IAClE,MAAM,IAAI,GAAU,SAAS,IAAI,IAAI,IAAI,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAClE,MAAM,UAAU,GAAG,SAAS,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7C,OAAO;QACL,IAAI,EAAE,IAAI,GAAG,UAAU;QACvB,IAAI;QACJ,KAAK,EAAE,GAAG,GAAG,IAAI,GAAG,UAAU,GAAG,IAAI;KACtC,CAAC;AACJ,CAAC"}

package/dist/model/refusals.d.ts

@@ -0,0 +1,51 @@
+import type { FlowError } from "@stapel/core";
+/** The author already reviewed this target (`one_per_author`). A **400**. */
+export declare const REVIEWS_ERROR_DUPLICATE = "error.400.reviews_duplicate_review";
+/** `target_type` is not in the host's registry — or one of the pair was missing. */
+export declare const REVIEWS_ERROR_UNKNOWN_TARGET_TYPE = "error.400.reviews_unknown_target_type";
+/** The rating fell outside `[RATING_MIN, RATING_MAX]`. */
+export declare const REVIEWS_ERROR_INVALID_RATING = "error.400.reviews_invalid_rating";
+/** The type's `can_review` callback said no. */
+export declare const REVIEWS_ERROR_CANNOT_REVIEW = "error.403.reviews_cannot_review";
+/** The type's `can_moderate` callback said no (fail-closed when unset). */
+export declare const REVIEWS_ERROR_CANNOT_MODERATE = "error.403.reviews_cannot_moderate";
+/** No review with that id. */
+export declare const REVIEWS_ERROR_NOT_FOUND = "error.404.reviews_review_not_found";
+/** Responses are switched off for this target type. */
+export declare const REVIEWS_ERROR_RESPONSE_NOT_ALLOWED = "error.400.reviews_response_not_allowed";
+/** The review already carries the owner's reply — the module's ONLY 409. */
+export declare const REVIEWS_ERROR_ALREADY_RESPONDED = "error.409.reviews_already_responded";
+/** Fold any thrown value into this pair's error dialect. */
+export declare function toReviewsError(error: unknown): FlowError;
+/**
+ * "You have already reviewed this target."
+ *
+ * Only ever true when the target type sets `one_per_author: true` — the
+ * registry default is `false` (`registry.resolve_policy`), and the catalogue
+ * shop preset turns it on for `listing`. A host whose policy allows several
+ * reviews will simply never see this.
+ */
+export declare function isDuplicateReview(error: unknown): boolean;
+/**
+ * "This read needs a signed-in account." True for the 401 every endpoint of
+ * this module answers to an anonymous caller.
+ *
+ * Both halves are checked: core maps an un-keyed 401 body to
+ * `stapel.http.401`, but a deployment that puts its own `localizable_error`
+ * in a 401 body would arrive with that key instead — and it is still a 401.
+ */
+export declare function isSignInRequired(error: unknown): boolean;
+/** The host's `can_review` callback refused this author for this target. */
+export declare function isReviewingForbidden(error: unknown): boolean;
+/**
+ * The target type is not registered on this deployment.
+ *
+ * Worth its own predicate because the view answers it for TWO different
+ * situations: an unknown type, and a missing `target_type`/`target_key` on a
+ * GET (`views.py` — "a missing one is ERR_400_UNKNOWN_TARGET_TYPE, not an
+ * empty list/aggregate"). Either way it is a wiring fault in the host, not
+ * something the person reading the page can fix, which is why the skin shows
+ * it as an error rather than as an empty state.
+ */
+export declare function isUnknownTargetType(error: unknown): boolean;
+//# sourceMappingURL=refusals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"refusals.d.ts","sourceRoot":"","sources":["../../src/model/refusals.ts"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAE9C,6EAA6E;AAC7E,eAAO,MAAM,uBAAuB,uCAAuC,CAAC;AAC5E,oFAAoF;AACpF,eAAO,MAAM,iCAAiC,0CACL,CAAC;AAC1C,0DAA0D;AAC1D,eAAO,MAAM,4BAA4B,qCAAqC,CAAC;AAC/E,gDAAgD;AAChD,eAAO,MAAM,2BAA2B,oCAAoC,CAAC;AAC7E,2EAA2E;AAC3E,eAAO,MAAM,6BAA6B,sCAAsC,CAAC;AACjF,8BAA8B;AAC9B,eAAO,MAAM,uBAAuB,uCAAuC,CAAC;AAC5E,uDAAuD;AACvD,eAAO,MAAM,kCAAkC,2CACL,CAAC;AAC3C,4EAA4E;AAC5E,eAAO,MAAM,+BAA+B,wCACL,CAAC;AAiBxC,4DAA4D;AAC5D,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAExD;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAEzD;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAGxD;AAED,4EAA4E;AAC5E,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE3D"}

package/dist/model/refusals.js

@@ -0,0 +1,103 @@
+/**
+ * The refusals this pair has to tell apart, and the reason they are read by
+ * CODE and never by status.
+ *
+ * ── The trap ───────────────────────────────────────────────────────────────
+ *
+ * "You have already reviewed this" is a **400**
+ * (`ERR_400_DUPLICATE_REVIEW = "error.400.reviews_duplicate_review"`,
+ * `views.ReviewListCreateView.post`), not the 409 the situation reads like.
+ * And the module DOES answer 409 — for something else entirely:
+ * `error.409.reviews_already_responded`, which says the owner's reply already
+ * exists. A form that branched on `status === 409` would therefore miss the
+ * duplicate every time and mis-handle a refusal about a different object.
+ *
+ * That is why every predicate here compares a `FlowError.code`, folded
+ * through core's `toFlowError`, and why the codes are exported as named
+ * constants rather than typed at each call site.
+ *
+ * ── The other one worth naming ─────────────────────────────────────────────
+ *
+ * All four stapel-reviews views are `IsAuthenticated`, so a signed-out
+ * visitor gets 401 on the review LIST and on the AGGREGATE. Read as a
+ * generic failure that becomes "no reviews yet" under any code that defaults
+ * an empty array — a well-reviewed seller shown as unreviewed to exactly the
+ * people who have not signed up yet. {@link isSignInRequired} exists so the
+ * list bag can carry that as its own state and the skin can say the true
+ * thing.
+ */
+import { isErrorCode, toFlowError } from "@stapel/core";
+/** The author already reviewed this target (`one_per_author`). A **400**. */
+export const REVIEWS_ERROR_DUPLICATE = "error.400.reviews_duplicate_review";
+/** `target_type` is not in the host's registry — or one of the pair was missing. */
+export const REVIEWS_ERROR_UNKNOWN_TARGET_TYPE = "error.400.reviews_unknown_target_type";
+/** The rating fell outside `[RATING_MIN, RATING_MAX]`. */
+export const REVIEWS_ERROR_INVALID_RATING = "error.400.reviews_invalid_rating";
+/** The type's `can_review` callback said no. */
+export const REVIEWS_ERROR_CANNOT_REVIEW = "error.403.reviews_cannot_review";
+/** The type's `can_moderate` callback said no (fail-closed when unset). */
+export const REVIEWS_ERROR_CANNOT_MODERATE = "error.403.reviews_cannot_moderate";
+/** No review with that id. */
+export const REVIEWS_ERROR_NOT_FOUND = "error.404.reviews_review_not_found";
+/** Responses are switched off for this target type. */
+export const REVIEWS_ERROR_RESPONSE_NOT_ALLOWED = "error.400.reviews_response_not_allowed";
+/** The review already carries the owner's reply — the module's ONLY 409. */
+export const REVIEWS_ERROR_ALREADY_RESPONDED = "error.409.reviews_already_responded";
+/** Core's cross-cutting key for an unauthenticated call. */
+const HTTP_401_KEY = "stapel.http.401";
+/**
+ * Named, not inlined — the cdn-react precedent, for the same reason
+ * `stapel/no-adhoc-401` gives: the rule bans a bare `=== 401` because that
+ * shape is how ad hoc refresh/redirect logic gets written outside core's one
+ * seam. What happens here is not that. Nothing is refreshed, retried or
+ * redirected; the status is merely CLASSIFIED so a public page can say "sign
+ * in to read the reviews" instead of "this seller has no reviews". The real
+ * 401 handling stays on the client's `onAuthRefresh` seam and never reaches
+ * this file.
+ */
+const HTTP_UNAUTHORIZED = 401;
+/** Fold any thrown value into this pair's error dialect. */
+export function toReviewsError(error) {
+    return toFlowError(error, "reviews.error.unknown");
+}
+/**
+ * "You have already reviewed this target."
+ *
+ * Only ever true when the target type sets `one_per_author: true` — the
+ * registry default is `false` (`registry.resolve_policy`), and the catalogue
+ * shop preset turns it on for `listing`. A host whose policy allows several
+ * reviews will simply never see this.
+ */
+export function isDuplicateReview(error) {
+    return isErrorCode(toReviewsError(error), REVIEWS_ERROR_DUPLICATE);
+}
+/**
+ * "This read needs a signed-in account." True for the 401 every endpoint of
+ * this module answers to an anonymous caller.
+ *
+ * Both halves are checked: core maps an un-keyed 401 body to
+ * `stapel.http.401`, but a deployment that puts its own `localizable_error`
+ * in a 401 body would arrive with that key instead — and it is still a 401.
+ */
+export function isSignInRequired(error) {
+    const flow = toReviewsError(error);
+    return flow.status === HTTP_UNAUTHORIZED || isErrorCode(flow, HTTP_401_KEY);
+}
+/** The host's `can_review` callback refused this author for this target. */
+export function isReviewingForbidden(error) {
+    return isErrorCode(toReviewsError(error), REVIEWS_ERROR_CANNOT_REVIEW);
+}
+/**
+ * The target type is not registered on this deployment.
+ *
+ * Worth its own predicate because the view answers it for TWO different
+ * situations: an unknown type, and a missing `target_type`/`target_key` on a
+ * GET (`views.py` — "a missing one is ERR_400_UNKNOWN_TARGET_TYPE, not an
+ * empty list/aggregate"). Either way it is a wiring fault in the host, not
+ * something the person reading the page can fix, which is why the skin shows
+ * it as an error rather than as an empty state.
+ */
+export function isUnknownTargetType(error) {
+    return isErrorCode(toReviewsError(error), REVIEWS_ERROR_UNKNOWN_TARGET_TYPE);
+}
+//# sourceMappingURL=refusals.js.map

package/dist/model/refusals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refusals.js","sourceRoot":"","sources":["../../src/model/refusals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAGxD,6EAA6E;AAC7E,MAAM,CAAC,MAAM,uBAAuB,GAAG,oCAAoC,CAAC;AAC5E,oFAAoF;AACpF,MAAM,CAAC,MAAM,iCAAiC,GAC5C,uCAAuC,CAAC;AAC1C,0DAA0D;AAC1D,MAAM,CAAC,MAAM,4BAA4B,GAAG,kCAAkC,CAAC;AAC/E,gDAAgD;AAChD,MAAM,CAAC,MAAM,2BAA2B,GAAG,iCAAiC,CAAC;AAC7E,2EAA2E;AAC3E,MAAM,CAAC,MAAM,6BAA6B,GAAG,mCAAmC,CAAC;AACjF,8BAA8B;AAC9B,MAAM,CAAC,MAAM,uBAAuB,GAAG,oCAAoC,CAAC;AAC5E,uDAAuD;AACvD,MAAM,CAAC,MAAM,kCAAkC,GAC7C,wCAAwC,CAAC;AAC3C,4EAA4E;AAC5E,MAAM,CAAC,MAAM,+BAA+B,GAC1C,qCAAqC,CAAC;AAExC,4DAA4D;AAC5D,MAAM,YAAY,GAAG,iBAAiB,CAAC;AAEvC;;;;;;;;;GASG;AACH,MAAM,iBAAiB,GAAG,GAAG,CAAC;AAE9B,4DAA4D;AAC5D,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,WAAW,CAAC,KAAK,EAAE,uBAAuB,CAAC,CAAC;AACrD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAAC,KAAc;IAC9C,OAAO,WAAW,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,uBAAuB,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,MAAM,IAAI,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACnC,OAAO,IAAI,CAAC,MAAM,KAAK,iBAAiB,IAAI,WAAW,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;AAC9E,CAAC;AAED,4EAA4E;AAC5E,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,OAAO,WAAW,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,2BAA2B,CAAC,CAAC;AACzE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAc;IAChD,OAAO,WAAW,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,iCAAiC,CAAC,CAAC;AAC/E,CAAC"}