@moonbase.sh/storefront-api 0.4.25 → 0.4.26

package/dist/index.cjs

@@ -28,24 +28,27 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   ActivationMethod: () => ActivationMethod,
   ActivationRequestFulfillmentType: () => ActivationRequestFulfillmentType,
   ActivationRequestStatus: () => ActivationRequestStatus,
   ActivationStatus: () => ActivationStatus,
   ConsoleLogger: () => ConsoleLogger,
   CycleLength: () => CycleLength,
+  DiscountUtils: () => DiscountUtils,
   InMemoryStore: () => InMemoryStore,
   LicenseStatus: () => LicenseStatus,
   LocalStorageStore: () => LocalStorageStore,
   LogLevel: () => LogLevel,
+  MoneyCollectionUtils: () => MoneyCollectionUtils,
   MoonbaseApi: () => MoonbaseApi,
   MoonbaseClient: () => MoonbaseClient,
   MoonbaseError: () => MoonbaseError,
   NotAuthenticatedError: () => NotAuthenticatedError,
   NotAuthorizedError: () => NotAuthorizedError,
   NotFoundError: () => NotFoundError,
+  OfferUtils: () => OfferUtils,
   OrderStatus: () => OrderStatus,
   Platform: () => Platform,
   SubscriptionStatus: () => SubscriptionStatus,
@@ -54,7 +57,7 @@ __export(src_exports, {
   schemas: () => schemas_exports3,
   utmToObject: () => utmToObject
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/activationRequests/endpoints.ts
 var import_zod5 = require("zod");
@@ -216,7 +219,7 @@ var storefrontProductSchema = import_zod3.z.object({
   downloads: downloadSchema.array().optional(),
   defaultVariation: pricingVariationSchema.optional(),
   variations: pricingVariationSchema.array().optional(),
-  type: import_zod3.z.void().transform(() => "product").pipe(import_zod3.z.literal("product"))
+  type: import_zod3.z.string().optional().default("Product").pipe(import_zod3.z.literal("Product"))
 });
 var storefrontBundleSchema = import_zod3.z.object({
   id: import_zod3.z.string(),
@@ -231,12 +234,27 @@ var storefrontBundleSchema = import_zod3.z.object({
   })).array(),
   defaultVariation: pricingVariationSchema.optional(),
   variations: pricingVariationSchema.array().optional(),
-  type: import_zod3.z.void().transform(() => "bundle").pipe(import_zod3.z.literal("bundle"))
+  type: import_zod3.z.string().optional().default("Bundle").pipe(import_zod3.z.literal("Bundle"))
+});
+var cartContainsItemsConditionSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("CartContainsItems"),
+  minimumItems: import_zod3.z.number(),
+  relevantItemVariations: import_zod3.z.record(import_zod3.z.string(), import_zod3.z.string().array())
+});
+var offerConditionSchema = import_zod3.z.discriminatedUnion("type", [cartContainsItemsConditionSchema]);
+var storefrontOfferSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  target: import_zod3.z.union([storefrontProductSchema, storefrontBundleSchema]),
+  targetVariations: import_zod3.z.string().array(),
+  condition: offerConditionSchema,
+  discount: discountSchema
 });
 var storefrontSchema = import_zod3.z.object({
   suggestedCurrency: import_zod3.z.string(),
   products: storefrontProductSchema.array(),
-  bundles: storefrontBundleSchema.array()
+  bundles: storefrontBundleSchema.array(),
+  // Offers need to be optional since we may still have old, cached representations in browsers
+  offers: storefrontOfferSchema.array().optional()
 });
 
 // src/activationRequests/models.ts
@@ -721,6 +739,7 @@ var openProductLineItem = import_zod11.z.object({
   productId: import_zod11.z.string(),
   quantity: import_zod11.z.number(),
   variationId: import_zod11.z.string(),
+  offerId: import_zod11.z.string().optional(),
   isDefaultVariation: import_zod11.z.boolean().nullish(),
   isSubcriptionPayment: import_zod11.z.boolean().nullish(),
   price: priceCollectionSchema.optional(),
@@ -744,7 +763,9 @@ var openBundleLineItem = import_zod11.z.object({
   bundleId: import_zod11.z.string(),
   quantity: import_zod11.z.number(),
   variationId: import_zod11.z.string(),
+  offerId: import_zod11.z.string().optional(),
   partial: import_zod11.z.boolean().optional(),
+  replaced: import_zod11.z.string().array().optional(),
   isDefaultVariation: import_zod11.z.boolean().nullish(),
   isSubcriptionPayment: import_zod11.z.boolean().nullish(),
   price: priceCollectionSchema.optional(),
@@ -1304,6 +1325,55 @@ __export(schemas_exports3, {
   orders: () => schemas_exports2
 });
 
+// src/utils/discount.ts
+var DiscountUtils = class {
+  static apply(discount, price) {
+    switch (discount.type) {
+      case "PercentageOffDiscount":
+        return Object.fromEntries(Object.entries(price).map(([currency, amount]) => [currency, amount * discount.percentage]));
+      case "FlatAmountOffDiscount":
+        return Object.fromEntries(Object.entries(price).map(([currency, amount]) => {
+          var _a, _b;
+          return [currency, Math.min(amount, (_b = (_a = discount.total) == null ? void 0 : _a[currency]) != null ? _b : 0)];
+        }));
+    }
+  }
+};
+
+// src/utils/money.ts
+var MoneyCollectionUtils = class {
+  static sum(a, b) {
+    return Object.fromEntries(Object.entries(a).map(([currency, amount]) => [currency, amount + b[currency]]));
+  }
+  static subtract(a, b) {
+    return Object.fromEntries(Object.entries(a).map(([currency, amount]) => [currency, amount - b[currency]]));
+  }
+};
+
+// src/utils/offer.ts
+var OfferUtils = class {
+  static eligible(offer, order) {
+    switch (offer.condition.type) {
+      case "CartContainsItems":
+        const relevantItems = order.items.filter(
+          (i) => i.type === "Product" && offer.condition.relevantItemVariations[`Product/${i.productId}`] && (offer.condition.relevantItemVariations[`Product/${i.productId}`].length === 0 || offer.condition.relevantItemVariations[`Product/${i.productId}`].includes(i.variationId)) || i.type === "Bundle" && offer.condition.relevantItemVariations[`Bundle/${i.bundleId}`] && (offer.condition.relevantItemVariations[`Bundle/${i.bundleId}`].length === 0 || offer.condition.relevantItemVariations[`Bundle/${i.bundleId}`].includes(i.variationId))
+        );
+        console.log("Relevant items for offer:", { offer, relevantItems });
+        return relevantItems.length >= offer.condition.minimumItems;
+    }
+    console.warn("Unsupported offer condition found:", offer.condition);
+    return false;
+  }
+  static applyToVariation(offer, variation) {
+    const discount = DiscountUtils.apply(offer.discount, variation.price);
+    return {
+      ...variation,
+      price: MoneyCollectionUtils.subtract(variation.price, discount),
+      hasDiscount: Object.values(discount).some((v) => v > 0) || variation.hasDiscount
+    };
+  }
+};
+
 // src/index.ts
 var MoonbaseClient = class {
   constructor(configuration) {
@@ -1330,16 +1400,19 @@ var MoonbaseClient = class {
   ActivationStatus,
   ConsoleLogger,
   CycleLength,
+  DiscountUtils,
   InMemoryStore,
   LicenseStatus,
   LocalStorageStore,
   LogLevel,
+  MoneyCollectionUtils,
   MoonbaseApi,
   MoonbaseClient,
   MoonbaseError,
   NotAuthenticatedError,
   NotAuthorizedError,
   NotFoundError,
+  OfferUtils,
   OrderStatus,
   Platform,
   SubscriptionStatus,