@nxtedition/lib 13.2.3 → 14.0.0-alpha.2

package/package.json

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

package/util/template/index.js

@@ -1,5 +1,5 @@
 const rx = require('rxjs/operators')
-const Observable = require('rxjs')
+const rxjs = require('rxjs')
 const fp = require('lodash/fp')
 const getNxtpressionsCompiler = require('./nextpressions')
 const getJavascriptCompiler = require('./javascript')
@@ -22,52 +22,86 @@ module.exports = (options) => {
     try {
       return compileObjectTemplate(obj)(...args)
     } catch (err) {
-      return Observable.throwError(err)
+      return rxjs.throwError(err)
     }
   }
 
-  // TODO (perf): Optimize...
-  const compileArrayTemplate = weakCache(function compileArrayTemplate(arr) {
+  const compileArrayTemplateLazy = (arr) => {
     if (!fp.isArray(arr)) {
       throw new Error('invalid argument')
     }
 
-    if (arr.length === 0) {
-      return () => Observable.of([])
+    let resolvers
+    let indices
+
+    for (let i = 0; i < arr.length; i++) {
+      const resolver = compileTemplateLazy(arr[i])
+      if (resolver) {
+        resolvers ??= []
+        resolvers.push(resolver)
+        indices ??= []
+        indices.push(i)
+      }
+    }
+
+    if (!resolvers) {
+      return null
     }
 
-    const resolvers = arr.map((template) => compileTemplate(template))
+    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 (...args) => Observable.combineLatest(resolvers.map((resolver) => resolver(...args)))
+  const compileArrayTemplate = weakCache(function compileArrayTemplate(arr) {
+    return compileArrayTemplateLazy(arr) ?? (() => rxjs.of(arr))
   })
 
-  // TODO (perf): Optimize...
-  const compileObjectTemplate = weakCache(function compileObjectTemplate(obj) {
+  const compileObjectTemplateLazy = (obj) => {
     if (!fp.isPlainObject(obj)) {
       throw new Error('invalid argument')
     }
 
-    const xs = []
-    for (const key of Object.keys(obj)) {
-      xs.push(key, obj[key])
-    }
+    let resolvers
+    let indices
+
+    const keys = Object.keys(obj)
 
-    if (xs.length === 0) {
-      return () => Observable.of({})
+    for (let i = 0; i < keys.length; i++) {
+      const resolver = compileTemplateLazy(obj[keys[i]])
+      if (resolver) {
+        resolvers ??= []
+        resolvers.push(resolver)
+        indices ??= []
+        indices.push(keys[i])
+      }
     }
 
-    const resolvers = xs.map((template) => compileTemplate(template))
+    if (!resolvers) {
+      return null
+    }
 
     return (...args) =>
-      Observable.combineLatest(resolvers.map((resolver) => resolver(...args))).pipe(
-        rx.map((ys) => {
-          const ret = {}
-          for (let n = 0; n < ys.length; n += 2) {
-            ret[ys[n + 0]] = ys[n + 1]
+      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
         })
       )
+  }
+
+  const compileObjectTemplate = weakCache(function compileObjectTemplate(obj) {
+    return compileObjectTemplateLazy(obj) ?? (() => rxjs.of(obj))
   })
 
   function inner(str) {
@@ -91,6 +125,7 @@ module.exports = (options) => {
     }
 
     return {
+      input: str,
       pre: str.slice(0, templateStart),
       type,
       body: str.slice(bodyStart, bodyEnd),
@@ -98,37 +133,43 @@ module.exports = (options) => {
     }
   }
 
-  const compileStringTemplate = weakCache(function compileStringTemplate(str) {
-    if (!fp.isString(str)) {
-      throw new Error('invalid argument')
-    }
-
-    const match = inner(str)
+  const _compileStringTemplate = weakCache(
+    function _compileStringTemplate(match) {
+      const { pre, type, body, post } = match
 
-    if (!match) {
-      return () => Observable.of(str)
-    }
+      const compileExpression = compilers[type]
+      if (!compileExpression) {
+        throw new Error('unknown expression type')
+      }
 
-    const { pre, type, body, post } = match
+      const expr = compileExpression(body)
 
-    const compileExpression = compilers[type]
-    if (!compileExpression) {
-      throw new Error('unknown expression type')
-    }
+      if (!pre && !post) {
+        return expr
+      }
 
-    const expr = compileExpression(body)
+      return (...args) =>
+        expr(...args).pipe(
+          rx.switchMap((body) =>
+            compileStringTemplate(`${pre}${stringify(body, type !== 'js')}${post}`)(...args)
+          )
+        )
+    },
+    (match) => match.input
+  )
 
-    if (!pre && !post) {
-      return expr
+  function compileStringTemplateLazy(str) {
+    if (!fp.isString(str)) {
+      throw new Error('invalid argument')
     }
 
-    return (...args) =>
-      expr(...args).pipe(
-        rx.switchMap((body) =>
-          compileStringTemplate(`${pre}${stringify(body, type !== 'js')}${post}`)(...args)
-        )
-      )
-  })
+    const match = inner(str)
+    return match ? _compileStringTemplate(str, match) : null
+  }
+
+  function compileStringTemplate(str) {
+    return compileStringTemplateLazy(str) ?? (() => rxjs.of(str))
+  }
 
   function stringify(value, escape) {
     if (value == null) {
@@ -145,6 +186,18 @@ module.exports = (options) => {
     return typeof val === 'string' && val.indexOf('{{') !== -1
   }
 
+  function compileTemplateLazy(template) {
+    if (fp.isPlainObject(template)) {
+      return compileObjectTemplateLazy(template)
+    } else if (fp.isArray(template)) {
+      return compileArrayTemplateLazy(template)
+    } else if (fp.isString(template)) {
+      return compileStringTemplateLazy(template)
+    } else {
+      return null
+    }
+  }
+
   function compileTemplate(template) {
     if (fp.isPlainObject(template)) {
       return compileObjectTemplate(template)
@@ -153,7 +206,7 @@ module.exports = (options) => {
     } else if (fp.isString(template)) {
       return compileStringTemplate(template)
     } else {
-      return () => Observable.of(template)
+      return () => rxjs.of(template)
     }
   }
 
@@ -165,13 +218,13 @@ module.exports = (options) => {
 
   function onResolveTemplate(str, ...args) {
     if (fp.isString(str) && str.lastIndexOf('{{') === -1) {
-      return Observable.of(str)
+      return rxjs.of(str)
     }
 
     try {
       return compileTemplate(str)(...args)
     } catch (err) {
-      return Observable.throwError(err)
+      return rxjs.throwError(err)
     }
   }
 

package/weakCache.js

@@ -18,8 +18,10 @@ module.exports = function weakCache(valueSelector, keySelector) {
       }
     }
     const value = valueSelector(...args)
-    cache.set(key, new WeakRef(value))
-    finalizationRegistry.register(value, key)
+    if (value != null) {
+      cache.set(key, new WeakRef(value))
+      finalizationRegistry.register(value, key)
+    }
     return value
   }
 }