cx 25.3.1 → 25.4.0

package/src/data/Expression.spec.js

@@ -1,229 +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(e2(), "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);
-      // });
-   });
-});
+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(e2(), "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/StringTemplate.js

@@ -1,92 +1,92 @@
-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++) {
-      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) {
-      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;
-}
+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++) {
+      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) {
+      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;
+}