@base44/app-plugin-commerce 0.2.7 → 0.3.2

package/src/commerce/storefront/useAddressForm.js

@@ -1,166 +0,0 @@
-import { useCallback, useMemo, useState } from "react";
-import { addressFieldSpec } from "@/commerce/utils";
-import { useStoreInfo } from "./StorefrontProvider";
-import { useCheckoutContext } from "./useCheckout";
-import { REQUIRED_BILLING_FIELDS } from "./address";
-
-/**
- * The store's country list, **always as an array**.
- *
- *   const { options, loading } = useCountries();
- *   <select>{options.map(o => <option key={o.value} value={o.value}>{o.label}</option>)}</select>
- *
- * `useStoreInfo().countries` is `null` until store info resolves, so mapping it
- * directly white-screens the checkout on a cold load — the most severe defect
- * observed in a generated storefront. Here the list is empty-then-full, never
- * null, and `loading` says which.
- */
-export function useCountries() {
-  const { countries, loading, error } = useStoreInfo();
-  const list = Array.isArray(countries) ? countries : [];
-  const options = useMemo(() => list.map((c) => ({ value: c.code, label: c.name })), [countries]); // eslint-disable-line react-hooks/exhaustive-deps
-  return { countries: list, options, loading, error };
-}
-
-/**
- * Read the new value out of whatever a field's `set` was handed. All three
- * forms an onChange is plausibly written as work, so a field setter can't be
- * called "wrong":
- *
- *   f.set(e.target.value)        // the value
- *   f.set(e)                     // the change event  (onChange={f.set})
- *   f.set(f.key, e.target.value) // key + value, mirroring the top-level set()
- */
-function newValue(args) {
-  if (args.length >= 2) return args[1];
-  const first = args[0];
-  if (first && typeof first === "object" && "target" in first) return first.target?.value ?? "";
-  return first;
-}
-
-/**
- * useAddressForm — the checkout address form as a field list bound to the
- * guided checkout. Needs a `<CheckoutProvider>` above it.
- *
- * Every field is **self-contained**: it carries its own value, setter, id,
- * `autoComplete` token and error, so the whole form is one map and every
- * element and attribute in it is yours:
- *
- *   const { fields } = useAddressForm("billing");
- *   {fields.map(f => (
- *     <div key={f.key} className="…">
- *       <label htmlFor={f.id}>{f.label}{f.required && " *"}</label>
- *       {f.isSelect ? (
- *         <select id={f.id} value={f.value} onChange={f.set}
- *                 autoComplete={f.autoComplete} className="…">
- *           <option value="">{f.placeholder}</option>
- *           {f.options.map(o => <option key={o.value} value={o.value}>{o.label}</option>)}
- *         </select>
- *       ) : <input id={f.id} type={f.type} value={f.value} onChange={f.set}
- *                  autoComplete={f.autoComplete} className="…" />}
- *       {f.error && <span role="alert" className="…">{f.error}</span>}
- *     </div>
- *   ))}
- *
- * ⚑ Keep `value={f.value}` + `onChange={f.set}` (the pair that binds the field
- * to checkout) and `autoComplete={f.autoComplete}` (browsers fill addresses in
- * one gesture with it, field by field without). `f.placeholder` resolves the
- * select's empty option ("Select Country", or "Loading…" while countries
- * arrive), so `countriesLoading` never needs handling by hand. `f.error` is
- * per-field: "we don't ship there" lands on the country field, and a required
- * field reports itself once it has been edited and left empty — untouched
- * fields stay quiet here and surface through the place-order `blockers`.
- *
- * `f.set` works with custom controls too — it accepts a value, the raw change
- * event (`onChange={f.set}`) or a `(key, value)` pair — as does the hook's
- * top-level `set(key, value)`.
- *
- * Editing a field is all it takes to trigger the shipping/tax recalculation —
- * `useCheckout` debounces and calls `set-shipping-address` once the address is
- * complete enough to price. Two things the field list gets right that a
- * hand-typed table did not: **`state` is present** (rates and taxes match on
- * country + state, and it switches to a select for countries with
- * subdivisions), and the country options are never null.
- *
- * @param {"billing"|"shipping"} [which]
- * @param {{includeState?: boolean, includePhone?: boolean, includeCompany?: boolean}} [options]
- * @returns {{fields: Array<{key: string, id: string, label: string, type: string,
- *   value: string, required: boolean, options: Array<object>, error: string|null,
- *   autoComplete: string, colSpan: number, set: (...args: any[]) => void,
- *   isSelect: boolean, placeholder: string|undefined}>,
- *   set: (key: string, value: any) => void, values: object, missing: Array<string>,
- *   complete: boolean, error: object|null, countriesLoading: boolean}}
- */
-export function useAddressForm(which = "billing", options = {}) {
-  const checkout = useCheckoutContext();
-  const { countries, loading: countriesLoading } = useCountries();
-
-  const isBilling = which === "billing";
-  const values = isBilling ? checkout.billing : checkout.shipping;
-  const { updateBilling, updateShipping } = checkout;
-  const set = useCallback(
-    (key, value) => (isBilling ? updateBilling({ [key]: value }) : updateShipping({ [key]: value })),
-    [isBilling, updateBilling, updateShipping],
-  );
-
-  // `place-order` only enforces required fields on billing; a separate shipping
-  // address is priced, not validated field-by-field.
-  const missing = isBilling ? checkout.missingBillingFields : [];
-
-  // A required field reports itself as `error` only after it has been edited —
-  // an untouched form must not open covered in "required" marks. (Fields never
-  // touched at all surface through the place-order blockers instead.)
-  const [visited, setVisited] = useState({});
-
-  const fields = useMemo(() => {
-    const spec = addressFieldSpec({
-      countries,
-      country: values?.country,
-      required: isBilling ? REQUIRED_BILLING_FIELDS : ["country", "city"],
-      includeEmail: isBilling, // one email per order, on billing
-      ...options,
-    });
-    return spec.map((f) => {
-      const value = values?.[f.key] ?? "";
-      // Self-contained: the field knows its own key, so a .map never has to
-      // reach back out to the hook's set() (and can't pass the wrong key).
-      // The first edit marks the field visited, arming its required check.
-      const setField = (...args) => {
-        setVisited((v) => (v[f.key] ? v : { ...v, [f.key]: true }));
-        set(f.key, newValue(args));
-      };
-      // The address-level error ("we don't ship there") belongs on country.
-      const error =
-        f.key === "country" && checkout.addressError?.code === "shipping_not_available"
-          ? checkout.addressError.message
-          : visited[f.key] && !value && missing.includes(f.key)
-            ? `${f.label} is required.`
-            : null;
-      return {
-        ...f,
-        id: `${which}-${f.key}`,
-        value,
-        set: setField,
-        error,
-        isSelect: f.type === "select",
-        placeholder:
-          f.type === "select"
-            ? f.key === "country" && countriesLoading
-              ? "Loading…"
-              : `Select ${f.label}`
-            : undefined,
-      };
-    });
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [countries, countriesLoading, values, which, isBilling, set, checkout.addressError, visited, missing.join(","), JSON.stringify(options)]);
-
-  return {
-    fields,
-    set,
-    values: values ?? {},
-    missing,
-    complete: missing.length === 0,
-    error: checkout.addressError ?? null,
-    countriesLoading,
-  };
-}

package/src/commerce/storefront/usePlaceOrder.js

@@ -1,63 +0,0 @@
-import { useCallback } from "react";
-import { useCheckoutContext } from "./useCheckout";
-import { useCheckoutBlockers } from "./useTotalsLines";
-
-/**
- * usePlaceOrder — the place-order gate as plain states and one handler. Needs
- * a `<CheckoutProvider>` above it. The whole bottom of a checkout page:
- *
- *   const order = usePlaceOrder();
- *   if (order.stage === "submitted") return <p>Order placed — taking you to your receipt…</p>;
- *   …
- *   <button type="button" onClick={order.placeOrder} disabled={order.disabled} className="…">
- *     {order.label}
- *   </button>
- *   {order.error && <p role="alert" className="…">{order.error.message}</p>}
- *   {!order.canPlaceOrder && order.blockers.map(b => <p key={b.code}>{b.message}</p>)}
- *
- * ⚑ **The `stage === "submitted"` guard goes above the page's empty-cart
- * branch.** Placing an order clears the cart before the browser navigates
- * away; without the guard the page flashes "your bag is empty" over a
- * just-placed order. `stage` is `"editing" | "placing" | "submitted"`.
- *
- * `disabled` is the gate plus in-flight (`!canPlaceOrder || placing`); `label`
- * follows `placing` and is overridable via `labels: { idle, placing }`.
- * `placeOrder` is safe as an `onClick` handler directly — a click event passed
- * to it is ignored (an explicit `extra` object is still forwarded). `blockers`
- * are the disabled button's reasons in words (`useCheckoutBlockers`), each
- * with a `field` to anchor it next to the input that fixes it. Pass
- * `blockerLabels` to override that copy per code.
- *
- * @param {{labels?: {idle?: string, placing?: string},
- *   blockerLabels?: Record<string, string>}} [options]
- * @returns {{placeOrder: (extra?: object) => Promise<object>, disabled: boolean,
- *   label: string, stage: "editing"|"placing"|"submitted", submitted: boolean,
- *   placing: boolean, canPlaceOrder: boolean, error: object|null,
- *   blockers: Array<{code: string, message: string, field: string|null}>}}
- */
-export function usePlaceOrder({ labels, blockerLabels } = {}) {
-  const checkout = useCheckoutContext();
-  const blockers = useCheckoutBlockers({ labels: blockerLabels });
-  const { canPlaceOrder, placing, submitted, stage, orderError, placeOrder } = checkout;
-
-  // Usable as onClick={order.placeOrder}: a DOM/React event is not `extra`.
-  const place = useCallback(
-    (extra) => {
-      const isEvent = extra && typeof extra === "object" && ("nativeEvent" in extra || "target" in extra);
-      return placeOrder(isEvent ? undefined : extra);
-    },
-    [placeOrder],
-  );
-
-  return {
-    placeOrder: place,
-    disabled: !canPlaceOrder || placing,
-    label: placing ? (labels?.placing ?? "Placing your order…") : (labels?.idle ?? "Place order"),
-    stage,
-    submitted,
-    placing,
-    canPlaceOrder,
-    error: orderError,
-    blockers,
-  };
-}

package/src/commerce/storefront/useProductGallery.js

@@ -1,78 +0,0 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-import { imageIndex, productImages } from "@/commerce/utils";
-
-/**
- * useProductGallery — the gallery's non-visual state: normalized images, the
- * active index, and the variant-follows-selection behaviour.
- *
- *   const g = useProductGallery(product, view);
- *   {g.hasImages
- *     ? <img src={g.active.src} alt={g.active.alt} />
- *     : <MyPlaceholder />}
- *   {g.images.map((img, i) => <Thumb key={img.src} onClick={() => g.setActiveIndex(i)} …/>)}
- *
- * The aspect ratio, crossfade and thumbnail styling stay yours — only the state
- * moves here, and with it three details worth having by default: images are
- * normalized to `{src, name, alt}` (they are stored as objects, so a raw
- * `images[0]` as `src` renders broken), `hasImages: false` is an explicit
- * placeholder signal rather than a collapsed element, and **a selection change
- * moves the active image to the variation's own picture while a manual pick
- * still wins until the selection changes again** — highlight, not replace.
- *
- * A null/not-yet-loaded product is fine (`hasImages: false`), so call this with
- * the other hooks **above** the page's `loading`/`not_found` guards — a hook
- * below an early return breaks the hook order the next render.
- *
- * @param {object} product
- * @param {object|null} [view] a `resolveSelection` view; its
- *   `display.image` is the variation's image
- */
-export function useProductGallery(product, view = null) {
-  const images = useMemo(() => productImages(product), [product]);
-  const [activeIndex, setActiveIndex] = useState(0);
-  const manualPick = useRef(false);
-
-  const variationImage = view?.display?.image ?? null;
-  const variationIndex = useMemo(() => imageIndex(images, variationImage), [images, variationImage]);
-  const selectionKey = JSON.stringify(view?.selection ?? {});
-
-  // A new product resets everything; a new selection re-arms the follow.
-  useEffect(() => {
-    manualPick.current = false;
-    setActiveIndex(0);
-  }, [product?.id]);
-
-  useEffect(() => {
-    manualPick.current = false;
-  }, [selectionKey]);
-
-  useEffect(() => {
-    if (manualPick.current || variationIndex < 0) return;
-    setActiveIndex(variationIndex);
-  }, [variationIndex]);
-
-  const select = useCallback(
-    (index) => {
-      manualPick.current = true;
-      setActiveIndex(Math.max(0, Math.min(images.length - 1, index)));
-    },
-    [images.length],
-  );
-  const next = useCallback(() => select((activeIndex + 1) % Math.max(1, images.length)), [activeIndex, images.length, select]);
-  const prev = useCallback(
-    () => select((activeIndex - 1 + Math.max(1, images.length)) % Math.max(1, images.length)),
-    [activeIndex, images.length, select],
-  );
-
-  const safeIndex = Math.min(activeIndex, Math.max(0, images.length - 1));
-  return {
-    images,
-    activeIndex: safeIndex,
-    setActiveIndex: select,
-    next,
-    prev,
-    active: images[safeIndex] ?? null,
-    hasImages: images.length > 0,
-    variationIndex,
-  };
-}

package/src/commerce/storefront/useProductPrice.js

@@ -1,58 +0,0 @@
-import { useCallback, useMemo } from "react";
-import { productPrice } from "@/commerce/utils";
-import { useFormatMoney, useStoreInfo } from "./StorefrontProvider";
-
-/**
- * Money formatting in the store's currency, with the pieces a custom price UI
- * needs (parity with the admin's `useMoney`).
- *
- * @returns {{format: (n: number) => string, formatRange: (a: number, b: number) => string,
- *   code: string|null, symbol: string, decimals: number}}
- */
-export function useMoney() {
-  const format = useFormatMoney();
-  const { settings } = useStoreInfo();
-  const code = settings?.currency ?? null;
-  const formatRange = useCallback((min, max) => `${format(min)} – ${format(max)}`, [format]);
-  const symbol = useMemo(() => {
-    if (!code) return "";
-    try {
-      // The currency part of a formatted zero — locale-correct, no symbol table.
-      return new Intl.NumberFormat(undefined, { style: "currency", currency: code })
-        .formatToParts(0)
-        .find((p) => p.type === "currency")?.value ?? code;
-    } catch {
-      return code;
-    }
-  }, [code]);
-  const decimals = useMemo(() => {
-    if (!code) return 2;
-    try {
-      return new Intl.NumberFormat(undefined, { style: "currency", currency: code })
-        .resolvedOptions().maximumFractionDigits ?? 2;
-    } catch {
-      return 2;
-    }
-  }, [code]);
-
-  return { format, formatRange, code, symbol, decimals };
-}
-
-/**
- * The rendered price of a product row **or** a resolved selection view, in the
- * store's currency:
- *
- *   const price = useProductPrice(row);    // a card:         "From €19.99"
- *   const price = useProductPrice(view);   // a product page: "€19.99 – €23.99"
- *                                          //   until the selection resolves
- *   <span>{price.label}</span>
- *   {price.compareAtLabel && <s>{price.compareAtLabel}</s>}
- *
- * One call for both views is the point — the from-price rule cannot be honoured
- * on the grid and forgotten on the product page. See `productPrice` for the
- * rules themselves.
- */
-export function useProductPrice(rowOrView) {
-  const formatMoney = useFormatMoney();
-  return useMemo(() => productPrice(rowOrView, { formatMoney }), [rowOrView, formatMoney]);
-}

package/src/commerce/storefront/useProductReviews.js

@@ -1,242 +0,0 @@
-import { useCallback, useMemo, useState } from "react";
-import { storefrontErrorCode, storefrontErrorMessage } from "@/commerce/utils";
-import { useStorefront } from "./StorefrontProvider";
-import { useAsyncData } from "./internal/useAsyncData";
-
-const EMPTY_FORM = Object.freeze({ reviewer: "", email: "", review: "", rating: 5 });
-
-/**
- * useProductReviews — the review list AND the submit form, including the store
- * policy, in one hook.
- *
- *   const r = useProductReviews(product, { policy: "open" });
- *   // list:   r.items, r.averageRating, r.ratingCount, r.hasNext, r.loadMore()
- *   // form:   r.form, r.setField("review", v), r.fieldErrors, r.valid, r.submit()
- *   // after:  r.submitted && <p>{r.message}</p>
- *
- * The backend ships complete (public submission by email, moderation,
- * auto-approve); everything that used to be hand-rolled around it lives here:
- *
- * - **The confirmation copy comes from the response.** `submit()` returns the
- *   server's `status` — `"approved"` when the store has `auto_approve_reviews`
- *   on, `"hold"` otherwise — and `message` follows it. A hardcoded "awaiting
- *   approval" lies to half of all stores.
- * - **Errors are field-level.** The three server codes (`email_required`,
- *   `review_incomplete`, `invalid_rating`) land in `fieldErrors` rather than
- *   rejecting into nothing, and `valid` gates the round trip.
- * - **Submitting refreshes the list**, so an auto-approved review appears
- *   instead of being invisible until the next page load.
- * - **`requiresEmail` is false for a signed-in visitor** — the session's email
- *   always wins server-side, so asking for it again is a field that does
- *   nothing.
- *
- * `policy` replaces the prose patterns a storefront used to implement by hand:
- * `"open"` (anyone with an email — the server's own default), `"login"` (only a
- * signed-in visitor; `canReview` false with `reviewBlockedReason:
- * "login_required"`), `"verified_buyers"` (only someone whose email has a
- * completed order for this product — `"not_a_buyer"`). Policies are UI-side by
- * design: the server accepts any valid email, so a stricter rule is exactly
- * this gate.
- *
- * @param {object} product the product being reviewed (needs `id`, and `slug` to page)
- * @param {{perPage?: number, policy?: "open"|"login"|"verified_buyers",
- *   requireRating?: boolean, refreshOnSubmit?: boolean, user?: object|null,
- *   initialReviews?: object}} [options]
- *   `user` is your app's current user (Base44 auth) — pass it for the `login`
- *   and `verified_buyers` policies and to drop the email field.
- */
-export function useProductReviews(product, options = {}) {
-  const {
-    perPage = 10,
-    policy = "open",
-    requireRating = false,
-    refreshOnSubmit = true,
-    user = null,
-    initialReviews = null,
-  } = options;
-
-  const store = useStorefront();
-  const [page, setPage] = useState(1);
-  const [appended, setAppended] = useState(null);
-  const ref = product?.slug ? product.slug : product?.id ? { id: product.id } : null;
-
-  const { data, loading, refreshing, error, reload } = useAsyncData(
-    () => store.getProductReviews(ref, { page, per_page: perPage }),
-    [store, product?.id, page, perPage],
-    { enabled: Boolean(ref), initialData: page === 1 ? initialReviews : null },
-  );
-
-  const items = useMemo(() => {
-    const rows = data?.items ?? [];
-    if (!appended) return rows;
-    const byId = new Map();
-    for (const r of [...appended, ...rows]) byId.set(r.id ?? `${r.reviewer}-${r.date_created}`, r);
-    return [...byId.values()];
-  }, [data, appended]);
-
-  const hasNext = Boolean(data?.has_next);
-  const next = useCallback(() => {
-    if (hasNext) setPage((p) => p + 1);
-  }, [hasNext]);
-  const prev = useCallback(() => setPage((p) => Math.max(1, p - 1)), []);
-  const loadMore = useCallback(() => {
-    if (!hasNext) return;
-    setAppended(items);
-    setPage((p) => p + 1);
-  }, [hasNext, items]);
-
-  // ── the form ───────────────────────────────────────────────────────────────
-  const [form, setForm] = useState(() => ({
-    ...EMPTY_FORM,
-    reviewer: user?.full_name ?? "",
-    email: user?.email ?? "",
-  }));
-  const [submitting, setSubmitting] = useState(false);
-  const [submitted, setSubmitted] = useState(false);
-  const [submittedStatus, setSubmittedStatus] = useState(null);
-  const [serverError, setServerError] = useState(null);
-
-  const setField = useCallback((name, value) => {
-    setServerError(null);
-    setForm((f) => ({ ...f, [name]: value }));
-  }, []);
-  const reset = useCallback(() => {
-    setForm({ ...EMPTY_FORM, reviewer: user?.full_name ?? "", email: user?.email ?? "" });
-    setSubmitted(false);
-    setSubmittedStatus(null);
-    setServerError(null);
-  }, [user?.full_name, user?.email]);
-
-  // A signed-in visitor's email is taken from the session server-side.
-  const requiresEmail = !user?.email;
-
-  const fieldErrors = useMemo(() => {
-    const errs = {};
-    if (requiresEmail && !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(String(form.email ?? "").trim())) {
-      errs.email = "A valid email address is required.";
-    }
-    if (!String(form.review ?? "").trim()) errs.review = "Write a few words about the product.";
-    const rating = Number(form.rating);
-    if (requireRating && !(rating >= 1 && rating <= 5)) errs.rating = "Choose a rating.";
-    else if (form.rating != null && (rating < 0 || rating > 5)) errs.rating = "Rating must be 0–5.";
-    if (serverError) errs[serverErrorField(serverError.code)] = serverError.message;
-    return errs;
-  }, [form, requiresEmail, requireRating, serverError]);
-
-  // ── policy ─────────────────────────────────────────────────────────────────
-  // "Has this visitor bought it?" can only be answered from their own orders —
-  // public reviews carry no email (by design), so the answer comes from
-  // `my-orders`. Fetched only for the policy that needs it.
-  const needsPurchaseCheck = policy === "verified_buyers" && Boolean(user) && Boolean(product?.id);
-  const { data: myOrders, loading: purchaseLoading } = useAsyncData(
-    () => store.inv("commerce/storefront-account", { action: "my-orders", per_page: 50 }),
-    [store, user?.email, product?.id],
-    { enabled: needsPurchaseCheck },
-  );
-  const purchased = useMemo(() => {
-    if (!needsPurchaseCheck) return false;
-    return (myOrders?.orders ?? []).some(
-      (o) =>
-        ["completed", "processing"].includes(o.status) &&
-        (o.line_items ?? []).some((li) => li.product_id === product.id),
-    );
-  }, [needsPurchaseCheck, myOrders, product?.id]);
-
-  let reviewBlockedReason = null;
-  if ((policy === "login" || policy === "verified_buyers") && !user) {
-    reviewBlockedReason = "login_required";
-  } else if (policy === "verified_buyers" && !purchased && !purchaseLoading) {
-    reviewBlockedReason = "not_a_buyer";
-  }
-  const canReview = !reviewBlockedReason && !purchaseLoading && !submitted;
-
-  const valid = canReview && Object.keys(fieldErrors).length === 0;
-
-  const submit = useCallback(async () => {
-    if (submitting) return { ok: false, error: { code: "submitting", message: "Already submitting." } };
-    if (reviewBlockedReason) {
-      return { ok: false, error: { code: reviewBlockedReason, message: blockedMessage(reviewBlockedReason) } };
-    }
-    if (Object.keys(fieldErrors).length) {
-      return { ok: false, error: { code: "invalid_form", message: "Please complete the form." } };
-    }
-    setSubmitting(true);
-    setServerError(null);
-    try {
-      const res = await store.submitReview({
-        product_id: product?.id,
-        review: String(form.review).trim(),
-        rating: form.rating == null ? undefined : Number(form.rating),
-        reviewer: String(form.reviewer ?? "").trim() || undefined,
-        email: requiresEmail ? String(form.email).trim() : undefined,
-      });
-      setSubmitted(true);
-      setSubmittedStatus(res.status);
-      // An auto-approved review is live immediately — show it.
-      if (refreshOnSubmit && res.status === "approved") {
-        setAppended(null);
-        setPage(1);
-        reload();
-      }
-      return { ok: true, status: res.status, verified: res.verified };
-    } catch (e) {
-      const err = { code: storefrontErrorCode(e) ?? "error", message: storefrontErrorMessage(e) };
-      setServerError(err);
-      return { ok: false, error: err };
-    } finally {
-      setSubmitting(false);
-    }
-  }, [submitting, reviewBlockedReason, fieldErrors, store, product?.id, form, requiresEmail, refreshOnSubmit, reload]);
-
-  const message = submitted
-    ? submittedStatus === "approved"
-      ? "Thanks — your review is published."
-      : "Thanks — your review has been submitted for approval."
-    : null;
-
-  return {
-    // list
-    items,
-    page,
-    perPage: data?.per_page ?? perPage,
-    hasNext,
-    next,
-    prev,
-    loadMore,
-    averageRating: data?.average_rating ?? product?.average_rating ?? 0,
-    ratingCount: data?.rating_count ?? product?.rating_count ?? 0,
-    loading,
-    refreshing,
-    error,
-    reload,
-    // submission
-    form,
-    setField,
-    reset,
-    fieldErrors,
-    valid,
-    submit,
-    submitting,
-    submitted,
-    submittedStatus,
-    message,
-    // policy
-    canReview,
-    reviewBlockedReason,
-    requiresEmail,
-  };
-}
-
-/** Server error code → the form field it belongs on. */
-function serverErrorField(code) {
-  if (code === "email_required") return "email";
-  if (code === "invalid_rating") return "rating";
-  if (code === "review_incomplete") return "review";
-  return "form";
-}
-
-function blockedMessage(reason) {
-  if (reason === "login_required") return "Please sign in to write a review.";
-  if (reason === "not_a_buyer") return "Only verified buyers can review this product.";
-  return "Reviews are closed.";
-}