@ordergroove/offers 2.33.0 → 2.33.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ordergroove/offers",
-  "version": "2.33.0",
+  "version": "2.33.2",
   "description": "offer state component",
   "author": "Eugenio Lattanzio <eugenio63@gmail.com>",
   "homepage": "https://github.com/ordergroove/plush-toys#readme",
@@ -47,5 +47,5 @@
   "devDependencies": {
     "@ordergroove/offers-templates": "^0.8.0"
   },
-  "gitHead": "79b0589a027dd38497e5b6db11397e1dfd94d639"
+  "gitHead": "771e0978a0b4025ce0a250e35a976e22cd1f09b2"
 }

package/src/components/When.js

@@ -16,9 +16,16 @@ export class When extends withProduct(LitElement) {
   }
 
   render() {
-    const result =
-      this.test &&
-      expression.parse(removeWhitespace(this.test), key => descriptors[key] && descriptors[key](this.state, this));
+    if (!this.test) {
+      return html``;
+    }
+
+    let test = removeWhitespace(this.test);
+    // the parser returns incorrect result if you use an expression with &!, e.g. test1&!test2
+    // it succeeds if you wrap !test2 in parentheses, e.g. test1&(!test2)
+    // so we'll wrap all "not" expressions in parentheses
+    test = test.replace(/(![a-zA-Z]+)/g, '($1)');
+    const result = expression.parse(test, key => descriptors[key] && descriptors[key](this.state, this));
 
     if (result) {
       return html`

package/src/components/__tests__/When.spec.js

@@ -12,38 +12,62 @@ class When extends WhenBase {
 }
 customElements.define('og-when-test', When);
 
+const PRODUCT_ID = 'prodA';
+
+function stateToString(state) {
+  return Object.keys(state)
+    .map(key => `${key}=${state[key][PRODUCT_ID]}`)
+    .join(' and ');
+}
+
+async function testWhen(expression, productState, expected) {
+  const element = new When();
+  element.product = { id: PRODUCT_ID };
+  element.test = expression;
+  element.state = Object.keys(productState).reduce((acc, key) => {
+    acc[key] = { [PRODUCT_ID]: productState[key] };
+    return acc;
+  }, {});
+  await appendToBody(element).then(() => {
+    const slot = querySelector(element, 'slot');
+    const expectedMessage = `expected ${expression} to be ${expected} when ${stateToString(element.state)}`;
+    if (expected) {
+      expect(slot).toBeTruthy(expectedMessage);
+    } else {
+      expect(slot).toBeFalsy(expectedMessage);
+    }
+  });
+}
+
 describe('Conditional', () => {
   it('should not render child given test result is false', async () => {
-    const element = new When();
-    element.product = { id: 'prodA' };
-    element.test = 'inStock';
-    element.state = {
-      inStock: {
-        prodA: false
-      },
-      autoshipEligible: {
-        prodA: false
-      }
-    };
-    await appendToBody(element);
-
-    expect(querySelector(element, 'slot')).toBeFalsy();
+    await testWhen('inStock', { inStock: false, autoshipEligible: false }, false);
   });
 
   it('should render child given test result is true', async () => {
-    const element = new When();
-    element.product = { id: 'prodA' };
-    element.test = 'inStock';
-    element.state = {
-      inStock: {
-        prodA: true
-      },
-      autoshipEligible: {
-        prodA: true
-      }
-    };
-    await appendToBody(element);
-
-    expect(querySelector(element, 'slot')).toBeTruthy();
+    await testWhen('inStock', { inStock: true, autoshipEligible: false }, true);
+  });
+
+  it('should handle compound expressions', async () => {
+    await testWhen('inStock&!eligible', { inStock: false, autoshipEligible: false }, false);
+    await testWhen('inStock&(!eligible)', { inStock: false, autoshipEligible: false }, false);
+    await testWhen('inStock|!eligible', { inStock: false, autoshipEligible: false }, true);
+    await testWhen('inStock|eligible', { inStock: false, autoshipEligible: true }, true);
+    await testWhen('!inStock&!eligible', { inStock: false, autoshipEligible: false }, true);
+    await testWhen(
+      'inStock&eligible&autoshipByDefault',
+      { inStock: false, autoshipEligible: true, autoshipbyDefault: true },
+      false
+    );
+    await testWhen(
+      'inStock&eligible&autoshipByDefault',
+      { inStock: true, autoshipEligible: true, autoshipbyDefault: true },
+      false
+    );
+    await testWhen(
+      'inStock&(!eligible|autoshipByDefault)',
+      { inStock: true, autoshipEligible: true, autoshipByDefault: true },
+      true
+    );
   });
 });

package/src/shopify/__tests__/shopifyReducer.spec.js

@@ -104,6 +104,68 @@ describe('autoshipEligible', () => {
 
     expect(actual).toEqual({ 'yum existing key': 'yum existing value' });
   });
+
+  it('should return false if there are only prepaid selling_plans', () => {
+    const actual = autoshipEligible(
+      {},
+      {
+        type: constants.SETUP_PRODUCT,
+        payload: {
+          product: {
+            id: 'yum product id',
+            selling_plan_allocations: [],
+            variants: [
+              {
+                id: 'single-non-prepaid',
+                selling_plan_allocations: [{ selling_plan_id: 1 }]
+              },
+              {
+                id: 'prepaid-and-non-prepaid',
+                selling_plan_allocations: [{ selling_plan_id: 1 }, { selling_plan_id: 2 }]
+              },
+              {
+                id: 'single-prepaid',
+                selling_plan_allocations: [{ selling_plan_id: 2 }]
+              },
+              {
+                id: 'multiple-prepaid',
+                selling_plan_allocations: [{ selling_plan_id: 2 }, { selling_plan_id: 3 }]
+              }
+            ],
+            selling_plan_groups: [
+              {
+                name: 'Subscribe and Save',
+                selling_plans: [
+                  {
+                    id: 1
+                  }
+                ]
+              },
+              {
+                name: 'Prepaid-yum variant id',
+                selling_plans: [
+                  {
+                    id: 2
+                  },
+                  {
+                    id: 3
+                  }
+                ]
+              }
+            ]
+          }
+        }
+      }
+    );
+
+    expect(actual).toEqual({
+      'yum product id': false,
+      'single-non-prepaid': true,
+      'prepaid-and-non-prepaid': true,
+      'single-prepaid': false,
+      'multiple-prepaid': false
+    });
+  });
 });
 
 describe('config', () => {

package/src/shopify/shopifyReducer.js

@@ -145,6 +145,28 @@ const reduceProductCartLine = (acc, cur) => {
   return { ...acc, [cur.key]: acc[productId] || null };
 };
 
+const isPrepaidSellingPlanGroup = sellingPlanGroup => sellingPlanGroup.name.toUpperCase().includes('PREPAID');
+
+const filterNonPrepaidSellingPlans = (sellingPlanAllocations, sellingPlanGroups) => {
+  if (!sellingPlanAllocations || sellingPlanAllocations.length === 0) {
+    return [];
+  }
+  if (!sellingPlanGroups || sellingPlanGroups.length === 0) {
+    return sellingPlanAllocations;
+  }
+
+  const nonPrepaidSellingPlansIds = sellingPlanGroups.reduce((allIds, group) => {
+    if (!isPrepaidSellingPlanGroup(group)) {
+      allIds.push(...group.selling_plans.map(sellingPlan => sellingPlan.id));
+    }
+    return allIds;
+  }, []);
+
+  return sellingPlanAllocations.filter(sellingPlanAllocation =>
+    nonPrepaidSellingPlansIds.includes(sellingPlanAllocation.selling_plan_id)
+  );
+};
+
 export const autoshipEligible = (state = {}, action) => {
   if (constants.RECEIVE_PRODUCT_PLANS === action.type) {
     return Object.entries(action.payload).reduce(productTrue, state);
@@ -157,13 +179,17 @@ export const autoshipEligible = (state = {}, action) => {
     const {
       payload: { product }
     } = action;
-    return [product, ...(product?.variants || [])]?.reduce(
-      (acc, cur) => ({
-        ...overrideLineKey(acc, cur.id, cur.selling_plan_allocations?.length > 0),
-        [cur.id]: cur.selling_plan_allocations?.length > 0
-      }),
-      state
-    );
+    return [product, ...(product?.variants || [])]?.reduce((acc, cur) => {
+      const selling_plans_without_prepaid = filterNonPrepaidSellingPlans(
+        cur?.selling_plan_allocations,
+        product?.selling_plan_groups
+      );
+
+      return {
+        ...overrideLineKey(acc, cur.id, selling_plans_without_prepaid?.length > 0),
+        [cur.id]: selling_plans_without_prepaid?.length > 0
+      };
+    }, state);
   }
   return state;
 };