@lana-commerce/core 11.0.0

package/cjs/typedLocalStorage.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveToLocalStorageTyped = exports.loadFromLocalStorageTyped = void 0;
+const tslib_1 = require("tslib");
+const ss = tslib_1.__importStar(require("superstruct"));
+function loadFromLocalStorageTyped(key, type) {
+    try {
+        const str = localStorage.getItem(key);
+        if (str) {
+            const rawJSON = JSON.parse(str);
+            const r = ss.validate(rawJSON, type);
+            if (r[0]) {
+                return undefined;
+            }
+            else {
+                return r[1];
+            }
+        }
+    }
+    catch (_a) { }
+    return undefined;
+}
+exports.loadFromLocalStorageTyped = loadFromLocalStorageTyped;
+function saveToLocalStorageTyped(key, v) {
+    try {
+        localStorage.setItem(key, JSON.stringify(v));
+    }
+    catch (_a) { }
+}
+exports.saveToLocalStorageTyped = saveToLocalStorageTyped;

package/cjs/variantImage.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantImage = void 0;
+const media_js_1 = require("./media.js");
+function variantImageFromList(list) {
+    if (!list)
+        return undefined;
+    for (const f of list) {
+        if (!f)
+            continue;
+        const { file, thumbnail_file } = f;
+        if (file && media_js_1.supportedImageMIMEs[file.mime] && file.public_url) {
+            return file;
+        }
+        if (thumbnail_file && thumbnail_file.public_url) {
+            return thumbnail_file;
+        }
+    }
+    return undefined;
+}
+function variantImage(v) {
+    if (!v)
+        return undefined;
+    return variantImageFromList(v.media_files) || variantImageFromList(v.linked_media_files);
+}
+exports.variantImage = variantImage;

package/cjs/variantImageURL.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantImageURL = void 0;
+const convertImageURL_js_1 = require("./convertImageURL.js");
+const variantImage_js_1 = require("./variantImage.js");
+function variantImageURL(cdn, v, params) {
+    const image = (0, variantImage_js_1.variantImage)(v);
+    if (!image) {
+        return (0, convertImageURL_js_1.convertImageURL)(cdn, null, params);
+    }
+    return (0, convertImageURL_js_1.convertImageURL)(cdn, image.public_url, params);
+}
+exports.variantImageURL = variantImageURL;

package/cjs/variantImages.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantImages = void 0;
+const media_js_1 = require("./media.js");
+function variantImages(v) {
+    if (!v || !v.media_files)
+        return [];
+    const out = [];
+    for (const f of v.media_files) {
+        if (!f)
+            continue;
+        const { file } = f;
+        if (file && media_js_1.supportedImageMIMEs[file.mime] && file.public_url) {
+            out.push(file);
+        }
+    }
+    return out;
+}
+exports.variantImages = variantImages;

package/cjs/variantInventory.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantInventory = void 0;
+function greaterThanZero(v) {
+    if (v === undefined)
+        return v;
+    return Math.max(0, v);
+}
+function variantInventory(v) {
+    var _a, _b, _c;
+    if (!v)
+        return { status: "available", available: undefined };
+    const available = greaterThanZero((_a = v.inventory) === null || _a === void 0 ? void 0 : _a.available);
+    if (v.inventory_policy === "deny") {
+        if (available === undefined || available <= 0) {
+            // available === undefined || available <= 0
+            return { status: "sold_out", available: 0 };
+        }
+        else if ((_b = v.inventory) === null || _b === void 0 ? void 0 : _b.low_stock) {
+            // available > 0
+            return { status: "low_stock", available };
+        }
+        else {
+            // available > 0
+            return { status: "in_stock", available };
+        }
+    }
+    else {
+        if (available === undefined || available <= 0) {
+            // available === undefined || available <= 0
+            return { status: "available", available };
+        }
+        else if ((_c = v.inventory) === null || _c === void 0 ? void 0 : _c.low_stock) {
+            // available > 0
+            return { status: "low_stock", available };
+        }
+        else {
+            // available > 0
+            return { status: "in_stock", available };
+        }
+    }
+}
+exports.variantInventory = variantInventory;

package/cjs/variantOptions.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantOptionsSuffix = exports.variantOptions = exports.variantOptionsWithName = void 0;
+function variantOptionsWithName(v, separator = ": ") {
+    const opts = v === null || v === void 0 ? void 0 : v.options;
+    if (!opts || opts.length === 0)
+        return [];
+    return opts.map((opt) => `${opt.option_name || opt.option_id}${separator}${opt.option_value_name || opt.option_value_id}`);
+}
+exports.variantOptionsWithName = variantOptionsWithName;
+function variantOptions(v, separator = " / ") {
+    return v && v.options && v.options.length
+        ? v.options.map((opt) => opt.option_value_name || opt.option_value_id).join(separator)
+        : "";
+}
+exports.variantOptions = variantOptions;
+function variantOptionsSuffix(v, separator = " / ") {
+    const opts = variantOptions(v, separator);
+    return opts ? ` (${opts})` : "";
+}
+exports.variantOptionsSuffix = variantOptionsSuffix;

package/cjs/variantPrice.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantPriceInfo = void 0;
+const toMajor_js_1 = require("./toMajor.js");
+function convertCurrency(env, value) {
+    const to = env.shopCurrencies[env.currency];
+    if (!to) {
+        console.warn(`failed converting price from ${env.shopCurrency} to ${env.currency}, destination currency info is missing`);
+        return value;
+    }
+    const major = (0, toMajor_js_1.toMajor)(env.shopCurrencies, env.shopCurrency, value);
+    if (major === undefined) {
+        console.warn(`failed converting price from ${env.shopCurrency} to ${env.currency}, source currency info is missing`);
+        return value;
+    }
+    const xrate = to.custom_exchange_rate || to.exchange_rate;
+    const v = Math.ceil(major * xrate * to.currency.to_minor);
+    return v + Math.ceil(v * (to.conversion_fee || 0));
+}
+function salePriceOrPrice(salePriceEligible, pi, tieredPricing) {
+    return salePriceEligible
+        ? { sale: true, price: pi.sale_price, previousPrice: pi.price, hide: pi.sale_price < pi.map_price, tieredPricing }
+        : { sale: false, price: pi.price, previousPrice: pi.retail_price, hide: pi.price < pi.map_price, tieredPricing };
+}
+function variantPriceInfoImpl(env, p) {
+    if (!p)
+        return { sale: false, price: 0, previousPrice: 0, hide: false, tieredPricing: undefined };
+    const defaultPrice = salePriceOrPrice(p.sale_price_eligible, p, p.tiered_pricing || undefined);
+    if (env.currency !== env.shopCurrency) {
+        // secondary currency, has priority over customer group prices
+        const cp = p.currency_prices.find((cp) => cp.currency === env.currency);
+        if (cp)
+            return salePriceOrPrice(p.sale_price_eligible, cp, cp.tiered_pricing || undefined);
+        // okay, when there is no provided currency price, we have to perform the conversion
+        defaultPrice.price = convertCurrency(env, defaultPrice.price);
+        defaultPrice.previousPrice = convertCurrency(env, defaultPrice.previousPrice);
+        if (defaultPrice.tieredPricing) {
+            const tp = defaultPrice.tieredPricing;
+            defaultPrice.tieredPricing = {
+                model: tp.model,
+                tiers: tp.tiers.map((t) => ({
+                    from: t.from,
+                    to: t.to,
+                    price: convertCurrency(env, t.price),
+                })),
+            };
+        }
+        return defaultPrice;
+    }
+    if (p.customer_group_price !== 0) {
+        return {
+            sale: false,
+            price: p.customer_group_price,
+            previousPrice: 0,
+            hide: false,
+            tieredPricing: p.tiered_pricing || undefined,
+        };
+    }
+    else {
+        return defaultPrice;
+    }
+}
+function applySubscriptionPlanPricing(oldPrice, plan, isShopCurrency) {
+    if (plan.price1_type === "price") {
+        if (isShopCurrency) {
+            return plan.price1;
+        }
+        else {
+            // we can't override non-shop currency with this price
+            return oldPrice;
+        }
+    }
+    else if (plan.price1_type === "fixed_off") {
+        return Math.max(0, oldPrice - plan.price1);
+    }
+    else if (plan.price1_type === "percentage_off") {
+        const off = Math.round(oldPrice * (plan.price1_percentage / 100));
+        return Math.max(0, oldPrice - off);
+    }
+    else {
+        return oldPrice;
+    }
+}
+function variantPriceInfo(env, p, plan) {
+    const vp = variantPriceInfoImpl(env, p);
+    if (plan) {
+        const newPrice = applySubscriptionPlanPricing(vp.price, plan, env.currency === env.shopCurrency);
+        if (vp.previousPrice === 0 && newPrice !== vp.price) {
+            vp.previousPrice = vp.price;
+        }
+        vp.price = newPrice;
+        vp.tieredPricing = undefined; // tiered pricing is not allowed for subscription-based items
+    }
+    return vp;
+}
+exports.variantPriceInfo = variantPriceInfo;

package/cjs/variantPriceCommerce.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantPriceInfo = void 0;
+const variantPrice_js_1 = require("./variantPrice.js");
+function variantLikeToStorefrontVariantPricer(v, customerGroupID) {
+    let tiered_pricing = v.tiered_pricing;
+    let customer_group_price = 0;
+    for (const c of v.customer_group_prices) {
+        if (c.customer_group && c.customer_group.id === customerGroupID) {
+            customer_group_price = c.price;
+            tiered_pricing = c.tiered_pricing;
+        }
+    }
+    return {
+        price: v.price,
+        customer_group_price,
+        sale_price: v.sale_price,
+        sale_price_eligible: v.sale_price_eligible,
+        retail_price: v.retail_price,
+        map_price: v.map_price,
+        currency_prices: v.currency_prices,
+        tiered_pricing,
+    };
+}
+function variantPriceInfo(env, variant, customerGroupID) {
+    const v = variantLikeToStorefrontVariantPricer(variant, customerGroupID);
+    return (0, variantPrice_js_1.variantPriceInfo)(env, v);
+}
+exports.variantPriceInfo = variantPriceInfo;

package/cjs/variantTitle.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantTitle = void 0;
+function variantTitle(t) {
+    if (t && t.product)
+        return t.product.title;
+    return "";
+}
+exports.variantTitle = variantTitle;

package/cjs/variantTitleFull.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantTitleFull = void 0;
+const variantOptions_js_1 = require("./variantOptions.js");
+const variantTitle_js_1 = require("./variantTitle.js");
+function variantTitleFull(t, placeholder = "—", separator = " / ") {
+    const title = (0, variantTitle_js_1.variantTitle)(t) || placeholder;
+    const opts = (0, variantOptions_js_1.variantOptions)(t, separator);
+    return opts ? `${title} (${opts})` : title;
+}
+exports.variantTitleFull = variantTitleFull;

package/cjs/variantURL.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.variantURL = void 0;
+function variantURL(baseURL, t) {
+    if (t && t.product)
+        return `${baseURL}/products/${t.product.handle}`;
+    return "";
+}
+exports.variantURL = variantURL;

package/cjs/vendor/popper/index.d.ts

@@ -0,0 +1,160 @@
+/**
+ * @fileoverview This file only declares the public portions of the API.
+ * It should not define internal pieces such as utils or modifier details.
+ *
+ * Original definitions by: edcarroll <https://github.com/edcarroll>, ggray <https://github.com/giladgray>, rhysd <https://rhysd.github.io>, joscha <https://github.com/joscha>, seckardt <https://github.com/seckardt>, marcfallows <https://github.com/marcfallows>
+ */
+
+/**
+ * This kind of namespace declaration is not necessary, but is kept here for backwards-compatibility with
+ * popper.js 1.x. It can be removed in 2.x so that the default export is simply the Popper class
+ * and all the types / interfaces are top-level named exports.
+ */
+declare namespace Popper {
+  export type Position = "top" | "right" | "bottom" | "left";
+
+  export type Placement =
+    | "auto-start"
+    | "auto"
+    | "auto-end"
+    | "top-start"
+    | "top"
+    | "top-end"
+    | "right-start"
+    | "right"
+    | "right-end"
+    | "bottom-end"
+    | "bottom"
+    | "bottom-start"
+    | "left-end"
+    | "left"
+    | "left-start";
+
+  export type Boundary = "scrollParent" | "viewport" | "window";
+
+  export type Behavior = "flip" | "clockwise" | "counterclockwise";
+
+  export type ModifierFn = (data: Data, options: Object) => Data;
+
+  export interface BaseModifier {
+    order?: number;
+    enabled?: boolean;
+    fn?: ModifierFn;
+  }
+
+  export interface Modifiers {
+    shift?: BaseModifier;
+    offset?: BaseModifier & {
+      offset?: number | string;
+    };
+    preventOverflow?: BaseModifier & {
+      priority?: Position[];
+      padding?: number;
+      boundariesElement?: Boundary | Element;
+      escapeWithReference?: boolean;
+    };
+    keepTogether?: BaseModifier;
+    arrow?: BaseModifier & {
+      element?: string | Element;
+    };
+    flip?: BaseModifier & {
+      behavior?: Behavior | Position[];
+      padding?: number;
+      boundariesElement?: Boundary | Element;
+    };
+    inner?: BaseModifier;
+    hide?: BaseModifier;
+    applyStyle?: BaseModifier & {
+      onLoad?: Function;
+      gpuAcceleration?: boolean;
+    };
+    computeStyle?: BaseModifier & {
+      gpuAcceleration?: boolean;
+      x?: "bottom" | "top";
+      y?: "left" | "right";
+    };
+
+    [name: string]: (BaseModifier & Record<string, any>) | undefined;
+  }
+
+  export interface Offset {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+  }
+
+  export interface Data {
+    instance: Popper;
+    placement: Placement;
+    originalPlacement: Placement;
+    flipped: boolean;
+    hide: boolean;
+    arrowElement: Element;
+    styles: CSSStyleDeclaration;
+    boundaries: Object;
+    offsets: {
+      popper: Offset;
+      reference: Offset;
+      arrow: {
+        top: number;
+        left: number;
+      };
+    };
+  }
+
+  export interface PopperOptions {
+    placement?: Placement;
+    positionFixed?: boolean;
+    eventsEnabled?: boolean;
+    modifiers?: Modifiers;
+    removeOnDestroy?: boolean;
+
+    onCreate?(data: Data): void;
+
+    onUpdate?(data: Data): void;
+  }
+
+  export interface ReferenceObject {
+    clientHeight: number;
+    clientWidth: number;
+
+    getBoundingClientRect(): ClientRect;
+  }
+}
+
+// Re-export types in the Popper namespace so that they can be accessed as top-level named exports.
+// These re-exports should be removed in 2.x when the "declare namespace Popper" syntax is removed.
+export type Position = Popper.Position;
+export type Placement = Popper.Placement;
+export type Boundary = Popper.Boundary;
+export type Behavior = Popper.Behavior;
+export type ModifierFn = Popper.ModifierFn;
+export type BaseModifier = Popper.BaseModifier;
+export type Modifiers = Popper.Modifiers;
+export type Offset = Popper.Offset;
+export type Data = Popper.Data;
+export type PopperOptions = Popper.PopperOptions;
+export type ReferenceObject = Popper.ReferenceObject;
+
+declare class Popper {
+  static modifiers: (BaseModifier & { name: string })[];
+  static placements: Placement[];
+  static Defaults: PopperOptions;
+
+  options: PopperOptions;
+
+  constructor(reference: Element | ReferenceObject, popper: Element, options?: PopperOptions);
+
+  destroy(): void;
+
+  update(): void;
+
+  scheduleUpdate(): void;
+
+  enableEventListeners(): void;
+
+  disableEventListeners(): void;
+}
+
+export default Popper;