@nxtedition/lib 14.0.0-alpha.2 → 14.0.1

package/package.json

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

package/util/template/index.js

@@ -22,7 +22,7 @@ module.exports = (options) => {
     try {
       return compileObjectTemplate(obj)(...args)
     } catch (err) {
-      return rxjs.throwError(err)
+      return rxjs.throwError(() => err)
     }
   }
 
@@ -37,27 +37,25 @@ module.exports = (options) => {
     for (let i = 0; i < arr.length; i++) {
       const resolver = compileTemplateLazy(arr[i])
       if (resolver) {
-        resolvers ??= []
+        resolvers ??= [() => rxjs.of({ indices, arr })]
         resolvers.push(resolver)
         indices ??= []
         indices.push(i)
       }
     }
 
-    if (!resolvers) {
-      return null
-    }
-
-    return (...args) =>
-      rxjs.combineLatest(resolvers.map((resolver) => resolver(...args))).pipe(
-        rx.map((values) => {
-          const ret = [...arr]
-          for (let n = 0; n < values.length; n++) {
-            ret[indices[n]] = values[n]
-          }
-          return ret
-        })
-      )
+    return resolvers
+      ? (...args) =>
+          rxjs.combineLatest(resolvers.map((resolver) => resolver(...args))).pipe(
+            rx.map((values) => {
+              const ret = [...arr]
+              for (let n = 0; n < values.length; n++) {
+                ret[indices[n]] = values[n]
+              }
+              return ret
+            })
+          )
+      : null
   }
 
   const compileArrayTemplate = weakCache(function compileArrayTemplate(arr) {
@@ -84,20 +82,18 @@ module.exports = (options) => {
       }
     }
 
-    if (!resolvers) {
-      return null
-    }
-
-    return (...args) =>
-      rxjs.combineLatest(resolvers.map((resolver) => resolver(...args))).pipe(
-        rx.map((values) => {
-          const ret = { ...obj }
-          for (let n = 0; n < values.length; n++) {
-            ret[indices[n]] = values[n]
-          }
-          return ret
-        })
-      )
+    return resolvers
+      ? (...args) =>
+          rxjs.combineLatest(resolvers.map((resolver) => resolver(...args))).pipe(
+            rx.map((values) => {
+              const ret = { ...obj }
+              for (let n = 0; n < values.length; n++) {
+                ret[indices[n]] = values[n]
+              }
+              return ret
+            })
+          )
+      : null
   }
 
   const compileObjectTemplate = weakCache(function compileObjectTemplate(obj) {
@@ -133,30 +129,27 @@ module.exports = (options) => {
     }
   }
 
-  const _compileStringTemplate = weakCache(
-    function _compileStringTemplate(match) {
-      const { pre, type, body, post } = match
+  const _compileStringTemplate = weakCache(function _compileStringTemplate(str, match) {
+    const { pre, type, body, post } = match
 
-      const compileExpression = compilers[type]
-      if (!compileExpression) {
-        throw new Error('unknown expression type')
-      }
+    const compileExpression = compilers[type]
+    if (!compileExpression) {
+      throw new Error('unknown expression type: ' + type)
+    }
 
-      const expr = compileExpression(body)
+    const expr = compileExpression(body)
 
-      if (!pre && !post) {
-        return expr
-      }
+    if (!pre && !post) {
+      return expr
+    }
 
-      return (...args) =>
-        expr(...args).pipe(
-          rx.switchMap((body) =>
-            compileStringTemplate(`${pre}${stringify(body, type !== 'js')}${post}`)(...args)
-          )
+    return (...args) =>
+      expr(...args).pipe(
+        rx.switchMap((body) =>
+          compileStringTemplate(`${pre}${stringify(body, type !== 'js')}${post}`)(...args)
         )
-    },
-    (match) => match.input
-  )
+      )
+  })
 
   function compileStringTemplateLazy(str) {
     if (!fp.isString(str)) {
@@ -224,7 +217,7 @@ module.exports = (options) => {
     try {
       return compileTemplate(str)(...args)
     } catch (err) {
-      return rxjs.throwError(err)
+      return rxjs.throwError(() => err)
     }
   }
 

package/util/template/javascript.js

@@ -141,6 +141,8 @@ function proxyify(value, expression) {
   }
 }
 
+const MAP_POOL = []
+
 module.exports = ({ ds, ...options }) => {
   class Expression {
     constructor(context, script, expression, args, observer) {
@@ -151,7 +153,7 @@ module.exports = ({ ds, ...options }) => {
 
       // TODO (perf): This could be faster by using an array + indices.
       // A bit similar to how react-hooks works.
-      this._entries = new Map()
+      this._entries = null
       this._refreshing = false
       this._counter = 0
       this._value = kEmpty
@@ -159,7 +161,7 @@ module.exports = ({ ds, ...options }) => {
       this._destroyed = false
       this._subscription = null
       this._args = null
-      this._hasArgs = false
+      this._ready = false
       this._handler = {
         get: (target, prop) => proxyify(target[prop], this),
       }
@@ -169,16 +171,20 @@ module.exports = ({ ds, ...options }) => {
         this._subscription = args.subscribe({
           next: (args) => {
             this._args = this._proxify ? proxyify(args, this) : args
-            this._hasArgs = true
+            this._ready = true
             this._refresh()
           },
           error: (err) => {
             this._observer.error(err)
+            this._subscription = null
+          },
+          complete: () => {
+            this._subscription = null
           },
         })
       } else {
         this._args = this._proxify ? proxyify(args, this) : args
-        this._hasArgs = true
+        this._ready = true
       }
 
       this._refreshNT(this)
@@ -231,16 +237,25 @@ module.exports = ({ ds, ...options }) => {
     _destroy() {
       this._destroyed = true
       this._subscription?.unsubscribe()
-      for (const entry of this._entries.values()) {
-        entry.dispose()
+
+      if (this._entries) {
+        for (const entry of this._entries.values()) {
+          entry.dispose()
+        }
+        this._entries.clear()
+
+        if (MAP_POOL.length < 1024) {
+          MAP_POOL.push(this._entries)
+        }
+
+        this._entries = null
       }
-      this._entries.clear()
     }
 
     _refreshNT(self) {
       self._refreshing = false
 
-      if (self._destroyed || self._disposing || !self._hasArgs) {
+      if (self._destroyed || self._disposing || !self._ready) {
         return
       }
 
@@ -271,18 +286,29 @@ module.exports = ({ ds, ...options }) => {
         self._context.nxt = null
 
         self._disposing = true
-        for (const entry of self._entries.values()) {
-          if (entry.counter !== self._counter) {
-            entry.dispose()
-            self._entries.delete(entry.key)
+
+        if (self._entries) {
+          for (const entry of self._entries.values()) {
+            if (entry.counter !== self._counter) {
+              entry.dispose()
+              self._entries.delete(entry.key)
+            }
+          }
+          if (self._entries.size === 0) {
+            self._entries = null
           }
         }
+
+        if (!self._entries) {
+          self._args = null
+        }
+
         self._disposing = false
       }
     }
 
     _refresh = () => {
-      if (this._refreshing || this._destroyed || this._disposing || !this._hasArgs) {
+      if (this._refreshing || this._destroyed || this._disposing || !this._ready) {
         return
       }
 
@@ -291,6 +317,7 @@ module.exports = ({ ds, ...options }) => {
     }
 
     _getEntry(key, Entry, opaque) {
+      this._entries ??= MAP_POOL.pop() ?? new Map()
       let entry = this._entries.get(key)
       if (!entry) {
         entry = new Entry(key, this._refresh, opaque)