@salesforce/lds-utils-adapters 1.110.1 → 1.111.0

package/dist/AsyncWorkerPool.d.ts

@@ -1,6 +1,7 @@
+import { LdsAbortController } from './LdsAbortController';
 export interface Work<T> {
-    workFn: () => Promise<T>;
-    cancelFn?: () => Promise<void>;
+    workFn: (abortController: LdsAbortController) => Promise<T>;
+    cancelFn?: () => void;
 }
 export declare class AsyncWorkerPool {
     private concurrency;
@@ -8,6 +9,10 @@ export declare class AsyncWorkerPool {
     private activeWork;
     constructor(concurrency: number);
     push<T>(work: Work<T>): Promise<T>;
-    cancel(): Promise<void>;
+    /**
+     * 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(): boolean;
     private doWork;
 }

package/dist/LdsAbortController.d.ts

@@ -0,0 +1,16 @@
+type EventListener = (signal: AbortSignal, event: Event) => void;
+export declare class LdsAbortController {
+    readonly signal: AbortSignal;
+    constructor();
+    abort(): void;
+}
+declare class AbortSignal {
+    private _aborted;
+    get aborted(): boolean;
+    private listeners;
+    addEventListener(type: 'abort', listener: EventListener): void;
+    removeEventListener(type: 'abort', listener: EventListener): void;
+    private dispatchEvent;
+    abort(): void;
+}
+export {};

package/dist/ldsAdapterUtils.js

@@ -303,6 +303,58 @@ function runAdapterWithReport(adapterName, adapter, adapterConfig, requestContex
     }
 }
 
+/* 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 = [];
@@ -313,51 +365,57 @@ class AsyncWorkerPool {
         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,
-    }))));
 }
 
-export { AsyncWorkerPool, runAdapterWithReport };
+export { AsyncWorkerPool, LdsAbortController, runAdapterWithReport };

package/dist/main.d.ts

@@ -1,3 +1,4 @@
 export { runAdapterWithReport } from './runAdapterWithReport';
 export { AdapterReport } from './AdapterReport';
 export { AsyncWorkerPool } from './AsyncWorkerPool';
+export { LdsAbortController } from './LdsAbortController';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@salesforce/lds-utils-adapters",
-    "version": "1.110.1",
+    "version": "1.111.0",
     "license": "SEE LICENSE IN LICENSE.txt",
     "description": "LDS Adapter Utilities",
     "main": "dist/ldsAdapterUtils.js",
@@ -26,6 +26,6 @@
         "test:unit": "jest"
     },
     "devDependencies": {
-        "@luvio/engine": "0.135.4"
+        "@luvio/engine": "0.136.5"
     }
 }