cx 24.3.7 → 24.3.9

package/src/data/Grouper.js

@@ -1,120 +1,144 @@
-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";
+import { Binding } from "./Binding";
+
+/*
+ 'column': {
+   index: 0,
+   sort: 'asc',
+   group: true
+   aggregate: 'count'
+ }
+ */
+
+export class Grouper {
+   constructor(key, aggregates, dataGetter, nameGetter) {
+      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, value) {
+               result[keyField] = value;
+               return result;
+            };
+         } else {
+            // for complex paths, use deep setter
+            let binding = Binding.get(keyField);
+            keySetter = (result, value) => binding.set(result, value);
+         }
+         return {
+            name: keyField,
+            keySetter,
+            value: getSelector(key[keyField]),
+         };
+      });
+      if (nameGetter) this.nameGetter = getSelector(nameGetter);
+      this.dataGetter = dataGetter || ((x) => x);
+      this.aggregates =
+         aggregates &&
+         transformValues(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 &&
+            transformValues(this.aggregates, (prop) => {
+               let f = AggregateFunction[prop.type];
+               return {
+                  processor: f(),
+                  value: prop.value,
+                  weight: prop.weight,
+               };
+            }),
+      };
+   }
+
+   process(record, index) {
+      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, indexes) {
+      if (indexes) {
+         for (let 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) {
+         let key = {};
+         this.keys.forEach((k, i) => {
+            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() {
+      let g = this.groups;
+      let results = [];
+      this.report(g, [], 0, results);
+      return results;
+   }
+}
+
+// transform object values using a function
+function transformValues(o, f) {
+   let res = {};
+   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) {
+   let res = {};
+   for (let k in o) {
+      if (k.indexOf(".") > 0) res = Binding.get(k).set(res, o[k]);
+      else res[k] = o[k];
+   }
+   return res;
+}

package/src/data/Grouper.spec.js

@@ -1,42 +1,57 @@
-var Grouper = require("./Grouper").Grouper;
-import assert from "assert";
-
-describe("Grouper", function () {
-   describe("single grouping", function () {
-      it("should work", function () {
-         var data = [
-            { name: "John", age: 12 },
-            { name: "Jane", age: 12 },
-         ];
-
-         var grouper = new Grouper({ name: { bind: "name" } });
-         grouper.processAll(data);
-
-         var results = grouper.getResults();
-         // console.log(results);
-         assert.equal(results.length, 2);
-      });
-   });
-
-   describe("multi grouping", function () {
-      it("should work", function () {
-         var 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 },
-         ];
-
-         var grouper = new Grouper({ name: { bind: "name" }, age: { bind: "age" } });
-         grouper.processAll(data);
-
-         var results = grouper.getResults();
-         // console.log(results);
-         assert.equal(results.length, 6);
-         assert.equal(results[0].records.length, 2);
-      });
-   });
-});
+let Grouper = require("./Grouper").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/StringTemplate.d.ts

@@ -1,14 +1,15 @@
-import {Selector} from '../core';
-
-export function stringTemplate(str: string): Selector<string>;
-
-export class StringTemplate {
-
-   static get(str: string): Selector<string>;
-
-   static compile(str: string): Selector<string>;
-
-   static format(format: string, ...args): string;
-}
-
-export function invalidateStringTemplateCache();
+import { Selector } from "../core";
+
+export function stringTemplate(str: string): Selector<string>;
+
+export class StringTemplate {
+   static get(str: string): Selector<string>;
+
+   static compile(str: string): Selector<string>;
+
+   static format(format: string, ...args): string;
+}
+
+export function invalidateStringTemplateCache(): void;
+
+export function setGetStringTemplateCacheCallback(callback: () => {}): void;

package/src/data/StringTemplate.js

@@ -1,85 +1,92 @@
-import { expression } from "./Expression";
-
-import { quoteStr } from "../util/quote";
-
-function plus(str) {
-   return str.length ? str + " + " : str;
-}
-
-let tplCache = {};
-
-export function stringTemplate(str) {
-   let expr = tplCache[str];
-   if (expr) return expr;
-
-   expr = "";
-
-   let termStart = -1,
-      quoteStart = 0,
-      term,
-      bracketsOpen = 0,
-      percentSign;
-
-   for (let i = 0; i < str.length; i++) {
-      let c = str[i];
-      switch (c) {
-         case "{":
-            if (termStart < 0) {
-               if (str[i + 1] == "{" && str[i - 1] != "%") {
-                  expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "{");
-                  i++;
-                  quoteStart = i + 1;
-               } else {
-                  termStart = i + 1;
-                  percentSign = str[i - 1] == "%";
-                  if (i > quoteStart) expr = plus(expr) + quoteStr(str.substring(quoteStart, percentSign ? i - 1 : i));
-                  bracketsOpen = 1;
-               }
-            } else bracketsOpen++;
-            break;
-
-         case "}":
-            if (termStart >= 0) {
-               if (--bracketsOpen == 0) {
-                  term = str.substring(termStart, i);
-                  if (term.indexOf(":") == -1) {
-                     let nullSepIndex = term.indexOf("|");
-                     if (nullSepIndex == -1) term += ":s";
-                     else term = term.substring(0, nullSepIndex) + ":s" + term.substring(nullSepIndex);
-                  }
-                  expr = plus(expr) + (percentSign ? "%{" : "{") + term + "}";
-                  termStart = -1;
-                  quoteStart = i + 1;
-                  bracketsOpen = 0;
-               }
-            } else if (str[i + 1] == "}") {
-               expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "}");
-               i++;
-               quoteStart = i + 1;
-            }
-            break;
-      }
-   }
-
-   if (quoteStart < str.length) expr = plus(expr) + quoteStr(str.substring(quoteStart));
-
-   return (tplCache[str] = expression(expr));
-}
-
-export const StringTemplate = {
-   get: function (str) {
-      return stringTemplate(str);
-   },
-
-   compile: function (str) {
-      return stringTemplate(str).memoize();
-   },
-
-   format: function (format, ...args) {
-      return stringTemplate(format)(args);
-   },
-};
-
-export function invalidateStringTemplateCache() {
-   tplCache = {};
-}
+import { expression } from "./Expression";
+
+import { quoteStr } from "../util/quote";
+
+function plus(str) {
+   return str.length ? str + " + " : str;
+}
+
+export function stringTemplate(str) {
+   let tplCache = getTplCache();
+   let expr = tplCache[str];
+   if (expr) return expr;
+
+   expr = "";
+
+   let termStart = -1,
+      quoteStart = 0,
+      term,
+      bracketsOpen = 0,
+      percentSign;
+
+   for (let i = 0; i < str.length; i++) {
+      let c = str[i];
+      switch (c) {
+         case "{":
+            if (termStart < 0) {
+               if (str[i + 1] == "{" && str[i - 1] != "%") {
+                  expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "{");
+                  i++;
+                  quoteStart = i + 1;
+               } else {
+                  termStart = i + 1;
+                  percentSign = str[i - 1] == "%";
+                  if (i > quoteStart) expr = plus(expr) + quoteStr(str.substring(quoteStart, percentSign ? i - 1 : i));
+                  bracketsOpen = 1;
+               }
+            } else bracketsOpen++;
+            break;
+
+         case "}":
+            if (termStart >= 0) {
+               if (--bracketsOpen == 0) {
+                  term = str.substring(termStart, i);
+                  if (term.indexOf(":") == -1) {
+                     let nullSepIndex = term.indexOf("|");
+                     if (nullSepIndex == -1) term += ":s";
+                     else term = term.substring(0, nullSepIndex) + ":s" + term.substring(nullSepIndex);
+                  }
+                  expr = plus(expr) + (percentSign ? "%{" : "{") + term + "}";
+                  termStart = -1;
+                  quoteStart = i + 1;
+                  bracketsOpen = 0;
+               }
+            } else if (str[i + 1] == "}") {
+               expr = plus(expr) + quoteStr(str.substring(quoteStart, i) + "}");
+               i++;
+               quoteStart = i + 1;
+            }
+            break;
+      }
+   }
+
+   if (quoteStart < str.length) expr = plus(expr) + quoteStr(str.substring(quoteStart));
+
+   return (tplCache[str] = expression(expr));
+}
+
+export const StringTemplate = {
+   get: function (str) {
+      return stringTemplate(str);
+   },
+
+   compile: function (str) {
+      return stringTemplate(str).memoize();
+   },
+
+   format: function (format, ...args) {
+      return stringTemplate(format)(args);
+   },
+};
+
+let tplCache = {};
+
+let getTplCache = () => tplCache;
+
+export function invalidateStringTemplateCache() {
+   tplCache = {};
+}
+
+export function setGetStringTemplateCacheCallback(callback) {
+   getTplCache = callback;
+}

package/src/ui/Culture.d.ts

@@ -1,23 +1,47 @@
-declare type DateEncoding = (date: Date) => any;
-
-export class Culture {
-   static setCulture(cultureCode: string): void;
-
-   static setDefaultCurrency(currencyCode: string): void;
-
-   static readonly defaultCurrency: string;
-
-   static readonly culture: string;
-
-   static setNumberCulture(cultureCode: string): void;
-
-   static getNumberCulture(): any;
-
-   static setDateTimeCulture(cultureCode: string): void;
-
-   static getDateTimeCulture(): any;
-
-   static getDefaultDateEncoding(): DateEncoding;
-
-   static setDefaultDateEncoding(encoding: DateEncoding): void;
-}
+declare type DateEncoding = (date: Date) => any;
+
+export class Culture {
+   static setCulture(cultureCode: string): void;
+
+   static setDefaultCurrency(currencyCode: string): void;
+
+   static readonly defaultCurrency: string;
+
+   static readonly culture: string;
+
+   static setNumberCulture(cultureCode: string): void;
+
+   static getNumberCulture(): any;
+
+   static setDateTimeCulture(cultureCode: string): void;
+
+   static getDateTimeCulture(): any;
+
+   static getDefaultDateEncoding(): DateEncoding;
+
+   static setDefaultDateEncoding(encoding: DateEncoding): void;
+}
+
+export interface CultureSpecs {
+   culture?: string;
+   numberCulture?: string;
+   dateCulture?: string;
+   defaultCurrency?: string;
+   dateEncoding?: DateEncoding;
+}
+
+export interface CultureInfo {
+   culture: string;
+   numberCulture?: string;
+   dateCulture?: string;
+   defaultCurrency: string;
+   dateEncoding: DateEncoding;
+}
+
+export function createCulture(cultureSpecs: CultureSpecs): CultureInfo;
+
+export function pushCulture(cultureSpecs: CultureInfo): void;
+
+export function popCulture(): CultureInfo;
+
+export function getCurrentCultureCache(): any;