@moonbase.sh/storefront-api 2.3.1 → 2.4.0

package/dist/index.cjs

@@ -71,6 +71,7 @@ __export(schemas_exports2, {
   offerConditionSchema: () => offerConditionSchema,
   storefrontBundleSchema: () => storefrontBundleSchema,
   storefrontOfferSchema: () => storefrontOfferSchema,
+  storefrontOfferTargetSchema: () => storefrontOfferTargetSchema,
   storefrontProductSchema: () => storefrontProductSchema,
   storefrontSchema: () => storefrontSchema,
   taxEstimateSchema: () => taxEstimateSchema
@@ -287,13 +288,36 @@ var cartContainsItemsConditionSchema = import_zod3.z.object({
   relevantItemVariations: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string().array())
 });
 var offerConditionSchema = import_zod3.z.discriminatedUnion("type", [cartContainsItemsConditionSchema]);
+var offerTargetItemSchema = import_zod3.z.union([storefrontProductSchema, storefrontBundleSchema]);
+var storefrontOfferTargetSchema = import_zod3.z.object({
+  // The product or bundle the offer applies to.
+  item: offerTargetItemSchema,
+  // The pricing variation IDs the offer is restricted to; an empty list means all variations.
+  variations: import_zod3.z.string().array()
+});
+function legacyOfferTargets(target, targetVariations) {
+  if (!target)
+    return [];
+  const items = Array.isArray(target) ? target : [target];
+  return items.map((item) => ({ item, variations: items.length === 1 ? targetVariations != null ? targetVariations : [] : [] }));
+}
 var storefrontOfferSchema = import_zod3.z.object({
   id: import_zod3.z.string(),
-  target: singleOrMultiple(import_zod3.z.union([storefrontProductSchema, storefrontBundleSchema])),
-  targetVariations: import_zod3.z.string().array(),
+  // Each target pairs a product/bundle with the pricing variations the offer applies to (an empty
+  // list means all variations). This is the model to consume.
+  targets: import_zod3.z.array(storefrontOfferTargetSchema).optional(),
+  // Legacy fields, kept optional only so old cached storefront responses still parse. The API now
+  // exposes the unified `targets` model; we derive `targets` from these when a response predates it.
+  // `.catch` guards against the deprecated shape drifting: a malformed legacy field is ignored
+  // rather than failing the whole response (newer responses carry `targets` anyway).
+  target: singleOrMultiple(offerTargetItemSchema).optional().catch(void 0),
+  targetVariations: import_zod3.z.string().array().optional().catch(void 0),
   condition: offerConditionSchema,
   discount: discountSchema
-});
+}).transform(({ target, targetVariations, targets, ...rest }) => ({
+  ...rest,
+  targets: targets != null ? targets : legacyOfferTargets(target, targetVariations)
+}));
 var taxEstimateSchema = import_zod3.z.object({
   rate: import_zod3.z.number(),
   mode: import_zod3.z.enum(["Exclusive", "Inclusive"]),
@@ -1693,11 +1717,27 @@ var OfferUtils = class _OfferUtils {
   // a. Not be owned, or all targets need to be owned
   // b. Not already in the cart
   static relevantTargets(offer, cartItems) {
-    if (Array.isArray(offer.target)) {
-      const allOwned = offer.target.every((i) => i.owned);
-      return offer.target.filter((i) => (allOwned || !i.owned) && !cartItems.some((l) => l.type === i.type && i.id === (l.type === "Product" ? l.productId : l.bundleId)));
+    if (offer.targets.length > 1) {
+      const allOwned = offer.targets.every((t) => t.item.owned);
+      return offer.targets.filter((t) => (allOwned || !t.item.owned) && !cartItems.some((l) => l.type === t.item.type && t.item.id === (l.type === "Product" ? l.productId : l.bundleId)));
     }
-    return [offer.target];
+    return offer.targets;
+  }
+  // The pricing variations a target restricts the offer to. An empty (or missing) variation list
+  // means the offer is not narrowed to specific variations, in which case we keep the established
+  // single default-variation upsell.
+  static targetedVariations(target) {
+    var _a;
+    const { item, variations } = target;
+    if (variations.length === 0)
+      return item.defaultVariation ? [item.defaultVariation] : [];
+    const itemVariations = (_a = item.variations) != null ? _a : item.defaultVariation ? [item.defaultVariation] : [];
+    return itemVariations.filter((v) => variations.includes(v.id));
+  }
+  // Expands the relevant targets into one `{ target, variation }` entry per targeted variation, so
+  // an offer targeting several variations (or several products) surfaces each as its own upsell row.
+  static relevantTargetVariations(offer, cartItems) {
+    return _OfferUtils.relevantTargets(offer, cartItems).flatMap((target) => _OfferUtils.targetedVariations(target).map((variation) => ({ target: target.item, variation })));
   }
   static applyToVariation(offer, variation) {
     const discount = DiscountUtils.apply(offer.discount, variation.price);
@@ -1708,8 +1748,7 @@ var OfferUtils = class _OfferUtils {
     };
   }
   static targetContainsBundle(offer, bundleId) {
-    if (Array.isArray(offer.target))
-      return offer.target.some((i) => i.type === "Bundle" && i.id === bundleId);
+    return offer.targets.some((t) => t.item.type === "Bundle" && t.item.id === bundleId);
   }
 };