@nxtedition/lib 23.9.9 → 23.9.11

package/app.js

@@ -314,7 +314,7 @@ export function makeApp(appConfig, onTerminate) {
     setInterval(() => {
       let currentLag = Math.max(0, histogram.mean / 1e6 - resolution)
       if (Number.isNaN(currentLag)) {
-        currentLag = 0
+        currentLag = Infinity
       }
       histogram.reset()
 

package/cache.js

@@ -1,6 +1,7 @@
 import { LRUCache } from 'lru-cache'
 
 export class AsyncCache {
+  /** @type LRUCache<string, { expire: Number, value: any } **/
   #lru
   #valueSelector
   #keySelector
@@ -77,12 +78,11 @@ export class AsyncCache {
       if (!promise) {
         promise = this.#valueSelector(...args).then(
           (value) => {
-            this.#dedupe.delete(key)
             this.set(key, value)
             return [null, value]
           },
           (err) => {
-            this.#dedupe.delete(key)
+            this.delete(key)
             return [err, null]
           },
         )
@@ -103,6 +103,10 @@ export class AsyncCache {
     return value
   }
 
+  /**
+   * @param {string} key
+   * @param {any} value
+   */
   set(key, value) {
     if (typeof key !== 'string' || key.length === 0) {
       throw new TypeError('key must be a non-empty string')
@@ -114,6 +118,19 @@ export class AsyncCache {
     }
 
     this.#lru.set(key, cached)
+    this.#dedupe.delete(key)
+  }
+
+  /**
+   * @param {string} key
+   */
+  delete(key) {
+    if (typeof key !== 'string' || key.length === 0) {
+      throw new TypeError('key must be a non-empty string')
+    }
+
+    this.#lru.delete(key)
+    this.#dedupe.delete(key)
   }
 
   clear() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "23.9.9",
+  "version": "23.9.11",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -44,7 +44,8 @@
     "transcript.js",
     "docker-secrets.js",
     "wordwrap.js",
-    "under-pressure.js"
+    "under-pressure.js",
+    "yield.js"
   ],
   "scripts": {
     "prepublishOnly": "pinst --disable",

package/under-pressure.js

@@ -16,10 +16,6 @@ export default function (opts = {}) {
   const maxRssBytes = opts.maxRssBytes || 0
   const maxEventLoopUtilization = opts.maxEventLoopUtilization || 0
 
-  const checkMaxEventLoopDelay = maxEventLoopDelay > 0
-  const checkMaxHeapUsedBytes = maxHeapUsedBytes > 0
-  const checkMaxRssBytes = maxRssBytes > 0
-  const checkMaxEventLoopUtilization = maxEventLoopUtilization > 0
   const pressure$ = new rxjs.BehaviorSubject(null)
 
   let heapUsedBytes = 0
@@ -35,18 +31,15 @@ export default function (opts = {}) {
     elu = performance.eventLoopUtilization()
   }
 
-  if (
-    checkMaxEventLoopUtilization === false &&
-    checkMaxEventLoopDelay === false &&
-    checkMaxHeapUsedBytes === false &&
-    checkMaxRssBytes === false
-  ) {
+  if (!maxEventLoopDelay && !maxHeapUsedBytes && !maxRssBytes && !maxEventLoopUtilization) {
     return
   }
 
   function updateEventLoopDelay() {
     eventLoopDelay = Math.max(0, histogram.mean / 1e6 - resolution)
-    if (Number.isNaN(eventLoopDelay)) eventLoopDelay = Infinity
+    if (Number.isNaN(eventLoopDelay)) {
+      eventLoopDelay = Infinity
+    }
     histogram.reset()
   }
 
@@ -71,19 +64,23 @@ export default function (opts = {}) {
   }
 
   function isUnderPressure() {
-    if (checkMaxEventLoopDelay && eventLoopDelay > maxEventLoopDelay) {
+    if (maxEventLoopDelay && eventLoopDelay > maxEventLoopDelay) {
+      return true
+    }
+
+    if (maxHeapUsedBytes && heapUsedBytes > maxHeapUsedBytes) {
       return true
     }
 
-    if (checkMaxHeapUsedBytes && heapUsedBytes > maxHeapUsedBytes) {
+    if (maxRssBytes && rssBytes > maxRssBytes) {
       return true
     }
 
-    if (checkMaxRssBytes && rssBytes > maxRssBytes) {
+    if (maxEventLoopUtilization && eventLoopUtilized > maxEventLoopUtilization) {
       return true
     }
 
-    return checkMaxEventLoopUtilization && eventLoopUtilized > maxEventLoopUtilization
+    return false
   }
 
   function getPressure() {

package/yield.js

@@ -0,0 +1,23 @@
+let yieldTime = performance.now()
+
+export function maybeYield(opts) {
+  const timeout = opts?.timeout ?? 50
+  if (performance.now() - yieldTime > timeout) {
+    return doYield(opts)
+  }
+  opts?.signal?.throwIfAborted()
+}
+
+export async function doYield(opts) {
+  await new Promise((resolve) => setImmediate(resolve))
+  resetYield(opts)
+}
+
+function resetYield(opts) {
+  yieldTime = performance.now()
+  opts?.signal?.throwIfAborted()
+}
+
+setInterval(() => {
+  yieldTime = performance.now()
+}, 500).unref()