@nxtedition/lib 23.16.4 → 23.17.0

package/logger.js

@@ -32,7 +32,7 @@ export function createLogger(
 
     let flushing = 0
     setInterval(() => {
-      if (flushing > 60) {
+      if (flushing >= 10) {
         try {
           logger.warn('logger is flushing too slow')
           stream.flushSync()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "23.16.4",
+  "version": "23.17.0",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -39,7 +39,6 @@
     "errors.js",
     "errors.d.ts",
     "worker.js",
-    "scheduler.js",
     "stream.js",
     "timeline.js",
     "transcript.js",

package/yield.js

@@ -1,6 +1,12 @@
 import { FixedQueue } from './fixed-queue.js'
 
-const yieldQueue = new FixedQueue()
+const yieldQueues = [new FixedQueue(), new FixedQueue(), new FixedQueue()]
+const yieldQueueLength = yieldQueues.length
+
+export const PRIORITY_HIGH = 0
+export const PRIORITY_NORMAL = 1
+export const PRIORITY_LOW = 2
+
 const yieldSchedule = globalThis.setImmediate ?? ((fn) => setTimeout(fn, 0))
 
 let yieldTimeout = 40
@@ -22,13 +28,13 @@ export function shouldYield() {
   return yieldActive
 }
 
-export function maybeYield(callback) {
+export function maybeYield(callback, priority) {
   if (callback != null && typeof callback !== 'function') {
     throw new TypeError('callback must be a function')
   }
 
   if (shouldYield()) {
-    return doYield(callback)
+    return doYield(callback, priority)
   }
 
   if (callback != null) {
@@ -38,23 +44,39 @@ export function maybeYield(callback) {
   return null
 }
 
-export function doYield(callback) {
+export function doYield(callbackOrPriority, priorityOrNil) {
+  let callback = callbackOrPriority
+  let priority = priorityOrNil
+
+  if (callbackOrPriority == null) {
+    // Do nothing...
+  } else if (typeof callbackOrPriority === 'number' && priorityOrNil == null) {
+    priority = callbackOrPriority
+    callback = null
+  } else {
+    callback = callbackOrPriority
+  }
+
   if (callback != null && typeof callback !== 'function') {
     throw new TypeError('callback must be a function')
   }
 
+  if (priority != null && typeof priority !== 'number') {
+    throw new TypeError('priority must be a number')
+  }
+
   if (!yieldScheduled) {
     yieldScheduled = true
     yieldSchedule(dispatchYield)
   }
 
   if (callback != null) {
-    yieldQueue.push(callback)
+    yieldQueues[priority ?? PRIORITY_NORMAL].push(callback)
     return null
   }
 
   return new Promise((resolve) => {
-    yieldQueue.push(resolve)
+    yieldQueues[priority ?? PRIORITY_NORMAL].push(resolve)
   })
 }
 
@@ -62,14 +84,17 @@ function dispatchYield() {
   yieldTime = performance.now()
   yieldActive = false
 
-  while (!yieldQueue.isEmpty()) {
-    const resolve = yieldQueue.shift()
+  for (let n = 0; n < yieldQueueLength; n++) {
+    const yieldQueue = yieldQueues[n]
+    while (!yieldQueue.isEmpty()) {
+      const resolve = yieldQueue.shift()
 
-    resolve(null)
+      resolve(null)
 
-    if (shouldYield()) {
-      yieldSchedule(dispatchYield)
-      return
+      if (shouldYield()) {
+        yieldSchedule(dispatchYield)
+        return
+      }
     }
   }
 

package/scheduler.js

@@ -1,32 +0,0 @@
-import { setImmediate } from 'timers/promises'
-
-let yieldTime = performance.now()
-let yieldPromise = undefined
-
-function reset() {
-  yieldTime = performance.now()
-  yieldPromise = undefined
-}
-
-setInterval(reset, 100).unref()
-
-export function shouldYield() {
-  if (yieldPromise === undefined) {
-    yieldPromise = performance.now() - yieldTime > 50 ? null : undefined
-  }
-  return yieldPromise !== undefined
-}
-
-export function maybeYield() {
-  if (yieldPromise === undefined) {
-    yieldPromise = performance.now() - yieldTime > 50 ? null : undefined
-  }
-  if (yieldPromise === null) {
-    yieldPromise = setImmediate().then(reset)
-  }
-  return yieldPromise ?? null
-}
-
-export async function yield() {
-  return (yieldPromise ??= setImmediate().then(reset))
-}