@lana-commerce/core 11.0.0

package/cjs/json/storefront.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = exports.prettyPrintResponseError = exports.requestErrorPrefix = exports.isExpanded = exports.assertExpanded = void 0;
+const common_js_1 = require("./common.js");
+var common_1 = require("./common");
+Object.defineProperty(exports, "assertExpanded", { enumerable: true, get: function () { return common_1.assertExpanded; } });
+Object.defineProperty(exports, "isExpanded", { enumerable: true, get: function () { return common_1.isExpanded; } });
+Object.defineProperty(exports, "requestErrorPrefix", { enumerable: true, get: function () { return common_1.requestErrorPrefix; } });
+Object.defineProperty(exports, "prettyPrintResponseError", { enumerable: true, get: function () { return common_1.prettyPrintResponseError; } });
+exports.request = common_js_1.requestFunction;

package/cjs/json/storefrontTypes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/lastValue.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lastValue = void 0;
+const tslib_1 = require("tslib");
+// TODO: better explanation
+// Wraps an async function in such a way that if while request #1 is running user makes request #2, request #1
+// will return undefined as a result. Last request always returns an unmodified value.
+function lastValue(f) {
+    let current;
+    return (...args) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const promise = f(...args);
+        current = promise;
+        const value = yield promise;
+        return promise === current ? { kind: "resolved", value } : { kind: "discarded" };
+    });
+}
+exports.lastValue = lastValue;

package/cjs/lineItemPrice.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineItemPrice = exports.lineItemPriceInfo = void 0;
+const variantPrice_js_1 = require("./variantPrice.js");
+const percentageOff_js_1 = require("./percentageOff.js");
+const tieredPrice_js_1 = require("./tieredPrice.js");
+function applyDiscountPreview(pi, quantity, dp) {
+    if (dp === 0)
+        return pi;
+    const prevLPrice = pi.lineItemPrice;
+    const prevIPrice = pi.perItemPrice;
+    const lprice = Math.max(0, prevLPrice - dp);
+    const iprice = lprice / quantity;
+    return {
+        sale: pi.sale,
+        hide: pi.hide,
+        kind: "price_discount",
+        lineItemPrice: lprice,
+        perItemPrice: iprice,
+        previousLineItemPrice: prevLPrice,
+        previousPerItemPrice: prevIPrice,
+        percentageOff: (0, percentageOff_js_1.percentageOff)(prevLPrice, lprice),
+    };
+}
+function lineItemPriceInfoPreDiscountPreview(vpi, quantity, tieredQuantity) {
+    if (vpi.tieredPricing && vpi.tieredPricing.tiers.length > 0) {
+        // tiered pricing
+        if (vpi.sale) {
+            const prevLPrice = (0, tieredPrice_js_1.tieredPrice)(vpi.tieredPricing, vpi.previousPrice, quantity, tieredQuantity);
+            const prevIPrice = Math.round(prevLPrice / quantity);
+            return {
+                sale: vpi.sale,
+                hide: vpi.hide,
+                kind: "price_discount",
+                lineItemPrice: vpi.price * quantity,
+                perItemPrice: vpi.price,
+                previousLineItemPrice: prevLPrice,
+                previousPerItemPrice: prevIPrice,
+                percentageOff: (0, percentageOff_js_1.percentageOff)(prevLPrice, vpi.price * quantity),
+            };
+        }
+        else {
+            const tieredLPrice = (0, tieredPrice_js_1.tieredPrice)(vpi.tieredPricing, vpi.price, quantity, tieredQuantity);
+            const tieredIPrice = Math.round(tieredLPrice / quantity);
+            if (tieredLPrice !== vpi.price * quantity) {
+                return {
+                    sale: vpi.sale,
+                    hide: vpi.hide,
+                    kind: "price_discount",
+                    lineItemPrice: tieredLPrice,
+                    perItemPrice: tieredIPrice,
+                    previousLineItemPrice: vpi.price * quantity,
+                    previousPerItemPrice: vpi.price,
+                    percentageOff: (0, percentageOff_js_1.percentageOff)(vpi.price * quantity, tieredLPrice),
+                };
+            }
+            else {
+                return {
+                    sale: vpi.sale,
+                    hide: vpi.hide,
+                    kind: "price",
+                    lineItemPrice: vpi.price * quantity,
+                    perItemPrice: vpi.price,
+                };
+            }
+        }
+    }
+    else {
+        // normal pricing
+        if (vpi.previousPrice !== 0 && vpi.previousPrice !== vpi.price) {
+            return {
+                sale: vpi.sale,
+                hide: vpi.hide,
+                kind: "price_discount",
+                lineItemPrice: vpi.price * quantity,
+                perItemPrice: vpi.price,
+                previousLineItemPrice: vpi.previousPrice * quantity,
+                previousPerItemPrice: vpi.previousPrice,
+                percentageOff: (0, percentageOff_js_1.percentageOff)(vpi.previousPrice, vpi.price),
+            };
+        }
+        else {
+            return {
+                sale: vpi.sale,
+                hide: vpi.hide,
+                kind: "price",
+                lineItemPrice: vpi.price * quantity,
+                perItemPrice: vpi.price,
+            };
+        }
+    }
+}
+function customItemPriceInfo(customItemPrice) {
+    return {
+        hide: false,
+        previousPrice: 0,
+        price: customItemPrice || 0,
+        sale: false,
+        tieredPricing: undefined,
+    };
+}
+function lineItemPriceInfo(vpi, customItemPrice, quantity, tieredQuantity, discountPreview) {
+    return applyDiscountPreview(lineItemPriceInfoPreDiscountPreview(vpi || customItemPriceInfo(customItemPrice), quantity, tieredQuantity), quantity, discountPreview);
+}
+exports.lineItemPriceInfo = lineItemPriceInfo;
+function lineItemPrice(env, p, customItemPrice, quantity, tieredQuantity, discountPreview, plans, planIndex) {
+    const plan = plans && planIndex !== undefined && planIndex >= 0 ? plans[planIndex] : undefined;
+    const vpi = p ? (0, variantPrice_js_1.variantPriceInfo)(env, p, plan) : undefined;
+    return lineItemPriceInfo(vpi, customItemPrice, quantity, tieredQuantity, discountPreview);
+}
+exports.lineItemPrice = lineItemPrice;

package/cjs/loadJWT.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadJWT = void 0;
+const tslib_1 = require("tslib");
+const jwt_decode_1 = tslib_1.__importDefault(require("jwt-decode"));
+const unixSecondsNow = () => Math.floor(+new Date() / 1000);
+function loadJWT(key, shopID) {
+    try {
+        const token = localStorage.getItem(key) || undefined;
+        if (!token)
+            return undefined;
+        const payload = (0, jwt_decode_1.default)(token);
+        if (!payload)
+            return undefined;
+        if (shopID !== undefined && payload.shop_id !== shopID)
+            return undefined;
+        if (payload.exp !== undefined && payload.exp < unixSecondsNow())
+            return undefined;
+        return token;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+exports.loadJWT = loadJWT;

package/cjs/mapInvalidInput.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapInvalidInput = exports.mapPrefix = void 0;
+const codes_js_1 = require("./generated/codes.js");
+function mapPrefix(v, prefixMaps) {
+    if (!prefixMaps || prefixMaps.length === 0)
+        return v;
+    for (const pm of prefixMaps) {
+        if (v.startsWith(pm.from)) {
+            return (pm.to || "") + v.slice(pm.from.length);
+        }
+    }
+    return v;
+}
+exports.mapPrefix = mapPrefix;
+function mapInvalidInput(e, ...prefixMaps) {
+    var _a;
+    let out;
+    if (e.kind === "error" &&
+        ((_a = e.error.apiError) === null || _a === void 0 ? void 0 : _a.code) === codes_js_1.ErrorCode.InvalidInput &&
+        e.error.apiError.meta &&
+        e.error.apiError.meta.fields) {
+        const fields = e.error.apiError.meta.fields;
+        if (fields.length > 0) {
+            out = {};
+            for (const f of fields) {
+                out[mapPrefix(f.field, prefixMaps)] = f;
+            }
+        }
+    }
+    return out;
+}
+exports.mapInvalidInput = mapInvalidInput;

package/cjs/mapResponseData.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstResponseData = exports.mapResponseData = void 0;
+function mapResponseData(resp, f) {
+    if (resp.kind !== "data")
+        return resp;
+    return {
+        kind: "data",
+        data: f(resp.data),
+    };
+}
+exports.mapResponseData = mapResponseData;
+function firstResponseData(resp) {
+    return mapResponseData(resp, (v) => v[0]);
+}
+exports.firstResponseData = firstResponseData;

package/cjs/mapResponseMultiData.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapResponseMultiData = void 0;
+function mapResponseMultiData(resp, f) {
+    if (resp.kind !== "data_or_error")
+        return resp;
+    return {
+        kind: "data_or_error",
+        data: resp.data ? f(resp.data) : undefined,
+        errors: resp.errors,
+        details: resp.details,
+    };
+}
+exports.mapResponseMultiData = mapResponseMultiData;

package/cjs/meanBy.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meanBy = void 0;
+function meanBy(array, cb) {
+    if (!array)
+        return 0;
+    if (array.length === 0)
+        return 0;
+    let sum = 0;
+    for (const v of array) {
+        sum += cb(v);
+    }
+    return sum / array.length;
+}
+exports.meanBy = meanBy;

package/cjs/media.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImage = exports.supportedImageMIMEs = void 0;
+exports.supportedImageMIMEs = {
+    "image/png": true,
+    "image/jpeg": true,
+    "image/gif": true,
+    "image/webp": true,
+    "image/heic": true,
+    "image/heif": true,
+    "image/avif": true,
+};
+function isImage(mime) {
+    return !!exports.supportedImageMIMEs[mime];
+}
+exports.isImage = isImage;

package/cjs/modules/advancedSearch.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdvancedSearch = exports.aggregatedOptionsToOptionAgg = exports.defaultSearchData = void 0;
+const tslib_1 = require("tslib");
+const effector_1 = require("effector");
+const dequal_1 = require("dequal");
+const request_js_1 = require("../request.js");
+const hierarchicalSearchOption_js_1 = require("../hierarchicalSearchOption.js");
+const combineEvery_js_1 = require("../effector/combineEvery.js");
+const combineSome_js_1 = require("../effector/combineSome.js");
+const compact_js_1 = require("../compact.js");
+const mapResponseData_js_1 = require("../mapResponseData.js");
+const requestResponse_js_1 = require("../effector/requestResponse.js");
+exports.defaultSearchData = {
+    products: [],
+    options: [],
+    priceRange: null,
+    count: 0,
+    lastKey: "",
+    hasMore: false,
+    params: null,
+};
+function aggregatedOptionsToOptionAgg(aggOpts) {
+    return aggOpts.uniqueOptionIDs.map((opt) => {
+        const vals = aggOpts.perOptionValues[opt] || [];
+        return {
+            count: 0,
+            name: opt,
+            values: vals.map((v) => ({
+                count: 0,
+                name: v,
+            })),
+        };
+    });
+}
+exports.aggregatedOptionsToOptionAgg = aggregatedOptionsToOptionAgg;
+function createAdvancedSearch(config) {
+    const configWithJWTAndLocale = (0, effector_1.combine)(config.jwt, config.locale, (authToken, locale) => (Object.assign(Object.assign({}, config), { opts: Object.assign(Object.assign({}, config.opts), { authToken,
+            locale }) })));
+    const queuedFor = (0, effector_1.createStore)("");
+    const data = (0, effector_1.createStore)(exports.defaultSearchData);
+    const nonNullParams = data.map((d) => !!d.params);
+    const unexpectedError = (0, effector_1.createEvent)();
+    const loadProducts = (0, effector_1.createEvent)();
+    const loadProductsFx = (0, effector_1.createEffect)((params) => tslib_1.__awaiter(this, void 0, void 0, function* () {
+        // reset products iteration?
+        const lastKey = (0, dequal_1.dequal)(params.params, params.currentParams) ? params.lastKey : "";
+        const p = params.params;
+        const data = (0, hierarchicalSearchOption_js_1.flattenHierarchicalSearchOptions)([...p.baseFilter, ...p.filter]);
+        const agg = p.filter.length === 0; // do we need options aggregation?
+        return (0, mapResponseData_js_1.mapResponseData)(yield (0, request_js_1.request)(config.graphql.searchProductsQuery)({
+            lastKey,
+            data,
+            limit: p.limit,
+            shopID: p.shopID,
+            sortBy: p.sortBy,
+            sortDesc: p.sortDesc,
+            aggregations: agg,
+        }, config.opts), (d) => {
+            const options = d.options.sort((a, b) => {
+                return a.name.localeCompare(b.name);
+            });
+            options.forEach((opt) => {
+                opt.values.sort((a, b) => {
+                    return a.name.localeCompare(b.name);
+                });
+            });
+            const products = (0, compact_js_1.compact)(d.items);
+            return {
+                products,
+                options: agg ? options : "keep",
+                priceRange: agg ? { min: d.price_min, max: d.price_max } : "keep",
+                count: d.count,
+                lastKey: d.last_key,
+                hasMore: lastKey && products.length === 0 ? false : true,
+                params: p,
+                mode: lastKey ? "append" : "replace",
+            };
+        });
+    }));
+    const loadProductsResult = (0, requestResponse_js_1.requestResponseSplit)(loadProductsFx.doneData);
+    // success
+    data.on((0, effector_1.sample)(queuedFor, loadProductsResult.data, (pageKey, result) => ({
+        result,
+        meantFor: pageKey,
+    })).filterMap((v) => (v.result && v.meantFor === v.result.params.pageKey ? v.result : undefined)), (prevData, r) => {
+        const products = r.mode === "append" ? [...prevData.products, ...r.products] : r.products;
+        return {
+            products,
+            count: r.count,
+            lastKey: r.lastKey,
+            hasMore: r.hasMore && products.length < r.count,
+            options: r.options === "keep" ? prevData.options : r.options,
+            priceRange: r.priceRange === "keep" ? prevData.priceRange : r.priceRange,
+            params: r.params,
+        };
+    });
+    // failure
+    (0, effector_1.forward)({ from: loadProductsResult.error, to: unexpectedError });
+    queuedFor.on(loadProducts, (_, ev) => ev.params.pageKey);
+    const somethingIsPending = (0, combineSome_js_1.combineSome)(loadProductsFx.pending);
+    const everythingIdle = somethingIsPending.map((pending) => !pending);
+    (0, effector_1.guard)({
+        source: (0, effector_1.sample)((0, effector_1.combine)(configWithJWTAndLocale, data), loadProducts, ([config, data], ev) => (Object.assign({ config, lastKey: data.lastKey, currentParams: data.params }, ev))),
+        filter: everythingIdle,
+        target: loadProductsFx,
+    });
+    // on locale change, let's re-submit the query, but only if there was some result
+    (0, effector_1.guard)({
+        source: (0, effector_1.sample)((0, effector_1.combine)(configWithJWTAndLocale, data), config.locale, ([config, data]) => ({
+            config,
+            lastKey: "",
+            currentParams: null,
+            params: data.params,
+        })),
+        filter: (0, combineEvery_js_1.combineEvery)(everythingIdle, nonNullParams),
+        target: loadProductsFx,
+    });
+    return {
+        loadProducts,
+        queuedFor,
+        data,
+        somethingIsPending,
+        unexpectedError,
+    };
+}
+exports.createAdvancedSearch = createAdvancedSearch;