cx 26.0.5 → 26.0.8

package/src/data/StringTemplate.spec.ts

@@ -1,132 +1,132 @@
-import { StringTemplate } from "./StringTemplate";
-import assert from "assert";
-
-describe("StringTemplate", function () {
-   describe("#compile()", function () {
-      it("returns a selector", function () {
-         var e = StringTemplate.compile("Hello {person.name}");
-         var state = {
-            person: {
-               name: "Jim",
-            },
-         };
-         assert.equal(e(state), "Hello Jim");
-      });
-
-      it("allows empty strings", function () {
-         let e = StringTemplate.compile("");
-         assert.equal(e({}), "");
-      });
-
-      it("properly encodes ' and \"", function () {
-         var e = StringTemplate.compile('It\'s "working"!');
-         assert.equal(e({}), 'It\'s "working"!');
-      });
-
-      it("allows \\ before a binding", function () {
-         var e = StringTemplate.compile("t\\{person.name}");
-         assert.equal(e({ person: { name: "Ogi" } }), "t\\Ogi");
-      });
-
-      it("supports multi-line strings", function () {
-         var e = StringTemplate.compile("a\nb");
-         assert.equal(e({}), "a\nb");
-
-         var e = StringTemplate.compile("a\r\nb");
-         assert.equal(e({}), "a\r\nb");
-      });
-   });
-
-   describe("double brackets are used to escape brackets", function () {
-      it("double brackets are preserved", function () {
-         var e = StringTemplate.compile("Hello {{person.name}}");
-         var state = {
-            person: {
-               name: "Jim",
-            },
-         };
-         assert.equal(e(state), "Hello {person.name}");
-      });
-
-      it("triple brackets are converted to single brackets and a binding", function () {
-         var e = StringTemplate.compile("Hello {{{person.name}}}");
-         var state = {
-            person: {
-               name: "Jim",
-            },
-         };
-         assert.equal(e(state), "Hello {Jim}");
-      });
-
-      it("open brackets are ignored", function () {
-         var e = StringTemplate.compile("B { A");
-         assert.equal(e({}), "B { A");
-      });
-   });
-
-   describe("supports formatting", function () {
-      it("with colon", function () {
-         var e = StringTemplate.compile("{str:suffix;kg}");
-         assert.equal(e({ str: "5" }), "5kg");
-      });
-
-      it("with multiple formats", function () {
-         var e = StringTemplate.compile("{str:suffix;kg:wrap;(;)}");
-         assert.equal(e({ str: "5" }), "(5kg)");
-      });
-
-      it("with null values", function () {
-         var e = StringTemplate.compile("{str:suffix;kg:|N/A}");
-         assert.equal(e({ str: null }), "N/A");
-      });
-
-      it("of null values", function () {
-         var e = StringTemplate.compile("{str|N/A}");
-         assert.equal(e({ str: null }), "N/A");
-      });
-   });
-
-   describe("properly handles backslashes", function () {
-      it("in a string", function () {
-         var e = StringTemplate.compile("a\\b");
-         assert.equal(e({}), "a\\b");
-      });
-
-      it("before a special character", function () {
-         var e = StringTemplate.compile("\\t");
-         assert.equal(e({}), "\\t");
-      });
-   });
-
-   describe("supports expressions", function () {
-      it("using []", function () {
-         var e = StringTemplate.compile("1 + 2 = {[1+2]}");
-         assert.equal(e({}), "1 + 2 = 3");
-      });
-
-      it("using %", function () {
-         var e = StringTemplate.compile("1 + 2 = %{1+2}");
-         assert.equal(e({}), "1 + 2 = 3");
-      });
-
-      it("with subexpressions", function () {
-         var e = StringTemplate.compile("1 + 2 = {[%{1+2}]}");
-         assert.equal(e({}), "1 + 2 = 3");
-      });
-
-      it("with a conditional operator", function () {
-         var e = StringTemplate.compile("1 + 2 = {[true ? 3 : 2]:s}");
-         assert.equal(e({}), "1 + 2 = 3");
-      });
-
-      it("with sub-expression formatting", function () {
-         var e = StringTemplate.compile("{[!!{person.age} ? {person.age:suffix; years old} : 'Age unknown']}");
-         var state = {
-            person: {
-               age: 32,
-            },
-         };
-         assert.equal(e(state), "32 years old");
-      });
-   });
-});
+import { StringTemplate } from "./StringTemplate";
+import assert from "assert";
+
+describe("StringTemplate", function () {
+   describe("#compile()", function () {
+      it("returns a selector", function () {
+         var e = StringTemplate.compile("Hello {person.name}");
+         var state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Hello Jim");
+      });
+
+      it("allows empty strings", function () {
+         let e = StringTemplate.compile("");
+         assert.equal(e({}), "");
+      });
+
+      it("properly encodes ' and \"", function () {
+         var e = StringTemplate.compile('It\'s "working"!');
+         assert.equal(e({}), 'It\'s "working"!');
+      });
+
+      it("allows \\ before a binding", function () {
+         var e = StringTemplate.compile("t\\{person.name}");
+         assert.equal(e({ person: { name: "Ogi" } }), "t\\Ogi");
+      });
+
+      it("supports multi-line strings", function () {
+         var e = StringTemplate.compile("a\nb");
+         assert.equal(e({}), "a\nb");
+
+         var e = StringTemplate.compile("a\r\nb");
+         assert.equal(e({}), "a\r\nb");
+      });
+   });
+
+   describe("double brackets are used to escape brackets", function () {
+      it("double brackets are preserved", function () {
+         var e = StringTemplate.compile("Hello {{person.name}}");
+         var state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Hello {person.name}");
+      });
+
+      it("triple brackets are converted to single brackets and a binding", function () {
+         var e = StringTemplate.compile("Hello {{{person.name}}}");
+         var state = {
+            person: {
+               name: "Jim",
+            },
+         };
+         assert.equal(e(state), "Hello {Jim}");
+      });
+
+      it("open brackets are ignored", function () {
+         var e = StringTemplate.compile("B { A");
+         assert.equal(e({}), "B { A");
+      });
+   });
+
+   describe("supports formatting", function () {
+      it("with colon", function () {
+         var e = StringTemplate.compile("{str:suffix;kg}");
+         assert.equal(e({ str: "5" }), "5kg");
+      });
+
+      it("with multiple formats", function () {
+         var e = StringTemplate.compile("{str:suffix;kg:wrap;(;)}");
+         assert.equal(e({ str: "5" }), "(5kg)");
+      });
+
+      it("with null values", function () {
+         var e = StringTemplate.compile("{str:suffix;kg:|N/A}");
+         assert.equal(e({ str: null }), "N/A");
+      });
+
+      it("of null values", function () {
+         var e = StringTemplate.compile("{str|N/A}");
+         assert.equal(e({ str: null }), "N/A");
+      });
+   });
+
+   describe("properly handles backslashes", function () {
+      it("in a string", function () {
+         var e = StringTemplate.compile("a\\b");
+         assert.equal(e({}), "a\\b");
+      });
+
+      it("before a special character", function () {
+         var e = StringTemplate.compile("\\t");
+         assert.equal(e({}), "\\t");
+      });
+   });
+
+   describe("supports expressions", function () {
+      it("using []", function () {
+         var e = StringTemplate.compile("1 + 2 = {[1+2]}");
+         assert.equal(e({}), "1 + 2 = 3");
+      });
+
+      it("using %", function () {
+         var e = StringTemplate.compile("1 + 2 = %{1+2}");
+         assert.equal(e({}), "1 + 2 = 3");
+      });
+
+      it("with subexpressions", function () {
+         var e = StringTemplate.compile("1 + 2 = {[%{1+2}]}");
+         assert.equal(e({}), "1 + 2 = 3");
+      });
+
+      it("with a conditional operator", function () {
+         var e = StringTemplate.compile("1 + 2 = {[true ? 3 : 2]:s}");
+         assert.equal(e({}), "1 + 2 = 3");
+      });
+
+      it("with sub-expression formatting", function () {
+         var e = StringTemplate.compile("{[!!{person.age} ? {person.age:suffix; years old} : 'Age unknown']}");
+         var state = {
+            person: {
+               age: 32,
+            },
+         };
+         assert.equal(e(state), "32 years old");
+      });
+   });
+});

package/src/data/StringTemplate.ts

@@ -1,93 +1,93 @@
-import { expression } from "./Expression";
-import { MemoSelector } from "./Selector";
-
-import { quoteStr } from "../util/quote";
-
-function plus(str: string) {
-   return str.length ? str + " + " : str;
-}
-
-export function stringTemplate(str: string): MemoSelector<string> {
-   let tplCache = getTplCache();
-   let cached = tplCache[str];
-   if (cached) return cached;
-
-   let expr = "";
-
-   let termStart = -1,
-      quoteStart = 0,
-      term: string,
-      bracketsOpen = 0,
-      percentSign: boolean = false;
-
-   for (let i = 0; i < str.length; i++) {
-      switch (str[i]) {
-         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;
-                  quoteStart = i; // for the case where the brackets are not closed
-               }
-            } 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.length == 0) expr = plus(expr) + quoteStr(str.substring(quoteStart));
-
-   return (tplCache[str] = expression(expr));
-}
-
-export const StringTemplate = {
-   get: function (str: string) {
-      return stringTemplate(str);
-   },
-
-   compile: function (str: string) {
-      return stringTemplate(str).memoize();
-   },
-
-   format: function (format: string, ...args: any[]) {
-      return stringTemplate(format)(args);
-   },
-};
-
-let tplCache: Record<string, MemoSelector> = {};
-
-let getTplCache = () => tplCache;
-
-export function invalidateStringTemplateCache() {
-   tplCache = {};
-}
-
-export function setGetStringTemplateCacheCallback(callback: () => Record<string, MemoSelector>) {
-   getTplCache = callback;
-}
+import { expression } from "./Expression";
+import { MemoSelector } from "./Selector";
+
+import { quoteStr } from "../util/quote";
+
+function plus(str: string) {
+   return str.length ? str + " + " : str;
+}
+
+export function stringTemplate(str: string): MemoSelector<string> {
+   let tplCache = getTplCache();
+   let cached = tplCache[str];
+   if (cached) return cached;
+
+   let expr = "";
+
+   let termStart = -1,
+      quoteStart = 0,
+      term: string,
+      bracketsOpen = 0,
+      percentSign: boolean = false;
+
+   for (let i = 0; i < str.length; i++) {
+      switch (str[i]) {
+         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;
+                  quoteStart = i; // for the case where the brackets are not closed
+               }
+            } 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.length == 0) expr = plus(expr) + quoteStr(str.substring(quoteStart));
+
+   return (tplCache[str] = expression(expr));
+}
+
+export const StringTemplate = {
+   get: function (str: string) {
+      return stringTemplate(str);
+   },
+
+   compile: function (str: string) {
+      return stringTemplate(str).memoize();
+   },
+
+   format: function (format: string, ...args: any[]) {
+      return stringTemplate(format)(args);
+   },
+};
+
+let tplCache: Record<string, MemoSelector> = {};
+
+let getTplCache = () => tplCache;
+
+export function invalidateStringTemplateCache() {
+   tplCache = {};
+}
+
+export function setGetStringTemplateCacheCallback(callback: () => Record<string, MemoSelector>) {
+   getTplCache = callback;
+}

package/src/data/StructuredSelector.spec.ts

@@ -1,113 +1,113 @@
-import { StructuredSelector } from "./StructuredSelector";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-
-describe("StructuredSelector", function () {
-   describe("#create()", function () {
-      it("constants", function () {
-         var x = {};
-         var s = new StructuredSelector({
-            props: {
-               a: undefined,
-               b: undefined,
-            },
-            values: {
-               a: 1,
-               b: 2,
-            },
-         }).create();
-
-         assert.deepEqual(s(x), { a: 1, b: 2 });
-      });
-
-      it("bindings", function () {
-         var x = { a: 1, b: 2 };
-         var s = new StructuredSelector({
-            props: {
-               a: undefined,
-               b: undefined,
-            },
-            values: {
-               a: { bind: "b" },
-               b: { bind: "a" },
-            },
-         }).create();
-
-         assert.deepEqual(s(x), { a: 2, b: 1 });
-      });
-
-      it("templates", function () {
-         var x = { a: 1, b: 2 };
-         var s = new StructuredSelector({
-            props: {
-               a: undefined,
-               b: undefined,
-            },
-            values: {
-               a: { tpl: "b{a}" },
-               b: { tpl: "a{b}" },
-            },
-         }).create();
-
-         assert.deepEqual(s(x), { a: "b1", b: "a2" });
-      });
-
-      it("structured", function () {
-         var x = { a: 1, b: 2 };
-         var s = new StructuredSelector({
-            props: {
-               a: {
-                  structured: true,
-               },
-               b: undefined,
-            },
-            values: {
-               a: {
-                  x: { expr: "{a} == 1" },
-                  y: { expr: "{b} == 1" },
-               },
-               b: { tpl: "a{b}" },
-            },
-         }).create();
-
-         assert.deepEqual(s(x), { a: { x: true, y: false }, b: "a2" });
-      });
-   });
-
-   it("structures do not change if data doesn't change", function () {
-      var x = { a: 1, b: 2 };
-      var s = new StructuredSelector({
-         props: {
-            a: {
-               structured: true,
-            },
-         },
-         values: {
-            a: {
-               x: { expr: "{a} == 1" },
-               y: { expr: "{b} == 1" },
-            },
-            b: { tpl: "a{b}" },
-         },
-      }).create();
-
-      let r1 = s(x);
-      let r2 = s(x);
-
-      assert.equal(r1, r2);
-   });
-
-   it("accessor model proxy works", function () {
-      var x = { a: { b: 2 } };
-      var m = createAccessorModelProxy<typeof x>();
-      var s = new StructuredSelector({
-         props: {
-            b: undefined,
-         },
-         values: {
-            b: m.a.b,
-         },
-      }).create();
-      assert.deepEqual(s(x), { b: 2 });
-   });
-});
+import { StructuredSelector } from "./StructuredSelector";
+import assert from "assert";
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+
+describe("StructuredSelector", function () {
+   describe("#create()", function () {
+      it("constants", function () {
+         var x = {};
+         var s = new StructuredSelector({
+            props: {
+               a: undefined,
+               b: undefined,
+            },
+            values: {
+               a: 1,
+               b: 2,
+            },
+         }).create();
+
+         assert.deepEqual(s(x), { a: 1, b: 2 });
+      });
+
+      it("bindings", function () {
+         var x = { a: 1, b: 2 };
+         var s = new StructuredSelector({
+            props: {
+               a: undefined,
+               b: undefined,
+            },
+            values: {
+               a: { bind: "b" },
+               b: { bind: "a" },
+            },
+         }).create();
+
+         assert.deepEqual(s(x), { a: 2, b: 1 });
+      });
+
+      it("templates", function () {
+         var x = { a: 1, b: 2 };
+         var s = new StructuredSelector({
+            props: {
+               a: undefined,
+               b: undefined,
+            },
+            values: {
+               a: { tpl: "b{a}" },
+               b: { tpl: "a{b}" },
+            },
+         }).create();
+
+         assert.deepEqual(s(x), { a: "b1", b: "a2" });
+      });
+
+      it("structured", function () {
+         var x = { a: 1, b: 2 };
+         var s = new StructuredSelector({
+            props: {
+               a: {
+                  structured: true,
+               },
+               b: undefined,
+            },
+            values: {
+               a: {
+                  x: { expr: "{a} == 1" },
+                  y: { expr: "{b} == 1" },
+               },
+               b: { tpl: "a{b}" },
+            },
+         }).create();
+
+         assert.deepEqual(s(x), { a: { x: true, y: false }, b: "a2" });
+      });
+   });
+
+   it("structures do not change if data doesn't change", function () {
+      var x = { a: 1, b: 2 };
+      var s = new StructuredSelector({
+         props: {
+            a: {
+               structured: true,
+            },
+         },
+         values: {
+            a: {
+               x: { expr: "{a} == 1" },
+               y: { expr: "{b} == 1" },
+            },
+            b: { tpl: "a{b}" },
+         },
+      }).create();
+
+      let r1 = s(x);
+      let r2 = s(x);
+
+      assert.equal(r1, r2);
+   });
+
+   it("accessor model proxy works", function () {
+      var x = { a: { b: 2 } };
+      var m = createAccessorModelProxy<typeof x>();
+      var s = new StructuredSelector({
+         props: {
+            b: undefined,
+         },
+         values: {
+            b: m.a.b,
+         },
+      }).create();
+      assert.deepEqual(s(x), { b: 2 });
+   });
+});