@kapeta/local-cluster-service 0.70.3 → 0.70.5

package/src/storm/PromiseQueue.ts

@@ -1,129 +0,0 @@
-/**
- * Copyright 2023 Kapeta Inc.
- * SPDX-License-Identifier: BUSL-1.1
- */
-export type Future<T> = () => Promise<T>;
-
-export type FuturePromise<T> = {
-    promise: Promise<T>;
-    resolve: (value: T) => void;
-    reject: (reason: any) => void;
-    isResolved: () => boolean;
-};
-
-export function createFuture<T = void>(): FuturePromise<T> {
-    let resolved = false;
-    let resolve: (value: T) => void = () => {
-        resolved = true;
-    };
-    let reject: (reason: any) => void = () => {
-        resolved = true;
-    };
-
-    const promise = new Promise<T>((res, rej) => {
-        resolve = (value: T) => {
-            resolved = true;
-            res(value);
-        };
-        reject = (reason: any) => {
-            resolved = true;
-            rej(reason);
-        };
-    });
-    return {
-        promise,
-        resolve,
-        reject,
-        isResolved: () => resolved,
-    };
-}
-
-type InternalFuture<T> = {
-    execute: Future<T>;
-    promise: Promise<T>;
-    resolve: (value: T) => void;
-    reject: (reason: any) => void;
-};
-
-export class PromiseQueue {
-    private readonly queue: InternalFuture<any>[] = [];
-    private readonly active: Promise<any>[] = [];
-
-    // Maximum number of concurrent promises
-    private readonly maxConcurrency: number;
-
-    constructor(maxConcurrency: number = 5) {
-        this.maxConcurrency = maxConcurrency;
-    }
-
-    private toInternal<T>(future: Future<T>): InternalFuture<T> {
-        let resolve: (value: T) => void = () => {};
-        let reject: (reason: any) => void = () => {};
-
-        const promise = new Promise<T>((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        return {
-            execute: future,
-            promise,
-            resolve,
-            reject,
-        };
-    }
-
-    public add<T>(future: Future<T>) {
-        const internal = this.toInternal<T>(future);
-        this.queue.push(internal);
-        this.next();
-
-        return internal.promise;
-    }
-
-    private next(): boolean {
-        if (this.active.length >= this.maxConcurrency) {
-            return false;
-        }
-        if (this.queue.length === 0) {
-            return false;
-        }
-
-        const future = this.queue.shift();
-        if (!future) {
-            return false;
-        }
-
-        const promise = future
-            .execute()
-            .then(future.resolve)
-            .catch(future.reject)
-            .finally(() => {
-                this.active.splice(this.active.indexOf(promise), 1);
-                this.next();
-            });
-
-        this.active.push(promise);
-
-        return this.next();
-    }
-
-    public cancel() {
-        this.queue.splice(0, this.queue.length);
-        this.active.splice(0, this.active.length);
-    }
-
-    public async wait() {
-        while (this.queue.length > 0 || this.active.length > 0) {
-            await Promise.allSettled(this.active);
-            this.next();
-        }
-    }
-
-    public get empty() {
-        return this.queue.length === 0 && this.active.length === 0;
-    }
-
-    public get length() {
-        return this.queue.length + this.active.length;
-    }
-}