@vnejs/semaphore 0.0.3

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { QueueEntry } from "./queue-entry.js";
+export declare class Semaphore {
+    queue: Record<string, QueueEntry>;
+    queueCurrent: QueueEntry[];
+    queueSorted: QueueEntry[];
+    length: number;
+    weight: number;
+    maxWeight: number;
+    isQueueStarted: boolean;
+    constructor(maxWeight: number);
+    push: (key: string, weight: number, func: () => Promise<unknown>) => Promise<void>;
+    waitAll: () => Promise<void[]>;
+    private startQueue;
+    private start;
+}

package/dist/index.js

@@ -0,0 +1,53 @@
+import { createQueueEntry, getPromiseField, isCanAddNewElement, race, recalcSortedQueue } from "./utils.js";
+export class Semaphore {
+    queue = {};
+    queueCurrent = [];
+    queueSorted = [];
+    length = 0;
+    weight = 0;
+    maxWeight = 999;
+    isQueueStarted = false;
+    constructor(maxWeight) {
+        this.maxWeight = maxWeight;
+    }
+    push = (key, weight, func) => {
+        const element = this.queue[key];
+        if (element) {
+            if (element.weight > weight && !element.inProcess)
+                Object.assign(element, { weight, func });
+            return element.promise;
+        }
+        const obj = createQueueEntry(key, weight, func);
+        this.queueSorted = [];
+        this.queue[key] = obj;
+        this.length++;
+        !this.isQueueStarted && void this.startQueue();
+        return obj.promise;
+    };
+    waitAll = () => Promise.all(this.queueCurrent.map(getPromiseField));
+    async startQueue() {
+        this.isQueueStarted = true;
+        while (this.length) {
+            this.queueSorted = this.queueSorted.length ? this.queueSorted : recalcSortedQueue(this.queue);
+            while (isCanAddNewElement(this.queueSorted, this.weight, this.maxWeight)) {
+                const entry = this.queueSorted.pop();
+                if (entry)
+                    this.start(entry);
+            }
+            await race(this.queueCurrent);
+        }
+        this.isQueueStarted = false;
+    }
+    start(e) {
+        this.weight += e.weight;
+        e.inProcess = true;
+        this.queueCurrent.push(e);
+        e.func().then(() => {
+            this.weight -= e.weight;
+            this.queueCurrent = this.queueCurrent.filter((a) => a.key !== e.key);
+            this.length--;
+            delete this.queue[e.key];
+            e.resolve?.();
+        });
+    }
+}

package/dist/queue-entry.d.ts

@@ -0,0 +1,8 @@
+export type QueueEntry = {
+    key: string;
+    weight: number;
+    func: () => Promise<unknown>;
+    inProcess: boolean;
+    resolve?: () => void;
+    promise: Promise<void>;
+};

package/dist/queue-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.d.ts

@@ -0,0 +1,12 @@
+import type { QueueEntry } from "./queue-entry.js";
+export declare const getPromiseField: (e: QueueEntry) => Promise<void>;
+export declare const onlyNotInProcessWithResolve: (e: QueueEntry) => e is QueueEntry & {
+    resolve: () => void;
+};
+export declare const byWeight: (a: QueueEntry, b: QueueEntry) => number;
+export declare const race: (entries: QueueEntry[]) => Promise<void>;
+export declare const createQueueEntry: (key: string, weight: number, func: () => Promise<unknown>) => QueueEntry;
+export declare const isCanAddNewElement: (queue: QueueEntry[], weight: number, maxWeight: number) => boolean;
+export declare const recalcSortedQueue: (queue: Record<string, QueueEntry>) => (QueueEntry & {
+    resolve: () => void;
+})[];

package/dist/utils.js

@@ -0,0 +1,14 @@
+export const getPromiseField = (e) => e.promise;
+export const onlyNotInProcessWithResolve = (e) => !e.inProcess && e.resolve !== undefined;
+export const byWeight = (a, b) => b.weight - a.weight;
+export const race = (entries) => entries.length ? Promise.race(entries.map(getPromiseField)) : new Promise((resolve) => setTimeout(resolve, 0));
+export const createQueueEntry = (key, weight, func) => {
+    const obj = { key, weight, func, inProcess: false };
+    const promise = new Promise((resolve) => {
+        obj.resolve = resolve;
+    });
+    obj.promise = promise;
+    return obj;
+};
+export const isCanAddNewElement = (queue, weight, maxWeight) => queue.length > 0 && maxWeight >= weight + queue[queue.length - 1].weight;
+export const recalcSortedQueue = (queue) => Object.values(queue).filter(onlyNotInProcessWithResolve).sort(byWeight);

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@vnejs/semaphore",
+  "version": "0.0.3",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc -p tsconfig.json",
+    "publish:major": "npm run build && npm version major && npm publish --access public",
+    "publish:minor": "npm run build && npm version minor && npm publish --access public",
+    "publish:patch": "npm run build && npm version patch && npm publish --access public"
+  },
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "typescript": "^6.0.3"
+  }
+}