@zoxllc/shopify-checkout-extensions 0.0.2 → 0.0.4

package/src/common/CustomerEmailQualifier.ts

@@ -1,10 +1,10 @@
-import type { DiscountCart } from "./DiscountCart";
+import type { DiscountCart } from './DiscountCart';
 import {
   StringComparisonType,
   QualifierMatchType,
   Qualifier,
-} from "./Qualifier";
-import { type Selector } from "./Selector";
+} from './Qualifier';
+import { type Selector } from './Selector';
 
 export class CustomerEmailQualifier extends Qualifier {
   invert: boolean;
@@ -34,20 +34,27 @@ export class CustomerEmailQualifier extends Qualifier {
 
     let matchResult = false;
 
-    const email = discountCart.cart.buyerIdentity.customer.email;
+    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) => e.includes(email)).length > 0;
+        matchResult =
+          this.emails.filter((e) => email.includes(e))
+            .length > 0;
         break;
       case StringComparisonType.START_WITH:
-        matchResult = this.emails.filter((e) => e.startsWith(email)).length > 0;
+        matchResult =
+          this.emails.filter((e) => email.startsWith(e))
+            .length > 0;
         break;
       case StringComparisonType.END_WITH:
-        matchResult = this.emails.filter((e) => e.endsWith(email)).length > 0;
+        matchResult =
+          this.emails.filter((e) => email.endsWith(e))
+            .length > 0;
         break;
     }
 

package/src/common/CustomerTagQualifier.ts

@@ -1,10 +1,10 @@
-import type { DiscountCart } from "./DiscountCart";
+import type { DiscountCart } from './DiscountCart';
 import {
   StringComparisonType,
   QualifierMatchType,
   Qualifier,
-} from "./Qualifier";
-import { type Selector } from "./Selector";
+} from './Qualifier';
+import { type Selector } from './Selector';
 
 export class CustomerTagQualifier extends Qualifier {
   invert: boolean;
@@ -30,21 +30,34 @@ export class CustomerTagQualifier extends Qualifier {
   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;
+        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;
           }
-          return false;
-        }) || []
+        ) || []
       ).length > 0;
 
     if (this.invert) {

package/src/common/DiscountCart.ts

@@ -1,15 +1,18 @@
-import type {
-  RunInput,
-  Discount,
-} from "extensions/zox-product-discount/generated/api";
+import type { RunInput as LineItemRunInput } from '../lineItem/api';
+import type { RunInput as ShippingRunInput } from '../shipping/api';
+import { Discount } from './DiscountInterface';
+
+type RunInput = {
+  cart: LineItemRunInput['cart'] & ShippingRunInput['cart'];
+};
 
 export class DiscountCart {
-  cart: RunInput["cart"];
+  cart: RunInput['cart'];
   subtotalAmount: number;
   appliedDiscountTotal: number;
   discounts: Discount[];
 
-  constructor(cart: RunInput["cart"]) {
+  constructor(cart: RunInput['cart']) {
     this.cart = cart;
     this.subtotalAmount = 0;
     this.appliedDiscountTotal = 0;
@@ -20,7 +23,7 @@ export class DiscountCart {
 
   subtotalExcludingVariants(variants: string[]) {
     return this.cart.lines.reduce((prev, curr) => {
-      if (curr.merchandise.__typename == "ProductVariant") {
+      if (curr.merchandise.__typename == 'ProductVariant') {
         if (variants.indexOf(curr.merchandise.id) > -1) {
           return prev - curr.cost.subtotalAmount.amount;
         }
@@ -32,10 +35,10 @@ export class DiscountCart {
 
   private subtotalExcludingGifts() {
     return this.cart.lines.reduce((prev, curr) => {
-      if (curr.merchandise.__typename == "ProductVariant") {
+      if (curr.merchandise.__typename == 'ProductVariant') {
         if (
           curr.merchandise.product.hasTags.filter(
-            (t) => t.hasTag && t.tag == "meta-exclude-gift"
+            (t) => t.hasTag && t.tag == 'meta-exclude-gift'
           ).length
         ) {
           return prev - curr.cost.subtotalAmount.amount;
@@ -47,15 +50,18 @@ export class DiscountCart {
   }
 
   totalLineItemQuantity() {
-    return this.cart.lines.reduce((total, item) => total + item.quantity, 0);
+    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.__typename == 'ProductVariant') {
         if (
           item.merchandise.product.hasTags.filter(
-            (t) => t.hasTag && t.tag == "meta-exclude-gift"
+            (t) => t.hasTag && t.tag == 'meta-exclude-gift'
           ).length
         ) {
           return total;
@@ -65,8 +71,9 @@ export class DiscountCart {
     }, 0);
   }
 
-  private setupCart(cart: RunInput["cart"]) {
-    this.subtotalAmount = cart.cost.subtotalAmount.amount as number;
+  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;
@@ -75,51 +82,68 @@ export class DiscountCart {
 
   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 {
+    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.fixedAmount?.amount > 0
-                ? discount.value.fixedAmount?.amount
-                : lineItemCost;
+              lineItemCost *
+              (discount.value.percentage?.value / 100) *
+              discountableItems;
           }
-        } else if (discount.value.percentage) {
-          total +=
-            lineItemCost *
-            (discount.value.percentage?.value / 100) *
-            discountableItems;
-        }
-      });
+        });
 
-      return total;
-    }, 0);
+        return total;
+      },
+      0
+    );
 
     this.appliedDiscountTotal += totalDiscounts;
-    console.error("appliedDiscountTotal", this.appliedDiscountTotal);
+    console.error(
+      'appliedDiscountTotal',
+      this.appliedDiscountTotal
+    );
 
     this.discounts.push(discount);
   }

package/src/common/DiscountInterface.ts

@@ -1,13 +1,25 @@
 import type {
+  CartDeliveryOption,
   CartLine,
-  Discount,
-} from "extensions/zox-product-discount/generated/api";
+} from '../lineItem/api';
 
-export type ApplyDiscount = {
+import type { Discount as ItemDiscount } from '../lineItem/api';
+import type { Discount as ShippingDiscount } from '~/shipping/api';
+
+export type Discount = ItemDiscount & ShippingDiscount;
+
+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,18 +1,21 @@
-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";
+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";
+  is_a: 'OrSelector';
   conditions: (Selector | Qualifier)[];
 
   constructor(conditions: (Selector | Qualifier)[]) {
-    this.is_a = "OrSelector";
+    this.is_a = 'OrSelector';
     this.conditions = conditions;
   }
 
-  match(item: CartLine | DiscountCart, selector?: Selector) {
+  match(
+    item: CartLine | DiscountCart,
+    selector?: Selector
+  ) {
     try {
       const conditionsResult = this.conditions
         .map((condition) => {
@@ -22,7 +25,9 @@ export class OrSelector {
               selector
             );
           } else {
-            return (condition as Selector).match(item as CartLine);
+            return (condition as Selector).match(
+              item as CartLine
+            );
           }
         })
         .filter((result) => result === true);

package/src/common/ProductHandleSelector.ts

@@ -1,8 +1,8 @@
 import type {
   CartLine,
   ProductVariant,
-} from "extensions/zox-product-discount/generated/api";
-import { MatchType, Selector } from "./Selector";
+} from '../lineItem/api';
+import { MatchType, Selector } from './Selector';
 
 export class ProductHandleSelector extends Selector {
   invert: boolean;
@@ -18,7 +18,9 @@ export class ProductHandleSelector extends Selector {
     const variant = lineItem.merchandise as ProductVariant;
 
     const matchResult =
-      this.handles.indexOf(variant.product.handle.toLowerCase()) > -1;
+      this.handles.indexOf(
+        variant.product.handle.toLowerCase()
+      ) > -1;
 
     if (this.invert) {
       return !matchResult;

package/src/common/ProductIdSelector.ts

@@ -1,23 +1,29 @@
 import type {
   CartLine,
   ProductVariant,
-} from "extensions/zox-product-discount/generated/api";
-import { MatchType, Selector } from "./Selector";
+} from '../lineItem/api';
+import { MatchType, Selector } from './Selector';
 
 export class ProductIdSelector extends Selector {
   invert: boolean;
   productIds: string[];
 
-  constructor(matchType: MatchType, 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);
+    const matchResult = this.productIds.includes(
+      variant.product.id
+    );
 
     if (this.invert) {
       return !matchResult;

package/src/common/ProductTagSelector.ts

@@ -1,9 +1,12 @@
 import type {
   CartLine,
   ProductVariant,
-} from "extensions/zox-product-discount/generated/api";
-import { Selector } from "./Selector";
-import { QualifierMatchType, StringComparisonType } from "./Qualifier";
+} from '../lineItem/api';
+import { Selector } from './Selector';
+import {
+  QualifierMatchType,
+  StringComparisonType,
+} from './Qualifier';
 
 export class ProductTagSelector extends Selector {
   invert: boolean;
@@ -21,21 +24,27 @@ export class ProductTagSelector extends Selector {
     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;
-    }, []);
+    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;
+          productTags.filter((tag) =>
+            this.tags.includes(tag)
+          ).length > 0;
         break;
       default:
         matchResult = this.partialMatch(

package/src/common/ProductTypeSelector.ts

@@ -1,19 +1,25 @@
 import type {
   CartLine,
   ProductVariant,
-} from "extensions/zox-product-discount/generated/api";
-import { MatchType, Selector } from "./Selector";
+} from '../lineItem/api';
+import { MatchType, Selector } from './Selector';
 
 export class ProductTypeSelector extends Selector {
   invert: boolean;
   productTypes: string[];
 
-  constructor(matchType: MatchType, productTypes: string[]) {
+  constructor(
+    matchType: MatchType,
+    productTypes: string[]
+  ) {
     super();
     this.invert = matchType == MatchType.NOT_ONE;
-    this.productTypes = productTypes.map((item) => item.toLowerCase());
+    this.productTypes = productTypes.map((item) =>
+      item.toLowerCase()
+    );
   }
 
+  match(subject: unknown): boolean;
   match(lineItem: CartLine) {
     const variant = lineItem.merchandise as ProductVariant;
 

package/src/common/SaleItemSelector.ts

@@ -1,4 +1,4 @@
-import { CartLine } from '../generated/api';
+import { CartLine } from '../lineItem/api';
 import { Selector } from './Selector';
 
 export enum SaleItemSelectorMatchType {
@@ -16,6 +16,7 @@ export class SaleItemSelector extends Selector {
     this.invert = matchType == SaleItemSelectorMatchType.IS;
   }
 
+  match(subject: unknown): boolean;
   match(lineItem: CartLine) {
     // Check to see if the item is NOT on sale
     const matchResult =

package/src/common/Selector.ts

@@ -1,16 +1,24 @@
-import type { CartLine } from "extensions/zox-product-discount/generated/api";
-import { StringComparisonType } from "./Qualifier";
+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",
+  'ALL' = ':all',
+  'IS_ONE' = ':is_one',
+  'NOT_ONE' = ':not_one',
+  'DOES' = ':does',
+  'DOES_NOT' = ':does_not',
 }
 
-export class Selector {
-  match(subject: CartLine, selector?: Selector) {
+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;
   }
 
@@ -30,19 +38,24 @@ export class Selector {
     possibleMatches: string[]
   ) {
     // Convert to an array if it isn't one
-    const subject = Array.isArray(itemInfo) ? itemInfo : [itemInfo];
+    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;
+            if (search.search(possibility) > -1)
+              foundMatch = true;
             break;
           case StringComparisonType.START_WITH:
-            if (search.startsWith(possibility)) foundMatch = true;
+            if (search.startsWith(possibility))
+              foundMatch = true;
             break;
           case StringComparisonType.END_WITH:
-            if (search.endsWith(possibility)) foundMatch = true;
+            if (search.endsWith(possibility))
+              foundMatch = true;
             break;
         }
       });

package/src/common/SubscriptionItemSelector.ts

@@ -1,5 +1,5 @@
-import type { CartLine } from "extensions/zox-product-discount/generated/api";
-import { MatchType, Selector } from "./Selector";
+import type { CartLine } from '../lineItem/api';
+import { MatchType, Selector } from './Selector';
 
 export class SubscriptionItemSelector extends Selector {
   invert: boolean;
@@ -9,8 +9,10 @@ export class SubscriptionItemSelector extends Selector {
     this.invert = matchType == MatchType.NOT_ONE;
   }
 
+  match(subject: unknown): boolean;
   match(lineItem: CartLine) {
-    const matchResult = lineItem.sellingPlanAllocation !== undefined;
+    const matchResult =
+      lineItem.sellingPlanAllocation !== undefined;
 
     if (this.invert) {
       return !matchResult;

package/src/index.ts

@@ -2,7 +2,7 @@ export { ConditionalDiscount } from './lineItem/ConditionalDiscount';
 export { FixedItemDiscount } from './lineItem/FixedItemDiscount';
 export { PercentageDiscount } from './lineItem/PercentageDiscount';
 export { AndSelector } from './common/AndSelector';
-export { BuyXGetY } from './common/BuyXGetY';
+export { BuyXGetY } from './lineItem/BuyXGetY';
 export { Campaign } from './common/Campaign';
 export type {
   CampaignType,