@nxtedition/lib 14.0.0-alpha.1 → 14.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "14.0.0-alpha.1",
+  "version": "14.0.0",
   "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) {
@@ -125,6 +121,7 @@ module.exports = (options) => {
     }
 
     return {
+      input: str,
       pre: str.slice(0, templateStart),
       type,
       body: str.slice(bodyStart, bodyEnd),
@@ -132,22 +129,12 @@ module.exports = (options) => {
     }
   }
 
-  const compileStringTemplateLazy = weakCache(function compileStringTemplatLazy(str) {
-    if (!fp.isString(str)) {
-      throw new Error('invalid argument')
-    }
-
-    const match = inner(str)
-
-    if (!match) {
-      return null
-    }
-
+  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')
+      throw new Error('unknown expression type: ' + type)
     }
 
     const expr = compileExpression(body)
@@ -164,7 +151,16 @@ module.exports = (options) => {
       )
   })
 
-  const compileStringTemplate = function compileStringTemplate(str) {
+  function compileStringTemplateLazy(str) {
+    if (!fp.isString(str)) {
+      throw new Error('invalid argument')
+    }
+
+    const match = inner(str)
+    return match ? _compileStringTemplate(str, match) : null
+  }
+
+  function compileStringTemplate(str) {
     return compileStringTemplateLazy(str) ?? (() => rxjs.of(str))
   }
 
@@ -221,7 +217,7 @@ module.exports = (options) => {
     try {
       return compileTemplate(str)(...args)
     } catch (err) {
-      return rxjs.throwError(err)
+      return rxjs.throwError(() => err)
     }
   }