cx 23.4.2 → 23.4.4

package/src/data/Expression.spec.js

@@ -1,164 +1,164 @@
-import { Expression } from "./Expression";
-import assert from "assert";
-
-describe("Expression", function () {
-   describe("#compile()", function () {
-      it("returns a selector", function () {
-         var e = Expression.compile("{person.name}");
-         var state = {
-            person: {
-               name: "Jim",
-            },
-         };
-         assert.equal(e(state), "Jim");
-      });
-
-      it("ignores bindings in strings", function () {
-         var e = Expression.compile('"{person.name}"');
-         var state = {
-            person: {
-               name: "Jim",
-            },
-         };
-         assert.equal(e(state), "{person.name}");
-      });
-
-      it("properly encodes quotes #1", function () {
-         var e = Expression.compile('"\'"');
-         var state = {};
-         assert.equal(e(state), "'");
-      });
-
-      it("properly encodes quotes #2", function () {
-         var e = Expression.compile('"\\""');
-         var state = {};
-         assert.equal(e(state), '"');
-      });
-   });
-
-   describe("allow subexpressions", function () {
-      it("in square brackets", function () {
-         var e = Expression.compile("{[{person.name}]}");
-         var state = {
-            person: {
-               name: "Jim",
-            },
-         };
-         assert.equal(e(state), "Jim");
-      });
-
-      it("in square brackets", function () {
-         var e = Expression.compile("{[{person.alias} || {person.name}]}");
-         var state = {
-            person: {
-               name: "Jim",
-               alias: "J",
-            },
-         };
-         assert.equal(e(state), "J");
-      });
-
-      it("prefixed with % sign", function () {
-         var e = Expression.compile("%{1+1}");
-         assert.equal(e(), "2");
-      });
-
-      it("can be formatted", function () {
-         var e = Expression.compile("{[1+1]:f;2}");
-         assert.equal(e(), "2.00");
-      });
-
-      it("n level deep", function () {
-         var e = Expression.compile("{[{[{[1+1]}]}]:f;2}");
-         assert.equal(e(), "2.00");
-      });
-
-      it("with complex math inside", function () {
-         var e = Expression.compile("%{{data}.reduce((a,b)=>a+b, 0):f;2}");
-         var state = {
-            data: [1, 2, 3],
-         };
-         assert.equal(e(state), "6.00");
-      });
-
-      it("with a conditional operator inside", function () {
-         var e = Expression.compile('{[true ? "T" : "F"]}');
-         assert.equal(e(), "T");
-      });
-   });
-
-   describe("are working", function () {
-      it("function expressions with get", function () {
-         var e = Expression.get((get) => get("a") + get("b"));
-         assert.equal(e({ a: 1, b: 2 }), 3);
-      });
-
-      it("are properly memoized", function () {
-         let inv = 0;
-         var 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 () {
-         var e = Expression.get((get) => get("name:prefix;Hello "));
-         assert(e({ name: "CxJS" }), "Hello CxJS");
-      });
-
-      // it('are properly memoized with proxies', function () {
-      //    let inv = 0;
-      //    var 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;
-      //    var 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);
-      // });
-   });
-});
+import { Expression } from "./Expression";
+import assert from "assert";
+
+describe("Expression", function () {
+   describe("#compile()", function () {
+      it("returns a selector", function () {
+         var e = Expression.compile("{person.name}");
+         var state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Jim");
+      });
+
+      it("ignores bindings in strings", function () {
+         var e = Expression.compile('"{person.name}"');
+         var state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "{person.name}");
+      });
+
+      it("properly encodes quotes #1", function () {
+         var e = Expression.compile('"\'"');
+         var state = {};
+         assert.equal(e(state), "'");
+      });
+
+      it("properly encodes quotes #2", function () {
+         var e = Expression.compile('"\\""');
+         var state = {};
+         assert.equal(e(state), '"');
+      });
+   });
+
+   describe("allow subexpressions", function () {
+      it("in square brackets", function () {
+         var e = Expression.compile("{[{person.name}]}");
+         var state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Jim");
+      });
+
+      it("in square brackets", function () {
+         var e = Expression.compile("{[{person.alias} || {person.name}]}");
+         var state = {
+            person: {
+               name: "Jim",
+               alias: "J",
+            },
+         };
+         assert.equal(e(state), "J");
+      });
+
+      it("prefixed with % sign", function () {
+         var e = Expression.compile("%{1+1}");
+         assert.equal(e(), "2");
+      });
+
+      it("can be formatted", function () {
+         var e = Expression.compile("{[1+1]:f;2}");
+         assert.equal(e(), "2.00");
+      });
+
+      it("n level deep", function () {
+         var e = Expression.compile("{[{[{[1+1]}]}]:f;2}");
+         assert.equal(e(), "2.00");
+      });
+
+      it("with complex math inside", function () {
+         var e = Expression.compile("%{{data}.reduce((a,b)=>a+b, 0):f;2}");
+         var state = {
+            data: [1, 2, 3],
+         };
+         assert.equal(e(state), "6.00");
+      });
+
+      it("with a conditional operator inside", function () {
+         var e = Expression.compile('{[true ? "T" : "F"]}');
+         assert.equal(e(), "T");
+      });
+   });
+
+   describe("are working", function () {
+      it("function expressions with get", function () {
+         var e = Expression.get((get) => get("a") + get("b"));
+         assert.equal(e({ a: 1, b: 2 }), 3);
+      });
+
+      it("are properly memoized", function () {
+         let inv = 0;
+         var 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 () {
+         var e = Expression.get((get) => get("name:prefix;Hello "));
+         assert(e({ name: "CxJS" }), "Hello CxJS");
+      });
+
+      // it('are properly memoized with proxies', function () {
+      //    let inv = 0;
+      //    var 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;
+      //    var 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/Grouper.d.ts

@@ -1,21 +1,21 @@
-import { StructuredProp, Record, StringProp } from '../core';
-
-interface GroupingResult {
-   key: Record,
-   name: string,
-   records: Record[],
-   indexes: number[],
-   aggregates: Record
-}
-
-export class Grouper {
-   constructor(key: StructuredProp, aggregates?: StructuredProp, dataGetter?: (any) => any, nameGetter?: StringProp);
-
-   reset();
-
-   process(record: Record, index: number): void;
-
-   processAll(records: Record[], indexes?: number[]): void;
-
-   getResults(): GroupingResult[]
-}
+import { StructuredProp, Record, StringProp } from '../core';
+
+interface GroupingResult {
+   key: Record,
+   name: string,
+   records: Record[],
+   indexes: number[],
+   aggregates: Record
+}
+
+export class Grouper {
+   constructor(key: StructuredProp, aggregates?: StructuredProp, dataGetter?: (any) => any, nameGetter?: StringProp);
+
+   reset();
+
+   process(record: Record, index: number): void;
+
+   processAll(records: Record[], indexes?: number[]): void;
+
+   getResults(): GroupingResult[]
+}

package/src/data/Grouper.js

@@ -1,120 +1,120 @@
-import {getSelector} from './getSelector';
-import {AggregateFunction} from './AggregateFunction';
-
-/*
- 'column': {
-   index: 0,
-   sort: 'asc',
-   group: true
-   aggregate: 'count'
- }
- */
-
-function transform(o, f) {
-   var res = {};
-   for (var k in o)
-      res[k] = f(o[k], k);
-   return res;
-}
-
-export class Grouper {
-   constructor(key, aggregates, dataGetter, nameGetter) {
-      this.keys = Object.keys(key).map(k => {
-         return {
-            name: k,
-            value: getSelector(key[k])
-         }
-      });
-      if (nameGetter)
-         this.nameGetter = getSelector(nameGetter);
-      this.dataGetter = dataGetter || (x=>x);
-      this.aggregates = aggregates && transform(aggregates, prop => {
-            if (!AggregateFunction[prop.type])
-               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) {
-      if (!leaf)
-         return {};
-
-      return {
-         records: [],
-         indexes: [],
-         aggregates: this.aggregates && transform(this.aggregates, prop => {
-            var f = AggregateFunction[prop.type];
-            return {
-               processor: f(),
-               value: prop.value,
-               weight: prop.weight
-            }
-         })
-      }
-   }
-
-   process(record, index) {
-      var data = this.dataGetter(record);
-      var key = this.keys.map(k=>k.value(data));
-      var g = this.groups;
-      for (var i = 0; i < key.length; i++) {
-         var 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 (var k in g.aggregates)
-            g.aggregates[k].processor.process(g.aggregates[k].value(data), g.aggregates[k].weight(data));
-      }
-   }
-
-   processAll(records, indexes) {
-      if (indexes) {
-         for (var i = 0; i < records.length; i++)
-            this.process(records[i], indexes[i]);
-      }
-      else
-         records.forEach((r, i)=>this.process(r, i));
-   }
-
-   report(g, path, level, results) {
-      if (level == this.keys.length) {
-         var key = {};
-         this.keys.forEach((k, i) => key[k.name] = path[i]);
-         results.push({
-            key: key,
-            name: g.name,
-            records: g.records,
-            indexes: g.indexes,
-            aggregates: transform(g.aggregates, p=>p.processor.getResult())
-         })
-      } else {
-         Object.keys(g).forEach(k=>this.report(g[k], [...path, k], level + 1, results));
-      }
-   }
-
-   getResults() {
-      var g = this.groups;
-      var results = [];
-      this.report(g, [], 0, results);
-      return results;
-   }
-}
+import {getSelector} from './getSelector';
+import {AggregateFunction} from './AggregateFunction';
+
+/*
+ 'column': {
+   index: 0,
+   sort: 'asc',
+   group: true
+   aggregate: 'count'
+ }
+ */
+
+function transform(o, f) {
+   var res = {};
+   for (var k in o)
+      res[k] = f(o[k], k);
+   return res;
+}
+
+export class Grouper {
+   constructor(key, aggregates, dataGetter, nameGetter) {
+      this.keys = Object.keys(key).map(k => {
+         return {
+            name: k,
+            value: getSelector(key[k])
+         }
+      });
+      if (nameGetter)
+         this.nameGetter = getSelector(nameGetter);
+      this.dataGetter = dataGetter || (x=>x);
+      this.aggregates = aggregates && transform(aggregates, prop => {
+            if (!AggregateFunction[prop.type])
+               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) {
+      if (!leaf)
+         return {};
+
+      return {
+         records: [],
+         indexes: [],
+         aggregates: this.aggregates && transform(this.aggregates, prop => {
+            var f = AggregateFunction[prop.type];
+            return {
+               processor: f(),
+               value: prop.value,
+               weight: prop.weight
+            }
+         })
+      }
+   }
+
+   process(record, index) {
+      var data = this.dataGetter(record);
+      var key = this.keys.map(k=>k.value(data));
+      var g = this.groups;
+      for (var i = 0; i < key.length; i++) {
+         var 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 (var k in g.aggregates)
+            g.aggregates[k].processor.process(g.aggregates[k].value(data), g.aggregates[k].weight(data));
+      }
+   }
+
+   processAll(records, indexes) {
+      if (indexes) {
+         for (var i = 0; i < records.length; i++)
+            this.process(records[i], indexes[i]);
+      }
+      else
+         records.forEach((r, i)=>this.process(r, i));
+   }
+
+   report(g, path, level, results) {
+      if (level == this.keys.length) {
+         var key = {};
+         this.keys.forEach((k, i) => key[k.name] = path[i]);
+         results.push({
+            key: key,
+            name: g.name,
+            records: g.records,
+            indexes: g.indexes,
+            aggregates: transform(g.aggregates, p=>p.processor.getResult())
+         })
+      } else {
+         Object.keys(g).forEach(k=>this.report(g[k], [...path, k], level + 1, results));
+      }
+   }
+
+   getResults() {
+      var g = this.groups;
+      var results = [];
+      this.report(g, [], 0, results);
+      return results;
+   }
+}

package/src/data/Grouper.spec.js

@@ -1,23 +1,23 @@
-var Grouper = require('./Grouper').Grouper;
-import assert from 'assert';
-
-describe('Grouper', function() {
-   describe('grouping', function () {
-      it('should work', function () {
-         var data = [{
-            key: 1,
-            value: 1
-         }, {
-            key: 2,
-            value: 2
-         }];
-
-         var grouper = new Grouper({ key: {bind:'key'}});
-         grouper.processAll(data);
-
-         var results = grouper.getResults();
-         //console.log(results);
-         assert.equal(results.length, 2);
-      });
-   });
+var Grouper = require('./Grouper').Grouper;
+import assert from 'assert';
+
+describe('Grouper', function() {
+   describe('grouping', function () {
+      it('should work', function () {
+         var data = [{
+            key: 1,
+            value: 1
+         }, {
+            key: 2,
+            value: 2
+         }];
+
+         var grouper = new Grouper({ key: {bind:'key'}});
+         grouper.processAll(data);
+
+         var results = grouper.getResults();
+         //console.log(results);
+         assert.equal(results.length, 2);
+      });
+   });
 });