@nxtedition/lib 14.0.11 → 14.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "14.0.11",
+  "version": "14.0.13",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "files": [

package/util/template/index.js

@@ -7,10 +7,14 @@ const JSON5 = require('json5')
 const objectHash = require('object-hash')
 const weakCache = require('../../weakCache')
 
-module.exports = (options) => {
+module.exports = ({ ds, proxify }) => {
+  const compiler = {
+    current: null,
+  }
+
   const compilers = {
-    nxt: getNxtpressionsCompiler(options),
-    js: getJavascriptCompiler(options),
+    nxt: getNxtpressionsCompiler({ ds }),
+    js: getJavascriptCompiler({ ds, proxify, compiler }),
   }
 
   function inner(str) {
@@ -70,158 +74,99 @@ module.exports = (options) => {
     }
   }
 
-  const _compileArrayTemplate = weakCache(
-    (template, hash) => {
-      if (!fp.isArray(template)) {
-        throw new Error('invalid argument')
-      }
-
-      if (!hash) {
-        return null
+  function compileArrayTemplate(template) {
+    let resolvers
+    let indices
+
+    for (let i = 0; i < template.length; i++) {
+      const resolver = compileTemplate(template[i])
+      if (resolver) {
+        resolvers ??= []
+        resolvers.push(resolver)
+        indices ??= []
+        indices.push(i)
       }
+    }
 
-      let resolvers
-      let indices
-
-      for (let i = 0; i < template.length; i++) {
-        const resolver = compileTemplate(template[i])
-        if (resolver) {
-          resolvers ??= []
-          resolvers.push(resolver)
-          indices ??= []
-          indices.push(i)
-        }
-      }
-
-      return resolvers
-        ? (arr, args$) => {
-            const len = resolvers.length
-            const values = new Array(len)
-            for (let n = 0; n < len; n++) {
-              values[n] = resolvers[n](arr[indices[n]], args$)
-            }
-
-            return rxjs.combineLatest(values).pipe(
-              rx.map((values) => {
-                const ret = [...arr]
-                for (let n = 0; n < values.length; n++) {
-                  ret[indices[n]] = values[n]
-                }
-                return ret
-              })
-            )
+    return resolvers
+      ? (arr, args$) => {
+          const len = resolvers.length
+          const values = new Array(len)
+          for (let n = 0; n < len; n++) {
+            values[n] = resolvers[n](arr[indices[n]], args$)
           }
-        : null
-    },
-    (arr, hash) => hash ?? hashTemplate(arr)
-  )
 
-  const compileArrayTemplate = (template) => {
-    if (!fp.isArray(template)) {
-      throw new Error('invalid argument')
-    }
-    const hash = hashTemplate(template)
-    return hash ? _compileArrayTemplate(template, hash) : null
+          return rxjs.combineLatest(values).pipe(
+            rx.map((values) => {
+              const ret = [...arr]
+              for (let n = 0; n < values.length; n++) {
+                ret[indices[n]] = values[n]
+              }
+              return ret
+            })
+          )
+        }
+      : null
   }
 
-  const _compileObjectTemplate = weakCache(
-    (template, hash) => {
-      if (!fp.isPlainObject(template)) {
-        throw new Error('invalid argument')
-      }
-
-      if (!hash) {
-        return null
-      }
-
-      let resolvers
-      let indices
+  function compileObjectTemplate(template) {
+    let resolvers
+    let indices
 
-      const keys = Object.keys(template)
+    const keys = Object.keys(template)
 
-      for (let i = 0; i < keys.length; i++) {
-        const resolver = compileTemplate(template[keys[i]])
-        if (resolver) {
-          resolvers ??= []
-          resolvers.push(resolver)
-          indices ??= []
-          indices.push(keys[i])
-        }
+    for (let i = 0; i < keys.length; i++) {
+      const resolver = compileTemplate(template[keys[i]])
+      if (resolver) {
+        resolvers ??= []
+        resolvers.push(resolver)
+        indices ??= []
+        indices.push(keys[i])
       }
+    }
 
-      return resolvers
-        ? (obj, args$) => {
-            const len = resolvers.length
-            const values = new Array(len)
-            for (let n = 0; n < len; n++) {
-              values[n] = resolvers[n](obj[indices[n]], args$)
-            }
-
-            return rxjs.combineLatest(values).pipe(
-              rx.map((values) => {
-                const ret = { ...obj }
-                for (let n = 0; n < values.length; n++) {
-                  ret[indices[n]] = values[n]
-                }
-                return ret
-              })
-            )
+    return resolvers
+      ? (obj, args$) => {
+          const len = resolvers.length
+          const values = new Array(len)
+          for (let n = 0; n < len; n++) {
+            values[n] = resolvers[n](obj[indices[n]], args$)
           }
-        : null
-    },
-    (obj, hash) => hash ?? hashTemplate(obj)
-  )
 
-  const compileObjectTemplate = (template) => {
-    if (!fp.isPlainObject(template)) {
-      throw new Error('invalid argument')
-    }
-
-    const hash = hashTemplate(template)
-    return hash ? _compileObjectTemplate(template, hash) : null
+          return rxjs.combineLatest(values).pipe(
+            rx.map((values) => {
+              const ret = { ...obj }
+              for (let n = 0; n < values.length; n++) {
+                ret[indices[n]] = values[n]
+              }
+              return ret
+            })
+          )
+        }
+      : null
   }
 
-  const _compileStringTemplate = weakCache(
-    (template, hash) => {
-      if (!fp.isString(template)) {
-        throw new Error('invalid argument')
-      }
-
-      if (!hash) {
-        return null
-      }
-
-      const match = inner(template)
-      if (!match) {
-        return null
-      }
-
-      const { pre, type, body, post } = match
-
-      const compileExpression = compilers[type]
-      if (!compileExpression) {
-        throw new Error('unknown expression type: ' + type)
-      }
+  function compileStringTemplate(template) {
+    const match = inner(template)
+    if (!match) {
+      return null
+    }
 
-      const expr = compileExpression(body)
+    const { pre, type, body, post } = match
 
-      if (!pre && !post) {
-        return (str, args$) => expr(args$)
-      }
+    const compileExpression = compilers[type]
+    if (!compileExpression) {
+      throw new Error('unknown expression type: ' + type)
+    }
 
-      return (str, args$) =>
-        expr(args$).pipe(rx.map((body) => `${pre}${stringify(body, type !== 'js')}${post}`))
-    },
-    (str, hash) => hash ?? hashTemplate(str)
-  )
+    const expr = compileExpression(body)
 
-  const compileStringTemplate = (template) => {
-    if (!fp.isString(template)) {
-      throw new Error('invalid argument')
+    if (!pre && !post) {
+      return (str, args$) => expr(args$)
     }
 
-    const hash = hashTemplate(template)
-    return hash ? _compileStringTemplate(template, hash) : null
+    return (str, args$) =>
+      expr(args$).pipe(rx.map((body) => `${pre}${stringify(body, type !== 'js')}${post}`))
   }
 
   function stringify(value, escape) {
@@ -239,16 +184,24 @@ module.exports = (options) => {
     return typeof val === 'string' && val.indexOf('{{') !== -1
   }
 
+  const compileTemplateCache = weakCache(
+    (template) => {
+      if (fp.isPlainObject(template)) {
+        return compileObjectTemplate(template)
+      } else if (fp.isArray(template)) {
+        return compileArrayTemplate(template)
+      } else if (isTemplate(template)) {
+        return compileStringTemplate(template)
+      } else {
+        return null
+      }
+    },
+    (template, hash) => hash
+  )
+
   function compileTemplate(template) {
-    if (fp.isPlainObject(template)) {
-      return compileObjectTemplate(template)
-    } else if (fp.isArray(template)) {
-      return compileArrayTemplate(template)
-    } else if (isTemplate(template)) {
-      return compileStringTemplate(template)
-    } else {
-      return null
-    }
+    const hash = hashTemplate(template)
+    return hash ? compileTemplateCache(template, hash) : null
   }
 
   async function resolveTemplate(template, args$) {
@@ -263,10 +216,10 @@ module.exports = (options) => {
     }
   }
 
-  return {
+  return Object.assign(compiler, {
     resolveTemplate,
     onResolveTemplate,
     compileTemplate,
     isTemplate,
-  }
+  })
 }

package/util/template/javascript.js

@@ -14,13 +14,13 @@ class TimerEntry {
   constructor(key, refresh, delay) {
     this.key = key
     this.counter = null
+
     this.timer = setTimeout(refresh, delay)
   }
 
   dispose() {
     clearTimeout(this.timer)
 
-    this.refresh = null
     this.timer = null
   }
 }
@@ -29,12 +29,12 @@ class FetchEntry {
   constructor(key, refresh, { resource, options }) {
     this.key = key
     this.counter = null
+
     this.refresh = refresh
     this.ac = new AbortController()
     this.signal = this.ac.signal
     this.body = null
     this.status = null
-    this.options = options
     this.error = null
 
     // TODO (fix): options.signal
@@ -42,9 +42,9 @@ class FetchEntry {
     // TODO (fix): expire...
 
     undici
-      .fetch(resource, { ...this.options, signal: this.signal })
+      .fetch(resource, { ...options, signal: this.signal })
       .then(async (res) => {
-        if (!this.signal.aborted) {
+        if (this.refresh) {
           // TODO (fix): max size...
           this.body = Buffer.from(await res.arrayBuffer())
           this.status = res.status
@@ -53,7 +53,7 @@ class FetchEntry {
         }
       })
       .catch((err) => {
-        if (!this.signal.aborted) {
+        if (this.refresh) {
           this.error = err
           this.refresh()
         }
@@ -61,9 +61,10 @@ class FetchEntry {
   }
 
   dispose() {
-    this.ac.abort()
-
     this.refresh = null
+
+    this.ac.abort()
+    this.ac = null
   }
 }
 
@@ -71,6 +72,7 @@ class RecordEntry {
   constructor(key, refresh, ds) {
     this.key = key
     this.counter = null
+
     this.refresh = refresh
     this.record = ds.record.getRecord(key)
 
@@ -116,6 +118,36 @@ class ObservableEntry {
   dispose() {
     this.subscription.unsubscribe()
     this.subscription = null
+    this.refresh = null
+  }
+}
+
+class PromiseEntry {
+  constructor(key, refresh, promise) {
+    this.key = key
+    this.counter = null
+    this.value = kEmpty
+    this.error = null
+    this.refresh = refresh
+
+    promise.then(
+      (value) => {
+        if (this.refresh) {
+          this.value = value
+          this.refresh()
+        }
+      },
+      (err) => {
+        if (this.refresh) {
+          this.error = err
+          this.refresh()
+        }
+      }
+    )
+  }
+
+  dispose() {
+    this.refresh = null
   }
 }
 
@@ -141,13 +173,15 @@ const globals = {
   nxt: null,
 }
 
-function proxyify(value, expression) {
+function proxify(value, expression, handler) {
   if (!value) {
     return value
   } else if (rxjs.isObservable(value)) {
-    return proxyify(expression.observe(value), expression)
+    return proxify(expression.observe(value), expression)
+  } else if (typeof value?.then === 'function') {
+    return proxify(expression.wait(value), expression, handler)
   } else if (typeof value === 'object') {
-    return new Proxy(value, expression._handler)
+    return new Proxy(value, handler)
   } else {
     return value
   }
@@ -155,7 +189,14 @@ function proxyify(value, expression) {
 
 const MAP_POOL = []
 
-module.exports = ({ ds, ...options }) => {
+function makeWrapper(expression) {
+  const handler = {
+    get: (target, prop) => proxify(target[prop], this),
+  }
+  return (value) => proxify(value, expression, handler)
+}
+
+module.exports = ({ ds, proxify, compiler }) => {
   class Expression {
     constructor(context, script, expression, args, observer) {
       this._context = context
@@ -172,19 +213,13 @@ module.exports = ({ ds, ...options }) => {
       this._disposing = false
       this._destroyed = false
       this._subscription = null
-      this._args = null
-      this._ready = false
-      this._handler = options.proxyify
-        ? {
-            get: (target, prop) => proxyify(target[prop], this),
-          }
-        : null
+      this._args = kEmpty
+      this._wrap = null
 
       if (rxjs.isObservable(args)) {
         this._subscription = args.subscribe({
           next: (args) => {
-            this._args = this._handler ? proxyify(args, this) : args
-            this._ready = true
+            this._args = proxify ? this.wrap(args) : args
             this._refresh()
           },
           error: (err) => {
@@ -196,12 +231,16 @@ module.exports = ({ ds, ...options }) => {
           },
         })
       } else {
-        this._args = this._handler ? proxyify(args, this) : args
-        this._ready = true
+        this._args = proxify ? this.wrap(args) : args
         this._refreshNT(this)
       }
     }
 
+    wrap(value) {
+      this._wrap ??= makeWrapper(this)
+      return this._wrap(value)
+    }
+
     suspend() {
       throw kSuspend
     }
@@ -214,6 +253,10 @@ module.exports = ({ ds, ...options }) => {
       return this._getObservable(observable, throws)
     }
 
+    wait(promise, throws) {
+      return this._getWait(promise, throws)
+    }
+
     ds(id, state, throws) {
       return this._getRecord(id, state, throws)
     }
@@ -267,7 +310,7 @@ module.exports = ({ ds, ...options }) => {
     _refreshNT(self) {
       self._refreshing = false
 
-      if (self._destroyed || self._disposing || !self._ready) {
+      if (self._destroyed || self._disposing || self._args === kEmpty) {
         return
       }
 
@@ -277,6 +320,7 @@ module.exports = ({ ds, ...options }) => {
       self._context.$ = self._args
       self._context.nxt = self
       try {
+        compiler.current = this
         const value = self._script.runInContext(self._context)
         if (value !== self._value) {
           self._value = value
@@ -294,6 +338,8 @@ module.exports = ({ ds, ...options }) => {
           })
         )
       } finally {
+        compiler.current = null
+
         self._context.$ = null
         self._context.nxt = null
 
@@ -321,7 +367,7 @@ module.exports = ({ ds, ...options }) => {
     }
 
     _refresh = () => {
-      if (this._refreshing || this._destroyed || this._disposing || !this._ready) {
+      if (this._refreshing || this._destroyed || this._disposing || this._args === kEmpty) {
         return
       }
 
@@ -381,6 +427,28 @@ module.exports = ({ ds, ...options }) => {
       return entry.value
     }
 
+    _getWait(promise, throws) {
+      if (typeof promise?.then !== 'function') {
+        throw new Error(`invalid argument: Promise (${promise})`)
+      }
+
+      const entry = this._getEntry(promise, PromiseEntry, promise)
+
+      if (entry.error) {
+        throw entry.error
+      }
+
+      if (entry.value === kEmpty) {
+        if (throws ?? true) {
+          throw kSuspend
+        } else {
+          return null
+        }
+      }
+
+      return entry.value
+    }
+
     _getRecord(key, state, throws) {
       if (!key || typeof key !== 'string') {
         throw new Error(`invalid argument: key (${key})`)