@aglyn/plugins-commerce 1.0.0-beta.143

package/src/lib/model/commerce-discounts.js

@@ -0,0 +1,231 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * Discounts engine v2 (AGL-305): code-based AND automatic promotions
+ * with scoping, schedules, and usage limits, superseding the AGL-96
+ * percent-only coupons (which keep working through the legacy path).
+ * One resolver serves cart, checkout, and POS. Docs live at
+ * `hosts/{hostId}/discounts`. Pure — callers own I/O and redemption
+ * increments.
+ */ import { PROMOTION_EXHAUSTED_MESSAGE, promotionExhausted } from "./commerce-promotions.js";
+/**
+ * The document a proposed discount is created as (AGL-2916): switched OFF,
+ * with no redemptions, its code in the shape the discounts card stores, and
+ * only the value its kind reads. A person switches it on from the discounts
+ * card. `null` for a proposal no discount can be made from: a percentage
+ * outside 1 to 100, or an amount off of nothing.
+ */ export function switchedOffDiscount(proposal) {
+    var _proposal_code, _proposal_minSubtotalCents;
+    const code = ((_proposal_code = proposal.code) != null ? _proposal_code : '').trim().toUpperCase().replace(/[^A-Z0-9_-]/g, '');
+    const minimum = Math.round(Number((_proposal_minSubtotalCents = proposal.minSubtotalCents) != null ? _proposal_minSubtotalCents : 0));
+    const base = _extends({
+        name: proposal.name.trim().slice(0, 80),
+        code: code || null,
+        kind: proposal.kind
+    }, minimum > 0 ? {
+        minSubtotalCents: minimum
+    } : {}, {
+        enabled: false,
+        redemptions: 0
+    });
+    if (proposal.kind === 'percent') {
+        const pct = Math.round(Number(proposal.valuePct));
+        return pct >= 1 && pct <= 100 ? _extends({}, base, {
+            valuePct: pct
+        }) : null;
+    }
+    if (proposal.kind === 'fixed') {
+        const cents = Math.round(Number(proposal.valueCents));
+        return cents > 0 ? _extends({}, base, {
+            valueCents: cents
+        }) : null;
+    }
+    return proposal.kind === 'free_shipping' ? base : null;
+}
+function applies(discount, context) {
+    var _context_nowMs;
+    var _discount_productIds;
+    const now = (_context_nowMs = context.nowMs) != null ? _context_nowMs : Date.now();
+    if (discount.enabled === false) return 'This discount is disabled';
+    if (discount.startAtMs != null && now < discount.startAtMs) {
+        return 'This discount has not started yet';
+    }
+    if (discount.endAtMs != null && now > discount.endAtMs) {
+        return 'This discount has expired';
+    }
+    // Holds count (AGL-2453). This read used to be `redemptions` alone, which is
+    // a figure that only moves once the webhook lands — minutes after this
+    // question is asked and answered. Every shopper who reached checkout while
+    // the counter sat one below the cap passed, so the cap bounded nothing but
+    // the paperwork. `promotionExhausted` counts the slots currently held by live
+    // checkouts as taken, which is the same question the in-transaction re-read
+    // asks below in `promotion-hold.ts` — deliberately the same function, so the
+    // pre-filter and the enforcement cannot drift.
+    if (promotionExhausted(discount, now)) {
+        return PROMOTION_EXHAUSTED_MESSAGE;
+    }
+    if (discount.minSubtotalCents != null && context.subtotalCents < discount.minSubtotalCents) {
+        return `Spend $${(discount.minSubtotalCents / 100).toFixed(2)} to use this`;
+    }
+    if (((_discount_productIds = discount.productIds) == null ? void 0 : _discount_productIds.length) && !context.productIds.some((id)=>discount.productIds.includes(id))) {
+        return 'This discount does not apply to your items';
+    }
+    return null;
+}
+/**
+ * The single derivation of what one discount is worth against one subtotal.
+ *
+ * Exhaustive over {@link DiscountKind} by construction: the `never` binding
+ * below fails the BUILD when a kind is added to the union and not handled
+ * here, so the next `free_shipping` cannot reach production as a silent zero.
+ * The runtime arm underneath it is not redundant — Firestore documents are not
+ * typechecked, and a `kind` written by a newer build than the one reading it
+ * arrives as an ordinary unrecognised string.
+ */ export function discountBenefit(discount, subtotalCents, lines) {
+    const kind = discount.kind;
+    if (kind === 'percent' || kind === 'fixed') {
+        var _discount_valuePct, _discount_valueCents;
+        // WHAT A SCOPE IS WORTH.
+        //
+        // `applies` already refuses a cart containing NONE of the scoped products,
+        // so the scope was never entirely dead — but the amount was still computed
+        // against the whole subtotal. A discount scoped to three products
+        // therefore discounted the entire basket the moment one of the three was
+        // in it: the merchant chose a scope, we charged as though they had not,
+        // and the margin went with it.
+        //
+        // A scoped discount with no line detail REFUSES rather than falling back
+        // to the whole subtotal. The fallback is the defect restated, and it would
+        // be a second pricing path for one feature split by what the caller
+        // happened to pass.
+        const scope = discount.productIds;
+        let base = subtotalCents;
+        if (scope == null ? void 0 : scope.length) {
+            if (!lines) {
+                return {
+                    kind: 'none',
+                    reason: 'this discount covers only some products, and the cart did not ' + 'say what each item costs'
+                };
+            }
+            base = lines.filter((line)=>scope.includes(line.productId)).reduce((sum, line)=>{
+                var _line_amountCents;
+                return sum + Math.max(0, Math.round(Number((_line_amountCents = line.amountCents) != null ? _line_amountCents : 0)));
+            }, 0);
+        }
+        const centsOff = kind === 'percent' ? Math.round(base * Math.min(100, Math.max(0, (_discount_valuePct = discount.valuePct) != null ? _discount_valuePct : 0)) / 100) : Math.min(base, Math.max(0, (_discount_valueCents = discount.valueCents) != null ? _discount_valueCents : 0));
+        // A discount configured to take nothing off — 0%, or a zero amount — is
+        // worth nothing, and saying so is what stops it being applied as a
+        // successful reduction of zero.
+        return centsOff > 0 ? {
+            kind: 'amount',
+            centsOff
+        } : {
+            kind: 'none',
+            reason: 'this discount takes nothing off the items in the cart'
+        };
+    }
+    if (kind === 'free_shipping') return {
+        kind: 'free-shipping'
+    };
+    // Unreachable while `DiscountKind` is fully handled above; the annotation is
+    // what makes adding a kind a compile error rather than a quiet no-op.
+    const unhandled = kind;
+    return {
+        kind: 'none',
+        reason: `this store has a discount of a kind this site cannot apply (${String(unhandled)})`
+    };
+}
+/**
+ * Best applicable discount: an entered code wins when valid (its
+ * failure reason is surfaced); otherwise the largest automatic
+ * promotion applies. Discounts never stack — Squarespace/Shopify
+ * baseline semantics.
+ */ export function resolveDiscount(discounts, context) {
+    var _context_code;
+    const entered = (_context_code = context.code) == null ? void 0 : _context_code.trim().toUpperCase();
+    if (entered) {
+        const coded = discounts.find((discount)=>{
+            var _discount_code;
+            return ((_discount_code = discount.code) == null ? void 0 : _discount_code.toUpperCase()) === entered;
+        });
+        if (!coded) return null;
+        const problem = applies(coded, context);
+        if (problem) {
+            return {
+                discount: coded,
+                discountId: coded.$id,
+                discountCents: 0,
+                freeShipping: false,
+                benefit: {
+                    kind: 'none',
+                    reason: problem
+                },
+                codeProblem: problem
+            };
+        }
+        const benefit = discountBenefit(coded, context.subtotalCents, context.lines);
+        // A code the shopper TYPED that turns out to be worth nothing is reported
+        // as a code problem, so it leaves through the caller's existing refusal
+        // rather than as a successful discount of zero. This is the free-shipping
+        // defect's actual exit: the caller's apply-block tests `discountCents > 0`
+        // and its invalid-code branch only fires when nothing resolved, so a
+        // benefit of `none` used to satisfy neither and the shopper was charged in
+        // full without a word.
+        if (benefit.kind === 'none') {
+            return {
+                discount: coded,
+                discountId: coded.$id,
+                discountCents: 0,
+                freeShipping: false,
+                benefit,
+                codeProblem: benefit.reason
+            };
+        }
+        return {
+            discount: coded,
+            discountId: coded.$id,
+            discountCents: benefit.kind === 'amount' ? benefit.centsOff : 0,
+            freeShipping: benefit.kind === 'free-shipping',
+            benefit
+        };
+    }
+    let best = null;
+    for (const discount of discounts){
+        if (discount.code) continue;
+        if (applies(discount, context)) continue;
+        const benefit = discountBenefit(discount, context.subtotalCents, context.lines);
+        // An automatic promotion worth nothing is passed over rather than reported:
+        // nobody asked for it, so there is no shopper to answer and a better one
+        // may still be in the list. An entered CODE is the opposite case and
+        // refuses above — the shopper made a request and is owed the reason.
+        if (benefit.kind === 'none') continue;
+        const cents = benefit.kind === 'amount' ? benefit.centsOff : 0;
+        const candidate = {
+            discount,
+            discountId: discount.$id,
+            discountCents: cents,
+            freeShipping: benefit.kind === 'free-shipping',
+            benefit
+        };
+        if (!best || cents > best.discountCents || candidate.freeShipping && !best.freeShipping && cents === best.discountCents) {
+            best = candidate;
+        }
+    }
+    return best;
+}
+
+//# sourceMappingURL=commerce-discounts.js.map

package/src/lib/model/commerce-discounts.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/commerce/src/lib/model/commerce-discounts.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Discounts engine v2 (AGL-305): code-based AND automatic promotions\n * with scoping, schedules, and usage limits, superseding the AGL-96\n * percent-only coupons (which keep working through the legacy path).\n * One resolver serves cart, checkout, and POS. Docs live at\n * `hosts/{hostId}/discounts`. Pure — callers own I/O and redemption\n * increments.\n */\n\nimport {\n  PROMOTION_EXHAUSTED_MESSAGE,\n  type PromotionHold,\n  promotionExhausted,\n} from './commerce-promotions'\n\nexport type DiscountKind = 'percent' | 'fixed' | 'free_shipping'\n\n/** `hosts/{hostId}/discounts/{id}` doc. */\nexport interface HostDiscount {\n  /** Uppercase entry code; absent = automatic (applies to every cart). */\n  code?: string\n  /** Display name for automatic promotions (\"Summer sale\"). */\n  name?: string\n  kind: DiscountKind\n  /** percent kind: 1-100. */\n  valuePct?: number\n  /** fixed kind: cents off the items subtotal. */\n  valueCents?: number\n  /** Only carts at/above this subtotal qualify. */\n  minSubtotalCents?: number\n  /** Scope: at least one cart line must be one of these products. */\n  productIds?: string[]\n  maxRedemptions?: number\n  redemptions?: number\n  /**\n   * In-flight claims on the remaining slots (AGL-2453), keyed by checkout\n   * attempt. Counted as redeemed by {@link applies} for as long as they stand,\n   * which is what stops N concurrent checkouts all passing a cap of one.\n   */\n  holds?: Record<string, PromotionHold>\n  startAtMs?: number\n  endAtMs?: number\n  enabled?: boolean\n}\n\n/** A discount proposed for a store, before anyone has switched it on (AGL-2916). */\nexport interface ProposedDiscount {\n  name: string\n  /** The code a shopper types, or `null` for a discount that applies on its own. */\n  code: string | null\n  kind: DiscountKind\n  valuePct: number | null\n  valueCents: number | null\n  minSubtotalCents: number | null\n}\n\n/** A stored discount as the discounts card writes one: an automatic discount's code is `null`. */\nexport type StoredDiscount = Omit<HostDiscount, 'code'> & { code: string | null }\n\n/**\n * The document a proposed discount is created as (AGL-2916): switched OFF,\n * with no redemptions, its code in the shape the discounts card stores, and\n * only the value its kind reads. A person switches it on from the discounts\n * card. `null` for a proposal no discount can be made from: a percentage\n * outside 1 to 100, or an amount off of nothing.\n */\nexport function switchedOffDiscount(proposal: ProposedDiscount): StoredDiscount | null {\n  const code = (proposal.code ?? '').trim().toUpperCase().replace(/[^A-Z0-9_-]/g, '')\n  const minimum = Math.round(Number(proposal.minSubtotalCents ?? 0))\n  const base: StoredDiscount = {\n    name: proposal.name.trim().slice(0, 80),\n    code: code || null,\n    kind: proposal.kind,\n    ...(minimum > 0 ? { minSubtotalCents: minimum } : {}),\n    enabled: false,\n    redemptions: 0,\n  }\n  if (proposal.kind === 'percent') {\n    const pct = Math.round(Number(proposal.valuePct))\n    return pct >= 1 && pct <= 100 ? { ...base, valuePct: pct } : null\n  }\n  if (proposal.kind === 'fixed') {\n    const cents = Math.round(Number(proposal.valueCents))\n    return cents > 0 ? { ...base, valueCents: cents } : null\n  }\n  return proposal.kind === 'free_shipping' ? base : null\n}\n\nexport interface DiscountContext {\n  /** Entered code, if any (case-insensitive). */\n  code?: string\n  subtotalCents: number\n  /** Product ids present in the cart (scope checks). */\n  productIds: string[]\n  /**\n   * What each cart line is worth, for pricing a SCOPED discount.\n   *\n   * Required whenever a discount carries `productIds`, and the reason is that\n   * `subtotalCents` alone cannot price one: a scope names some of the cart, so\n   * the discount is worth some of the cart. A caller that omits these gets a\n   * refusal rather than a whole-cart discount — see `discountBenefit`.\n   */\n  lines?: readonly { productId: string; amountCents: number }[]\n  nowMs?: number\n}\n\nexport interface ResolvedDiscount {\n  discount: HostDiscount\n  discountId: string\n  discountCents: number\n  freeShipping: boolean\n  /**\n   * What this discount confers, as one value. `discountCents` and\n   * `freeShipping` are projections of it and are kept because callers read\n   * them; the benefit is what a caller should GATE on, because it is the only\n   * one of the three that can say \"nothing, and here is why\".\n   */\n  benefit: DiscountBenefit\n  /** Why a specifically-entered code failed; unset when one applied. */\n  codeProblem?: string\n}\n\nfunction applies(\n  discount: HostDiscount,\n  context: DiscountContext,\n): string | null {\n  const now = context.nowMs ?? Date.now()\n  if (discount.enabled === false) return 'This discount is disabled'\n  if (discount.startAtMs != null && now < discount.startAtMs) {\n    return 'This discount has not started yet'\n  }\n  if (discount.endAtMs != null && now > discount.endAtMs) {\n    return 'This discount has expired'\n  }\n  // Holds count (AGL-2453). This read used to be `redemptions` alone, which is\n  // a figure that only moves once the webhook lands — minutes after this\n  // question is asked and answered. Every shopper who reached checkout while\n  // the counter sat one below the cap passed, so the cap bounded nothing but\n  // the paperwork. `promotionExhausted` counts the slots currently held by live\n  // checkouts as taken, which is the same question the in-transaction re-read\n  // asks below in `promotion-hold.ts` — deliberately the same function, so the\n  // pre-filter and the enforcement cannot drift.\n  if (promotionExhausted(discount, now)) {\n    return PROMOTION_EXHAUSTED_MESSAGE\n  }\n  if (\n    discount.minSubtotalCents != null &&\n    context.subtotalCents < discount.minSubtotalCents\n  ) {\n    return `Spend $${(discount.minSubtotalCents / 100).toFixed(2)} to use this`\n  }\n  if (\n    discount.productIds?.length &&\n    !context.productIds.some((id) => discount.productIds!.includes(id))\n  ) {\n    return 'This discount does not apply to your items'\n  }\n  return null\n}\n\n/**\n * WHAT A DISCOUNT ACTUALLY CONFERS, named rather than implied.\n *\n * The whole point of this type is that \"nothing\" is a STATED outcome with a\n * reason, not the number zero. `valueCents` used to answer a bare `number`,\n * and every kind it did not understand — `free_shipping` included — answered\n * `0`. The cart's apply-block gates on `discountCents > 0`, and the\n * invalid-code 400 beside it only fires when NO discount resolved at all, so a\n * free-shipping code took neither branch: it resolved successfully, conferred\n * nothing, raised no error, and the shopper paid full shipping. A silent zero\n * cannot be told from \"this discount is worth nothing\", which is exactly the\n * distinction a money path has to make.\n *\n * So a caller cannot read a benefit without also seeing the `none` case, and a\n * kind this build does not recognise reports itself instead of underpaying.\n */\nexport type DiscountBenefit =\n  /** Cents off the items subtotal. Always > 0 — a zero lands on `none`. */\n  | { kind: 'amount'; centsOff: number }\n  /** The shopper pays no shipping, whichever rate they pick. */\n  | { kind: 'free-shipping' }\n  /** Resolvable, but worth nothing. The caller must refuse, never proceed. */\n  | { kind: 'none'; reason: string }\n\n/**\n * The single derivation of what one discount is worth against one subtotal.\n *\n * Exhaustive over {@link DiscountKind} by construction: the `never` binding\n * below fails the BUILD when a kind is added to the union and not handled\n * here, so the next `free_shipping` cannot reach production as a silent zero.\n * The runtime arm underneath it is not redundant — Firestore documents are not\n * typechecked, and a `kind` written by a newer build than the one reading it\n * arrives as an ordinary unrecognised string.\n */\nexport function discountBenefit(\n  discount: HostDiscount,\n  subtotalCents: number,\n  lines?: readonly { productId: string; amountCents: number }[],\n): DiscountBenefit {\n  const kind = discount.kind\n  if (kind === 'percent' || kind === 'fixed') {\n    // WHAT A SCOPE IS WORTH.\n    //\n    // `applies` already refuses a cart containing NONE of the scoped products,\n    // so the scope was never entirely dead — but the amount was still computed\n    // against the whole subtotal. A discount scoped to three products\n    // therefore discounted the entire basket the moment one of the three was\n    // in it: the merchant chose a scope, we charged as though they had not,\n    // and the margin went with it.\n    //\n    // A scoped discount with no line detail REFUSES rather than falling back\n    // to the whole subtotal. The fallback is the defect restated, and it would\n    // be a second pricing path for one feature split by what the caller\n    // happened to pass.\n    const scope = discount.productIds\n    let base = subtotalCents\n    if (scope?.length) {\n      if (!lines) {\n        return {\n          kind: 'none',\n          reason:\n            'this discount covers only some products, and the cart did not ' +\n            'say what each item costs',\n        }\n      }\n      base = lines\n        .filter((line) => scope.includes(line.productId))\n        .reduce(\n          (sum, line) => sum + Math.max(0, Math.round(Number(line.amountCents ?? 0))),\n          0,\n        )\n    }\n    const centsOff =\n      kind === 'percent'\n        ? Math.round(\n            (base * Math.min(100, Math.max(0, discount.valuePct ?? 0))) / 100,\n          )\n        : Math.min(base, Math.max(0, discount.valueCents ?? 0))\n    // A discount configured to take nothing off — 0%, or a zero amount — is\n    // worth nothing, and saying so is what stops it being applied as a\n    // successful reduction of zero.\n    return centsOff > 0\n      ? { kind: 'amount', centsOff }\n      : {\n          kind: 'none',\n          reason: 'this discount takes nothing off the items in the cart',\n        }\n  }\n  if (kind === 'free_shipping') return { kind: 'free-shipping' }\n  // Unreachable while `DiscountKind` is fully handled above; the annotation is\n  // what makes adding a kind a compile error rather than a quiet no-op.\n  const unhandled: never = kind\n  return {\n    kind: 'none',\n    reason: `this store has a discount of a kind this site cannot apply (${String(\n      unhandled,\n    )})`,\n  }\n}\n\n/**\n * Best applicable discount: an entered code wins when valid (its\n * failure reason is surfaced); otherwise the largest automatic\n * promotion applies. Discounts never stack — Squarespace/Shopify\n * baseline semantics.\n */\nexport function resolveDiscount(\n  discounts: Array<HostDiscount & { $id: string }>,\n  context: DiscountContext,\n): ResolvedDiscount | null {\n  const entered = context.code?.trim().toUpperCase()\n  if (entered) {\n    const coded = discounts.find(\n      (discount) => discount.code?.toUpperCase() === entered,\n    )\n    if (!coded) return null\n    const problem = applies(coded, context)\n    if (problem) {\n      return {\n        discount: coded,\n        discountId: coded.$id,\n        discountCents: 0,\n        freeShipping: false,\n        benefit: { kind: 'none', reason: problem },\n        codeProblem: problem,\n      }\n    }\n    const benefit = discountBenefit(coded, context.subtotalCents, context.lines)\n    // A code the shopper TYPED that turns out to be worth nothing is reported\n    // as a code problem, so it leaves through the caller's existing refusal\n    // rather than as a successful discount of zero. This is the free-shipping\n    // defect's actual exit: the caller's apply-block tests `discountCents > 0`\n    // and its invalid-code branch only fires when nothing resolved, so a\n    // benefit of `none` used to satisfy neither and the shopper was charged in\n    // full without a word.\n    if (benefit.kind === 'none') {\n      return {\n        discount: coded,\n        discountId: coded.$id,\n        discountCents: 0,\n        freeShipping: false,\n        benefit,\n        codeProblem: benefit.reason,\n      }\n    }\n    return {\n      discount: coded,\n      discountId: coded.$id,\n      discountCents: benefit.kind === 'amount' ? benefit.centsOff : 0,\n      freeShipping: benefit.kind === 'free-shipping',\n      benefit,\n    }\n  }\n  let best: ResolvedDiscount | null = null\n  for (const discount of discounts) {\n    if (discount.code) continue\n    if (applies(discount, context)) continue\n    const benefit = discountBenefit(discount, context.subtotalCents, context.lines)\n    // An automatic promotion worth nothing is passed over rather than reported:\n    // nobody asked for it, so there is no shopper to answer and a better one\n    // may still be in the list. An entered CODE is the opposite case and\n    // refuses above — the shopper made a request and is owed the reason.\n    if (benefit.kind === 'none') continue\n    const cents = benefit.kind === 'amount' ? benefit.centsOff : 0\n    const candidate: ResolvedDiscount = {\n      discount,\n      discountId: discount.$id,\n      discountCents: cents,\n      freeShipping: benefit.kind === 'free-shipping',\n      benefit,\n    }\n    if (\n      !best ||\n      cents > best.discountCents ||\n      (candidate.freeShipping && !best.freeShipping && cents === best.discountCents)\n    ) {\n      best = candidate\n    }\n  }\n  return best\n}\n"],"names":["PROMOTION_EXHAUSTED_MESSAGE","promotionExhausted","switchedOffDiscount","proposal","code","trim","toUpperCase","replace","minimum","Math","round","Number","minSubtotalCents","base","name","slice","kind","enabled","redemptions","pct","valuePct","cents","valueCents","applies","discount","context","now","nowMs","Date","startAtMs","endAtMs","subtotalCents","toFixed","productIds","length","some","id","includes","discountBenefit","lines","scope","reason","filter","line","productId","reduce","sum","max","amountCents","centsOff","min","unhandled","String","resolveDiscount","discounts","entered","coded","find","problem","discountId","$id","discountCents","freeShipping","benefit","codeProblem","best","candidate"],"mappings":"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"}

package/src/lib/model/commerce-dispute.d.ts

@@ -0,0 +1,124 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { HostOrder, OrderDispute } from './commerce-orders';
+/** How the merchant should read a dispute at a glance. */
+export type OrderDisputeTone = 'open' | 'lost' | 'won' | 'settled';
+/**
+ * A dispute Stripe has not decided yet — the case with a DEADLINE attached.
+ *
+ * Three independent signals, all of which must say "open", because saying
+ * "evidence due" about a settled dispute is the one error with a cost: it
+ * sends a merchant to gather documents for a case that is closed. `outcome`
+ * and `closedAtMs` are both written by `charge.dispute.closed` and `status` is
+ * overwritten with the outcome, so a record that disagrees with itself is
+ * malformed — and this resolves a malformed record to "settled", the answer
+ * that cannot waste anyone's afternoon.
+ *
+ * Note `evidenceDueByMs` is NOT one of the signals: Stripe sends
+ * `evidence_details.due_by` on the `closed` event too, so a closed dispute
+ * still carries a deadline and testing for one would report every settled
+ * dispute as open.
+ */
+export declare function isOrderDisputeOpen(dispute?: OrderDispute): boolean;
+/** Whether this order has a dispute still running against it. */
+export declare function orderHasOpenDispute(order: Pick<HostOrder, 'dispute'>): boolean;
+/**
+ * Whether a refund on this order must be REFUSED because of its dispute
+ * (AGL-1809).
+ *
+ * Not the same question as `orderHasOpenDispute`, and the difference is the
+ * whole decision. A formal open dispute (`needs_response`, `under_review`)
+ * means the bank has already pulled the disputed funds and Stripe's refund
+ * API refuses the charge outright (`charge_disputed` — "The charge you're
+ * attempting to refund has been charged back"); a refund alongside it would
+ * pay the shopper twice, once by the refund and once by the chargeback. An
+ * open INQUIRY is the opposite case: no money has moved, Stripe permits the
+ * refund, and its docs name "issuing a full refund" as the way to resolve an
+ * inquiry before it escalates — refusing that would forbid the recommended
+ * exit. Settled disputes refuse nothing here: a lost one already moved the
+ * order to `refunded` (the status guard's job), and a won or closed one left
+ * the charge refundable again.
+ *
+ * An open dispute whose status is unrecognised blocks — on a question of
+ * sending money twice, an unknown state fails closed.
+ */
+export declare function orderDisputeBlocksRefund(order: Pick<HostOrder, 'dispute'>): boolean;
+/** What the console renders beside an order's status when a dispute exists. */
+export interface OrderDisputeBadge {
+    tone: OrderDisputeTone;
+    /** Short chip label, e.g. `Chargeback open`, `Charged back`. */
+    label: string;
+    /** A sentence for the tooltip: reason, amount, deadline or outcome. */
+    detail: string;
+    /** The deadline, present ONLY while the dispute is open. */
+    evidenceDueByMs?: number;
+    /**
+     * Whole days until evidence is due, negative once the deadline has passed.
+     * Present only alongside `evidenceDueByMs`.
+     */
+    evidenceDaysLeft?: number;
+}
+/**
+ * The badge for an order's dispute, or `null` when there is none.
+ *
+ * `nowMs` is a parameter rather than a `Date.now()` call so the deadline
+ * arithmetic is testable without freezing the clock.
+ */
+export declare function describeOrderDispute(order: Pick<HostOrder, 'dispute'>, nowMs?: number): OrderDisputeBadge | null;
+/** What the orders list needs to raise the alarm, over a window of orders. */
+export interface OpenDisputeSummary {
+    /** Orders with a dispute still running. */
+    count: number;
+    /** The soonest evidence deadline among them, when any carries one. */
+    soonestDueByMs?: number;
+    /** Whole days to `soonestDueByMs`; negative once it has passed. */
+    soonestDaysLeft?: number;
+    /** True when at least one deadline is already behind us. */
+    overdue: boolean;
+}
+/**
+ * Count the open disputes in a window of orders and find the tightest
+ * deadline (AGL-1796).
+ *
+ * A filter only helps a merchant who already suspects there is something to
+ * filter FOR, and an evidence window is days long — so the orders list has to
+ * say it unprompted. Computed over every loaded order rather than the visible
+ * ones: a merchant filtered to "delivered" still needs to know a dispute is
+ * running on a `paid` one.
+ */
+export declare function summariseOpenDisputes(orders: ReadonlyArray<Pick<HostOrder, 'dispute'>>, nowMs?: number): OpenDisputeSummary;
+/** Money off this order, split by the door it left through. */
+export interface OrderReversalSplit {
+    /** Cents refunded by a decision the merchant made. */
+    refundedCents: number;
+    /** Cents taken back by a lost chargeback. */
+    chargedBackCents: number;
+}
+/**
+ * Split `order.refundedCents` into the part the merchant chose and the part
+ * a chargeback took.
+ *
+ * AGL-1787 writes BOTH into `refundedCents`, deliberately — money reversed is
+ * money reversed, and the CSV, the analytics card and the member drawer all
+ * want the total. Only the label needs the split, and `dispute.reversedCents`
+ * is the piece to subtract.
+ *
+ * The chargeback share is clamped to the recorded total, so a `reversedCents`
+ * larger than `refundedCents` (which can only mean the two fields disagree)
+ * yields a zero refund line rather than a negative one.
+ */
+export declare function splitOrderReversal(order: Pick<HostOrder, 'refundedCents' | 'dispute'>): OrderReversalSplit;

package/src/lib/model/commerce-dispute.js

@@ -0,0 +1,225 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * Reading a chargeback back out of an order (AGL-1796).
+ *
+ * AGL-1787 decided that a lost dispute leaves the order `status: 'refunded'`,
+ * because five entitlement gates match that literal and a new status would
+ * have escaped all of them. The cost of that decision is paid HERE: a merchant
+ * opening the order sees "Refunded", the one word that says they chose it.
+ * The distinction rides on the `dispute` record beside the status, and these
+ * are the pure readers that turn it back into something a console can say.
+ *
+ * Kept out of `commerce-orders.ts` on the same principle the model directory
+ * already follows — cart, discounts, shipping and tax each own a file — and
+ * because this is presentation-shaped: it answers "what should the merchant be
+ * told", not "what is true of the order".
+ *
+ * Dates render as `YYYY-MM-DD` through `toISOString`, which is what the
+ * webhook's own timeline entries do. Deterministic, and the console shows
+ * these strings beside those entries.
+ */ /**
+ * Stripe dispute statuses that mean it is over.
+ *
+ * `warning_*` statuses belong to an inquiry that has not become a dispute yet;
+ * `warning_closed` is the one that ends. The other `warning_*` values
+ * (`warning_needs_response`, `warning_under_review`) are OPEN, which is why
+ * this is a settled-list rather than a "starts with warning" test.
+ */ const SETTLED_DISPUTE_STATUSES = new Set([
+    'won',
+    'lost',
+    'warning_closed'
+]);
+/**
+ * A dispute Stripe has not decided yet — the case with a DEADLINE attached.
+ *
+ * Three independent signals, all of which must say "open", because saying
+ * "evidence due" about a settled dispute is the one error with a cost: it
+ * sends a merchant to gather documents for a case that is closed. `outcome`
+ * and `closedAtMs` are both written by `charge.dispute.closed` and `status` is
+ * overwritten with the outcome, so a record that disagrees with itself is
+ * malformed — and this resolves a malformed record to "settled", the answer
+ * that cannot waste anyone's afternoon.
+ *
+ * Note `evidenceDueByMs` is NOT one of the signals: Stripe sends
+ * `evidence_details.due_by` on the `closed` event too, so a closed dispute
+ * still carries a deadline and testing for one would report every settled
+ * dispute as open.
+ */ export function isOrderDisputeOpen(dispute) {
+    var _dispute_status;
+    if (!dispute) return false;
+    if (dispute.outcome) return false;
+    if (dispute.closedAtMs) return false;
+    return !SETTLED_DISPUTE_STATUSES.has(String((_dispute_status = dispute.status) != null ? _dispute_status : ''));
+}
+/** Whether this order has a dispute still running against it. */ export function orderHasOpenDispute(order) {
+    return isOrderDisputeOpen(order == null ? void 0 : order.dispute);
+}
+/**
+ * The OPEN statuses that belong to an INQUIRY — the pre-dispute phase, where
+ * no chargeback exists yet and no funds have been pulled.
+ *
+ * An explicit list rather than a "starts with warning" test, for the same
+ * reason as `SETTLED_DISPUTE_STATUSES` above: `warning_closed` also starts
+ * with `warning`, and an unknown future status must not be mistaken for a
+ * refundable inquiry by its prefix.
+ */ const OPEN_INQUIRY_STATUSES = new Set([
+    'warning_needs_response',
+    'warning_under_review'
+]);
+/**
+ * Whether a refund on this order must be REFUSED because of its dispute
+ * (AGL-1809).
+ *
+ * Not the same question as `orderHasOpenDispute`, and the difference is the
+ * whole decision. A formal open dispute (`needs_response`, `under_review`)
+ * means the bank has already pulled the disputed funds and Stripe's refund
+ * API refuses the charge outright (`charge_disputed` — "The charge you're
+ * attempting to refund has been charged back"); a refund alongside it would
+ * pay the shopper twice, once by the refund and once by the chargeback. An
+ * open INQUIRY is the opposite case: no money has moved, Stripe permits the
+ * refund, and its docs name "issuing a full refund" as the way to resolve an
+ * inquiry before it escalates — refusing that would forbid the recommended
+ * exit. Settled disputes refuse nothing here: a lost one already moved the
+ * order to `refunded` (the status guard's job), and a won or closed one left
+ * the charge refundable again.
+ *
+ * An open dispute whose status is unrecognised blocks — on a question of
+ * sending money twice, an unknown state fails closed.
+ */ export function orderDisputeBlocksRefund(order) {
+    var _ref;
+    var _order_dispute;
+    if (!orderHasOpenDispute(order)) return false;
+    return !OPEN_INQUIRY_STATUSES.has(String((_ref = (_order_dispute = order.dispute) == null ? void 0 : _order_dispute.status) != null ? _ref : ''));
+}
+/** `product_not_received` reads as `product not received`. */ function humanReason(reason) {
+    return String(reason != null ? reason : '').replace(/_/g, ' ').trim();
+}
+const isoDay = (ms)=>new Date(ms).toISOString().slice(0, 10);
+const usd = (cents)=>`$${(Math.max(0, cents) / 100).toFixed(2)}`;
+/**
+ * The badge for an order's dispute, or `null` when there is none.
+ *
+ * `nowMs` is a parameter rather than a `Date.now()` call so the deadline
+ * arithmetic is testable without freezing the clock.
+ */ export function describeOrderDispute(order, nowMs = Date.now()) {
+    var _ref, _dispute_outcome;
+    const dispute = order == null ? void 0 : order.dispute;
+    if (!dispute) return null;
+    const reason = humanReason(dispute.reason);
+    const because = reason ? ` (${reason})` : '';
+    if (isOrderDisputeOpen(dispute)) {
+        var _dispute_evidenceDueByMs;
+        const dueBy = Number((_dispute_evidenceDueByMs = dispute.evidenceDueByMs) != null ? _dispute_evidenceDueByMs : 0);
+        // `Math.ceil` so a deadline eight hours away reads as "1 day left" rather
+        // than "0" — rounding a live deadline down to zero reads as expired.
+        const daysLeft = dueBy > 0 ? Math.ceil((dueBy - nowMs) / 86400000) : undefined;
+        return _extends({
+            tone: 'open',
+            label: 'Chargeback open',
+            detail: `${usd(dispute.amountCents)} disputed${because}, opened ` + `${isoDay(dispute.openedAtMs)}. ` + (dueBy > 0 ? `Evidence is due to Stripe by ${isoDay(dueBy)}` + (daysLeft !== undefined && daysLeft >= 0 ? ` — ${daysLeft} day${daysLeft === 1 ? '' : 's'} left.` : ' — that deadline has passed.') : 'Respond in the Stripe dashboard while the case is open.')
+        }, dueBy > 0 ? {
+            evidenceDueByMs: dueBy,
+            evidenceDaysLeft: daysLeft
+        } : {});
+    }
+    const outcome = String((_ref = (_dispute_outcome = dispute.outcome) != null ? _dispute_outcome : dispute.status) != null ? _ref : '');
+    const closed = dispute.closedAtMs ? ` on ${isoDay(dispute.closedAtMs)}` : '';
+    if (outcome === 'lost') {
+        var _dispute_reversedCents;
+        const reversed = Number((_dispute_reversedCents = dispute.reversedCents) != null ? _dispute_reversedCents : 0);
+        return {
+            tone: 'lost',
+            label: 'Charged back',
+            // The reversed figure can be LESS than the disputed one: AGL-1787 caps
+            // the reversal against what is left, so a partly-refunded order loses
+            // only the remainder. Saying only the disputed amount would overstate
+            // what left the merchant's books.
+            detail: `Dispute lost${closed}. ${usd(reversed)} was taken back` + `${because}` + (reversed < dispute.amountCents ? ` (of ${usd(dispute.amountCents)} disputed — the rest was already refunded).` : '.')
+        };
+    }
+    if (outcome === 'won') {
+        return {
+            tone: 'won',
+            label: 'Dispute won',
+            detail: `Dispute won${closed}${because} — no money was reversed.`
+        };
+    }
+    return {
+        tone: 'settled',
+        label: 'Dispute closed',
+        detail: `Dispute closed${closed}${because}` + (outcome ? ` as ${humanReason(outcome)}` : '') + ' — no money was reversed.'
+    };
+}
+/**
+ * Count the open disputes in a window of orders and find the tightest
+ * deadline (AGL-1796).
+ *
+ * A filter only helps a merchant who already suspects there is something to
+ * filter FOR, and an evidence window is days long — so the orders list has to
+ * say it unprompted. Computed over every loaded order rather than the visible
+ * ones: a merchant filtered to "delivered" still needs to know a dispute is
+ * running on a `paid` one.
+ */ export function summariseOpenDisputes(orders, nowMs = Date.now()) {
+    let count = 0;
+    let soonestDueByMs;
+    for (const order of orders != null ? orders : []){
+        var _ref;
+        var _order_dispute;
+        if (!orderHasOpenDispute(order)) continue;
+        count += 1;
+        const dueBy = Number((_ref = (_order_dispute = order.dispute) == null ? void 0 : _order_dispute.evidenceDueByMs) != null ? _ref : 0);
+        if (dueBy > 0 && (soonestDueByMs === undefined || dueBy < soonestDueByMs)) {
+            soonestDueByMs = dueBy;
+        }
+    }
+    if (soonestDueByMs === undefined) return {
+        count,
+        overdue: false
+    };
+    const soonestDaysLeft = Math.ceil((soonestDueByMs - nowMs) / 86400000);
+    return {
+        count,
+        soonestDueByMs,
+        soonestDaysLeft,
+        overdue: soonestDueByMs < nowMs
+    };
+}
+/**
+ * Split `order.refundedCents` into the part the merchant chose and the part
+ * a chargeback took.
+ *
+ * AGL-1787 writes BOTH into `refundedCents`, deliberately — money reversed is
+ * money reversed, and the CSV, the analytics card and the member drawer all
+ * want the total. Only the label needs the split, and `dispute.reversedCents`
+ * is the piece to subtract.
+ *
+ * The chargeback share is clamped to the recorded total, so a `reversedCents`
+ * larger than `refundedCents` (which can only mean the two fields disagree)
+ * yields a zero refund line rather than a negative one.
+ */ export function splitOrderReversal(order) {
+    var _ref, _ref1;
+    var _order_dispute;
+    const total = Math.max(0, Number((_ref = order == null ? void 0 : order.refundedCents) != null ? _ref : 0) || 0);
+    const chargedBackCents = Math.min(total, Math.max(0, Number((_ref1 = order == null ? void 0 : (_order_dispute = order.dispute) == null ? void 0 : _order_dispute.reversedCents) != null ? _ref1 : 0) || 0));
+    return {
+        refundedCents: total - chargedBackCents,
+        chargedBackCents
+    };
+}
+
+//# sourceMappingURL=commerce-dispute.js.map