@lana-commerce/core 11.0.0

package/cjs/preact/transition/Transition.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transition = void 0;
+const hooks_1 = require("preact/hooks");
+const noop = () => { };
+const APPEAR = "APPEAR";
+const APPEARING = "APPEARING";
+const APPEARED = "APPEARED";
+const ENTER = "ENTER";
+const ENTERING = "ENTERING";
+const ENTERED = "ENTERED";
+const EXIT = "EXIT";
+const EXITING = "EXITING";
+const EXITED = "EXITED";
+const Transition = ({ in: inProp = false, appear = false, enter = true, exit = true, duration = 500, alwaysMounted = false, children, onEnter = noop, onEntering = noop, onEntered = noop, onExit = noop, onExiting = noop, onExited = noop, }) => {
+    const timeoutRef = (0, hooks_1.useRef)();
+    let ignoreInPropChange = false;
+    const [phase, setPhase] = (0, hooks_1.useState)(() => {
+        ignoreInPropChange = true;
+        if (!inProp)
+            return EXITED;
+        if (appear)
+            return APPEAR;
+        return APPEARED;
+    });
+    (0, hooks_1.useEffect)(() => {
+        switch (phase) {
+            case APPEAR:
+                onEnter();
+                setPhase(APPEARING);
+                break;
+            case APPEARING:
+                onEntering();
+                timeoutRef.current = setTimeout(() => {
+                    setPhase(APPEARED);
+                }, duration);
+                break;
+            case APPEARED:
+                onEntered();
+                break;
+            case ENTER:
+                onEnter();
+                setPhase(ENTERING);
+                break;
+            case ENTERING:
+                onEntering();
+                timeoutRef.current = setTimeout(() => {
+                    setPhase(ENTERED);
+                }, duration);
+                break;
+            case ENTERED:
+                onEntered();
+                break;
+            case EXIT:
+                onExit();
+                setPhase(EXITING);
+                break;
+            case EXITING:
+                onExiting();
+                timeoutRef.current = setTimeout(() => {
+                    setPhase(EXITED);
+                }, duration);
+                break;
+            case EXITED:
+                onExited();
+                break;
+        }
+        return () => {
+            if (timeoutRef.current)
+                clearTimeout(timeoutRef.current);
+        };
+    }, [phase]);
+    (0, hooks_1.useLayoutEffect)(() => {
+        if (!ignoreInPropChange) {
+            switch (true) {
+                case !!(inProp && enter):
+                    setPhase(ENTER);
+                    break;
+                case !!(inProp && !enter):
+                    setPhase(ENTERED);
+                    break;
+                case !!(!inProp && exit):
+                    setPhase(EXIT);
+                    break;
+                case !!(!inProp && !exit):
+                    setPhase(EXITED);
+                    break;
+            }
+        }
+    }, [inProp]);
+    const value = (0, hooks_1.useMemo)(() => ({
+        appear: phase === APPEAR,
+        appearActive: phase === APPEARING,
+        appearDone: phase === APPEARED,
+        enter: phase === ENTER,
+        enterActive: phase === ENTERING,
+        enterDone: phase === ENTERED,
+        exit: phase === EXIT,
+        exitActive: phase === EXITING,
+        exitDone: phase === EXITED,
+    }), [phase]);
+    return alwaysMounted || phase !== EXITED ? children(value) : null;
+};
+exports.Transition = Transition;

package/cjs/preact/translateLocalStatic.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeT = void 0;
+/**
+ * @jsx h
+ * @jsxFrag Fragment
+ */
+const preact_1 = require("preact");
+const formatToJSX_js_1 = require("../formatToJSX.js");
+const translateLocale_js_1 = require("../translateLocale.js");
+const formatJSXConfig = {
+    cloneElement: preact_1.cloneElement,
+    isValidElement: preact_1.isValidElement,
+    toFragment: (v) => (0, preact_1.h)(preact_1.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/productFiltering.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRatingFilter = exports.makePriceFilter = exports.makeOptionFilter = exports.filtersToSearchOptions = exports.filterProducts = exports.createProductFiltering = void 0;
+const effector_1 = require("effector");
+const variantPrice_js_1 = require("./variantPrice.js");
+const compact_js_1 = require("./compact.js");
+const debounced_js_1 = require("./effector/debounced.js");
+function createProductFiltering() {
+    const pageKey = (0, effector_1.createStore)("");
+    const setFiltersState = (0, effector_1.createEvent)();
+    const setFilterState = (0, effector_1.createEvent)();
+    const filtersState = (0, effector_1.createStore)({});
+    const filtersStateDebounced = (0, effector_1.createStore)({});
+    (0, debounced_js_1.debounced)(filtersState, filtersStateDebounced, 500);
+    filtersState.on(setFiltersState, (_, v) => v.state);
+    filtersState.on(setFilterState, (fs, { id, data }) => {
+        const s = Object.assign({}, fs);
+        if (data === undefined) {
+            delete s[id];
+        }
+        else {
+            s[id] = data;
+        }
+        return s;
+    });
+    pageKey.on(setFiltersState, (_, v) => v.pageKey);
+    pageKey.on(setFilterState, (_, v) => v.pageKey);
+    return {
+        setFiltersState,
+        setFilterState,
+        filtersState,
+        filtersStateDebounced,
+        pageKey,
+    };
+}
+exports.createProductFiltering = createProductFiltering;
+function filterProducts(state, filtersMap, products) {
+    if (Object.keys(state).length === 0)
+        return products.map((p) => ({ original: p, filtered: p }));
+    const funcs = [];
+    for (const key in state) {
+        const f = filtersMap[key];
+        if (!f)
+            continue;
+        const val = state[key];
+        funcs.push((p) => f.filter(val, p));
+    }
+    return (0, compact_js_1.compact)(products.map((p) => {
+        let pp = p;
+        for (const f of funcs) {
+            if (!pp)
+                break;
+            pp = f(pp);
+        }
+        return pp ? { original: p, filtered: pp } : undefined;
+    }));
+}
+exports.filterProducts = filterProducts;
+function filtersToSearchOptions(state, filtersMap) {
+    const perContext = new Map();
+    const out = [];
+    for (const key in state) {
+        const f = filtersMap[key];
+        if (!f)
+            continue;
+        const val = state[key];
+        const result = f.api(val);
+        if (result) {
+            const context = f.context;
+            if (!perContext.has(context)) {
+                perContext.set(context, []);
+            }
+            const array = perContext.get(context);
+            array.push(result);
+        }
+    }
+    const p = perContext.get("product");
+    if (p)
+        out.push(...p);
+    const v = perContext.get("variant");
+    if (v)
+        out.push({ kind: "and", opts: v, context: "variants" });
+    return out;
+}
+exports.filtersToSearchOptions = filtersToSearchOptions;
+function makeOptionFilter(optionID) {
+    return {
+        id: `option:${optionID}`,
+        context: "variant",
+        filter: (state, p) => {
+            if (state === undefined)
+                return p;
+            const variants = (0, compact_js_1.compact)(p.variants).filter((v) => v.options.some((opt) => opt.option_id === optionID && (state === null || state === void 0 ? void 0 : state.has(opt.option_value_id))));
+            if (variants.length === 0)
+                return undefined;
+            return Object.assign(Object.assign({}, p), { variants });
+        },
+        api: (state) => {
+            if (!state)
+                return undefined;
+            const vals = Array.from(state.keys());
+            return {
+                kind: "or",
+                opts: vals.map((val) => ({
+                    kind: "and",
+                    opts: [
+                        { kind: "opt", opt: { op: "eq", name: "variants.options.option_id", text: optionID } },
+                        { kind: "opt", opt: { op: "eq", name: "variants.options.option_value_id", text: val } },
+                    ],
+                })),
+            };
+        },
+    };
+}
+exports.makeOptionFilter = makeOptionFilter;
+function makePriceFilter(env) {
+    return {
+        id: "price-range",
+        context: "variant",
+        filter: (state, p) => {
+            if (state === undefined)
+                return p;
+            const variants = (0, compact_js_1.compact)(p.variants).filter((v) => {
+                const price = (0, variantPrice_js_1.variantPriceInfo)(env, v).price;
+                return price >= state.from && price <= state.to;
+            });
+            if (variants.length === 0)
+                return undefined;
+            return Object.assign(Object.assign({}, p), { variants });
+        },
+        api: (state) => {
+            if (state === undefined)
+                return undefined;
+            // TODO: better API price filtering, what about other currencies?
+            return {
+                kind: "and",
+                opts: [
+                    { kind: "opt", opt: { op: "ge", name: "variants.price", number: state.from } },
+                    { kind: "opt", opt: { op: "le", name: "variants.price", number: state.to } },
+                ],
+            };
+        },
+    };
+}
+exports.makePriceFilter = makePriceFilter;
+function makeRatingFilter() {
+    return {
+        id: "rating-range",
+        context: "product",
+        filter: (state, p) => {
+            if (state === undefined)
+                return p;
+            const score = p.average_score / 2 + 0.5;
+            if (score >= state.from && score <= state.to)
+                return p;
+            return undefined;
+        },
+        api: (state) => {
+            if (state === undefined)
+                return undefined;
+            const lo = 2 * state.from - 1;
+            const hi = 2 * state.to - 1;
+            return {
+                kind: "and",
+                opts: [
+                    { kind: "opt", opt: { op: "ge", name: "average_score", number: lo, zero: lo === 0 } },
+                    { kind: "opt", opt: { op: "le", name: "average_score", number: hi, zero: hi === 0 } },
+                ],
+            };
+        },
+    };
+}
+exports.makeRatingFilter = makeRatingFilter;

package/cjs/productSEO.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.productSEO = void 0;
+const defaultVariant_js_1 = require("./defaultVariant.js");
+const toMajor_js_1 = require("./toMajor.js");
+const variantImages_js_1 = require("./variantImages.js");
+const variantPrice_js_1 = require("./variantPrice.js");
+function productSEO(env, product) {
+    var _a;
+    const variant = (0, defaultVariant_js_1.defaultVariant)(product);
+    if (!variant)
+        return undefined;
+    const images = (0, variantImages_js_1.variantImages)(variant);
+    const priceInfo = (0, variantPrice_js_1.variantPriceInfo)(env, variant);
+    const info = variant
+        ? {
+            variantID: variant.id,
+            variantSKU: variant.sku,
+            productID: product.id,
+            productHandle: product.handle,
+        }
+        : undefined;
+    return {
+        canonicalLinkHref: info && env.canonicalVariantURL ? env.canonicalVariantURL(info) : undefined,
+        meta: [
+            { name: "title", content: product.meta_title },
+            { name: "description", content: product.meta_description },
+            // OPEN GRAPH
+            { property: "og:type", content: "product" },
+            { property: "og:title", content: product.meta_title },
+            ...(info && env.canonicalVariantURL ? [{ property: "og:url", content: env.canonicalVariantURL(info) }] : []),
+            { property: "og:price:amount", content: `${(0, toMajor_js_1.toMajor)(env.shopCurrencies, env.currency, priceInfo.price)}` },
+            { property: "og:price:currency", content: env.currency },
+            { property: "og:availability", content: (((_a = variant.inventory) === null || _a === void 0 ? void 0 : _a.available) || 0) > 0 ? "instock" : "oos" },
+            { property: "og:description", content: product.meta_description },
+            // TWITTER CARD
+            { name: "twitter:card", content: "summary" },
+            { name: "twitter:title", content: product.meta_title },
+            { name: "twitter:description", content: product.meta_description },
+            // OPEN GRAPH images
+            ...images.reduce((array, f) => [
+                ...array,
+                { property: "og:image", content: f.public_url },
+                { property: "og:image:secure_url", content: f.public_url },
+            ], []),
+            // TWITTER CARD images
+            ...images.reduce((array, f) => [...array, { property: "twitter:image", content: f.public_url }], []),
+        ],
+    };
+}
+exports.productSEO = productSEO;

package/cjs/productSorting.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortProducts = exports.defaultSortOptions = exports.sortByVisitsDesc = exports.sortBySalesDesc = exports.sortByRatingDesc = exports.sortByRatingAsc = exports.sortByTitleDesc = exports.sortByTitleAsc = exports.sortByPriceDesc = exports.sortByPriceAsc = void 0;
+const variantPrice_js_1 = require("./variantPrice.js");
+const defaultVariant_js_1 = require("./defaultVariant.js");
+exports.sortByPriceAsc = {
+    id: "price_asc",
+    api: () => ["min_price", false],
+    func: (a, b) => a.price - b.price,
+};
+exports.sortByPriceDesc = {
+    id: "price_desc",
+    api: () => ["min_price", true],
+    func: (a, b) => b.price - a.price,
+};
+exports.sortByTitleAsc = {
+    id: "title_asc",
+    api: () => ["title", false],
+    func: (a, b) => a.title.localeCompare(b.title),
+};
+exports.sortByTitleDesc = {
+    id: "title_desc",
+    api: () => ["title", true],
+    func: (a, b) => b.title.localeCompare(a.title),
+};
+exports.sortByRatingAsc = {
+    id: "rating_asc",
+    api: () => ["rating", false],
+    func: (a, b) => {
+        if (a.rating !== undefined && b.rating !== undefined) {
+            return a.rating - b.rating;
+        }
+        else {
+            return (a.rating !== undefined ? 0 : 1) - (b.rating !== undefined ? 0 : 1);
+        }
+    },
+};
+exports.sortByRatingDesc = {
+    id: "rating_desc",
+    api: () => ["rating", true],
+    func: (a, b) => {
+        if (a.rating !== undefined && b.rating !== undefined) {
+            return b.rating - a.rating;
+        }
+        else {
+            return (a.rating !== undefined ? 0 : 1) - (b.rating !== undefined ? 0 : 1);
+        }
+    },
+};
+exports.sortBySalesDesc = {
+    id: "top_selling",
+    api: () => ["sales", true],
+    func: () => {
+        throw new Error("not implemented");
+    },
+    apiOnly: true,
+};
+exports.sortByVisitsDesc = {
+    id: "most_viewed",
+    api: () => ["visits", true],
+    func: () => {
+        throw new Error("not implemented");
+    },
+    apiOnly: true,
+};
+exports.defaultSortOptions = [
+    exports.sortByPriceAsc,
+    exports.sortByPriceDesc,
+    exports.sortByTitleAsc,
+    exports.sortByTitleDesc,
+    exports.sortByRatingAsc,
+    exports.sortByRatingDesc,
+    exports.sortBySalesDesc,
+    exports.sortByVisitsDesc,
+];
+function sortProducts(env, sortBy, products) {
+    if (!sortBy)
+        return products;
+    return products
+        .map((fp, idx) => {
+        const p = fp.filtered;
+        const v = (0, defaultVariant_js_1.defaultVariant)(p);
+        return {
+            idx,
+            price: (0, variantPrice_js_1.variantPriceInfo)(env, v).price,
+            title: p.title,
+            rating: p.review_count !== 0 ? p.average_score : undefined,
+        };
+    })
+        .sort(sortBy.func)
+        .map((vi) => products[vi.idx]);
+}
+exports.sortProducts = sortProducts;

package/cjs/promiseAll.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseAll = void 0;
+const tslib_1 = require("tslib");
+function promiseAll(obj) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const keys = Object.keys(obj);
+        const values = yield Promise.all(keys.map((key) => obj[key]));
+        const out = {};
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            const val = values[i];
+            out[key] = val;
+        }
+        return out;
+    });
+}
+exports.promiseAll = promiseAll;

package/cjs/promiseLimit.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PromiseLimiter = void 0;
+const tslib_1 = require("tslib");
+class PromiseLimiter {
+    constructor(num) {
+        this.queue = [];
+        this.dispatch = () => tslib_1.__awaiter(this, void 0, void 0, function* () {
+            if (this.queue.length === 0 || this.slots.length === 0)
+                return;
+            const slot = this.slots.shift();
+            const item = this.queue.shift();
+            try {
+                item.resolve(yield item.pfunc(slot));
+            }
+            catch (err) {
+                item.reject(err);
+            }
+            this.slots.push(slot);
+            this.dispatch();
+        });
+        this.slots = Array.from({ length: num }).map((_, idx) => idx);
+    }
+    run(pfunc) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            const p = new Promise((resolve, reject) => {
+                this.queue.push({
+                    pfunc,
+                    resolve,
+                    reject,
+                });
+            });
+            this.dispatch();
+            return p;
+        });
+    }
+}
+exports.PromiseLimiter = PromiseLimiter;

package/cjs/rdsToInitialScores.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rdsToInitialScores = void 0;
+const compact_js_1 = require("./compact.js");
+function findScoreInPrevScores(rdID, prevScores) {
+    const s = prevScores === null || prevScores === void 0 ? void 0 : prevScores.find((s) => (s.review_dimension ? s.review_dimension.id === rdID : rdID === ""));
+    return s ? s.score : 0;
+}
+function defaultInitialScoresValue(prevScores) {
+    return [{ review_dimension_id: "", score: findScoreInPrevScores("", prevScores) || 9, overall: false }];
+}
+function rdsToInitialScores(rds, reviewDimensions, prevScores) {
+    var _a;
+    if (!rds) {
+        return defaultInitialScoresValue(prevScores);
+    }
+    const overallID = rds.overall_review_dimension ? rds.overall_review_dimension.id : "";
+    const arr = (0, compact_js_1.compact)((_a = rds.review_dimensions) === null || _a === void 0 ? void 0 : _a.map((rd) => {
+        if (!rd)
+            return undefined;
+        const v = reviewDimensions[rd.id];
+        if (!v)
+            return undefined;
+        return {
+            review_dimension_id: v.id,
+            score: findScoreInPrevScores(v.id, prevScores) || 9,
+            overall: v.id === overallID,
+        };
+    }));
+    return arr.length > 0 ? arr : defaultInitialScoresValue(prevScores);
+}
+exports.rdsToInitialScores = rdsToInitialScores;

package/cjs/react/components/Portal.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Portal = void 0;
+const tslib_1 = require("tslib");
+const react_dom_1 = tslib_1.__importDefault(require("react-dom"));
+const Portal = (props) => typeof document !== "undefined" ? react_dom_1.default.createPortal(props.children, document.body) : null;
+exports.Portal = Portal;

package/cjs/react/components/RootCloseWrapper.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RootCloseWrapper = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const rootClose_js_1 = require("../rootClose.js");
+const globalTracker = new rootClose_js_1.RootCloseTracker(true);
+class RootCloseWrapper extends react_1.default.Component {
+    constructor() {
+        super(...arguments);
+        this.added = false;
+    }
+    componentDidMount() {
+        const { tracker, tag, onRootClose, disabled, ignoreBelowWidth, ignoreAboveWidth } = this.props;
+        if (!disabled) {
+            (tracker || globalTracker).addTrackedComponent(this, tag, onRootClose, { ignoreBelowWidth, ignoreAboveWidth });
+            this.added = true;
+        }
+    }
+    componentDidUpdate() {
+        const { tracker, tag, onRootClose, disabled } = this.props;
+        if (this.added && disabled) {
+            (tracker || globalTracker).removeTrackedComponent(this);
+            this.added = false;
+        }
+        else if (!this.added && !disabled) {
+            (tracker || globalTracker).addTrackedComponent(this, tag, onRootClose);
+            this.added = true;
+        }
+    }
+    componentWillUnmount() {
+        const { tracker } = this.props;
+        if (this.added) {
+            (tracker || globalTracker).removeTrackedComponent(this);
+        }
+    }
+    render() {
+        return this.props.children;
+    }
+}
+exports.RootCloseWrapper = RootCloseWrapper;