cx 25.10.1 → 26.0.1

package/src/data/Expression.spec.ts

@@ -0,0 +1,229 @@
+import { Expression } from "./Expression";
+import assert from "assert";
+import { StringTemplate } from "./StringTemplate";
+
+describe("Expression", function () {
+   describe("#compile()", function () {
+      it("returns a selector", function () {
+         let e = Expression.compile("{person.name}");
+         let state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Jim");
+      });
+
+      it("ignores bindings in strings", function () {
+         let e = Expression.compile('"{person.name}"');
+         let state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "{person.name}");
+      });
+
+      it("allows mixed curly braces in strings", () => {
+         let e = Expression.compile('"Hello {" + "person.name}"');
+         assert.equal(e({}), "Hello {person.name}");
+      });
+
+      it("properly encodes quotes #1", function () {
+         let e = Expression.compile('"\'"');
+         let state = {};
+         assert.equal(e(state), "'");
+      });
+
+      it("properly encodes quotes #2", function () {
+         let e = Expression.compile('"\\""');
+         let state = {};
+         assert.equal(e(state), '"');
+      });
+
+      it("properly encodes quotes #3", function () {
+         let e = Expression.compile('"\\\\\\""');
+         let state = {};
+         assert.equal(e(state), '\\"');
+      });
+
+      it("properly encodes quotes #4", function () {
+         let e = Expression.compile('"\\\\"');
+         let state = {};
+         assert.equal(e(state), "\\");
+      });
+   });
+
+   describe("allow subexpressions", function () {
+      it("in square brackets", function () {
+         let e = Expression.compile("{[{person.name}]}");
+         let state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Jim");
+      });
+
+      it("in square brackets", function () {
+         let e = Expression.compile("{[{person.alias} || {person.name}]}");
+         let state = {
+            person: {
+               name: "Jim",
+               alias: "J",
+            },
+         };
+         assert.equal(e(state), "J");
+      });
+
+      it("prefixed with % sign", function () {
+         let e = Expression.compile("%{1+1}");
+         assert.equal(e({}), "2");
+      });
+
+      it("can be formatted", function () {
+         let e = Expression.compile("{[1+1]:f;2}");
+         assert.equal(e({}), "2.00");
+      });
+
+      it("n level deep", function () {
+         let e = Expression.compile("{[{[{[1+1]}]}]:f;2}");
+         assert.equal(e({}), "2.00");
+      });
+
+      it("with complex math inside", function () {
+         let e = Expression.compile("%{{data}.reduce((a,b)=>a+b, 0):f;2}");
+         let state = {
+            data: [1, 2, 3],
+         };
+         assert.equal(e(state), "6.00");
+      });
+
+      it("with a conditional operator inside", function () {
+         let e = Expression.compile('{[true ? "T" : "F"]}');
+         assert.equal(e({}), "T");
+      });
+
+      it("with string interpolation inside", function () {
+         let e = Expression.compile("{[`${{test}}`]}");
+         assert.equal(e({ test: "T" }), "T");
+      });
+   });
+
+   describe("are working", function () {
+      it("function expressions with get", function () {
+         let e = Expression.get((get) => get("a") + get("b"));
+         assert.equal(e({ a: 1, b: 2 }), 3);
+      });
+
+      it("are properly memoized", function () {
+         let inv = 0;
+         let e = Expression.get((get) => {
+            inv++;
+            return get("a") + get("b");
+         }).memoize();
+
+         assert.equal(e({ a: 1, b: 1 }), 2);
+         assert.equal(inv, 1);
+
+         assert.equal(e({ a: 1, b: 1 }), 2);
+         assert.equal(inv, 1);
+
+         assert.equal(e({ a: 1, b: 2 }), 3);
+         assert.equal(inv, 2);
+
+         assert.equal(e({ a: 1, b: 2 }), 3);
+         assert.equal(inv, 2);
+
+         assert.equal(e({ a: 2, b: 2 }), 4);
+         assert.equal(inv, 3);
+      });
+
+      it("formatting can be used inside bindings", function () {
+         let e = Expression.get((get) => get("name:prefix;Hello "));
+         assert(e({ name: "CxJS" }), "Hello CxJS");
+      });
+
+      it("allows using the fmt function inside", function () {
+         let e = Expression.compile('{[fmt({text}, "prefix;Hello ")]}');
+         assert.equal(e({ text: "CxJS" }), "Hello CxJS");
+      });
+
+      it("allows using dashes inside names", function () {
+         let e = Expression.compile("{framework-name}");
+         assert.equal(e({ "framework-name": "CxJS" }), "CxJS");
+      });
+
+      it("allows using spaces and other characters inside names", function () {
+         let e = Expression.compile("{1nv@lid js ident1fier}");
+         assert.equal(e({ "1nv@lid js ident1fier": "CxJS" }), "CxJS");
+      });
+
+      it("allows strings in subexpressions", () => {
+         let e = Expression.compile("{['1']}");
+         assert.equal(e({}), "1");
+
+         let e2 = Expression.compile('%{"1"}');
+         assert.equal(e({}), "1");
+      });
+
+      it("allows string templates in nested expressions", () => {
+         Expression.registerHelper("tpl", StringTemplate.format);
+         let e = Expression.compile("tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})");
+         assert.equal(e({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
+
+         let e2 = Expression.compile("{[tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})]}");
+         assert.equal(e2({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
+
+         // we're going to need a better parser for this
+         // let e3 = Expression.compile("%{tpl('{0:n;2} {1:p;2:wrap;(;)}', {value}, {percentage})}");
+         // assert.equal(e3({ value: 1, percentage: 0.02 }), "1.00 (2.00%)");
+      });
+
+      it("string templates can be in the data", () => {
+         Expression.registerHelper("tpl", StringTemplate.format);
+         let e = Expression.compile("tpl({template}, {value}, {percentage})");
+         assert.equal(e({ value: 1, percentage: 0.02, template: "{0:n;2} {1:p;2:wrap;(;)}" }), "1.00 (2.00%)");
+      });
+
+      // it('are properly memoized with proxies', function () {
+      //    let inv = 0;
+      //    let e = Expression.get(d => { inv++; return d.a + d.b}).memoize();
+      //
+      //    assert.equal(e({ a: 1, b: 1 }), 2);
+      //    assert.equal(inv, 1);
+      //
+      //    assert.equal(e({ a: 1, b: 1 }), 2);
+      //    assert.equal(inv, 1);
+      //
+      //    assert.equal(e({ a: 1, b: 2 }), 3);
+      //    assert.equal(inv, 2);
+      //
+      //    assert.equal(e({ a: 1, b: 2 }), 3);
+      //    assert.equal(inv, 2);
+      //
+      //    assert.equal(e({ a: 2, b: 2 }), 4);
+      //    assert.equal(inv, 3);
+      // });
+      //
+      // it('are properly memoized with proxies and deep data', function () {
+      //    let inv = 0;
+      //    let e = Expression.get(d => { inv++; return d.v.a + d.v.b}).memoize();
+      //
+      //    assert.equal(e({ v: { a: 1, b: 1 }}), 2);
+      //    assert.equal(inv, 1);
+      //
+      //    assert.equal(e({ v: { a: 1, b: 1 }}), 2);
+      //    assert.equal(inv, 1);
+      //
+      //    assert.equal(e({ v: { a: 1, b: 2 }}), 3);
+      //    assert.equal(inv, 2);
+      //
+      //    assert.equal(e({ v: { a: 1, b: 2 }}), 3);
+      //    assert.equal(inv, 2);
+      //
+      //    assert.equal(e({ v: { a: 2, b: 2 }}), 4);
+      //    assert.equal(inv, 3);
+      // });
+   });
+});

package/src/data/Expression.ts

@@ -0,0 +1,233 @@
+import { computable } from "./computable";
+import { Format } from "../util/Format";
+import { Binding } from "./Binding";
+
+import { quoteStr } from "../util/quote";
+import { isFunction } from "../util/isFunction";
+import { isValidIdentifierName } from "../util/isValidIdentifierName";
+import { MemoSelector, Selector } from "./Selector";
+
+/*
+   Helper usage example
+
+   Expression.registerHelper('_', _);
+   let e = Expression.compile('_.min({data})');
+ */
+
+let helpers: Record<string, any> = {},
+   helperNames: string[] = [],
+   helperValues: any[] = [],
+   expFatArrows: null | ((body: string) => string) = null;
+
+function getExpr(expr: Selector): MemoSelector {
+   if (expr.memoize) return expr as MemoSelector;
+
+   function memoize(): Selector {
+      let lastValue: any,
+         lastRunBindings: Record<string, Selector> = {},
+         lastRunResults: Record<string, any> = {},
+         getters: Record<string, Selector> = {},
+         currentData: any,
+         len = -1;
+
+      let get = function (bindingWithFormat: string) {
+         let getter = getters[bindingWithFormat];
+         if (!getter) {
+            let binding = bindingWithFormat,
+               format;
+            let colonIndex = bindingWithFormat.indexOf(":");
+            if (colonIndex != -1) {
+               format = Format.parse(bindingWithFormat.substring(colonIndex + 1));
+               binding = bindingWithFormat.substring(0, colonIndex);
+            } else {
+               let nullSeparatorIndex = bindingWithFormat.indexOf(":");
+               if (nullSeparatorIndex != -1) {
+                  format = Format.parse(bindingWithFormat.substring(nullSeparatorIndex));
+                  binding = bindingWithFormat.substring(0, nullSeparatorIndex - 1);
+               }
+            }
+            let b = Binding.get(binding);
+            getter = (data) => {
+               let value = b.value(data);
+               lastRunBindings[len] = b.value;
+               lastRunResults[len] = value;
+               len++;
+               return value;
+            };
+
+            if (format) {
+               let valueGetter = getter;
+               getter = (data) => format(valueGetter(data));
+            }
+
+            getters[bindingWithFormat] = getter;
+         }
+         return getter(currentData);
+      };
+
+      return function (data) {
+         let i = 0;
+         for (; i < len; i++) if (lastRunBindings[i](data) !== lastRunResults[i]) break;
+         if (i !== len) {
+            len = 0;
+            currentData = data;
+            lastValue = expr(get);
+         }
+         return lastValue;
+      };
+   }
+
+   let result: Selector = memoize();
+   result.memoize = memoize;
+   return result as MemoSelector;
+}
+
+export function expression(str: string | Selector): MemoSelector {
+   if (isFunction(str)) return getExpr(str);
+
+   let cache = getExpressionCache();
+   let r = cache[str];
+   if (r) return r;
+
+   let quote: string | false = false;
+
+   let termStart = -1,
+      curlyBrackets = 0,
+      percentExpression;
+
+   let fb = ["return ("];
+
+   let args: Record<string, string | Selector> = {};
+   let formats = [];
+   let subExprCount = 0;
+   let invalidNameCount = 0;
+
+   for (let i = 0; i < str.length; i++) {
+      let c = str[i];
+      switch (c) {
+         case "{":
+            if (curlyBrackets > 0 && !quote) curlyBrackets++;
+            else if (!quote && termStart < 0 && (str[i + 1] != "{" || str[i - 1] == "%")) {
+               termStart = i + 1;
+               curlyBrackets = 1;
+               percentExpression = str[i - 1] == "%";
+               if (percentExpression) fb.pop(); //%
+            } else if (termStart < 0 && (quote || str[i - 1] != "{")) fb.push(c);
+            break;
+
+         case "}":
+            if (termStart >= 0) {
+               if (quote) continue;
+               if (--curlyBrackets == 0) {
+                  let term = str.substring(termStart, i);
+                  let formatStart = 0;
+                  if (term[0] == "[") formatStart = term.indexOf("]");
+                  let colon = term.indexOf(":", formatStart > 0 ? formatStart : 0);
+                  let binding = colon == -1 ? term : term.substring(0, colon);
+                  let format = colon == -1 ? null : term.substring(colon + 1);
+                  if (colon == -1) {
+                     let nullSepIndex = binding.indexOf("|", formatStart);
+                     if (nullSepIndex != -1) {
+                        format = binding.substring(nullSepIndex);
+                        binding = binding.substring(0, nullSepIndex);
+                     }
+                  }
+                  let argName = binding.replace(/\./g, "_");
+                  if (!isValidIdentifierName(argName)) argName = "inv" + ++invalidNameCount;
+                  if (percentExpression || (binding[0] == "[" && binding[binding.length - 1] == "]")) {
+                     argName = `expr${++subExprCount}`;
+                     args[argName] = expression(percentExpression ? binding : binding.substring(1, binding.length - 1));
+                  } else args[argName] = binding;
+                  if (format) {
+                     let formatter = "fmt" + formats.length;
+                     fb.push(formatter, "(", argName, ", ", quoteStr(format), ")");
+                     formats.push(Format.parse(format));
+                  } else fb.push(argName);
+                  termStart = -1;
+               }
+            } else fb.push(c);
+
+            break;
+
+         case '"':
+         case "'":
+            if (!quote) quote = c;
+            else if (quote == c) {
+               let at = i - 1;
+               let slashCount = 0;
+               while (at >= 0 && str[at] === "\\") {
+                  slashCount++;
+                  at--;
+               }
+               if (slashCount % 2 == 0) quote = false;
+            }
+
+            if (curlyBrackets == 0) fb.push(c);
+
+            break;
+
+         default:
+            if (termStart < 0) fb.push(c);
+            break;
+      }
+   }
+
+   fb.push(")");
+
+   let body = fb.join("");
+
+   if (expFatArrows) body = expFatArrows(body);
+
+   //console.log(body);
+   let keys = Object.keys(args);
+
+   try {
+      let compute = new Function("fmt", ...formats.map((f, i) => "fmt" + i), ...helperNames, ...keys, body).bind(
+         Format,
+         Format.value,
+         ...formats,
+         ...helperValues,
+      );
+
+      let selector = computable(...keys.map((k) => args[k]), compute);
+      cache[str] = selector;
+      return selector;
+   } catch (err) {
+      throw new Error(`Failed to parse expression: '${str}'. ${err}`);
+   }
+}
+
+export type GetFunction = (bindingPath: string) => any;
+export type SelectorFunction = (get: GetFunction) => any;
+
+export const Expression = {
+   get: function (str: string | SelectorFunction): MemoSelector {
+      return expression(str);
+   },
+
+   compile: function (str: string | SelectorFunction): Selector {
+      return this.get(str).memoize();
+   },
+
+   registerHelper: function (name: string, helper: any) {
+      helpers[name] = helper;
+      helperNames = Object.keys(helpers);
+      helperValues = helperNames.map((n) => helpers[n]);
+   },
+};
+
+export function plugFatArrowExpansion(impl: (body: string) => string) {
+   expFatArrows = impl;
+}
+
+export function invalidateExpressionCache() {
+   expCache = {};
+}
+
+let expCache: Record<string, MemoSelector> = {};
+
+let getExpressionCache = () => expCache;
+
+export function setGetExpressionCacheCallback(callback: () => Record<string, MemoSelector>) {
+   getExpressionCache = callback;
+}

package/src/data/Grouper.spec.ts

@@ -0,0 +1,57 @@
+import { Grouper } from "./Grouper";
+import assert from "assert";
+
+describe("Grouper", function () {
+   describe("single grouping", function () {
+      it("should work", function () {
+         let data = [
+            { name: "John", age: 12 },
+            { name: "Jane", age: 12 },
+         ];
+
+         let grouper = new Grouper({ name: { bind: "name" } });
+         grouper.processAll(data);
+
+         let results = grouper.getResults();
+         // console.log(results);
+         assert.equal(results.length, 2);
+      });
+
+      it("keys can have nested properties", function () {
+         let data = [
+            { name: "John", age: 12 },
+            { name: "Jane", age: 12 },
+         ];
+
+         let grouper = new Grouper({ "person.name": { bind: "name" } });
+         grouper.processAll(data);
+
+         let results = grouper.getResults();
+         assert.equal(results.length, 2);
+         assert.equal(results[0].key.person?.name, "John");
+         assert.equal(results[1].key.person?.name, "Jane");
+      });
+   });
+
+   describe("multi grouping", function () {
+      it("should work", function () {
+         let data = [
+            { name: "John", age: 12 },
+            { name: "John", age: 12 },
+            { name: "John", age: 13 },
+            { name: "John", age: 14 },
+            { name: "Jane", age: 12 },
+            { name: "Jane", age: 13 },
+            { name: "Jane", age: 14 },
+         ];
+
+         let grouper = new Grouper({ name: { bind: "name" }, age: { bind: "age" } });
+         grouper.processAll(data);
+
+         let results = grouper.getResults();
+         // console.log(results);
+         assert.equal(results.length, 6);
+         assert.equal(results[0].records.length, 2);
+      });
+   });
+});

package/src/data/Grouper.ts

@@ -0,0 +1,158 @@
+import { getSelector } from "./getSelector";
+import { AggregateFunction } from "./AggregateFunction";
+import { Binding } from "./Binding";
+
+/*
+ 'column': {
+   index: 0,
+   sort: 'asc',
+   group: true
+   aggregate: 'count'
+ }
+ */
+
+export interface GroupResult {
+   key: any;
+   name?: any;
+   records: any[];
+   indexes: number[];
+   aggregates?: Record<string, any>;
+}
+
+export class Grouper {
+   keys: any[];
+   nameGetter?: any;
+   dataGetter: any;
+   aggregates?: any;
+   groups: any;
+
+   constructor(key: any, aggregates?: any, dataGetter?: any, nameGetter?: any) {
+      this.keys = Object.keys(key).map((keyField) => {
+         let isSimpleField = keyField.indexOf(".") === -1;
+         let keySetter;
+         if (isSimpleField) {
+            // use simple field setter wherever possible
+            keySetter = function set(result: any, value: any) {
+               result[keyField] = value;
+               return result;
+            };
+         } else {
+            // for complex paths, use deep setter
+            let binding = Binding.get(keyField);
+            keySetter = (result: any, value: any) => binding.set(result, value);
+         }
+         return {
+            name: keyField,
+            keySetter,
+            value: getSelector(key[keyField]),
+         };
+      });
+      if (nameGetter) this.nameGetter = getSelector(nameGetter);
+      this.dataGetter = dataGetter || ((x: any) => x);
+      this.aggregates =
+         aggregates &&
+         transformValues(aggregates, (prop) => {
+            if (!(prop.type in AggregateFunction)) throw new Error(`Unknown aggregate function '${prop.type}'.`);
+
+            return {
+               value: getSelector(prop.value),
+               weight: getSelector(prop.weight ?? 1),
+               type: prop.type,
+            };
+         });
+      this.reset();
+   }
+
+   reset() {
+      this.groups = this.initGroup(this.keys.length == 0);
+   }
+
+   initGroup(leaf: boolean) {
+      if (!leaf) return {};
+
+      return {
+         records: [],
+         indexes: [],
+         aggregates:
+            this.aggregates &&
+            transformValues(this.aggregates, (prop) => {
+               let f = (AggregateFunction as any)[prop.type];
+               return {
+                  processor: f(),
+                  value: prop.value,
+                  weight: prop.weight,
+               };
+            }),
+      };
+   }
+
+   process(record: any, index: number) {
+      let data = this.dataGetter(record);
+      let key = this.keys.map((k) => k.value(data));
+      let g = this.groups;
+      for (let i = 0; i < key.length; i++) {
+         let sg = g[key[i]];
+         if (!sg) {
+            sg = g[key[i]] = this.initGroup(i + 1 == key.length);
+            if (this.nameGetter) sg.name = this.nameGetter(data);
+         }
+         g = sg;
+      }
+
+      g.records.push(record);
+      g.indexes.push(index);
+
+      if (g.aggregates) {
+         for (let k in g.aggregates)
+            g.aggregates[k].processor.process(g.aggregates[k].value(data), g.aggregates[k].weight(data));
+      }
+   }
+
+   processAll(records: any[], indexes?: number[]) {
+      if (indexes) {
+         for (let i = 0; i < records.length; i++) this.process(records[i], indexes[i]);
+      } else records.forEach((r: any, i: number) => this.process(r, i));
+   }
+
+   report(g: any, path: any[], level: number, results: GroupResult[]) {
+      if (level == this.keys.length) {
+         let key = {};
+         this.keys.forEach((k: any, i: number) => {
+            key = k.keySetter(key, path[i]);
+         });
+         results.push({
+            key: key,
+            name: g.name,
+            records: g.records,
+            indexes: g.indexes,
+            aggregates: resolveKeyPaths(transformValues(g.aggregates, (p) => p.processor.getResult())),
+         });
+      } else {
+         Object.keys(g).forEach((k) => this.report(g[k], [...path, k], level + 1, results));
+      }
+   }
+
+   getResults(): GroupResult[] {
+      let g = this.groups;
+      let results: GroupResult[] = [];
+      this.report(g, [], 0, results);
+      return results;
+   }
+}
+
+// transform object values using a function
+function transformValues(o: Record<string, any>, f: (v: any, k?: string) => any): Record<string, any> {
+   let res: Record<string, any> = {};
+   for (let k in o) res[k] = f(o[k], k);
+   return res;
+}
+
+// transform keys like 'a.b.c' into nested objects
+function resolveKeyPaths(o: Record<string, any>) {
+   let res: Record<string, any> = {};
+   for (let k in o) {
+      if (k.indexOf(".") > 0) res = Binding.get(k).set(res, o[k]);
+      else res[k] = o[k];
+   }
+   return res;
+}