@mframework/layer-commerce 0.0.3

package/app/utils/Polyfill/index.ts

@@ -0,0 +1,336 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+/* eslint-disable */
+
+//smoothscroll.js file
+
+/*
+ * smoothscroll polyfill - v0.3.5
+ * https://iamdustan.github.io/smoothscroll
+ * 2016 (c) Dustan Kasten, Jeremias Menichelli - MIT License
+ */
+
+(function(w, d, undefined) {
+  'use strict';
+
+  /*
+   * aliases
+   * w: window global object
+   * d: document
+   * undefined: undefined
+   */
+
+  // polyfill
+  function polyfill() {
+    // return when scrollBehavior interface is supported
+    if ('scrollBehavior' in d.documentElement.style) {
+      return;
+    }
+
+    /*
+     * globals
+     */
+    var Element = w.HTMLElement || w.Element;
+    var SCROLL_TIME = 468;
+
+    /*
+     * object gathering original scroll methods
+     */
+    var original = {
+      scroll: w.scroll || w.scrollTo,
+      scrollBy: w.scrollBy,
+      elScroll: Element.prototype.scroll || scrollElement,
+      scrollIntoView: Element.prototype.scrollIntoView
+    };
+
+    /*
+     * define timing method
+     */
+    var now = w.performance && w.performance.now
+      ? w.performance.now.bind(w.performance) : Date.now;
+
+    /**
+     * changes scroll position inside an element
+     * @method scrollElement
+     * @param {Number} x
+     * @param {Number} y
+     */
+    function scrollElement(x, y) {
+      this.scrollLeft = x;
+      this.scrollTop = y;
+    }
+
+    /**
+     * returns result of applying ease math function to a number
+     * @method ease
+     * @param {Number} k
+     * @returns {Number}
+     */
+    function ease(k) {
+      return 0.5 * (1 - Math.cos(Math.PI * k));
+    }
+
+    /**
+     * indicates if a smooth behavior should be applied
+     * @method shouldBailOut
+     * @param {Number|Object} x
+     * @returns {Boolean}
+     */
+    function shouldBailOut(x) {
+      if (typeof x !== 'object'
+            || x === null
+            || x.behavior === undefined
+            || x.behavior === 'auto'
+            || x.behavior === 'instant') {
+        // first arg not an object/null
+        // or behavior is auto, instant or undefined
+        return true;
+      }
+
+      if (typeof x === 'object'
+            && x.behavior === 'smooth') {
+        // first argument is an object and behavior is smooth
+        return false;
+      }
+
+      // throw error when behavior is not supported
+      throw new TypeError('behavior not valid');
+    }
+
+    /**
+     * finds scrollable parent of an element
+     * @method findScrollableParent
+     * @param {Node} el
+     * @returns {Node} el
+     */
+    function findScrollableParent(el) {
+      var isBody;
+      var hasScrollableSpace;
+      var hasVisibleOverflow;
+
+      do {
+        el = el.parentNode;
+
+        // set condition variables
+        isBody = el === d.body;
+        hasScrollableSpace =
+          el.clientHeight < el.scrollHeight ||
+          el.clientWidth < el.scrollWidth;
+        hasVisibleOverflow =
+          w.getComputedStyle(el, null).overflow === 'visible';
+      } while (!isBody && !(hasScrollableSpace && !hasVisibleOverflow));
+
+      isBody = hasScrollableSpace = hasVisibleOverflow = null;
+
+      return el;
+    }
+
+    /**
+     * self invoked function that, given a context, steps through scrolling
+     * @method step
+     * @param {Object} context
+     */
+    function step(context) {
+      var time = now();
+      var value;
+      var currentX;
+      var currentY;
+      var elapsed = (time - context.startTime) / SCROLL_TIME;
+
+      // avoid elapsed times higher than one
+      elapsed = elapsed > 1 ? 1 : elapsed;
+
+      // apply easing to elapsed time
+      value = ease(elapsed);
+
+      currentX = context.startX + (context.x - context.startX) * value;
+      currentY = context.startY + (context.y - context.startY) * value;
+
+      context.method.call(context.scrollable, currentX, currentY);
+
+      // scroll more if we have not reached our destination
+      if (currentX !== context.x || currentY !== context.y) {
+        w.requestAnimationFrame(step.bind(w, context));
+      }
+    }
+
+    /**
+     * scrolls window with a smooth behavior
+     * @method smoothScroll
+     * @param {Object|Node} el
+     * @param {Number} x
+     * @param {Number} y
+     */
+    function smoothScroll(el, x, y) {
+      var scrollable;
+      var startX;
+      var startY;
+      var method;
+      var startTime = now();
+
+      // define scroll context
+      if (el === d.body) {
+        scrollable = w;
+        startX = w.scrollX || w.pageXOffset;
+        startY = w.scrollY || w.pageYOffset;
+        method = original.scroll;
+      } else {
+        scrollable = el;
+        startX = el.scrollLeft;
+        startY = el.scrollTop;
+        method = scrollElement;
+      }
+
+      // scroll looping over a frame
+      step({
+        scrollable: scrollable,
+        method: method,
+        startTime: startTime,
+        startX: startX,
+        startY: startY,
+        x: x,
+        y: y
+      });
+    }
+
+    /*
+     * ORIGINAL METHODS OVERRIDES
+     */
+
+    // w.scroll and w.scrollTo
+    w.scroll = w.scrollTo = function() {
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0])) {
+        original.scroll.call(
+          w,
+          arguments[0].left || arguments[0],
+          arguments[0].top || arguments[1]
+        );
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      smoothScroll.call(
+        w,
+        d.body,
+        ~~arguments[0].left,
+        ~~arguments[0].top
+      );
+    };
+
+    // w.scrollBy
+    w.scrollBy = function() {
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0])) {
+        original.scrollBy.call(
+          w,
+          arguments[0].left || arguments[0],
+          arguments[0].top || arguments[1]
+        );
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      smoothScroll.call(
+        w,
+        d.body,
+        ~~arguments[0].left + (w.scrollX || w.pageXOffset),
+        ~~arguments[0].top + (w.scrollY || w.pageYOffset)
+      );
+    };
+
+    // Element.prototype.scroll and Element.prototype.scrollTo
+    Element.prototype.scroll = Element.prototype.scrollTo = function() {
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0])) {
+        original.elScroll.call(
+            this,
+            arguments[0].left || arguments[0],
+            arguments[0].top || arguments[1]
+        );
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      smoothScroll.call(
+          this,
+          this,
+          arguments[0].left,
+          arguments[0].top
+      );
+    };
+
+    // Element.prototype.scrollBy
+    Element.prototype.scrollBy = function() {
+      var arg0 = arguments[0];
+
+      if (typeof arg0 === 'object') {
+        this.scroll({
+          left: arg0.left + this.scrollLeft,
+          top: arg0.top + this.scrollTop,
+          behavior: arg0.behavior
+        });
+      } else {
+        this.scroll(
+          this.scrollLeft + arg0,
+          this.scrollTop + arguments[1]
+        );
+      }
+    };
+
+    // Element.prototype.scrollIntoView
+    Element.prototype.scrollIntoView = function() {
+      // avoid smooth behavior if not required
+      if (shouldBailOut(arguments[0])) {
+        original.scrollIntoView.call(this, arguments[0] || true);
+
+        return;
+      }
+
+      // LET THE SMOOTHNESS BEGIN!
+      var scrollableParent = findScrollableParent(this);
+      var parentRects = scrollableParent.getBoundingClientRect();
+      var clientRects = this.getBoundingClientRect();
+
+      if (scrollableParent !== d.body) {
+        // reveal element inside parent
+        smoothScroll.call(
+          this,
+          scrollableParent,
+          scrollableParent.scrollLeft + clientRects.left - parentRects.left,
+          scrollableParent.scrollTop + clientRects.top - parentRects.top
+        );
+        // reveal parent in viewport
+        w.scrollBy({
+          left: parentRects.left,
+          top: parentRects.top,
+          behavior: 'smooth'
+        });
+      } else {
+        const top = arguments[0].block === 'center'
+            ? clientRects.top - clientRects.height
+            : clientRects.top;
+
+        // reveal element in viewport
+        w.scrollBy({
+          left: clientRects.left,
+          top: top,
+          behavior: 'smooth'
+        });
+      }
+    };
+  }
+
+  if (typeof exports === 'object') {
+    // commonjs
+    module.exports = { polyfill: polyfill };
+  } else {
+    // global
+    polyfill();
+  }
+})(window, document);
+
+export default {};

package/app/utils/Preload/CategoryPreload.ts

@@ -0,0 +1,74 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework
+ * @link https://github.com/meeovi/mframework
+ */
+
+import { ProductListOptions } from '../../normalizers/ProductList.type';
+import { SortDirections } from '../../routes/CategoryPage/CategoryPage.config';
+import ProductListDispatcher from '../../stores/ProductList/ProductList.dispatcher';
+import history from '../../utils/History';
+import getStore from '../../utils/Store';
+import { getQueryParam } from '../../utils/Url';
+
+/** @namespace ../../utils/Preload/CategoryPreload */
+export class CategoryPreload {
+    productListOptions = (): Partial<ProductListOptions> => ({
+        isNext: false,
+        isPlp: true,
+        noAttributes: false,
+        noVariants: false,
+            args: {
+            sort: getQueryParam('sortKey', history.location) || 'position',
+            filter: {
+                priceRange: this.getSelectedPriceRangeFromUrl(),
+                customFilters: this.getSelectedFiltersFromUrl(),
+                categoryIds: window.actionName?.id,
+            },
+            search: '',
+            pageSize: 24,
+            currentPage: this.getPageFromUrl(),
+        },
+    });
+
+    getPageFromUrl() {
+        const { location } = history;
+
+        return +(getQueryParam('page', location) || 1);
+    }
+
+    getSelectedFiltersFromUrl() {
+        const { location } = history;
+        const selectedFiltersString = (getQueryParam('customFilters', location, false) || '').split(';');
+
+        return selectedFiltersString.reduce((acc, filter) => {
+            if (!filter) {
+                return acc;
+            }
+            const [key, value] = filter.split(':');
+
+            return { ...acc, [key]: value.split(',') };
+        }, {});
+    }
+
+    getSelectedPriceRangeFromUrl() {
+        const { location } = history;
+        const min = +getQueryParam('priceMin', location);
+        const max = +getQueryParam('priceMax', location);
+
+        return { min, max };
+    }
+
+    dispatch = getStore().dispatch;
+
+    preloadProducts() {
+        ProductListDispatcher.handleData(this.dispatch, this.productListOptions());
+    }
+}
+
+export default new CategoryPreload();

package/app/utils/Preload/ProductPreload.ts

@@ -0,0 +1,28 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework
+ * @link https://github.com/meeovi/mframework
+ */
+
+import { ProductListOptions } from '../../normalizers/ProductList.type';
+import ProductDispatcher from '../../stores/Product/Product.dispatcher';
+import getStore from '../../utils/Store';
+
+/** @namespace ../../utils/Preload/ProductPreload */
+export class ProductPreload {
+    options: Partial<ProductListOptions> = {
+        isSingleProduct: true,
+        args: { filter: { productID: window.actionName?.id } },
+    };
+
+    preloadProduct() {
+        ProductDispatcher.handleData(getStore().dispatch, this.options);
+    }
+}
+
+export default new ProductPreload();

package/app/utils/Preload/index.ts

@@ -0,0 +1,75 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework
+ * @link https://github.com/meeovi/mframework
+ */
+
+import { UrlRewritePageType } from '../../routes/UrlRewrites/UrlRewrites.config';
+import ProductReducer from '../../stores/Product/Product.reducer';
+import ProductListReducer from '../../stores/ProductList/ProductList.reducer';
+import BrowserDatabase from '../../utils/BrowserDatabase';
+import { isMobile } from '../../utils/Mobile';
+import getStore, { injectReducers } from '../../utils/Store';
+
+import CategoryPreload from './CategoryPreload';
+import ProductPreload from './ProductPreload';
+
+injectReducers(getStore(), {
+    ProductReducer,
+    ProductListReducer,
+});
+
+const { actionName: { type = '' } = {} } = window;
+
+export const criticalChunkLoad = {
+    CategoryChunk: {
+        test: type === UrlRewritePageType.CATEGORY,
+        importChunk: () => CategoryPreload.preloadProducts(),
+    },
+    CmsChunk: {
+        test: type === UrlRewritePageType.CMS_PAGE,
+        importChunk: () => {
+            const isAndroid = isMobile.android();
+            const isIos = isMobile.iOS() && isMobile.safari();
+
+            if ((isAndroid || isIos)
+                && !isMobile.standaloneMode()
+                && !BrowserDatabase.getItem('postpone_installation')
+                && !BrowserDatabase.getItem('app_installed')
+            ) {
+                window.isInstallPromptAvailable = true;
+            }
+
+            const {
+                actionName: {
+                    cmsPage: {
+                        content = '',
+                    } = {},
+                } = {},
+            } = window;
+
+            if (!content.trim().length) {
+                window.isPriorityLoaded = true;
+            }
+        },
+    },
+    ProductChunk: {
+        test: type === UrlRewritePageType.PRODUCT,
+        importChunk: () => ProductPreload.preloadProduct(),
+    },
+};
+
+export const importBooster = Object.values(criticalChunkLoad).find(({ test }) => test);
+
+if (!importBooster) {
+    window.isPriorityLoaded = true;
+} else {
+    window.isPriorityLoaded = false;
+    window.isPrefetchValueUsed = true;
+    importBooster.importChunk();
+}

package/app/utils/Price/Price.config.ts

@@ -0,0 +1,189 @@
+/**
+ * M Framework - Flexible backend agnostic framework.
+ *
+ * Copyright © Meeovi, LTD. All rights reserved.
+ * See LICENSE for license details.
+ *
+ * @license OSL-3.0 (Open Software License ("OSL") v. 3.0)
+ * @package mframework/mframework-theme
+ * @link https://github.com/meeovi/mframework-theme
+ */
+export const TIER_PRICES = 'TIER_PRICES';
+
+export const HUNDRED_PERCENT = 100;
+
+export enum CurrencyMap {
+    AED = 'د.إ',
+    AFN = '؋',
+    ALL = 'L',
+    AMD = '֏',
+    ANG = 'ƒ',
+    AOA = 'Kz',
+    ARS = '$',
+    AUD = '$',
+    AWG = 'ƒ',
+    AZN = '₼',
+    BAM = 'KM',
+    BBD = 'Bds$',
+    BDT = '৳',
+    BGN = 'лв',
+    BHD = '.د.ب',
+    BIF = 'FBu',
+    BMD = '$',
+    BND = 'B$',
+    BOB = '$b',
+    BRL = 'R$',
+    BSD = 'B$',
+    BTC = '฿',
+    BTN = 'Nu.',
+    BWP = 'P',
+    BYR = 'Br',
+    BYN = 'Br',
+    BZD = 'BZ$',
+    CAD = 'CA$',
+    CDF = 'FC',
+    CHF = 'CHF',
+    CLP = '$',
+    CNY = '¥',
+    COP = '$',
+    CRC = '₡',
+    CUC = 'CUC$',
+    CUP = '₱',
+    CVE = '$',
+    CZK = 'Kč',
+    DJF = 'Fdj',
+    DKK = 'kr',
+    DOP = 'RD$',
+    DZD = 'دج',
+    EEK = 'kr',
+    EGP = '£',
+    ERN = 'Nfk',
+    ETB = 'Br',
+    ETH = 'Ξ',
+    EUR = '€',
+    FJD = 'FJ$',
+    FKP = '£',
+    GBP = '£',
+    GEL = '₾',
+    GGP = '£',
+    GHC = '₵',
+    GHS = 'GH₵',
+    GIP = '£',
+    GMD = 'D',
+    GNF = 'FG',
+    GTQ = 'Q',
+    GYD = 'G$',
+    HKD = 'HK$',
+    HNL = 'L',
+    HRK = 'kn',
+    HTG = 'G',
+    HUF = 'Ft',
+    IDR = 'Rp',
+    ILS = '₪',
+    IMP = '£',
+    INR = '₹',
+    IQD = 'ع.د',
+    IRR = '﷼',
+    ISK = 'kr',
+    JEP = '£',
+    JMD = 'J$',
+    JOD = 'JD',
+    JPY = '¥',
+    KES = 'KSh',
+    KGS = 'лв',
+    KHR = '៛',
+    KMF = 'CF',
+    KPW = '₩',
+    KRW = '₩',
+    KWD = 'KD',
+    KYD = '$',
+    KZT = 'лв',
+    LAK = '₭',
+    LBP = '£',
+    LKR = '₨',
+    LRD = 'L$',
+    LSL = 'M',
+    LTC = 'Ł',
+    LTL = 'Lt',
+    LVL = 'Ls',
+    LYD = 'LD',
+    MAD = 'MAD',
+    MDL = 'lei',
+    MGA = 'Ar',
+    MKD = 'ден',
+    MMK = 'K',
+    MNT = '₮',
+    MOP = 'MOP$',
+    MRO = 'UM',
+    MRU = 'UM',
+    MUR = '₨',
+    MVR = 'Rf',
+    MWK = 'MK',
+    MXN = 'Mex$',
+    MYR = 'RM',
+    MZN = 'MT',
+    NAD = '$',
+    NGN = '₦',
+    NIO = 'C$',
+    NOK = 'kr',
+    NPR = '₨',
+    NZD = '$',
+    OMR = '﷼',
+    PAB = 'B/.',
+    PEN = 'S/.',
+    PGK = 'K',
+    PHP = '₱',
+    PKR = '₨',
+    PLN = 'zł',
+    PYG = 'Gs',
+    QAR = '﷼',
+    RMB = '￥',
+    RON = 'lei',
+    RSD = 'Дин.',
+    RUB = '₽',
+    RWF = 'R₣',
+    SAR = '﷼',
+    SBD = 'Si$',
+    SCR = '₨',
+    SDG = 'ج.س.',
+    SEK = 'kr',
+    SGD = '$',
+    SHP = '£',
+    SLL = 'Le',
+    SOS = 'S',
+    SRD = '$',
+    SSP = '£',
+    STD = 'Db',
+    STN = 'Db',
+    SVC = '₡',
+    SYP = '£',
+    SZL = 'E',
+    THB = '฿',
+    TJS = 'SM',
+    TMT = 'T',
+    TND = 'د.ت',
+    TOP = 'T$',
+    TRL = '₤',
+    TRY = '₺',
+    TTD = 'TT$',
+    TVD = '$',
+    TWD = 'NT$',
+    TZS = 'TSh',
+    UAH = '₴',
+    UGX = 'USh',
+    USD = '$',
+    UYU = '$U',
+    UZS = 'лв',
+    VEF = 'Bs',
+    VND = '₫',
+    VUV = 'VT',
+    WST = 'WS$',
+    XAF = 'FCFA',
+    XBT = 'Ƀ',
+    XCD = '$',
+    XOF = 'CFA',
+    XPF = '₣',
+    YER = '﷼',
+    ZAR = 'R',
+    ZWD = 'Z$',
+}