@zoxllc/shopify-checkout-extensions 0.0.1

package/src/common/CustomerSubscriberQualifier.ts

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,56 @@
+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) {
+            switch (this.matchCondition) {
+              case StringComparisonType.MATCH:
+                return this.tags.includes(t.tag);
+              case StringComparisonType.CONTAINS:
+                return this.tags.filter((e) => e.includes(t.tag)).length > 0;
+              case StringComparisonType.START_WITH:
+                return this.tags.filter((e) => e.startsWith(t.tag)).length > 0;
+              case StringComparisonType.END_WITH:
+                return this.tags.filter((e) => e.endsWith(t.tag)).length > 0;
+            }
+          }
+          return false;
+        }) || []
+      ).length > 0;
+
+    if (this.invert) {
+      return !matchResult;
+    }
+
+    return matchResult;
+  }
+}

package/src/common/DiscountCart.ts

@@ -0,0 +1,130 @@
+import type {
+  RunInput,
+  Discount,
+} from "extensions/zox-product-discount/generated/api";
+
+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 = [];
+  }
+
+  addDiscount(discount: Discount) {
+    // 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);
+
+        // TODO: Make sure we're not discounting more items than are available on the line item quantity
+
+        // 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);
+  }
+
+  reset() {
+    this.setupCart(this.cart);
+  }
+}

package/src/common/DiscountInterface.ts

@@ -0,0 +1,13 @@
+import type {
+  CartLine,
+  Discount,
+} from "extensions/zox-product-discount/generated/api";
+
+export type ApplyDiscount = {
+  lineItem: CartLine;
+  maxDiscounts?: number;
+};
+
+export interface DiscountInterface {
+  apply(items: ApplyDiscount[]): Discount;
+}

package/src/common/OrSelector.ts

@@ -0,0 +1,35 @@
+import type { DiscountCart } from "./DiscountCart";
+import type { Qualifier } from "./Qualifier";
+import type { Selector } from "./Selector";
+import type { CartLine } from "extensions/zox-product-discount/generated/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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,29 @@
+import type {
+  CartLine,
+  ProductVariant,
+} from "extensions/zox-product-discount/generated/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

@@ -0,0 +1,28 @@
+import type {
+  CartLine,
+  ProductVariant,
+} from "extensions/zox-product-discount/generated/api";
+import { MatchType, Selector } from "./Selector";
+
+export class ProductIdSelector extends Selector {
+  invert: boolean;
+  productIds: string[];
+
+  constructor(matchType: MatchType, productIds: string[]) {
+    super();
+    this.invert = matchType == MatchType.NOT_ONE;
+    this.productIds = productIds;
+  }
+
+  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

@@ -0,0 +1,54 @@
+import type {
+  CartLine,
+  ProductVariant,
+} from "extensions/zox-product-discount/generated/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(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;
+    }, []);
+
+    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;
+  }
+}

package/src/common/ProductTypeSelector.ts

@@ -0,0 +1,34 @@
+import type {
+  CartLine,
+  ProductVariant,
+} from "extensions/zox-product-discount/generated/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(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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,35 @@
+import { CartLine } from '../generated/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(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

@@ -0,0 +1,53 @@
+import type { CartLine } from "extensions/zox-product-discount/generated/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 class Selector {
+  match(subject: CartLine, selector?: Selector) {
+    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

@@ -0,0 +1,21 @@
+import type { CartLine } from "extensions/zox-product-discount/generated/api";
+import { MatchType, Selector } from "./Selector";
+
+export class SubscriptionItemSelector extends Selector {
+  invert: boolean;
+
+  constructor(matchType: MatchType) {
+    super();
+    this.invert = matchType == MatchType.NOT_ONE;
+  }
+
+  match(lineItem: CartLine) {
+    const matchResult = lineItem.sellingPlanAllocation !== undefined;
+
+    if (this.invert) {
+      return !matchResult;
+    }
+
+    return false;
+  }
+}