@lana-commerce/core 11.0.0

package/esm/convertImageURL.js

@@ -0,0 +1,15 @@
+import { compact } from "./compact.js";
+export function convertImageURL(cdnBaseURL, url, p) {
+    if (!url) {
+        url = `${cdnBaseURL}/placeholder.svg`;
+    }
+    const extMatch = url.match(/\.[^/.]+$/);
+    if (!extMatch) {
+        // no extension, bail out, shouldn't really happen
+        return "";
+    }
+    const ext = extMatch[0];
+    const noext = url.replace(/\.[^/.]+$/, ""); // strip away extension
+    const params = compact([p.size, p.crop, p.low ? "low" : undefined]);
+    return params.length === 0 ? url : noext + "_" + params.join("_") + (p.scale ? `@${p.scale}x` : "") + ext;
+}

package/esm/dataLoader.js

@@ -0,0 +1,192 @@
+import { prettyPrintRequestResponseError, request } from "./request.js";
+import { embedAnalytics } from "./script.js";
+import { arrayToDict } from "./arrayToDict.js";
+import { compact } from "./compact.js";
+import { fetchAllItems } from "./fetchAllItems.js";
+import { nonNull } from "./nonNull.js";
+import { promiseAll } from "./promiseAll.js";
+import { timeIt } from "./timeIt.js";
+function throwOnFailure(resp) {
+    if (resp.kind !== "data") {
+        throw new Error(prettyPrintRequestResponseError(resp, true));
+    }
+    return resp.data;
+}
+async function fetchCategoriesTreeRecursive(shopID, query, opts, category) {
+    const apiCategories = throwOnFailure(await request(query)({ shopID, childrenOf: category ? category.id : undefined }, opts));
+    const categories = apiCategories.map((c) => ({ ...c, children: [] }));
+    for (const category of categories) {
+        if (!category.has_children)
+            continue;
+        category.children = await fetchCategoriesTreeRecursive(shopID, query, opts, category);
+    }
+    return categories;
+}
+function categoriesForEach(categories, cb, parentID = "") {
+    for (const c of categories) {
+        cb(c, parentID);
+        categoriesForEach(c.children, cb, c.id);
+    }
+}
+function flattenCategories(categories) {
+    const out = [];
+    categoriesForEach(categories, (c) => {
+        const cc = { ...c, children: [] };
+        out.push(cc);
+    });
+    return out;
+}
+function createCategoriesMap(categories) {
+    const out = {};
+    categoriesForEach(categories, (c) => {
+        out[c.id] = c;
+    });
+    return out;
+}
+function createCategoryParentMap(categories) {
+    const out = {};
+    categoriesForEach(categories, (c, parentID) => {
+        out[c.id] = parentID;
+    });
+    return out;
+}
+function categoryRelativeURL(c, cmap, cpmap) {
+    const parentCategory = cmap[cpmap[c.id] || ""];
+    const parentURL = parentCategory ? categoryRelativeURL(parentCategory, cmap, cpmap) : "";
+    return `${parentURL}/${c.handle}`;
+}
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------------------------------
+function createCategoryBriefs(categories, products) {
+    const cmap = createCategoriesMap(categories);
+    const cpmap = createCategoryParentMap(categories);
+    const out = {};
+    categoriesForEach(categories, (c, parentID) => {
+        out[c.id] = {
+            id: c.id,
+            parentID: parentID,
+            title: c.title,
+            relativeUrl: categoryRelativeURL(c, cmap, cpmap),
+            featured: c.featured,
+            quantity: products.reduce((count, p) => count + (p.categories?.some((pc) => pc?.id === c.id) ? 1 : 0), 0),
+            imageUrl: c.image_files?.find(() => true)?.public_url || undefined,
+        };
+    });
+    return out;
+}
+function createProductBriefs(products) {
+    const out = {};
+    for (const p of products) {
+        out[p.id] = {
+            id: p.id,
+            handle: p.handle,
+            title: p.title,
+            average_score: p.average_score,
+            review_count: p.review_count,
+            variants: compact(p.variants?.map((v) => v
+                ? {
+                    currency_prices: v.currency_prices,
+                    customer_group_price: v.customer_group_price,
+                    id: v.id,
+                    inventory: v.inventory,
+                    inventory_policy: v.inventory_policy,
+                    is_default: v.is_default,
+                    map_price: v.map_price,
+                    media_files: v.media_files,
+                    options: v.options.map((opt) => ({
+                        option_id: opt.option_id,
+                        option_value_id: opt.option_value_id,
+                    })),
+                    price: v.price,
+                    retail_price: v.retail_price,
+                    sale_price: v.sale_price,
+                    sale_price_eligible: v.sale_price_eligible,
+                    sku: v.sku,
+                    tiered_pricing: v.tiered_pricing,
+                }
+                : undefined)),
+        };
+    }
+    return out;
+}
+async function loadDataForLanguage(config, locale, isDefault) {
+    const opts = locale ? { ...config.opts, locale } : config.opts;
+    const ltimeIt = (name, cb) => {
+        const prefix = locale ? `[${locale}] ` : "";
+        const log = (seconds) => {
+            console.log(`${prefix}fetched ${name}: ${seconds.toFixed(3)}s elapsed`);
+        };
+        return timeIt(log, cb);
+    };
+    const { shop, currencies, products, menus, contentBlocks, categoriesTree, branding, gateways, reviewDimensions, reviewSettings, options, inventoryLocations, } = await promiseAll({
+        shop: ltimeIt("shop", async () => throwOnFailure(await request(config.graphql.getShopQuery)({ shopID: config.shopID }, opts))[0]),
+        currencies: ltimeIt("currencies", async () => throwOnFailure(await request(config.graphql.getShopCurrenciesQuery)({ shopID: config.shopID }, opts))),
+        products: ltimeIt("products", async () => throwOnFailure(await fetchAllItems(config.graphql.getProductsPageQuery, { shopID: config.shopID }, opts))),
+        menus: ltimeIt("menus", async () => throwOnFailure(await fetchAllItems(config.graphql.getMenusPageQuery, { shopID: config.shopID }, opts))),
+        contentBlocks: ltimeIt("content blocks", async () => throwOnFailure(await fetchAllItems(config.graphql.getContentBlocksPageQuery, { shopID: config.shopID }, opts))),
+        categoriesTree: ltimeIt("categories", async () => fetchCategoriesTreeRecursive(config.shopID, config.graphql.getCategoriesQuery, opts)),
+        branding: ltimeIt("branding", async () => throwOnFailure(await request(config.graphql.getBrandingQuery)({ shopID: config.shopID }, opts))),
+        gateways: ltimeIt("gateways", async () => throwOnFailure(await request(config.graphql.getGatewaysQuery)({ shopID: config.shopID }, opts))),
+        reviewDimensions: ltimeIt("review dimensions", async () => throwOnFailure(await request(config.graphql.getReviewDimensionsQuery)({ shopID: config.shopID }, opts))),
+        reviewSettings: ltimeIt("review settings", async () => throwOnFailure(await request(config.graphql.getReviewSettingsQuery)({ shopID: config.shopID }, opts))),
+        options: ltimeIt("options", async () => throwOnFailure(await request(config.graphql.getOptionsQuery)({ shopID: config.shopID }, opts))),
+        inventoryLocations: ltimeIt("inventoryLocations", async () => throwOnFailure(await request(config.graphql.getInventoryLocationsQuery)({ shopID: config.shopID }, opts))),
+    });
+    const analytics = await embedAnalytics({
+        shop,
+        branding,
+        cdn: config.cdn,
+        beacon: config.beacon,
+    });
+    const categoriesBrief = createCategoryBriefs(categoriesTree, products);
+    const categories = flattenCategories(categoriesTree);
+    const productsBrief = createProductBriefs(products);
+    const shopLocale = locale || shop.language?.code || "en";
+    const additionalDataContext = { menus, contentBlocks };
+    const additionalShopData = config.resolveAdditionalShopData(additionalDataContext);
+    const additionalLocaleData = config.resolveAdditionalLocaleData(additionalDataContext);
+    return {
+        isDefault: isDefault ?? true,
+        locale: shopLocale,
+        shopData: {
+            singleLocale: locale === undefined,
+            locale: shopLocale,
+            shop,
+            currencies: arrayToDict(currencies, (c) => c.currency.code),
+            options: arrayToDict(options, (opt) => opt.id),
+            inventoryLocations: arrayToDict(inventoryLocations, (il) => il.id),
+            gateways,
+            reviewSettings,
+            reviewDimensions: arrayToDict(reviewDimensions, (rd) => rd.id),
+            categories: categoriesBrief,
+            siteUrl: config.siteUrl,
+            cdn: config.cdn,
+            opts,
+            staticData: config.staticData,
+            ...additionalShopData,
+        },
+        products,
+        productsBrief,
+        contentBlocks,
+        categories,
+        branding,
+        gateways,
+        analytics,
+        ...additionalLocaleData,
+    };
+}
+export async function loadData(config) {
+    const shop = throwOnFailure(await request(config.graphql.getShopQuery)({ shopID: config.shopID }, config.opts))[0];
+    const shopExtraLanguages = compact(shop.languages);
+    const shopLanguage = nonNull(shop.language, "shop language");
+    if (!shop.languages || shop.languages.length === 0) {
+        return { perLocale: [await loadDataForLanguage(config)] };
+    }
+    else {
+        const allLanguages = [shopLanguage, ...shopExtraLanguages];
+        return {
+            perLocale: await Promise.all(allLanguages.map(async (l, idx) => loadDataForLanguage(config, l.code, idx === 0))),
+        };
+    }
+}

package/esm/defaultVariant.js

@@ -0,0 +1,25 @@
+export function defaultVariant(product) {
+    if (!product)
+        return undefined;
+    let out;
+    if (product.variants) {
+        for (const v of product.variants) {
+            if (!v)
+                continue;
+            if (!out) {
+                // some variant, better than nothing
+                out = v;
+            }
+            if ((v.media_files?.length || 0) > 0) {
+                // prefer some variant with images
+                out = v;
+            }
+            if (v.is_default) {
+                // definitely the one we're looking for
+                out = v;
+                break;
+            }
+        }
+    }
+    return out;
+}

package/esm/effector/clearOnChangeAfterDelay.js

@@ -0,0 +1,13 @@
+import { createEvent } from "effector";
+export function clearOnChangeAfterDelay(store, timeout) {
+    const clear = createEvent();
+    store.reset(clear);
+    let lastTimeout = null;
+    store.updates.watch(() => {
+        if (lastTimeout)
+            clearTimeout(lastTimeout);
+        lastTimeout = setTimeout(() => {
+            clear();
+        }, timeout);
+    });
+}

package/esm/effector/combineEvery.js

@@ -0,0 +1,4 @@
+import { combine } from "effector";
+export function combineEvery(...stores) {
+    return combine(stores, (stores) => stores.every(Boolean));
+}

package/esm/effector/combineSome.js

@@ -0,0 +1,4 @@
+import { combine } from "effector";
+export function combineSome(...stores) {
+    return combine(stores, (stores) => stores.some(Boolean));
+}

package/esm/effector/debounced.js

@@ -0,0 +1,14 @@
+import { createEvent } from "effector";
+export function debounced(src, dst, delay) {
+    const setDst = createEvent();
+    dst.on(setDst, (_, v) => v);
+    let timeout;
+    src.updates.watch((v) => {
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(() => {
+            setDst(v);
+            timeout = undefined;
+        }, delay);
+    });
+}

package/esm/effector/form.js

@@ -0,0 +1,166 @@
+import { combine, createEvent, createStore, forward, guard, sample } from "effector";
+import { applyValidators, combineValidators } from "./validator.js";
+import { restoreNamed } from "./restoreNamed.js";
+function commonFields(name) {
+    const setAPIError = createEvent(`${name}.setAPIError`);
+    const apiError = restoreNamed(setAPIError.map((errs) => errs[name]?.problem || null), null, `${name}.apiError`);
+    return {
+        setAPIError,
+        apiError,
+    };
+}
+export function createBooleanField(name, initialValueArg) {
+    const { apiError, setAPIError } = commonFields(name);
+    const change = createEvent(`${name}.change`);
+    const changeUntouched = createEvent(`${name}.changeUntouched`);
+    const touch = createEvent(`${name}.touch`); // for compatibility with createFormSubmit
+    const setInitialValue = createEvent(`${name}.setInitialValue`);
+    const initialValue = restoreNamed(setInitialValue, initialValueArg, `${name}.initialValue`);
+    const value = restoreNamed(change, initialValueArg, `${name}.value`).on(changeUntouched, (_, v) => v);
+    const invalid = createStore(null, { name: `${name}.invalid` });
+    const visibleError = apiError;
+    const reset = createEvent(`${name}.reset`);
+    apiError.reset(reset);
+    sample({
+        source: initialValue,
+        clock: reset,
+        target: value,
+    });
+    return {
+        reset,
+        touch,
+        change,
+        changeUntouched,
+        value,
+        invalid,
+        setAPIError,
+        apiError,
+        visibleError,
+        setInitialValue,
+        initialValue,
+    };
+}
+export function createStringField(name, initialValueArg, validators) {
+    return createCommonStringField(name, initialValueArg, validators);
+}
+export function createEnumField(name, initialValueArg, validators) {
+    return createCommonStringField(name, initialValueArg, validators);
+}
+function createCommonStringField(name, initialValueArg, validators) {
+    const { apiError, setAPIError } = commonFields(name);
+    const change = createEvent(`${name}.change`);
+    const changeUntouched = createEvent(`${name}.changeUntouched`);
+    const touch = createEvent(`${name}.touch`);
+    const touched = restoreNamed(change.map(() => true), false, `${name}.touched`).on(touch, () => true);
+    const setInitialValue = createEvent(`${name}.setInitialValue`);
+    const initialValue = restoreNamed(setInitialValue, initialValueArg, `${name}.initialValue`);
+    const value = restoreNamed(change, initialValueArg, `${name}.value`).on(changeUntouched, (_, v) => v);
+    const invalid = applyValidators(value, validators);
+    const visibleError = combine(touched, invalid, apiError, (touched, invalid, apiError) => {
+        if (apiError)
+            return apiError;
+        if (touched && invalid)
+            return invalid;
+        return null;
+    });
+    const reset = createEvent(`${name}.reset`);
+    apiError.reset(reset);
+    touched.reset(reset);
+    sample({
+        source: initialValue,
+        clock: reset,
+        target: value,
+    });
+    return {
+        reset,
+        change,
+        changeUntouched,
+        touch,
+        touched,
+        value,
+        invalid,
+        setAPIError,
+        apiError,
+        visibleError,
+        setInitialValue,
+        initialValue,
+    };
+}
+function fieldValues(obj, keys) {
+    const out = {};
+    for (const key of keys) {
+        out[key] = obj[key].value;
+    }
+    return out;
+}
+export function createForm(obj) {
+    const init = createEvent();
+    const propagateInitialValues = createEvent();
+    const reset = createEvent();
+    const submit = createEvent();
+    const keys = Object.keys(obj);
+    forward({
+        from: submit,
+        to: keys.map((f) => obj[f].touch),
+    });
+    forward({
+        from: [reset, init],
+        to: keys.map((f) => obj[f].reset),
+    });
+    for (const key of keys) {
+        const f = obj[key];
+        forward({
+            from: init.map((v) => v[key]),
+            to: f.setInitialValue,
+        });
+        forward({
+            from: propagateInitialValues.map((v) => v[key]),
+            to: f.setInitialValue,
+        });
+    }
+    const valid = combineValidators(keys.map((f) => obj[f].invalid));
+    // TODO: I failed figuring out how to do the type here properly. If I apply the actual type from function signature,
+    // "guard()" type inference starts to fail. Could be lib issue. Or just a type inference mess.
+    const submitted = createEvent();
+    guard({
+        source: combine(fieldValues(obj, keys)),
+        clock: submit,
+        filter: valid,
+        target: submitted,
+    });
+    const propagateErrors = createEvent();
+    forward({
+        from: propagateErrors,
+        to: keys.map((f) => obj[f].setAPIError),
+    });
+    const noAPIErrorsSet = combine(keys.map((f) => obj[f].apiError), (errs) => errs.every((e) => !e));
+    const errorPropagationFailed = createEvent();
+    guard({
+        source: propagateErrors,
+        filter: noAPIErrorsSet,
+        target: errorPropagationFailed,
+    });
+    return {
+        ...obj,
+        init,
+        reset,
+        submit,
+        submitted,
+        valid,
+        propagateErrors,
+        propagateInitialValues,
+        errorPropagationFailed,
+    };
+}
+export function createFormWithCustomError(obj, err) {
+    const form = createForm(obj);
+    const setError = createEvent("setError");
+    const error = restoreNamed(setError, err, "error");
+    error.reset(form.init);
+    error.reset(form.reset);
+    return {
+        ...form,
+        error,
+        setError,
+    };
+}

package/esm/effector/hideOnChangeAfterDelay.js

@@ -0,0 +1,13 @@
+import { createEvent } from "effector";
+export function hideOnChangeAfterDelay(store, timeout) {
+    const clear = createEvent();
+    store.on(clear, (prev) => ({ ...prev, visible: false }));
+    let lastTimeout = null;
+    store.updates.watch(() => {
+        if (lastTimeout)
+            clearTimeout(lastTimeout);
+        lastTimeout = setTimeout(() => {
+            clear();
+        }, timeout);
+    });
+}

package/esm/effector/requestResponse.js

@@ -0,0 +1,24 @@
+import { createEvent, split } from "effector";
+export function requestResponseSplitGeneric(ev, fn) {
+    const dataSink = createEvent();
+    const errorSink = createEvent();
+    const data = dataSink.filterMap((v) => (v.kind === "data" ? fn(v.data) : undefined));
+    const error = errorSink.filterMap((v) => (v.kind !== "data" ? v : undefined));
+    split({
+        source: ev,
+        match: (ev) => ev.kind,
+        cases: {
+            data: dataSink,
+            error: errorSink,
+            system_error: errorSink,
+            custom_error: errorSink,
+        },
+    });
+    return { data, error };
+}
+export function requestResponseSplit(ev) {
+    return requestResponseSplitGeneric(ev, (v) => v);
+}
+export function requestResponseSplitFirst(ev) {
+    return requestResponseSplitGeneric(ev, (v) => v[0]);
+}

package/esm/effector/requestResponseMulti.js

@@ -0,0 +1,47 @@
+import { createEvent } from "effector";
+import { prettyPrintGraphErrors } from "../request.js";
+import { splitMap } from "./split.js";
+function allFieldsAreNull(v) {
+    for (var key in v) {
+        if (v[key] !== null)
+            return false;
+    }
+    return true;
+}
+export function requestResponseSplitMulti(ev) {
+    const data = createEvent();
+    const error = createEvent();
+    splitMap(ev)
+        .map((v) => {
+        return v.kind !== "data_or_error" ? v : undefined;
+    }, error)
+        .map((v) => {
+        if (v.kind !== "data_or_error")
+            return undefined;
+        if (v.errors && allFieldsAreNull(v.data)) {
+            const err = {
+                kind: "custom_error",
+                text: prettyPrintGraphErrors(v.errors),
+            };
+            return err;
+        }
+        if (!v.data) {
+            const err = {
+                kind: "custom_error",
+                text: "no data",
+            };
+            return err;
+        }
+        return undefined;
+    }, error)
+        .map((v) => {
+        if (v.kind !== "data_or_error")
+            return undefined;
+        if (v.errors && allFieldsAreNull(v.data))
+            return undefined;
+        if (!v.data)
+            return undefined;
+        return v.data;
+    }, data);
+    return { data, error };
+}

package/esm/effector/restoreNamed.js

@@ -0,0 +1,4 @@
+import { createStore } from "effector";
+export function restoreNamed(event, defaultState, name) {
+    return createStore(defaultState, { name }).on(event, (_, v) => v);
+}

package/esm/effector/split.js

@@ -0,0 +1,25 @@
+import { forward } from "effector";
+export function splitMap(source) {
+    let lastSource = source;
+    const builder = {
+        map(fn, target) {
+            const classify = lastSource.map((v) => {
+                const target = fn(v);
+                return target !== undefined ? { r: true, v: target } : { r: false, v };
+            });
+            forward({
+                from: classify.filterMap((v) => (v.r ? v.v : undefined)),
+                to: target,
+            });
+            lastSource = classify.filterMap((v) => (!v.r ? v.v : undefined));
+            return builder;
+        },
+        fallback(target) {
+            forward({
+                from: lastSource,
+                to: target,
+            });
+        },
+    };
+    return builder;
+}

package/esm/effector/validator.js

@@ -0,0 +1,28 @@
+import { combine } from "effector";
+function makeValidator(k, fn) {
+    return (v) => (fn(v) ? null : k);
+}
+export function applyValidators(store, validators) {
+    return store.map((v) => {
+        for (const validator of validators) {
+            const result = validator(v);
+            if (result)
+                return result;
+        }
+        return null;
+    });
+}
+const nonEmpty = (v) => !!v;
+const isEmpty = (v) => !v;
+export const validMaxLengthLongText = makeValidator("max_length_exceeded", (v) => v.length <= 100000);
+export const validMaxLength250 = makeValidator("max_length_exceeded", (v) => v.length <= 250);
+export const validMaxLength190 = makeValidator("max_length_exceeded", (v) => v.length <= 190);
+export const validMaxLength160 = makeValidator("max_length_exceeded", (v) => v.length <= 160);
+export const validMaxLength80 = makeValidator("max_length_exceeded", (v) => v.length <= 80);
+export const validMaxLength32 = makeValidator("max_length_exceeded", (v) => v.length <= 32);
+export const validNonEmpty = makeValidator("invalid_non_empty", nonEmpty);
+export const validEmail = makeValidator("invalid_email", (v) => isEmpty(v) || /^[a-zA-Z0-9.!#$%&’*+/=?^_`{|}~-]+@[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*$/.test(v));
+// TODO: improve type safety
+export function combineValidators(validStates) {
+    return combine(validStates, (v) => v.every((v) => v === null));
+}

package/esm/effector/wrapSignInRequired.js

@@ -0,0 +1,9 @@
+import { createEvent, sample } from "effector";
+import { splitMap } from "./split.js";
+export function wrapSignInRequired(jwt, signInRequired, orig) {
+    const wrappedEvent = createEvent();
+    splitMap(sample(jwt, wrappedEvent, (jwt, value) => ({ jwt, value })))
+        .map((v) => (v.jwt ? v.value : undefined), orig)
+        .map((v) => (!v.jwt ? true : undefined), signInRequired);
+    return wrappedEvent;
+}

package/esm/exceptions.js

@@ -0,0 +1,2 @@
+export class IterError extends Error {
+}

package/esm/fetchAllItems.js

@@ -0,0 +1,44 @@
+import { prettyPrintRequestResponseError, request } from "./request.js";
+import { IterError } from "./exceptions.js";
+export async function fetchAllItems(query, vars, opts) {
+    let lastKey = "";
+    let data = [];
+    while (true) {
+        const resp = await request(query)({ lastKey, limit: opts?.limit ?? 20, ...vars }, opts);
+        if (resp.kind === "data") {
+            const items = resp.data.items;
+            if (!items || items.length === 0) {
+                break;
+            }
+            data.push(...items);
+            lastKey = resp.data.last_key;
+            if (!lastKey) {
+                throw new IterError(`"last_key" is missing in the response, make sure you explicitly specify "sort_by" in the request`);
+            }
+        }
+        else {
+            return resp;
+        }
+    }
+    return { kind: "data", data };
+}
+export async function* iterAllItems(query, vars, opts) {
+    let lastKey = "";
+    while (true) {
+        const resp = await request(query)({ lastKey, limit: opts?.limit ?? 20, ...vars }, opts);
+        if (resp.kind !== "data") {
+            throw new IterError(prettyPrintRequestResponseError(resp, true));
+        }
+        const items = resp.data.items;
+        if (!items || items.length === 0) {
+            break;
+        }
+        for (const item of items) {
+            yield item;
+        }
+        lastKey = resp.data.last_key;
+        if (!lastKey) {
+            throw new IterError(`"last_key" is missing in the response, make sure you explicitly specify "sort_by" in the request`);
+        }
+    }
+}