@lana-commerce/core 11.0.0

package/esm/aggregateOptions.js

@@ -0,0 +1,169 @@
+function buildEnabledValues(perOptionValues) {
+    const out = {};
+    const keys = Object.keys(perOptionValues);
+    for (const key of keys) {
+        const val = perOptionValues[key];
+        if (!val)
+            continue;
+        const d = {};
+        for (const v of val) {
+            d[v] = true;
+        }
+        out[key] = d;
+    }
+    return out;
+}
+function buildPerOptionValues(uniqueOptionIDs, sets, cond) {
+    const perOptionValues = {};
+    for (const id of uniqueOptionIDs) {
+        const uniqueVals = {};
+        for (const set of sets) {
+            const ok = cond(set, id);
+            if (!ok)
+                continue;
+            let setVal = "";
+            for (const opt of set.options) {
+                if (opt.key === id) {
+                    setVal = opt.value;
+                }
+            }
+            uniqueVals[setVal] = true;
+        }
+        perOptionValues[id] = Object.keys(uniqueVals).sort();
+    }
+    return perOptionValues;
+}
+function optionMatches(key, val, set) {
+    const vval = set.options.find((opt) => opt.key === key);
+    if (vval === undefined) {
+        // option not found in set, but we match if it's undefined
+        return !val;
+    }
+    else {
+        return val === vval.value;
+    }
+}
+function matchVariantID(opts, selected) {
+    const keys = Object.keys(selected);
+    nextSet: for (const set of opts.sets) {
+        for (const key of keys) {
+            const val = selected[key];
+            if (!optionMatches(key, val, set)) {
+                continue nextSet;
+            }
+        }
+        return set.variantID;
+    }
+    return "";
+}
+function variantMatches(key, val, v) {
+    const vval = v.options.find((opt) => opt.option_id === key);
+    if (vval === undefined) {
+        // option not found in set, but we match if it's undefined
+        return !val;
+    }
+    else {
+        return val === vval.option_value_id;
+    }
+}
+export function matchVariant(variants, selected) {
+    const keys = Object.keys(selected);
+    nextSet: for (const v of variants) {
+        for (const key of keys) {
+            const val = selected[key];
+            if (!variantMatches(key, val, v)) {
+                continue nextSet;
+            }
+        }
+        return v;
+    }
+    return undefined;
+}
+export function closestVariantIDs(opts, selected) {
+    const keys = Object.keys(selected);
+    const variants = [];
+    for (const set of opts.sets) {
+        const variantID = set.variantID;
+        let numMatches = 0;
+        for (const key of keys) {
+            const val = selected[key];
+            const matches = optionMatches(key, val, set);
+            if (matches)
+                numMatches++;
+        }
+        const numExtra = set.options.length - numMatches;
+        variants.push({ variantID, numMatches, numExtra });
+    }
+    variants.sort((a, b) => {
+        if (a.numMatches === b.numMatches) {
+            return a.numExtra - b.numExtra;
+        }
+        else {
+            return b.numMatches - a.numMatches;
+        }
+    });
+    return variants.map((v) => v.variantID);
+}
+function restrictValues(opts, key, value) {
+    return buildPerOptionValues(opts.uniqueOptionIDs, opts.sets, (set) => value
+        ? !!set.options.find((opt) => opt.key === key && opt.value === value)
+        : !set.options.find((opt) => opt.key === key));
+}
+export function restrictSelected(opts, selected, key, val) {
+    const perOptionValues = restrictValues(opts, key, val);
+    const newSelected = { [key]: val };
+    for (const otherOpt of opts.uniqueOptionIDs) {
+        if (otherOpt === key)
+            continue;
+        const current = selected[otherOpt] || "";
+        const isValid = perOptionValues[otherOpt]?.find((v) => v === current) !== undefined;
+        newSelected[otherOpt] = isValid ? current : perOptionValues[otherOpt]?.[0] || "";
+    }
+    return {
+        enabledValues: buildEnabledValues(buildPerOptionValues(opts.uniqueOptionIDs, opts.sets, (set, id) => {
+            const selected = { ...newSelected };
+            delete selected[id];
+            return set.options.every((opt) => selected[opt.key] === undefined || opt.value === selected[opt.key]);
+        })),
+        selected: newSelected,
+        variantID: matchVariantID(opts, newSelected),
+    };
+}
+export function selectVariantID(opts, variantID) {
+    const set = opts.sets.find((set) => set.variantID === variantID);
+    if (!set)
+        throw new Error(`${variantID} is missing in aggregated options`);
+    const selected = {};
+    for (const opt of set.options) {
+        selected[opt.key] = opt.value;
+    }
+    return {
+        enabledValues: buildEnabledValues(buildPerOptionValues(opts.uniqueOptionIDs, opts.sets, (set, id) => {
+            const s = { ...selected };
+            delete s[id];
+            return set.options.every((opt) => s[opt.key] === undefined || opt.value === s[opt.key]);
+        })),
+        selected,
+        variantID,
+    };
+}
+export function aggregateOptions(variants) {
+    const allOptIDs = {};
+    for (const v of variants) {
+        for (const opt of v.options) {
+            allOptIDs[opt.option_id] = true;
+        }
+    }
+    const sets = variants.map((v) => ({
+        variantID: v.id,
+        options: v.options.map((opt) => ({ key: opt.option_id, value: opt.option_value_id })),
+    }));
+    const uniqueOptionIDs = Object.keys(allOptIDs).sort();
+    const perOptionValues = buildPerOptionValues(uniqueOptionIDs, sets, () => true);
+    return {
+        uniqueOptionIDs,
+        sets,
+        perOptionValues,
+        enabledValues: buildEnabledValues(perOptionValues),
+    };
+}

package/esm/analytics.js

@@ -0,0 +1,91 @@
+// type safe wrapper for calling analytics.js
+function analyticsDo(cb) {
+    if (typeof document !== "undefined") {
+        const a = window.analytics;
+        if (a)
+            cb(a);
+    }
+}
+export function identify(id) {
+    analyticsDo((a) => {
+        a.identify(id);
+    });
+}
+export function promotionClicked(promotion) {
+    analyticsDo((a) => {
+        a.track("Promotion Clicked", promotion);
+    });
+}
+export function productClicked(product) {
+    analyticsDo((a) => {
+        a.track("Product Clicked", product);
+    });
+}
+export function productsSearched(query) {
+    analyticsDo((a) => {
+        a.track("Products Searched", { query });
+    });
+}
+export function cartViewed(orderID, products) {
+    analyticsDo((a) => {
+        a.track("Cart Viewed", {
+            cart_id: orderID,
+            products: products.map((p, idx) => ({
+                ...p.product,
+                position: idx + 1,
+                quantity: p.quantity,
+            })),
+        });
+    });
+}
+export function productListViewed(categoryID, categoryName, products) {
+    analyticsDo((a) => {
+        a.track("Product List Viewed", {
+            list_id: categoryID,
+            category: categoryName,
+            products,
+        });
+    });
+}
+export function productViewed(product) {
+    analyticsDo((a) => {
+        a.track("Product Viewed", product);
+    });
+}
+export function wishlistAdded(product) {
+    analyticsDo((a) => {
+        a.track("Product Added to Wishlist", {
+            ...product,
+        });
+    });
+}
+export function wishlistRemoved(product) {
+    analyticsDo((a) => {
+        a.track("Product Removed from Wishlist", {
+            ...product,
+        });
+    });
+}
+export function productAdded(orderID, quantity, product) {
+    analyticsDo((a) => {
+        a.track("Product Added", {
+            ...product,
+            cart_id: orderID,
+            quantity,
+        });
+    });
+}
+export function productRemoved(orderID, quantity, product) {
+    analyticsDo((a) => {
+        a.track("Product Removed", {
+            ...product,
+            cart_id: orderID,
+            quantity,
+        });
+    });
+}
+export function page() {
+    analyticsDo((a) => {
+        a.page();
+    });
+}

package/esm/analyticsProductData.js

@@ -0,0 +1,28 @@
+import { variantPriceInfo } from "./variantPrice.js";
+import { convertImageURL } from "./convertImageURL.js";
+import { toMajor } from "./toMajor.js";
+import { variantImage } from "./variantImage.js";
+export function analyticsProductData(env, variant, variantID) {
+    const priceInfo = variantPriceInfo(env, variant);
+    const image = variantImage(variant);
+    const info = variant && variant.product
+        ? {
+            variantID: variant.id,
+            variantSKU: variant.sku,
+            productID: variant.product.id,
+            productHandle: variant.product.handle,
+        }
+        : undefined;
+    return {
+        product_id: variant?.id || variantID || "",
+        sku: variant?.sku || "",
+        name: variant?.product?.title || "",
+        price: toMajor(env.shopCurrencies, env.currency, priceInfo.price),
+        currency: env.currency,
+        url: info ? env.canonicalVariantURL?.(info) : undefined,
+        image_url: convertImageURL(env.cdn, image?.public_url, {
+            size: "200x200",
+            crop: "center",
+        }),
+    };
+}

package/esm/arrayToDict.js

@@ -0,0 +1,8 @@
+export function arrayToDict(array, key) {
+    const out = {};
+    for (const v of array) {
+        const k = key(v);
+        out[k] = v;
+    }
+    return out;
+}

package/esm/asyncModuleWrapper.js

@@ -0,0 +1,47 @@
+export function asyncImportWrapper(load) {
+    return asyncModuleWrapper((cfg) => load().then((m) => m.load(cfg)));
+}
+export function asyncModuleWrapper(load) {
+    let promise;
+    let loaded;
+    const queue = [];
+    const m = {
+        load: (v) => {
+            if (promise)
+                throw new Error("async module load() can only be called once");
+            promise = load(v).then((m) => {
+                loaded = m;
+                for (const item of queue) {
+                    item(m);
+                }
+                queue.length = 0;
+                return m;
+            });
+        },
+        loadOnce: (v) => {
+            if (!promise) {
+                m.load(v);
+            }
+            return promise;
+        },
+        afterLoad: () => promise ||
+            new Promise((resolve) => {
+                queue.push(resolve);
+            }),
+    };
+    return new Proxy({}, {
+        get(_target, prop) {
+            if (prop in m)
+                return m[prop];
+            if (loaded) {
+                const p = loaded[prop];
+                return typeof p === "function" ? (...args) => p.apply(loaded, args) : p;
+            }
+            return (...args) => {
+                queue.push((m) => {
+                    m[prop](...args);
+                });
+            };
+        },
+    });
+}

package/esm/averageReviewScore.js

@@ -0,0 +1,40 @@
+import { meanBy } from "./meanBy.js";
+export function averageReviewScore(product, reviewSettings) {
+    let overallDimID;
+    const ids = {};
+    // first consider data from the product itself
+    product.review_dimension_set?.review_dimensions?.forEach((rds) => {
+        const id = rds?.id;
+        if (id)
+            ids[id] = true;
+    });
+    overallDimID = product.review_dimension_set?.overall_review_dimension?.id || "";
+    if (Object.keys(ids).length === 0) {
+        // no data on the product? let's get default one
+        reviewSettings.default_review_dimension_set?.review_dimensions?.forEach((drds) => {
+            const id = drds?.id;
+            if (id)
+                ids[id] = true;
+        });
+        overallDimID = reviewSettings.default_review_dimension_set?.overall_review_dimension?.id || "";
+    }
+    if (Object.keys(ids).length === 0) {
+        // no review dimensions found for this product, let's try to get a score with empty dimension
+        const rd = product.average_scores.find((s) => s.review_dimension?.id === "");
+        if (rd)
+            return rd.score;
+        // if no review dimension found, let's just calc average of all
+        return meanBy(product.average_scores, (s) => s.score);
+    }
+    else {
+        // if we have overall dimension id, let's use it
+        const overall = overallDimID
+            ? product.average_scores.find((s) => s.review_dimension?.id === overallDimID)
+            : undefined;
+        if (overall)
+            return overall.score;
+        // otherwise calc average using only review dimensions from a map
+        const scores = product.average_scores.filter((s) => !!s.review_dimension && !!ids[s.review_dimension.id]);
+        return meanBy(scores, (s) => s.score);
+    }
+}

package/esm/buildconfig.js

@@ -0,0 +1,13 @@
+export const BUILD_CONFIG = {
+    ANALYTICS_INTEGRATION_NAME: "Lana",
+    API_URL: "https://api.lana.dev",
+    APP_DOMAIN: "lana.sh",
+    BEACON_URL: "https://api.lana.dev/i",
+    CDN_URL: "https://cdn.lana.dev",
+    SLATE_CLASS_PREFIX: "trunkery-",
+    UI_LIB_GLOBAL: "LanaUI",
+    UI_LIB: "@lana-commerce/ui",
+    WS_URL: "wss://api.lana.dev",
+    POPUP_CONNECT_QUEUE_KEY: "trunkery_popup_connect_queue",
+    AUTH_KEY: "trunkery_auth",
+};

package/esm/cachedLoader.js

@@ -0,0 +1,32 @@
+export class CachedLoader {
+    _loader;
+    _promise;
+    _value;
+    _initQueue = [];
+    constructor(_loader) {
+        this._loader = _loader;
+    }
+    get value() {
+        return this._value;
+    }
+    async load(a) {
+        if (!this._promise) {
+            this._promise = this._loader(a).then((v) => {
+                this._value = v;
+                for (const cb of this._initQueue)
+                    cb(v);
+                this._initQueue.length = 0;
+                return v;
+            });
+        }
+        return this._promise;
+    }
+    onLoad(callback) {
+        if (this._promise) {
+            this._promise.then(callback);
+        }
+        else {
+            this._initQueue.push(callback);
+        }
+    }
+}

package/esm/canonicalVariantURL.js

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

package/esm/cartOperation.js

@@ -0,0 +1,126 @@
+import { compact } from "./compact.js";
+// Filter out all operations that are not relevant for create API.
+// This includes remove operations and non-positive quantity operations.
+export function filterOutNonCreateOpertions(ops) {
+    const out = [];
+    for (const op of ops) {
+        if (op.kind === "remove")
+            continue;
+        if (op.kind === "change" && op.quantityDelta > 0) {
+            out.push({
+                kind: "set",
+                variant: op.variant,
+                variantID: op.variantID,
+                quantity: op.quantityDelta,
+                fieldSetID: op.fieldSetID,
+                fields: op.fields,
+                subscriptionPlanIndex: op.subscriptionPlanIndex,
+                customItemIndex: op.customItemIndex,
+            });
+        }
+        if (op.kind === "set" && op.quantity > 0) {
+            out.push(op);
+        }
+    }
+    return out;
+}
+function normalizeSetOperation(op) {
+    if (op.quantity <= 0) {
+        return {
+            kind: "remove",
+            variantID: op.variantID,
+        };
+    }
+    else {
+        return op;
+    }
+}
+// Function combines all cart operations, accumulating "change" operations and applying "remove" operations.
+// Changes are accumulated per variant id and order is preserved. If combined "change" operation results
+// in 0 quantity delta, then it's removed completely.
+export function compactCartOperations(operations) {
+    if (operations.length === 0)
+        return [];
+    const perVariant = {};
+    let order = 0;
+    for (const op of operations) {
+        const id = op.variantID;
+        if (op.kind === "remove") {
+            // remove overrides last operation
+            perVariant[id] = { op, order };
+        }
+        else if (op.kind === "set") {
+            // set overrides last operation (with normalization)
+            perVariant[id] = { op: normalizeSetOperation(op), order };
+        }
+        else {
+            const last = perVariant[id];
+            if (!last) {
+                perVariant[id] = { op, order };
+            }
+            else if (last.op.kind === "change") {
+                // change -> change, accumulate
+                const quantityDelta = last.op.quantityDelta + op.quantityDelta;
+                perVariant[id] = {
+                    order: last.order,
+                    op: {
+                        kind: "change",
+                        variant: op.variant,
+                        variantID: op.variantID,
+                        fieldSetID: op.fieldSetID || last.op.fieldSetID,
+                        fields: op.fields || last.op.fields,
+                        subscriptionPlanIndex: op.subscriptionPlanIndex ?? last.op.subscriptionPlanIndex,
+                        customItemIndex: op.customItemIndex ?? last.op.customItemIndex,
+                        quantityDelta,
+                    },
+                };
+            }
+            else if (last.op.kind === "set") {
+                // set -> change, accumulate
+                const quantity = last.op.quantity + op.quantityDelta;
+                perVariant[id] = {
+                    order: last.order,
+                    op: {
+                        kind: "set",
+                        variant: op.variant,
+                        variantID: op.variantID,
+                        fieldSetID: op.fieldSetID || last.op.fieldSetID,
+                        fields: op.fields || last.op.fields,
+                        subscriptionPlanIndex: op.subscriptionPlanIndex ?? last.op.subscriptionPlanIndex,
+                        customItemIndex: op.customItemIndex ?? last.op.customItemIndex,
+                        quantity,
+                    },
+                };
+            }
+            else {
+                // remove -> change, override
+                perVariant[id] = { op, order };
+            }
+        }
+        order++;
+    }
+    const variantIDs = Object.keys(perVariant);
+    for (const id of variantIDs) {
+        const cmd = perVariant[id];
+        if (!cmd)
+            continue;
+        const op = cmd.op;
+        if (op.kind === "change" && op.quantityDelta === 0) {
+            // zero quantity "change", delete
+            delete perVariant[id];
+        }
+        else if (op.kind === "set" && op.quantity <= 0) {
+            // negative or zero quantity "set", replace it with "remove"
+            perVariant[id] = {
+                order: cmd.order,
+                op: {
+                    kind: "remove",
+                    variantID: op.variantID,
+                },
+            };
+        }
+    }
+    const items = compact(Object.values(perVariant));
+    items.sort((a, b) => a.order - b.order);
+    return items.map((v) => v.op);
+}

package/esm/categorySEO.js

@@ -0,0 +1,16 @@
+import { compact } from "./compact.js";
+export function categorySEO(category) {
+    const images = compact(category.image_files);
+    return {
+        meta: [
+            { name: "title", content: category.meta_title },
+            { name: "description", content: category.meta_description },
+            // TWITTER CARD
+            { name: "twitter:card", content: "summary" },
+            { name: "twitter:title", content: category.meta_title },
+            { name: "twitter:description", content: category.meta_description },
+            // TWITTER CARD images
+            ...images.reduce((array, f) => [...array, { property: "twitter:image", content: f.public_url }], []),
+        ],
+    };
+}

package/esm/commonTypes.js

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

package/esm/compact.js

@@ -0,0 +1,4 @@
+export function compact(v) {
+    // type override is safe here, because we get rid of said values in filter function
+    return (v?.filter((v) => v !== null && v !== undefined) || []);
+}

package/esm/configLoader.js

@@ -0,0 +1,61 @@
+export function anyVar(mandatory) {
+    const v = { kind: "any", __type: undefined, mandatory };
+    return mandatory ? { kind: "mandatory", mandatory: v } : v;
+}
+// prettier-ignore
+export function stringVar(envVars, defaultValue, mandatory) {
+    const v = { kind: "string", envVars, defaultValue, mandatory };
+    return defaultValue !== undefined ? { kind: "default", default: v } : mandatory ? { kind: "mandatory", mandatory: v } : v;
+}
+// prettier-ignore
+export function booleanVar(envVars, defaultValue, mandatory) {
+    const v = { kind: "boolean", envVars, defaultValue, mandatory };
+    return defaultValue !== undefined ? { kind: "default", default: v } : mandatory ? { kind: "mandatory", mandatory: v } : v;
+}
+function varToBaseBar(v) {
+    if (v.kind === "default") {
+        return v.default;
+    }
+    else if (v.kind === "mandatory") {
+        return v.mandatory;
+    }
+    else {
+        return v;
+    }
+}
+function envVarOrUndefined(v) {
+    if (v.kind === "string" || v.kind === "boolean") {
+        for (const envKey of v.envVars) {
+            const envVal = process.env[envKey]?.trim();
+            if (envVal) {
+                if (v.kind === "string") {
+                    return envVal;
+                }
+                else {
+                    return true;
+                }
+            }
+        }
+    }
+}
+function defaultOrUndefined(v) {
+    return v.kind === "string" || v.kind === "boolean" ? v.defaultValue : undefined;
+}
+export function loadConfig(confDef, input) {
+    const out = {};
+    for (const key in confDef) {
+        const fdef = varToBaseBar(confDef[key]);
+        let val = input[key];
+        if (val === undefined) {
+            val = envVarOrUndefined(fdef);
+        }
+        if (val === undefined) {
+            val = defaultOrUndefined(fdef);
+        }
+        if (val === undefined && fdef.mandatory) {
+            throw new Error(`"${key}" config field is mandatory`);
+        }
+        out[key] = val;
+    }
+    return out;
+}

package/esm/controlledQueue.js

@@ -0,0 +1,38 @@
+export class ControlledQueue {
+    queue = [];
+    queueLoopPromise;
+    discardQueue() {
+        while (this.queue.length > 0) {
+            const item = this.queue[0];
+            this.queue.splice(0, 1);
+            item.resolve({ kind: "discarded" });
+        }
+    }
+    async queueLoop() {
+        let discard = false;
+        const controller = {
+            discard: () => {
+                discard = true;
+            },
+        };
+        while (this.queue.length > 0) {
+            const item = this.queue[0];
+            this.queue.splice(0, 1);
+            const result = await item.pfn(controller);
+            item.resolve({ kind: "resolved", value: result });
+            if (discard) {
+                discard = false;
+                this.discardQueue();
+            }
+        }
+        this.queueLoopPromise = undefined;
+    }
+    exec(pfn) {
+        return new Promise((resolve) => {
+            this.queue.push({ pfn, resolve });
+            if (!this.queueLoopPromise) {
+                this.queueLoopPromise = Promise.resolve().then(() => this.queueLoop());
+            }
+        });
+    }
+}