@swishapp/sdk 0.105.1 → 0.106.0

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

@@ -52,7 +52,7 @@ export interface Cart {
     cart_level_discount_applications: any[];
 }
 export interface AddToCartItem {
-    id: string;
+    id: string | number;
     quantity: number;
 }
 export interface AddToCartRequest {

package/dist/dom/create-placement.d.ts

@@ -0,0 +1,114 @@
+import { SwishApp } from "../swish";
+import { CreateElementLocatorArgs } from "./dom-utils";
+export declare function createPlacement<TDomElement extends HTMLElement = HTMLElement, TElementName extends ElementName = ElementName>(swish: SwishApp, spec: PlacementSpec<TDomElement, TElementName>): {
+    mount(): void;
+    unmount(): void;
+};
+/** --------------------------------------------
+ * Types
+ * -------------------------------------------- */
+export type BreakpointsSpec = {
+    sm?: number;
+    lg?: number;
+} | Record<string, number>;
+export type ResponsiveValue<T> = T | {
+    base?: T;
+    [breakpoint: string]: T | undefined;
+};
+type ElementName = "save-button" | "home-button";
+export type SaveButtonDesignSpec = {
+    background?: ResponsiveValue<string>;
+    savedBackground?: ResponsiveValue<string>;
+    color?: ResponsiveValue<string>;
+    savedColor?: ResponsiveValue<string>;
+    height?: ResponsiveValue<string | number>;
+    radius?: ResponsiveValue<string | number>;
+};
+export type HomeButtonDesignSpec = {
+    background?: ResponsiveValue<string>;
+    color?: ResponsiveValue<string>;
+    height?: ResponsiveValue<string | number>;
+    radius?: ResponsiveValue<string | number>;
+};
+type DesignSpecMap = {
+    "save-button": SaveButtonDesignSpec;
+    "home-button": HomeButtonDesignSpec;
+};
+export type DesignSpecForElementName<TName extends ElementName = ElementName> = TName extends keyof DesignSpecMap ? DesignSpecMap[TName] : never;
+export type MountMode = "before" | "after" | "append" | "prepend" | "replace";
+export type MountAt = "target" | {
+    closest: string;
+} | {
+    query: string;
+} | {
+    withinClosest: {
+        root: string;
+        selector: string;
+    };
+};
+export type ContainerSpec = {
+    tag?: keyof HTMLElementTagNameMap;
+    classNames?: string[];
+};
+export type OverlayAnchor = "top-left" | "top-right" | "bottom-left" | "bottom-right";
+export type ElementSpec<TName extends string = ElementName> = {
+    name: TName;
+    props?: Record<string, unknown>;
+    classNames?: string[];
+};
+export type OffsetSpec = {
+    x?: number;
+    y?: number;
+};
+export type OverlayLayoutSpec = {
+    type: "overlay";
+    anchor?: OverlayAnchor;
+    zIndex?: number | string;
+    offset?: OffsetSpec | ResponsiveValue<OffsetSpec>;
+};
+export type InlineLayoutSpec = {
+    type: "inline";
+    rowSelector?: string;
+};
+export type PlacementLayoutSpec = OverlayLayoutSpec | InlineLayoutSpec;
+export type PlacementSpec<TDomElement extends HTMLElement = HTMLElement, TElementName extends ElementName = ElementName> = {
+    id: string;
+    target: Omit<CreateElementLocatorArgs, "onElementFound">;
+    mount: {
+        at?: MountAt;
+        mode: MountMode;
+    };
+    layout?: PlacementLayoutSpec;
+    breakpoints?: BreakpointsSpec;
+    container?: ContainerSpec;
+    element?: ElementSpec<TElementName> | RenderFn;
+    /** Design tokens (typed when element name is known). */
+    design?: DesignSpecForElementName<TElementName>;
+    /** Custom CSS appended after defaults (one stylesheet per placement). */
+    css?: string;
+    onMount?: (ctx: MountContext<TDomElement>) => void;
+    onUnmount?: (ctx: UnmountContext<TDomElement>) => void;
+};
+export type MountContext<T extends HTMLElement> = {
+    id: string;
+    targetEl: Element;
+    renderTargetEl: Element;
+    mountEl: T;
+    containerEl?: HTMLElement;
+    rowEl?: HTMLElement;
+    cleanup: (fn: () => void) => void;
+};
+export type UnmountContext<T extends HTMLElement> = Omit<MountContext<T>, "cleanup">;
+export type MountedElement<T extends HTMLElement> = {
+    targetEl: HTMLElement;
+    renderTargetEl: HTMLElement;
+    mountEl: T;
+    containerEl?: HTMLElement;
+    rowEl?: HTMLElement;
+    rowWasCreated?: boolean;
+    rowInlineAttrPrevValue?: string | null;
+    cleanupFns: Array<() => void>;
+    ownsNode: boolean;
+};
+export type RenderFn = (spec: PlacementSpec<any, any>) => HTMLElement | Promise<HTMLElement>;
+export {};

package/dist/dom/dom-utils.d.ts

@@ -3,8 +3,9 @@ export interface CreateElementLocatorArgs {
     onElementFound: (element: Element) => void;
     selector: string;
     observerOptions?: IntersectionObserverInit;
+    mustMatch?: (element: Element) => boolean;
 }
-export declare function createElementLocator({ onElementFound, selector, observerOptions, }: CreateElementLocatorArgs): MutationObserver;
+export declare function createElementLocator({ onElementFound, selector, observerOptions, mustMatch, }: CreateElementLocatorArgs): MutationObserver;
 export interface CreateLocationObserverArgs {
     onLocationChange: (location: Location) => void;
     fireOnInit?: boolean;

package/dist/intents/handlers/create-cart-line-handler.d.ts

@@ -0,0 +1,21 @@
+import * as v from "valibot";
+import type { AddToCartResponse } from "../../ajax-api/ajax-api-client";
+import { IntentHandler } from "../intent-handler";
+import { IntentResponse, SuccessIntentResponse } from "../types";
+export declare const CreateCartLineIntentDataSchema: v.UnionSchema<[v.ObjectSchema<{
+    readonly variantId: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, string>]>, v.NumberSchema<undefined>], undefined>, v.TransformAction<string | number, number>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>]>;
+    readonly quantity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>, 1>;
+}, undefined>, v.ObjectSchema<{
+    readonly items: v.SchemaWithPipe<readonly [v.ArraySchema<v.ObjectSchema<{
+        readonly variantId: v.SchemaWithPipe<readonly [v.UnionSchema<[v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TransformAction<string, string>]>, v.NumberSchema<undefined>], undefined>, v.TransformAction<string | number, number>, v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>]>;
+        readonly quantity: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 1, undefined>]>, 1>;
+    }, undefined>, undefined>, v.MinLengthAction<{
+        variantId: number;
+        quantity: number;
+    }[], 1, undefined>]>;
+}, undefined>], undefined>;
+export type CreateCartLineIntentData = v.InferInput<typeof CreateCartLineIntentDataSchema>;
+export type CreateCartLineSuccessResponse = SuccessIntentResponse<AddToCartResponse>;
+export declare class CreateCartLineHandler extends IntentHandler<"create:cart-line"> {
+    invoke(data: CreateCartLineIntentData): Promise<IntentResponse<"create:cart-line">>;
+}

package/dist/intents/handlers/edit-item-lists-handler.d.ts

@@ -14,6 +14,6 @@ export type EditItemListsSuccessResponse = SuccessIntentResponse<{
     variant: GetSaveIntentDataWithVariantQuery["variant"];
 }>;
 export type EditItemListsIntentDataValidated = v.InferInput<typeof EditItemListsIntentDataSchema>;
-export declare class EditItemListsHandler extends IntentHandler<"edit:item-lists" | "delete:item"> {
-    invoke(data: EditItemListsIntentData): Promise<IntentResponse<"edit:item-lists" | "delete:item">>;
+export declare class EditItemListsHandler extends IntentHandler<"edit:item-lists" | "unsave:item"> {
+    invoke(data: EditItemListsIntentData): Promise<IntentResponse<"edit:item-lists" | "unsave:item">>;
 }

package/dist/intents/handlers/edit-list-access-handler.d.ts

@@ -0,0 +1,15 @@
+import { List } from "@swishapp/api-client";
+import * as v from "valibot";
+import { IntentHandler } from "../intent-handler";
+import { IntentResponse, SuccessIntentResponse } from "../types";
+export declare const EditListAccessIntentDataSchema: v.ObjectSchema<{
+    readonly listId: v.StringSchema<undefined>;
+    readonly access: v.PicklistSchema<["public", "private"], undefined>;
+}, undefined>;
+export type EditListAccessIntentData = v.InferInput<typeof EditListAccessIntentDataSchema>;
+export type EditListAccessSuccessResponse = SuccessIntentResponse<{
+    list: List;
+}>;
+export declare class EditListAccessHandler extends IntentHandler<"edit:list-access"> {
+    invoke(data: EditListAccessIntentData): Promise<IntentResponse<"edit:list-access">>;
+}

package/dist/intents/handlers/open-list-menu-handler.d.ts

@@ -1,13 +1,15 @@
 import * as v from "valibot";
 import { IntentHandler } from "../intent-handler";
 import { IntentResponse } from "../types";
-import { EditListSuccessResponse } from "./edit-list-handler";
 import { DeleteListSuccessResponse } from "./delete-list-handler";
+import { EditListAccessSuccessResponse } from "./edit-list-access-handler";
+import { EditListSuccessResponse } from "./edit-list-handler";
+import { ShareListSuccessResponse } from "./share-list-handler";
 export declare const OpenListMenuIntentDataSchema: v.ObjectSchema<{
     readonly listId: v.StringSchema<undefined>;
 }, undefined>;
 export type OpenListMenuIntentData = v.InferInput<typeof OpenListMenuIntentDataSchema>;
-export type OpenListMenuSuccessResponse = EditListSuccessResponse | DeleteListSuccessResponse;
-export declare class OpenListMenuHandler extends IntentHandler<"open:list-menu" | "edit:list" | "delete:list"> {
-    invoke(data: OpenListMenuIntentData): Promise<IntentResponse<"open:list-menu" | "edit:list" | "delete:list">>;
+export type OpenListMenuSuccessResponse = EditListSuccessResponse | DeleteListSuccessResponse | EditListAccessSuccessResponse | ShareListSuccessResponse;
+export declare class OpenListMenuHandler extends IntentHandler<"open:list-menu" | "edit:list" | "delete:list" | "edit:list-access" | "share:list"> {
+    invoke(data: OpenListMenuIntentData): Promise<IntentResponse<"open:list-menu" | "edit:list" | "delete:list" | "edit:list-access" | "share:list">>;
 }

package/dist/intents/handlers/share-list-handler.d.ts

@@ -0,0 +1,16 @@
+import * as v from "valibot";
+import { IntentHandler } from "../intent-handler";
+import { IntentResponse, SuccessIntentResponse } from "../types";
+export declare const ShareListIntentDataSchema: v.ObjectSchema<{
+    readonly listId: v.StringSchema<undefined>;
+}, undefined>;
+export type ShareListIntentData = v.InferInput<typeof ShareListIntentDataSchema>;
+export type ShareListSuccessResponse = SuccessIntentResponse<{
+    listId: string;
+    url: string;
+    method: "native" | "clipboard";
+    publicListId?: string;
+}>;
+export declare class ShareListHandler extends IntentHandler<"share:list"> {
+    invoke(data: ShareListIntentData): Promise<IntentResponse<"share:list">>;
+}

package/dist/intents/handlers/show-toast-handler.d.ts

@@ -9,6 +9,8 @@ export declare const ToastIntentDataSchema: v.ObjectSchema<{
         readonly label: v.StringSchema<undefined>;
         readonly url: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
     }, undefined>, undefined>;
+    readonly variant: v.OptionalSchema<v.PicklistSchema<["compact", "full"], undefined>, undefined>;
+    readonly icon: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
 }, undefined>;
 export type ToastIntentData = v.InferInput<typeof ToastIntentDataSchema>;
 export type ToastSuccessResponse = SuccessIntentResponse<void>;

package/dist/intents/handlers/unsave-item-handler.d.ts

@@ -0,0 +1,14 @@
+import * as v from "valibot";
+import { IntentHandler } from "../intent-handler";
+import { IntentResponse, SuccessIntentResponse } from "../types";
+export declare const UnsaveItemIntentDataSchema: v.ObjectSchema<{
+    readonly itemId: v.StringSchema<undefined>;
+    readonly delete: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+}, undefined>;
+export type UnsaveItemIntentData = v.InferInput<typeof UnsaveItemIntentDataSchema>;
+export type UnsaveItemSuccessResponse = SuccessIntentResponse<{
+    itemId: string;
+}>;
+export declare class UnsaveItemHandler extends IntentHandler<"unsave:item" | "edit:item-lists"> {
+    invoke(data: UnsaveItemIntentData): Promise<IntentResponse<"unsave:item" | "edit:item-lists">>;
+}

package/dist/intents/hooks/after-edit-list-access-hook.d.ts

@@ -0,0 +1,5 @@
+import { IntentHook } from "../intent-hook";
+import { IntentResponse } from "../types";
+export declare class AfterEditListAccessHook extends IntentHook<"edit:list-access"> {
+    invoke(response: IntentResponse<"edit:list-access">): Promise<void>;
+}

package/dist/intents/hooks/after-share-list-hook.d.ts

@@ -0,0 +1,5 @@
+import { IntentHook } from "../intent-hook";
+import { IntentResponse } from "../types";
+export declare class AfterShareListHook extends IntentHook<"share:list"> {
+    invoke(response: IntentResponse<"share:list">): Promise<void>;
+}

package/dist/intents/intents.d.ts

@@ -1,20 +1,20 @@
 import { SwishApp } from "../swish";
-import { Intent, IntentActivity, IntentQueryWithParams, IntentResponse, IntentToData } from "./types";
 import { SwishUi } from "../swish-ui/swish-ui";
+import { Intent, IntentActivity, IntentQueryWithParams, IntentResponse, IntentToData } from "./types";
 export interface IntentOptions {
-    save: {
-        requireVariant: boolean;
-        requireVariantConfirmation: boolean;
-        showToast: boolean;
+    saveProduct: {
+        promptVariantIfMissing: boolean;
+        promptVariantIfPresent: boolean;
+        showFeedback: boolean;
     };
-    edit: {
-        requireVariantConfirmation: boolean;
-        showToast: boolean;
+    unsaveProduct: {
+        selectList: boolean;
+        confirm: boolean;
+        showFeedback: boolean;
     };
-    unsave: {
-        requireConfirmation: boolean;
-        openEditor: boolean;
-        showToast: boolean;
+    editSavedProduct: {
+        promptVariantChange: boolean;
+        showFeedback: boolean;
     };
 }
 export declare class Intents {

package/dist/intents/types.d.ts

@@ -1,27 +1,30 @@
-import type { SaveItemIntentData, SaveItemSuccessResponse } from "./handlers/save-item-handler";
-import type { DeleteItemIntentData, DeleteItemSuccessResponse } from "./handlers/delete-item-handler";
-import type { EditItemVariantIntentData, EditItemVariantSuccessResponse } from "./handlers/edit-item-variant-handler";
+import type { CreateListIntentData, CreateListSuccessResponse } from "./handlers/create-list-handler";
+import type { CreateCartLineIntentData, CreateCartLineSuccessResponse } from "./handlers/create-cart-line-handler";
+import type { DeleteListIntentData, DeleteListSuccessResponse } from "./handlers/delete-list-handler";
 import type { EditItemListsIntentData, EditItemListsSuccessResponse } from "./handlers/edit-item-lists-handler";
+import type { EditItemVariantIntentData, EditItemVariantSuccessResponse } from "./handlers/edit-item-variant-handler";
+import type { EditListAccessIntentData, EditListAccessSuccessResponse } from "./handlers/edit-list-access-handler";
 import type { EditListIntentData, EditListSuccessResponse } from "./handlers/edit-list-handler";
-import type { DeleteListIntentData, DeleteListSuccessResponse } from "./handlers/delete-list-handler";
-import type { CreateListIntentData, CreateListSuccessResponse } from "./handlers/create-list-handler";
 import type { OpenHomeSuccessResponse } from "./handlers/open-home-handler";
-import type { OpenListMenuIntentData, OpenListMenuSuccessResponse } from "./handlers/open-list-menu-handler";
-import type { OpenSignInIntentData, OpenSignInSuccessResponse } from "./handlers/open-sign-in-handler";
-import type { OpenQuickBuyIntentData, OpenQuickBuySuccessResponse } from "./handlers/open-quick-buy-handler";
 import type { OpenListDetailPageMenuIntentData, OpenListDetailPageMenuSuccessResponse } from "./handlers/open-list-detail-page-menu-handler";
-import { ToastIntentData, ToastSuccessResponse } from "./handlers/show-toast-handler";
+import { OpenListIntentData, OpenListSuccessResponse } from "./handlers/open-list-handler";
+import type { OpenListMenuIntentData, OpenListMenuSuccessResponse } from "./handlers/open-list-menu-handler";
 import { OpenListsSuccessResponse } from "./handlers/open-lists-handler";
-import { OpenOrdersSuccessResponse } from "./handlers/open-orders-handler";
-import { OpenSavesSuccessResponse } from "./handlers/open-saves-handler";
 import { OpenNotificationsSuccessResponse } from "./handlers/open-notifications-handler";
-import { OpenProfileSuccessResponse } from "./handlers/open-profile-handler";
-import { OpenListIntentData, OpenListSuccessResponse } from "./handlers/open-list-handler";
-import { OpenProductIntentData, OpenProductSuccessResponse } from "./handlers/open-product-handler";
 import { OpenOrderIntentData, OpenOrderSuccessResponse } from "./handlers/open-order-handler";
 import type { OpenOrderMenuIntentData, OpenOrderMenuSuccessResponse } from "./handlers/open-order-menu-handler";
-export type { DeleteItemSuccessResponse, EditItemVariantSuccessResponse, EditItemListsSuccessResponse, SaveItemSuccessResponse, EditListSuccessResponse, DeleteListSuccessResponse, CreateListSuccessResponse, ToastSuccessResponse, };
-export type Intent = "save:item" | "edit:item-variant" | "edit:item-lists" | "delete:item" | "edit:list" | "delete:list" | "create:list" | "open:home" | "open:list" | "open:lists" | "open:orders" | "open:order" | "open:saves" | "open:notifications" | "open:profile" | "open:product" | "open:list-menu" | "open:order-menu" | "open:list-detail-page-menu" | "open:sign-in" | "open:quick-buy" | "show:toast";
+import { OpenOrdersSuccessResponse } from "./handlers/open-orders-handler";
+import { OpenProductIntentData, OpenProductSuccessResponse } from "./handlers/open-product-handler";
+import { OpenProfileSuccessResponse } from "./handlers/open-profile-handler";
+import type { OpenQuickBuyIntentData, OpenQuickBuySuccessResponse } from "./handlers/open-quick-buy-handler";
+import { OpenSavesSuccessResponse } from "./handlers/open-saves-handler";
+import type { OpenSignInIntentData, OpenSignInSuccessResponse } from "./handlers/open-sign-in-handler";
+import type { SaveItemIntentData, SaveItemSuccessResponse } from "./handlers/save-item-handler";
+import type { ShareListIntentData, ShareListSuccessResponse } from "./handlers/share-list-handler";
+import { ToastIntentData, ToastSuccessResponse } from "./handlers/show-toast-handler";
+import type { UnsaveItemIntentData, UnsaveItemSuccessResponse } from "./handlers/unsave-item-handler";
+export type { CreateCartLineSuccessResponse, CreateListSuccessResponse, DeleteListSuccessResponse, EditItemListsSuccessResponse, EditItemVariantSuccessResponse, EditListAccessSuccessResponse, EditListSuccessResponse, SaveItemSuccessResponse, ShareListSuccessResponse, ToastSuccessResponse, UnsaveItemSuccessResponse, };
+export type Intent = "create:cart-line" | "save:item" | "edit:item-variant" | "edit:item-lists" | "unsave:item" | "edit:list" | "edit:list-access" | "delete:list" | "create:list" | "share:list" | "open:home" | "open:list" | "open:lists" | "open:orders" | "open:order" | "open:saves" | "open:notifications" | "open:profile" | "open:product" | "open:list-menu" | "open:order-menu" | "open:list-detail-page-menu" | "open:sign-in" | "open:quick-buy" | "show:toast";
 export type IntentQueryParam = `${string}=${string}`;
 export type IntentQueryWithParams = `${Intent},${IntentQueryParam}`;
 export type IntentResponse<I extends Intent = Intent> = ClosedIntentResponse<I> | ErrorIntentResponse<I> | IntentToSuccessResponse<I>;
@@ -48,13 +51,16 @@ export interface SuccessIntentResponse<T, I extends Intent = Intent> extends Int
     data: T;
 }
 interface IntentDataMap {
+    "create:cart-line": CreateCartLineIntentData;
     "save:item": SaveItemIntentData;
     "edit:item-variant": EditItemVariantIntentData;
     "edit:item-lists": EditItemListsIntentData;
-    "delete:item": DeleteItemIntentData;
+    "unsave:item": UnsaveItemIntentData;
     "edit:list": EditListIntentData;
+    "edit:list-access": EditListAccessIntentData;
     "delete:list": DeleteListIntentData;
     "create:list": CreateListIntentData;
+    "share:list": ShareListIntentData;
     "open:home": void;
     "open:list": OpenListIntentData;
     "open:lists": void;
@@ -72,13 +78,16 @@ interface IntentDataMap {
     "show:toast": ToastIntentData;
 }
 interface IntentSuccessResponseMap {
+    "create:cart-line": CreateCartLineSuccessResponse;
     "save:item": SaveItemSuccessResponse;
     "edit:item-variant": EditItemVariantSuccessResponse;
-    "edit:item-lists": EditItemListsSuccessResponse | DeleteItemSuccessResponse;
-    "delete:item": DeleteItemSuccessResponse;
+    "edit:item-lists": EditItemListsSuccessResponse | UnsaveItemSuccessResponse;
+    "unsave:item": UnsaveItemSuccessResponse;
     "edit:list": EditListSuccessResponse;
+    "edit:list-access": EditListAccessSuccessResponse;
     "delete:list": DeleteListSuccessResponse;
     "create:list": CreateListSuccessResponse;
+    "share:list": ShareListSuccessResponse;
     "open:home": OpenHomeSuccessResponse;
     "open:list": OpenListSuccessResponse;
     "open:lists": OpenListsSuccessResponse;

package/dist/options/swish-options.d.ts

@@ -1,13 +1,16 @@
+import { IntentOptions } from "../intents/intents";
 import { StorefrontApiOptions, SwishClientConfig } from "../swish";
-import { StorefrontContext, SwishBadgeOptions, SwishMetafieldOptions, SwishOptions, SwishUiOptions } from "./types";
+import { StorefrontContext, SwishBadgeOptions, SwishFeaturesOptions, SwishMetafieldOptions, SwishOptions, SwishUiOptions } from "./types";
 export type SwishOptionsInput = {
     storefrontApi: StorefrontApiOptions;
     storefrontContext: StorefrontContext;
-    badges?: SwishBadgeOptions;
-    metafields?: SwishMetafieldOptions;
     swishApi?: SwishClientConfig & {
         version: string;
     };
     swishUi?: SwishUiOptions;
+    badges?: SwishBadgeOptions;
+    metafields?: SwishMetafieldOptions;
+    features?: SwishFeaturesOptions;
+    intents?: IntentOptions;
 };
 export declare const createSwishOptions: (options: SwishOptionsInput) => SwishOptions;

package/dist/options/types.d.ts

@@ -5,12 +5,14 @@ import { Badge } from "../utils/shopify-badge-utils";
 export interface SwishOptions {
     storefrontApi: StorefrontApiOptions;
     storefrontContext: StorefrontContext;
-    badges: SwishBadgeOptions;
-    metafields: SwishMetafieldOptions;
     swishApi: SwishClientConfig & {
         version: string;
     };
     swishUi: SwishUiOptions;
+    features: SwishFeaturesOptions;
+    intents: IntentOptions;
+    metafields: SwishMetafieldOptions;
+    badges: SwishBadgeOptions;
 }
 export interface SwishMetafieldOptions {
     product: `${string}.${string}`[];
@@ -23,14 +25,82 @@ export interface SwishBadgeOptions {
         defaultBadges: string[];
     }) => (string | Badge)[];
 }
+export interface SwishUiDesignOptions {
+    appearance?: {
+        iconThickness?: number | string;
+    };
+    sizes?: {
+        buttonHeight?: number | string;
+        iconButtonSize?: number | string;
+        formInputHeight?: number | string;
+        iconSize?: number | string;
+        imageCardAspectRatio?: string;
+        imageSliderAspectRatio?: string;
+    };
+    rounding?: {
+        borderRadiusScale?: number | string;
+        badgeBorderRadius?: string;
+        buttonBorderRadius?: string;
+        dialogBorderRadius?: string;
+        formInputBorderRadius?: string;
+        imageCardBorderRadius?: string;
+        imageSliderBorderRadius?: string;
+        thumbnailBorderRadius?: string;
+    };
+    colors?: {
+        backgroundRgb?: string;
+        textColorRgb?: string;
+        textColorDangerRgb?: string;
+        headingColorRgb?: string;
+        primaryButtonBackgroundRgb?: string;
+        primaryButtonColorRgb?: string;
+        secondaryButtonBackgroundRgb?: string;
+        secondaryButtonColorRgb?: string;
+        dangerButtonColorRgb?: string;
+        statusDotBackgroundRgb?: string;
+        badgeBackgroundRgb?: string;
+        badgeColorRgb?: string;
+    };
+    typography?: {
+        headingFontFamily?: string;
+        headingTextTransform?: string;
+        headingFontSize?: number | string;
+        headingLetterSpacing?: string;
+        headingLineHeight?: number | string;
+        headingFontWeight?: number | string;
+        textFontFamily?: string;
+        textFontSize?: number | string;
+        textLetterSpacing?: string;
+        textLineHeight?: number | string;
+        textLineHeightParagraph?: number | string;
+        textFontWeight?: number | string;
+        buttonFontFamily?: string;
+        buttonTextTransform?: string;
+        buttonFontSize?: number | string;
+        buttonLetterSpacing?: string;
+        buttonLineHeight?: number | string;
+        buttonFontWeight?: number | string;
+        badgeFontFamily?: string;
+        badgeTextTransform?: string;
+        badgeFontSize?: number | string;
+        badgeLetterSpacing?: string;
+        badgeLineHeight?: number | string;
+        badgeFontWeight?: number | string;
+    };
+}
 export interface SwishUiOptions {
     baseUrl: string;
     components: SwishComponentOptions;
     css: (string | URL)[];
-    intents: IntentOptions;
-    theme: Record<string, string>;
+    design: SwishUiDesignOptions;
     version: string;
 }
+export interface SwishFeaturesOptions {
+    accounts: boolean;
+    lists: boolean;
+    orders: boolean;
+    notifications: boolean;
+}
 export interface StorefrontContext {
     customer: {
         id: string | null;
@@ -45,10 +115,13 @@ export interface StorefrontContext {
         market: string;
     };
     myshopifyDomain: string;
-    newCustomAccounts: boolean;
+    capabilities: {
+        newCustomerAccounts: boolean;
+    };
     routes: {
         accountUrl: string;
         rootUrl: string;
+        listDetailPagePath: string;
     };
 }
 export interface SwishComponentOptions {
@@ -96,6 +169,7 @@ export interface SwishDrawerNavigationItem {
     intent: Intent;
 }
 export interface SwishDrawerNavigationOptions {
+    enabled: boolean;
     variant: SwishDrawerNavigationVariant;
     items: SwishDrawerNavigationItem[];
 }
@@ -104,6 +178,7 @@ export interface SwishDrawerMiniMenuItem {
     url: string;
 }
 export interface SwishDrawerMiniMenuOptions {
+    enabled: boolean;
     items: SwishDrawerMiniMenuItem[];
 }
 export interface SwishDrawerListDetailViewOptions {
@@ -120,4 +195,8 @@ export interface SwishDrawerOptions {
     navigation: SwishDrawerNavigationOptions;
     miniMenu: SwishDrawerMiniMenuOptions;
     listDetailView: SwishDrawerListDetailViewOptions;
+    emptyCallout: SwishDrawerEmptyCalloutOptions;
+}
+export interface SwishDrawerEmptyCalloutOptions {
+    shoppingCalloutUrl: string;
 }

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

@@ -23,6 +23,7 @@ export declare class SwishApi {
         count: () => Promise<ApiResponse<ItemCount>>;
         list: (query?: ItemControllerFindData["query"], options?: {
             batch?: boolean;
+            shared?: boolean;
         }) => Promise<PaginatedApiResponse<Item>>;
         findById: (itemId: string) => Promise<ApiResponse<ItemDetail>>;
         create: (items: import("@swishapp/api-client").CreateItemInput) => Promise<ApiResponse<Item>>;
@@ -33,7 +34,9 @@ export declare class SwishApi {
     };
     get lists(): {
         list: (query?: ListControllerFindData["query"]) => Promise<PaginatedApiResponse<ListDetail>>;
-        findById: (listId: string) => Promise<ApiResponse<ListDetail>>;
+        findById: (listId: string, options?: {
+            shared?: boolean;
+        }) => 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>>;

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

@@ -4,6 +4,7 @@ export interface Ref<T> {
 declare const BaseElement: typeof HTMLElement;
 export declare class SwishUiElement extends BaseElement {
     constructor();
+    connectedCallback(): void;
     private componentRef;
     getComponentRef: <TComponent = unknown>() => Ref<TComponent>;
     setComponentRef: <TComponent = unknown>(ref: Ref<TComponent>) => void;

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

@@ -1,11 +1,11 @@
 import { StorefrontContext, SwishUiOptions } from "../options/types";
-import type { SwishUiElement } from "./swish-ui-element";
-import { DeleteListAlertOptions, DrawerOptions, ListDetailPageOptions, ListDetailPageMenuOptions, ListEditorOptions, ListEditorSubmitData, ListMenuOptions, ListMenuResponse, ListSelectOptions, ListSelectResponse, OrderMenuOptions, OrderMenuResponse, QuickBuyOptions, QuickBuySubmitData, RequireUiComponentOptions, SignInOptions, Toast, UiResponse, UnsaveAlertOptions, UnsaveAlertSubmitData, VariantSelectOptions, VariantSelectSubmitData } from "./types";
+import type { Ref, SwishUiElement } from "./swish-ui-element";
+import { ConfirmDialogOptions, DeleteListAlertOptions, DrawerOptions, ListDetailPageMenuOptions, ListDetailPageOptions, ListEditorOptions, ListEditorSubmitData, ListMenuOptions, ListMenuResponse, ListSelectOptions, ListSelectResponse, OrderMenuOptions, OrderMenuResponse, QuickBuyOptions, QuickBuySubmitData, RequireUiComponentOptions, SignInOptions, Toast, UiResponse, UnsaveAlertOptions, UnsaveAlertSubmitData, VariantSelectOptions, VariantSelectSubmitData } from "./types";
 export declare class SwishUi {
-    private storefrontContext;
-    private swishUiOptions;
-    private inflightModals;
-    private modalsWithScrollLock;
+    private readonly storefrontContext;
+    private readonly swishUiOptions;
+    private readonly inflightModals;
+    private readonly modalsWithScrollLock;
     private scrollLockStyleSheet;
     private scrollLockRefCount;
     private scrollPositionBeforeLock;
@@ -16,6 +16,7 @@ export declare class SwishUi {
     showSignIn(options?: SignInOptions): Promise<UiResponse<void>>;
     showUnsaveAlert(options: UnsaveAlertOptions): Promise<UiResponse<UnsaveAlertSubmitData>>;
     showDeleteListAlert(options: DeleteListAlertOptions): Promise<UiResponse<void>>;
+    showConfirmDialog(options: ConfirmDialogOptions): Promise<UiResponse<void>>;
     showDrawer(options?: DrawerOptions): Promise<UiResponse<void>>;
     showListMenu(options: ListMenuOptions): Promise<ListMenuResponse>;
     showOrderMenu(options: OrderMenuOptions): Promise<OrderMenuResponse>;
@@ -27,7 +28,13 @@ export declare class SwishUi {
     showVariantSelect(options?: VariantSelectOptions): Promise<UiResponse<VariantSelectSubmitData>>;
     showQuickBuy(options?: QuickBuyOptions): Promise<UiResponse<QuickBuySubmitData>>;
     showListEditor(options?: ListEditorOptions): Promise<UiResponse<ListEditorSubmitData>>;
+    createElement<T extends SwishUiElement>(name: string, options?: RequireUiComponentOptions<T>): Promise<T>;
+    hydrateElement<T extends SwishUiElement>(name: string, element: T, onHydrated?: (ref: Ref<T>) => void): Promise<void>;
     requireUiComponent<TComponent = unknown>(name: string, options?: RequireUiComponentOptions<TComponent>): Promise<SwishUiElement>;
+    private _templatePromises;
+    loadTemplate(name: string): Promise<string>;
+    private _importPromises;
+    importScript(name: string): Promise<any>;
     private _loadCricalResourcesPromise;
     loadCricalResources(): Promise<{
         themeVariablesStylesheet: CSSStyleSheet;
@@ -37,9 +44,8 @@ export declare class SwishUi {
         bundleCssStylesheet: CSSStyleSheet;
         customCssStylesheets: CSSStyleSheet[];
     }>;
-    insertComponent<T extends HTMLElement = SwishUiElement>({ name, instance, template, position, refElement, }: {
+    insertComponent<T extends HTMLElement = SwishUiElement>({ name, template, position, refElement, }: {
         name: string;
-        instance?: string;
         template: string;
         position: InsertPosition;
         refElement: HTMLElement;