@askdialog/dialog-sdk 2.4.0 → 2.6.0

package/dist/__tests__/searchControllerAttribution.spec.js

@@ -0,0 +1,176 @@
+/* eslint max-lines: ["error", 300] */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createSearchController } from "../searchController";
+const tracker = vi.hoisted(() => ({
+    setContext: vi.fn(),
+    observe: vi.fn(),
+    forceImpression: vi.fn(),
+    flush: vi.fn(),
+    disconnect: vi.fn(),
+}));
+vi.mock("../utils/searchImpressions", () => ({
+    createSearchImpressionTracker: () => tracker,
+}));
+const response = (overrides = {}) => ({
+    queryId: "qid-1",
+    hits: [
+        {
+            id: "h1",
+            score: 1,
+            product: { id: "p1", url: "https://shop.example/p1" },
+        },
+        { id: "h2", score: 0.9, product: { id: "p2" } },
+    ],
+    nbHits: 30,
+    page: 0,
+    nbPages: 3,
+    hitsPerPage: 12,
+    processingTimeMs: 5,
+    query: "shoes",
+    ...overrides,
+});
+const search = vi.fn();
+const trackViewSearchResults = vi.fn();
+const trackSelectSearchResult = vi.fn();
+const navigate = vi.fn();
+const createController = () => createSearchController({
+    search,
+    analytics: {
+        surface: "search_page",
+        trackViewSearchResults,
+        trackSelectSearchResult,
+    },
+    navigate,
+});
+beforeEach(() => {
+    vi.useFakeTimers();
+});
+afterEach(() => {
+    vi.useRealTimers();
+    vi.clearAllMocks();
+});
+const settle = async () => {
+    await Promise.resolve();
+    await Promise.resolve();
+};
+describe("search controller attribution", () => {
+    it("omits queryId for a new query and resends it while the query is unchanged", async () => {
+        const controller = createController();
+        search.mockResolvedValue(response());
+        controller.submit("shoes");
+        await settle();
+        controller.setPage(1);
+        await settle();
+        expect(search.mock.calls[0][0].queryId).toBeUndefined();
+        expect(search.mock.calls[1][0]).toMatchObject({
+            query: "shoes",
+            page: 1,
+            queryId: "qid-1",
+        });
+    });
+    it("declares the rendered response's envelope to the impression tracker", async () => {
+        const controller = createController();
+        search.mockResolvedValue(response({ page: 1, query: "shoes" }));
+        controller.submit("shoes");
+        await settle();
+        expect(tracker.setContext).toHaveBeenCalledWith({
+            query_id: "qid-1",
+            surface: "search_page",
+            page: 2,
+            total_hits: 30,
+            query_length: 5,
+        });
+    });
+    it("keeps query_id stable across pagination and rotates it on a new query", async () => {
+        const controller = createController();
+        search
+            .mockResolvedValueOnce(response())
+            .mockResolvedValueOnce(response({ page: 1, queryId: "qid-1" }))
+            .mockResolvedValueOnce(response({ query: "boots", queryId: "qid-2" }));
+        controller.submit("shoes");
+        await settle();
+        controller.setPage(1);
+        await settle();
+        controller.submit("boots");
+        await settle();
+        const queryIds = tracker.setContext.mock.calls.map(([envelope]) => envelope.query_id);
+        expect(queryIds).toEqual(["qid-1", "qid-1", "qid-2"]);
+    });
+    it("emits the zero-items view event for a rendered no-results state", async () => {
+        const controller = createController();
+        search.mockResolvedValue(response({ hits: [], nbHits: 0, nbPages: 0, query: "nothing" }));
+        controller.submit("nothing");
+        await settle();
+        expect(trackViewSearchResults).toHaveBeenCalledWith({
+            query_id: "qid-1",
+            surface: "search_page",
+            page: 1,
+            total_hits: 0,
+            query_length: 7,
+            items: [],
+        });
+    });
+    it("observes result elements with absolute 1-based positions", async () => {
+        const controller = createController();
+        search.mockResolvedValue(response({ page: 2 }));
+        const element = {};
+        controller.submit("shoes");
+        await settle();
+        controller.observeResult(element, 1);
+        expect(tracker.observe).toHaveBeenCalledWith(element, {
+            product_id: "p2",
+            position: 2 * 12 + 2,
+        });
+    });
+    it("ignores observe and select before any response", () => {
+        const controller = createController();
+        controller.observeResult({}, 0);
+        controller.selectResult(0);
+        expect(tracker.observe).not.toHaveBeenCalled();
+        expect(trackSelectSearchResult).not.toHaveBeenCalled();
+        expect(navigate).not.toHaveBeenCalled();
+    });
+    it("records selection attribution before handing navigation to the adapter", async () => {
+        const controller = createController();
+        const landed = response();
+        search.mockResolvedValue(landed);
+        const order = [];
+        tracker.forceImpression.mockImplementation(() => order.push("impression"));
+        trackSelectSearchResult.mockImplementation(() => order.push("select"));
+        navigate.mockImplementation(() => order.push("navigate"));
+        controller.submit("shoes");
+        await settle();
+        controller.selectResult(0);
+        expect(tracker.forceImpression).toHaveBeenCalledWith({
+            product_id: "p1",
+            position: 1,
+        });
+        expect(trackSelectSearchResult).toHaveBeenCalledWith({
+            query_id: "qid-1",
+            surface: "search_page",
+            page: 1,
+            total_hits: 30,
+            query_length: 5,
+            items: [{ product_id: "p1", position: 1 }],
+        });
+        expect(navigate).toHaveBeenCalledWith("https://shop.example/p1", landed.hits[0]);
+        expect(order).toEqual(["impression", "select", "navigate"]);
+    });
+    it("still records attribution when the hit has no URL to navigate to", async () => {
+        const controller = createController();
+        search.mockResolvedValue(response());
+        controller.submit("shoes");
+        await settle();
+        controller.selectResult(1);
+        expect(trackSelectSearchResult).toHaveBeenCalledWith(expect.objectContaining({ items: [{ product_id: "p2", position: 2 }] }));
+        expect(navigate).not.toHaveBeenCalled();
+    });
+    it("disconnects the impression tracker on dispose", async () => {
+        const controller = createController();
+        search.mockResolvedValue(response());
+        controller.submit("shoes");
+        await settle();
+        controller.dispose();
+        expect(tracker.disconnect).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/__tests__/searchImpressions.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=searchImpressions.spec.d.ts.map

package/dist/__tests__/searchImpressions.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchImpressions.spec.d.ts","sourceRoot":"","sources":["../../src/__tests__/searchImpressions.spec.ts"],"names":[],"mappings":""}

package/dist/__tests__/searchImpressions.spec.js

@@ -0,0 +1,218 @@
+/* eslint max-lines: ["error", 300] */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createSearchImpressionTracker } from "../utils/searchImpressions";
+const envelope = {
+    query_id: "query-1",
+    surface: "search_page",
+    page: 1,
+    total_hits: 42,
+    query_length: 6,
+};
+let observerCallback;
+const observe = vi.fn();
+const unobserve = vi.fn();
+const disconnect = vi.fn();
+const windowListeners = new Map();
+const element = () => ({});
+const intersect = (target, ratio) => {
+    observerCallback([{ target, intersectionRatio: ratio }]);
+};
+beforeEach(() => {
+    vi.useFakeTimers();
+    vi.stubGlobal("IntersectionObserver", class {
+        constructor(callback) {
+            observerCallback = callback;
+        }
+        observe = observe;
+        unobserve = unobserve;
+        disconnect = disconnect;
+    });
+    vi.stubGlobal("window", {
+        addEventListener: (type, listener) => {
+            windowListeners.set(type, listener);
+        },
+        removeEventListener: (type) => {
+            windowListeners.delete(type);
+        },
+    });
+});
+afterEach(() => {
+    vi.useRealTimers();
+    vi.unstubAllGlobals();
+    vi.clearAllMocks();
+    windowListeners.clear();
+});
+describe("createSearchImpressionTracker", () => {
+    it("emits a batched impression after dwell then scroll inactivity", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(500);
+        expect(emit).not.toHaveBeenCalled();
+        vi.advanceTimersByTime(1500);
+        expect(emit).toHaveBeenCalledWith({
+            ...envelope,
+            items: [{ product_id: "product-1", position: 1 }],
+        });
+    });
+    it("does not count an item that leaves the viewport before the dwell time", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(300);
+        intersect(card, 0.2);
+        vi.advanceTimersByTime(5000);
+        expect(emit).not.toHaveBeenCalled();
+    });
+    it("never re-counts a (query_id, product_id) pair", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(2000);
+        intersect(card, 0.1);
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(5000);
+        expect(emit).toHaveBeenCalledTimes(1);
+    });
+    it("flushes immediately when the batch reaches the item cap", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({
+            emit,
+            maxItemsPerEvent: 2,
+        });
+        tracker.setContext(envelope);
+        const first = element();
+        const second = element();
+        tracker.observe(first, { product_id: "product-1", position: 1 });
+        tracker.observe(second, { product_id: "product-2", position: 2 });
+        intersect(first, 0.6);
+        intersect(second, 0.6);
+        vi.advanceTimersByTime(500);
+        expect(emit).toHaveBeenCalledTimes(1);
+        expect(emit.mock.calls[0][0].items).toHaveLength(2);
+    });
+    it("flushes pending impressions under their own envelope when the context changes", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(500);
+        tracker.setContext({ ...envelope, query_id: "query-2", page: 1 });
+        expect(emit).toHaveBeenCalledWith(expect.objectContaining({ query_id: "query-1" }));
+    });
+    it("forces the clicked item's impression and flushes immediately", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        tracker.forceImpression({ product_id: "product-1", position: 1 });
+        expect(emit).toHaveBeenCalledWith({
+            ...envelope,
+            items: [{ product_id: "product-1", position: 1 }],
+        });
+    });
+    it("does not duplicate a forced impression already counted", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(2000);
+        tracker.forceImpression({ product_id: "product-1", position: 1 });
+        expect(emit).toHaveBeenCalledTimes(1);
+    });
+    it("keeps deduplication across pagination of the same query", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(2000);
+        tracker.setContext({ ...envelope, page: 2 });
+        const cardOnPage2 = element();
+        tracker.observe(cardOnPage2, { product_id: "product-1", position: 1 });
+        intersect(cardOnPage2, 0.6);
+        vi.advanceTimersByTime(2000);
+        expect(emit).toHaveBeenCalledTimes(1);
+    });
+    it("drops a previous query's dedup keys when the query changes", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(2000);
+        tracker.setContext({ ...envelope, query_id: "query-2" });
+        // Same query_id served again (e.g. a cached response): a fresh render is
+        // a new exposure, like the bfcache restore.
+        tracker.setContext(envelope);
+        const cardAgain = element();
+        tracker.observe(cardAgain, { product_id: "product-1", position: 1 });
+        intersect(cardAgain, 0.6);
+        vi.advanceTimersByTime(2000);
+        expect(emit).toHaveBeenCalledTimes(2);
+    });
+    it("flushes qualified impressions on pagehide", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(500);
+        windowListeners.get("pagehide")?.({});
+        expect(emit).toHaveBeenCalledTimes(1);
+    });
+    it("re-qualifies items after a back/forward-cache restore", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(2000);
+        expect(emit).toHaveBeenCalledTimes(1);
+        windowListeners.get("pageshow")?.({ persisted: true });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(2000);
+        expect(emit).toHaveBeenCalledTimes(2);
+    });
+    it("requires a full fresh dwell after a back/forward-cache restore", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        const card = element();
+        tracker.observe(card, { product_id: "product-1", position: 1 });
+        intersect(card, 0.6);
+        vi.advanceTimersByTime(300);
+        windowListeners.get("pageshow")?.({ persisted: true });
+        intersect(card, 0.6);
+        // A stale pre-restore timer (200ms left) would record at 200ms and flush
+        // at 1700ms; a fresh dwell records at 500ms and flushes at 2000ms.
+        vi.advanceTimersByTime(1700);
+        expect(emit).not.toHaveBeenCalled();
+        vi.advanceTimersByTime(300);
+        expect(emit).toHaveBeenCalledTimes(1);
+    });
+    it("emits nothing when no impression qualified", () => {
+        const emit = vi.fn();
+        const tracker = createSearchImpressionTracker({ emit });
+        tracker.setContext(envelope);
+        tracker.flush();
+        windowListeners.get("pagehide")?.({});
+        expect(emit).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/searchService.spec.js

@@ -31,6 +31,7 @@ describe("searchProducts", () => {
             query: "running shoes",
             page: 2,
             hitsPerPage: 50,
+            queryId: "0198c3f2-0000-7000-8000-000000000000",
         });
         expect(fetchMock).toHaveBeenCalledTimes(1);
         const [url, init] = fetchMock.mock.calls[0];
@@ -44,9 +45,10 @@ describe("searchProducts", () => {
             query: "running shoes",
             page: 2,
             hitsPerPage: 50,
+            queryId: "0198c3f2-0000-7000-8000-000000000000",
         });
     });
-    it("omits pagination fields the caller did not provide", async () => {
+    it("omits pagination fields and queryId the caller did not provide", async () => {
         fetchMock.mockResolvedValue(jsonResponse(emptyResponse));
         await searchProducts(API_KEY, { query: "running shoes" });
         const [, init] = fetchMock.mock.calls[0];

package/dist/config/config.development.js

@@ -1,5 +1,5 @@
 export const config = {
-    baseApiUrl: "https://abkjr5ukvi.execute-api.eu-west-1.amazonaws.com",
+    baseApiUrl: "https://hr5buzenb1.execute-api.eu-west-1.amazonaws.com",
     // Nest monolith (staging) — serves POST /public/search.
     monolithApiUrl: "https://fvcphlqyle.execute-api.eu-west-1.amazonaws.com",
     assistantUrl: "https://d2bycosa71tnxv.cloudfront.net/assets/index.js",

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 export * from "./Dialog";
 export * from "./DialogSearchError";
 export * from "./EventsHandler";
+export * from "./searchController";
 export * from "./types";
+export * from "./utils/searchImpressions";
 export * from "./windowAudit";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,qBAAqB,CAAC;AACpC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,SAAS,CAAC;AACxB,cAAc,2BAA2B,CAAC;AAC1C,cAAc,eAAe,CAAC"}

package/dist/index.js

@@ -1,5 +1,7 @@
 export * from "./Dialog";
 export * from "./DialogSearchError";
 export * from "./EventsHandler";
+export * from "./searchController";
 export * from "./types";
+export * from "./utils/searchImpressions";
 export * from "./windowAudit";

package/dist/searchController.d.ts

@@ -0,0 +1,3 @@
+import { SearchController, SearchControllerOptions } from "./types/searchController";
+export declare function createSearchController({ search, analytics, navigate, debounceMs, hitsPerPage, }: SearchControllerOptions): SearchController;
+//# sourceMappingURL=searchController.d.ts.map

package/dist/searchController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchController.d.ts","sourceRoot":"","sources":["../src/searchController.ts"],"names":[],"mappings":"AACA,OAAO,EACL,gBAAgB,EAChB,uBAAuB,EAGxB,MAAM,0BAA0B,CAAC;AAgBlC,wBAAgB,sBAAsB,CAAC,EACrC,MAAM,EACN,SAAS,EACT,QAAQ,EACR,UAAgC,EAChC,WAAmC,GACpC,EAAE,uBAAuB,GAAG,gBAAgB,CA2K5C"}

package/dist/searchController.js

@@ -0,0 +1,164 @@
+import { SearchStatus, } from "./types/searchController";
+import { createControllerAnalytics } from "./utils/searchControllerAnalytics";
+const DEFAULT_DEBOUNCE_MS = 250;
+const DEFAULT_HITS_PER_PAGE = 12;
+// `SearchRequest` rejects queries under two visible characters (code points).
+const MIN_QUERY_CODE_POINTS = 2;
+const INITIAL_STATE = {
+    status: SearchStatus.IDLE,
+    query: "",
+    page: 0,
+    response: undefined,
+    error: undefined,
+};
+export function createSearchController({ search, analytics, navigate, debounceMs = DEFAULT_DEBOUNCE_MS, hitsPerPage = DEFAULT_HITS_PER_PAGE, }) {
+    let state = INITIAL_STATE;
+    const listeners = new Set();
+    const controllerAnalytics = createControllerAnalytics(analytics);
+    let debounceTimer;
+    // Query typed but not yet run: `state.query` only holds committed queries, so
+    // without this, `setPage()` would cancel the debounce and paginate stale results.
+    let pendingQuery;
+    let abortController;
+    // Monotonic token: a response only lands if it belongs to the latest request.
+    let requestId = 0;
+    let disposed = false;
+    const setState = (patch) => {
+        state = { ...state, ...patch };
+        for (const listener of listeners) {
+            listener(state);
+        }
+    };
+    const cancelInFlight = () => {
+        clearTimeout(debounceTimer);
+        abortController?.abort();
+        abortController = undefined;
+    };
+    const buildRequest = (query, page) => {
+        const request = { query, page, hitsPerPage };
+        // Query unchanged since the last response: resend its queryId; a new
+        // query gets a fresh engine-generated one.
+        const previous = state.response;
+        if (previous?.query === query) {
+            request.queryId = previous.queryId;
+        }
+        return request;
+    };
+    const run = async (query, page) => {
+        cancelInFlight();
+        abortController = new AbortController();
+        const id = ++requestId;
+        const request = buildRequest(query, page);
+        setState({ status: SearchStatus.LOADING, query, page });
+        try {
+            const response = await search(request, {
+                signal: abortController.signal,
+            });
+            if (id !== requestId) {
+                return; // A newer request landed first: this response is stale.
+            }
+            controllerAnalytics.onResponse(response);
+            setState({
+                status: response.nbHits === 0 ? SearchStatus.EMPTY : SearchStatus.SUCCESS,
+                response,
+                error: undefined,
+            });
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === "AbortError") {
+                return; // Superseded by a newer request — never surfaced.
+            }
+            if (id !== requestId) {
+                return;
+            }
+            setState({ status: SearchStatus.ERROR, error, response: undefined });
+        }
+    };
+    // Shared by `setQuery`/`submit`: undefined = reset to idle (query too short).
+    const prepare = (rawQuery) => {
+        const query = rawQuery.trim();
+        cancelInFlight();
+        pendingQuery = undefined;
+        if ([...query].length < MIN_QUERY_CODE_POINTS) {
+            requestId += 1; // Invalidate anything in flight.
+            setState(INITIAL_STATE);
+            return undefined;
+        }
+        return query;
+    };
+    return {
+        setQuery(rawQuery) {
+            const query = disposed ? undefined : prepare(rawQuery);
+            if (query === undefined) {
+                return;
+            }
+            pendingQuery = query;
+            debounceTimer = setTimeout(() => {
+                pendingQuery = undefined;
+                void run(query, 0);
+            }, debounceMs);
+        },
+        submit(rawQuery) {
+            const query = disposed ? undefined : prepare(rawQuery);
+            if (query === undefined) {
+                return;
+            }
+            void run(query, 0);
+        },
+        setPage(page) {
+            if (disposed) {
+                return;
+            }
+            if (pendingQuery !== undefined) {
+                // A query change is pending: the click targeted stale results, so the
+                // new query supersedes pagination — flush it now instead of debouncing.
+                const query = pendingQuery;
+                pendingQuery = undefined;
+                void run(query, 0);
+                return;
+            }
+            if (state.query === "") {
+                return; // Pagination requires a committed non-empty query.
+            }
+            void run(state.query, page);
+        },
+        retry() {
+            if (disposed || state.status !== SearchStatus.ERROR) {
+                return;
+            }
+            void run(state.query, state.page);
+        },
+        observeResult(element, index) {
+            if (state.response === undefined) {
+                return;
+            }
+            controllerAnalytics.observeResult(element, state.response, index);
+        },
+        selectResult(index) {
+            const response = state.response;
+            if (response === undefined) {
+                return;
+            }
+            controllerAnalytics.select(response, index);
+            const url = response.hits[index].product.url;
+            if (navigate !== undefined && url !== undefined) {
+                navigate(url, response.hits[index]);
+            }
+        },
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        getState: () => state,
+        dispose() {
+            disposed = true;
+            cancelInFlight();
+            requestId += 1;
+            pendingQuery = undefined;
+            listeners.clear();
+            controllerAnalytics.dispose();
+        },
+    };
+}

package/dist/types/constructor.d.ts

@@ -22,5 +22,13 @@ export interface DialogConstructor {
     callbacks?: DialogCallbacks;
     theme?: Partial<Theme>;
     userId?: string;
+    /**
+     * Adds `data-ot-ignore` on the injected assistant script so OneTrust
+     * auto-blocking does not neutralize it for visitors who declined cookies.
+     * The assistant gates analytics on consent internally, so loading it is
+     * safe — but exempting a script from the CMP is the merchant's compliance
+     * call, hence opt-in. No effect outside OneTrust auto-blocking setups.
+     */
+    ignoreOneTrustAutoBlock?: boolean;
 }
 //# sourceMappingURL=constructor.d.ts.map

package/dist/types/constructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constructor.d.ts","sourceRoot":"","sources":["../../src/types/constructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,UAAU,EAAE,CACV,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,KACf,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}
+{"version":3,"file":"constructor.d.ts","sourceRoot":"","sources":["../../src/types/constructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,WAAW,CAAC;AAC9C,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpD,UAAU,EAAE,CACV,SAAS,EAAE,MAAM,EACjB,SAAS,CAAC,EAAE,MAAM,KACf,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACjC;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC;IACvB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;;;OAMG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC"}

package/dist/types/events.d.ts

@@ -1,3 +1,4 @@
+import { SelectSearchResultEventPayload, ViewSearchResultsEventPayload } from "./searchAnalytics";
 export declare const DIALOG_CUSTOM_EVENT = "enableDialogAssistantEvent";
 export declare enum DialogEvents {
     OPEN_ASSISTANT = "open_assistant",
@@ -5,7 +6,9 @@ export declare enum DialogEvents {
     SEND_MESSAGE = "PRODUCT_QUESTION",
     SEND_GENERIC_QUESTION = "GENERIC_QUESTION",
     TRACK_ADD_TO_CART = "TRACK_ADD_TO_CART",
-    TRACK_SUBMIT_CHECKOUT = "TRACK_SUBMIT_CHECKOUT"
+    TRACK_SUBMIT_CHECKOUT = "TRACK_SUBMIT_CHECKOUT",
+    TRACK_VIEW_SEARCH_RESULTS = "TRACK_VIEW_SEARCH_RESULTS",
+    TRACK_SELECT_SEARCH_RESULT = "TRACK_SELECT_SEARCH_RESULT"
 }
 export interface GenericQuestionPayload {
     question: string;
@@ -87,7 +90,7 @@ export interface LegacyCheckoutParams {
     currency?: string;
     variantId?: string;
 }
-export type DialogEventPayload = ProductQuestionPayload | GenericQuestionPayload | DiagnosticPayload | OpenAssistantPayload | TrackEventPayload | SubmitCheckoutEventPayload;
+export type DialogEventPayload = ProductQuestionPayload | GenericQuestionPayload | DiagnosticPayload | OpenAssistantPayload | TrackEventPayload | SubmitCheckoutEventPayload | ViewSearchResultsEventPayload | SelectSearchResultEventPayload;
 export interface DialogEvent<T = DialogEventPayload> {
     type: DialogEvents;
     payload: T;