@nxtedition/lib 23.17.14 → 23.17.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "23.17.14",
+  "version": "23.17.15",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",

package/yield.js

@@ -1,12 +1,6 @@
 import { FixedQueue } from './fixed-queue.js'
-import * as timers from './timers.js'
 
-export const YIELD_PRIORITY_HIGH = 0
-export const YIELD_PRIORITY_NORMAL = 1
-export const YIELD_PRIORITY_LOW = 2
-export const YIELD_PRIORITY_COUNT = 3
-
-const yieldQueue = new Array(YIELD_PRIORITY_COUNT).fill(null).map(() => new FixedQueue())
+const yieldQueue = new FixedQueue()
 const yieldSchedule = globalThis.setImmediate ?? ((fn) => setTimeout(fn, 0))
 
 let yieldTimeout = 40
@@ -14,8 +8,6 @@ let yieldActive = false
 let yieldScheduled = false
 let yieldTime = performance.now()
 
-const POOL = []
-
 export function setYieldTimeout(timeout) {
   if (typeof timeout !== 'number' || timeout < 0) {
     throw new TypeError('timeout must be a positive number')
@@ -23,26 +15,6 @@ export function setYieldTimeout(timeout) {
   yieldTimeout = timeout
 }
 
-export function setTimeout(callback, timeout, opaque, priority) {
-  if (typeof callback !== 'function') {
-    throw new TypeError('callback must be a function')
-  }
-  if (typeof timeout !== 'number' || timeout < 0) {
-    throw new TypeError('timeout must be a positive number')
-  }
-
-  return timers.setTimeout((opaque) => maybeYield(callback, opaque, priority), timeout, opaque)
-}
-
-export function clearTimeout(timeout) {
-  timers.clearTimeout(timeout)
-}
-
-// TODO (fix): Return a handle?
-export function setImmediate(callback, opaque, priority) {
-  maybeYield(callback, opaque, priority)
-}
-
 export function shouldYield() {
   if (!yieldActive && performance.now() - yieldTime >= yieldTimeout) {
     yieldActive = true
@@ -50,99 +22,54 @@ export function shouldYield() {
   return yieldActive
 }
 
-export function maybeYield(callback, opaque, priority) {
+export function maybeYield(callback) {
   if (callback != null && typeof callback !== 'function') {
     throw new TypeError('callback must be a function')
   }
 
   if (shouldYield()) {
-    return doYield(callback, opaque, priority)
+    return doYield(callback)
   }
 
   if (callback != null) {
-    callback(opaque)
+    callback(null)
   }
 
   return null
 }
 
-export function doYield(callback, opaque, priority) {
+export function doYield(callback) {
   if (callback != null && typeof callback !== 'function') {
     throw new TypeError('callback must be a function')
   }
 
-  if (priority === undefined) {
-    priority = YIELD_PRIORITY_NORMAL
-  }
-
-  if (priority < 0 || priority >= YIELD_PRIORITY_COUNT) {
-    throw new RangeError('invalid priority')
-  }
-
   if (!yieldScheduled) {
     yieldScheduled = true
     yieldSchedule(dispatchYield)
   }
 
   if (callback != null) {
-    if (opaque !== undefined) {
-      const arr = POOL.pop() ?? [null, null]
-      arr[0] = callback
-      arr[1] = opaque
-      yieldQueue[priority].push(arr)
-    } else {
-      yieldQueue[priority].push(callback)
-    }
+    yieldQueue.push(callback)
     return null
   }
 
   return new Promise((resolve) => {
-    if (opaque !== undefined) {
-      const arr = POOL.pop() ?? [null, null]
-      arr[0] = resolve
-      arr[1] = opaque
-      yieldQueue[priority].push(arr)
-    } else {
-      yieldQueue[priority].push(callback)
-    }
+    yieldQueue.push(resolve)
   })
 }
 
-function dispatchItem(item) {
-  if (item == null) {
-    return
-  }
-
-  let callback
-  let opaque = null
-
-  if (Array.isArray(item)) {
-    callback = item[0]
-    opaque = item[1]
-    if (POOL.length < 4096) {
-      item[0] = null
-      item[1] = null
-      POOL.push(item)
-    }
-  } else {
-    callback = item
-  }
-
-  callback(opaque)
-}
-
 function dispatchYield() {
   yieldTime = performance.now()
   yieldActive = false
 
-  for (let i = 0; i < YIELD_PRIORITY_COUNT; i++) {
-    const queue = yieldQueue[i]
-    while (!queue.isEmpty()) {
-      if (shouldYield()) {
-        yieldSchedule(dispatchYield)
-        return
-      }
-      dispatchItem(queue.shift())
+  while (!yieldQueue.isEmpty()) {
+    const resolve = yieldQueue.shift()
+
+    resolve(null)
+
+    if (shouldYield()) {
+      yieldSchedule(dispatchYield)
+      return
     }
   }