@ordergroove/offers 2.27.23 → 2.28.1

package/karma-shopify.conf.js

@@ -0,0 +1,79 @@
+// Karma configuration
+// Generated on Mon Apr 01 2019 14:32:09 GMT-0400 (EDT)
+
+module.exports = function(config) {
+  config.set({
+    // frameworks to use
+    // available frameworks: https://npmjs.org/browse/keyword/karma-adapter
+    frameworks: ['jasmine'],
+
+    // list of files / patterns to load in the browser
+    files: [
+      {
+        pattern: 'src/init-shopify-tests.js',
+        type: 'js',
+        included: true,
+        served: true
+      },
+      {
+        pattern: 'src/shopify/**/*.spec.js',
+        type: 'js',
+        included: true,
+        served: true
+      }
+    ],
+
+    // list of files / patterns to exclude
+    exclude: [],
+
+    // preprocess matching files before serving them to the browser
+    // available preprocessors: https://npmjs.org/browse/keyword/karma-preprocessor
+    preprocessors: {
+      '**/*.js': ['esbuild']
+    },
+
+    esbuild: {
+      // Replace some global variables
+      define: {
+        // COVERAGE: coverage,
+        'process.env.NODE_ENV': JSON.stringify(process.env.NODE_ENV || ''),
+        ENABLE_PERFORMANCE: true
+      },
+      // plugins: [createEsbuildPlugin()],
+
+      // Karma-esbuild specific options
+      singleBundle: false // Merge all test files into one bundle(default: true)
+      // singleBundle: true // Merge all test files into one bundle(default: true)
+    },
+
+    // test results reporter to use
+    // possible values: 'dots', 'progress'
+    // available reporters: https://npmjs.org/browse/keyword/karma-reporter
+    reporters: ['spec'],
+
+    // web server port
+    port: 9876,
+
+    // enable / disable colors in the output (reporters and logs)
+    colors: true,
+
+    // level of logging
+    // possible values: config.LOG_DISABLE || config.LOG_ERROR || config.LOG_WARN || config.LOG_INFO || config.LOG_DEBUG
+    logLevel: config.LOG_DEBUG,
+
+    // enable / disable watching file and executing tests whenever any file changes
+    autoWatch: true,
+
+    // start these browsers
+    // available browser launchers: https://npmjs.org/browse/keyword/karma-launcher
+    browsers: ['ChromeHeadless'],
+
+    // Continuous Integration mode
+    // if true, Karma captures browsers, runs the tests and exits
+    singleRun: false,
+
+    // Concurrency level
+    // how many browser should be started simultaneous
+    concurrency: Infinity
+  });
+};

package/karma.conf.js

@@ -17,7 +17,7 @@ module.exports = function(config) {
         served: true
       },
       {
-        pattern: 'src/**/*.spec.js',
+        pattern: 'src/!(shopify)/**/*.spec.js',
         type: 'js',
         included: true,
         served: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ordergroove/offers",
-  "version": "2.27.23",
+  "version": "2.28.1",
   "description": "offer state component",
   "author": "Eugenio Lattanzio <eugenio63@gmail.com>",
   "homepage": "https://github.com/ordergroove/plush-toys#readme",
@@ -17,7 +17,9 @@
     "bundlesize": "../../node_modules/.bin/bundlesize",
     "lint": "../../node_modules/.bin/eslint --ignore-path ../../.gitignore ./src",
     "prepublishOnly": "npm run -s build:prod && npm run -s bundlesize",
-    "test": "../../node_modules/.bin/karma start --single-run --log-level error --reporters progress && npm run build && ../../node_modules/.bin/karma start --single-run --log-level error --reporters progress karma-functional.conf.js",
+    "test": "../../node_modules/.bin/karma start --single-run --log-level error --reporters progress && npm run test:shopify && npm run build && ../../node_modules/.bin/karma start --single-run --log-level error --reporters progress karma-functional.conf.js",
+    "test:shopify": "../../node_modules/.bin/karma start karma-shopify.conf.js --single-run --log-level error --reporters progress",
+    "test:watch:shopify": "../../node_modules/.bin/karma start karma-shopify.conf.js",
     "test:watch": "../../node_modules/.bin/karma start",
     "test:watch:functional": "npm run build && ../../node_modules/.bin/karma start karma-functional.conf.js",
     "test:functional": "npm run test:watch:functional -- --single-run --log-level error --reporters progress",
@@ -34,7 +36,7 @@
   ],
   "dependencies": {
     "@ordergroove/auth": "^2.3.0",
-    "@ordergroove/offers-live-editor": "^0.6.0",
+    "@ordergroove/offers-live-editor": "^0.6.1",
     "lit-element": "^2.1.0",
     "lodash.memoize": "^4.1.2",
     "logical-expression-parser": "1.0.0",
@@ -45,5 +47,5 @@
   "devDependencies": {
     "@ordergroove/offers-templates": "^0.4.16"
   },
-  "gitHead": "474581ad550212f9ee3f15ab60c7aff06bb4e3b6"
+  "gitHead": "30db419a37eeddd12f09976a4eab2b5bb40cfbf8"
 }

package/src/components/Offer.js

@@ -312,6 +312,7 @@ export class Offer extends TemplateElement {
 
   get defaultFrequency() {
     const storeFrequency = this.productFrequency || this.productDefaultFrequency;
+
     if (storeFrequency) {
       return storeFrequency;
     }

package/src/components/OptinButton.js

@@ -4,6 +4,8 @@ import { OptinStatus, mapStateToProps } from './OptinStatus';
 import { connect } from '../core/connect';
 import { defaultFrequency } from '../core/props';
 import { resolveProduct } from '../core/resolveProperties';
+import { frequencyToSellingPlan } from '../core/utils';
+import platform from '../platform';
 
 export class OptinButton extends OptinStatus {
   static get properties() {
@@ -15,12 +17,30 @@ export class OptinButton extends OptinStatus {
     };
   }
 
+  updated(changed) {
+    if (changed.has('subscribed')) {
+      this.frequencyMatch = this.frequency === this.optinFrequency;
+    }
+  }
+
+  get optinFrequency() {
+    let freq;
+
+    // use the attribute since this.defaultFrequency comes from mapStateToProps and contains more logic
+    if (this.hasAttribute('default-frequency')) {
+      freq = this.getAttribute('default-frequency');
+    } else {
+      freq = this.offer ? this.offer.defaultFrequency : this.defaultFrequency;
+    }
+    if (platform.shopify_selling_plans && this.store) {
+      freq = frequencyToSellingPlan(freq, this.store.getState().config);
+    }
+
+    return freq;
+  }
+
   handleClick(ev) {
-    this.optinProduct(
-      resolveProduct(this),
-      this.offer ? this.offer.defaultFrequency : this.defaultFrequency,
-      this.offer
-    );
+    this.optinProduct(resolveProduct(this), this.optinFrequency, this.offer);
     ev.preventDefault();
   }
 

package/src/components/OptinSelect.js

@@ -35,10 +35,8 @@ export class OptinSelect extends withChildOptions(OptinStatus) {
     if (!this.subscribed) {
       return 'optedOut';
     }
-    if (this.frequency) {
-      return this.frequency;
-    }
-    return this.defaultFrequency;
+
+    return this.frequency || this.productDefaultFrequency || this.defaultFrequency;
   }
 
   onOptinChange(value) {

package/src/components/OptinStatus.js

@@ -1,6 +1,7 @@
 import { html, css } from 'lit-element';
 import {
   makeOptedinSelector,
+  makeProductDefaultFrequencySelector,
   makeProductFrequencySelector,
   configSelector,
   templatesSelector
@@ -14,7 +15,9 @@ export class OptinStatus extends withProduct(TemplateElement) {
   static get properties() {
     return {
       subscribed,
-      frequencyMatch: { type: Boolean, reflect: true, attribute: 'frequency-match' }
+      frequencyMatch: { type: Boolean, reflect: true, attribute: 'frequency-match' },
+      productDefaultFrequency: { type: String },
+      defaultFrequency: { type: String }
     };
   }
 
@@ -121,6 +124,7 @@ export class OptinStatus extends withProduct(TemplateElement) {
 export const mapStateToProps = (state, ownProps = {}) => ({
   subscribed: makeOptedinSelector(ownProps.product)(state),
   frequency: makeProductFrequencySelector(ownProps.product)(state),
+  productDefaultFrequency: makeProductDefaultFrequencySelector((ownProps.product || {}).id)(state),
   ...configSelector(state, ownProps, 'defaultFrequency'),
   ...templatesSelector(state, ownProps)
 });

package/src/components/OptinToggle.js

@@ -49,8 +49,15 @@ export class OptinToggle extends OptinStatus {
   }
 
   handleClick(ev) {
-    if (this.subscribed) this.optoutProduct(this.product, this.offer);
-    else this.optinProduct(this.product, this.frequency || this.defaultFrequency, this.offer);
+    if (this.subscribed) {
+      this.optoutProduct(this.product, this.offer);
+    } else {
+      this.optinProduct(
+        this.product,
+        this.frequency || this.productDefaultFrequency || this.defaultFrequency,
+        this.offer
+      );
+    }
     ev.preventDefault();
   }
 

package/src/components/__tests__/OG.fspec.js

@@ -19,7 +19,7 @@ const waitUpdate = async offer => {
   await offer.updateComplete;
   await new Promise(r => setTimeout(r, 10));
 };
-const mockOfferResponse = (productId, inStock = true, autoship = true) => {
+const mockOfferResponse = (productId, inStock = true, autoship = true, defaultFrequency) => {
   return Promise.resolve({
     json() {
       return Promise.resolve({
@@ -33,7 +33,12 @@ const mockOfferResponse = (productId, inStock = true, autoship = true) => {
         incentives_display: {},
         incentives: {
           [productId]: { initial: [], ongoing: [] }
-        }
+        },
+        ...(defaultFrequency && {
+          default_frequencies: {
+            [productId]: defaultFrequency
+          }
+        })
       });
     }
   });
@@ -210,4 +215,81 @@ describe('Offer', function() {
       expect(htmlSelectElement.innerText).toEqual('Buy one time\n2 weeks (recomended)\n1 month');
     });
   });
+
+  describe('optin default frequency tests', function() {
+    let element;
+    beforeEach(async () => {
+      og.offers.clear();
+    });
+
+    it('it should opt in with default frequency', async () => {
+      fetch.and.returnValue(mockOfferResponse(productIdInStock));
+      document.body.innerHTML = `
+    <og-offer product="${productIdInStock}">
+      <og-optout-button></og-optout-button>
+      <og-optin-button></og-optin-button>
+      <og-select-frequency default-text=" (recomended)">
+        <option value="optedOut">Buy one time</option>
+        <option value="2_2" selected="selected">2 weeks</option>
+        <option value="1_3">1 month </option>
+      </og-select-frequency>
+    </og-offer>
+    `;
+      element = document.querySelector('og-offer');
+      await new Promise(r => setTimeout(r, 10));
+
+      expect(fetch).toHaveBeenCalledTimes(1);
+
+      expect(og.offers.store.getState().optedin).toEqual([]);
+
+      document.querySelector('og-optin-button').click();
+      await element.updateComplete;
+      expect(og.offers.store.getState().optedin).toEqual([{ id: productIdInStock, frequency: '2_2' }]);
+    });
+
+    it('it should opt in with PSDF', async () => {
+      fetch.and.returnValue(mockOfferResponse(productIdInStock, true, true, { every: '5', period: '1' }));
+
+      document.body.innerHTML = `
+    <og-offer product="${productIdInStock}">
+      <og-optout-button></og-optout-button>
+      <og-optin-button></og-optin-button>
+      <og-select-frequency default-text=" (recomended)">
+        <option value="optedOut">Buy one time</option>
+        <option value="2_2" selected="selected">2 weeks</option>
+        <option value="1_3">1 month </option>
+        <option value="5_1">5 days </option>
+      </og-select-frequency>
+    </og-offer>
+    `;
+      element = document.querySelector('og-offer');
+      await new Promise(r => setTimeout(r, 10));
+
+      expect(fetch).toHaveBeenCalledTimes(1);
+
+      expect(og.offers.store.getState().optedin).toEqual([]);
+
+      document.querySelector('og-optin-button').click();
+      await element.updateComplete;
+      expect(og.offers.store.getState().optedin).toEqual([{ id: productIdInStock, frequency: '5_1' }]);
+    });
+
+    it('buttons only template should use attr frequency as first option', async () => {
+      fetch.and.returnValue(mockOfferResponse(productIdInStock, true, true, { every: '5', period: '1' }));
+      document.body.innerHTML = `
+    <og-offer product="${productIdInStock}" default-frequency="6_1">
+      <og-optin-button default-frequency="6_1">Six days</og-optin-button>
+      <og-optin-button default-frequency="13_1">thirteen days</og-optin-button>
+      <og-optin-button default-frequency="3_2">Three weeks</og-optin-button>
+    </og-offer>
+    `;
+      element = document.querySelector('og-offer');
+      await new Promise(r => setTimeout(r, 10));
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(og.offers.store.getState().optedin).toEqual([]);
+      document.querySelector('[default-frequency="13_1"]').click();
+      await element.updateComplete;
+      expect(og.offers.store.getState().optedin).toEqual([{ id: productIdInStock, frequency: '13_1' }]);
+    });
+  });
 });

package/src/core/__tests__/utils.spec.js

@@ -0,0 +1,26 @@
+import { frequencyToSellingPlan } from '../utils';
+
+describe('frequencyToSellingPlan', () => {
+  it('should return a selling plan from config', () => {
+    expect(
+      frequencyToSellingPlan('1_2', {
+        frequenciesEveryPeriod: ['1_1', '1_2', '1_3'],
+        frequencies: [123, 456, 789]
+      })
+    ).toEqual(456);
+  });
+
+  it('should return same input if it does not looks like a frequency ', () => {
+    expect(frequencyToSellingPlan(123, {})).toEqual(123);
+    expect(frequencyToSellingPlan('345', {})).toEqual('345');
+  });
+
+  it('should return original frequency if no frequency match', () => {
+    expect(
+      frequencyToSellingPlan('1_2', {
+        frequenciesEveryPeriod: ['1_1', '1_3'],
+        frequencies: [123, 789]
+      })
+    ).toEqual('1_2');
+  });
+});

package/src/core/selectors.js

@@ -1,6 +1,8 @@
 import { createSelector } from 'reselect';
 import memoize from 'lodash.memoize';
 import { stringifyFrequency } from './api';
+import platform from '../platform';
+import { mapFrequencyToSellingPlan, safeProductId } from '../core/utils';
 
 memoize.Cache = Map;
 
@@ -21,6 +23,12 @@ function arraysEqual(a, b) {
   return true;
 }
 
+function resolveFrequency(sellingPlans, frequenciesEveryPeriod, frequency) {
+  const ogFrequency = stringifyFrequency(frequency);
+  if (!platform.shopify_selling_plans) return ogFrequency;
+  return mapFrequencyToSellingPlan(sellingPlans, frequenciesEveryPeriod, ogFrequency);
+}
+
 export const isSameProduct = (a, b) => {
   if (a === b) return true;
   if (typeof a === 'object' && typeof b === 'object' && a && b) {
@@ -48,6 +56,10 @@ export const autoshipSelector = state => state.autoshipByDefault || {};
 
 export const defaultFrequenciesSelector = state => state.defaultFrequencies || {};
 
+export const sellingPlansSelector = state => state?.config?.frequencies || [];
+
+export const frequenciesEveryPeriodSelector = state => state?.config?.frequenciesEveryPeriod || [];
+
 /**
  * Creates a function with state arguments that return the true when
  * productId is in the optedin array or not in optedout or autoship by default
@@ -110,7 +122,12 @@ export const makeProductFrequencySelector = memoize(productId =>
 export const makeProductDefaultFrequencySelector = memoize(productId =>
   createSelector(
     defaultFrequenciesSelector,
-    defaultFrequencies => (defaultFrequencies[productId] && stringifyFrequency(defaultFrequencies[productId])) || null
+    sellingPlansSelector,
+    frequenciesEveryPeriodSelector,
+    (defaultFrequencies, sellingPlans, frequenciesEveryPeriod) =>
+      (defaultFrequencies[safeProductId(productId)] &&
+        resolveFrequency(sellingPlans, frequenciesEveryPeriod, defaultFrequencies[safeProductId(productId)])) ||
+      null
   )
 );
 

package/src/core/store.js

@@ -3,6 +3,7 @@ import thunk from 'redux-thunk';
 
 import { loadState } from './localStorage';
 import { dispatchMiddleware, localStorageMiddleware, offerEvents } from './middleware';
+import { waitUntilOffersReady } from './waitUntilOffersReady';
 
 export function makeStore(reducer, ...extraMiddlewares) {
   if (window.og && window.og.store) return window.og.store;
@@ -14,11 +15,11 @@ export function makeStore(reducer, ...extraMiddlewares) {
     typeof window === 'object' && window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__
       ? // eslint-disable-next-line no-underscore-dangle
         window.__REDUX_DEVTOOLS_EXTENSION_COMPOSE__({
-          // Specify extension’s options like name, actionsBlacklist, actionsCreators, serialize...
+          name: 'Ordergroove Offers'
         })
       : compose;
 
-  const middlewares = [thunk, dispatchMiddleware, offerEvents];
+  const middlewares = [waitUntilOffersReady, thunk, dispatchMiddleware, offerEvents];
 
   let initial = {};
 

package/src/core/utils.ts

@@ -36,7 +36,7 @@ export function resolveEnvAndMerchant() {
 }
 
 export const safeProductId = product => {
-  if (!product ) return '';
+  if (!product) return '';
   let productId = `${product.id || product}`;
   if (platform?.shopify_selling_plans) {
     // we can't avoid make offer request since we need to know the upsell group and autoship by default
@@ -49,20 +49,29 @@ export const safeProductId = product => {
 /**
  * Returns the OG frequency if platform is running on selling plans
  * @param initialFrequency
- * @param config 
+ * @param config
  */
- export const safeOgFrequency = (initialFrequency, config) => {
+export const safeOgFrequency = (initialFrequency, config) => {
   if (platform.shopify_selling_plans) {
     const ix = config.frequencies?.indexOf(initialFrequency);
     if (ix >= 0 && config.frequenciesEveryPeriod[ix]) {
       return config.frequenciesEveryPeriod[ix];
-    } else {
-      throw `OG Can't convert selling_plan_id ${initialFrequency} to OG frequency every period`;
     }
   }
   return initialFrequency;
 };
 
+export const frequencyToSellingPlan = (ogFrequency, config) => {
+  // og frequency contains underscore
+  if (!`${ogFrequency}`.includes('_')) return ogFrequency;
+  const ix = config.frequenciesEveryPeriod?.indexOf(ogFrequency);
+  if (ix >= 0 && config.frequenciesEveryPeriod[ix]) {
+    return config.frequencies[ix];
+  }
+
+  return ogFrequency;
+};
+
 /**
  * Attempts to auto initialize the offer library reading the merchantId and env from
  * integration script i.e. <script src="http://static.ordergroove...."/>.
@@ -70,9 +79,19 @@ export const safeProductId = product => {
  */
 export function autoInitializeOffers(offers) {
   if (offers.isReady()) return;
+
+  console.info('OG offers are auto initializing');
+
   const [merchantId, env] = resolveEnvAndMerchant();
   if (!env && !merchantId) return;
-  offers.initialize(merchantId, env);
+  const script = document.createElement('script');
+  script.onload = () => console.info('OG pull initialization chunk for merchant', merchantId, env);
+  script.onerror = () => offers.initialize(merchantId, env);
+  script.src = `${window.location.protocol}//${
+    env === ENV_PROD ? STATIC_HOST : STAGING_STATIC_HOST
+  }/${merchantId}/main.js?initOnly=true`;
+
+  document.head.appendChild(script);
 }
 
 export const clearCookie = cookieId => {
@@ -84,3 +103,23 @@ export function getCookieValue(cookieId) {
   const cookie = document.cookie.match(`(^|;) ?${cookieId}=([^;]*)(;|$)`);
   return cookie ? cookie[2] : null;
 }
+export const isOgFrequency = frequency => !!(frequency && frequency?.includes('_'));
+
+export const getFirstSellingPlan = (frequencies = []) => frequencies?.[0] || null;
+
+export const hasShopifySellingPlans = (sellingPlans = [], frequenciesEveryPeriod = []) =>
+  !!(platform?.shopify_selling_plans && sellingPlans.length && frequenciesEveryPeriod.length);
+
+export const mapFrequencyToSellingPlan = (sellingPlans, frequenciesEveryPeriod, frequency) => {
+  if (sellingPlans.length !== frequenciesEveryPeriod.length) {
+    return null;
+  }
+
+  const index = frequenciesEveryPeriod.findIndex(it => it === frequency);
+
+  if (index >= 0) {
+    return sellingPlans[index];
+  }
+
+  return null;
+};

package/src/core/waitUntilOffersReady.js

@@ -0,0 +1,66 @@
+import { createSessionId, fetchAuth } from './actions';
+import {
+  CREATED_SESSION_ID,
+  SET_ENVIRONMENT_DEV,
+  SET_ENVIRONMENT_PROD,
+  SET_ENVIRONMENT_STAGING,
+  SET_MERCHANT_ID
+} from './constants';
+import { listenLocalStorageChanges } from './localStorage';
+
+const waitFor = () => {
+  let resolve, reject;
+  return [
+    new Promise((yes, no) => {
+      resolve = yes;
+      reject = no;
+    }),
+    resolve,
+    reject
+  ];
+};
+/**
+ * Middleware that awaits offers being initialized and resumes the regular actions after.
+ * @param {*} store
+ * @returns
+ */
+export function waitUntilOffersReady(store) {
+  const [waitForSetEnv, resolveEnv] = waitFor();
+  const [waitForMerchantId, resolveMerchantId] = waitFor();
+  const [waitForSessionId, resolveSessionId] = waitFor();
+
+  waitForMerchantId.then(merchantId => {
+    const { sessionId } = store.getState();
+    if (!sessionId || (merchantId && !sessionId.startsWith(merchantId))) {
+      store.dispatch(createSessionId(merchantId));
+    } else {
+      resolveSessionId(sessionId);
+    }
+  });
+
+  const waitForReady = Promise.all([waitForMerchantId, waitForSetEnv, waitForSessionId]);
+
+  waitForReady.then(() => {
+    window.addEventListener('storage', listenLocalStorageChanges(store));
+    if (!store.getState().auth?.ts) {
+      store.dispatch(fetchAuth());
+    }
+  });
+
+  return next => async action => {
+    if (
+      SET_ENVIRONMENT_DEV === action.type ||
+      SET_ENVIRONMENT_STAGING === action.type ||
+      SET_ENVIRONMENT_PROD === action.type
+    ) {
+      resolveEnv(action.payload);
+    } else if (SET_MERCHANT_ID === action.type) {
+      resolveMerchantId(action.payload);
+    } else if (CREATED_SESSION_ID === action.type) {
+      resolveSessionId(action.payload);
+    } else {
+      await waitForReady;
+    }
+    next(action);
+  };
+}

package/src/index.js

@@ -34,15 +34,19 @@ export const setTemplates = offers.setTemplates;
 export const setupCart = offers.setupCart;
 export const setupProduct = offers.setupProduct;
 export const setupProducts = offers.setupProducts;
+export const autoInit = () => autoInitializeOffers(offers);
+
 export { platform };
 export default offers.initialize;
-
 /*
  * Attempts to auto initialize the offer library reading the merchantId and env from
  * integration script i.e. <script src="http://static.ordergroove...."/>.
  * Useful when local develop using http redirects
  */
-onReady(() => autoInitializeOffers(offers));
+if (process.env.NODE_ENV === 'development') {
+  console.info('%c Ordergroove Offers DEV MODE ', 'background: #222; color: #bada55');
+  onReady(autoInit);
+}
 
 if (platform?.shopify_selling_plans) {
   onReady(() => authorizeShopifyCustomer(offers));

package/src/init-shopify-tests.js

@@ -0,0 +1,7 @@
+import { STATIC_HOST } from './core/constants';
+
+const mainJs = document.createElement('script');
+mainJs.setAttribute('id', `mock-main-js`);
+mainJs.setAttribute('src', `http://${STATIC_HOST}`);
+mainJs.dataset.shopifySellingPlans = true;
+document.head.appendChild(mainJs);

package/src/make-api.js

@@ -156,7 +156,11 @@ export default function makeApi(store) {
      */
     initialize(merchantId, env, authUrl) {
       // settings resolves once, before anything.
-      if (!isReady) offers.resolveSettings(merchantId, env, window.og_settings, store);
+      if (isReady) {
+        console.warn('og.offers has been initialized already. Skipping.');
+      } else {
+        offers.resolveSettings(merchantId, env, window.og_settings, store);
+      }
 
       const state = store.getState();
       // dont re-trigger actions if value is the same. allowing set new authurl only
@@ -165,20 +169,6 @@ export default function makeApi(store) {
       // allow set new authUrl
       if (authUrl) offers.setAuthUrl(authUrl);
 
-      if (isReady) {
-        console.warn('og.offers has been initialized already. Skipping.');
-      } else {
-        window.addEventListener('storage', listenLocalStorageChanges(store));
-        store.dispatch(actions.requestSessionId());
-      }
-
-      if (arguments.length === 3) {
-        // fetch auth is not there already
-        if (!store.getState().auth?.ts) {
-          store.dispatch(actions.fetchAuth());
-        }
-      }
-
       isReady = true;
 
       return this;