@salesforce/lds-worker-api 1.110.1 → 1.111.0

package/dist/standalone/umd/lds-worker-api.js

@@ -3655,7 +3655,7 @@
             return this.environment.buildStructuredKey(namespace, representationName, idValues);
         }
     }
-    // engine version: 0.135.4-ca0c061d
+    // engine version: 0.136.5-77eb3bb4
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -3782,7 +3782,7 @@
         }
         callbacks.push(callback);
     }
-    // version: 1.110.1-cc1242727
+    // version: 1.111.0-f30e5e921
 
     // TODO [TD-0081508]: once that TD is fulfilled we can probably change this file
     function instrumentAdapter$1(createFunction, _metadata) {
@@ -15206,7 +15206,7 @@
         updateReferenceMapWithKnownKey(ast, luvioDocumentNode);
         return luvioDocumentNode;
     }
-    // version: 1.110.1-cc1242727
+    // version: 1.111.0-f30e5e921
 
     function unwrap(data) {
         // The lwc-luvio bindings import a function from lwc called "unwrap".
@@ -16087,7 +16087,7 @@
         const { apiFamily, name } = metadata;
         return createGraphQLWireAdapterConstructor$1(adapter, `${apiFamily}.${name}`, luvio, astResolver);
     }
-    // version: 1.110.1-cc1242727
+    // version: 1.111.0-f30e5e921
 
     /**
      * Copyright (c) 2022, Salesforce, Inc.,
@@ -16170,7 +16170,7 @@
     ({
         state: FragmentReadResultState.Missing,
     });
-    // engine version: 0.135.4-ca0c061d
+    // engine version: 0.136.5-77eb3bb4
 
     const { keys: ObjectKeys$3, freeze: ObjectFreeze$3, create: ObjectCreate$3 } = Object;
 
@@ -20824,7 +20824,7 @@
             }
         }
     }
-    function tokenForAtMost(paginationMetadata, maxOffset) {
+    function tokenForAtMost$1(paginationMetadata, maxOffset) {
         const tokens = Object.keys(paginationMetadata);
         let tokenResult = undefined;
         let offsetResult = -1;
@@ -22630,7 +22630,7 @@
                     return [undefined, -1];
                 }
                 const maxOffset = configTokenOffset + num;
-                const [token, offset] = tokenForAtMost(paginationMetadata, maxOffset);
+                const [token, offset] = tokenForAtMost$1(paginationMetadata, maxOffset);
                 if (token !== undefined) {
                     return [token, configPageSize - (offset - configTokenOffset)];
                 }
@@ -23051,7 +23051,7 @@
                 pageToken: config.pageToken,
                 pagination: {
                     offsetFromToken: offsetFromToken$1,
-                    tokenForAtMost,
+                    tokenForAtMost: tokenForAtMost$1,
                     paginationMetadata,
                 },
             });
@@ -23406,7 +23406,7 @@
                 pageToken: config.pageToken,
                 pagination: {
                     offsetFromToken: offsetFromToken$1,
-                    tokenForAtMost,
+                    tokenForAtMost: tokenForAtMost$1,
                     paginationMetadata,
                 },
             });
@@ -40373,7 +40373,7 @@
                     return [undefined, -1];
                 }
                 const maxOffset = configTokenOffset + num;
-                const [token, offset] = tokenForAtMost(paginationMetadata, maxOffset);
+                const [token, offset] = tokenForAtMost$1(paginationMetadata, maxOffset);
                 if (token !== undefined) {
                     return [token, configPageSize - (offset - configTokenOffset)];
                 }
@@ -41970,11 +41970,11 @@
                     trackedFields: optionalFieldsTrie,
                     serverRequestCount: 1,
                 }), body);
+                const snapshot = buildCachedSnapshot$1(luvio, context, {
+                    ...config,
+                    recordTypeId: responseRecordTypeId,
+                });
                 return luvio.storeBroadcast().then(() => {
-                    const snapshot = buildCachedSnapshot$1(luvio, context, {
-                        ...config,
-                        recordTypeId: responseRecordTypeId,
-                    });
                     return snapshot;
                 });
             }, () => {
@@ -44030,7 +44030,7 @@
             dropFunction: instrumentation$2.notifyRecordUpdateAvailableDropped,
         });
     });
-    // version: 1.110.1-cc1242727
+    // version: 1.111.0-f30e5e921
 
     var caseSensitiveUserId = '005B0000000GR4OIAW';
 
@@ -45113,10 +45113,10 @@
         };
         const storeBroadcast = function (_rebuildSnapshot, _snapshotDataAvailable) {
             validateNotDisposed();
-            // return resolved promise here and wait for the L2 flush to happen in handleSuccessResponse,
-            // that flush will cause the onChanged handler to fire which will revive
-            // records to the main L1 store and call the base storeBroadcast
-            return Promise.resolve();
+            // publishing to L2 is essentially "broadcasting" because the onChanged
+            // handler will fire which will revive records to the main L1 store and
+            // call the base storeBroadcast
+            return publishChangesToDurableStore();
         };
         const publishChangesToDurableStore = function () {
             validateNotDisposed();
@@ -45337,7 +45337,6 @@
                     // we don't need to prime metadata
                     () => { });
                     snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
-                    await publishChangesToDurableStore();
                 })();
                 for (const key of keysToReviveAsArray) {
                     // we are overwriting the previous promise at this key, but that
@@ -45365,7 +45364,6 @@
                 // so all we have to do is ingest then write to L2
                 ingestStagingStore = buildIngestStagingStore(environment);
                 snapshotFromMemoryIngest = await ingestAndBroadcastFunc();
-                await publishChangesToDurableStore();
             }
             if (snapshotFromMemoryIngest === undefined) {
                 return undefined;
@@ -45378,12 +45376,10 @@
             const result = await reviveSnapshot(environment, durableStore, snapshotFromMemoryIngest, durableStoreErrorHandler, () => environment.storeLookup(select, environment.createSnapshot, refresh));
             return result.snapshot;
         };
-        const handleErrorResponse = function (ingestAndBroadcastFunc) {
+        const handleErrorResponse = async function (ingestAndBroadcastFunc) {
             validateNotDisposed();
-            const snapshotFromMemoryIngest = ingestAndBroadcastFunc();
-            return publishChangesToDurableStore().then(() => {
-                return snapshotFromMemoryIngest;
-            });
+            ingestStagingStore = buildIngestStagingStore(environment);
+            return ingestAndBroadcastFunc();
         };
         const getNotifyChangeStoreEntries = function (keys) {
             validateNotDisposed();
@@ -48408,6 +48404,58 @@
      * For full license text, see the LICENSE.txt file
      */
 
+    /* Ideally we would use AbortController but it does not exist in V8, if it is ever polyfilled we can swap for it */
+    class LdsAbortController {
+        constructor() {
+            this.signal = new AbortSignal();
+        }
+        abort() {
+            this.signal.abort();
+        }
+    }
+    class AbortSignal {
+        constructor() {
+            this._aborted = false;
+            this.listeners = new Map();
+        }
+        get aborted() {
+            return this._aborted;
+        }
+        addEventListener(type, listener) {
+            let listeners = this.listeners.get(type);
+            if (!listeners) {
+                listeners = new Set();
+                this.listeners.set(type, listeners);
+            }
+            listeners.add(listener);
+        }
+        removeEventListener(type, listener) {
+            const listeners = this.listeners.get(type);
+            if (listeners) {
+                listeners.delete(listener);
+                if (listeners.size === 0) {
+                    this.listeners.delete(type);
+                }
+            }
+        }
+        dispatchEvent(event) {
+            const listeners = this.listeners.get(event.type);
+            if (listeners) {
+                for (const listener of listeners) {
+                    listener(this, event);
+                }
+            }
+            return !event.defaultPrevented;
+        }
+        abort() {
+            if (!this.aborted) {
+                this._aborted = true;
+                const abortEvent = new Event('abort');
+                this.dispatchEvent(abortEvent);
+            }
+        }
+    }
+
     class AsyncWorkerPool {
         constructor(concurrency) {
             this.queue = [];
@@ -48418,51 +48466,57 @@
             return new Promise((resolve, reject) => {
                 this.queue.push({
                     ...work,
-                    workFn: () => work.workFn().then(resolve).catch(reject),
+                    workFn: (abortController) => work.workFn(abortController).then(resolve).catch(reject),
                 });
                 this.doWork();
             });
         }
-        async cancel() {
-            const promises = [];
-            const cancellingWork = [
-                ...this.activeWork.splice(0, this.activeWork.length),
-                ...this.queue.splice(0, this.queue.length),
-            ];
-            cancellingWork.forEach((work) => {
-                const { cancelFn } = work;
+        /**
+         * cancel all work in the queue and active work
+         * @returns true if all work was cancelled, false if any work could not be cancelled
+         */
+        cancel() {
+            let success = true;
+            for (const { cancelFn } of this.queue) {
                 if (cancelFn) {
-                    promises.push(cancelFn());
+                    try {
+                        cancelFn();
+                    }
+                    catch (_a) {
+                        success = false;
+                    }
                 }
-            });
-            await promiseAllSettled(promises);
+            }
+            this.queue = [];
+            for (const { abortController, cancelFn } of this.activeWork) {
+                abortController.abort();
+                if (cancelFn) {
+                    try {
+                        cancelFn();
+                    }
+                    catch (_b) {
+                        success = false;
+                    }
+                }
+            }
+            this.activeWork = [];
+            return success;
         }
         doWork() {
             while (this.queue.length > 0 && this.activeWork.length < this.concurrency) {
                 const work = this.queue.shift();
                 if (work) {
-                    this.activeWork.push(work);
+                    const abortController = new LdsAbortController();
+                    const newWork = { ...work, abortController };
+                    this.activeWork.push(newWork);
                     const { workFn } = work;
-                    workFn()
-                        .then()
-                        .finally(() => {
-                        this.activeWork = this.activeWork.filter((w) => w !== work);
+                    workFn(abortController).finally(() => {
+                        this.activeWork = this.activeWork.filter((w) => w !== newWork);
                         this.doWork();
                     });
                 }
             }
         }
-    }
-    function promiseAllSettled(promises) {
-        return Promise.all(promises.map((promise) => promise
-            .then((value) => ({
-            status: 'fulfilled',
-            value,
-        }))
-            .catch((reason) => ({
-            status: 'rejected',
-            reason,
-        }))));
     }
 
     /**
@@ -49764,9 +49818,8 @@
                     const { response, synchronousIngest } = entry;
                     synchronousIngest(response, action);
                 }
-                // ingestAndBroadcastFunction can return Promise<void>, that's easiest
-                // to return since it's unused in this function
-                return Promise.resolve();
+                // must call base broadcast
+                return luvio.storeBroadcast();
             }, 
             // getTypeCacheKeysRecord uses the response, not the full path factory
             // so 2nd parameter will be unused
@@ -58864,9 +58917,10 @@
     const DEFAULT_CONCURRENCY = 6;
     class PrimingSession extends EventEmitter {
         constructor(config) {
+            var _a, _b;
             super();
-            this.batchSize = config.batchSize || DEFAULT_BATCH_SIZE;
-            this.concurrency = config.concurrency || DEFAULT_CONCURRENCY;
+            this.batchSize = (_a = config.batchSize) !== null && _a !== void 0 ? _a : DEFAULT_BATCH_SIZE;
+            this.concurrency = (_b = config.concurrency) !== null && _b !== void 0 ? _b : DEFAULT_CONCURRENCY;
             this.recordLoader = config.recordLoader;
             this.recordIngestor = config.recordIngestor;
             this.objectInfoLoader = config.objectInfoLoader;
@@ -58894,12 +58948,20 @@
                 this.enqueueBatches(availableBatches);
             }
         }
+        cancel() {
+            this.networkWorkerPool.cancel();
+        }
         // parallelizes batches of priming work
         enqueueBatches(batches) {
             for (const batch of batches) {
                 this.networkWorkerPool.push({
-                    workFn: () => {
-                        return this.recordLoader.fetchRecordData(batch).then(async (result) => {
+                    workFn: (abortController) => {
+                        return this.recordLoader
+                            .fetchRecordData(batch, abortController)
+                            .then(async (result) => {
+                            if (abortController.signal.aborted) {
+                                return;
+                            }
                             if (result.ok === false) {
                                 const { error } = result;
                                 const primingError = error === 'network-error' ? 'service-unavailable' : 'unknown';
@@ -58923,6 +58985,9 @@
                             this.recordIngestor
                                 .insertRecords(records)
                                 .then(({ written, conflicted }) => {
+                                if (abortController.signal.aborted) {
+                                    return;
+                                }
                                 // now that the records are persisted, emit the primed event
                                 if (written.length > 0) {
                                     this.emit('primed', Array.from(written));
@@ -58939,6 +59004,13 @@
                             });
                         });
                     },
+                    cancelFn: () => {
+                        this.emit('error', {
+                            ids: batch.ids,
+                            code: 'canceled',
+                            message: `batch canceled`,
+                        });
+                    },
                 });
             }
         }
@@ -58964,8 +59036,6 @@
     }
 
     const requiredPrefix = `required_`;
-    // note this is automatically incremented by scripts/release/bump-api-version.js at each release
-    const apiVersion = `v58.0`;
     const requiredFieldMap = {
         ApiName: 'ApiName',
         Id: 'Id',
@@ -58979,10 +59049,10 @@
         constructor(networkAdapter) {
             this.networkAdapter = networkAdapter;
         }
-        async fetchRecordData(batch) {
+        async fetchRecordData(batch, abortController) {
             let rep;
             try {
-                rep = await this.callGraphQL(batch);
+                rep = await this.callGraphQL(batch, abortController);
             }
             catch (e) {
                 return {
@@ -59024,25 +59094,9 @@
                 missingIds: Array.from(seenRecords),
             };
         }
-        async callGraphQL(batch) {
+        callGraphQL(batch, abortController) {
             const query = this.generateGraphQLQuery(batch.type, batch.fields);
-            const response = await this.networkAdapter({
-                baseUri: `/services/data/${apiVersion}`,
-                basePath: '/graphql',
-                method: 'POST',
-                priority: 'background',
-                body: {
-                    query,
-                    variables: {
-                        ids: batch.ids,
-                        first: batch.ids.length,
-                    },
-                },
-                queryParams: {},
-                urlParams: {},
-                headers: {},
-            }, {});
-            return response.body;
+            return this.networkAdapter.postGraphQL(query, { ids: batch.ids, first: batch.ids.length }, abortController);
         }
         generateGraphQLQuery(type, fields) {
             const fieldList = Object.keys(requiredFieldMap)
@@ -59177,8 +59231,57 @@
         return session;
     }
 
+    // so eslint doesn't complain about nimbus
+    /* global __nimbus */
+    // note this is automatically incremented by scripts/release/bump-api-version.js at each release
+    const apiVersion = `v58.0`;
+    class NimbusPrimingNetworkAdapter {
+        postGraphQL(query, variables, abortController) {
+            return new Promise((resolve, reject) => {
+                let listener;
+                const unregisterListener = () => {
+                    if (listener) {
+                        abortController.signal.removeEventListener('abort', listener);
+                    }
+                };
+                __nimbus.plugins.LdsNetworkAdapter
+                    .sendRequest({
+                    method: 'POST',
+                    path: `/services/data/${apiVersion}/graphql`,
+                    body: JSON.stringify({
+                        query,
+                        variables,
+                    }),
+                    headers: {},
+                    queryParams: {},
+                    priority: 'background',
+                    observabilityContext: {},
+                }, (response) => {
+                    unregisterListener();
+                    const { body } = response;
+                    if (body) {
+                        resolve(JSON.parse(body));
+                    }
+                    else {
+                        reject(new Error('No body returned from graphql endpoint'));
+                    }
+                }, (error) => {
+                    unregisterListener();
+                    reject(error);
+                })
+                    .then((cancellationToken) => {
+                    listener = () => {
+                        __nimbus.plugins.LdsNetworkAdapter.cancelRequest(cancellationToken);
+                    };
+                    abortController.signal.addEventListener('abort', listener);
+                });
+            });
+        }
+    }
+
     function primingSessionFactory(config) {
-        const { networkAdapter, store, objectInfoService, getLuvio } = config;
+        const { store, objectInfoService, getLuvio } = config;
+        const networkAdapter = new NimbusPrimingNetworkAdapter();
         const recordLoader = new RecordLoaderGraphQL(networkAdapter);
         const recordIngestor = new RecordIngestor(store, getLuvio);
         const session = new PrimingSession({
@@ -59303,7 +59406,6 @@
             createPrimingSession: (config) => {
                 return primingSessionFactory({
                     store: lazyBaseDurableStore,
-                    networkAdapter: lazyNetworkAdapter,
                     objectInfoService: lazyObjectInfoService,
                     getLuvio: () => lazyLuvio,
                     concurrency: config.concurrency,
@@ -59324,7 +59426,7 @@
         id: '@salesforce/lds-network-adapter',
         instrument: instrument$1,
     });
-    // version: 1.110.1-cc1242727
+    // version: 1.111.0-f30e5e921
 
     const { create: create$2, keys: keys$2 } = Object;
     const { stringify: stringify$1, parse: parse$1 } = JSON;
@@ -59597,6 +59699,26 @@
             }
         }
     }
+    function tokenForAtMost(paginationMetadata, maxOffset) {
+        const tokens = Object.keys(paginationMetadata);
+        let tokenResult = undefined;
+        let offsetResult = -1;
+        for (let i = 0, len = tokens.length; i < len; i++) {
+            const token = tokens[i];
+            const offset = paginationMetadata[token];
+            if (token === '__END__' || offset === undefined) {
+                continue;
+            }
+            if (offset === maxOffset) {
+                return [token, offset];
+            }
+            if (offset < maxOffset && offset > offsetResult) {
+                tokenResult = token;
+                offsetResult = offset;
+            }
+        }
+        return [tokenResult, offsetResult];
+    }
     function trimEdges(edges, startOffset, endOffset) {
         const trimmedEdges = [];
         if (edges !== undefined) {
@@ -59608,6 +59730,35 @@
             }
         }
         return trimmedEdges;
+    }
+    function optimizePagination(metadata, firstArgName, afterArgName, variables) {
+        if (typeof metadata === 'object' && metadata !== null && offsetFromToken(metadata, variables[afterArgName]) >= 0) {
+            // optimize only if after cursor is unspecified in the request or it's already loaded in metadata
+            const length = Object.keys(metadata).length;
+            const lastTokenAndOffset = tokenForAtMost(metadata, length);
+            if (lastTokenAndOffset !== undefined) {
+                const [token, offset] = lastTokenAndOffset;
+                variables[firstArgName + '_original'] = variables[firstArgName];
+                variables[afterArgName + '_original'] = variables[afterArgName];
+                variables[firstArgName] -= variables[afterArgName] === null ? (offset + 1) : (offset - 1);
+                variables[afterArgName] = token;
+            }
+        }
+    }
+    function revertPaginationOptimization(variables) {
+        if (variables) {
+            const toBeRemoved = [];
+            for (const key in variables) {
+                if (key.endsWith('_original')) {
+                    const origKey = key.substring(0, key.length - '_original'.length);
+                    if (Object.prototype.hasOwnProperty.call(variables, origKey)) {
+                        variables[origKey] = variables[key];
+                        toBeRemoved.push(key);
+                    }
+                }
+            }
+            toBeRemoved.forEach((k) => delete variables[k]);
+        }
     }
 
     function applyToSelection$6(selection, directive, variables) {
@@ -66218,7 +66369,7 @@
         });
     }
     function selectType$h(typename, sel, fieldData, reader, key, sink, variables, fragments) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         if (fieldData === null) {
             reader.assignScalar(key, sink, fieldData);
             return sink;
@@ -66876,6 +67027,10 @@
                             if (trimmedEdges === undefined || !listHasEnoughItems) {
                                 reader.markMissingLink(fieldData.__ref);
                                 reader.markMissing();
+                                // optimize pagination when "first" and "after" args are part of the variable
+                                if (((_c = firstArg === null || firstArg === void 0 ? void 0 : firstArg.value) === null || _c === void 0 ? void 0 : _c.kind) === 'Variable' && ((_d = afterArg === null || afterArg === void 0 ? void 0 : afterArg.value) === null || _d === void 0 ? void 0 : _d.kind) === 'Variable') {
+                                    optimizePagination(metadata, firstArg.value.name.value, afterArg.value.name.value, variables);
+                                }
                                 return;
                             }
                         }
@@ -66889,7 +67044,7 @@
                     const result = select$o(sel, variables, fragments)(paginatedData, reader);
                     const pageInfo = createPageInfo(result === null || result === void 0 ? void 0 : result.edges, startOffset, endOffset, maxOffset, metadata);
                     if (pageInfo !== undefined) {
-                        const selectedPageInfo = selectPageInfo$1((_c = sel.selectionSet) === null || _c === void 0 ? void 0 : _c.selections, fragments, pageInfo);
+                        const selectedPageInfo = selectPageInfo$1((_e = sel.selectionSet) === null || _e === void 0 ? void 0 : _e.selections, fragments, pageInfo);
                         if (selectedPageInfo !== undefined) {
                             reader.assignNonScalar(result, 'pageInfo', selectedPageInfo);
                         }
@@ -68520,7 +68675,7 @@
         }
     }
     function selectType$e(typename, sel, fieldData, reader, key, sink, variables, fragments) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e;
         if (fieldData === null) {
             reader.assignScalar(key, sink, fieldData);
             return sink;
@@ -68598,6 +68753,10 @@
                             if (trimmedEdges === undefined || !listHasEnoughItems) {
                                 reader.markMissingLink(fieldData.__ref);
                                 reader.markMissing();
+                                // optimize pagination when "first" and "after" args are part of the variable
+                                if (((_c = firstArg === null || firstArg === void 0 ? void 0 : firstArg.value) === null || _c === void 0 ? void 0 : _c.kind) === 'Variable' && ((_d = afterArg === null || afterArg === void 0 ? void 0 : afterArg.value) === null || _d === void 0 ? void 0 : _d.kind) === 'Variable') {
+                                    optimizePagination(metadata, firstArg.value.name.value, afterArg.value.name.value, variables);
+                                }
                                 return;
                             }
                         }
@@ -68611,7 +68770,7 @@
                     const result = select$o(sel, variables, fragments)(paginatedData, reader);
                     const pageInfo = createPageInfo(result === null || result === void 0 ? void 0 : result.edges, startOffset, endOffset, maxOffset, metadata);
                     if (pageInfo !== undefined) {
-                        const selectedPageInfo = selectPageInfo((_c = sel.selectionSet) === null || _c === void 0 ? void 0 : _c.selections, fragments, pageInfo);
+                        const selectedPageInfo = selectPageInfo((_e = sel.selectionSet) === null || _e === void 0 ? void 0 : _e.selections, fragments, pageInfo);
                         if (selectedPageInfo !== undefined) {
                             reader.assignNonScalar(result, 'pageInfo', selectedPageInfo);
                         }
@@ -75024,7 +75183,8 @@
                     return aVal < bVal ? -1 : (aVal > bVal) ? 1 : 0;
                 }).map((val, i) => serializeValueNode$1(val, variables) + `[${i}]`).join(',');
             case ("Variable"):
-                return variables[valueNode.name.value] + ""; //TODO: Is this correct serialization for object type variables?
+                const variableValue = variables[valueNode.name.value];
+                return typeof variableValue === "string" ? variableValue : JSON.stringify(variableValue);
             case ("NullValue"):
                 return "null";
             case ("ObjectValue"):
@@ -75795,6 +75955,9 @@
         const key = keyBuilder$3();
         const { query, variables } = resourceParams.body;
         luvio.storeIngest(key, ingest(query, variables), body);
+        // revert the optimized pagination variables back to its original so that subsequent store lookup will include all records, not just the ones loaded by an optimized query
+        // see optimizePagination for initial update to optimize the query
+        revertPaginationOptimization(variables);
         const snapshot = luvio.storeLookup({
             recordId: key,
             node: select$7(luvio, config),
@@ -76977,7 +77140,7 @@
         configuration: { ...configurationForGraphQLAdapters },
         instrument,
     });
-    // version: 1.110.1-cc1242727
+    // version: 1.111.0-f30e5e921
 
     // On core the unstable adapters are re-exported with different names,
 
@@ -79106,7 +79269,7 @@
         unstable_graphQL_imperative = createImperativeAdapter(luvio, createInstrumentedAdapter(ldsAdapter, adapterMetadata), adapterMetadata);
         graphQLImperative = ldsAdapter;
     });
-    // version: 1.110.1-cc1242727
+    // version: 1.111.0-f30e5e921
 
     var gqlApi = /*#__PURE__*/Object.freeze({
         __proto__: null,
@@ -79772,6 +79935,7 @@
         }
         return {
             enqueue: session.enqueue.bind(session),
+            cancel: session.cancel.bind(session),
         };
     }
 
@@ -79797,4 +79961,4 @@
     Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-// version: 1.110.1-cc1242727
+// version: 1.111.0-f30e5e921

package/dist/standalone/umd/primingApi.d.ts

@@ -3,7 +3,7 @@ interface PrimingError {
     code: ErrorCode;
     message: string;
 }
-type ErrorCode = 'precondition-error' | 'not-found' | 'service-unavailable' | 'unknown';
+type ErrorCode = 'precondition-error' | 'not-found' | 'service-unavailable' | 'canceled' | 'unknown';
 interface PrimingEventHandler {
     onError?: (error: PrimingError) => void;
     onPrimed?: (ids: string[]) => void;
@@ -15,5 +15,6 @@ export interface PrimingSessionConfig {
 }
 export declare function createPrimingSession(config: PrimingSessionConfig): {
     enqueue: (work: PrimingWork) => Promise<void>;
+    cancel: () => void;
 };
 export {};