@lana-commerce/core 11.0.0

package/cjs/aggregateOptions.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateOptions = exports.selectVariantID = exports.restrictSelected = exports.closestVariantIDs = exports.matchVariant = void 0;
+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;
+    }
+}
+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;
+}
+exports.matchVariant = matchVariant;
+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);
+}
+exports.closestVariantIDs = closestVariantIDs;
+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));
+}
+function restrictSelected(opts, selected, key, val) {
+    var _a, _b;
+    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 = ((_a = perOptionValues[otherOpt]) === null || _a === void 0 ? void 0 : _a.find((v) => v === current)) !== undefined;
+        newSelected[otherOpt] = isValid ? current : ((_b = perOptionValues[otherOpt]) === null || _b === void 0 ? void 0 : _b[0]) || "";
+    }
+    return {
+        enabledValues: buildEnabledValues(buildPerOptionValues(opts.uniqueOptionIDs, opts.sets, (set, id) => {
+            const selected = Object.assign({}, newSelected);
+            delete selected[id];
+            return set.options.every((opt) => selected[opt.key] === undefined || opt.value === selected[opt.key]);
+        })),
+        selected: newSelected,
+        variantID: matchVariantID(opts, newSelected),
+    };
+}
+exports.restrictSelected = restrictSelected;
+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 = Object.assign({}, selected);
+            delete s[id];
+            return set.options.every((opt) => s[opt.key] === undefined || opt.value === s[opt.key]);
+        })),
+        selected,
+        variantID,
+    };
+}
+exports.selectVariantID = selectVariantID;
+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),
+    };
+}
+exports.aggregateOptions = aggregateOptions;

package/cjs/analytics.js

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

package/cjs/analyticsProductData.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyticsProductData = void 0;
+const variantPrice_js_1 = require("./variantPrice.js");
+const convertImageURL_js_1 = require("./convertImageURL.js");
+const toMajor_js_1 = require("./toMajor.js");
+const variantImage_js_1 = require("./variantImage.js");
+function analyticsProductData(env, variant, variantID) {
+    var _a, _b;
+    const priceInfo = (0, variantPrice_js_1.variantPriceInfo)(env, variant);
+    const image = (0, variantImage_js_1.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 === null || variant === void 0 ? void 0 : variant.id) || variantID || "",
+        sku: (variant === null || variant === void 0 ? void 0 : variant.sku) || "",
+        name: ((_a = variant === null || variant === void 0 ? void 0 : variant.product) === null || _a === void 0 ? void 0 : _a.title) || "",
+        price: (0, toMajor_js_1.toMajor)(env.shopCurrencies, env.currency, priceInfo.price),
+        currency: env.currency,
+        url: info ? (_b = env.canonicalVariantURL) === null || _b === void 0 ? void 0 : _b.call(env, info) : undefined,
+        image_url: (0, convertImageURL_js_1.convertImageURL)(env.cdn, image === null || image === void 0 ? void 0 : image.public_url, {
+            size: "200x200",
+            crop: "center",
+        }),
+    };
+}
+exports.analyticsProductData = analyticsProductData;

package/cjs/arrayToDict.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayToDict = void 0;
+function arrayToDict(array, key) {
+    const out = {};
+    for (const v of array) {
+        const k = key(v);
+        out[k] = v;
+    }
+    return out;
+}
+exports.arrayToDict = arrayToDict;

package/cjs/asyncModuleWrapper.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncModuleWrapper = exports.asyncImportWrapper = void 0;
+function asyncImportWrapper(load) {
+    return asyncModuleWrapper((cfg) => load().then((m) => m.load(cfg)));
+}
+exports.asyncImportWrapper = asyncImportWrapper;
+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);
+                });
+            };
+        },
+    });
+}
+exports.asyncModuleWrapper = asyncModuleWrapper;

package/cjs/averageReviewScore.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.averageReviewScore = void 0;
+const meanBy_js_1 = require("./meanBy.js");
+function averageReviewScore(product, reviewSettings) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    let overallDimID;
+    const ids = {};
+    // first consider data from the product itself
+    (_b = (_a = product.review_dimension_set) === null || _a === void 0 ? void 0 : _a.review_dimensions) === null || _b === void 0 ? void 0 : _b.forEach((rds) => {
+        const id = rds === null || rds === void 0 ? void 0 : rds.id;
+        if (id)
+            ids[id] = true;
+    });
+    overallDimID = ((_d = (_c = product.review_dimension_set) === null || _c === void 0 ? void 0 : _c.overall_review_dimension) === null || _d === void 0 ? void 0 : _d.id) || "";
+    if (Object.keys(ids).length === 0) {
+        // no data on the product? let's get default one
+        (_f = (_e = reviewSettings.default_review_dimension_set) === null || _e === void 0 ? void 0 : _e.review_dimensions) === null || _f === void 0 ? void 0 : _f.forEach((drds) => {
+            const id = drds === null || drds === void 0 ? void 0 : drds.id;
+            if (id)
+                ids[id] = true;
+        });
+        overallDimID = ((_h = (_g = reviewSettings.default_review_dimension_set) === null || _g === void 0 ? void 0 : _g.overall_review_dimension) === null || _h === void 0 ? void 0 : _h.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) => { var _a; return ((_a = s.review_dimension) === null || _a === void 0 ? void 0 : _a.id) === ""; });
+        if (rd)
+            return rd.score;
+        // if no review dimension found, let's just calc average of all
+        return (0, meanBy_js_1.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) => { var _a; return ((_a = s.review_dimension) === null || _a === void 0 ? void 0 : _a.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 (0, meanBy_js_1.meanBy)(scores, (s) => s.score);
+    }
+}
+exports.averageReviewScore = averageReviewScore;

package/cjs/buildconfig.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILD_CONFIG = void 0;
+exports.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/cjs/cachedLoader.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CachedLoader = void 0;
+const tslib_1 = require("tslib");
+class CachedLoader {
+    constructor(_loader) {
+        this._loader = _loader;
+        this._initQueue = [];
+    }
+    get value() {
+        return this._value;
+    }
+    load(a) {
+        return tslib_1.__awaiter(this, void 0, void 0, function* () {
+            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);
+        }
+    }
+}
+exports.CachedLoader = CachedLoader;

package/cjs/canonicalVariantURL.js

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

package/cjs/cartOperation.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactCartOperations = exports.filterOutNonCreateOpertions = void 0;
+const compact_js_1 = require("./compact.js");
+// Filter out all operations that are not relevant for create API.
+// This includes remove operations and non-positive quantity operations.
+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;
+}
+exports.filterOutNonCreateOpertions = filterOutNonCreateOpertions;
+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.
+function compactCartOperations(operations) {
+    var _a, _b, _c, _d;
+    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: (_a = op.subscriptionPlanIndex) !== null && _a !== void 0 ? _a : last.op.subscriptionPlanIndex,
+                        customItemIndex: (_b = op.customItemIndex) !== null && _b !== void 0 ? _b : 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: (_c = op.subscriptionPlanIndex) !== null && _c !== void 0 ? _c : last.op.subscriptionPlanIndex,
+                        customItemIndex: (_d = op.customItemIndex) !== null && _d !== void 0 ? _d : 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 = (0, compact_js_1.compact)(Object.values(perVariant));
+    items.sort((a, b) => a.order - b.order);
+    return items.map((v) => v.op);
+}
+exports.compactCartOperations = compactCartOperations;

package/cjs/categorySEO.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.categorySEO = void 0;
+const compact_js_1 = require("./compact.js");
+function categorySEO(category) {
+    const images = (0, compact_js_1.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 }], []),
+        ],
+    };
+}
+exports.categorySEO = categorySEO;

package/cjs/commonTypes.js

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

package/cjs/compact.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compact = void 0;
+function compact(v) {
+    // type override is safe here, because we get rid of said values in filter function
+    return ((v === null || v === void 0 ? void 0 : v.filter((v) => v !== null && v !== undefined)) || []);
+}
+exports.compact = compact;