@zoxllc/shopify-checkout-extensions 0.0.7 → 0.1.0

package/src/common/CartQuantityQualifier.ts

@@ -1,94 +0,0 @@
-import type { CartLine } from '../lineItem/api';
-import type { DiscountCart } from './DiscountCart';
-import {
-  type NumericalComparisonType,
-  Qualifier,
-} from './Qualifier';
-import { type Selector } from './Selector';
-
-export enum CartQuantityBehavior {
-  CART = ':cart',
-  ITEM = ':item',
-  LINE_ANY = ':line_any',
-  LINE_ALL = ':line_all',
-}
-
-export class CartQuantityQualifier extends Qualifier {
-  totalMethod: CartQuantityBehavior;
-  comparisonType: NumericalComparisonType;
-  quantity: number;
-
-  constructor(
-    totalMethod: CartQuantityBehavior,
-    comparisonType: NumericalComparisonType,
-    quantity: number
-  ) {
-    super();
-    this.totalMethod = totalMethod;
-    this.comparisonType = comparisonType;
-    this.quantity = quantity;
-  }
-
-  /**
-   * Determines if the carts amount
-   * @param cart
-   * @param selector
-   */
-  match(discountCart: DiscountCart, selector?: Selector) {
-    let total = 0;
-
-    switch (this.totalMethod) {
-      case CartQuantityBehavior.ITEM:
-        total = discountCart.cart.lines.reduce(
-          (totalQty, line) => {
-            return (
-              totalQty +
-              ((
-                selector
-                  ? selector.match(line as CartLine)
-                  : 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 as CartLine) : 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
-      );
-    }
-  }
-}

package/src/common/CountryCodeQualifier.ts

@@ -1,49 +0,0 @@
-import type { DiscountCart } from './DiscountCart';
-import {
-  StringComparisonType,
-  QualifierMatchType,
-  Qualifier,
-} from './Qualifier';
-import { type Selector } from './Selector';
-
-export class CountryCodeQualifier extends Qualifier {
-  invert: boolean;
-  countryCodes: string[];
-
-  constructor(
-    matchType: QualifierMatchType,
-    countryCodes: string[]
-  ) {
-    super();
-    this.invert = matchType == 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: DiscountCart, selector?: 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;
-  }
-}

package/src/common/CustomerEmailQualifier.ts

@@ -1,67 +0,0 @@
-import type { DiscountCart } from './DiscountCart';
-import {
-  StringComparisonType,
-  QualifierMatchType,
-  Qualifier,
-} from './Qualifier';
-import { type Selector } from './Selector';
-
-export class CustomerEmailQualifier extends Qualifier {
-  invert: boolean;
-  matchCondition: StringComparisonType;
-  emails: string[];
-
-  constructor(
-    matchType: QualifierMatchType,
-    matchCondition: StringComparisonType,
-    emails: string[]
-  ) {
-    super();
-    this.invert = matchType == QualifierMatchType.DOES_NOT;
-    this.matchCondition = matchCondition;
-    this.emails = emails.map((e) => e.toLowerCase());
-  }
-
-  /**
-   * Determines if the customer's email matches
-   * @param discountCart DiscountCart
-   * @param selector Selector
-   */
-  match(discountCart: DiscountCart, selector?: Selector) {
-    if (!discountCart.cart.buyerIdentity?.customer?.email) {
-      return false;
-    }
-
-    let matchResult = false;
-
-    const email =
-      discountCart.cart.buyerIdentity.customer.email.toLowerCase();
-
-    switch (this.matchCondition) {
-      case StringComparisonType.MATCH:
-        matchResult = this.emails.includes(email);
-        break;
-      case StringComparisonType.CONTAINS:
-        matchResult =
-          this.emails.filter((e) => email.includes(e))
-            .length > 0;
-        break;
-      case StringComparisonType.START_WITH:
-        matchResult =
-          this.emails.filter((e) => email.startsWith(e))
-            .length > 0;
-        break;
-      case StringComparisonType.END_WITH:
-        matchResult =
-          this.emails.filter((e) => email.endsWith(e))
-            .length > 0;
-        break;
-    }
-
-    if (this.invert) {
-      return !matchResult;
-    }
-
-    return matchResult;
-  }
-}

package/src/common/CustomerSubscriberQualifier.ts

@@ -1,32 +0,0 @@
-import type { DiscountCart } from "./DiscountCart";
-import { QualifierMatchType, Qualifier } from "./Qualifier";
-import { type Selector } from "./Selector";
-
-export class CustomerSubscriberQualifier extends Qualifier {
-  invert: boolean;
-
-  /**
-   * Whether the customer contains an active subscription or not.
-   * @param matchType Pass :DOES or :DOES_NOT respectively
-   */
-  constructor(matchType: QualifierMatchType) {
-    super();
-    this.invert = matchType == QualifierMatchType.DOES_NOT;
-  }
-
-  /**
-   * Determines if the customer has specified tags
-   * @param discountCart DiscountCart
-   * @param selector Selector
-   */
-  match(discountCart: DiscountCart, selector?: Selector) {
-    const matchResult =
-      discountCart.cart.buyerIdentity?.customer?.isActiveSubscriber || false;
-
-    if (this.invert) {
-      return !matchResult;
-    }
-
-    return matchResult;
-  }
-}

package/src/common/CustomerTagQualifier.ts

@@ -1,69 +0,0 @@
-import type { DiscountCart } from './DiscountCart';
-import {
-  StringComparisonType,
-  QualifierMatchType,
-  Qualifier,
-} from './Qualifier';
-import { type Selector } from './Selector';
-
-export class CustomerTagQualifier extends Qualifier {
-  invert: boolean;
-  matchCondition: StringComparisonType;
-  tags: string[];
-
-  constructor(
-    matchType: QualifierMatchType,
-    matchCondition: StringComparisonType,
-    tags: string[]
-  ) {
-    super();
-    this.invert = matchType == QualifierMatchType.DOES_NOT;
-    this.matchCondition = matchCondition;
-    this.tags = tags.map((e) => e.toLowerCase());
-  }
-
-  /**
-   * Determines if the customer has specified tags
-   * @param discountCart DiscountCart
-   * @param selector Selector
-   */
-  match(discountCart: DiscountCart, selector?: Selector) {
-    const matchResult =
-      (
-        discountCart.cart.buyerIdentity?.customer?.hasTags.filter(
-          (t) => {
-            if (t.hasTag) {
-              const tag = t.tag.toLowerCase();
-              switch (this.matchCondition) {
-                case StringComparisonType.MATCH:
-                  return this.tags.includes(tag);
-                case StringComparisonType.CONTAINS:
-                  return (
-                    this.tags.filter((e) => tag.includes(e))
-                      .length > 0
-                  );
-                case StringComparisonType.START_WITH:
-                  return (
-                    this.tags.filter((e) =>
-                      tag.startsWith(e)
-                    ).length > 0
-                  );
-                case StringComparisonType.END_WITH:
-                  return (
-                    this.tags.filter((e) => tag.endsWith(e))
-                      .length > 0
-                  );
-              }
-            }
-            return false;
-          }
-        ) || []
-      ).length > 0;
-
-    if (this.invert) {
-      return !matchResult;
-    }
-
-    return matchResult;
-  }
-}

package/src/common/DiscountCart.ts

@@ -1,161 +0,0 @@
-import type {
-  RunInput as LineItemRunInput,
-  Discount as DiscountItem,
-} from '../lineItem/api';
-import type {
-  RunInput as ShippingRunInput,
-  Discount as DiscountShipping,
-} from '../shipping/api';
-import { Discount } from './DiscountInterface';
-
-type RunInput = {
-  cart: LineItemRunInput['cart'] & ShippingRunInput['cart'];
-};
-
-export class DiscountCart {
-  cart: RunInput['cart'];
-  subtotalAmount: number;
-  appliedDiscountTotal: number;
-  discounts: Discount[];
-
-  constructor(cart: RunInput['cart']) {
-    this.cart = cart;
-    this.subtotalAmount = 0;
-    this.appliedDiscountTotal = 0;
-    this.discounts = [];
-
-    this.setupCart(cart);
-  }
-
-  subtotalExcludingVariants(variants: string[]) {
-    return this.cart.lines.reduce((prev, curr) => {
-      if (curr.merchandise.__typename == 'ProductVariant') {
-        if (variants.indexOf(curr.merchandise.id) > -1) {
-          return prev - curr.cost.subtotalAmount.amount;
-        }
-      }
-
-      return prev;
-    }, this.subtotalExcludingGifts());
-  }
-
-  private subtotalExcludingGifts() {
-    return this.cart.lines.reduce((prev, curr) => {
-      if (curr.merchandise.__typename == 'ProductVariant') {
-        if (
-          curr.merchandise.product.hasTags.filter(
-            (t) => t.hasTag && t.tag == 'meta-exclude-gift'
-          ).length
-        ) {
-          return prev - curr.cost.subtotalAmount.amount;
-        }
-      }
-
-      return prev;
-    }, this.subtotalAmount);
-  }
-
-  totalLineItemQuantity() {
-    return this.cart.lines.reduce(
-      (total, item) => total + item.quantity,
-      0
-    );
-  }
-
-  totalLineItemQuantityExcludingGifts() {
-    return this.cart.lines.reduce((total, item) => {
-      if (item.merchandise.__typename == 'ProductVariant') {
-        if (
-          item.merchandise.product.hasTags.filter(
-            (t) => t.hasTag && t.tag == 'meta-exclude-gift'
-          ).length
-        ) {
-          return total;
-        }
-      }
-      return total + item.quantity;
-    }, 0);
-  }
-
-  private setupCart(cart: RunInput['cart']) {
-    this.subtotalAmount = cart.cost.subtotalAmount
-      .amount as number;
-    // Adjust the subtotal amount by excluding the value from gift items
-    this.subtotalAmount = this.subtotalExcludingGifts();
-    this.appliedDiscountTotal = 0;
-    this.discounts = [];
-  }
-
-  addShippingDiscount(discount: DiscountShipping) {
-    this.discounts.push(discount as Discount);
-  }
-
-  addDiscount(discount: DiscountItem) {
-    // Figure out how much discount has been applied
-    const totalDiscounts = discount.targets.reduce(
-      (total, target) => {
-        // gather target lineItem
-        const lineItems = this.cart.lines.filter((line) =>
-          line.merchandise.__typename == 'ProductVariant'
-            ? line.merchandise.id ==
-              target.productVariant.id
-            : false
-        );
-
-        // loop over the line items and do maths
-        lineItems.forEach((line) => {
-          let discountableItems = target.productVariant
-            .quantity
-            ? target.productVariant.quantity
-            : line.quantity;
-
-          const lineItemCost = parseFloat(
-            line.cost.amountPerQuantity.amount
-          );
-
-          // When it's a fixed amount, calculate the items per but only if it applies to each individual item...
-          if (discount.value.fixedAmount) {
-            if (
-              discount.value.fixedAmount.appliesToEachItem
-            ) {
-              total +=
-                lineItemCost -
-                  discount.value.fixedAmount?.amount >
-                0
-                  ? discount.value.fixedAmount?.amount *
-                    discountableItems
-                  : lineItemCost * discountableItems;
-            } else {
-              total +=
-                lineItemCost -
-                  discount.value.fixedAmount?.amount >
-                0
-                  ? discount.value.fixedAmount?.amount
-                  : lineItemCost;
-            }
-          } else if (discount.value.percentage) {
-            total +=
-              lineItemCost *
-              (discount.value.percentage?.value / 100) *
-              discountableItems;
-          }
-        });
-
-        return total;
-      },
-      0
-    );
-
-    this.appliedDiscountTotal += totalDiscounts;
-    console.error(
-      'appliedDiscountTotal',
-      this.appliedDiscountTotal
-    );
-
-    this.discounts.push(discount as Discount);
-  }
-
-  reset() {
-    this.setupCart(this.cart);
-  }
-}

package/src/common/DiscountInterface.ts

@@ -1,26 +0,0 @@
-import type {
-  CartDeliveryOption,
-  CartLine,
-} from '../lineItem/api';
-
-import type { Discount as DiscountItem } from '../lineItem/api';
-import type { Discount as DiscountShipping } from '../shipping/api';
-
-export type Discount = DiscountItem & DiscountShipping;
-
-
-type ApplyLineItemDiscount = {
-  lineItem: CartLine;
-  maxDiscounts?: number;
-};
-
-type ApplyShippingDiscount = {
-  deliveryOption: CartDeliveryOption;
-};
-
-export type ApplyDiscount = ApplyLineItemDiscount &
-  ApplyShippingDiscount;
-
-export interface DiscountInterface {
-  apply(items: ApplyDiscount[]): Discount;
-}

package/src/common/OrSelector.ts

@@ -1,40 +0,0 @@
-import type { DiscountCart } from './DiscountCart';
-import type { Qualifier } from './Qualifier';
-import type { Selector } from './Selector';
-import type { CartLine } from '../lineItem/api';
-
-export class OrSelector {
-  is_a: 'OrSelector';
-  conditions: (Selector | Qualifier)[];
-
-  constructor(conditions: (Selector | Qualifier)[]) {
-    this.is_a = 'OrSelector';
-    this.conditions = conditions;
-  }
-
-  match(
-    item: CartLine | DiscountCart,
-    selector?: Selector
-  ) {
-    try {
-      const conditionsResult = this.conditions
-        .map((condition) => {
-          if (selector) {
-            return (condition as Qualifier).match(
-              item as DiscountCart,
-              selector
-            );
-          } else {
-            return (condition as Selector).match(
-              item as CartLine
-            );
-          }
-        })
-        .filter((result) => result === true);
-
-      return conditionsResult.length > 0;
-    } catch (e) {
-      return false;
-    }
-  }
-}

package/src/common/PostCartAmountQualifier.ts

@@ -1,21 +0,0 @@
-import type { DiscountCart } from "./DiscountCart";
-import { type NumericalComparisonType, Qualifier } from "./Qualifier";
-
-export class PostCartAmountQualifier extends Qualifier {
-  comparisonType: NumericalComparisonType;
-  amount: number;
-
-  constructor(comparisonType: NumericalComparisonType, amount: number) {
-    super();
-    this.comparisonType = comparisonType;
-    this.amount = amount;
-  }
-
-  match(discountCart: DiscountCart) {
-    return this.compareAmounts(
-      discountCart.subtotalAmount - discountCart.appliedDiscountTotal,
-      this.comparisonType,
-      this.amount
-    );
-  }
-}

package/src/common/ProductHandleSelector.ts

@@ -1,31 +0,0 @@
-import type {
-  CartLine,
-  ProductVariant,
-} from '../lineItem/api';
-import { MatchType, Selector } from './Selector';
-
-export class ProductHandleSelector extends Selector {
-  invert: boolean;
-  handles: string[];
-
-  constructor(matchType: MatchType, handles: string[]) {
-    super();
-    this.invert = matchType == MatchType.NOT_ONE;
-    this.handles = handles.map((t) => t.toLowerCase());
-  }
-
-  match(lineItem: CartLine) {
-    const variant = lineItem.merchandise as ProductVariant;
-
-    const matchResult =
-      this.handles.indexOf(
-        variant.product.handle.toLowerCase()
-      ) > -1;
-
-    if (this.invert) {
-      return !matchResult;
-    }
-
-    return matchResult;
-  }
-}

package/src/common/ProductIdSelector.ts

@@ -1,34 +0,0 @@
-import type {
-  CartLine,
-  ProductVariant,
-} from '../lineItem/api';
-import { MatchType, Selector } from './Selector';
-
-export class ProductIdSelector extends Selector {
-  invert: boolean;
-  productIds: string[];
-
-  constructor(
-    matchType: MatchType.IS_ONE | MatchType.NOT_ONE,
-    productIds: string[]
-  ) {
-    super();
-    this.invert = matchType == MatchType.NOT_ONE;
-    this.productIds = productIds;
-  }
-
-  match(subject: unknown): boolean;
-  match(lineItem: CartLine) {
-    const variant = lineItem.merchandise as ProductVariant;
-
-    const matchResult = this.productIds.includes(
-      variant.product.id
-    );
-
-    if (this.invert) {
-      return !matchResult;
-    }
-
-    return matchResult;
-  }
-}

package/src/common/ProductTagSelector.ts

@@ -1,63 +0,0 @@
-import type {
-  CartLine,
-  ProductVariant,
-} from '../lineItem/api';
-import { Selector } from './Selector';
-import {
-  QualifierMatchType,
-  StringComparisonType,
-} from './Qualifier';
-
-export class ProductTagSelector extends Selector {
-  invert: boolean;
-  matchCondition: StringComparisonType;
-  tags: string[];
-
-  constructor(
-    matchType: QualifierMatchType,
-    matchCondition: StringComparisonType,
-    tags: string[]
-  ) {
-    super();
-    this.matchCondition = matchCondition;
-    this.invert = matchType == QualifierMatchType.DOES_NOT;
-    this.tags = tags.map((t) => t.toLowerCase());
-  }
-
-  match(subject: unknown): boolean;
-  match(lineItem: CartLine) {
-    const variant = lineItem.merchandise as ProductVariant;
-    const productTags = variant.product.hasTags.reduce(
-      (tags, t) => {
-        if (t.hasTag) {
-          tags.push(t.tag.toLowerCase());
-        }
-        return tags;
-      },
-      [] as string[]
-    );
-
-    let matchResult: boolean;
-
-    switch (this.matchCondition) {
-      case StringComparisonType.MATCH:
-        matchResult =
-          productTags.filter((tag) =>
-            this.tags.includes(tag)
-          ).length > 0;
-        break;
-      default:
-        matchResult = this.partialMatch(
-          this.matchCondition,
-          productTags,
-          this.tags
-        );
-    }
-
-    if (this.invert) {
-      return !matchResult;
-    }
-
-    return matchResult;
-  }
-}