@lana-commerce/core 11.0.0

package/types/aggregateOptions.d.ts

@@ -0,0 +1,33 @@
+import type { Dict } from "./commonTypes.js";
+export interface VariantLike {
+    id: string;
+    options: {
+        option_id: string;
+        option_value_id: string;
+    }[];
+}
+export interface Option {
+    key: string;
+    value: string;
+}
+export interface OptionSet {
+    variantID: string;
+    options: Option[];
+}
+export interface AggregatedOptions {
+    uniqueOptionIDs: string[];
+    sets: OptionSet[];
+    perOptionValues: Dict<string[]>;
+    enabledValues: Dict<Dict<boolean>>;
+}
+export declare function matchVariant<T extends VariantLike>(variants: T[], selected: Dict<string>): T | undefined;
+export declare function closestVariantIDs(opts: AggregatedOptions, selected: Dict<string>): string[];
+interface State {
+    enabledValues: Dict<Dict<boolean>>;
+    selected: Dict<string>;
+    variantID: string;
+}
+export declare function restrictSelected(opts: AggregatedOptions, selected: Dict<string>, key: string, val: string): State;
+export declare function selectVariantID(opts: AggregatedOptions, variantID: string): State;
+export declare function aggregateOptions(variants: VariantLike[]): AggregatedOptions;
+export {};

package/types/analytics.d.ts

@@ -0,0 +1,23 @@
+import type { AnalyticsProductData } from "./analyticsProductData.js";
+export declare function identify(id: string): void;
+export interface AnalyticsPromotionData {
+    promotion_id: string;
+    name?: string;
+    creative?: string;
+    position?: string;
+}
+export declare function promotionClicked(promotion: AnalyticsPromotionData): void;
+export declare function productClicked(product: AnalyticsProductData): void;
+export declare function productsSearched(query: string): void;
+export interface CartLineItem {
+    quantity: number;
+    product: AnalyticsProductData;
+}
+export declare function cartViewed(orderID: string, products: CartLineItem[]): void;
+export declare function productListViewed(categoryID: string, categoryName: string, products: AnalyticsProductData[]): void;
+export declare function productViewed(product: AnalyticsProductData): void;
+export declare function wishlistAdded(product: AnalyticsProductData): void;
+export declare function wishlistRemoved(product: AnalyticsProductData): void;
+export declare function productAdded(orderID: string, quantity: number, product: AnalyticsProductData): void;
+export declare function productRemoved(orderID: string, quantity: number, product: AnalyticsProductData): void;
+export declare function page(): void;

package/types/analyticsProductData.d.ts

@@ -0,0 +1,38 @@
+import type { CanonicalVariantURLFunc } from "./canonicalVariantURL.js";
+import type { CurrencyFragment } from "./graphql/types.js";
+import type { Dict } from "./commonTypes.js";
+import { VariantPricer } from "./variantPrice.js";
+export interface VariantLike extends VariantPricer {
+    id: string;
+    sku: string;
+    product: {
+        id: string;
+        title: string;
+        handle: string;
+    } | null;
+    media_files: ({
+        file: {
+            public_url: string;
+            mime: string;
+        } | null;
+    } | null)[] | null;
+}
+export interface AnalyticsProductData {
+    product_id: string;
+    sku: string;
+    category?: string;
+    name: string;
+    price?: number;
+    currency: string;
+    url?: string;
+    image_url: string;
+}
+interface Environment {
+    cdn: string;
+    currency: string;
+    shopCurrency: string;
+    shopCurrencies: Dict<CurrencyFragment>;
+    canonicalVariantURL: CanonicalVariantURLFunc | null;
+}
+export declare function analyticsProductData(env: Environment, variant: VariantLike | null | undefined, variantID?: string): AnalyticsProductData;
+export {};

package/types/arrayToDict.d.ts

@@ -0,0 +1,2 @@
+import type { Dict } from "./commonTypes.js";
+export declare function arrayToDict<T>(array: T[], key: (v: T) => string): Dict<T>;

package/types/asyncModuleWrapper.d.ts

@@ -0,0 +1,13 @@
+export interface Import<Config, M> {
+    load(v: Config): Promise<M> | M;
+}
+export type MethodsOnly<T extends object> = Pick<T, {
+    [K in keyof T]-?: T[K] extends (...args: any) => any ? K : never;
+}[keyof T]>;
+export type ModuleWrapper<Config, M extends object> = MethodsOnly<M> & {
+    load(v: Config): void;
+    loadOnce(v: Config): Promise<M>;
+    afterLoad(): Promise<M>;
+};
+export declare function asyncImportWrapper<Config, M extends object>(load: () => Promise<Import<Config, M>>): ModuleWrapper<Config, M>;
+export declare function asyncModuleWrapper<Config, M extends object>(load: (v: Config) => Promise<M>): ModuleWrapper<Config, M>;

package/types/averageReviewScore.d.ts

@@ -0,0 +1,28 @@
+interface ReviewDimension {
+    id: string;
+    name: string;
+}
+interface ReviewDimensionSet {
+    id: string;
+    name: string;
+    overall_review_dimension: ReviewDimension | null;
+    review_dimensions: Array<ReviewDimension | null> | null;
+}
+interface ReviewSettingsLike {
+    default_review_dimension_set: ReviewDimensionSet | null;
+}
+interface ProductLike {
+    review_dimension_set: ReviewDimensionSet | null;
+    average_scores: {
+        count: number;
+        histogram: Array<{
+            key: string;
+            value: string;
+        }>;
+        review_dimension: ReviewDimension | null;
+        score: number;
+        sum: number;
+    }[];
+}
+export declare function averageReviewScore(product: ProductLike, reviewSettings: ReviewSettingsLike): number;
+export {};

package/types/buildconfig.d.ts

@@ -0,0 +1,13 @@
+export declare const BUILD_CONFIG: {
+    ANALYTICS_INTEGRATION_NAME: string;
+    API_URL: string;
+    APP_DOMAIN: string;
+    BEACON_URL: string;
+    CDN_URL: string;
+    SLATE_CLASS_PREFIX: string;
+    UI_LIB_GLOBAL: string;
+    UI_LIB: string;
+    WS_URL: string;
+    POPUP_CONNECT_QUEUE_KEY: string;
+    AUTH_KEY: string;
+};

package/types/cachedLoader.d.ts

@@ -0,0 +1,10 @@
+export declare class CachedLoader<T, A = void> {
+    private _loader;
+    private _promise;
+    private _value;
+    private _initQueue;
+    constructor(_loader: (a: A) => Promise<T>);
+    get value(): T | undefined;
+    load(a: A): Promise<T>;
+    onLoad(callback: (v: T) => void): void;
+}

package/types/canonicalVariantURL.d.ts

@@ -0,0 +1,12 @@
+export interface CanonicalVariantURLInfo {
+    variantID: string;
+    variantSKU: string;
+    productID: string;
+    productHandle: string;
+}
+export type CanonicalVariantURLFunc = (info: CanonicalVariantURLInfo) => string;
+export type GoToVariantFunc = (info: CanonicalVariantURLInfo) => void;
+export interface Hooks {
+    goToVariant: GoToVariantFunc | null;
+    canonicalVariantURL: CanonicalVariantURLFunc | null;
+}

package/types/cartOperation.d.ts

@@ -0,0 +1,28 @@
+import type { LineItemFieldCreate } from "./graphql/types.js";
+export interface CartChangeOperation<Variant> {
+    kind: "change";
+    variantID: string;
+    variant: Variant | undefined;
+    quantityDelta: number;
+    fieldSetID?: string;
+    fields?: LineItemFieldCreate[];
+    subscriptionPlanIndex?: number;
+    customItemIndex?: number;
+}
+export interface CartSetOperation<Variant> {
+    kind: "set";
+    variantID: string;
+    variant: Variant | undefined;
+    quantity: number;
+    fieldSetID?: string;
+    fields?: LineItemFieldCreate[];
+    subscriptionPlanIndex?: number;
+    customItemIndex?: number;
+}
+export interface CartRemoveOperation {
+    kind: "remove";
+    variantID: string;
+}
+export type CartOperation<Variant> = CartChangeOperation<Variant> | CartSetOperation<Variant> | CartRemoveOperation;
+export declare function filterOutNonCreateOpertions<Variant>(ops: CartOperation<Variant>[]): CartSetOperation<Variant>[];
+export declare function compactCartOperations<Variant>(operations: CartOperation<Variant>[]): CartOperation<Variant>[];

package/types/categorySEO.d.ts

@@ -0,0 +1,17 @@
+import type { SEOMeta } from "./seo.js";
+interface CategoryLike {
+    id: string;
+    handle: string;
+    image_files: Array<{
+        id: string;
+        mime: string;
+        public_url: string;
+    } | null> | null;
+    meta_description: string;
+    meta_title: string;
+}
+export interface CategorySEO {
+    meta: SEOMeta[];
+}
+export declare function categorySEO(category: CategoryLike): CategorySEO | undefined;
+export {};

package/types/commonTypes.d.ts

@@ -0,0 +1,10 @@
+export type Dict<T> = {
+    [key: string]: T | undefined;
+};
+export type EnumDict<K extends string, T> = {
+    [KK in K]: T;
+};
+export interface ListItem {
+    value: string;
+    label: string;
+}

package/types/compact.d.ts

@@ -0,0 +1 @@
+export declare function compact<T>(v: (T | null | undefined)[] | null | undefined): T[];

package/types/configLoader.d.ts

@@ -0,0 +1,53 @@
+export interface Boolean {
+    kind: "boolean";
+    envVars: string[];
+    defaultValue?: boolean;
+    mandatory?: boolean;
+}
+export interface String {
+    kind: "string";
+    envVars: string[];
+    defaultValue?: string;
+    mandatory?: boolean;
+}
+export interface Any<T> {
+    kind: "any";
+    mandatory?: boolean;
+    __type: T;
+}
+export type BaseVar = Any<any> | String | Boolean;
+export type Mandatory<T extends BaseVar> = {
+    kind: "mandatory";
+    mandatory: T;
+};
+export type Default<T extends BaseVar> = {
+    kind: "default";
+    default: T;
+};
+export type Var = Mandatory<any> | Default<any> | BaseVar;
+export declare function anyVar<T>(mandatory?: false): Any<T>;
+export declare function anyVar<T>(mandatory: true): Mandatory<Any<T>>;
+export declare function stringVar(envVars: string[], defaultValue?: undefined, mandatory?: false): String;
+export declare function stringVar(envVars: string[], defaultValue: undefined, mandatory: true): Mandatory<String>;
+export declare function stringVar(envVars: string[], defaultValue: string, mandatory?: boolean): Default<String>;
+export declare function booleanVar(envVars: string[], defaultValue?: undefined, mandatory?: false): Boolean;
+export declare function booleanVar(envVars: string[], defaultValue: undefined, mandatory: true): Mandatory<Boolean>;
+export declare function booleanVar(envVars: string[], defaultValue: boolean, mandatory?: boolean): Default<Boolean>;
+type BaseType<T> = T extends String ? string : T extends Boolean ? boolean : T extends Any<infer U> ? U : never;
+type FieldType<F> = F extends Mandatory<infer T> ? BaseType<T> : F extends Default<infer T> ? BaseType<T> : BaseType<F> | undefined;
+type InpufFieldType<A> = FieldType<A> | undefined;
+type Optionalize<S extends object> = OmitBy<S, undefined> & Partial<PickBy<S, undefined>>;
+type OmitBy<T, V> = Omit<T, {
+    [K in keyof T]: V extends Extract<T[K], V> ? K : never;
+}[keyof T]>;
+type PickBy<T, V> = Pick<T, {
+    [K in keyof T]: V extends Extract<T[K], V> ? K : never;
+}[keyof T]>;
+export type ConfigType<C> = Optionalize<{
+    [K in keyof C]: FieldType<C[K]>;
+}>;
+export type InputConfigType<C> = Optionalize<{
+    [K in keyof C]: InpufFieldType<C[K]>;
+}>;
+export declare function loadConfig<CD extends Record<string, Var>>(confDef: CD, input: InputConfigType<CD>): ConfigType<CD>;
+export {};

package/types/controlledQueue.d.ts

@@ -0,0 +1,17 @@
+type TaskResult<T> = {
+    kind: "resolved";
+    value: T;
+} | {
+    kind: "discarded";
+};
+interface QueueController {
+    discard(): void;
+}
+export declare class ControlledQueue {
+    private queue;
+    private queueLoopPromise;
+    private discardQueue;
+    private queueLoop;
+    exec<T>(pfn: (controller: QueueController) => Promise<T>): Promise<TaskResult<T>>;
+}
+export {};

package/types/convertImageURL.d.ts

@@ -0,0 +1,9 @@
+type ImageCrop = "top" | "right" | "bottom" | "left" | "center" | "top_left" | "top_right" | "bottom_left" | "bottom_right" | "left_top" | "right_top" | "left_bottom" | "right_bottom";
+export interface ImageParams {
+    size?: string;
+    crop?: ImageCrop;
+    scale?: 2 | 3;
+    low?: boolean;
+}
+export declare function convertImageURL(cdnBaseURL: string, url: string | null | undefined, p: ImageParams): string;
+export {};

package/types/dataLoader.d.ts

@@ -0,0 +1,301 @@
+import { AbstractOp, GraphQLOpts } from "./request.js";
+import { AnalyticsEmbedInfo } from "./script.js";
+import type { BrandingFieldType, CustomerOAuthProviderKind, InventoryPolicy, TieredPricingModel } from "./json/storefrontTypes.js";
+import type { Dict } from "./commonTypes.js";
+interface TieredPricing {
+    model: TieredPricingModel;
+    tiers: Array<{
+        from: number;
+        price: number;
+        to: number;
+    }>;
+}
+interface File {
+    id: string;
+    image_alt: string;
+    image_color: string;
+    image_height: number;
+    image_width: number;
+    mime: string;
+    public_url: string;
+}
+interface Language {
+    code: string;
+    id: string;
+    name: string;
+    name_en: string;
+    name_native: string;
+}
+export interface CategoryBrief {
+    id: string;
+    parentID: string;
+    title: string;
+    relativeUrl: string;
+    featured: boolean;
+    quantity: number;
+    imageUrl?: string;
+}
+export interface VariantBrief {
+    currency_prices: Array<{
+        currency: string;
+        map_price: number;
+        price: number;
+        retail_price: number;
+        sale_price: number;
+        tiered_pricing: TieredPricing | null;
+    }>;
+    customer_group_price: number;
+    id: string;
+    inventory: {
+        available: number;
+        low_stock: boolean;
+        locations: {
+            available: number;
+            low_stock: boolean;
+            inventory_location: {
+                id: string;
+            } | null;
+        }[];
+    } | null;
+    inventory_policy: InventoryPolicy;
+    is_default: boolean;
+    map_price: number;
+    media_files: Array<{
+        file: File | null;
+        thumbnail_file: File | null;
+    }>;
+    options: Array<{
+        option_id: string;
+        option_value_id: string;
+    }>;
+    price: number;
+    retail_price: number;
+    sale_price: number;
+    sale_price_eligible: boolean;
+    sku: string;
+    tiered_pricing: TieredPricing | null;
+}
+export interface ProductBrief {
+    id: string;
+    handle: string;
+    title: string;
+    variants: Array<VariantBrief | null> | null;
+    average_score: number;
+    review_count: number;
+}
+interface Page<T> {
+    items: T[];
+    last_key: string;
+}
+export type Modify<T, R> = Omit<T, keyof R> & R;
+export type CategoryRecursive<T> = Modify<T, {
+    children: CategoryRecursive<T>[];
+}>;
+interface CategoryReq {
+    id: string;
+    title: string;
+    featured: boolean;
+    handle: string;
+    has_children: boolean;
+    image_files: ({
+        public_url: string;
+    } | null)[] | null;
+}
+interface ProductReq {
+    id: string;
+    title: string;
+    handle: string;
+    average_score: number;
+    review_count: number;
+    categories: ({
+        id: string;
+    } | null)[] | null;
+    variants: (VariantReq | null)[] | null;
+}
+interface VariantReq {
+    currency_prices: VariantBrief["currency_prices"];
+    customer_group_price: VariantBrief["customer_group_price"];
+    id: VariantBrief["id"];
+    inventory: VariantBrief["inventory"];
+    inventory_policy: VariantBrief["inventory_policy"];
+    is_default: VariantBrief["is_default"];
+    map_price: VariantBrief["map_price"];
+    media_files: VariantBrief["media_files"];
+    options: VariantBrief["options"];
+    price: VariantBrief["price"];
+    retail_price: VariantBrief["retail_price"];
+    sale_price: VariantBrief["sale_price"];
+    sale_price_eligible: VariantBrief["sale_price_eligible"];
+    sku: VariantBrief["sku"];
+    tiered_pricing: VariantBrief["tiered_pricing"];
+}
+interface BrandingReq {
+    fields: Array<{
+        boolean: boolean | null;
+        color: string | null;
+        font: string | null;
+        id: string;
+        image_file: File | null;
+        link: string | null;
+        radio: string | null;
+        string: string | null;
+        text: string | null;
+        type: BrandingFieldType;
+    }>;
+}
+interface ShopReq {
+    app_domain: string;
+    created_at: string;
+    currency: string;
+    customer_oauth_providers: Array<{
+        client_id: string;
+        kind: CustomerOAuthProviderKind;
+    }>;
+    customer_service_email: string;
+    id: string;
+    name: string;
+    primary_domain: {
+        domain: string;
+        id: string;
+    } | null;
+    product_review_enabled: boolean;
+    tax_label: string;
+    timezone: string;
+    language: Language | null;
+    languages: Array<Language | null> | null;
+    tips_enabled: boolean;
+    tips_variant: {
+        id: string;
+    } | null;
+}
+interface CurrencyReq {
+    currency: {
+        code: string;
+    };
+}
+interface ReviewDimensionReq {
+    id: string;
+}
+interface OptionReq {
+    id: string;
+}
+interface InventoryLocationReq {
+    id: string;
+}
+interface AdditionalDataContext<ContentBlock, Menu> {
+    menus: Menu[];
+    contentBlocks: ContentBlock[];
+}
+interface LoadConfig<Branding extends BrandingReq, Category extends CategoryReq, ContentBlock, Currency extends CurrencyReq, Gateway, InventoryLocation extends InventoryLocationReq, Menu, Option extends OptionReq, Product extends ProductReq, ReviewDimension extends ReviewDimensionReq, ReviewSettings, Shop extends ShopReq, AdditionalLocaleData, AdditionalShopData> {
+    graphql: {
+        getBrandingQuery: AbstractOp<{
+            branding: Branding | null;
+        }, {
+            shopID: string;
+        }>;
+        getCategoriesQuery: AbstractOp<{
+            categories: Category[] | null;
+        }, {
+            shopID: string;
+            ids?: string[] | null;
+            childrenOf?: string | null;
+        }>;
+        getContentBlocksPageQuery: AbstractOp<{
+            page: Page<ContentBlock> | null;
+        }, {
+            shopID: string;
+            limit: number;
+            lastKey: string;
+        }>;
+        getGatewaysQuery: AbstractOp<{
+            gateways: Gateway[] | null;
+        }, {
+            shopID: string;
+        }>;
+        getInventoryLocationsQuery: AbstractOp<{
+            inventoryLocations: InventoryLocation[] | null;
+        }, {
+            shopID: string;
+        }>;
+        getMenusPageQuery: AbstractOp<{
+            page: Page<Menu> | null;
+        }, {
+            shopID: string;
+            limit: number;
+            lastKey: string;
+        }>;
+        getOptionsQuery: AbstractOp<{
+            options: Option[] | null;
+        }, {
+            shopID: string;
+        }>;
+        getProductsPageQuery: AbstractOp<{
+            page: Page<Product> | null;
+        }, {
+            shopID: string;
+            limit: number;
+            lastKey: string;
+        }>;
+        getReviewDimensionsQuery: AbstractOp<{
+            reviewDimensions: ReviewDimension[] | null;
+        }, {
+            shopID: string;
+        }>;
+        getReviewSettingsQuery: AbstractOp<{
+            reviewSettings: ReviewSettings | null;
+        }, {
+            shopID: string;
+        }>;
+        getShopCurrenciesQuery: AbstractOp<{
+            currencies: Currency[] | null;
+        }, {
+            shopID: string;
+        }>;
+        getShopQuery: AbstractOp<{
+            shops: Shop[] | null;
+        }, {
+            shopID: string;
+        }>;
+    };
+    shopID: string;
+    cdn: string;
+    beacon: string;
+    staticData: boolean;
+    resolveAdditionalLocaleData: (ctx: AdditionalDataContext<ContentBlock, Menu>) => AdditionalLocaleData;
+    resolveAdditionalShopData: (ctx: AdditionalDataContext<ContentBlock, Menu>) => AdditionalShopData;
+    opts?: GraphQLOpts<any>;
+    siteUrl?: string;
+}
+export type LocaleData<Branding, Category, ContentBlock, Currency, Gateway, InventoryLocation, Option, Product, ReviewDimension, ReviewSettings, Shop, AdditionalLocaleData, AdditionalShopData> = {
+    isDefault: boolean;
+    locale: string;
+    shopData: ShopData<Gateway, InventoryLocation, Option, ReviewDimension, ReviewSettings, Currency, Shop, AdditionalShopData>;
+    products: Product[];
+    productsBrief: Dict<ProductBrief>;
+    contentBlocks: ContentBlock[];
+    categories: CategoryRecursive<Category>[];
+    branding: Branding;
+    gateways: Gateway[];
+    analytics: AnalyticsEmbedInfo;
+} & AdditionalLocaleData;
+export type ShopData<Gateway, InventoryLocation, Option, ReviewDimension, ReviewSettings, Currency, Shop, AdditionalShopData> = {
+    singleLocale: boolean;
+    locale: string;
+    shop: Shop;
+    gateways: Gateway[];
+    currencies: Dict<Currency>;
+    categories: Dict<CategoryBrief>;
+    options: Dict<Option>;
+    inventoryLocations: Dict<InventoryLocation>;
+    reviewSettings: ReviewSettings;
+    reviewDimensions: Dict<ReviewDimension>;
+    siteUrl: string | undefined;
+    cdn: string;
+    opts?: GraphQLOpts<any>;
+    staticData: boolean;
+} & AdditionalShopData;
+export type AllData<Branding, Category, ContentBlock, Currency, Gateway, InventoryLocation, Option, Product, ReviewDimension, ReviewSettings, Shop, AdditionalLocaleData, AdditionalShopData> = {
+    perLocale: LocaleData<Branding, Category, ContentBlock, Currency, Gateway, InventoryLocation, Option, Product, ReviewDimension, ReviewSettings, Shop, AdditionalLocaleData, AdditionalShopData>[];
+};
+export declare function loadData<Branding extends BrandingReq, Category extends CategoryReq, ContentBlock, Currency extends CurrencyReq, Gateway, InventoryLocation extends InventoryLocationReq, Menu, Option extends OptionReq, Product extends ProductReq, ReviewDimension extends ReviewDimensionReq, ReviewSettings, Shop extends ShopReq, AdditionalLocaleData, AdditionalShopData>(config: LoadConfig<Branding, Category, ContentBlock, Currency, Gateway, InventoryLocation, Menu, Option, Product, ReviewDimension, ReviewSettings, Shop, AdditionalLocaleData, AdditionalShopData>): Promise<AllData<Branding, Category, ContentBlock, Currency, Gateway, InventoryLocation, Option, Product, ReviewDimension, ReviewSettings, Shop, AdditionalLocaleData, AdditionalShopData>>;
+export {};

package/types/defaultVariant.d.ts

@@ -0,0 +1,9 @@
+interface VariantLike {
+    is_default?: boolean;
+    media_files?: any[] | null;
+}
+interface ProductLike<T> {
+    variants?: (T | null)[] | null;
+}
+export declare function defaultVariant<T extends VariantLike>(product: ProductLike<T> | undefined | null): T | undefined;
+export {};

package/types/effector/clearOnChangeAfterDelay.d.ts

@@ -0,0 +1,2 @@
+import { Store } from "effector";
+export declare function clearOnChangeAfterDelay<T>(store: Store<T>, timeout: number): void;

package/types/effector/combineEvery.d.ts

@@ -0,0 +1,2 @@
+import { Store } from "effector";
+export declare function combineEvery(...stores: Store<boolean>[]): Store<boolean>;

package/types/effector/combineSome.d.ts

@@ -0,0 +1,2 @@
+import { Store } from "effector";
+export declare function combineSome(...stores: Store<boolean>[]): Store<boolean>;

package/types/effector/debounced.d.ts

@@ -0,0 +1,2 @@
+import { Store } from "effector";
+export declare function debounced<T>(src: Store<T>, dst: Store<T>, delay: number): void;