@zoxllc/shopify-checkout-extensions 0.0.3 → 0.0.4

package/src/common/DiscountCart.ts

@@ -1,12 +1,18 @@
-import type { RunInput, Discount } from '../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;
@@ -17,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;
         }
@@ -29,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;
@@ -44,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;
@@ -62,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;
@@ -72,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,10 +1,25 @@
-import type { CartLine, Discount } from '../generated/api';
+import type {
+  CartDeliveryOption,
+  CartLine,
+} 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 '../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 '../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 '../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,7 +1,7 @@
 import type {
   CartLine,
   ProductVariant,
-} from '../generated/api';
+} from '../lineItem/api';
 import { Selector } from './Selector';
 import {
   QualifierMatchType,
@@ -24,6 +24,7 @@ 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(

package/src/common/ProductTypeSelector.ts

@@ -1,19 +1,25 @@
 import type {
   CartLine,
   ProductVariant,
-} from '../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,4 +1,5 @@
-import type { CartLine } from '../generated/api';
+import type { CartDeliveryOption } from '~/shipping/api';
+import type { CartLine } from '../lineItem/api';
 import { StringComparisonType } from './Qualifier';
 
 export enum MatchType {
@@ -9,8 +10,15 @@ export enum MatchType {
   '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;
   }
 

package/src/common/SubscriptionItemSelector.ts

@@ -1,4 +1,4 @@
-import type { CartLine } from '../generated/api';
+import type { CartLine } from '../lineItem/api';
 import { MatchType, Selector } from './Selector';
 
 export class SubscriptionItemSelector extends Selector {
@@ -9,6 +9,7 @@ export class SubscriptionItemSelector extends Selector {
     this.invert = matchType == MatchType.NOT_ONE;
   }
 
+  match(subject: unknown): boolean;
   match(lineItem: CartLine) {
     const matchResult =
       lineItem.sellingPlanAllocation !== undefined;

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,

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

@@ -1,16 +1,16 @@
-import { Campaign } from "./Campaign";
-import type { AndSelector } from './AndSelector';
-import type { DiscountCart } from './DiscountCart';
+import { Campaign } from '../common/Campaign';
+import type { AndSelector } from '../common/AndSelector';
+import type { DiscountCart } from '../common/DiscountCart';
 import type {
   ApplyDiscount,
   DiscountInterface,
-} from './DiscountInterface';
-import type { OrSelector } from './OrSelector';
+} from '../common/DiscountInterface';
+import type { OrSelector } from '../common/OrSelector';
 import type {
   Qualifier,
   QualifierBehavior,
-} from './Qualifier';
-import type { Selector } from './Selector';
+} from '../common/Qualifier';
+import type { Selector } from '../common/Selector';
 
 export class BuyXGetY extends Campaign {
   lineItemSelector?: Selector;

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;
+  }
+}