@brytdesigns/shopify-ajax-cart 1.1.8 → 3.0.0

package/dist/main/actions.d.ts

@@ -0,0 +1,378 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import * as Cause from 'effect/Cause';
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Layer from 'effect/Layer';
+import * as LogLevel from 'effect/LogLevel';
+import * as Scope from 'effect/Scope';
+
+declare const toAsyncCallback: <Args extends ReadonlyArray<unknown>, A, E, R>(services: Context.Context<R>, f: (...args: Args) => Effect.Effect<A, E, R>) => (...args: Args) => Promise<A>;
+declare const toSyncCallback: <Args extends ReadonlyArray<unknown>, A, R>(services: Context.Context<R>, f: (...args: Args) => Effect.Effect<A, never, R>, onAbnormal: (cause: Cause.Cause<never>) => A) => (...args: Args) => A;
+declare const fromPromiseThunk: <A, E>(thunk: () => Promise<A>, onReject: (cause: unknown) => E) => Effect.Effect<A, E>;
+/** Every action exposed on `window.Shopify.actions`. */
+export type ActionName = "getCart" | "updateCart" | "openCart";
+/**
+ * Only `updateCart` and `openCart` are `ActionFunction`s — `getCart` is a bare
+ * callable with no `configure()` / `isDefault()`.
+ */
+export type ConfigurableActionName = Exclude<ActionName, "getCart">;
+declare const ActionsUnavailableError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{
+	readonly [P in keyof A as P extends "_tag" ? never : P]: A[P];
+}>) => import("effect/Cause").YieldableError & {
+	readonly _tag: "@brytdesigns/shopify-utils/ActionsUnavailableError";
+} & Readonly<A>;
+declare class ActionsUnavailableError extends ActionsUnavailableError_base<{
+	readonly action: ActionName;
+	readonly message: string;
+}> {
+	constructor(options: {
+		readonly action: ActionName;
+	});
+}
+declare const ActionConfigurationRejectedError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{
+	readonly [P in keyof A as P extends "_tag" ? never : P]: A[P];
+}>) => import("effect/Cause").YieldableError & {
+	readonly _tag: "@brytdesigns/shopify-utils/ActionConfigurationRejectedError";
+} & Readonly<A>;
+declare class ActionConfigurationRejectedError extends ActionConfigurationRejectedError_base<{
+	readonly action: ConfigurableActionName;
+	readonly message: string;
+}> {
+	constructor(options: {
+		readonly action: ConfigurableActionName;
+	});
+}
+declare const ActionInvocationError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{
+	readonly [P in keyof A as P extends "_tag" ? never : P]: A[P];
+}>) => import("effect/Cause").YieldableError & {
+	readonly _tag: "@brytdesigns/shopify-utils/ActionInvocationError";
+} & Readonly<A>;
+declare class ActionInvocationError extends ActionInvocationError_base<{
+	readonly action: ActionName;
+	readonly cause: unknown;
+	readonly message: string;
+}> {
+	constructor(options: {
+		readonly action: ActionName;
+		readonly cause: unknown;
+	});
+}
+// -----------------------------------------------------------------------------
+// VENDORED FILE — DO NOT EDIT BY HAND.
+//
+// Source:    https://cdn.shopify.com/storefront/standard-actions.d.ts
+// Vendored:  2026-08-13
+// Upstream version (see `// version:` line below): 977e4f914dd2b3eca85ad01dee81c2c96eb1b2e5
+// sha256 (upstream body only, i.e. everything below this header):
+//            2f0fc044f35999cd09550b8b68620077601d1409817edae16745e600417788e7
+//
+// Everything below this header is the upstream file byte-for-byte. To diff
+// against a future revision:
+//
+//   curl -sSL https://cdn.shopify.com/storefront/standard-actions.d.ts \
+//     | diff - <(tail -n +25 shopify/utils/src/types/standard-actions.d.ts)
+//
+// There is NO npm package for this. Shopify injects the runtime on every Liquid
+// storefront as `window.Shopify.actions`; a module build for import maps lives
+// at https://cdn.shopify.com/storefront/standard-actions.js. Do not add a
+// dependency — import types via the `@theme/standard-actions` alias
+// (see tsconfig.json `paths`), which is marked `external` in tsup.config.ts.
+//
+// This file is excluded from Biome in the root biome.json so formatting/lint
+// never rewrites upstream content and pollutes the diff.
+// -----------------------------------------------------------------------------
+// version: 977e4f914dd2b3eca85ad01dee81c2c96eb1b2e5
+export interface Price {
+	amount: string;
+	currencyCode: string;
+}
+export interface CartDiscountCode {
+	applicable: boolean;
+	code: string;
+}
+export interface CartCost {
+	totalAmount: Price;
+}
+export interface CartLine {
+	id: string;
+	quantity: number;
+	cost: CartCost;
+}
+export interface CartMutationUserError {
+	code?: string;
+	field?: string[];
+	message: string;
+}
+export interface CartMutationWarning {
+	code?: string;
+	message: string;
+	target?: string;
+}
+declare const CART_UPDATE_CONTEXTS: readonly [
+	"product",
+	"cart",
+	"dialog",
+	"standard-action"
+];
+export type CartUpdateContext = (typeof CART_UPDATE_CONTEXTS)[number];
+declare const CART_UPDATE_ACTIONS: readonly [
+	"add",
+	"remove",
+	"update"
+];
+export type CartUpdateAction = (typeof CART_UPDATE_ACTIONS)[number];
+export type ActionArgs<P, O = void> = [
+	P
+] extends [
+	void
+] ? [
+	options?: O
+] : [
+	Extract<P, void>
+] extends [
+	never
+] ? [
+	payload: P,
+	options?: O
+] : [
+	payload?: Exclude<P, void>,
+	options?: O
+];
+export type UpdateCartUserError = CartMutationUserError;
+export type UpdateCartWarning = CartMutationWarning;
+export interface CartAttributeInput {
+	key: string;
+	value: string;
+}
+export interface StorefrontCartLinesConnection {
+	nodes: CartLine[];
+}
+export interface StorefrontCartSummary {
+	id: string;
+	totalQuantity: number;
+	cost: CartCost;
+	lines: StorefrontCartLinesConnection;
+	discountCodes: CartDiscountCode[];
+}
+export type UpdateCartEventTargetMeta = {
+	type: "shopify:cart:lines-update";
+	action: CartUpdateAction;
+} | {
+	type: "shopify:cart:note-update" | "shopify:cart:attributes-update" | "shopify:cart:discount-update" | "shopify:cart:error";
+};
+export interface CartLineInput {
+	/**
+	 * Existing-line id from SFAPI or the AJAX cart API.
+	 * CartLine GIDs keep or receive a `?cart=` suffix automatically when the cart id is known.
+	 * Present = update/remove; absent = add.
+	 */
+	id?: string;
+	/** ProductVariant GID or raw variant id. Required for add. */
+	merchandiseId?: string;
+	/** Set to 0 to remove. */
+	quantity: number;
+	/** Line item-level custom attributes */
+	attributes?: CartAttributeInput[];
+	/** Selling plan GID or raw selling plan id. */
+	sellingPlanId?: string;
+}
+export interface UpdateCartPayload {
+	/** Cart GID or raw cart token. If omitted, discovered from the cart cookie. */
+	cartId?: string;
+	lines?: CartLineInput[];
+	note?: string;
+	discountCodes?: string[];
+	/** Cart-level custom attributes */
+	attributes?: CartAttributeInput[];
+}
+export interface UpdateCartResult {
+	cart: StorefrontCartSummary;
+	userErrors?: UpdateCartUserError[];
+	warnings?: UpdateCartWarning[];
+	detail?: Record<string, any>;
+}
+export interface UpdateCartOptions {
+	signal?: AbortSignal;
+	event?: {
+		detail?: Record<string, any>;
+		context?: CartUpdateContext;
+	};
+}
+export interface GetCartPayload {
+	/** Cart GID or raw cart token. If omitted, discovered from the browser cookie. */
+	cartId?: string;
+}
+export interface GetCartResult {
+	cart: StorefrontCartSummary | null;
+	detail?: Record<string, any>;
+}
+export interface GetCartOptions {
+	signal?: AbortSignal;
+}
+/**
+ * The default handler, lifted into Effect-land.
+ *
+ * Handlers receive this rather than a pre-computed result so they keep the full
+ * range of the upstream contract: run the default, wrap it, retry it, race it,
+ * or skip it entirely and synthesise a result.
+ */
+export type DefaultHandler<A> = Effect.Effect<A, ActionInvocationError>;
+/**
+ * An action handler written in Effect.
+ *
+ * The returned Effect's success value is what the action resolves with, and its
+ * failure becomes a rejected promise for Shopify.
+ *
+ * Note that `E` is checked but never surfaces to the fiber that called
+ * `configure` — the handler runs long afterwards, when a shopper triggers the
+ * action, so its failure has nowhere to go but the promise Shopify awaits. If
+ * you want handler failures observed, observe them inside the handler.
+ */
+export type Handler<P, A, O, E, R> = (defaultHandler: DefaultHandler<A>, ...args: ActionArgs<P, O>) => Effect.Effect<A, E, R>;
+/**
+ * Resolves the element that `shopify:cart:*` events are dispatched from.
+ *
+ * The error channel is `never` on purpose. Shopify calls this synchronously and
+ * uses the return value immediately, so there is nowhere for a failure to go —
+ * handle errors inside the Effect and fall back to an element or `null`.
+ *
+ * For the same reason this Effect must complete synchronously. Anything that
+ * suspends (`Effect.sleep`, an HTTP call, an async service) cannot produce a
+ * value in time and is reported as `null` with a logged defect, which makes
+ * Shopify dispatch on `document`. If you need async work, resolve it ahead of
+ * time into a `Ref` and read the `Ref` here.
+ */
+export type EventTargetResolver<R> = (meta: UpdateCartEventTargetMeta) => Effect.Effect<EventTarget | null, never, R>;
+export interface UpdateCartConfiguration<E, R> {
+	readonly eventTarget: EventTargetResolver<R>;
+	/** Optional: routing events without changing cart behaviour is valid. */
+	readonly handler?: Handler<UpdateCartPayload, UpdateCartResult, UpdateCartOptions, E, R>;
+}
+export interface OpenCartConfiguration<E, R> {
+	/**
+	 * Required, unlike `updateCart`'s. `openCart` has no event target, so a
+	 * configuration without a handler would claim the one-shot upstream slot
+	 * while contributing nothing — locking everyone else out for the life of
+	 * the page in exchange for default behaviour.
+	 */
+	readonly handler: Handler<void, void, void, E, R>;
+}
+export interface ShopifyStorefrontActionsImpl {
+	/**
+	 * Read the current cart. `getCart` is a bare callable upstream — it has no
+	 * `configure()`, so there is no `configureGetCart`.
+	 */
+	readonly getCart: (payload?: GetCartPayload, options?: GetCartOptions) => Effect.Effect<GetCartResult, ActionsUnavailableError | ActionInvocationError>;
+	readonly updateCart: (payload: UpdateCartPayload, options?: UpdateCartOptions) => Effect.Effect<UpdateCartResult, ActionsUnavailableError | ActionInvocationError>;
+	readonly openCart: Effect.Effect<void, ActionsUnavailableError | ActionInvocationError>;
+	/**
+	 * Install an Effect-based `updateCart` configuration for the lifetime of the
+	 * enclosing `Scope`.
+	 *
+	 * The `R` of the supplied Effects flows out into the returned Effect's
+	 * requirements, so the services your handler needs stay explicit and must be
+	 * provided before this runs — they are captured, not smuggled.
+	 *
+	 * Calling this more than once rebinds rather than failing: we claim the
+	 * upstream slot once and swap our own configuration behind it. A
+	 * `ActionConfigurationRejectedError` therefore means one specific thing —
+	 * something outside this library claimed the action first.
+	 *
+	 * For page-lifetime registration, build it into a layer with
+	 * `Layer.effectDiscard(Actions.configureUpdateCart({ ... }))` so the
+	 * registration lives exactly as long as the runtime does.
+	 */
+	readonly configureUpdateCart: <E, R>(config: UpdateCartConfiguration<E, R>) => Effect.Effect<void, ActionsUnavailableError | ActionConfigurationRejectedError, R | Scope.Scope>;
+	readonly configureOpenCart: <E, R>(config: OpenCartConfiguration<E, R>) => Effect.Effect<void, ActionsUnavailableError | ActionConfigurationRejectedError, R | Scope.Scope>;
+	/**
+	 * Upstream's own notion: `true` until the action's slot is claimed.
+	 *
+	 * Because the slot can never be released, this stays `false` once we have
+	 * claimed it, even after every configuration has been deactivated.
+	 */
+	readonly isDefault: (action: ConfigurableActionName) => Effect.Effect<boolean, ActionsUnavailableError>;
+}
+declare const ShopifyStorefrontActions_base: Context.ServiceClass<ShopifyStorefrontActions, "@brytdesigns/shopify-utils/ShopifyStorefrontActions", ShopifyStorefrontActionsImpl>;
+declare class ShopifyStorefrontActions extends ShopifyStorefrontActions_base {
+}
+declare const layer: Layer.Layer<ShopifyStorefrontActions, never, never>;
+declare const getCart: (payload?: GetCartPayload, options?: GetCartOptions) => Effect.Effect<GetCartResult, ActionsUnavailableError | ActionInvocationError, ShopifyStorefrontActions>;
+declare const updateCart: (payload: UpdateCartPayload, options?: UpdateCartOptions) => Effect.Effect<UpdateCartResult, ActionsUnavailableError | ActionInvocationError, ShopifyStorefrontActions>;
+declare const openCart: Effect.Effect<void, ActionsUnavailableError | ActionInvocationError, ShopifyStorefrontActions>;
+declare const configureUpdateCart: <E, R>(config: UpdateCartConfiguration<E, R>) => Effect.Effect<void, ActionsUnavailableError | ActionConfigurationRejectedError, Scope.Scope | ShopifyStorefrontActions | R>;
+declare const configureOpenCart: <E, R>(config: OpenCartConfiguration<E, R>) => Effect.Effect<void, ActionsUnavailableError | ActionConfigurationRejectedError, Scope.Scope | ShopifyStorefrontActions | R>;
+declare const isDefault: (action: ConfigurableActionName) => Effect.Effect<boolean, ActionsUnavailableError, ShopifyStorefrontActions>;
+declare namespace Bridge {
+	export { fromPromiseThunk, toAsyncCallback, toSyncCallback };
+}
+declare namespace Actions {
+	export { ActionConfigurationRejectedError, ActionInvocationError, ActionName, ActionsUnavailableError, Bridge, CartAttributeInput, CartCost, CartDiscountCode, CartLine, CartLineInput, CartMutationUserError, CartMutationWarning, CartUpdateAction, CartUpdateContext, ConfigurableActionName, DefaultHandler, EventTargetResolver, GetCartOptions, GetCartPayload, GetCartResult, Handler, OpenCartConfiguration, Price, ShopifyStorefrontActions, ShopifyStorefrontActionsImpl, StorefrontCartLinesConnection, StorefrontCartSummary, UpdateCartConfiguration, UpdateCartEventTargetMeta, UpdateCartOptions, UpdateCartPayload, UpdateCartResult, UpdateCartUserError, UpdateCartWarning, configureOpenCart, configureUpdateCart, getCart, isDefault, layer, openCart, updateCart };
+}
+export declare namespace syncWithStorefrontActions {
+	type Options = {
+		/**
+		 * Opens the cart. Supply this and `openCart` is configured; omit it and the
+		 * action is left alone entirely.
+		 *
+		 * Shopify's default looks for `<cart-drawer-component>` or `<cart-drawer>`
+		 * with an `.open()` method and, finding neither, sets
+		 * `window.location.href = "/cart"`. Bryt themes have neither, so without a
+		 * callback here every `Shopify.actions.openCart()` navigates the shopper
+		 * off the page.
+		 *
+		 * @example
+		 * ```ts
+		 * openCart: () => {
+		 *   const drawer = document.querySelector("drawer-context#cart");
+		 *   if (drawer) drawer.isOpen = true;
+		 * }
+		 * ```
+		 */
+		openCart?: () => void;
+		/**
+		 * Chooses the element `shopify:cart:*` events are dispatched from.
+		 *
+		 * Returning `null` - the default - dispatches on `document`, which is what
+		 * Shopify does when nothing is configured. Because these events are
+		 * `bubbles: true`, returning an element is purely additive: listeners on
+		 * `document` still fire.
+		 *
+		 * Must be synchronous. Shopify uses the return value immediately.
+		 */
+		eventTarget?: (meta: Actions.UpdateCartEventTargetMeta) => EventTarget | null;
+	};
+	/** Deactivates the configuration installed by this call. */
+	type Dispose = () => Promise<void>;
+}
+/**
+ * Route Shopify's storefront cart actions through AjaxCart.
+ *
+ * Two regressions on a Bryt theme are fixed by configuring at all, before any
+ * resync happens. While `updateCart` is unconfigured, Shopify probes for Dawn's
+ * `<cart-icon>` / `<cart-items-component>` and for `cart-drawer`-family
+ * elements, and finding none falls back to `window.location.reload()`. And
+ * `openCart` falls back to navigating to `/cart`.
+ *
+ * Opt-in by design: this claims page-global, one-shot configuration slots, so
+ * it is the theme's call to make, not something that happens on import.
+ *
+ * Retries while the actions runtime is absent. Shopify installs
+ * `window.Shopify.actions` from a synchronous IIFE and announces nothing, so
+ * there is no readiness signal to wait on and script order is not ours to
+ * control.
+ *
+ * @example
+ * ```ts
+ * const dispose = await syncWithStorefrontActions({
+ *   openCart: () => { drawer.isOpen = true; },
+ * });
+ * ```
+ */
+export declare const syncWithStorefrontActions: (options?: syncWithStorefrontActions.Options) => Promise<syncWithStorefrontActions.Dispose>;
+
+export {
+	syncWithStorefrontActions as default,
+};
+
+export {};

package/dist/main/actions.js

@@ -0,0 +1,80 @@
+import { cancel, invalidate } from "./query/cart.js";
+import "./query/index.js";
+import { Actions } from "@brytdesigns/shopify-utils/effect";
+import * as Effect from "effect/Effect";
+import * as Exit from "effect/Exit";
+import * as Schedule from "effect/Schedule";
+import * as Scope from "effect/Scope";
+//#region src/actions.ts
+/**
+* Refetch `/cart.js`.
+*
+* This has to be a refetch rather than a cache write: the handler is handed a
+* `StorefrontCartSummary` (`id`, `totalQuantity`, `cost`, `lines.nodes`,
+* `discountCodes`) while `CartData` is the classic AJAX shape, with line
+* titles, images and discount allocations that the summary simply does not
+* carry.
+*
+* Cancel-then-invalidate mirrors what the `window.fetch` patch in `index.ts`
+* already does for `/cart/*` mutations.
+*
+* Failure is swallowed on purpose. Shopify rethrows whatever the handler
+* rejects with, so letting a transient `/cart.js` error escape would report an
+* add-to-cart that already succeeded - and whose cart cookie is already
+* written - to the shopper as a failure.
+*/
+var resync = Effect.promise(async () => {
+	await cancel();
+	await invalidate();
+}).pipe(Effect.catchCause((cause) => Effect.logWarning("AjaxCart resync failed after a storefront cart action", cause)));
+var configure = (options) => Effect.gen(function* () {
+	yield* Actions.configureUpdateCart({
+		eventTarget: (meta) => Effect.sync(() => options.eventTarget?.(meta) ?? null),
+		handler: (defaultAction, payload) => defaultAction.pipe(Effect.tap(() => payload.cartId === void 0 ? resync : Effect.logDebug("updateCart was given an explicit cartId; the cart cookie is not synced, so AjaxCart was left alone")))
+	});
+	const openCart = options.openCart;
+	if (openCart === void 0) return;
+	yield* Actions.configureOpenCart({ handler: () => Effect.try(() => openCart()).pipe(Effect.catchCause((cause) => Effect.logError("openCart callback threw; cart was not opened", cause))) });
+});
+/**
+* Route Shopify's storefront cart actions through AjaxCart.
+*
+* Two regressions on a Bryt theme are fixed by configuring at all, before any
+* resync happens. While `updateCart` is unconfigured, Shopify probes for Dawn's
+* `<cart-icon>` / `<cart-items-component>` and for `cart-drawer`-family
+* elements, and finding none falls back to `window.location.reload()`. And
+* `openCart` falls back to navigating to `/cart`.
+*
+* Opt-in by design: this claims page-global, one-shot configuration slots, so
+* it is the theme's call to make, not something that happens on import.
+*
+* Retries while the actions runtime is absent. Shopify installs
+* `window.Shopify.actions` from a synchronous IIFE and announces nothing, so
+* there is no readiness signal to wait on and script order is not ours to
+* control.
+*
+* @example
+* ```ts
+* const dispose = await syncWithStorefrontActions({
+*   openCart: () => { drawer.isOpen = true; },
+* });
+* ```
+*/
+var syncWithStorefrontActions = async (options = {}) => {
+	const scope = Effect.runSync(Scope.make());
+	const dispose = () => Effect.runPromise(Scope.close(scope, Exit.void));
+	try {
+		await Effect.runPromise(configure(options).pipe(Effect.retry({
+			schedule: Schedule.exponential("50 millis").pipe(Schedule.upTo({ duration: "3 seconds" })),
+			while: (error) => error instanceof Actions.ActionsUnavailableError
+		}), Scope.provide(scope), Effect.provide(Actions.layer)));
+	} catch (error) {
+		await dispose();
+		throw error;
+	}
+	return dispose;
+};
+//#endregion
+export { syncWithStorefrontActions as default, syncWithStorefrontActions };
+
+//# sourceMappingURL=actions.js.map

package/dist/main/actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.js","names":[],"sources":["../../src/actions.ts"],"sourcesContent":["// The package's ./effect entry exposes namespaces (`export * as Actions`), so\n// the wrapper is reached through the Actions namespace rather than directly.\nimport { Actions } from \"@brytdesigns/shopify-utils/effect\";\nimport * as Effect from \"effect/Effect\";\nimport * as Exit from \"effect/Exit\";\nimport * as Schedule from \"effect/Schedule\";\nimport * as Scope from \"effect/Scope\";\n\nimport { Cart } from \"./query/index.js\";\n\nexport namespace syncWithStorefrontActions {\n\texport type Options = {\n\t\t/**\n\t\t * Opens the cart. Supply this and `openCart` is configured; omit it and the\n\t\t * action is left alone entirely.\n\t\t *\n\t\t * Shopify's default looks for `<cart-drawer-component>` or `<cart-drawer>`\n\t\t * with an `.open()` method and, finding neither, sets\n\t\t * `window.location.href = \"/cart\"`. Bryt themes have neither, so without a\n\t\t * callback here every `Shopify.actions.openCart()` navigates the shopper\n\t\t * off the page.\n\t\t *\n\t\t * @example\n\t\t * ```ts\n\t\t * openCart: () => {\n\t\t *   const drawer = document.querySelector(\"drawer-context#cart\");\n\t\t *   if (drawer) drawer.isOpen = true;\n\t\t * }\n\t\t * ```\n\t\t */\n\t\topenCart?: () => void;\n\n\t\t/**\n\t\t * Chooses the element `shopify:cart:*` events are dispatched from.\n\t\t *\n\t\t * Returning `null` - the default - dispatches on `document`, which is what\n\t\t * Shopify does when nothing is configured. Because these events are\n\t\t * `bubbles: true`, returning an element is purely additive: listeners on\n\t\t * `document` still fire.\n\t\t *\n\t\t * Must be synchronous. Shopify uses the return value immediately.\n\t\t */\n\t\teventTarget?: (\n\t\t\tmeta: Actions.UpdateCartEventTargetMeta,\n\t\t) => EventTarget | null;\n\t};\n\n\t/** Deactivates the configuration installed by this call. */\n\texport type Dispose = () => Promise<void>;\n}\n\n/**\n * Refetch `/cart.js`.\n *\n * This has to be a refetch rather than a cache write: the handler is handed a\n * `StorefrontCartSummary` (`id`, `totalQuantity`, `cost`, `lines.nodes`,\n * `discountCodes`) while `CartData` is the classic AJAX shape, with line\n * titles, images and discount allocations that the summary simply does not\n * carry.\n *\n * Cancel-then-invalidate mirrors what the `window.fetch` patch in `index.ts`\n * already does for `/cart/*` mutations.\n *\n * Failure is swallowed on purpose. Shopify rethrows whatever the handler\n * rejects with, so letting a transient `/cart.js` error escape would report an\n * add-to-cart that already succeeded - and whose cart cookie is already\n * written - to the shopper as a failure.\n */\nconst resync = Effect.promise(async () => {\n\tawait Cart.cancel();\n\tawait Cart.invalidate();\n}).pipe(\n\tEffect.catchCause((cause) =>\n\t\tEffect.logWarning(\n\t\t\t\"AjaxCart resync failed after a storefront cart action\",\n\t\t\tcause,\n\t\t),\n\t),\n);\n\nconst configure = (options: syncWithStorefrontActions.Options) =>\n\tEffect.gen(function* () {\n\t\tyield* Actions.configureUpdateCart({\n\t\t\t// Wrapping a plain function in Effect.sync makes the wrapper's\n\t\t\t// synchronous-only contract unrepresentable to break here.\n\t\t\teventTarget: (meta) =>\n\t\t\t\tEffect.sync(() => options.eventTarget?.(meta) ?? null),\n\n\t\t\thandler: (defaultAction, payload) =>\n\t\t\t\tdefaultAction.pipe(\n\t\t\t\t\tEffect.tap(() =>\n\t\t\t\t\t\t// With an explicit cartId, Shopify sets syncCartCookie: false and\n\t\t\t\t\t\t// never writes the cart cookie, so /cart.js still resolves a\n\t\t\t\t\t\t// different cart. Refetching could not reflect this mutation.\n\t\t\t\t\t\tpayload.cartId === undefined\n\t\t\t\t\t\t\t? resync\n\t\t\t\t\t\t\t: Effect.logDebug(\n\t\t\t\t\t\t\t\t\t\"updateCart was given an explicit cartId; the cart cookie is not synced, so AjaxCart was left alone\",\n\t\t\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t\t),\n\t\t});\n\n\t\tconst openCart = options.openCart;\n\n\t\tif (openCart === undefined) return;\n\n\t\tyield* Actions.configureOpenCart({\n\t\t\thandler: () =>\n\t\t\t\tEffect.try(() => openCart()).pipe(\n\t\t\t\t\tEffect.catchCause((cause) =>\n\t\t\t\t\t\t// Deliberately not falling through to Shopify's default, which\n\t\t\t\t\t\t// would navigate to /cart - the behaviour this exists to prevent.\n\t\t\t\t\t\tEffect.logError(\n\t\t\t\t\t\t\t\"openCart callback threw; cart was not opened\",\n\t\t\t\t\t\t\tcause,\n\t\t\t\t\t\t),\n\t\t\t\t\t),\n\t\t\t\t),\n\t\t});\n\t});\n\n/**\n * Route Shopify's storefront cart actions through AjaxCart.\n *\n * Two regressions on a Bryt theme are fixed by configuring at all, before any\n * resync happens. While `updateCart` is unconfigured, Shopify probes for Dawn's\n * `<cart-icon>` / `<cart-items-component>` and for `cart-drawer`-family\n * elements, and finding none falls back to `window.location.reload()`. And\n * `openCart` falls back to navigating to `/cart`.\n *\n * Opt-in by design: this claims page-global, one-shot configuration slots, so\n * it is the theme's call to make, not something that happens on import.\n *\n * Retries while the actions runtime is absent. Shopify installs\n * `window.Shopify.actions` from a synchronous IIFE and announces nothing, so\n * there is no readiness signal to wait on and script order is not ours to\n * control.\n *\n * @example\n * ```ts\n * const dispose = await syncWithStorefrontActions({\n *   openCart: () => { drawer.isOpen = true; },\n * });\n * ```\n */\nexport const syncWithStorefrontActions = async (\n\toptions: syncWithStorefrontActions.Options = {},\n): Promise<syncWithStorefrontActions.Dispose> => {\n\tconst scope = Effect.runSync(Scope.make());\n\n\tconst dispose = () => Effect.runPromise(Scope.close(scope, Exit.void));\n\n\ttry {\n\t\tawait Effect.runPromise(\n\t\t\tconfigure(options).pipe(\n\t\t\t\tEffect.retry({\n\t\t\t\t\tschedule: Schedule.exponential(\"50 millis\").pipe(\n\t\t\t\t\t\tSchedule.upTo({ duration: \"3 seconds\" }),\n\t\t\t\t\t),\n\t\t\t\t\t// A rejected configuration means another script owns the slot; that\n\t\t\t\t\t// will never come good, so only wait on the runtime being absent.\n\t\t\t\t\twhile: (error) => error instanceof Actions.ActionsUnavailableError,\n\t\t\t\t}),\n\t\t\t\tScope.provide(scope),\n\t\t\t\tEffect.provide(Actions.layer),\n\t\t\t),\n\t\t);\n\t} catch (error) {\n\t\tawait dispose();\n\t\tthrow error;\n\t}\n\n\treturn dispose;\n};\n\nexport default syncWithStorefrontActions;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAoEA,IAAM,SAAS,OAAO,QAAQ,YAAY;CACzC,MAAM,OAAY;CAClB,MAAM,WAAgB;AACvB,CAAC,CAAC,CAAC,KACF,OAAO,YAAY,UAClB,OAAO,WACN,yDACA,KACD,CACD,CACD;AAEA,IAAM,aAAa,YAClB,OAAO,IAAI,aAAa;CACvB,OAAO,QAAQ,oBAAoB;EAGlC,cAAc,SACb,OAAO,WAAW,QAAQ,cAAc,IAAI,KAAK,IAAI;EAEtD,UAAU,eAAe,YACxB,cAAc,KACb,OAAO,UAIN,QAAQ,WAAW,KAAA,IAChB,SACA,OAAO,SACP,oGACD,CACH,CACD;CACF,CAAC;CAED,MAAM,WAAW,QAAQ;CAEzB,IAAI,aAAa,KAAA,GAAW;CAE5B,OAAO,QAAQ,kBAAkB,EAChC,eACC,OAAO,UAAU,SAAS,CAAC,CAAC,CAAC,KAC5B,OAAO,YAAY,UAGlB,OAAO,SACN,gDACA,KACD,CACD,CACD,EACF,CAAC;AACF,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;AA0BF,IAAa,4BAA4B,OACxC,UAA6C,CAAC,MACE;CAChD,MAAM,QAAQ,OAAO,QAAQ,MAAM,KAAK,CAAC;CAEzC,MAAM,gBAAgB,OAAO,WAAW,MAAM,MAAM,OAAO,KAAK,IAAI,CAAC;CAErE,IAAI;EACH,MAAM,OAAO,WACZ,UAAU,OAAO,CAAC,CAAC,KAClB,OAAO,MAAM;GACZ,UAAU,SAAS,YAAY,WAAW,CAAC,CAAC,KAC3C,SAAS,KAAK,EAAE,UAAU,YAAY,CAAC,CACxC;GAGA,QAAQ,UAAU,iBAAiB,QAAQ;EAC5C,CAAC,GACD,MAAM,QAAQ,KAAK,GACnB,OAAO,QAAQ,QAAQ,KAAK,CAC7B,CACD;CACD,SAAS,OAAO;EACf,MAAM,QAAQ;EACd,MAAM;CACP;CAEA,OAAO;AACR"}

package/dist/main/api.js

@@ -1,8 +1,58 @@
-import { createAjaxCartApi } from '@brytdesigns/shopify-ajax-cart-api';
+import { createAjaxCartApi } from "@brytdesigns/shopify-ajax-cart-api";
+//#region src/api.ts
+var instance;
+var overrides;
+/**
+* Builds the client on first use rather than on import.
+*
+* `debug` comes from `window.BrytDesigns.debug`, which a theme sets from an
+* inline script. Reading it at module scope made the result depend on whether
+* that script ran before or after this module evaluated - and as an ES module
+* in a Shopify theme, it usually ran after, so `debug: true` was silently
+* ignored. Deferring the read to the first request removes the ordering
+* question entirely.
+*/
+var resolve = () => {
+	if (instance === void 0) instance = createAjaxCartApi({
+		debug: globalThis.window?.BrytDesigns?.debug,
+		...overrides
+	});
+	return instance;
+};
+/**
+* Replaces the options the client is built with.
+*
+* Must be called before the first request; after that the client exists and
+* this is ignored unless {@link reset} is called first. Intended for tests and
+* for a theme that wants to supply its own transport - a storefront that just
+* wants logging should set `window.BrytDesigns.debug`.
+*/
+var configure = (options) => {
+	overrides = options;
+	instance = void 0;
+};
+/** Drops the built client so the next call rebuilds it. For tests. */
+var reset = () => {
+	instance = void 0;
+	overrides = void 0;
+};
+/**
+* The cart client, as a stable object whose methods resolve lazily.
+*
+* A getter-backed facade rather than the client itself: callers import this at
+* module scope, so handing them the real object would force construction at
+* import time, which is the thing being avoided.
+*
+* @internal
+*/
+var API = {
+	add: ((input, options) => resolve().add(input, options)),
+	change: ((input, options) => resolve().change(input, options)),
+	clear: ((input, options) => resolve().clear(input, options)),
+	get: ((input, options) => resolve().get(input, options)),
+	update: ((input, options) => resolve().update(input, options))
+};
+//#endregion
+export { configure, API as default, reset };
 
-const API = createAjaxCartApi({ debug: window?.BrytDesigns?.debug });
-var api_default = API;
-
-export { api_default as default };
-//# sourceMappingURL=api.js.map
 //# sourceMappingURL=api.js.map

package/dist/main/api.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/api.ts"],"names":[],"mappings":";;AAKA,MAAM,MAAM,iBAAkB,CAAA,EAAE,OAAO,MAAQ,EAAA,WAAA,EAAa,OAAO,CAAA;AAEnE,IAAO,WAAQ,GAAA","file":"api.js","sourcesContent":["import { createAjaxCartApi } from \"@brytdesigns/shopify-ajax-cart-api\";\n\n/**\n * @internal\n */\nconst API = createAjaxCartApi({ debug: window?.BrytDesigns?.debug });\n\nexport default API;\n"]}
+{"version":3,"file":"api.js","names":[],"sources":["../../src/api.ts"],"sourcesContent":["import { createAjaxCartApi } from \"@brytdesigns/shopify-ajax-cart-api\";\n\ntype Api = ReturnType<typeof createAjaxCartApi>;\ntype Options = Parameters<typeof createAjaxCartApi>[0];\n\nlet instance: Api | undefined;\nlet overrides: Options;\n\n/**\n * Builds the client on first use rather than on import.\n *\n * `debug` comes from `window.BrytDesigns.debug`, which a theme sets from an\n * inline script. Reading it at module scope made the result depend on whether\n * that script ran before or after this module evaluated - and as an ES module\n * in a Shopify theme, it usually ran after, so `debug: true` was silently\n * ignored. Deferring the read to the first request removes the ordering\n * question entirely.\n */\nconst resolve = (): Api => {\n\tif (instance === undefined) {\n\t\tinstance = createAjaxCartApi({\n\t\t\tdebug: globalThis.window?.BrytDesigns?.debug,\n\t\t\t...overrides,\n\t\t});\n\t}\n\treturn instance;\n};\n\n/**\n * Replaces the options the client is built with.\n *\n * Must be called before the first request; after that the client exists and\n * this is ignored unless {@link reset} is called first. Intended for tests and\n * for a theme that wants to supply its own transport - a storefront that just\n * wants logging should set `window.BrytDesigns.debug`.\n */\nexport const configure = (options: Options): void => {\n\toverrides = options;\n\tinstance = undefined;\n};\n\n/** Drops the built client so the next call rebuilds it. For tests. */\nexport const reset = (): void => {\n\tinstance = undefined;\n\toverrides = undefined;\n};\n\n/**\n * The cart client, as a stable object whose methods resolve lazily.\n *\n * A getter-backed facade rather than the client itself: callers import this at\n * module scope, so handing them the real object would force construction at\n * import time, which is the thing being avoided.\n *\n * @internal\n */\nconst API = {\n\tadd: ((input, options) => resolve().add(input, options)) as Api[\"add\"],\n\tchange: ((input, options) =>\n\t\tresolve().change(input, options)) as Api[\"change\"],\n\tclear: ((input, options) => resolve().clear(input, options)) as Api[\"clear\"],\n\tget: ((input, options) => resolve().get(input, options)) as Api[\"get\"],\n\tupdate: ((input, options) =>\n\t\tresolve().update(input, options)) as Api[\"update\"],\n};\n\nexport default API;\n"],"mappings":";;AAKA,IAAI;AACJ,IAAI;;;;;;;;;;;AAYJ,IAAM,gBAAqB;CAC1B,IAAI,aAAa,KAAA,GAChB,WAAW,kBAAkB;EAC5B,OAAO,WAAW,QAAQ,aAAa;EACvC,GAAG;CACJ,CAAC;CAEF,OAAO;AACR;;;;;;;;;AAUA,IAAa,aAAa,YAA2B;CACpD,YAAY;CACZ,WAAW,KAAA;AACZ;;AAGA,IAAa,cAAoB;CAChC,WAAW,KAAA;CACX,YAAY,KAAA;AACb;;;;;;;;;;AAWA,IAAM,MAAM;CACX,OAAO,OAAO,YAAY,QAAQ,CAAC,CAAC,IAAI,OAAO,OAAO;CACtD,UAAU,OAAO,YAChB,QAAQ,CAAC,CAAC,OAAO,OAAO,OAAO;CAChC,SAAS,OAAO,YAAY,QAAQ,CAAC,CAAC,MAAM,OAAO,OAAO;CAC1D,OAAO,OAAO,YAAY,QAAQ,CAAC,CAAC,IAAI,OAAO,OAAO;CACtD,UAAU,OAAO,YAChB,QAAQ,CAAC,CAAC,OAAO,OAAO,OAAO;AACjC"}

package/dist/main/client.js

@@ -1,24 +1,90 @@
-import { QueryClient } from '@tanstack/solid-query';
-import { experimental_createQueryPersister } from '@tanstack/query-persist-client-core';
-import lz from 'lz-string';
+import { QueryClient } from "@tanstack/solid-query";
+import { experimental_createQueryPersister } from "@tanstack/query-persist-client-core";
+import lz from "lz-string";
+//#region src/client.ts
+/**
+* Fields removed before the cart is written to disk.
+*
+* `token` identifies the cart to Shopify's Ajax endpoints; `note` and
+* `attributes` are free text the shopper typed. lz-string is compression, not
+* encryption, so all three sat in `localStorage` in readable form for twelve
+* hours — long enough that the next person on a shared or kiosk browser could
+* read the previous shopper's cart, and long enough to outlive the shopper
+* clearing their cart.
+*
+* Line-item `properties` are in the list for the same reason: gift messages
+* and engraving text are the most personal thing a cart holds, and they are
+* exactly what someone reading a shared browser's storage would find
+* interesting. The trade is that a cart restored from the cache paints its
+* line items without their properties for the one frame before `/cart.js`
+* resolves — incomplete briefly, rather than readable for twelve hours.
+*
+* This is a *cache*. Everything dropped here is re-fetched on the next
+* `/cart.js`, so nothing is lost; only the first paint from a restored entry
+* is thinner.
+*/
+var REDACTED_CART_FIELDS = [
+	"token",
+	"note",
+	"attributes",
+	"properties"
+];
+/**
+* Strips {@link REDACTED_CART_FIELDS} wherever they appear in the persisted
+* payload.
+*
+* Walks the whole structure rather than reaching for a known path: the
+* persister writes its own envelope around the query state, and a shape
+* assumption here would fail silently — leaving the fields on disk — the next
+* time TanStack changes it.
+*/
+var redact = (value) => {
+	if (Array.isArray(value)) return value.map(redact);
+	if (value === null || typeof value !== "object") return value;
+	const out = {};
+	for (const [key, nested] of Object.entries(value)) {
+		if (REDACTED_CART_FIELDS.includes(key)) continue;
+		out[key] = redact(nested);
+	}
+	return out;
+};
+var makeClient = () => {
+	const persister = experimental_createQueryPersister({
+		serialize: (data) => lz.compressToUTF16(JSON.stringify(redact(data))),
+		deserialize: (data) => JSON.parse(lz.decompressFromUTF16(data)),
+		storage: window.localStorage,
+		maxAge: 432e5,
+		prefix: "@brytdesigns/shopify-ajax-cart"
+	});
+	return new QueryClient({ defaultOptions: { queries: {
+		gcTime: 3e5,
+		persister: persister.persisterFn
+	} } });
+};
+/**
+* Memoised on `window` rather than on the module.
+*
+* Within one copy of this package a module-level constant would be enough.
+* The hazard is two copies on one page - a theme and an app block resolving
+* different versions, or a bundler emitting duplicate instances - where each
+* would otherwise hold its own QueryClient and an `invalidate()` from one
+* would leave the other's cache untouched. Anchoring to `window` means every
+* copy converges on one client, and observers sharing the `cart` key share a
+* single cache entry.
+*
+* **This one is deliberately not injectable, and should stay that way.** The
+* other `window` reads in this package were lifted out - the route table and
+* origin became `Context.Reference`s, and the API client is built on first use
+* rather than at import. This is the exception: the whole point is to converge
+* copies that cannot see each other, and a copy holding an injected client is
+* exactly the divergence the global was introduced to prevent. Making it a
+* parameter would reintroduce the bug it was written to fix.
+*/
+if (window.BrytDesigns === void 0) window.BrytDesigns = {};
+var globals = window.BrytDesigns;
+if (globals.queryClient === void 0) globals.queryClient = makeClient();
+var client = globals.queryClient;
+//#endregion
+export { client as default, redact };
 
-const persister = experimental_createQueryPersister({
-  serialize: (data) => lz.compressToUTF16(JSON.stringify(data)),
-  deserialize: (data) => JSON.parse(lz.decompressFromUTF16(data)),
-  storage: window.localStorage,
-  maxAge: 1e3 * 60 * 60 * 12,
-  prefix: "@brytdesigns/shopify-ajax-cart"
-});
-const client = new QueryClient({
-  defaultOptions: {
-    queries: {
-      gcTime: 1e3 * 60 * 5,
-      persister: persister.persisterFn
-    }
-  }
-});
-var client_default = client;
-
-export { client_default as default };
-//# sourceMappingURL=client.js.map
 //# sourceMappingURL=client.js.map