@dra2020/baseclient 1.0.142 → 1.0.144

package/dist/filterexpr/filterexpr.d.ts

@@ -45,6 +45,7 @@ declare class Parser {
     initFromClauses(clauses: Clause[]): void;
     convertOpToText(): void;
     combineParenthetical(): void;
+    combineArithmetic(): void;
     combineUnary(): void;
     combineColon(): void;
     combineBinary(tt: TokType): void;

package/lib/detail/detail.ts

@@ -12,15 +12,19 @@
 //
 
 import * as Util from '../util/all';
+//import { Util } from '@dra2020/baseclient';
 
 const reIdentifier = /\b[a-zA-Z_$][a-zA-Z0-9_$]*\b/g;
-const reParam = /^__\d+$/
+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: number, format: string): string
 {
   if (!format) format = 'locale.0';
+  if (isNaN(n)) n = 0;
   let parts = format.split('.');
   let fmt = parts[0];
   let precision = Number(parts[1] || '0');
@@ -37,18 +41,20 @@ const DefaultDetailOptions: DetailOptions = { numberFormat: 'locale.0' };
 
 class Evaluator
 {
+  options: DetailOptions;
   expr: string;
   _error: boolean;
 
-  constructor(expr: string)
+  constructor(expr: string, options?: DetailOptions)
   {
+    this.options = Util.shallowAssignImmutable(DefaultDetailOptions, options);
     this.expr = expr;
     this._error = false;
   }
 
   get error(): boolean { return this._error }
 
-  eval(o: any): number
+  eval(o: any): any
   {
     this._error = false;
     try
@@ -65,17 +71,25 @@ 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: string, n2: string) => n2.length - n1.length);
-      names.forEach((n: string, i: number) => {
-          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,
+      safeexpr = safeexpr.replace(reIdentifierOrString,
                                   (match) => {
-                                      let valid = reParam.test(match);
+                                      let valid = reParam.test(match) || match === '__format' || reString.test(match);
                                       if (valid)
                                         return match;
                                       else
@@ -84,6 +98,9 @@ class Evaluator
                                         return 'invalid';
                                       }
                                     });
+      let __format = (n: number) => { 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
@@ -91,7 +108,7 @@ class Evaluator
 
       // 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)
     {
@@ -131,30 +148,8 @@ export class FormatDetail
     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
     {
@@ -191,17 +186,20 @@ export class FormatDetail
       this._error = true;
       return { n: 0, v: '' };
     }
-    let n: number;
+    let n: any = 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('') }

package/lib/filterexpr/filterexpr.ts

@@ -87,6 +87,26 @@ function tokIsUnary(tt: TokType): boolean
     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: TokType): boolean
+{
+  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;
@@ -276,6 +296,8 @@ class Parser
     this.clauses = clauses;
     this.combineParenthetical();
     this.convertOpToText();
+    this.combineArithmetic();
+    this.convertOpToText();
     this.combineBinary(TokType.Colon);
     this.convertOpToText();
     this.combineUnary();
@@ -363,6 +385,23 @@ class Parser
     }
   }
 
+  combineArithmetic(): void
+  {
+    // go backwards to handle not not
+    for (let i: number = 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(): void
   {
     // go backwards to handle not not

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dra2020/baseclient",
-  "version": "1.0.142",
+  "version": "1.0.144",
   "description": "Utility functions for Javascript projects.",
   "main": "dist/baseclient.js",
   "types": "./dist/all/all.d.ts",