@lana-commerce/core 11.0.0

package/types/lastValue.d.ts

@@ -0,0 +1,10 @@
+type ArgumentTypes<T> = T extends (...args: infer U) => any ? U : never;
+type PromiseType<T extends Promise<any>> = T extends Promise<infer R> ? R : any;
+type Result<T> = {
+    kind: "discarded";
+} | {
+    kind: "resolved";
+    value: T;
+};
+export declare function lastValue<T extends (...args: any[]) => Promise<any>>(f: T): (...args: ArgumentTypes<T>) => Promise<Result<PromiseType<ReturnType<T>>>>;
+export {};

package/types/lineItemPrice.d.ts

@@ -0,0 +1,18 @@
+import { PriceInfo, SubscriptionPlanLike, VariantPriceInfoEnv, VariantPricer } from "./variantPrice.js";
+export type LineItemPriceInfo = {
+    sale: boolean;
+    hide: boolean;
+} & ({
+    kind: "price";
+    lineItemPrice: number;
+    perItemPrice: number;
+} | {
+    kind: "price_discount";
+    lineItemPrice: number;
+    perItemPrice: number;
+    previousLineItemPrice: number;
+    previousPerItemPrice: number;
+    percentageOff: number;
+});
+export declare function lineItemPriceInfo(vpi: PriceInfo | undefined, customItemPrice: number | undefined, quantity: number, tieredQuantity: number, discountPreview: number): LineItemPriceInfo;
+export declare function lineItemPrice(env: VariantPriceInfoEnv, p: VariantPricer | null | undefined, customItemPrice: number | undefined, quantity: number, tieredQuantity: number, discountPreview: number, plans?: SubscriptionPlanLike[], planIndex?: number): LineItemPriceInfo;

package/types/loadJWT.d.ts

@@ -0,0 +1 @@
+export declare function loadJWT(key: string, shopID?: string): string | undefined;

package/types/mapInvalidInput.d.ts

@@ -0,0 +1,15 @@
+import type { Dict } from "./commonTypes.js";
+import { InvalidInputProblem } from "./generated/codes.js";
+import type { RequestResponseError } from "./request.js";
+export interface PrefixMap {
+    from: string;
+    to?: string;
+}
+export interface InvalidInputField {
+    field: string;
+    max: number;
+    min: number;
+    problem: InvalidInputProblem;
+}
+export declare function mapPrefix(v: string, prefixMaps: PrefixMap[] | undefined): string;
+export declare function mapInvalidInput(e: RequestResponseError, ...prefixMaps: PrefixMap[]): Dict<InvalidInputField> | undefined;

package/types/mapResponseData.d.ts

@@ -0,0 +1,3 @@
+import type { RequestResponseData } from "./request.js";
+export declare function mapResponseData<T, U>(resp: RequestResponseData<T>, f: (data: T) => U): RequestResponseData<U>;
+export declare function firstResponseData<T>(resp: RequestResponseData<T[]>): RequestResponseData<T>;

package/types/mapResponseMultiData.d.ts

@@ -0,0 +1,2 @@
+import type { RequestResponseMulti } from "./request.js";
+export declare function mapResponseMultiData<T, U>(resp: RequestResponseMulti<T>, f: (data: T) => U): RequestResponseMulti<U>;

package/types/meanBy.d.ts

@@ -0,0 +1 @@
+export declare function meanBy<T>(array: T[] | null | undefined, cb: (v: T) => number): number;

package/types/media.d.ts

@@ -0,0 +1,3 @@
+import type { Dict } from "./commonTypes.js";
+export declare const supportedImageMIMEs: Dict<boolean>;
+export declare function isImage(mime: string): boolean;

package/types/modules/advancedSearch.d.ts

@@ -0,0 +1,78 @@
+import { Store } from "effector";
+import { AbstractOp, GraphQLOpts, RequestResponseError } from "../request.js";
+import type { AggregatedOptions } from "../aggregateOptions.js";
+import type { Dict } from "../commonTypes.js";
+import { HierarchicalSearchOption } from "../hierarchicalSearchOption.js";
+import type { SearchOption, SearchProductsSortBy } from "../graphql/types.js";
+export interface OptionAgg {
+    count: number;
+    name: string;
+    values: {
+        count: number;
+        name: string;
+    }[];
+}
+export interface SearchData<Product> {
+    products: Product[];
+    options: OptionAgg[];
+    priceRange: {
+        min: number;
+        max: number;
+    } | null;
+    count: number;
+    lastKey: string;
+    hasMore: boolean;
+    params: ProductsPageQueryParameters | null;
+}
+export declare const defaultSearchData: SearchData<any>;
+export interface ProductsPageQueryParameters {
+    shopID: string;
+    pageKey: string;
+    baseFilter: HierarchicalSearchOption[];
+    filter: HierarchicalSearchOption[];
+    limit: number;
+    sortBy: SearchProductsSortBy;
+    sortDesc: boolean;
+    filterState: Dict<any>;
+}
+export interface LoadProductsEvent {
+    params: ProductsPageQueryParameters;
+}
+export declare function aggregatedOptionsToOptionAgg(aggOpts: AggregatedOptions): OptionAgg[];
+export interface AdvancedSearchConfig<Product> {
+    readonly graphql: {
+        readonly searchProductsQuery: AbstractOp<{
+            search: {
+                count: number;
+                items: Array<Product | null> | null;
+                last_key: string;
+                options: Array<OptionAgg>;
+                price_max: number;
+                price_min: number;
+            } | null;
+        }, {
+            aggregations: boolean;
+            data: Array<SearchOption>;
+            lastKey: string;
+            limit: number;
+            shopID: string;
+            sortBy: SearchProductsSortBy;
+            sortDesc: boolean;
+        }>;
+    };
+    /** Your shop id. */
+    readonly shopID: string;
+    /** These graphql options are applied to all "request" api calls search does. */
+    readonly opts?: Readonly<GraphQLOpts<any>>;
+    /** A store that represents current auth state. You should pass it in to keep auth state in-sync. */
+    readonly jwt: Store<string>;
+    /** Current locale. Module will react to its changes. */
+    readonly locale: Store<string>;
+}
+export declare function createAdvancedSearch<Product>(config: AdvancedSearchConfig<Product>): {
+    loadProducts: import("effector").Event<LoadProductsEvent>;
+    queuedFor: Store<string>;
+    data: Store<SearchData<Product>>;
+    somethingIsPending: Store<boolean>;
+    unexpectedError: import("effector").Event<RequestResponseError>;
+};

package/types/modules/cart.d.ts

@@ -0,0 +1,263 @@
+import { Store } from "effector";
+import { AbstractOp, GraphQLOpts, RequestResponseError } from "../request.js";
+import type { CreateCartMutationVariables, GetCartQueryVariables, GetLastCartQueryVariables, LineItemFieldCreate, LineItemFieldFragment, ModifyCartMutationVariables, OrderState, ProductFieldType } from "../graphql/types.js";
+export interface CartType<Variant> {
+    discount_code: string | null;
+    id: string;
+    line_items: Array<{
+        id: string;
+        quantity: number;
+        variant: Variant | null;
+        variant_id: string | null;
+        discount_preview: number;
+        field_set: {
+            id: string;
+        } | null;
+        fields: Array<{
+            field_index: number;
+            choice_index: number;
+            type: ProductFieldType;
+            label: string;
+            value: string;
+        }>;
+        subscription_plan_index: number;
+        custom_item_index: number;
+    }>;
+    custom_items: Array<{
+        id: string;
+        title: string;
+        price: number;
+    }> | null;
+    state: OrderState;
+    updated_at: string;
+    uuid: string;
+    currency: string;
+}
+export interface CartCustomItem {
+    id: string;
+    title: string;
+    price: number;
+}
+export interface CartLineItem<Variant> {
+    quantity: number;
+    variant: Variant | undefined;
+    variantID: string;
+    discountPreview: number;
+    fieldSetID: string;
+    fields?: LineItemFieldFragment[];
+    subscriptionPlanIndex?: number;
+    customItemIndex?: number;
+    customItem?: CartCustomItem;
+}
+export interface CartOperationResult<Variant> {
+    orders: Array<CartType<Variant>> | null;
+}
+export interface CartOperationResultSingular<Variant> {
+    order: CartType<Variant> | null;
+}
+export interface CartAPIState<Variant> {
+    cart: CartType<Variant>;
+    lineItems: CartLineItem<Variant>[];
+}
+/**
+ * Cart background activity state.
+ *  - **idle**: cart is doing nothing
+ *  - **sync**: cart is syncing line items with the server
+ *  - **init**: cart is initializing
+ *  - **discount**: applying/removing discount code
+ *  - **currency**: applying currency
+ */
+export type CartActivity = "idle" | "sync" | "init" | "discount" | "currency";
+export interface CartConfig<Variant> {
+    /**
+     * A set of GraphQL queries cart uses to manipulate cart's server-side state. One can provide custom ones as
+     * long as they pass minimum requirements (this is ensured only by typescript type safety). Or one can use
+     * default ones from "./config/defaultCartGraphQLConfig".
+     */
+    readonly graphql: {
+        readonly getCartQuery: AbstractOp<CartOperationResult<Variant>, GetCartQueryVariables>;
+        readonly getLastCartQuery: AbstractOp<CartOperationResultSingular<Variant>, GetLastCartQueryVariables>;
+        readonly createCartMutation: AbstractOp<CartOperationResult<Variant>, CreateCartMutationVariables>;
+        readonly modifyCartMutation: AbstractOp<CartOperationResult<Variant>, ModifyCartMutationVariables>;
+    };
+    /** Your shop id. */
+    readonly shopID: string;
+    /** These graphql options are applied to all "request" api calls cart does. */
+    readonly opts?: GraphQLOpts<any>;
+    /** Internal debug hook, interface is not specified, use at your own risk. */
+    readonly debug?: any;
+    /** A store that represents current auth state. You should pass it in to keep auth state in-sync. */
+    readonly jwt: Store<string>;
+    /** Current locale. Module will react to its changes. */
+    readonly locale: Store<string>;
+    /** Persist data across multiple browser tabs (good for multi-page applications). */
+    readonly persist?: {
+        /** Load data from persistent storage. */
+        readonly load: () => string;
+        /** Save data to persistent storage. */
+        readonly save: (data: string) => void;
+        /**
+         * Register a callback that is called when data is changed in persistent storage (only from the outside,
+         * should ignore "save" calls).
+         */
+        readonly onChange: (callback: (data: string) => void) => void;
+        /** If stored data is older than this, it's ignored. In milliseconds. Default: 30 minutes. */
+        readonly maxAgeMs?: number;
+    };
+}
+export type CartInitBasic = {
+    kind: "fetch_last";
+} | {
+    kind: "fetch_by_id";
+    id: string;
+    uuid: string;
+} | {
+    kind: "fetch_last_or_by_id";
+    id: string;
+    uuid: string;
+} | {
+    kind: "new";
+};
+/**
+ * All variants for cart initialization.
+ *
+ * 1. **fetch_last**: Fetch last cart for a registered customer. This option assumes that config contains a
+ * valid authToken.
+ * 2. **fetch_by_id**: Fetch cart by id and uuid. This options works best for unregistered customers, who created a cart
+ * and saved its id/uuid in localStorage.
+ * 3. **fetch_last_or_by_id**: Try **fetch_last**, on failure try **fetch_by_id**.
+ * 4. **new**: Create a new cart. New cart is created lazily when customer adds items to it.
+ * 5. **load_or**: Load cart from peristent storage, if that fails, fallback to logic specified in "init" field.
+ * Note that loading will only work when **persist** config option is provided. See **CartConfig** for details.
+ */
+export type CartInit = CartInitBasic | {
+    kind: "load_or";
+    init: CartInit;
+};
+/**
+ * When applying discount code, it responds with one of these.
+ *
+ * - **ok**: Everything is okay, discount code was applied, its value will be reported via onChange() callback.
+ * - **discarded**: Something failed on init/sync stage, ignore this error, the Cart API will call onSyncLock(true)
+ *   and you will have to lock the UI in another place. Feel free to avoid clearing discount code input field. Customer
+ *   might want to retry after "reload()".
+ * - **not_found**: Discount code is not found or expired.
+ * - **customer_id_required**: If promotion has max uses per customer restriction, it requires customer id to be
+ *   assigned to the cart/order. Ask your customer to enter it again at a later stage.
+ * - **unexpected_error**: Unexpected error happened during API call. Most likely connectivity issue.
+ */
+export type ApplyDiscountCodeResult = {
+    kind: "ok";
+} | {
+    kind: "discarded";
+} | {
+    kind: "not_found";
+} | {
+    kind: "customer_id_required";
+} | {
+    kind: "unexpected_error";
+    error: RequestResponseError;
+};
+export interface Cart<Variant> {
+    /**
+     * Once cart is created or fetched, this reflects the currency used by the cart.
+     */
+    currency: Store<string>;
+    /**
+     * Use this store for discount code input field. Its value will be used on {@link Cart#applyDiscountCode}.
+     */
+    discountCodeInput: Store<string>;
+    /**
+     * This store is used to report changes on background cart activity. Cart code might delay activity report
+     * changes with intention to provide better UI experience.
+     */
+    activity: Store<CartActivity>;
+    /**
+     * This store is changed if there was a failure during cart line items synchronization. You cannot perform
+     * any actions with the cart but "reload()" after this point. Make sure UI reflects this. Note that this store
+     * is also changed when cart is restored after "reload()".
+     */
+    locked: Store<boolean>;
+    /**
+     * Current line items on the cart. Could be result of client-side prediction or up-to-date info from the server.
+     */
+    lineItems: Store<CartLineItem<Variant>[]>;
+    /**
+     * The most recent cart data received from the server. It also contains line items augmented with data
+     * from prediction model. For example if server fails to expand a variant on a line item, but this
+     * line item was added prior to that using predicted data, the line item will keep using predicted data.
+     */
+    cartData: Store<CartAPIState<Variant> | null>;
+    /**
+     * Represents current discount code received from the server.
+     */
+    discountCode: Store<string>;
+    /**
+     * Whether "apply discount code" operation is pending (disable "apply" button if so).
+     */
+    discountCodePending: Store<boolean>;
+    /**
+     * Outcome of the last "apply discount code" operation.
+     *
+     * @see {ApplyDiscountCodeResult}
+     */
+    discountCodeResult: Store<ApplyDiscountCodeResult>;
+    /**
+     * Make an attempt to unlock the cart by reloading it from the server. If cart ends up being locked (see: "locked" Store),
+     * you should display an error UI which offers customer to reload the cart by clicking a button. All cart operations
+     * will throw an exception if you try to invoke them in a locked state.
+     */
+    reload(): void;
+    /**
+     * Set cart item.
+     *
+     * Second "variant" parameter is optional, however it's recommended to provide one, this variant info is used for
+     * client-side prediction. The info you pass in will be reflected in "lineItems" Store instantly as a result
+     * client-side prediction. Furthermore if server fails to provide variant info, the existing info will be used
+     * instead. This may happen for example if shop was statically generated, but since then the target product
+     * was unpublished.
+     */
+    setItem(variantID: string, variant: Variant | undefined, quantity: number, fieldSetID?: string, fields?: LineItemFieldCreate[], subscriptionPlanIndex?: number): void;
+    /**
+     * Change cart item, use quantityDelta == +1 to increment item quantity (or add a new item), use quantityDelta == -1
+     * to decrement an item. You can of course use other quantities.
+     *
+     * Second "variant" parameter is optional, however it's recommended to provide one, this variant info is used for
+     * client-side prediction. The info you pass in will be reflected in "lineItems" Store instantly as a result
+     * client-side prediction. Furthermore if server fails to provide variant info, the existing info will be used
+     * instead. This may happen for example if shop was statically generated, but since then the target product
+     * was unpublished.
+     */
+    changeItem(variantID: string, variant: Variant | undefined, quantityDelta: number, fieldSetID?: string, fields?: LineItemFieldCreate[], subscriptionPlanIndex?: number): void;
+    /**
+     * Remove item from the cart.
+     */
+    removeItem(variantID: string): void;
+    /**
+     * Apply discount code to the cart.
+     *
+     * @see {Cart.discountCodeInput}
+     */
+    applyDiscountCode(): void;
+    /**
+     * Remove discount code from the cart.
+     */
+    removeDiscountCode(): void;
+    /**
+     * Use method to set value for {@link Cart#discountCodeInput}
+     */
+    setDiscountCodeInput(value: string): void;
+    /**
+     * This callback is executed in cart's queue once everything is settled. It is meant to be used for checkout flow.
+     */
+    checkout(callback: () => Promise<void>): void;
+    /**
+     * Set cart's currency. When "soft" mode is used, the currency is only set if there is no cart yet.
+     */
+    setCurrency(currency: string, mode?: "soft"): void;
+}
+/**
+ * Create the Cart instance with a given config and init option. Note that if init option is not "new", cart
+ * will start fetching its state from the server right away.
+ */
+export declare function createCart<Variant>(config: CartConfig<Variant>, init: CartInit): Cart<Variant>;

package/types/modules/config/defaultAdvancedSearchGraphQLConfig.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultAdvancedSearchGraphQLConfig: {
+    searchProductsQuery: import("../../graphql/types.js").SearchProductsAdvancedQueryMeta;
+};

package/types/modules/config/defaultCartGraphQLConfig.d.ts

@@ -0,0 +1,6 @@
+export declare const defaultCartGraphQLConfig: {
+    getCartQuery: import("../../graphql/types.js").GetCartQueryMeta;
+    getLastCartQuery: import("../../graphql/types.js").GetLastCartQueryMeta;
+    createCartMutation: import("../../graphql/types.js").CreateCartMutationMeta;
+    modifyCartMutation: import("../../graphql/types.js").ModifyCartMutationMeta;
+};

package/types/modules/config/defaultProductGraphQLConfig.d.ts

@@ -0,0 +1,23 @@
+export declare const defaultProductGraphQLConfig: {
+    loadProductQuery: import("../../graphql/types.js").LoadProductQueryMeta;
+    loadProductNoCustomerQuery: import("../../graphql/types.js").LoadProductNoCustomerQueryMeta;
+    createReviewMutation: import("../../graphql/types.js").CreateProductReviewMutationMeta;
+    modifyReviewMutation: import("../../graphql/types.js").ModifyProductReviewMutationMeta;
+    deleteReviewMutation: import("../../graphql/types.js").DeleteProductReviewMutationMeta;
+    createQuestionMutation: import("../../graphql/types.js").CreateProductQuestionMutationMeta;
+    modifyQuestionMutation: import("../../graphql/types.js").ModifyProductQuestionMutationMeta;
+    deleteQuestionMutation: import("../../graphql/types.js").DeleteProductQuestionMutationMeta;
+    voteReviewMutation: import("../../graphql/types.js").VoteReviewMutationMeta;
+    flagReviewMutation: import("../../graphql/types.js").FlagReviewMutationMeta;
+    voteQuestionMutation: import("../../graphql/types.js").VoteQuestionMutationMeta;
+    flagQuestionMutation: import("../../graphql/types.js").FlagQuestionMutationMeta;
+    getReviewQuery: import("../../graphql/types.js").GetReviewQueryMeta;
+    getQuestionQuery: import("../../graphql/types.js").GetQuestionQueryMeta;
+    searchReviewsQuery: import("../../graphql/types.js").SearchReviewsQueryMeta;
+    searchQuestionsQuery: import("../../graphql/types.js").SearchQuestionsQueryMeta;
+    deleteQuestionAnswerMutation: import("../../graphql/types.js").DeleteProductQuestionAnswerMutationMeta;
+    voteQuestionAnswerMutation: import("../../graphql/types.js").VoteQuestionAnswerMutationMeta;
+    flagQuestionAnswerMutation: import("../../graphql/types.js").FlagQuestionAnswerMutationMeta;
+    createQuestionAnswerMutation: import("../../graphql/types.js").CreateProductQuestionAnswerMutationMeta;
+    modifyQuestionAnswerMutation: import("../../graphql/types.js").ModifyProductQuestionAnswerMutationMeta;
+};

package/types/modules/config/defaultSearchGraphQLConfig.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultSearchGraphQLConfig: {
+    searchProductsQuery: import("../../graphql/types.js").SearchProductsQueryMeta;
+};