@nxtedition/scheduler 1.0.1

package/lib/fixed-queue.d.ts

@@ -0,0 +1,8 @@
+export class FixedQueue {
+    head: any;
+    tail: any;
+    size: number;
+    isEmpty(): any;
+    push(data: any): void;
+    shift(): any;
+}

package/lib/fixed-queue.js

@@ -0,0 +1,123 @@
+// Extracted from node/lib/internal/fixed_queue.js
+
+// Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two.
+const kSize = 2048
+const kMask = kSize - 1
+
+// The FixedQueue is implemented as a singly-linked list of fixed-size
+// circular buffers. It looks something like this:
+//
+//  head                                                       tail
+//    |                                                          |
+//    v                                                          v
+// +-----------+ <-----\       +-----------+ <------\         +-----------+
+// |  [null]   |        \----- |   next    |         \------- |   next    |
+// +-----------+               +-----------+                  +-----------+
+// |   item    | <-- bottom    |   item    | <-- bottom       |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |       bottom --> |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |    ...    |               |    ...    |                  |    ...    |
+// |   item    |               |   item    |                  |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |  [empty]  | <-- top       |   item    |                  |   item    |
+// |  [empty]  |               |   item    |                  |   item    |
+// |  [empty]  |               |  [empty]  | <-- top  top --> |  [empty]  |
+// +-----------+               +-----------+                  +-----------+
+//
+// Or, if there is only one circular buffer, it looks something
+// like either of these:
+//
+//  head   tail                                 head   tail
+//    |     |                                     |     |
+//    v     v                                     v     v
+// +-----------+                               +-----------+
+// |  [null]   |                               |  [null]   |
+// +-----------+                               +-----------+
+// |  [empty]  |                               |   item    |
+// |  [empty]  |                               |   item    |
+// |   item    | <-- bottom            top --> |  [empty]  |
+// |   item    |                               |  [empty]  |
+// |  [empty]  | <-- top            bottom --> |   item    |
+// |  [empty]  |                               |   item    |
+// +-----------+                               +-----------+
+//
+// Adding a value means moving `top` forward by one, removing means
+// moving `bottom` forward by one. After reaching the end, the queue
+// wraps around.
+//
+// When `top === bottom` the current queue is empty and when
+// `top + 1 === bottom` it's full. This wastes a single space of storage
+// but allows much quicker checks.
+
+class FixedCircularBuffer {
+  constructor() {
+    this.bottom = 0
+    this.top = 0
+    this.list = new Array(kSize).fill(undefined)
+    this.next = null
+  }
+
+  isEmpty() {
+    return this.top === this.bottom
+  }
+
+  isFull() {
+    return ((this.top + 1) & kMask) === this.bottom
+  }
+
+  push(data) {
+    this.list[this.top] = data
+    this.top = (this.top + 1) & kMask
+  }
+
+  shift() {
+    const nextItem = this.list[this.bottom]
+    if (nextItem === undefined) {
+      return null
+    }
+    this.list[this.bottom] = undefined
+    this.bottom = (this.bottom + 1) & kMask
+    return nextItem
+  }
+}
+
+const POOL = []
+
+export class FixedQueue {
+  constructor() {
+    this.head = this.tail = POOL.pop() ?? new FixedCircularBuffer()
+    this.size = 0
+  }
+
+  isEmpty() {
+    return this.head.isEmpty()
+  }
+
+  push(data) {
+    if (this.head.isFull()) {
+      // Head is full: Creates a new queue, sets the old queue's `.next` to it,
+      // and sets it as the new main queue.
+      this.head = this.head.next = POOL.pop() ?? new FixedCircularBuffer()
+    }
+    this.head.push(data)
+  }
+
+  shift() {
+    const tail = this.tail
+    const next = tail.shift()
+    if (tail.isEmpty() && tail.next !== null) {
+      // If there is another queue, it forms the new tail.
+      this.tail = tail.next
+      tail.next = null
+      tail.bottom = 0
+      tail.top = 0
+      if (POOL.length < 64) {
+        POOL.push(tail)
+      }
+    }
+    return next
+  }
+}

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+export declare class Scheduler {
+    #private;
+    static LOW: 0;
+    static NORMAL: 1;
+    static HIGH: 2;
+    constructor({ concurrency }?: {
+        concurrency?: number | undefined;
+    });
+    schedule(fn: ((next: Function) => any), priority?: 1): any;
+}

package/lib/index.js

@@ -0,0 +1,63 @@
+import { FixedQueue } from './fixed-queue.js'
+
+export class Scheduler {
+  static LOW    = 0
+  static NORMAL    = 1
+  static HIGH    = 2
+
+  #concurrency
+  #running = 0
+  #counter = 0
+
+  #lowQueue = new FixedQueue()
+  #normalQueue = new FixedQueue()
+  #highQueue = new FixedQueue()
+
+  constructor({ concurrency = Infinity } = {}) {
+    this.#concurrency = concurrency
+  }
+
+  schedule(fn                           , priority = Scheduler.NORMAL) {
+    if (typeof fn !== 'function') {
+      throw new TypeError('First argument must be a function')
+    }
+
+    if (priority == null) {
+      priority = Scheduler.NORMAL
+    }
+
+    if (!Number.isInteger(priority)) {
+      throw new Error('Invalid priority')
+    }
+
+    if (this.#running < this.#concurrency) {
+      this.#running++
+      return fn(this.#next)
+    }
+
+    if (priority > Scheduler.NORMAL) {
+      this.#highQueue.push(fn)
+    } else if (priority < Scheduler.NORMAL) {
+      this.#lowQueue.push(fn)
+    } else {
+      this.#normalQueue.push(fn)
+    }
+  }
+
+  #next = () => {
+    this.#counter++
+    this.#running--
+
+    const fn =
+      ((this.#counter & 63) === 0 && this.#lowQueue.shift()) ??
+      ((this.#counter & 15) === 0 && this.#normalQueue.shift()) ??
+      this.#highQueue.shift() ??
+      this.#normalQueue.shift() ??
+      this.#lowQueue.shift()
+
+    if (fn) {
+      this.#running++
+      fn(this.#next)
+    }
+  }
+}

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@nxtedition/scheduler",
+  "version": "1.0.1",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "rimraf lib && tsc && amaroc ./src/index.ts && mv src/index.js lib/ && cp src/fixed-queue.js lib/",
+    "prepublishOnly": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test",
+    "test:ci": "node --test"
+  },
+  "devDependencies": {
+    "amaroc": "^1.0.1",
+    "rimraf": "^6.1.2",
+    "typescript": "^5.9.3"
+  },
+  "gitHead": "5e9be5511fdd2e10aecbab7cc007bdaf990f728a"
+}