@zoxllc/shopify-checkout-extensions 0.0.8 → 0.1.0

package/src/common/ProductTypeSelector.ts

@@ -1,40 +0,0 @@
-import type {
-  CartLine,
-  ProductVariant,
-} from '../lineItem/api';
-import { MatchType, Selector } from './Selector';
-
-export class ProductTypeSelector extends Selector {
-  invert: boolean;
-  productTypes: string[];
-
-  constructor(
-    matchType: MatchType,
-    productTypes: string[]
-  ) {
-    super();
-    this.invert = matchType == MatchType.NOT_ONE;
-    this.productTypes = productTypes.map((item) =>
-      item.toLowerCase()
-    );
-  }
-
-  match(subject: unknown): boolean;
-  match(lineItem: CartLine) {
-    const variant = lineItem.merchandise as ProductVariant;
-
-    if (variant.product.productType) {
-      const matchResult = this.productTypes.includes(
-        variant.product.productType.toLowerCase()
-      );
-
-      if (this.invert) {
-        return !matchResult;
-      }
-
-      return matchResult;
-    }
-
-    return false;
-  }
-}

package/src/common/Qualifier.ts

@@ -1,67 +0,0 @@
-import type { DiscountCart } from './DiscountCart';
-import type { Selector } from './Selector';
-
-export enum QualifierMatchType {
-  DOES = ':does',
-  DOES_NOT = ':does_not',
-}
-
-export enum StringComparisonType {
-  MATCH = ':match',
-  CONTAINS = ':contains',
-  START_WITH = ':start_with',
-  END_WITH = ':end_with',
-}
-
-export enum NumericalComparisonType {
-  GREATER_THAN = ':greater_than',
-  GREATER_THAN_OR_EQUAL = ':greater_than_or_equal',
-  LESS_THAN = ':less_than',
-  LESS_THAN_OR_EQUAL = ':less_than_or_equal',
-  EQUAL_TO = ':equal_to',
-}
-
-// export enum ComparisonType {
-//   GREATER_THAN = ":greater_than",
-//   GREATER_THAN_OR_EQUAL = ":greater_than_or_equal",
-//   LESS_THAN = ":less_than",
-//   LESS_THAN_OR_EQUAL = ":less_than_or_equal",
-//   EQUAL_TO = ":equal_to",
-// }
-
-export enum QualifierBehavior {
-  ALL = ':all',
-  ANY = ':any',
-}
-export class Qualifier {
-  is_a: 'Qualifier';
-
-  constructor() {
-    this.is_a = 'Qualifier';
-  }
-
-  compareAmounts(
-    compare: number,
-    comparisonType: NumericalComparisonType,
-    compareTo: number
-  ) {
-    switch (comparisonType) {
-      case NumericalComparisonType.GREATER_THAN:
-        return compare > compareTo;
-      case NumericalComparisonType.GREATER_THAN_OR_EQUAL:
-        return compare >= compareTo;
-      case NumericalComparisonType.LESS_THAN:
-        return compare < compareTo;
-      case NumericalComparisonType.LESS_THAN_OR_EQUAL:
-        return compare <= compareTo;
-      case NumericalComparisonType.EQUAL_TO:
-        return compare == compareTo;
-      default:
-        throw new Error('Invalid comparison type');
-    }
-  }
-
-  match(discountCart: DiscountCart, selector?: Selector) {
-    return false;
-  }
-}

package/src/common/SaleItemSelector.ts

@@ -1,36 +0,0 @@
-import { CartLine } from '../lineItem/api';
-import { Selector } from './Selector';
-
-export enum SaleItemSelectorMatchType {
-  IS = ':is',
-  NOT = ':not',
-}
-
-export class SaleItemSelector extends Selector {
-  invert: boolean;
-
-  constructor(matchType: SaleItemSelectorMatchType) {
-    super();
-    // Unlike other common scenarios, we invert if we pass an :IS
-    // because it is easier to figure out of the item is NOT on sale.
-    this.invert = matchType == SaleItemSelectorMatchType.IS;
-  }
-
-  match(subject: unknown): boolean;
-  match(lineItem: CartLine) {
-    // Check to see if the item is NOT on sale
-    const matchResult =
-      !lineItem.cost.compareAtAmountPerQuantity ||
-      parseFloat(
-        lineItem.cost.compareAtAmountPerQuantity.amount
-      ) <=
-        parseFloat(lineItem.cost.amountPerQuantity.amount);
-
-    // If we want to check that the item IS on sale, we'll invert the result
-    if (this.invert) {
-      return !matchResult;
-    }
-
-    return matchResult;
-  }
-}

package/src/common/Selector.ts

@@ -1,66 +0,0 @@
-import type { CartDeliveryOption } from '../shipping/api';
-import type { CartLine } from '../lineItem/api';
-import { StringComparisonType } from './Qualifier';
-
-export enum MatchType {
-  'ALL' = ':all',
-  'IS_ONE' = ':is_one',
-  'NOT_ONE' = ':not_one',
-  'DOES' = ':does',
-  'DOES_NOT' = ':does_not',
-}
-
-export type SelectorInterface = {
-  match(subject: CartLine): boolean;
-  match(subject: CartDeliveryOption): boolean;
-};
-
-export class Selector implements SelectorInterface {
-  match(subject: CartLine): boolean;
-  match(subject: CartDeliveryOption): boolean;
-  match(subject: unknown): boolean {
-    return true;
-  }
-
-  /**
-   * Checks each member of the subject array for possible matches. Returns true when any possible match is made.
-   * @param matchType StringComparisonType
-   * @param itemInfo string | string[]
-   * @param possibleMatches string[]
-   * @returns boolean
-   */
-  partialMatch(
-    matchType:
-      | StringComparisonType.CONTAINS
-      | StringComparisonType.START_WITH
-      | StringComparisonType.END_WITH,
-    itemInfo: string | string[],
-    possibleMatches: string[]
-  ) {
-    // Convert to an array if it isn't one
-    const subject = Array.isArray(itemInfo)
-      ? itemInfo
-      : [itemInfo];
-    let foundMatch = false;
-    possibleMatches.forEach((possibility) => {
-      subject.forEach((search) => {
-        switch (matchType) {
-          case StringComparisonType.CONTAINS:
-            if (search.search(possibility) > -1)
-              foundMatch = true;
-            break;
-          case StringComparisonType.START_WITH:
-            if (search.startsWith(possibility))
-              foundMatch = true;
-            break;
-          case StringComparisonType.END_WITH:
-            if (search.endsWith(possibility))
-              foundMatch = true;
-            break;
-        }
-      });
-    });
-
-    return foundMatch;
-  }
-}

package/src/common/SubscriptionItemSelector.ts

@@ -1,23 +0,0 @@
-import type { CartLine } from '../lineItem/api';
-import { MatchType, Selector } from './Selector';
-
-export class SubscriptionItemSelector extends Selector {
-  invert: boolean;
-
-  constructor(matchType: MatchType) {
-    super();
-    this.invert = matchType == MatchType.NOT_ONE;
-  }
-
-  match(subject: unknown): boolean;
-  match(lineItem: CartLine) {
-    const matchResult =
-      lineItem.sellingPlanAllocation !== undefined;
-
-    if (this.invert) {
-      return !matchResult;
-    }
-
-    return false;
-  }
-}

package/src/lineItem/BuyXGetY.ts

@@ -1,131 +0,0 @@
-import { Campaign } from '../common/Campaign';
-import type { AndSelector } from '../common/AndSelector';
-import type { DiscountCart } from '../common/DiscountCart';
-import type {
-  ApplyDiscount,
-  DiscountInterface,
-} from '../common/DiscountInterface';
-import type { OrSelector } from '../common/OrSelector';
-import type {
-  Qualifier,
-  QualifierBehavior,
-} from '../common/Qualifier';
-import type { Selector } from '../common/Selector';
-
-export class BuyXGetY extends Campaign {
-  lineItemSelector?: Selector;
-  getItemSelector?: Selector;
-  discount: DiscountInterface;
-  buyX: number;
-  getY: number;
-  maxSets?: number;
-
-  constructor(
-    behavior: QualifierBehavior,
-    conditions: [AndSelector | OrSelector | Qualifier],
-    discount: DiscountInterface,
-    buyItemSelector: Selector,
-    getItemSelector: Selector,
-    buyX: number,
-    getY: number,
-    maxSets?: number
-  ) {
-    super(behavior, conditions);
-    this.lineItemSelector = buyItemSelector;
-    this.getItemSelector = getItemSelector;
-    this.discount = discount;
-    this.buyX = buyX;
-    this.getY = getY;
-    this.maxSets = maxSets;
-  }
-
-  run(discountCart: DiscountCart) {
-    if (this.qualifies(discountCart)) {
-      // Find the items that qualify for buyX
-      let applicableBuyItems = discountCart.cart.lines;
-      if (this.lineItemSelector) {
-        applicableBuyItems = discountCart.cart.lines.filter(
-          (lineItem) => {
-            // @ts-ignore
-            return this.lineItemSelector?.match(lineItem);
-          }
-        );
-      }
-
-      if (
-        applicableBuyItems.reduce(
-          (qty, item) => (qty += item.quantity),
-          0
-        ) < this.buyX
-      ) {
-        return discountCart;
-      }
-
-      // Find the items that qualify for getX
-      let eligibleGetItems = discountCart.cart.lines;
-      if (this.getItemSelector) {
-        eligibleGetItems = discountCart.cart.lines.filter(
-          (lineItem) => {
-            // @ts-ignore
-            return this.getItemSelector?.match(lineItem);
-          }
-        );
-      }
-
-      // Check if cart qualifies for discounts and limit the discount sets
-      const purchasedQuantity = applicableBuyItems.reduce(
-        (total, item) => (total += item.quantity),
-        0
-      );
-      const discountableSets = this.maxSets
-        ? [
-            purchasedQuantity / this.buyX,
-            this.maxSets,
-          ].sort((a, b) => a - b)[0]
-        : Math.floor(purchasedQuantity / this.buyX);
-
-      if (discountableSets > 0) {
-        let discountableQuantity =
-          discountableSets *
-          (this.getY
-            ? this.getY
-            : discountCart.totalLineItemQuantity());
-
-        // Apply the discounts (sort to discount lower priced items first)
-        eligibleGetItems = eligibleGetItems.sort(
-          (item) => item.cost.amountPerQuantity.amount
-        );
-
-        const itemsToApplyDiscounts: ApplyDiscount[] = [];
-
-        eligibleGetItems.forEach((lineItem) => {
-          if (discountableQuantity == 0) {
-            return;
-          }
-
-          if (lineItem.quantity <= discountableQuantity) {
-            itemsToApplyDiscounts.push({
-              lineItem,
-            } as ApplyDiscount);
-            discountableQuantity -= lineItem.quantity;
-          } else {
-            itemsToApplyDiscounts.push({
-              lineItem,
-              maxDiscounts: discountableQuantity,
-            } as ApplyDiscount);
-            discountableQuantity = 0;
-          }
-        });
-
-        if (itemsToApplyDiscounts.length) {
-          const discount = this.discount.apply(
-            itemsToApplyDiscounts
-          );
-          discountCart.addDiscount(discount);
-        }
-      }
-    }
-
-    return discountCart;
-  }
-}

package/src/lineItem/ConditionalDiscount.ts

@@ -1,102 +0,0 @@
-import type { CartLine } from './api';
-import { Campaign } from '../common/Campaign';
-import type { DiscountCart } from '../common/DiscountCart';
-import type {
-  ApplyDiscount,
-  DiscountInterface,
-} from '../common/DiscountInterface';
-import type {
-  QualifierBehavior,
-  Qualifier,
-} from '../common/Qualifier';
-import type { Selector } from '../common/Selector';
-import type { AndSelector } from '../common/AndSelector';
-import type { OrSelector } from '../common/OrSelector';
-
-export class ConditionalDiscount extends Campaign {
-  discount: DiscountInterface;
-  itemsToDiscount?: number;
-
-  constructor(
-    behavior: QualifierBehavior,
-    qualifiers: [Qualifier | AndSelector | OrSelector],
-    discount: DiscountInterface,
-    lineItemSelector?: Selector,
-    maxDiscounts?: number
-  ) {
-    super(behavior, qualifiers);
-    this.discount = discount;
-    this.lineItemSelector = lineItemSelector;
-    this.itemsToDiscount =
-      maxDiscounts == 0 ? undefined : maxDiscounts;
-  }
-
-  run(discountCart: DiscountCart) {
-    // First we see if this cart qualifies for this discount
-    if (this.qualifies(discountCart)) {
-      // Now that it qualifies, we can determine the applicableLineItems
-      // to apply discounts to
-
-      // figure out applicable lineItems...
-      const applicableLineItems = discountCart.cart.lines
-        .filter((lineItem) => {
-          if (this.lineItemSelector === undefined) {
-            return true;
-          }
-          return this.lineItemSelector.match(
-            lineItem as CartLine
-          );
-        })
-        .sort((a, b) => {
-          const priceA = a.cost.amountPerQuantity
-            .amount as number;
-          const priceB = b.cost.amountPerQuantity
-            .amount as number;
-
-          if (priceA < priceB) return -1;
-          if (priceA == priceB) return 0;
-          return 1;
-        });
-
-      const itemsToApplyDiscounts: ApplyDiscount[] = [];
-
-      // Loop over the applicable line items and deduct the itemsToDiscount count
-      // as they are applied to not exceed a maximum.
-      applicableLineItems.forEach((lineItem) => {
-        // If there are no more items to discount, return/skip
-        if (this.itemsToDiscount === 0) return;
-
-        // If items to discount is not undefined, apply as many as possible
-        if (this.itemsToDiscount !== undefined) {
-          // There are more than enough qty to apply, apply the maximum
-          if (lineItem.quantity >= this.itemsToDiscount) {
-            itemsToApplyDiscounts.push({
-              lineItem,
-              maxDiscounts: this.itemsToDiscount,
-            } as ApplyDiscount);
-            this.itemsToDiscount = 0;
-          } else {
-            itemsToApplyDiscounts.push({
-              lineItem,
-            } as ApplyDiscount);
-            this.itemsToDiscount -= lineItem.quantity;
-          }
-        } else {
-          // items to discount is undefined, so apply to entire item count
-          itemsToApplyDiscounts.push({
-            lineItem,
-          } as ApplyDiscount);
-        }
-
-        if (itemsToApplyDiscounts.length) {
-          // append the discount to the discountCart singleton
-          const discount = this.discount.apply(
-            itemsToApplyDiscounts
-          );
-          discountCart.addDiscount(discount);
-        }
-      });
-    }
-    return discountCart;
-  }
-}

package/src/lineItem/FixedItemDiscount.ts

@@ -1,51 +0,0 @@
-import type { ProductVariant } from './api';
-import type {
-  ApplyDiscount,
-  Discount,
-  DiscountInterface,
-} from '../common/DiscountInterface';
-
-export class FixedItemDiscount
-  implements DiscountInterface
-{
-  amount: number;
-  appliesToEachItem: boolean;
-  message: string;
-
-  constructor(
-    amount: number,
-    appliesToEachItem: boolean,
-    message: string
-  ) {
-    this.amount = amount;
-    this.appliesToEachItem = appliesToEachItem;
-    this.message = message;
-  }
-
-  apply(items: ApplyDiscount[]): Discount {
-    const targets = items.map(
-      ({ lineItem, maxDiscounts }) => {
-        const variant =
-          lineItem.merchandise as ProductVariant;
-        return {
-          productVariant: {
-            id: variant.id,
-            quantity:
-              maxDiscounts == 0 ? undefined : maxDiscounts,
-          },
-        };
-      }
-    );
-
-    return {
-      targets,
-      value: {
-        fixedAmount: {
-          amount: this.amount,
-          appliesToEachItem: this.appliesToEachItem,
-        },
-      },
-      message: this.message,
-    } as Discount;
-  }
-}

package/src/lineItem/PercentageDiscount.ts

@@ -1,44 +0,0 @@
-import type { ProductVariant } from './api';
-import type {
-  Discount,
-  ApplyDiscount,
-  DiscountInterface,
-} from '../common/DiscountInterface';
-
-export class PercentageDiscount
-  implements DiscountInterface
-{
-  discount: number;
-  message?: string;
-
-  constructor(percentage: number, message?: string) {
-    this.discount = percentage;
-    this.message = message;
-  }
-
-  apply(items: ApplyDiscount[]): Discount {
-    const targets = items.map(
-      ({ lineItem, maxDiscounts }) => {
-        const variant =
-          lineItem.merchandise as ProductVariant;
-        return {
-          productVariant: {
-            id: variant.id,
-            quantity:
-              maxDiscounts == 0 ? undefined : maxDiscounts,
-          },
-        };
-      }
-    );
-
-    return {
-      targets,
-      value: {
-        percentage: {
-          value: this.discount,
-        },
-      },
-      message: this.message,
-    } as Discount;
-  }
-}