@final-commerce/common 2.5.1-preprod.4 → 2.6.0-staging.2

package/dist/index.mjs

@@ -237,7 +237,6 @@ var InventorySpecificActionType = /* @__PURE__ */ ((InventorySpecificActionType2
   InventorySpecificActionType2["PO_RECEIVED"] = "PO_RECEIVED";
   InventorySpecificActionType2["EXTERNAL_SALE"] = "EXTERNAL_SALE";
   InventorySpecificActionType2["EXTERNAL_RESTOCK"] = "EXTERNAL_RESTOCK";
-  InventorySpecificActionType2["CUSTOM"] = "CUSTOM";
   return InventorySpecificActionType2;
 })(InventorySpecificActionType || {});
 var ExtensionCategory = /* @__PURE__ */ ((ExtensionCategory2) => {
@@ -424,6 +423,7 @@ var ProductType = /* @__PURE__ */ ((ProductType2) => {
   ProductType2["SIMPLE"] = "simple";
   ProductType2["VARIABLE"] = "variable";
   ProductType2["BOOKING"] = "booking";
+  ProductType2["COMPOSITE"] = "composite";
   return ProductType2;
 })(ProductType || {});
 var ProductStatus = /* @__PURE__ */ ((ProductStatus2) => {
@@ -1354,6 +1354,312 @@ function normalizeMongoIdString(value) {
   return null;
 }
 
+// utils/composite-price.util.ts
+var compositeItemCost = (item) => item.extraCharge * item.quantity;
+function cheapestCompositeItem(items) {
+  let cheapest;
+  items.forEach((item, index) => {
+    if (!item.available) return;
+    if (cheapest === void 0 || compositeItemCost(item) < compositeItemCost(items[cheapest])) cheapest = index;
+  });
+  return cheapest;
+}
+function cheapestCompositePrice(parts) {
+  let total = 0;
+  for (const part of parts) {
+    if (part.min === 0) continue;
+    const index = cheapestCompositeItem(part.items) ?? cheapestCompositeItem(part.items.map((item) => ({ ...item, available: true })));
+    if (index === void 0) return void 0;
+    total += part.min * compositeItemCost(part.items[index]);
+  }
+  return total;
+}
+
+// utils/modifier-resolution.util.ts
+function ancestorChain(categoryId, categoriesById) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set([categoryId]);
+  let current = categoriesById.get(categoryId)?.parentId ?? void 0;
+  while (current && !seen.has(current)) {
+    chain.push(current);
+    seen.add(current);
+    current = categoriesById.get(current)?.parentId ?? void 0;
+  }
+  return chain;
+}
+function clampRule(rule) {
+  if (rule.min != null && rule.max != null && rule.min > rule.max) {
+    return { ...rule, min: rule.max };
+  }
+  return rule;
+}
+function mergeRules(a, b) {
+  const required = a.required || b.required;
+  const min = a.min == null ? b.min : b.min == null ? a.min : Math.max(a.min, b.min);
+  const max = a.max == null ? b.max : b.max == null ? a.max : Math.min(a.max, b.max);
+  return clampRule({ required, min, max, sortOrder: Math.min(a.sortOrder, b.sortOrder) });
+}
+function toRule(row) {
+  const required = row.required ?? false;
+  return clampRule({
+    required,
+    // `required` is the gate: a stale min left on a placement that went optional is
+    // ignored. A cleared min/max stays the explicit null it arrived as — nothing
+    // downstream distinguishes null from absent.
+    min: required ? row.min : void 0,
+    max: row.max,
+    sortOrder: row.sortOrder ?? 0
+  });
+}
+function toResolvedChoices(modifier) {
+  return (modifier.choices ?? []).map((choice, index) => ({
+    _id: String(choice._id),
+    name: choice.name,
+    price: choice.price ?? 0,
+    isDefault: choice.isDefault,
+    defaultQuantity: choice.defaultQuantity,
+    unavailableOutletIds: choice.unavailableOutletIds?.map(String),
+    sortOrder: choice.sortOrder ?? index
+  })).sort((a, b) => a.sortOrder - b.sortOrder);
+}
+function resolveModifiersForProduct(inputs) {
+  const categoriesById = new Map(
+    inputs.categories.filter((category) => !category.isDeleted).map((category) => [String(category._id), category])
+  );
+  const modifiersById = new Map(
+    inputs.modifiers.filter((modifier) => !modifier.isDeleted).map((modifier) => [String(modifier._id), modifier])
+  );
+  const directCategories = new Set(inputs.categoryIds.map(String));
+  const inheritedCategories = /* @__PURE__ */ new Set();
+  for (const categoryId of directCategories) {
+    for (const ancestor of ancestorChain(categoryId, categoriesById)) {
+      if (!directCategories.has(ancestor)) inheritedCategories.add(ancestor);
+    }
+  }
+  const rules = /* @__PURE__ */ new Map();
+  for (const placement of inputs.categoryModifiers) {
+    if (placement.isDeleted) continue;
+    const categoryId = String(placement.categoryId);
+    const precedence = directCategories.has(categoryId) ? 0 : inheritedCategories.has(categoryId) ? 1 : -1;
+    if (precedence === -1) continue;
+    const modifierId = String(placement.modifierId);
+    if (!modifiersById.has(modifierId)) continue;
+    const incoming = toRule(placement);
+    const existing = rules.get(modifierId);
+    if (!existing || precedence < existing.precedence) {
+      rules.set(modifierId, { precedence, rule: incoming });
+    } else if (precedence === existing.precedence) {
+      rules.set(modifierId, { precedence, rule: mergeRules(existing.rule, incoming) });
+    }
+  }
+  const resolved = [];
+  for (const [modifierId, { rule }] of rules) {
+    const modifier = modifiersById.get(modifierId);
+    if (!modifier) continue;
+    const required = rule.required;
+    resolved.push({
+      _id: modifierId,
+      name: modifier.name,
+      selectionType: modifier.selectionType,
+      allowQuantity: modifier.allowQuantity,
+      required,
+      // single-selection is implicitly capped at 1 — min/max are never carried.
+      min: modifier.selectionType === "single" ? void 0 : rule.min,
+      max: modifier.selectionType === "single" ? void 0 : rule.max,
+      sortOrder: rule.sortOrder,
+      choices: toResolvedChoices(modifier)
+    });
+  }
+  return resolved.sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name));
+}
+function isChoiceAvailableAtOutlet(choice, outletId) {
+  return !(choice.unavailableOutletIds ?? []).includes(outletId);
+}
+function hasSellableChoice(modifier, outletId) {
+  return modifier.choices.some((choice) => isChoiceAvailableAtOutlet(choice, outletId));
+}
+var modifiersSellable = (modifiers, outletId) => modifiers.every((modifier) => !modifier.required || hasSellableChoice(modifier, outletId));
+
+// utils/composite-availability.util.ts
+function poolStockAt(rows, outletId) {
+  if (!rows.some((row) => row.manageStock === true)) return null;
+  return Math.max(0, rows.find((row) => String(row.outletId) === outletId)?.quantity ?? 0);
+}
+function compositeVariantInStock(variantId, quantity, outlet) {
+  const shelf = outlet.shelves.get(variantId);
+  if (!shelf || shelf.unresolved) return false;
+  const onHand = outlet.poolStock.get(shelf.pool);
+  if (onHand === void 0) return false;
+  if (onHand === null || shelf.backorder) return true;
+  return onHand >= (shelf.unit ? toBase(quantity, shelf.unit) : quantity);
+}
+function compositeItemUnavailable(item, rows) {
+  const { outlet } = rows;
+  const sellableHere = (productId2) => !outlet || !outlet.hiddenProductIds.has(productId2) && !outlet.unsellableProductIds.has(productId2);
+  if (item.categoryId) {
+    const variants = rows.categoryVariants.get(String(item.categoryId));
+    if (!variants) return "deleted";
+    const offered = variants.filter((variantId2) => sellableHere(rows.variantProducts.get(variantId2) ?? ""));
+    if (!offered.length) return "empty";
+    if (!outlet) return null;
+    const unmarked = offered.filter((variantId2) => !outlet.markedVariantIds.has(variantId2));
+    if (!unmarked.length) return "marked_sold_out";
+    return unmarked.some((variantId2) => compositeVariantInStock(variantId2, item.quantity, outlet)) ? null : "out_of_stock";
+  }
+  const variantId = String(item.variantId);
+  const productId = rows.variantProducts.get(variantId);
+  if (!productId || !rows.productStatuses.has(productId)) return "deleted";
+  if (rows.productStatuses.get(productId) !== "active" /* ACTIVE */) return "inactive";
+  if (!outlet) return null;
+  if (outlet.hiddenProductIds.has(productId)) return "hidden";
+  if (outlet.unsellableProductIds.has(productId)) return "empty";
+  if (outlet.markedVariantIds.has(variantId)) return "marked_sold_out";
+  if (rows.bookableProductIds.has(productId)) {
+    if (!outlet.bookableSeats) return "by_date";
+    return (outlet.bookableSeats.get(productId) ?? 0) >= item.quantity ? null : "fully_booked";
+  }
+  return compositeVariantInStock(variantId, item.quantity, outlet) ? null : "out_of_stock";
+}
+function compositeMakeable(parts, rows) {
+  const { outlet } = rows;
+  if (!outlet) throw new Error("compositeMakeable counts at one outlet: rows.outlet is required");
+  const required = parts.map((part, partIndex) => ({ ...part, partIndex })).filter((part) => part.min > 0);
+  const isBookable = (variantId) => rows.bookableProductIds.has(rows.variantProducts.get(String(variantId)) ?? "");
+  if (required.some((part) => part.items.some((item) => item.variantId && isBookable(item.variantId))))
+    return { byDate: true };
+  const optionsOf = (item) => (item.categoryId ? rows.categoryVariants.get(String(item.categoryId)) ?? [] : [String(item.variantId)]).flatMap(
+    (variantId) => {
+      const reason = compositeItemUnavailable({ variantId, quantity: item.quantity }, rows);
+      const shelf = outlet.shelves.get(variantId);
+      if (reason && reason !== "out_of_stock" || !shelf) return [];
+      const stock = outlet.poolStock.get(shelf.pool);
+      const onHand = shelf.unresolved || stock === void 0 ? 0 : stock === null || shelf.backorder ? null : stock;
+      const perPick = shelf.unit ? toBase(item.quantity, shelf.unit) : item.quantity;
+      return [{ itemId: item.id, pool: shelf.pool, perPick, onHand }];
+    }
+  );
+  const counted = required.map((part) => ({ ...part, options: part.items.flatMap(optionsOf) }));
+  const order = [...counted].sort((a, b) => Number(a.options.length !== 1) - Number(b.options.length !== 1));
+  const picksLeft = (option, reserved) => option.onHand === null ? Infinity : Math.max(0, Math.floor((option.onHand - (reserved.get(option.pool) ?? 0)) / option.perPick));
+  const shortAt = (n) => {
+    const reserved = /* @__PURE__ */ new Map();
+    for (const part of order) {
+      let wanted = part.min * n;
+      const ranked = [...part.options].sort((a, b) => picksLeft(b, reserved) - picksLeft(a, reserved));
+      for (const option of ranked) {
+        if (wanted <= 0) break;
+        const taken = Math.min(wanted, picksLeft(option, reserved));
+        if (option.onHand !== null)
+          reserved.set(option.pool, (reserved.get(option.pool) ?? 0) + taken * option.perPick);
+        wanted -= taken;
+      }
+      if (wanted > 0) return part.partIndex;
+    }
+    return void 0;
+  };
+  const whyRows = [];
+  const rowPools = /* @__PURE__ */ new Map();
+  const makes = (has, uses) => has === null ? null : Math.floor(has / uses);
+  for (const part of counted) {
+    const [option] = part.options;
+    if (part.options.length === 1) {
+      const uses = option.perPick * part.min;
+      const row = whyRows.find((candidate) => rowPools.get(candidate) === option.pool);
+      if (!row) {
+        const created = { itemIds: [option.itemId], uses, has: option.onHand, makes: makes(option.onHand, uses) };
+        rowPools.set(created, option.pool);
+        whyRows.push(created);
+        continue;
+      }
+      row.itemIds.push(option.itemId);
+      row.uses += uses;
+      if (option.onHand === null) row.has = null;
+      row.makes = makes(row.has, row.uses);
+      continue;
+    }
+    const perPool = /* @__PURE__ */ new Map();
+    for (const candidate of part.options)
+      perPool.set(candidate.pool, Math.max(perPool.get(candidate.pool) ?? 0, picksLeft(candidate, /* @__PURE__ */ new Map())));
+    const total = [...perPool.values()].reduce((sum, picks) => sum + picks, 0);
+    const has = total === Infinity ? null : total;
+    whyRows.push({
+      itemIds: part.items.map((item) => item.id),
+      partIndex: part.partIndex,
+      uses: part.min,
+      has,
+      makes: makes(has, part.min)
+    });
+  }
+  if (counted.every((part) => part.options.some((option) => option.onHand === null)))
+    return { count: null, rows: whyRows };
+  const ceiling = Math.min(
+    ...counted.filter((part) => !part.options.some((option) => option.onHand === null)).map(
+      (part) => Math.floor(part.options.reduce((sum, option) => sum + picksLeft(option, /* @__PURE__ */ new Map()), 0) / part.min)
+    )
+  );
+  let [low, high] = [0, ceiling];
+  while (low < high) {
+    const mid = Math.ceil((low + high) / 2);
+    if (shortAt(mid) === void 0) low = mid;
+    else high = mid - 1;
+  }
+  const short = shortAt(low + 1);
+  const shortPart = counted.find((part) => part.partIndex === short);
+  const limitedBy = whyRows.findIndex(
+    (row) => shortPart?.options.length === 1 ? row.partIndex === void 0 && row.itemIds.includes(shortPart.options[0].itemId) : row.partIndex === short
+  );
+  return { count: low, rows: whyRows, ...limitedBy >= 0 ? { limitedBy } : {} };
+}
+var poolOf = (line) => line.stockVariantId || line.variantId;
+function poolDemand(lines) {
+  const demand = /* @__PURE__ */ new Map();
+  const add = (line, times) => demand.set(
+    poolOf(line),
+    (demand.get(poolOf(line)) ?? 0) + (line.unit ? toBase(line.quantity * times, line.unit) : line.quantity * times)
+  );
+  for (const line of lines) {
+    if (line.components) for (const component of line.components) add(component, line.quantity);
+    else add(line, 1);
+  }
+  return demand;
+}
+function poolShortfall(demand, poolStock, backordered = /* @__PURE__ */ new Set()) {
+  for (const [poolId, wanted] of demand) {
+    const available = poolStock.get(poolId);
+    if (available === null || available === void 0 || backordered.has(poolId)) continue;
+    if (wanted > available) return { poolId, available, wanted };
+  }
+  return null;
+}
+
+// utils/composite-reservation.util.ts
+function compositeModifierMismatches(lineItems) {
+  return lineItems.flatMap(
+    (line) => line.components?.length ? (line.modifiers ?? []).flatMap(
+      (modifier) => modifier.componentIndex !== void 0 && line.components[modifier.componentIndex] !== void 0 ? [] : [
+        `Modifier ${modifier.modifierName ?? "?"} on composite line ${line.internalId ?? "?"} names no component (componentIndex ${modifier.componentIndex}) \u2014 a composite has no modifiers of its own`
+      ]
+    ) : []
+  );
+}
+function compositeReservationMismatches(order) {
+  return (order.reservations ?? []).flatMap((reservation) => {
+    if (reservation.lineItemInternalId === void 0) return [];
+    const name = `Booking ${String(reservation.bookingId ?? "?")}`;
+    const line = order.lineItems?.find((candidate) => candidate.internalId === reservation.lineItemInternalId);
+    if (!line) return [`${name} names line ${reservation.lineItemInternalId}, which is not on the order`];
+    const component = reservation.componentIndex === void 0 ? void 0 : line.components?.[reservation.componentIndex];
+    if (!component) return [`${name} names no component ${reservation.componentIndex} of line ${line.internalId}`];
+    if (String(component.productId) !== String(reservation.productId))
+      return [
+        `${name} is for ${String(reservation.productId)}, but that component sold ${String(component.productId)}`
+      ];
+    if (reservation.price !== 0 || reservation.total !== 0)
+      return [`${name} carries money (${reservation.price}/${reservation.total}); its component already does`];
+    return [];
+  });
+}
+
 // units/family-code.ts
 var MAX_SLUG_LENGTH = 32;
 var FALLBACK_SLUG = "family";
@@ -2492,51 +2798,6 @@ function inferStatesFromLegacyStatus(order) {
   return { payment: "unpaid", fulfillment: "pending" };
 }
 
-// order-state-machine/in-cart.ts
-function hasInCartFlag(order) {
-  return order.inCart != null;
-}
-function isInCart(order) {
-  if (order.inCart != null) return order.inCart.active === true;
-  if (order.fulfillmentState) return order.fulfillmentState === "draft";
-  return (order.status ?? "").trim().toLowerCase() === "in-cart";
-}
-
-// order-state-machine/order-status.ts
-function validateOrderStatuses(statuses) {
-  if (!Array.isArray(statuses)) {
-    return [{ index: -1, field: "orderStatuses", message: "must be an array" }];
-  }
-  const errors = [];
-  const seen = /* @__PURE__ */ new Set();
-  statuses.forEach((raw, index) => {
-    const s = raw ?? {};
-    const add = (field, message) => errors.push({ index, field, message });
-    if (typeof s.id !== "string" || !s.id.trim()) add("id", "must be a non-empty string");
-    else if (seen.has(s.id)) add("id", `duplicate id "${s.id}"`);
-    else seen.add(s.id);
-    if (typeof s.label !== "string" || !s.label.trim()) add("label", "must be a non-empty string");
-    for (const field of ["color", "icon"]) {
-      if (s[field] !== void 0 && typeof s[field] !== "string") add(field, "must be a string");
-    }
-    if (s.fulfillmentState !== void 0 && !(typeof s.fulfillmentState === "string" && isFulfillmentState(s.fulfillmentState))) {
-      add("fulfillmentState", `"${String(s.fulfillmentState)}" is not a fulfillment state`);
-    }
-    if (s.requiresPaymentState !== void 0) {
-      if (!Array.isArray(s.requiresPaymentState) || s.requiresPaymentState.length === 0) {
-        add("requiresPaymentState", "must be a non-empty array of payment states");
-      } else {
-        for (const p of s.requiresPaymentState) {
-          if (!(typeof p === "string" && isPaymentState(p))) {
-            add("requiresPaymentState", `"${String(p)}" is not a payment state`);
-          }
-        }
-      }
-    }
-  });
-  return errors;
-}
-
 // order-state-machine/write-strategy.ts
 var LegacyWriteStrategy = class {
   applyState(_order) {
@@ -3048,7 +3309,9 @@ function buildGrid(rule, timeZone, from, to, now, busy = []) {
     const start = startAt.getTime();
     if (start < askedFrom || start >= askedTo) return false;
     if (start < notBefore || start > notAfter) return false;
-    return !blocked.some(({ from: blockFrom, to: blockTo }) => start < blockTo && bufferEndAt.getTime() > blockFrom);
+    return !blocked.some(
+      ({ from: blockFrom, to: blockTo }) => start < blockTo && bufferEndAt.getTime() > blockFrom
+    );
   }).sort((first, second) => +first.startAt - +second.startAt);
 }
 function slotsForWindow(grid, startAt, endAt) {
@@ -3167,7 +3430,14 @@ function buildAvailability({
     for (const slot of slots2) {
       const { taken, foreignProductId } = occupancyIn(mine, productId, slot.startAt, slot.bufferEndAt, shared);
       const free = foreignProductId ? 0 : Math.max(capacity - taken, 0);
-      const entry = byInstant.get(+slot.startAt) ?? { ...slot, capacity: 0, booked: 0, free: 0, resources: [], dayKey: shopDayKey(slot.startAt, resource.timeZone) };
+      const entry = byInstant.get(+slot.startAt) ?? {
+        ...slot,
+        capacity: 0,
+        booked: 0,
+        free: 0,
+        resources: [],
+        dayKey: shopDayKey(slot.startAt, resource.timeZone)
+      };
       entry.capacity += capacity;
       entry.booked += foreignProductId ? capacity : taken;
       entry.free += free;
@@ -3245,33 +3515,9 @@ var ADYEN_ROLLOUT_COUNTRY_CODES = /* @__PURE__ */ new Set(["CA"]);
 function isAdyenRolloutCountry(alpha2) {
   return ADYEN_ROLLOUT_COUNTRY_CODES.has(alpha2);
 }
-var AFFIRM_PRICE_PLANS = ["core", "standard", "signature"];
-function isAffirmPricePlan(value) {
-  return typeof value === "string" && AFFIRM_PRICE_PLANS.includes(value);
-}
-var AFFIRM_COUNTRY_CODES = /* @__PURE__ */ new Set(["CA"]);
-function isAffirmCountry(alpha2) {
-  return !!alpha2 && AFFIRM_COUNTRY_CODES.has(alpha2.toUpperCase());
-}
-var BNPL_METHOD_STATUS = {
-  ACTIVE: "active",
-  PENDING: "pending",
-  UNAVAILABLE: "unavailable",
-  UNKNOWN: "unknown"
-};
-var BNPL_SKIP_REASON = {
-  PENDING: "pending",
-  NO_SUPPORT_EMAIL: "no_support_email",
-  NO_CURRENCY: "no_currency",
-  NO_BUSINESS_LINE: "no_business_line"
-};
 export {
   ADYEN_ROLLOUT_COUNTRY_CODES,
-  AFFIRM_COUNTRY_CODES,
-  AFFIRM_PRICE_PLANS,
   AttributeType,
-  BNPL_METHOD_STATUS,
-  BNPL_SKIP_REASON,
   BookingRatePeriod,
   BookingResourceKind,
   BookingResourceStatus,
@@ -3349,6 +3595,7 @@ export {
   UserTypes,
   addAmounts,
   amountToString,
+  ancestorChain,
   assertUnitSane,
   availableIn,
   baseFor,
@@ -3362,6 +3609,14 @@ export {
   buildResolvedConfig,
   calculatePercentage,
   canTransition,
+  cheapestCompositeItem,
+  cheapestCompositePrice,
+  compositeItemCost,
+  compositeItemUnavailable,
+  compositeMakeable,
+  compositeModifierMismatches,
+  compositeReservationMismatches,
+  compositeVariantInStock,
   conditionSummary,
   convertFixedFeeToLocalCurrency,
   createAmount,
@@ -3396,15 +3651,13 @@ export {
   getPricingRegionFromCountry,
   getSettlementTotal,
   getTotalCollected,
-  hasInCartFlag,
+  hasSellableChoice,
   holdExpiresAt,
   inferStatesFromLegacyStatus,
   isAdyenRolloutCountry,
-  isAffirmCountry,
-  isAffirmPricePlan,
+  isChoiceAvailableAtOutlet,
   isConditionOperator,
   isFulfillmentState,
-  isInCart,
   isPaymentState,
   isSupportedCurrency,
   isSystemFamilyCode,
@@ -3413,6 +3666,7 @@ export {
   mapToLegacyStatus,
   maxPrecisionFor,
   mergeFragment,
+  modifiersSellable,
   multiplyAmount,
   normalizeMongoIdString,
   occupancyIn,
@@ -3420,9 +3674,14 @@ export {
   parseCurrencyCode,
   parseStripeCurrencyCode,
   planWindow,
+  poolDemand,
+  poolOf,
+  poolShortfall,
+  poolStockAt,
   presentAt,
   removeFragment,
   resolveFamily,
+  resolveModifiersForProduct,
   resolveTemplate,
   resolveUnit,
   roundToPrecision,
@@ -3438,7 +3697,6 @@ export {
   toMinorUnits,
   validateConfig,
   validateFragmentCompatibility,
-  validateOrderStatuses,
   violatesFinancialInvariant,
   windowEndsAt,
   withinPresence