@vnejs/semaphore 0.0.3 → 0.0.5

package/package.json

@@ -1,22 +1,21 @@
 {
   "name": "@vnejs/semaphore",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "src",
+    "tsconfig.json"
   ],
   "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"
+    "build": "npx @vnejs/monorepo package",
+    "publish:major": "npx @vnejs/monorepo publish major --access public",
+    "publish:minor": "npx @vnejs/monorepo publish minor --access public",
+    "publish:patch": "npx @vnejs/monorepo publish patch --access public"
   },
   "author": "",
-  "license": "ISC",
-  "devDependencies": {
-    "typescript": "^6.0.3"
-  }
+  "license": "ISC"
 }

package/src/index.ts

@@ -0,0 +1,58 @@
+import type { QueueEntry } from "./queue-entry.js";
+import { createQueueEntry, getPromiseField, isCanAddNewElement, race, recalcSortedQueue } from "./utils.js";
+
+export class Semaphore {
+  queue: Record<string, QueueEntry> = {};
+  queueCurrent: QueueEntry[] = [];
+  queueSorted: QueueEntry[] = [];
+  length = 0;
+  weight = 0;
+  maxWeight = 999;
+  isQueueStarted = false;
+
+  constructor(maxWeight: number) {
+    this.maxWeight = maxWeight;
+  }
+
+  push = (key: string, weight: number, func: () => Promise<unknown>) => {
+    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));
+
+  private 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;
+  }
+
+  private start(e: QueueEntry) {
+    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/src/queue-entry.ts

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

package/src/utils.ts

@@ -0,0 +1,27 @@
+import type { QueueEntry } from "./queue-entry.js";
+
+export const getPromiseField = (e: QueueEntry) => e.promise;
+
+export const onlyNotInProcessWithResolve = (
+  e: QueueEntry,
+): e is QueueEntry & { resolve: () => void } => !e.inProcess && e.resolve !== undefined;
+
+export const byWeight = (a: QueueEntry, b: QueueEntry) => b.weight - a.weight;
+
+export const race = (entries: QueueEntry[]) =>
+  entries.length ? Promise.race(entries.map(getPromiseField)) : new Promise<void>((resolve) => setTimeout(resolve, 0));
+
+export const createQueueEntry = (key: string, weight: number, func: () => Promise<unknown>): QueueEntry => {
+  const obj = { key, weight, func, inProcess: false } as QueueEntry;
+  const promise = new Promise<void>((resolve) => {
+    obj.resolve = resolve;
+  });
+  obj.promise = promise;
+  return obj;
+};
+
+export const isCanAddNewElement = (queue: QueueEntry[], weight: number, maxWeight: number) =>
+  queue.length > 0 && maxWeight >= weight + queue[queue.length - 1].weight;
+
+export const recalcSortedQueue = (queue: Record<string, QueueEntry>) =>
+  Object.values(queue).filter(onlyNotInProcessWithResolve).sort(byWeight);

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "noEmitOnError": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules"]
+}