@swishapp/sdk 0.52.0

package/dist/swish-api/items-batch-loader.d.ts

@@ -0,0 +1,4 @@
+import DataLoader from "dataloader";
+import type { SwishApi } from "./swish-api-client";
+import type { Item, PaginatedApiResponse } from "@swishapp/api-client";
+export declare const createItemsBatchLoader: (apiClient: SwishApi) => DataLoader<string, PaginatedApiResponse<Item>, string>;

package/dist/swish-api/swish-api-client.d.ts

@@ -0,0 +1,43 @@
+import { ApiResponse, Item, ItemControllerFindData, ItemDetail, ListControllerFindData, ListDetail, PaginatedApiResponse, SwishClientConfig } from "@swishapp/api-client";
+export interface SwishApiConfig extends SwishClientConfig {
+    loadProfile?: () => string | undefined;
+    storeProfile?: (profile: string) => void;
+    deleteProfile?: () => void;
+    responseInterceptor?: (response: Response, request: Request) => Promise<void> | void;
+}
+export declare class SwishApi {
+    private readonly cache;
+    private readonly apiClient;
+    private readonly config;
+    private readonly itemsLoader;
+    constructor(config: SwishApiConfig, cacheKeyPrefix: string);
+    private processProfileHeader;
+    get items(): {
+        list: (query?: ItemControllerFindData["query"], options?: {
+            batch?: boolean;
+        }) => Promise<PaginatedApiResponse<Item>>;
+        findById: (itemId: string) => Promise<ApiResponse<ItemDetail>>;
+        create: (items: import("@swishapp/api-client").CreateItemInput) => Promise<ApiResponse<Item>>;
+        delete: (itemIds: import("@swishapp/api-client").DeleteItemsInput["itemIds"]) => Promise<ApiResponse<unknown>>;
+        updateById: (itemId: string, body: import("@swishapp/api-client").UpdateItemInput) => Promise<ApiResponse<Item>>;
+        deleteById: (itemId: string) => Promise<ApiResponse<unknown>>;
+        setListsById: (itemId: string, listIds: import("@swishapp/api-client").SetItemListsInput["listIds"]) => Promise<ApiResponse<ItemDetail>>;
+        count: () => Promise<ApiResponse<import("@swishapp/api-client").ItemCount>>;
+    };
+    get lists(): {
+        list: (query?: ListControllerFindData["query"]) => Promise<PaginatedApiResponse<ListDetail>>;
+        findById: (listId: string) => Promise<ApiResponse<ListDetail>>;
+        create: (list: import("@swishapp/api-client").CreateListInput) => Promise<ApiResponse<import("@swishapp/api-client").List>>;
+        updateById: (listId: string, body: import("@swishapp/api-client").UpdateListInput) => Promise<ApiResponse<import("@swishapp/api-client").List>>;
+        deleteById: (listId: string) => Promise<ApiResponse<unknown>>;
+        orderItems: (listId: string, itemIds: import("@swishapp/api-client").SetListItemsOrderInput["itemIds"]) => Promise<ApiResponse<import("@swishapp/api-client").List>>;
+        addItemsToList: (listId: string, itemIds: import("@swishapp/api-client").AddItemsToListInput["itemIds"]) => Promise<ApiResponse<ListDetail>>;
+        removeItemFromList: (listId: string, itemId: string) => Promise<ApiResponse<unknown>>;
+    };
+    get profiles(): {
+        customerAccountsVersion: () => Promise<ApiResponse<import("@swishapp/api-client").AccountsVersionResult>>;
+        createToken: (body?: import("@swishapp/api-client").CreateProfileTokenInput) => Promise<ApiResponse<import("@swishapp/api-client").CreateProfileTokenResult>>;
+        identify: (body: import("@swishapp/api-client").IdentifyProfileInput) => Promise<ApiResponse<import("@swishapp/api-client").IdentifyProfileResult>>;
+    };
+    clearCache(): Promise<void>;
+}

package/dist/swish-api/swish-api-publisher.d.ts

@@ -0,0 +1,8 @@
+import { EventBus, EventName } from "../events/event-bus";
+export declare class SwishApiPublisher {
+    private readonly eventBus;
+    private readonly eventMap;
+    constructor(eventBus: EventBus);
+    processFetchResponse(response: Response, request: Request): Promise<void>;
+    getEventName(method: string, status: number, url: string): EventName | undefined;
+}

package/dist/swish-ui/swish-ui-element.d.ts

@@ -0,0 +1,9 @@
+export interface Ref<T> {
+    current: T;
+}
+export declare class SwishUiElement extends HTMLElement {
+    constructor();
+    private componentRef;
+    getComponentRef: <TComponent = unknown>() => Ref<TComponent>;
+    setComponentRef: <TComponent = unknown>(ref: Ref<TComponent>) => void;
+}

package/dist/swish-ui/swish-ui-utils.d.ts

@@ -0,0 +1,112 @@
+import type { SwishUiManifest, SwishUiOptions } from "../types";
+import type { ShopBridge } from "../utils/shop-bridge";
+import type { Ref, SwishUiElement } from "./swish-ui-element";
+import "../utils/shop-bridge";
+import { Item, ItemDetail } from "@swishapp/api-client";
+import { GetProductCardDataWithVariantQuery, GetSelectedVariantQuery } from "../storefront-api/storefront-api-client";
+export interface Notifications {
+    pushNotification(notification: Notification): string;
+    removeNotification(id: string): void;
+    clearAllNotifications(): void;
+}
+export interface Notification {
+    title?: string;
+    text: string;
+    image?: string;
+    action?: {
+        label: string;
+        url?: string;
+        onAction?: () => void;
+    };
+}
+export declare const setConfig: (opts: SwishUiOptions) => void;
+export declare const hideModal: (element: string | HTMLElement) => Promise<void>;
+export declare const showModal: (element: string | HTMLElement) => Promise<void>;
+export declare const showSignIn: (options?: {
+    returnTo?: string;
+}) => Promise<void>;
+export interface UnsaveAlertOptions {
+    itemId: string;
+    onSubmit?: (data: UnsaveAlertSubmitData) => void;
+    onCancel?: () => void;
+}
+export interface UnsaveAlertSubmitData {
+    itemId: string;
+}
+export declare const showUnsaveAlert: (options: UnsaveAlertOptions) => Promise<void>;
+export declare const showDeleteListAlert: (options: {
+    listId: string;
+    onSubmit?: () => void;
+    onCancel?: () => void;
+}) => Promise<void>;
+export declare const showDrawer: () => Promise<void>;
+export declare const showListMenu: (options: {
+    listId: string;
+    onClose?: (data: {
+        reason: string;
+    }) => void;
+}) => Promise<void>;
+export interface ListSelectOptions {
+    itemId: string;
+    onSubmit?: (data: ListSelectSubmitData) => void | Promise<void>;
+    onClose?: () => void;
+    onUnsave?: (data: UnsaveAlertSubmitData) => void;
+}
+export type ListSelectProduct = Exclude<GetProductCardDataWithVariantQuery["product"], undefined | null>;
+export type ListSelectVariant = Exclude<GetProductCardDataWithVariantQuery["variant"], undefined | null>;
+export interface ListSelectSubmitData {
+    item: ItemDetail;
+    product: ListSelectProduct;
+    variant?: ListSelectVariant;
+}
+export declare const showListSelect: (options: ListSelectOptions) => Promise<void>;
+export declare const showNotification: (options: {
+    title?: string;
+    text: string;
+    image?: string;
+    action?: {
+        label: string;
+        url?: string;
+        onAction?: () => void;
+    };
+}) => Promise<void>;
+export declare const hideAllNotifications: () => Promise<void>;
+export interface VariantSelectOptions {
+    productId?: string;
+    productHandle?: string;
+    variantId?: string;
+    displayType?: "rows" | "pills";
+    action?: "none" | "save";
+    onSubmit: (data: VariantSelectSubmitData) => void;
+}
+export type VariantSelectProduct = Exclude<GetSelectedVariantQuery["product"], undefined | null>;
+export type VariantSelectVariant = Exclude<VariantSelectProduct["variantBySelectedOptions"], undefined | null>;
+export interface VariantSelectSubmitData {
+    item: Item;
+    product: VariantSelectProduct;
+    variant: VariantSelectVariant;
+}
+export declare const showVariantSelect: (options?: VariantSelectOptions) => Promise<void>;
+export declare const showListEditor: <TData = unknown>(options?: {
+    listId?: string;
+    variantId?: string;
+    onSubmit: (data: TData) => void | Promise<void>;
+}) => Promise<void>;
+export declare const initShopBridge: ({ onShopModalOpen, }: {
+    onShopModalOpen: () => void;
+}) => Promise<ShopBridge>;
+export declare const loadManifest: () => Promise<SwishUiManifest>;
+export interface RequireUiComponentOptions<TComponent> {
+    instance?: string;
+    listeners?: Record<string, (event: Event | CustomEvent) => void>;
+    onHydrated?: (ref: Ref<TComponent>) => void;
+}
+export declare const requireUiComponent: <TComponent = unknown>(name: string, options?: RequireUiComponentOptions<TComponent>) => Promise<SwishUiElement>;
+export declare const insertComponent: <T extends HTMLElement = SwishUiElement>({ name, instance, template, position, refElement, }: {
+    name: string;
+    instance?: string;
+    template: string;
+    position: InsertPosition;
+    refElement: HTMLElement;
+}) => Promise<T>;
+export declare const queryComponent: <T extends HTMLElement = SwishUiElement>(name: string, instance?: string) => T;

package/dist/swish.d.ts

@@ -0,0 +1,124 @@
+import type { SwishAppOptions, SwishEmbedData } from "./types";
+import { AjaxApiClient } from "./ajax-api/ajax-api-client";
+import { createElementLocator, createLocationObserver } from "./dom/dom-utils";
+import { EventBus } from "./events/event-bus";
+import { effect, signal } from "./state";
+import { StorefrontApiClient } from "./storefront-api/storefront-api-client";
+import { SwishApi } from "./swish-api/swish-api-client";
+export declare const VERSION: string;
+export declare const swishEmbedData: SwishEmbedData;
+export declare const swishApp: (options: SwishAppOptions) => Promise<SwishApp>;
+export declare class SwishApp {
+    private readonly swishApi;
+    private readonly swishApiPublisher;
+    private readonly storefrontApi;
+    private readonly ajaxApi;
+    private readonly ajaxApiPublisher;
+    private readonly options;
+    readonly events: EventBus;
+    constructor(options: SwishAppOptions);
+    get customer(): {
+        id: string | null;
+        email: string | null;
+        firstName: string | null;
+        lastName: string | null;
+        b2b: boolean | null;
+    };
+    get localization(): {
+        country: string;
+        language: string;
+        market: number;
+    };
+    get shopifyRoutes(): {
+        accountUrl: string;
+        accountLoginUrl: string;
+        rootUrl: string;
+    };
+    get api(): SwishApi;
+    get storefront(): StorefrontApiClient;
+    get ajax(): AjaxApiClient;
+    get shopUrl(): string;
+    readonly ui: {
+        showSignIn: (options?: {
+            returnTo?: string;
+        }) => Promise<void>;
+        showVariantSelect: (options?: import(".").VariantSelectOptions) => Promise<void>;
+        initShopBridge: ({ onShopModalOpen, }: {
+            onShopModalOpen: () => void;
+        }) => Promise<import(".").ShopBridge>;
+        showNotification: (options: {
+            title?: string;
+            text: string;
+            image?: string;
+            action?: {
+                label: string;
+                url?: string;
+                onAction?: () => void;
+            };
+        }) => Promise<void>;
+        hideAllNotifications: () => Promise<void>;
+        showListSelect: (options: import(".").ListSelectOptions) => Promise<void>;
+        showDrawer: () => Promise<void>;
+        showListEditor: <TData = unknown>(options?: {
+            listId?: string;
+            variantId?: string;
+            onSubmit: (data: TData) => void | Promise<void>;
+        }) => Promise<void>;
+        showUnsaveAlert: (options: import(".").UnsaveAlertOptions) => Promise<void>;
+        hideModal: (element: string | HTMLElement) => Promise<void>;
+        showModal: (element: string | HTMLElement) => Promise<void>;
+        showListMenu: (options: {
+            listId: string;
+            onClose?: (data: {
+                reason: string;
+            }) => void;
+        }) => Promise<void>;
+        showDeleteListAlert: (options: {
+            listId: string;
+            onSubmit?: () => void;
+            onCancel?: () => void;
+        }) => Promise<void>;
+    };
+    readonly dom: {
+        createElementLocator: typeof createElementLocator;
+        createQueryParamsObserver: typeof createLocationObserver;
+    };
+    readonly state: {
+        itemContext: (source?: HTMLElement) => import("@preact/signals-core").Signal<import("./state").ItemContext>;
+        itemState: (context: import("@preact/signals-core").Signal<import("./state").ItemContext>) => import("@preact/signals-core").ReadonlySignal<{
+            error: import("@swishapp/api-client").ApiError | null;
+            status: string;
+            savedItemId: string | null;
+            loading: boolean;
+            submitting: boolean;
+            saved: boolean;
+            saving: boolean;
+            unsaving: boolean;
+        }> & {
+            save: () => Promise<void>;
+            unsave: () => void;
+            update: () => void;
+            toggle: () => Promise<void>;
+        };
+        itemCount: () => import("@preact/signals-core").ReadonlySignal<{
+            count: number;
+            loading: boolean;
+            error: import("@swishapp/api-client").ApiError | null;
+        }>;
+        swishQuery: <TResponse extends import("@swishapp/api-client").ApiResponse<any> | import("@swishapp/api-client").PaginatedApiResponse<any>, TVariables>(fetch: import("./state/swish-query-signals").FetchFn<TResponse, TVariables>, options?: {
+            variables?: import("@preact/signals-core").Signal<TVariables>;
+            skip?: import("@preact/signals-core").Signal<boolean>;
+            refetch?: import(".").EventName[];
+        }) => {
+            data: import("@preact/signals-core").Signal<(TResponse extends {
+                data: infer D;
+            } ? D : never) | null>;
+            pageInfo: import("@preact/signals-core").Signal<import("@swishapp/api-client").PageInfo | null>;
+            error: import("@preact/signals-core").Signal<import("@swishapp/api-client").ApiError | null>;
+            loading: import("@preact/signals-core").Signal<boolean>;
+            refetching: import("@preact/signals-core").ReadonlySignal<boolean>;
+        };
+        effect: typeof effect;
+        signal: typeof signal;
+    };
+}