@swishapp/sdk 0.149.0 → 0.149.1-unstable.20260917131745

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

@@ -2,6 +2,13 @@ export interface AjaxConfig {
     storeDomain: string;
     fetch?: (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
     responseInterceptor?: (response: Response, request: Request) => Promise<void> | void;
+    /**
+     * Called as a request is dispatched, before any response exists. Returning a
+     * function marks that request as in flight; the returned function is called
+     * once its response has been fully processed, or once the request has failed,
+     * so a consumer can hold state for the whole round trip.
+     */
+    requestInterceptor?: (request: Request) => (() => void) | void;
 }
 export interface CartLineItem {
     id: number;
@@ -91,8 +98,8 @@ export interface CartChangeItem {
     view_key: string;
 }
 export interface CartChangeResponse extends Cart {
-    items_added: CartChangeItem[];
-    items_removed: CartChangeItem[];
+    items_added?: CartChangeItem[];
+    items_removed?: CartChangeItem[];
     discount_codes: any[];
 }
 export interface CartError {

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

@@ -3,10 +3,59 @@ export declare class AjaxApiPublisher {
     private readonly eventBus;
     private readonly eventMap;
     private previousCart;
+    private pendingCartMutations;
     constructor(eventBus: EventBus);
+    /**
+     * Registers a cart mutation as in flight from the moment it is dispatched
+     * until its response has been processed, and returns the function that
+     * clears it. Requests that are not cart mutations are ignored.
+     *
+     * This is what stops a plain `/cart.js` read that resolves mid-mutation from
+     * replacing the snapshot the mutation will be diffed against — see
+     * `snapshotCart` and SWI-2836.
+     */
+    beginRequest(request: Request): (() => void) | void;
     processFetchResponse(response: Response, request: Request): Promise<void>;
     getEventName(url: string): EventName | null;
+    /**
+     * A cart read that resolves while a mutation is in flight can already reflect
+     * that mutation, and adopting it would leave the mutation diffing against a
+     * cart the removal has happened in — nothing looks removed. The mutation's
+     * own response is the next snapshot; reads wait their turn.
+     *
+     * `/cart/change.js` no longer depends on this, since `diffRemovedItems` reads
+     * Shopify's `items_removed` first. `/cart/update.js` has no such field, so
+     * the snapshot is all it has.
+     */
     private snapshotCart;
+    /**
+     * `/cart/change.js` reports its own removals in `items_removed`, so that is
+     * the authoritative answer and it is read first.
+     *
+     * Leading with the snapshot diff instead loses the removal whenever another
+     * script's `/cart.js` read lands between the removal request and its response
+     * (an abandoned-cart app polling the cart is enough): `snapshotCart` has
+     * already replaced `previousCart` with the post-removal cart, so the diff
+     * finds nothing gone and the shopper is never offered the save — SWI-2836.
+     *
+     * `/cart/update.js` omits the field entirely, so an *absent* `items_removed`
+     * is what selects the snapshot diff. An empty array is Shopify telling us
+     * nothing was removed, and is not second-guessed.
+     *
+     * Both branches match on the cart line, never on `variant_id`. Shopify lists
+     * a quantity *decrease* in `items_removed` too, naming the line that survived
+     * it; a line the shopper deleted names a line the cart no longer has. Keying
+     * off `variant_id` instead drops a deleted line whenever another line still
+     * holds that variant — two lines of one variant separated by line item
+     * properties (gift wrap, engraving, a selling plan) — and the shopper is
+     * offered nothing for a deletion they just made.
+     *
+     * Verified against the live Ajax API (2026-09-16): an `items_removed` entry
+     * carries the line key as `view_key` and has no `key` of its own, and a
+     * 2 → 1 quantity change reports the surviving line's key there.
+     * `/cart/update.js` returns no `items_removed`, and its `items_changelog`
+     * carries `added` only — the snapshot really is all that path has.
+     */
     private diffRemovedItems;
     private toCartChangeItem;
 }