@nxtedition/lib 19.4.6 → 19.4.9

package/errors.js

@@ -142,15 +142,16 @@ function _serializeError(error, { depth }) {
 
 // TODO (fix): Recursion guard?
 export function makeMessages(error, options) {
-  if (!error) {
+  if (!error || error.length === 0) {
     return []
   }
 
   if (Array.isArray(error)) {
     return fp.pipe(
       fp.flattenDeep,
+      fp.filter(Boolean),
       fp.flatMap((x) => makeMessages(x, options)),
-      fp.uniqBy(fp.isEqual),
+      fp.uniqBy('id'),
     )(error)
   } else if (Array.isArray(error.messages)) {
     return makeMessages(error.messages, options)
@@ -209,13 +210,11 @@ export function makeMessages(error, options) {
 
     return [
       err,
-      ...makeMessages([
-        error.cause,
-        error.error,
-        error.errors,
-        error.messages,
-        error.status?.messages,
-      ]),
+      ...makeMessages(
+        [error.cause, error.error, error.errors, error.messages, error.status?.messages].filter(
+          Boolean,
+        ),
+      ),
     ]
   } else {
     return []

package/package.json

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

package/util/template/javascript.js

@@ -164,7 +164,7 @@ class PromiseEntry {
   }
 }
 
-function pipe(value, ...fns) {
+function pipe(value, fns) {
   for (const fn of fns) {
     value = fn(value)
     if (value == null) {
@@ -233,6 +233,7 @@ export default function ({ ds, proxify, compiler }) {
       this._wrap = null
       this._suspended = false
       this._errored = false
+      this._refreshImpl = this._refreshImpl.bind(this)
 
       if (rxjs.isObservable(args)) {
         this._subscription = args.subscribe({
@@ -250,7 +251,7 @@ export default function ({ ds, proxify, compiler }) {
         })
       } else {
         this._args = proxify ? this.wrap(args) : args
-        this._refreshNT(this)
+        this._refreshImpl()
       }
     }
 
@@ -325,78 +326,78 @@ export default function ({ ds, proxify, compiler }) {
       }
     }
 
-    _refreshNT(self) {
-      self._refreshing = false
+    _refreshImpl() {
+      this._refreshing = false
 
-      if (self._destroyed || self._disposing || self._args === kEmpty) {
+      if (this._destroyed || this._disposing || this._args === kEmpty) {
         return
       }
 
-      self._counter = (self._counter + 1) & maxInt
+      this._counter = (this._counter + 1) & maxInt
 
       // TODO (fix): freeze?
-      self._context.$ = self._args
-      self._context.nxt = self
+      this._context.$ = this._args
+      this._context.nxt = this
 
       const previous = compiler.current
-      compiler.current = self
+      compiler.current = this
 
       try {
-        assert(self._suspended === false)
-        const value = self._script.runInContext(self._context)
-        self._errored = false
-        if (self._suspended) {
+        assert(this._suspended === false)
+        const value = this._script.runInContext(this._context)
+        this._errored = false
+        if (this._suspended) {
           return
         }
 
-        if (value !== self._value) {
-          self._value = value
-          self._observer.next(value)
+        if (value !== this._value) {
+          this._value = value
+          this._observer.next(value)
         }
       } catch (err) {
         if (err === kSuspend) {
           return
         }
 
-        self._errored = true
+        this._errored = true
 
         const error = Object.assign(new Error('expression failed'), {
           cause: err,
-          data: self._expression,
+          data: this._expression,
         })
 
-        if (self._suspended) {
+        if (this._suspended) {
           process.emitWarning(error)
         } else {
-          self._observer.error(error)
+          this._observer.error(error)
         }
       } finally {
         compiler.current = previous
 
-        self._context.$ = null
-        self._context.nxt = null
+        this._context.$ = null
+        this._context.nxt = null
 
-        self._suspended = false
-        self._disposing = true
+        this._suspended = false
+        this._disposing = true
 
-        if (self._entries) {
-          for (const entry of self._entries.values()) {
-            if (entry.counter !== self._counter) {
+        if (this._entries) {
+          for (const entry of this._entries.values()) {
+            if (entry.counter !== this._counter) {
               entry.dispose()
-              self._entries.delete(entry.key)
+              this._entries.delete(entry.key)
             }
           }
-          if (self._entries.size === 0) {
-            self._entries = null
+          if (this._entries.size === 0) {
+            this._entries = null
           }
         }
 
         // TODO (perf): Make this work.
-        // if (!self._entries) {
-        //   self._args = null
+        // if (!this._entries) {
+        //   this._args = null
         // }
 
-        self._disposing = false
+        this._disposing = false
       }
     }
 
@@ -406,7 +407,7 @@ export default function ({ ds, proxify, compiler }) {
       }
 
       this._refreshing = true
-      process.nextTick(this._refreshNT, this)
+      queueMicrotask(this._refreshImpl)
     }
 
     _getEntry(key, Entry, opaque) {
@@ -569,7 +570,7 @@ export default function ({ ds, proxify, compiler }) {
       script = new vm.Script(`
       "use strict";
       {
-        const _ = (...args) => pipe(...args);
+        const _ = (value, ...args) => pipe(value, args);
         _.asset = (type, state, throws) => (id) => nxt._asset(id, type, state, throws);
         _.ds = (postfix, state, throws) => (id) => nxt._ds(id, postfix, state, throws);
         _.timer = (dueTime) => (dueValue) => nxt.timer(dueTime, dueValue);