@zoxllc/shopify-checkout-extensions 0.0.2 → 0.0.4

package/src/{common → lineItem}/BuyXGetY.ts

@@ -1,11 +1,16 @@
-import { Campaign } from "./Campaign";
-import type { CartLine } from "../../../../extensions/zox-product-discount/generated/api";
-import type { AndSelector } from "./AndSelector";
-import type { DiscountCart } from "./DiscountCart";
-import type { ApplyDiscount, DiscountInterface } from "./DiscountInterface";
-import type { OrSelector } from "./OrSelector";
-import type { Qualifier, QualifierBehavior } from "./Qualifier";
-import type { Selector } from "./Selector";
+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;
@@ -39,14 +44,19 @@ export class BuyXGetY extends Campaign {
       // Find the items that qualify for buyX
       let applicableBuyItems = discountCart.cart.lines;
       if (this.lineItemSelector) {
-        applicableBuyItems = discountCart.cart.lines.filter((lineItem) => {
-          return this.lineItemSelector?.match(lineItem as CartLine);
-        });
+        applicableBuyItems = discountCart.cart.lines.filter(
+          (lineItem) => {
+            // @ts-ignore
+            return this.lineItemSelector?.match(lineItem);
+          }
+        );
       }
 
       if (
-        applicableBuyItems.reduce((qty, item) => (qty += item.quantity), 0) <
-        this.buyX
+        applicableBuyItems.reduce(
+          (qty, item) => (qty += item.quantity),
+          0
+        ) < this.buyX
       ) {
         return discountCart;
       }
@@ -54,9 +64,12 @@ export class BuyXGetY extends Campaign {
       // Find the items that qualify for getX
       let eligibleGetItems = discountCart.cart.lines;
       if (this.getItemSelector) {
-        eligibleGetItems = discountCart.cart.lines.filter((lineItem) => {
-          return this.getItemSelector?.match(lineItem as CartLine);
-        });
+        eligibleGetItems = discountCart.cart.lines.filter(
+          (lineItem) => {
+            // @ts-ignore
+            return this.getItemSelector?.match(lineItem);
+          }
+        );
       }
 
       // Check if cart qualifies for discounts and limit the discount sets
@@ -65,13 +78,18 @@ export class BuyXGetY extends Campaign {
         0
       );
       const discountableSets = this.maxSets
-        ? [purchasedQuantity / this.buyX, this.maxSets].sort((a, b) => a - b)[0]
+        ? [
+            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());
+          (this.getY
+            ? this.getY
+            : discountCart.totalLineItemQuantity());
 
         // Apply the discounts (sort to discount lower priced items first)
         eligibleGetItems = eligibleGetItems.sort(
@@ -86,7 +104,9 @@ export class BuyXGetY extends Campaign {
           }
 
           if (lineItem.quantity <= discountableQuantity) {
-            itemsToApplyDiscounts.push({ lineItem } as ApplyDiscount);
+            itemsToApplyDiscounts.push({
+              lineItem,
+            } as ApplyDiscount);
             discountableQuantity -= lineItem.quantity;
           } else {
             itemsToApplyDiscounts.push({
@@ -98,7 +118,9 @@ export class BuyXGetY extends Campaign {
         });
 
         if (itemsToApplyDiscounts.length) {
-          const discount = this.discount.apply(itemsToApplyDiscounts);
+          const discount = this.discount.apply(
+            itemsToApplyDiscounts
+          );
           discountCart.addDiscount(discount);
         }
       }

package/src/lineItem/ConditionalDiscount.ts

@@ -1,4 +1,4 @@
-import type { CartLine } from '../generated/api';
+import type { CartLine } from './api';
 import { Campaign } from '../common/Campaign';
 import type { DiscountCart } from '../common/DiscountCart';
 import type {

package/src/lineItem/FixedItemDiscount.ts

@@ -1,9 +1,7 @@
-import type {
-  Discount,
-  ProductVariant,
-} from '../generated/api';
+import type { ProductVariant } from './api';
 import type {
   ApplyDiscount,
+  Discount,
   DiscountInterface,
 } from '../common/DiscountInterface';
 

package/src/lineItem/PercentageDiscount.ts

@@ -1,8 +1,6 @@
+import type { ProductVariant } from './api';
 import type {
   Discount,
-  ProductVariant,
-} from '../generated/api';
-import type {
   ApplyDiscount,
   DiscountInterface,
 } from '../common/DiscountInterface';
@@ -41,6 +39,6 @@ export class PercentageDiscount
         },
       },
       message: this.message,
-    };
+    } as Discount;
   }
 }

package/src/shipping/FixedDiscount.ts

@@ -0,0 +1,37 @@
+import type {
+  ApplyDiscount,
+  Discount,
+  DiscountInterface,
+} from '../common/DiscountInterface';
+
+export class FixedDiscount implements DiscountInterface {
+  amount: number;
+  message: string;
+
+  constructor(amount: number, message: string) {
+    this.amount = amount;
+    this.message = message;
+  }
+
+  apply(items: ApplyDiscount[]): Discount {
+    const targets = items.map(
+      ({ deliveryOption: { handle } }) => {
+        return {
+          deliveryOption: {
+            handle,
+          },
+        };
+      }
+    );
+
+    return {
+      targets,
+      value: {
+        fixedAmount: {
+          amount: this.amount,
+        },
+      },
+      message: this.message,
+    } as Discount;
+  }
+}

package/src/shipping/RateNameSelector.ts

@@ -0,0 +1,54 @@
+import type { CartDeliveryOption } from '../shipping/api';
+import { MatchType, Selector } from '../common/Selector';
+import { StringComparisonType } from '../common/Qualifier';
+
+export class RateNameSelector extends Selector {
+  invert: boolean;
+  matchCondition: StringComparisonType;
+  names: string[];
+
+  constructor(
+    matchType: MatchType.DOES | MatchType.DOES_NOT,
+    matchCondition: StringComparisonType,
+    names: string[]
+  ) {
+    super();
+    this.invert = matchType == MatchType.DOES_NOT;
+    this.matchCondition = matchCondition;
+    this.names = names.map((e) => e.toLowerCase());
+  }
+
+  match(subject: unknown): boolean;
+  match(subject: CartDeliveryOption) {
+    let matchResult;
+
+    const title = subject?.title?.toLowerCase() || '';
+
+    switch (this.matchCondition) {
+      case StringComparisonType.MATCH:
+        matchResult = this.names.includes(title);
+        break;
+      case StringComparisonType.CONTAINS:
+        matchResult =
+          this.names.filter((e) => title.indexOf(e) > -1)
+            .length > 0;
+        break;
+      case StringComparisonType.START_WITH:
+        matchResult =
+          this.names.filter((e) => title.startsWith(e))
+            .length > 0;
+        break;
+      case StringComparisonType.END_WITH:
+        matchResult =
+          this.names.filter((e) => title.endsWith(e))
+            .length > 0;
+        break;
+    }
+
+    if (this.invert) {
+      return !matchResult;
+    }
+
+    return matchResult;
+  }
+}

package/src/shipping/ShippingDiscount.ts

@@ -0,0 +1,75 @@
+import type { CartDeliveryOption } 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 ShippingDiscount extends Campaign {
+  discount: DiscountInterface;
+  rateSelector: Selector;
+
+  constructor(
+    behavior: QualifierBehavior,
+    qualifiers:
+      | (Qualifier | AndSelector | OrSelector)[]
+      | null,
+    discount: DiscountInterface,
+    rateSelector: Selector
+  ) {
+    super(behavior, qualifiers);
+    this.discount = discount;
+    this.rateSelector = rateSelector;
+  }
+
+  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 applicableDeliveryOptions
+      // to apply discounts to by...
+      // Loop through all deliveryGroups
+      const applicableDiscounts =
+        discountCart.cart.deliveryGroups
+          .reduce((deliveryOptions, deliveryGroup) => {
+            // Loop through its delivery options
+            deliveryGroup.deliveryOptions.forEach((o) => {
+              const deliveryOption =
+                o as CartDeliveryOption;
+              // 2. Looping any deliveryOptions within the group
+              if (
+                this.rateSelector &&
+                this.rateSelector.match(deliveryOption)
+              ) {
+                // if this is a match, we want to apply this discount
+                deliveryOptions.push(deliveryOption);
+              }
+            });
+
+            return deliveryOptions;
+          }, [] as CartDeliveryOption[])
+          .map((deliveryOption) => {
+            return {
+              deliveryOption: {
+                handle: deliveryOption.handle,
+              },
+            } as ApplyDiscount;
+          });
+
+      if (applicableDiscounts.length) {
+        const discount = this.discount.apply(
+          applicableDiscounts
+        );
+        discountCart.addDiscount(discount);
+      }
+    }
+    return discountCart;
+  }
+}