cx 23.12.2 → 24.0.0

package/src/data/Expression.spec.js

@@ -1,164 +1,174 @@
-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");
+      });
+
+      it("with string interpolation inside", function () {
+         var e = Expression.compile("{[`${{test}}`]}");
+         assert.equal(e({ test: "T" }), "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("allows using the fmt function inside", function () {
+         var e = Expression.compile('{[fmt({text}, "prefix;Hello ")]}');
+         assert.equal(e({ text: "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/ui/Format.js

@@ -1,89 +1,87 @@
-import {Culture} from "./Culture";
-import {Format as Fmt, resolveMinMaxFractionDigits} from "../util/Format";
-import {GlobalCacheIdentifier} from '../util/GlobalCacheIdentifier';
-
-export const Format = Fmt;
-
-let cultureSensitiveFormatsRegistered = false;
-
-export function enableCultureSensitiveFormatting() {
-
-   if (cultureSensitiveFormatsRegistered)
-      return;
-
-   cultureSensitiveFormatsRegistered = true;
-
-   Fmt.registerFactory(
-      ['number', 'n'],
-      (format, minimumFractionDigits, maximumFractionDigits) => {
-         let culture = Culture.getNumberCulture();
-
-         let formatter = culture.getFormatter(resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits));
-
-         return value => formatter.format(value);
-      }
-   );
-
-   Fmt.registerFactory('currency',
-      (format, currency, minimumFractionDigits, maximumFractionDigits) => {
-         let culture = Culture.getNumberCulture();
-         currency = currency || Culture.defaultCurrency;
-
-         let formatter = culture.getFormatter({
-            style: 'currency',
-            currency: currency,
-            ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits)
-         });
-
-         return value => formatter.format(value);
-      }
-   );
-
-   Fmt.registerFactory(
-      ['percentage', 'p', '%'],
-      (format, minimumFractionDigits, maximumFractionDigits) => {
-         let culture = Culture.getNumberCulture();
-         let formatter = culture.getFormatter({
-            style: 'percent',
-            ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits)
-         });
-         return value => formatter.format(value);
-      }
-   );
-
-   Fmt.registerFactory(
-      ['percentSign', 'ps'],
-      (format, minimumFractionDigits, maximumFractionDigits) => {
-         let culture = Culture.getNumberCulture();
-         let formatter = culture.getFormatter({
-            style: 'percent',
-            ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits)
-         });
-         return value => formatter.format(value / 100);
-      }
-   );
-
-   Fmt.registerFactory(['date', 'd'], (fmt, format = 'yyyyMMdd') => {
-      let culture = Culture.getDateTimeCulture();
-      let formatter = culture.getFormatter(format);
-      return value => formatter.format(new Date(value));
-   });
-
-
-   Fmt.registerFactory(['time', 't'], (fmt, format = 'hhmmss') => {
-      let culture = Culture.getDateTimeCulture();
-      let formatter = culture.getFormatter(format);
-      return value => formatter.format(new Date(value));
-   });
-
-   Fmt.registerFactory(
-      ['datetime', 'dt'],
-      (fmt, format = 'yyyyMd hhmm') => {
-         let culture = Culture.getDateTimeCulture();
-         let formatter = culture.getFormatter(format);
-         return value => formatter.format(new Date(value));
-      }
-   );
-
-   GlobalCacheIdentifier.change();
-}
+import { Culture } from "./Culture";
+import { Format as Fmt, resolveMinMaxFractionDigits } from "../util/Format";
+import { GlobalCacheIdentifier } from "../util/GlobalCacheIdentifier";
+
+export const Format = Fmt;
+
+let cultureSensitiveFormatsRegistered = false;
+
+export function resolveNumberFormattingFlags(flags) {
+   if (!flags) return null;
+   let result = {};
+   if (flags.indexOf("+") >= 0) result.signDisplay = "exceptZero";
+   if (flags.indexOf("c") >= 0) result.notation = "compact";
+   if (flags.indexOf("a") >= 0) result.currencySign = "accounting";
+   return result;
+}
+
+export function enableCultureSensitiveFormatting() {
+   if (cultureSensitiveFormatsRegistered) return;
+
+   cultureSensitiveFormatsRegistered = true;
+
+   Fmt.registerFactory(["number", "n"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+
+      let formatter = culture.getFormatter({
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+
+      return (value) => formatter.format(value);
+   });
+
+   Fmt.registerFactory("currency", (format, currency, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+      currency = currency || Culture.defaultCurrency;
+
+      let formatter = culture.getFormatter({
+         style: "currency",
+         currency: currency,
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+
+      return (value) => formatter.format(value);
+   });
+
+   Fmt.registerFactory(["percentage", "p", "%"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+      let formatter = culture.getFormatter({
+         style: "percent",
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+      return (value) => formatter.format(value);
+   });
+
+   Fmt.registerFactory(["percentSign", "ps"], (format, minimumFractionDigits, maximumFractionDigits, flags) => {
+      let culture = Culture.getNumberCulture();
+      let formatter = culture.getFormatter({
+         style: "percent",
+         ...resolveMinMaxFractionDigits(minimumFractionDigits, maximumFractionDigits),
+         ...resolveNumberFormattingFlags(flags),
+      });
+      return (value) => formatter.format(value / 100);
+   });
+
+   Fmt.registerFactory(["date", "d"], (fmt, format = "yyyyMMdd") => {
+      let culture = Culture.getDateTimeCulture();
+      let formatter = culture.getFormatter(format);
+      return (value) => formatter.format(new Date(value));
+   });
+
+   Fmt.registerFactory(["time", "t"], (fmt, format = "hhmmss") => {
+      let culture = Culture.getDateTimeCulture();
+      let formatter = culture.getFormatter(format);
+      return (value) => formatter.format(new Date(value));
+   });
+
+   Fmt.registerFactory(["datetime", "dt"], (fmt, format = "yyyyMd hhmm") => {
+      let culture = Culture.getDateTimeCulture();
+      let formatter = culture.getFormatter(format);
+      return (value) => formatter.format(new Date(value));
+   });
+
+   GlobalCacheIdentifier.change();
+}

package/src/ui/Restate.d.ts

@@ -8,6 +8,9 @@ interface RestateProps extends Cx.PureContainerProps {
    idleTimeout?: Cx.NumberProp;
    cacheKey?: Cx.StringProp;
 
+   /* Set to true to disable batching of updates. */
+   immediate?: boolean;
+
    onError?: (err: Error, instance: Instance) => void;
 }
 

package/src/ui/Restate.js

@@ -95,6 +95,7 @@ export class Restate extends PureContainer {
             onError={this.onError}
             deferredUntilIdle={instance.data.deferredUntilIdle}
             idleTimeout={instance.data.idleTimeout}
+            immediate={this.immediate}
          />
       );
    }
@@ -102,6 +103,7 @@ export class Restate extends PureContainer {
 
 Restate.prototype.detached = false;
 Restate.prototype.waitForIdle = false;
+Restate.prototype.immediate = false;
 
 export const PrivateStore = Restate;