@lana-commerce/core 11.0.0

package/cjs/react/components/SixDigitInput.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SixDigitInput = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+class SixDigitInput extends react_1.default.Component {
+    constructor() {
+        super(...arguments);
+        this.inputRefs = [null, null, null, null, null, null];
+        this.focusedOnce = false;
+        this.cursorKeyDownPos = 0;
+    }
+    focus() {
+        const v = this.inputRefs[0];
+        if (v)
+            v.focus();
+    }
+    onChangeNth(e, idx) {
+        const newValue = e.target.value;
+        const { value } = this.props;
+        const oldValue = value.length > idx ? value[idx] : "";
+        let nextValue = "";
+        let move = 0;
+        if (oldValue === "") {
+            nextValue = value + newValue;
+            const shouldBeAt = Math.min(5, nextValue.length);
+            move = shouldBeAt - idx;
+        }
+        else if (oldValue !== "") {
+            const ar = value.split("");
+            ar.splice(idx, 1, ...newValue.split(""));
+            nextValue = ar.join("");
+            if (this.cursorKeyDownPos === 1)
+                move = 1;
+        }
+        nextValue = nextValue.substring(0, 6);
+        this.onChange(nextValue, idx, move);
+    }
+    onChange(nextValue, idx, move) {
+        this.props.onChange(nextValue);
+        if (nextValue.length === 6) {
+            const e6 = this.props.onEnteredSixDigits;
+            if (e6) {
+                setTimeout(e6, 0);
+            }
+        }
+        if (move !== 0) {
+            const r = this.inputRefs[idx + move];
+            if (r) {
+                r.focus();
+                if (move > 0) {
+                    r.setSelectionRange(0, 0);
+                }
+                else {
+                    r.setSelectionRange(1, 1);
+                }
+            }
+        }
+    }
+    onKeyDownNth(idx, e) {
+        var _a;
+        const pos = ((_a = this.inputRefs[idx]) === null || _a === void 0 ? void 0 : _a.selectionStart) || 0;
+        const { value } = this.props;
+        const v = value.length > idx ? value[idx] : "";
+        const absPos = idx + pos;
+        const isFirst = pos === 0;
+        const isLast = v.length > 0 ? pos === 1 : true;
+        switch (e.keyCode) {
+            case 8: // backspace
+                e.preventDefault();
+                if (absPos > 0 && absPos <= value.length) {
+                    if (pos === 1)
+                        this.cursorOverride = { idx, pos: 0 };
+                    if (pos === 0)
+                        this.cursorOverride = { idx: idx - 1, pos: 0 };
+                    const ar = value.split("");
+                    ar.splice(absPos - 1, 1);
+                    this.onChange(ar.join(""), idx, pos === 0 ? -1 : 0);
+                }
+                break;
+            case 46: // delete
+                e.preventDefault();
+                if (value.length > absPos) {
+                    if (pos === 0)
+                        this.cursorOverride = { idx, pos: 0 };
+                    const ar = value.split("");
+                    ar.splice(absPos, 1);
+                    this.onChange(ar.join(""), idx, 0);
+                }
+                break;
+            case 37: // arrow left
+                if (isFirst) {
+                    e.preventDefault();
+                    if (idx > 0) {
+                        const r = this.inputRefs[idx - 1];
+                        if (r) {
+                            r.focus();
+                            r.setSelectionRange(1, 1);
+                        }
+                    }
+                }
+                break;
+            case 39: // arrow right
+                if (isLast) {
+                    e.preventDefault();
+                    if (idx < 5) {
+                        const r = this.inputRefs[idx + 1];
+                        if (r) {
+                            r.focus();
+                            r.setSelectionRange(0, 0);
+                        }
+                    }
+                }
+                break;
+            case 36: // home
+                {
+                    const r = this.inputRefs[0];
+                    if (r) {
+                        r.focus();
+                        r.setSelectionRange(0, 0);
+                    }
+                }
+                break;
+            case 35: // end
+                {
+                    const r = this.inputRefs[value.length === 6 ? 5 : value.length];
+                    if (r) {
+                        r.focus();
+                        r.setSelectionRange(1, 1);
+                    }
+                }
+                break;
+            default:
+                if (value.length === 6)
+                    e.preventDefault();
+                this.cursorKeyDownPos = pos;
+                break;
+        }
+    }
+    getValue(idx) {
+        const { value } = this.props;
+        return value.length > idx ? value[idx] : "";
+    }
+    componentDidUpdate() {
+        var _a;
+        const co = this.cursorOverride;
+        if (co) {
+            (_a = this.inputRefs[co.idx]) === null || _a === void 0 ? void 0 : _a.setSelectionRange(co.pos, co.pos);
+            this.cursorOverride = undefined;
+        }
+    }
+    render() {
+        const { autoFocus, className, inputClassName } = this.props;
+        return (react_1.default.createElement("div", { className: className }, [0, 1, 2, 3, 4, 5].map((i) => (react_1.default.createElement("input", { key: i, inputMode: "numeric", pattern: "[0-9]*", autoComplete: "off", type: "text", ref: (e) => {
+                this.inputRefs[i] = e;
+                if (i === 0 && autoFocus && !this.focusedOnce && e) {
+                    this.focusedOnce = true;
+                    e.focus();
+                }
+            }, className: inputClassName, value: this.getValue(i), onKeyDown: (e) => {
+                this.onKeyDownNth(i, e);
+            }, onChange: (e) => {
+                this.onChangeNth(e, i);
+            } })))));
+    }
+}
+exports.SixDigitInput = SixDigitInput;

package/cjs/react/contains.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contains = void 0;
+const DOCUMENT_POSITION_CONTAINED_BY = 16;
+function contains(container, elem) {
+    if (!container || !elem)
+        return false;
+    if (container.contains) {
+        return container.contains(elem);
+    }
+    const comparison = container.compareDocumentPosition(elem);
+    return comparison === 0 || (comparison & DOCUMENT_POSITION_CONTAINED_BY) !== 0;
+}
+exports.contains = contains;

package/cjs/react/popperBinder.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PopperBinder = void 0;
+const tslib_1 = require("tslib");
+const react_dom_1 = tslib_1.__importDefault(require("react-dom"));
+const index_js_1 = tslib_1.__importDefault(require("../vendor/popper/index.js"));
+class PopperBinder {
+    constructor(params) {
+        this.params = params;
+        this.popper = null;
+        this.triggerRef = null;
+        this.menuRef = null;
+        this.onUpdateCallbacks = [];
+        this.handleUpdateMenuRef = (e) => {
+            this.menuRef = e;
+            this.hookPopper(this.triggerRef, this.menuRef);
+        };
+        this.handleUpdateTriggerRef = (e) => {
+            this.triggerRef = e;
+            this.hookPopper(this.triggerRef, this.menuRef);
+        };
+        this.handleUpdate = () => {
+            for (const cb of this.onUpdateCallbacks)
+                cb();
+        };
+    }
+    addOnUpdateCallback(newCB) {
+        if (this.onUpdateCallbacks.some((cb) => cb === newCB))
+            return;
+        this.onUpdateCallbacks.push(newCB);
+    }
+    removeOnUpdateCallback(oldCB) {
+        const idx = this.onUpdateCallbacks.findIndex((cb) => cb === oldCB);
+        if (idx !== -1)
+            this.onUpdateCallbacks.splice(idx, 1);
+    }
+    hookPopper(triggerRef, menuRef) {
+        const { noFlip, scrollFlip, placement, parentWidth } = this.params;
+        if (this.popper && (!triggerRef || !menuRef)) {
+            this.popper.destroy();
+            this.popper = null;
+            return;
+        }
+        if (!this.popper && triggerRef && menuRef) {
+            const triggerEl = react_dom_1.default.findDOMNode(triggerRef);
+            const menuEl = react_dom_1.default.findDOMNode(menuRef);
+            this.popper = new index_js_1.default(triggerEl, menuEl, {
+                onUpdate: this.handleUpdate,
+                placement: placement || "bottom-end",
+                modifiers: Object.assign({ hide: { enabled: false }, preventOverflow: { enabled: false }, flip: { enabled: !noFlip, boundariesElement: scrollFlip ? "scrollParent" : "viewport" } }, (parentWidth
+                    ? {
+                        applyWidthToStyle: {
+                            enabled: true,
+                            fn: (data) => {
+                                data.styles.width = `${data.offsets.reference.width}`;
+                                return data;
+                            },
+                            order: 890,
+                        },
+                    }
+                    : {})),
+            });
+        }
+    }
+    update() {
+        if (this.popper)
+            this.popper.update();
+    }
+}
+exports.PopperBinder = PopperBinder;

package/cjs/react/rootClose.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootCloseTracker = void 0;
+const tslib_1 = require("tslib");
+const react_dom_1 = tslib_1.__importDefault(require("react-dom"));
+const contains_js_1 = require("./contains.js");
+const generateUUID_js_1 = require("../generateUUID.js");
+const escapeKeyCode = 27;
+function isLeftClickEvent(event) {
+    return event.button === 0;
+}
+function isModifierEvent(event) {
+    return !!(event.metaKey || event.altKey || event.ctrlKey || event.shiftKey);
+}
+function isWidthBelowWidth(comp) {
+    var _a;
+    const w = (_a = comp === null || comp === void 0 ? void 0 : comp.opts) === null || _a === void 0 ? void 0 : _a.ignoreBelowWidth;
+    if (w === undefined)
+        return false;
+    return window.innerWidth < w;
+}
+function isWidthAboveWidth(comp) {
+    var _a;
+    const w = (_a = comp === null || comp === void 0 ? void 0 : comp.opts) === null || _a === void 0 ? void 0 : _a.ignoreAboveWidth;
+    if (w === undefined)
+        return false;
+    return window.innerWidth >= w;
+}
+function shouldDoNothing(event, hierarchical, trackedComponents) {
+    const len = trackedComponents.length;
+    const last = len > 0 ? trackedComponents[len - 1] : undefined;
+    if (isWidthBelowWidth(last) || isWidthAboveWidth(last))
+        return true;
+    const tag = last === null || last === void 0 ? void 0 : last.tag;
+    const group = trackedComponents.filter((comp) => comp.tag === tag);
+    return (isModifierEvent(event) ||
+        !isLeftClickEvent(event) ||
+        (hierarchical && len > 0
+            ? group.some((comp) => (0, contains_js_1.contains)(react_dom_1.default.findDOMNode(comp.instance), event.target))
+            : trackedComponents.some((comp) => (0, contains_js_1.contains)(react_dom_1.default.findDOMNode(comp.instance), event.target))));
+}
+class RootCloseTracker {
+    constructor(hierarchical) {
+        this.hierarchical = hierarchical;
+        this.mouseDownStatus = "do_nothing";
+        this.trackedComponents = [];
+        this.handleMouseDownCapture = (e) => {
+            const len = this.trackedComponents.length;
+            if (len === 0)
+                return;
+            this.mouseDownStatus = shouldDoNothing(e, this.hierarchical, this.trackedComponents) ? "do_nothing" : "close";
+        };
+        this.handleClickCapture = (e) => {
+            const len = this.trackedComponents.length;
+            if (len === 0)
+                return;
+            const shouldClose = !shouldDoNothing(e, this.hierarchical, this.trackedComponents);
+            if (shouldClose && this.mouseDownStatus === "close") {
+                if (this.hierarchical && len > 1) {
+                    e.preventDefault();
+                    e.stopPropagation();
+                }
+                this.trackedComponents[len - 1].onRootClose();
+            }
+        };
+        this.handleKeyUp = (e) => {
+            const len = this.trackedComponents.length;
+            const last = len > 0 ? this.trackedComponents[len - 1] : undefined;
+            if (isWidthBelowWidth(last) || isWidthAboveWidth(last))
+                return;
+            if (e.keyCode === escapeKeyCode && last) {
+                last.onRootClose();
+            }
+        };
+    }
+    addTrackedComponent(v, tag, onRootClose, opts) {
+        this.trackedComponents.push({ instance: v, onRootClose, tag: tag || (0, generateUUID_js_1.generateUUID)(), opts });
+        if (this.trackedComponents.length === 1) {
+            // added first one, setup event listeners
+            this.addEventListeners();
+        }
+    }
+    removeTrackedComponent(v) {
+        const i = this.trackedComponents.findIndex((comp) => comp.instance === v);
+        if (i !== -1) {
+            this.trackedComponents.splice(i, 1);
+        }
+        if (this.trackedComponents.length === 0) {
+            // removed last one, remove event listeners
+            this.removeEventListeners();
+        }
+    }
+    addEventListeners() {
+        document.addEventListener("mousedown", this.handleMouseDownCapture, true);
+        document.addEventListener("click", this.handleClickCapture, true);
+        document.addEventListener("keyup", this.handleKeyUp);
+        // we took root close wrapper from some other project and it had those mobile safari hacks, I
+        // wasn't able to find the exact details on what it does and whether it's even still relevant today
+        // hence commenting it out for now
+        // if ("ontouchstart" in document.documentElement) {
+        //   this.mobileSafariHackListeners = [].slice.call(document.body.children).map(el => listen(el, "mousemove", noop));
+        // }
+    }
+    removeEventListeners() {
+        document.removeEventListener("keyup", this.handleKeyUp);
+        document.removeEventListener("click", this.handleClickCapture, true);
+        document.removeEventListener("mousedown", this.handleMouseDownCapture, true);
+        // if (this.mobileSafariHackListeners)
+        //   this.mobileSafariHackListeners.forEach(remove => remove())
+    }
+}
+exports.RootCloseTracker = RootCloseTracker;

package/cjs/react/translateLocalStatic.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeT = void 0;
+const tslib_1 = require("tslib");
+/**
+ * @jsx React.createElement
+ * @jsxFrag React.Fragment
+ */
+const react_1 = tslib_1.__importStar(require("react"));
+const formatToJSX_js_1 = require("../formatToJSX.js");
+const translateLocale_js_1 = require("../translateLocale.js");
+const formatJSXConfig = {
+    cloneElement: react_1.cloneElement,
+    isValidElement: react_1.isValidElement,
+    toFragment: (v) => react_1.default.createElement(react_1.default.Fragment, null, v),
+};
+function makeT(perLocaleData) {
+    return (template, ...args) => {
+        var _a;
+        const locale = (0, translateLocale_js_1.getLocale)();
+        let pat = template;
+        if (locale !== "en") {
+            pat = (_a = perLocaleData[locale]) === null || _a === void 0 ? void 0 : _a[template];
+            if (!pat) {
+                console.warn(`missing translation string for "${locale}" locale: ${template}`);
+                pat = template;
+            }
+        }
+        return (0, formatToJSX_js_1.format)(formatJSXConfig, pat, ...args);
+    };
+}
+exports.makeT = makeT;

package/cjs/react/useAsyncCachedValue.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAsyncCachedValue = void 0;
+const react_1 = require("react");
+function useAsyncCachedValue(loader) {
+    const [value, setValue] = (0, react_1.useState)(loader.value);
+    (0, react_1.useEffect)(() => {
+        if (!value) {
+            loader.load().then(setValue);
+        }
+    }, []);
+    return value;
+}
+exports.useAsyncCachedValue = useAsyncCachedValue;

package/cjs/refreshTimeout.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshTimeout = void 0;
+function refreshTimeout(f, delayMs) {
+    let timeout;
+    const ff = () => {
+        timeout = undefined;
+        f();
+    };
+    timeout = setTimeout(ff, delayMs);
+    return {
+        clear: () => {
+            if (timeout)
+                clearTimeout(timeout);
+            timeout = undefined;
+        },
+        refresh: () => {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = setTimeout(ff, delayMs);
+            }
+        },
+    };
+}
+exports.refreshTimeout = refreshTimeout;

package/cjs/remoteAuth.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setRemoteAuth = exports.getRemote = exports.authFromJWT = void 0;
+const tslib_1 = require("tslib");
+const postmate_1 = tslib_1.__importDefault(require("postmate"));
+const jwt_decode_1 = tslib_1.__importDefault(require("jwt-decode"));
+const getSalesChannelID_js_1 = require("./getSalesChannelID.js");
+const getSessionID_js_1 = require("./getSessionID.js");
+const sleep_js_1 = require("./sleep.js");
+function authFromJWT(jwt) {
+    let customerID = "";
+    if (jwt) {
+        try {
+            const data = (0, jwt_decode_1.default)(jwt);
+            customerID = data.customer_id;
+        }
+        catch (_a) {
+            // do nothing
+        }
+    }
+    return jwt && customerID ? { kind: "authorized", jwt, customerID, customerEmail: "" } : { kind: "not_authorized" };
+}
+exports.authFromJWT = authFromJWT;
+let globalPostmate;
+function getRemote(url) {
+    if (!globalPostmate) {
+        let el = document.getElementById("remote-container");
+        if (!el) {
+            el = document.createElement("div");
+            el.style.display = "none";
+            document.body.appendChild(el);
+        }
+        globalPostmate = new postmate_1.default({
+            container: el,
+            url,
+        });
+    }
+    return globalPostmate;
+}
+exports.getRemote = getRemote;
+function setRemoteAuth(pm, jwt, timeout = 3000) {
+    return Promise.race([
+        pm
+            .then((pm) => {
+            pm.call("setAuth", authFromJWT(jwt));
+            const sessionID = (0, getSessionID_js_1.getSessionID)();
+            if (sessionID) {
+                pm.call("setSessionID", sessionID);
+            }
+            const salesChannelID = (0, getSalesChannelID_js_1.getSalesChannelID)();
+            if (salesChannelID) {
+                pm.call("setSalesChannelID", salesChannelID);
+            }
+        })
+            .then(() => "success"),
+        (0, sleep_js_1.sleep)(timeout).then(() => "timeout"),
+    ]);
+}
+exports.setRemoteAuth = setRemoteAuth;