@dra2020/baseclient 1.0.142 → 1.0.144

package/dist/baseclient.js

@@ -1244,12 +1244,17 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.FormatDetail = void 0;
 const Util = __importStar(__webpack_require__(/*! ../util/all */ "./lib/util/all.ts"));
+//import { Util } from '@dra2020/baseclient';
 const reIdentifier = /\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g;
+const reIdentifierOrString = /([a-zA-Z_$][a-zA-Z0-9_$]*)|(['"])(?:(?=(\\?))\3.)*?\2/g;
 const reParam = /^__\d+$/;
+const reString = /^['"]/;
 // Number format: (locale|general|integer|currency).precision
 function formatNumber(n, format) {
     if (!format)
         format = 'locale.0';
+    if (isNaN(n))
+        n = 0;
     let parts = format.split('.');
     let fmt = parts[0];
     let precision = Number(parts[1] || '0');
@@ -1258,7 +1263,8 @@ function formatNumber(n, format) {
 }
 const DefaultDetailOptions = { numberFormat: 'locale.0' };
 class Evaluator {
-    constructor(expr) {
+    constructor(expr, options) {
+        this.options = Util.shallowAssignImmutable(DefaultDetailOptions, options);
         this.expr = expr;
         this._error = false;
     }
@@ -1277,15 +1283,20 @@ class Evaluator {
             let values = Object.values(o);
             let safeexpr = this.expr;
             let safenames = names.map(n => namemap[n]);
-            // replace longest field names first in case they contain substrings of short field names
-            names.sort((n1, n2) => n2.length - n1.length);
-            names.forEach((n, i) => {
-                while (safeexpr.indexOf(n) >= 0)
-                    safeexpr = safeexpr.replace(n, namemap[n]);
+            // Replace valid identifiers with safe version
+            safeexpr = safeexpr.replace(reIdentifierOrString, (match) => {
+                if (namemap[match])
+                    return namemap[match];
+                else if (match === '__format' || reString.test(match))
+                    return match;
+                else {
+                    this._error = true;
+                    return 'invalid';
+                }
             });
             // Remove any identifiers that aren't the simple parameters to prevent out-of-sandbox execution
-            safeexpr = safeexpr.replace(reIdentifier, (match) => {
-                let valid = reParam.test(match);
+            safeexpr = safeexpr.replace(reIdentifierOrString, (match) => {
+                let valid = reParam.test(match) || match === '__format' || reString.test(match);
                 if (valid)
                     return match;
                 else {
@@ -1293,12 +1304,15 @@ class Evaluator {
                     return 'invalid';
                 }
             });
+            let __format = (n) => { return formatNumber(n, this.options.numberFormat); };
+            safenames.push('__format');
+            values.push(__format);
             // Create a new function that accepts the variables as parameters
             // and evaluates the expression
             const func = new Function(...safenames, `return ${safeexpr};`);
             // Call the function with the variable values
             let r = func(...values);
-            return isNaN(r) ? 0 : r;
+            return typeof r === 'string' ? r : ((typeof r !== 'number' || isNaN(r)) ? 0 : r);
         }
         catch (err) {
             this._error = true;
@@ -1315,28 +1329,8 @@ class FormatDetail {
         this.pattern = pattern.trim();
         let a = reExpr.exec(pattern);
         if (a && a.length == 2) {
-            this.items = [];
             const expr = a[1];
-            const parse = expr.split('"');
-            let state = 'expr';
-            parse.forEach(subexpr => {
-                if (state === 'expr') {
-                    if (subexpr.length) {
-                        // Don't allow unsafe actions
-                        if (reInvalidChars.test(subexpr))
-                            this.items.push({ text: subexpr });
-                        else
-                            this.items.push({ expr: subexpr });
-                    }
-                    state = 'text';
-                }
-                else // state === 'text'
-                 {
-                    if (subexpr.length)
-                        this.items.push({ text: subexpr });
-                    state = 'expr';
-                }
-            });
+            this.items = [{ expr }];
         }
         else {
             this._error = true;
@@ -1364,16 +1358,19 @@ class FormatDetail {
             this._error = true;
             return { n: 0, v: '' };
         }
-        let n;
+        let n = 0;
         let av = this.items.map(di => {
             if (di.text)
                 return di.text;
             else {
-                let e = new Evaluator(di.expr);
+                let e = new Evaluator(di.expr, this.options);
                 n = e.eval(o);
                 if (!this._error)
                     this._error = e.error;
-                return formatNumber(n, this.options.numberFormat);
+                if (typeof n === 'string')
+                    return n;
+                else
+                    return formatNumber(n, this.options.numberFormat);
             }
         });
         return { n, v: av.join('') };
@@ -1577,6 +1574,23 @@ function tokIsUnary(tt) {
         case TokType.And: return false;
         case TokType.Or: return false;
         case TokType.Colon: return false;
+        case TokType.GreaterThan: return false;
+        case TokType.GreaterThanEqual: return false;
+        case TokType.Equal: return false;
+        case TokType.LessThan: return false;
+        case TokType.LessThanEqual: return false;
+        case TokType.NotEqual: return false;
+    }
+}
+function tokIsArithmetic(tt) {
+    switch (tt) {
+        case TokType.Text: return false;
+        case TokType.OpenParen: return false;
+        case TokType.CloseParen: return false;
+        case TokType.Not: return false;
+        case TokType.And: return false;
+        case TokType.Or: return false;
+        case TokType.Colon: return false;
         // Nominally binary, but written as "prop: < 3" so appears as unary operator where test is comparative to prop value
         case TokType.GreaterThan: return true;
         case TokType.GreaterThanEqual: return true;
@@ -1709,6 +1723,8 @@ class Parser {
         this.clauses = clauses;
         this.combineParenthetical();
         this.convertOpToText();
+        this.combineArithmetic();
+        this.convertOpToText();
         this.combineBinary(TokType.Colon);
         this.convertOpToText();
         this.combineUnary();
@@ -1785,6 +1801,19 @@ class Parser {
             }
         }
     }
+    combineArithmetic() {
+        // go backwards to handle not not
+        for (let i = this.clauses.length - 1; i >= 0; i--) {
+            let c = this.clauses[i];
+            if (tokIsArithmetic(c.op.tt)) {
+                let argclause = (i < this.clauses.length - 1) ? { op: c.op, operand1: this.clauses[i + 1] } : undefined;
+                if (argclause)
+                    this.clauses.splice(i, 2, argclause);
+                else
+                    this.clauses.splice(i, 1);
+            }
+        }
+    }
     combineUnary() {
         // go backwards to handle not not
         for (let i = this.clauses.length - 1; i >= 0; i--) {