@nxtedition/yield 1.0.0-alpha.0

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+type Dispatcher = (callback: () => void) => void;
+export declare function setYieldDispatcher(schedule: Dispatcher | null): void;
+export declare function setYieldTimeout(timeout: number): void;
+export declare function shouldYield(timeout?: number): boolean;
+export declare function maybeYield<T>(callback?: (opaque: T | undefined) => void, opaque?: T, timeout?: number | undefined): Promise<null> | null;
+export declare function doYield<T>(callback?: (opaque: T | undefined) => void, opaque?: T): Promise<null> | null;
+export {};

package/lib/index.js

@@ -0,0 +1,113 @@
+                                                
+
+const kDefaultSchedule             =
+  globalThis.setImmediate ?? ((fn            ) => setTimeout(fn, 0))
+let yieldSchedule = kDefaultSchedule
+const yieldQueue                 = []
+
+let yieldIndex = 0
+let yieldTimeout = 40
+let yieldActive = false
+let yieldScheduled = false
+let yieldTime = performance.now()
+
+export function setYieldDispatcher(schedule                   ) {
+  yieldSchedule = schedule ?? kDefaultSchedule
+}
+
+export function setYieldTimeout(timeout        ) {
+  if (typeof timeout !== 'number' || timeout < 0) {
+    throw new TypeError('timeout must be a positive number')
+  }
+  yieldTimeout = timeout
+}
+
+export function shouldYield(timeout         ) {
+  if (timeout === undefined) {
+    timeout = yieldTimeout
+  }
+
+  if (!yieldActive && performance.now() - yieldTime >= timeout) {
+    yieldActive = true
+  }
+
+  return yieldActive
+}
+
+export function maybeYield   (
+  callback                                  ,
+  opaque    ,
+  timeout                     ,
+)                       {
+  if (callback != null && typeof callback !== 'function') {
+    throw new TypeError('callback must be a function')
+  }
+
+  if (shouldYield(timeout)) {
+    return doYield(callback, opaque)
+  }
+
+  if (callback != null) {
+    callback(opaque)
+  }
+
+  return null
+}
+
+export function doYield   (
+  callback                                  ,
+  opaque    ,
+)                       {
+  if (callback != null && typeof callback !== 'function') {
+    throw new TypeError('callback must be a function')
+  }
+
+  if (!yieldScheduled) {
+    yieldScheduled = true
+    yieldSchedule(dispatchYield)
+  }
+
+  if (callback != null) {
+    yieldQueue.push(callback, opaque)
+    return null
+  }
+
+  return new Promise((resolve) => {
+    yieldQueue.push(resolve, null)
+  })
+}
+
+function dispatchYield() {
+  yieldTime = performance.now()
+  yieldActive = false
+
+  const maxIndex = yieldQueue.length
+
+  while (yieldIndex < maxIndex) {
+    const resolve = yieldQueue[yieldIndex]                             
+    yieldQueue[yieldIndex] = null
+    yieldIndex += 1
+
+    const opaque = yieldQueue[yieldIndex]           
+    yieldQueue[yieldIndex] = null
+    yieldIndex += 1
+
+    resolve(opaque)
+
+    if (shouldYield()) {
+      break
+    }
+  }
+
+  if (yieldIndex === yieldQueue.length) {
+    yieldScheduled = false
+    yieldQueue.splice(0)
+    yieldIndex = 0
+  } else {
+    if (yieldIndex > 16 * 1024) {
+      yieldQueue.splice(0, yieldIndex)
+      yieldIndex = 0
+    }
+    yieldSchedule(dispatchYield)
+  }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@nxtedition/yield",
+  "version": "1.0.0-alpha.0",
+  "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/",
+    "prepublishOnly": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test"
+  },
+  "devDependencies": {
+    "amaroc": "^1.0.1",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.9.3"
+  },
+  "gitHead": "7e4d71a9276d64d7cb8c39eaed681121903e16a4"
+}