@lana-commerce/core 11.0.0

package/esm/json/storefront.js

@@ -0,0 +1,3 @@
+import { requestFunction } from "./common.js";
+export { assertExpanded, isExpanded, requestErrorPrefix, prettyPrintResponseError, } from "./common";
+export const request = requestFunction;

package/esm/json/storefrontTypes.js

@@ -0,0 +1 @@
+export {};

package/esm/lastValue.js

@@ -0,0 +1,12 @@
+// 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.
+export function lastValue(f) {
+    let current;
+    return async (...args) => {
+        const promise = f(...args);
+        current = promise;
+        const value = await promise;
+        return promise === current ? { kind: "resolved", value } : { kind: "discarded" };
+    };
+}

package/esm/lineItemPrice.js

@@ -0,0 +1,106 @@
+import { variantPriceInfo, } from "./variantPrice.js";
+import { percentageOff } from "./percentageOff.js";
+import { tieredPrice } from "./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: percentageOff(prevLPrice, lprice),
+    };
+}
+function lineItemPriceInfoPreDiscountPreview(vpi, quantity, tieredQuantity) {
+    if (vpi.tieredPricing && vpi.tieredPricing.tiers.length > 0) {
+        // tiered pricing
+        if (vpi.sale) {
+            const prevLPrice = 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: percentageOff(prevLPrice, vpi.price * quantity),
+            };
+        }
+        else {
+            const tieredLPrice = 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: 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: 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,
+    };
+}
+export function lineItemPriceInfo(vpi, customItemPrice, quantity, tieredQuantity, discountPreview) {
+    return applyDiscountPreview(lineItemPriceInfoPreDiscountPreview(vpi || customItemPriceInfo(customItemPrice), quantity, tieredQuantity), quantity, discountPreview);
+}
+export function lineItemPrice(env, p, customItemPrice, quantity, tieredQuantity, discountPreview, plans, planIndex) {
+    const plan = plans && planIndex !== undefined && planIndex >= 0 ? plans[planIndex] : undefined;
+    const vpi = p ? variantPriceInfo(env, p, plan) : undefined;
+    return lineItemPriceInfo(vpi, customItemPrice, quantity, tieredQuantity, discountPreview);
+}

package/esm/loadJWT.js

@@ -0,0 +1,20 @@
+import jwtDecode from "jwt-decode";
+const unixSecondsNow = () => Math.floor(+new Date() / 1000);
+export function loadJWT(key, shopID) {
+    try {
+        const token = localStorage.getItem(key) || undefined;
+        if (!token)
+            return undefined;
+        const payload = jwtDecode(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 {
+        return undefined;
+    }
+}

package/esm/mapInvalidInput.js

@@ -0,0 +1,27 @@
+import { ErrorCode } from "./generated/codes.js";
+export 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;
+}
+export function mapInvalidInput(e, ...prefixMaps) {
+    let out;
+    if (e.kind === "error" &&
+        e.error.apiError?.code === 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;
+}

package/esm/mapResponseData.js

@@ -0,0 +1,11 @@
+export function mapResponseData(resp, f) {
+    if (resp.kind !== "data")
+        return resp;
+    return {
+        kind: "data",
+        data: f(resp.data),
+    };
+}
+export function firstResponseData(resp) {
+    return mapResponseData(resp, (v) => v[0]);
+}

package/esm/mapResponseMultiData.js

@@ -0,0 +1,10 @@
+export 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,
+    };
+}

package/esm/meanBy.js

@@ -0,0 +1,11 @@
+export 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;
+}

package/esm/media.js

@@ -0,0 +1,12 @@
+export const supportedImageMIMEs = {
+    "image/png": true,
+    "image/jpeg": true,
+    "image/gif": true,
+    "image/webp": true,
+    "image/heic": true,
+    "image/heif": true,
+    "image/avif": true,
+};
+export function isImage(mime) {
+    return !!supportedImageMIMEs[mime];
+}

package/esm/modules/advancedSearch.js

@@ -0,0 +1,132 @@
+import { combine, createEffect, createEvent, createStore, forward, guard, sample } from "effector";
+import { dequal } from "dequal";
+import { request } from "../request.js";
+import { flattenHierarchicalSearchOptions } from "../hierarchicalSearchOption.js";
+import { combineEvery } from "../effector/combineEvery.js";
+import { combineSome } from "../effector/combineSome.js";
+import { compact } from "../compact.js";
+import { mapResponseData } from "../mapResponseData.js";
+import { requestResponseSplit } from "../effector/requestResponse.js";
+export const defaultSearchData = {
+    products: [],
+    options: [],
+    priceRange: null,
+    count: 0,
+    lastKey: "",
+    hasMore: false,
+    params: null,
+};
+export 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,
+            })),
+        };
+    });
+}
+export function createAdvancedSearch(config) {
+    const configWithJWTAndLocale = combine(config.jwt, config.locale, (authToken, locale) => ({
+        ...config,
+        opts: {
+            ...config.opts,
+            authToken,
+            locale,
+        },
+    }));
+    const queuedFor = createStore("");
+    const data = createStore(defaultSearchData);
+    const nonNullParams = data.map((d) => !!d.params);
+    const unexpectedError = createEvent();
+    const loadProducts = createEvent();
+    const loadProductsFx = createEffect(async (params) => {
+        // reset products iteration?
+        const lastKey = dequal(params.params, params.currentParams) ? params.lastKey : "";
+        const p = params.params;
+        const data = flattenHierarchicalSearchOptions([...p.baseFilter, ...p.filter]);
+        const agg = p.filter.length === 0; // do we need options aggregation?
+        return mapResponseData(await 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 = 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 = requestResponseSplit(loadProductsFx.doneData);
+    // success
+    data.on(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
+    forward({ from: loadProductsResult.error, to: unexpectedError });
+    queuedFor.on(loadProducts, (_, ev) => ev.params.pageKey);
+    const somethingIsPending = combineSome(loadProductsFx.pending);
+    const everythingIdle = somethingIsPending.map((pending) => !pending);
+    guard({
+        source: sample(combine(configWithJWTAndLocale, data), loadProducts, ([config, data], ev) => ({
+            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
+    guard({
+        source: sample(combine(configWithJWTAndLocale, data), config.locale, ([config, data]) => ({
+            config,
+            lastKey: "",
+            currentParams: null,
+            params: data.params,
+        })),
+        filter: combineEvery(everythingIdle, nonNullParams),
+        target: loadProductsFx,
+    });
+    return {
+        loadProducts,
+        queuedFor,
+        data,
+        somethingIsPending,
+        unexpectedError,
+    };
+}