cx 24.11.4 → 25.1.0

package/src/data/Expression.spec.js

@@ -1,217 +1,217 @@
-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), '"');
-      });
-   });
-
-   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), '"');
+      });
+   });
+
+   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

@@ -20,8 +20,7 @@ export function stringTemplate(str) {
       percentSign;
 
    for (let i = 0; i < str.length; i++) {
-      let c = str[i];
-      switch (c) {
+      switch (str[i]) {
          case "{":
             if (termStart < 0) {
                if (str[i + 1] == "{" && str[i - 1] != "%") {
@@ -33,6 +32,7 @@ export function stringTemplate(str) {
                   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;