@nxtedition/lib 23.17.12 → 23.17.14

package/app.js

@@ -902,7 +902,7 @@ export function makeApp(appConfig, onTerminate) {
       )
 
     const loggerSubscription = status$
-      .pipe(rx.pluck('messages'), rx.startWith([]), rx.pairwise())
+      .pipe(rx.auditTime(1e3), rx.pluck('messages'), rx.startWith([]), rx.pairwise())
       .subscribe(([prev, next]) => {
         for (const { level, msg: status, ...message } of fp.differenceBy('id', next, prev)) {
           if (level >= 50) {

package/http.js

@@ -232,7 +232,7 @@ export async function requestMiddleware(ctx, next) {
     }
 
     if (!isHealthcheck) {
-      ctx.logger?.debug('request started')
+      ctx.logger?.debug({ req }, 'request started')
     }
 
     if (ctx.id) {

package/package.json

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

package/util/template/index.test.js

@@ -34,3 +34,19 @@ test('pipe short-circuit', async () => {
     undefined,
   )
 })
+
+test('return function', async () => {
+  const compiler = makeTemplateCompiler({
+    ds: {},
+    logger: console,
+  })
+
+  assert.strictEqual(
+    (
+      await compiler.resolveTemplate(`{{#js (input) => fp.toUpper($.foo + input) }}`, {
+        foo: 'bar',
+      })
+    )('baz'),
+    'BARBAZ',
+  )
+})

package/util/template/javascript.js

@@ -644,6 +644,15 @@ export default function ({ ds, proxify, compiler, logger, platform }) {
 
           return value
         };
+
+        const fp = globalThis.fp
+        const moment = globalThis.moment
+        const Timecode = globalThis.Timecode
+        const datefns = globalThis.datefns
+        const JSON5 = globalThis.JSON5
+        const $ = globalThis.$
+        const nxt = globalThis.nxt
+
         _.asset = (type, state, suspend) => (name) => nxt._asset(name, type, state, suspend);
         _.ds = (postfix, state, suspend) => (name) => nxt._ds(name, postfix, state, suspend);
         _.get = (postfix, path, state, suspend) => (name) => nxt._get(name, postfix, path, state, suspend);

package/yield.js

@@ -1,6 +1,12 @@
 import { FixedQueue } from './fixed-queue.js'
+import * as timers from './timers.js'
 
-const yieldQueue = new FixedQueue()
+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 yieldSchedule = globalThis.setImmediate ?? ((fn) => setTimeout(fn, 0))
 
 let yieldTimeout = 40
@@ -8,6 +14,8 @@ 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')
@@ -15,6 +23,26 @@ 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
@@ -22,54 +50,99 @@ export function shouldYield() {
   return yieldActive
 }
 
-export function maybeYield(callback) {
+export function maybeYield(callback, opaque, priority) {
   if (callback != null && typeof callback !== 'function') {
     throw new TypeError('callback must be a function')
   }
 
   if (shouldYield()) {
-    return doYield(callback)
+    return doYield(callback, opaque, priority)
   }
 
   if (callback != null) {
-    callback(null)
+    callback(opaque)
   }
 
   return null
 }
 
-export function doYield(callback) {
+export function doYield(callback, opaque, priority) {
   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) {
-    yieldQueue.push(callback)
+    if (opaque !== undefined) {
+      const arr = POOL.pop() ?? [null, null]
+      arr[0] = callback
+      arr[1] = opaque
+      yieldQueue[priority].push(arr)
+    } else {
+      yieldQueue[priority].push(callback)
+    }
     return null
   }
 
   return new Promise((resolve) => {
-    yieldQueue.push(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)
+    }
   })
 }
 
+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
 
-  while (!yieldQueue.isEmpty()) {
-    const resolve = yieldQueue.shift()
-
-    resolve(null)
-
-    if (shouldYield()) {
-      yieldSchedule(dispatchYield)
-      return
+  for (let i = 0; i < YIELD_PRIORITY_COUNT; i++) {
+    const queue = yieldQueue[i]
+    while (!queue.isEmpty()) {
+      if (shouldYield()) {
+        yieldSchedule(dispatchYield)
+        return
+      }
+      dispatchItem(queue.shift())
     }
   }