@zoxllc/shopify-checkout-extensions 0.0.8 → 0.1.0

package/dist/common/CampaignFactory.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CampaignFactory = void 0;
+const OrSelector_1 = require("./OrSelector");
+const AndSelector_1 = require("./AndSelector");
+const CartAmountQualifier_1 = require("./CartAmountQualifier");
+const CartQuantityQualifier_1 = require("./CartQuantityQualifier");
+const CustomerEmailQualifier_1 = require("./CustomerEmailQualifier");
+const CustomerSubscriberQualifier_1 = require("./CustomerSubscriberQualifier");
+const CustomerTagQualifier_1 = require("./CustomerTagQualifier");
+const PostCartAmountQualifier_1 = require("./PostCartAmountQualifier");
+const ProductIdSelector_1 = require("./ProductIdSelector");
+const ProductTagSelector_1 = require("./ProductTagSelector");
+const ProductTypeSelector_1 = require("./ProductTypeSelector");
+const SaleItemSelector_1 = require("./SaleItemSelector");
+const ConditionalDiscount_1 = require("../lineItem/ConditionalDiscount");
+const FixedItemDiscount_1 = require("../lineItem/FixedItemDiscount");
+const PercentageDiscount_1 = require("../lineItem/PercentageDiscount");
+const BuyXGetY_1 = require("../lineItem/BuyXGetY");
+const SubscriptionItemSelector_1 = require("./SubscriptionItemSelector");
+const CountryCodeQualifier_1 = require("./CountryCodeQualifier");
+const RateNameSelector_1 = require("../shipping/RateNameSelector");
+const FixedDiscount_1 = require("../shipping/FixedDiscount");
+const ShippingDiscount_1 = require("../shipping/ShippingDiscount");
+class CampaignFactory {
+    static createFromConfig(config) {
+        return CampaignFactory.createInputsObject(config);
+    }
+    static parseInputConfig(input) {
+        if (typeof input == 'string' ||
+            typeof input == 'number' ||
+            typeof input == 'boolean' ||
+            input === null) {
+            return input;
+        }
+        else {
+            return CampaignFactory.createInputsObject(input);
+        }
+    }
+    static createInputsObject(config) {
+        const args = config.inputs.map((input) => {
+            if (Array.isArray(input)) {
+                return input.map((i) => CampaignFactory.parseInputConfig(i));
+            }
+            else {
+                return CampaignFactory.parseInputConfig(input);
+            }
+        });
+        switch (config.__type) {
+            case 'ConditionalDiscount':
+                return new ConditionalDiscount_1.ConditionalDiscount(args[0], args[1], args[2], args[3], args[4]);
+            case 'BuyXGetY':
+                return new BuyXGetY_1.BuyXGetY(args[0], args[1], args[2], args[3], args[4], args[5], args[6], args[7]);
+            case 'ShippingDiscount':
+                return new ShippingDiscount_1.ShippingDiscount(args[0], args[1], args[2], args[3]);
+            case 'AndSelector':
+                return new AndSelector_1.AndSelector([...args]);
+            case 'OrSelector':
+                return new OrSelector_1.OrSelector([...args]);
+            case 'PostCartAmountQualifier':
+                return new PostCartAmountQualifier_1.PostCartAmountQualifier(args[0], args[1]);
+            case 'CartAmountQualifier':
+                return new CartAmountQualifier_1.CartAmountQualifier(args[0], args[1], args[2]);
+            case 'CartQuantityQualifier':
+                return new CartQuantityQualifier_1.CartQuantityQualifier(args[0], args[1], args[2]);
+            case 'CountryCodeQualifier':
+                return new CountryCodeQualifier_1.CountryCodeQualifier(args[0], args[1]);
+            case 'SaleItemSelector':
+                return new SaleItemSelector_1.SaleItemSelector(args[0]);
+            case 'ProductIdSelector':
+                return new ProductIdSelector_1.ProductIdSelector(args[0], args[1]);
+            case 'ProductTypeSelector':
+                return new ProductTypeSelector_1.ProductTypeSelector(args[0], args[1]);
+            case 'ProductTagSelector':
+                return new ProductTagSelector_1.ProductTagSelector(args[0], args[1], args[2]);
+            case 'PercentageDiscount':
+                return new PercentageDiscount_1.PercentageDiscount(args[0], args[1]);
+            case 'FixedItemDiscount':
+                return new FixedItemDiscount_1.FixedItemDiscount(args[0], args[1], args[2]);
+            case 'FixedDiscount':
+                return new FixedDiscount_1.FixedDiscount(args[0], args[1]);
+            case 'SubscriptionItemSelector':
+                return new SubscriptionItemSelector_1.SubscriptionItemSelector(args[0]);
+            case 'RateNameSelector':
+                return new RateNameSelector_1.RateNameSelector(args[0], args[1], args[2]);
+            case 'CustomerSubscriberQualifier':
+                return new CustomerSubscriberQualifier_1.CustomerSubscriberQualifier(args[0]);
+            case 'CustomerEmailQualifier':
+                return new CustomerEmailQualifier_1.CustomerEmailQualifier(args[0], args[1], args[2]);
+            case 'CustomerTagQualifier':
+                return new CustomerTagQualifier_1.CustomerTagQualifier(args[0], args[1], args[2]);
+        }
+    }
+}
+exports.CampaignFactory = CampaignFactory;

package/dist/common/CartAmountQualifier.d.ts

@@ -0,0 +1,22 @@
+import type { DiscountCart } from "./DiscountCart";
+import { type NumericalComparisonType, Qualifier } from "./Qualifier";
+import { type Selector } from "./Selector";
+export declare enum CartAmountBehavior {
+    CART = ":cart",
+    ITEM = ":item",
+    DIFF_CART = ":diff_cart",
+    DIFF_ITEM = ":diff_item"
+}
+export declare class CartAmountQualifier extends Qualifier {
+    behavior: CartAmountBehavior;
+    comparisonType: NumericalComparisonType;
+    amount: number;
+    constructor(behavior: CartAmountBehavior, comparisonType: NumericalComparisonType, amount: number);
+    /**
+     * Determines if the carts amount
+     * @param cart
+     * @param selector
+     */
+    match(discountCart: DiscountCart, selector?: Selector): boolean;
+}
+//# sourceMappingURL=CartAmountQualifier.d.ts.map

package/dist/common/CartAmountQualifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CartAmountQualifier.d.ts","sourceRoot":"","sources":["../../src/common/CartAmountQualifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAAE,KAAK,uBAAuB,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,oBAAY,kBAAkB;IAC5B,IAAI,UAAU;IACd,IAAI,UAAU;IACd,SAAS,eAAe;IACxB,SAAS,eAAe;CACzB;AAED,qBAAa,mBAAoB,SAAQ,SAAS;IAChD,QAAQ,EAAE,kBAAkB,CAAC;IAC7B,cAAc,EAAE,uBAAuB,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC;gBAGb,QAAQ,EAAE,kBAAkB,EAC5B,cAAc,EAAE,uBAAuB,EACvC,MAAM,EAAE,MAAM;IAQhB;;;;OAIG;IACH,KAAK,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,QAAQ;CA+BtD"}

package/dist/common/CartAmountQualifier.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartAmountQualifier = exports.CartAmountBehavior = void 0;
+const Qualifier_1 = require("./Qualifier");
+var CartAmountBehavior;
+(function (CartAmountBehavior) {
+    CartAmountBehavior["CART"] = ":cart";
+    CartAmountBehavior["ITEM"] = ":item";
+    CartAmountBehavior["DIFF_CART"] = ":diff_cart";
+    CartAmountBehavior["DIFF_ITEM"] = ":diff_item";
+})(CartAmountBehavior || (exports.CartAmountBehavior = CartAmountBehavior = {}));
+class CartAmountQualifier extends Qualifier_1.Qualifier {
+    behavior;
+    comparisonType;
+    amount;
+    constructor(behavior, comparisonType, amount) {
+        super();
+        this.behavior = behavior;
+        this.comparisonType = comparisonType;
+        this.amount = amount;
+    }
+    /**
+     * Determines if the carts amount
+     * @param cart
+     * @param selector
+     */
+    match(discountCart, selector) {
+        let total = parseFloat(discountCart.cart.cost.subtotalAmount.amount) -
+            discountCart.appliedDiscountTotal;
+        switch (this.behavior) {
+            case CartAmountBehavior.CART:
+            case CartAmountBehavior.ITEM:
+                return this.compareAmounts(total, this.comparisonType, this.amount);
+            case CartAmountBehavior.DIFF_CART:
+                return this.compareAmounts(parseFloat(discountCart.cart.cost.subtotalAmount.amount) -
+                    this.amount, this.comparisonType, total);
+            case CartAmountBehavior.DIFF_ITEM:
+                const originalLineTotal = discountCart.cart.lines.reduce((runningTotal, line) => {
+                    runningTotal += parseFloat(line.cost.subtotalAmount.amount);
+                    return runningTotal;
+                }, total);
+                return this.compareAmounts(originalLineTotal - this.amount, this.comparisonType, total);
+        }
+    }
+}
+exports.CartAmountQualifier = CartAmountQualifier;

package/dist/common/CartHasItemQualifier.d.ts

@@ -0,0 +1,21 @@
+import type { DiscountCart } from './DiscountCart';
+import { type NumericalComparisonType, Qualifier } from './Qualifier';
+import { type Selector } from './Selector';
+export declare enum CartHasItemBehavior {
+    QUANTITY = ":quantity",
+    SUBTOTAL = ":subtotal"
+}
+export declare class CartHasItemQualifier extends Qualifier {
+    quantityOrSubtotal: CartHasItemBehavior;
+    comparisonType: NumericalComparisonType;
+    amount: number;
+    itemSelector: Selector;
+    constructor(quantityOrSubtotal: CartHasItemBehavior, comparisonType: NumericalComparisonType, amount: number, itemSelector: Selector);
+    /**
+     * Determines if the carts amount
+     * @param cart
+     * @param selector
+     */
+    match(discountCart: DiscountCart, selector?: Selector): boolean;
+}
+//# sourceMappingURL=CartHasItemQualifier.d.ts.map

package/dist/common/CartHasItemQualifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CartHasItemQualifier.d.ts","sourceRoot":"","sources":["../../src/common/CartHasItemQualifier.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EACL,KAAK,uBAAuB,EAC5B,SAAS,EACV,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,oBAAY,mBAAmB;IAC7B,QAAQ,cAAc;IACtB,QAAQ,cAAc;CACvB;AAED,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,kBAAkB,EAAE,mBAAmB,CAAC;IACxC,cAAc,EAAE,uBAAuB,CAAC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,QAAQ,CAAC;gBAGrB,kBAAkB,EAAE,mBAAmB,EACvC,cAAc,EAAE,uBAAuB,EACvC,MAAM,EAAE,MAAM,EACd,YAAY,EAAE,QAAQ;IAaxB;;;;OAIG;IACH,KAAK,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,QAAQ;CAsCtD"}

package/dist/common/CartHasItemQualifier.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartHasItemQualifier = exports.CartHasItemBehavior = void 0;
+const Qualifier_1 = require("./Qualifier");
+var CartHasItemBehavior;
+(function (CartHasItemBehavior) {
+    CartHasItemBehavior["QUANTITY"] = ":quantity";
+    CartHasItemBehavior["SUBTOTAL"] = ":subtotal";
+})(CartHasItemBehavior || (exports.CartHasItemBehavior = CartHasItemBehavior = {}));
+class CartHasItemQualifier extends Qualifier_1.Qualifier {
+    quantityOrSubtotal;
+    comparisonType;
+    amount;
+    itemSelector;
+    constructor(quantityOrSubtotal, comparisonType, amount, itemSelector) {
+        super();
+        this.quantityOrSubtotal = quantityOrSubtotal;
+        this.comparisonType = comparisonType;
+        this.amount =
+            this.quantityOrSubtotal ==
+                CartHasItemBehavior.SUBTOTAL
+                ? amount
+                : Math.floor(amount);
+        this.itemSelector = itemSelector;
+    }
+    /**
+     * Determines if the carts amount
+     * @param cart
+     * @param selector
+     */
+    match(discountCart, selector) {
+        let total = 0;
+        switch (this.quantityOrSubtotal) {
+            case CartHasItemBehavior.QUANTITY:
+                total = discountCart.cart.lines.reduce((quantity, line) => {
+                    return (quantity +
+                        (this.itemSelector.match(line)
+                            ? line.quantity
+                            : 0));
+                }, 0);
+                break;
+            case CartHasItemBehavior.SUBTOTAL:
+                total = discountCart.cart.lines.reduce((amount, line) => {
+                    return (amount +
+                        (this.itemSelector.match(line)
+                            ? line.cost.subtotalAmount.amount
+                            : 0));
+                }, 0);
+                break;
+        }
+        return this.compareAmounts(total, this.comparisonType, this.amount);
+    }
+}
+exports.CartHasItemQualifier = CartHasItemQualifier;

package/dist/common/CartQuantityQualifier.d.ts

@@ -0,0 +1,22 @@
+import type { DiscountCart } from './DiscountCart';
+import { type NumericalComparisonType, Qualifier } from './Qualifier';
+import { type Selector } from './Selector';
+export declare enum CartQuantityBehavior {
+    CART = ":cart",
+    ITEM = ":item",
+    LINE_ANY = ":line_any",
+    LINE_ALL = ":line_all"
+}
+export declare class CartQuantityQualifier extends Qualifier {
+    totalMethod: CartQuantityBehavior;
+    comparisonType: NumericalComparisonType;
+    quantity: number;
+    constructor(totalMethod: CartQuantityBehavior, comparisonType: NumericalComparisonType, quantity: number);
+    /**
+     * Determines if the carts amount
+     * @param cart
+     * @param selector
+     */
+    match(discountCart: DiscountCart, selector?: Selector): boolean;
+}
+//# sourceMappingURL=CartQuantityQualifier.d.ts.map

package/dist/common/CartQuantityQualifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CartQuantityQualifier.d.ts","sourceRoot":"","sources":["../../src/common/CartQuantityQualifier.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EACL,KAAK,uBAAuB,EAC5B,SAAS,EACV,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,oBAAY,oBAAoB;IAC9B,IAAI,UAAU;IACd,IAAI,UAAU;IACd,QAAQ,cAAc;IACtB,QAAQ,cAAc;CACvB;AAED,qBAAa,qBAAsB,SAAQ,SAAS;IAClD,WAAW,EAAE,oBAAoB,CAAC;IAClC,cAAc,EAAE,uBAAuB,CAAC;IACxC,QAAQ,EAAE,MAAM,CAAC;gBAGf,WAAW,EAAE,oBAAoB,EACjC,cAAc,EAAE,uBAAuB,EACvC,QAAQ,EAAE,MAAM;IAQlB;;;;OAIG;IACH,KAAK,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,QAAQ;CAyDtD"}

package/dist/common/CartQuantityQualifier.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CartQuantityQualifier = exports.CartQuantityBehavior = void 0;
+const Qualifier_1 = require("./Qualifier");
+var CartQuantityBehavior;
+(function (CartQuantityBehavior) {
+    CartQuantityBehavior["CART"] = ":cart";
+    CartQuantityBehavior["ITEM"] = ":item";
+    CartQuantityBehavior["LINE_ANY"] = ":line_any";
+    CartQuantityBehavior["LINE_ALL"] = ":line_all";
+})(CartQuantityBehavior || (exports.CartQuantityBehavior = CartQuantityBehavior = {}));
+class CartQuantityQualifier extends Qualifier_1.Qualifier {
+    totalMethod;
+    comparisonType;
+    quantity;
+    constructor(totalMethod, comparisonType, quantity) {
+        super();
+        this.totalMethod = totalMethod;
+        this.comparisonType = comparisonType;
+        this.quantity = quantity;
+    }
+    /**
+     * Determines if the carts amount
+     * @param cart
+     * @param selector
+     */
+    match(discountCart, selector) {
+        let total = 0;
+        switch (this.totalMethod) {
+            case CartQuantityBehavior.ITEM:
+                total = discountCart.cart.lines.reduce((totalQty, line) => {
+                    return (totalQty +
+                        ((selector
+                            ? selector.match(line)
+                            : true)
+                            ? line.quantity
+                            : 0));
+                }, 0);
+                break;
+            case CartQuantityBehavior.CART:
+                total =
+                    discountCart.totalLineItemQuantityExcludingGifts();
+                break;
+        }
+        if (this.totalMethod == CartQuantityBehavior.LINE_ANY ||
+            this.totalMethod == CartQuantityBehavior.LINE_ALL) {
+            const qualifiedItems = discountCart.cart.lines
+                .filter((line) => selector ? selector.match(line) : true)
+                .map((line) => this.compareAmounts(line.quantity, this.comparisonType, this.quantity));
+            switch (this.totalMethod) {
+                case CartQuantityBehavior.LINE_ANY:
+                    return qualifiedItems.indexOf(true) > -1;
+                case CartQuantityBehavior.LINE_ALL:
+                    return qualifiedItems.indexOf(false) == -1;
+            }
+        }
+        else {
+            return this.compareAmounts(total, this.comparisonType, this.quantity);
+        }
+    }
+}
+exports.CartQuantityQualifier = CartQuantityQualifier;

package/dist/common/ConfigSchema.d.ts

@@ -0,0 +1,71 @@
+/**
+ * JSON Schema definitions for campaign configurations.
+ * Use these schemas in your UI app to validate configurations before saving.
+ */
+export declare const CampaignConfigSchema: {
+    $schema: string;
+    type: string;
+    required: string[];
+    properties: {
+        __type: {
+            type: string;
+            enum: string[];
+            description: string;
+        };
+        label: {
+            type: string;
+            minLength: number;
+            maxLength: number;
+            description: string;
+        };
+        active: {
+            type: string;
+            description: string;
+        };
+        description: {
+            type: string;
+            maxLength: number;
+            description: string;
+        };
+        inputs: {
+            type: string;
+            description: string;
+        };
+    };
+};
+export declare const QualifierBehaviorSchema: {
+    type: string;
+    enum: string[];
+    description: string;
+};
+export declare const MatchTypeSchema: {
+    type: string;
+    enum: string[];
+    description: string;
+};
+export declare const QualifierMatchTypeSchema: {
+    type: string;
+    enum: string[];
+    description: string;
+};
+export declare const NumericalComparisonSchema: {
+    type: string;
+    enum: string[];
+    description: string;
+};
+export declare const StringComparisonSchema: {
+    type: string;
+    enum: string[];
+    description: string;
+};
+/**
+ * Type definitions that match the schemas
+ */
+export type CampaignConfigSchemaType = {
+    __type: 'ConditionalDiscount' | 'BuyXGetY' | 'ShippingDiscount';
+    label: string;
+    active: boolean;
+    description?: string;
+    inputs: unknown[];
+};
+//# sourceMappingURL=ConfigSchema.d.ts.map

package/dist/common/ConfigSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigSchema.d.ts","sourceRoot":"","sources":["../../src/common/ConfigSchema.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BhC,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;CAInC,CAAC;AAEF,eAAO,MAAM,eAAe;;;;CAI3B,CAAC;AAEF,eAAO,MAAM,wBAAwB;;;;CAIpC,CAAC;AAEF,eAAO,MAAM,yBAAyB;;;;CAUrC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;CAIlC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,EAAE,qBAAqB,GAAG,UAAU,GAAG,kBAAkB,CAAC;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,OAAO,EAAE,CAAC;CACnB,CAAC"}

package/dist/common/ConfigSchema.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * JSON Schema definitions for campaign configurations.
+ * Use these schemas in your UI app to validate configurations before saving.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringComparisonSchema = exports.NumericalComparisonSchema = exports.QualifierMatchTypeSchema = exports.MatchTypeSchema = exports.QualifierBehaviorSchema = exports.CampaignConfigSchema = void 0;
+exports.CampaignConfigSchema = {
+    $schema: 'http://json-schema.org/draft-07/schema#',
+    type: 'object',
+    required: ['__type', 'label', 'active', 'inputs'],
+    properties: {
+        __type: {
+            type: 'string',
+            enum: ['ConditionalDiscount', 'BuyXGetY', 'ShippingDiscount'],
+            description: 'The type of campaign to create',
+        },
+        label: {
+            type: 'string',
+            minLength: 1,
+            maxLength: 100,
+            description: 'Human-readable label for the campaign',
+        },
+        active: {
+            type: 'boolean',
+            description: 'Whether this campaign is currently active',
+        },
+        description: {
+            type: 'string',
+            maxLength: 500,
+            description: 'Optional description of what this campaign does',
+        },
+        inputs: {
+            type: 'array',
+            description: 'Constructor arguments for the campaign',
+        },
+    },
+};
+exports.QualifierBehaviorSchema = {
+    type: 'string',
+    enum: [':all', ':any'],
+    description: 'How to combine multiple qualifiers (ALL must match, or ANY can match)',
+};
+exports.MatchTypeSchema = {
+    type: 'string',
+    enum: [':all', ':is_one', ':not_one', ':does', ':does_not'],
+    description: 'How to match items',
+};
+exports.QualifierMatchTypeSchema = {
+    type: 'string',
+    enum: [':does', ':does_not'],
+    description: 'Positive or negative matching',
+};
+exports.NumericalComparisonSchema = {
+    type: 'string',
+    enum: [
+        ':greater_than',
+        ':greater_than_or_equal',
+        ':less_than',
+        ':less_than_or_equal',
+        ':equal_to',
+    ],
+    description: 'How to compare numerical values',
+};
+exports.StringComparisonSchema = {
+    type: 'string',
+    enum: [':match', ':contains', ':start_with', ':end_with'],
+    description: 'How to compare string values',
+};

package/dist/common/ConfigValidator.d.ts

@@ -0,0 +1,29 @@
+import type { CampaignInputConfig } from './CampaignFactory';
+export interface ValidationError {
+    field: string;
+    message: string;
+    value?: unknown;
+}
+export interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+/**
+ * Validates campaign configurations.
+ * Use this in your UI app before saving configurations.
+ */
+export declare class ConfigValidator {
+    /**
+     * Validates a campaign configuration
+     */
+    static validate(config: unknown): ValidationResult;
+    /**
+     * Validates multiple configurations
+     */
+    static validateAll(configs: unknown[]): ValidationResult;
+    /**
+     * Type guard to check if a config is valid
+     */
+    static isValid(config: unknown): config is CampaignInputConfig;
+}
+//# sourceMappingURL=ConfigValidator.d.ts.map

package/dist/common/ConfigValidator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ConfigValidator.d.ts","sourceRoot":"","sources":["../../src/common/ConfigValidator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAE7D,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED;;;GAGG;AACH,qBAAa,eAAe;IAC1B;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,OAAO,GAAG,gBAAgB;IAgDlD;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,gBAAgB;IA4BxD;;OAEG;IACH,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,IAAI,mBAAmB;CAG/D"}

package/dist/common/ConfigValidator.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigValidator = void 0;
+/**
+ * Validates campaign configurations.
+ * Use this in your UI app before saving configurations.
+ */
+class ConfigValidator {
+    /**
+     * Validates a campaign configuration
+     */
+    static validate(config) {
+        const errors = [];
+        // Check if config is an object
+        if (!config || typeof config !== 'object') {
+            return {
+                valid: false,
+                errors: [{ field: 'config', message: 'Configuration must be an object' }],
+            };
+        }
+        const cfg = config;
+        // Validate required fields
+        if (!cfg.__type) {
+            errors.push({ field: '__type', message: 'Campaign type is required' });
+        }
+        else if (!['ConditionalDiscount', 'BuyXGetY', 'ShippingDiscount'].includes(cfg.__type)) {
+            errors.push({
+                field: '__type',
+                message: 'Invalid campaign type',
+                value: cfg.__type,
+            });
+        }
+        if (!cfg.label || typeof cfg.label !== 'string') {
+            errors.push({ field: 'label', message: 'Label is required and must be a string' });
+        }
+        else if (cfg.label.length === 0) {
+            errors.push({ field: 'label', message: 'Label cannot be empty' });
+        }
+        if (typeof cfg.active !== 'boolean') {
+            errors.push({ field: 'active', message: 'Active must be a boolean' });
+        }
+        if (!Array.isArray(cfg.inputs)) {
+            errors.push({ field: 'inputs', message: 'Inputs must be an array' });
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Validates multiple configurations
+     */
+    static validateAll(configs) {
+        const allErrors = [];
+        if (!Array.isArray(configs)) {
+            return {
+                valid: false,
+                errors: [{ field: 'configs', message: 'Configs must be an array' }],
+            };
+        }
+        configs.forEach((config, index) => {
+            const result = ConfigValidator.validate(config);
+            if (!result.valid) {
+                result.errors.forEach((error) => {
+                    allErrors.push({
+                        ...error,
+                        field: `configs[${index}].${error.field}`,
+                    });
+                });
+            }
+        });
+        return {
+            valid: allErrors.length === 0,
+            errors: allErrors,
+        };
+    }
+    /**
+     * Type guard to check if a config is valid
+     */
+    static isValid(config) {
+        return ConfigValidator.validate(config).valid;
+    }
+}
+exports.ConfigValidator = ConfigValidator;

package/dist/common/CountryCodeQualifier.d.ts

@@ -0,0 +1,15 @@
+import type { DiscountCart } from './DiscountCart';
+import { QualifierMatchType, Qualifier } from './Qualifier';
+import { type Selector } from './Selector';
+export declare class CountryCodeQualifier extends Qualifier {
+    invert: boolean;
+    countryCodes: string[];
+    constructor(matchType: QualifierMatchType, countryCodes: string[]);
+    /**
+     * Determines if the customer has specified tags
+     * @param discountCart DiscountCart
+     * @param selector Selector
+     */
+    match(discountCart: DiscountCart, selector?: Selector): boolean;
+}
+//# sourceMappingURL=CountryCodeQualifier.d.ts.map

package/dist/common/CountryCodeQualifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CountryCodeQualifier.d.ts","sourceRoot":"","sources":["../../src/common/CountryCodeQualifier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,EAEL,kBAAkB,EAClB,SAAS,EACV,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,MAAM,EAAE,OAAO,CAAC;IAChB,YAAY,EAAE,MAAM,EAAE,CAAC;gBAGrB,SAAS,EAAE,kBAAkB,EAC7B,YAAY,EAAE,MAAM,EAAE;IASxB;;;;OAIG;IACH,KAAK,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,CAAC,EAAE,QAAQ;CAoBtD"}

package/dist/common/CountryCodeQualifier.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountryCodeQualifier = void 0;
+const Qualifier_1 = require("./Qualifier");
+class CountryCodeQualifier extends Qualifier_1.Qualifier {
+    invert;
+    countryCodes;
+    constructor(matchType, countryCodes) {
+        super();
+        this.invert = matchType == Qualifier_1.QualifierMatchType.DOES_NOT;
+        this.countryCodes = countryCodes.map((e) => e.toLowerCase());
+    }
+    /**
+     * Determines if the customer has specified tags
+     * @param discountCart DiscountCart
+     * @param selector Selector
+     */
+    match(discountCart, selector) {
+        const matchResult = (discountCart.cart.deliveryGroups.filter((deliveryGroup) => {
+            const countryCode = deliveryGroup?.deliveryAddress?.countryCode?.toLowerCase() ||
+                '';
+            return this.countryCodes.includes(countryCode);
+        }) || []).length > 0;
+        if (this.invert) {
+            return !matchResult;
+        }
+        return matchResult;
+    }
+}
+exports.CountryCodeQualifier = CountryCodeQualifier;