cx 22.4.0 → 22.4.1

package/src/data/computable.spec.js

@@ -1,55 +1,55 @@
-import { computable } from "./computable";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-
-describe("computable", function () {
-   it("creates a selector", function () {
-      let state = { person: { name: "Joe" } };
-      let nameLength = computable("person.name", (name) => name.length);
-      assert.equal(nameLength(state), 3);
-   });
-
-   it("fires every time if not memoized", function () {
-      let state = { person: { name: "Joe" } };
-      let fired = 0;
-      let nameLength = computable("person.name", (name) => {
-         fired++;
-         return name.length;
-      });
-      assert.equal(nameLength(state), 3);
-      assert.equal(nameLength(state), 3);
-      assert.equal(fired, 2);
-   });
-
-   it("fires once if memoized and data has not changed", function () {
-      let state = { person: { name: "Joe" } };
-      let fired = 0;
-      let nameLength = computable("person.name", (name) => {
-         fired++;
-         return name.length;
-      }).memoize();
-      assert.equal(nameLength(state), 3);
-      assert.equal(nameLength(state), 3);
-      assert.equal(fired, 1);
-   });
-
-   //weird but that's how triggers work and
-   it("memoize with warmup data will not call compute", function () {
-      let state = { person: { name: "Joe" } };
-      let fired = 0;
-      let nameLength = computable("person.name", (name) => {
-         fired++;
-         return name.length;
-      }).memoize(state);
-      assert.equal(nameLength(state), undefined);
-      assert.equal(nameLength(state), undefined);
-      assert.equal(fired, 0);
-   });
-
-   it("works with accessors", function () {
-      var m = createAccessorModelProxy();
-      let state = { person: { name: "Joe" } };
-      let nameLength = computable(m.person.name, (name) => name.length);
-      assert.equal(nameLength(state), 3);
-   });
-});
+import { computable } from "./computable";
+import assert from "assert";
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+
+describe("computable", function () {
+   it("creates a selector", function () {
+      let state = { person: { name: "Joe" } };
+      let nameLength = computable("person.name", (name) => name.length);
+      assert.equal(nameLength(state), 3);
+   });
+
+   it("fires every time if not memoized", function () {
+      let state = { person: { name: "Joe" } };
+      let fired = 0;
+      let nameLength = computable("person.name", (name) => {
+         fired++;
+         return name.length;
+      });
+      assert.equal(nameLength(state), 3);
+      assert.equal(nameLength(state), 3);
+      assert.equal(fired, 2);
+   });
+
+   it("fires once if memoized and data has not changed", function () {
+      let state = { person: { name: "Joe" } };
+      let fired = 0;
+      let nameLength = computable("person.name", (name) => {
+         fired++;
+         return name.length;
+      }).memoize();
+      assert.equal(nameLength(state), 3);
+      assert.equal(nameLength(state), 3);
+      assert.equal(fired, 1);
+   });
+
+   //weird but that's how triggers work and
+   it("memoize with warmup data will not call compute", function () {
+      let state = { person: { name: "Joe" } };
+      let fired = 0;
+      let nameLength = computable("person.name", (name) => {
+         fired++;
+         return name.length;
+      }).memoize(state);
+      assert.equal(nameLength(state), undefined);
+      assert.equal(nameLength(state), undefined);
+      assert.equal(fired, 0);
+   });
+
+   it("works with accessors", function () {
+      var m = createAccessorModelProxy();
+      let state = { person: { name: "Joe" } };
+      let nameLength = computable(m.person.name, (name) => name.length);
+      assert.equal(nameLength(state), 3);
+   });
+});

package/src/data/createAccessorModelProxy.d.ts

@@ -1,6 +1,6 @@
-import { AccessorChain } from "../core";
-
-export function isAccessorChain(value: any): boolean;
-export function isAccessorChain<V>(value: AccessorChain<V>): true;
-
-export function createAccessorModelProxy<M>(): AccessorChain<M>;
+import { AccessorChain } from "../core";
+
+export function isAccessorChain(value: any): boolean;
+export function isAccessorChain<V>(value: AccessorChain<V>): true;
+
+export function createAccessorModelProxy<M>(): AccessorChain<M>;

package/src/data/createAccessorModelProxy.js

@@ -1,24 +1,24 @@
-export function createAccessorModelProxy(chain = "") {
-   const proxy = new Proxy(() => {}, {
-      get: (target, name) => {
-         if (name === "isAccessorChain") return true;
-         if (typeof name !== "string") return this;
-         if (name === "toString" || name === "valueOf") return proxy;
-
-         let newChain = chain;
-         if (newChain.length > 0) newChain += ".";
-         newChain += name;
-         return createAccessorModelProxy(newChain);
-      },
-
-      apply() {
-         return chain;
-      },
-   });
-   proxy.isAccessorChain = true;
-   return proxy;
-}
-
-export function isAccessorChain(value) {
-   return value != null && !!value.isAccessorChain;
-}
+export function createAccessorModelProxy(chain = "") {
+   const proxy = new Proxy(() => {}, {
+      get: (target, name) => {
+         if (name === "isAccessorChain") return true;
+         if (typeof name !== "string") return this;
+         if (name === "toString" || name === "valueOf") return proxy;
+
+         let newChain = chain;
+         if (newChain.length > 0) newChain += ".";
+         newChain += name;
+         return createAccessorModelProxy(newChain);
+      },
+
+      apply() {
+         return chain;
+      },
+   });
+   proxy.isAccessorChain = true;
+   return proxy;
+}
+
+export function isAccessorChain(value) {
+   return value != null && !!value.isAccessorChain;
+}

package/src/data/createAccessorModelProxy.spec.tsx

@@ -1,23 +1,23 @@
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-import assert from "assert";
-
-interface Model {
-   firstName: string;
-   address: {
-      city: string;
-   };
-}
-
-describe("createAccessorModelProxy", () => {
-   it("generates correct paths", () => {
-      var model = createAccessorModelProxy<Model>();
-      assert.strictEqual(model.firstName.toString(), "firstName");
-      assert.strictEqual(model.address.toString(), "address");
-      assert.strictEqual(model.address.city.toString(), "address.city");
-   });
-
-   it("can be used in string templates", () => {
-      var model = createAccessorModelProxy<Model>();
-      assert.strictEqual("address.city", `${model.address.city}`);
-   });
-});
+import { createAccessorModelProxy } from "./createAccessorModelProxy";
+import assert from "assert";
+
+interface Model {
+   firstName: string;
+   address: {
+      city: string;
+   };
+}
+
+describe("createAccessorModelProxy", () => {
+   it("generates correct paths", () => {
+      var model = createAccessorModelProxy<Model>();
+      assert.strictEqual(model.firstName.toString(), "firstName");
+      assert.strictEqual(model.address.toString(), "address");
+      assert.strictEqual(model.address.city.toString(), "address.city");
+   });
+
+   it("can be used in string templates", () => {
+      var model = createAccessorModelProxy<Model>();
+      assert.strictEqual("address.city", `${model.address.city}`);
+   });
+});

package/src/data/createStructuredSelector.d.ts

@@ -1,3 +1,3 @@
-import { Record, StructuredSelector, Selector } from '../core';
-
+import { Record, StructuredSelector, Selector } from '../core';
+
 export function createStructuredSelector(selector: StructuredSelector, constants?: Record): Selector<Record>;

package/src/data/createStructuredSelector.js

@@ -1,43 +1,43 @@
-export function createStructuredSelector(selector, constants) {
-   let keys = Object.keys(selector);
-   if (keys.length == 0) return () => constants;
-
-   function memoize() {
-      let lastResult = Object.assign({}, constants);
-
-      let memoizedSelectors = {};
-
-      keys.forEach((key) => {
-         memoizedSelectors[key] = selector[key].memoize ? selector[key].memoize() : selector[key];
-         lastResult[key] = undefined;
-      });
-
-      return function (data) {
-         let result = lastResult,
-            k,
-            v,
-            i;
-         for (i = 0; i < keys.length; i++) {
-            k = keys[i];
-            v = memoizedSelectors[k](data);
-            if (result === lastResult) {
-               if (v === lastResult[k]) continue;
-               result = Object.assign({}, lastResult);
-            }
-            result[k] = v;
-         }
-         return (lastResult = result);
-      };
-   }
-
-   function evaluate(data) {
-      let result = Object.assign({}, constants);
-      for (let i = 0; i < keys.length; i++) {
-         result[keys[i]] = selector[keys[i]](data);
-      }
-      return result;
-   }
-
-   evaluate.memoize = memoize;
-   return evaluate;
-}
+export function createStructuredSelector(selector, constants) {
+   let keys = Object.keys(selector);
+   if (keys.length == 0) return () => constants;
+
+   function memoize() {
+      let lastResult = Object.assign({}, constants);
+
+      let memoizedSelectors = {};
+
+      keys.forEach((key) => {
+         memoizedSelectors[key] = selector[key].memoize ? selector[key].memoize() : selector[key];
+         lastResult[key] = undefined;
+      });
+
+      return function (data) {
+         let result = lastResult,
+            k,
+            v,
+            i;
+         for (i = 0; i < keys.length; i++) {
+            k = keys[i];
+            v = memoizedSelectors[k](data);
+            if (result === lastResult) {
+               if (v === lastResult[k]) continue;
+               result = Object.assign({}, lastResult);
+            }
+            result[k] = v;
+         }
+         return (lastResult = result);
+      };
+   }
+
+   function evaluate(data) {
+      let result = Object.assign({}, constants);
+      for (let i = 0; i < keys.length; i++) {
+         result[keys[i]] = selector[keys[i]](data);
+      }
+      return result;
+   }
+
+   evaluate.memoize = memoize;
+   return evaluate;
+}

package/src/data/createStructuredSelector.spec.js

@@ -1,46 +1,46 @@
-import {createStructuredSelector} from './createStructuredSelector';
-import assert from 'assert';
-import {getSelector} from "./getSelector";
-import {computable} from "./computable";
-
-describe('createStructuredSelector', function() {
-
-   it('works', function () {
-      let structure = {
-         name: getSelector({bind: "name"})
-      };
-      let state = {name: 'Joe'};
-      let selector = createStructuredSelector(structure);
-      assert.deepEqual(selector(state), {name: "Joe"});
-   });
-
-   it('does not memoize by default', function () {
-      let computes = 0;
-      let structure = {
-         name: computable("name", name => {
-            computes++;
-            return name;
-         })
-      };
-      let state = {name: 'Joe'};
-      let selector = createStructuredSelector(structure);
-      assert.deepEqual(selector(state), {name: "Joe"});
-      selector(state);
-      assert.deepEqual(computes, 2);
-   });
-
-   it('supports memoize', function () {
-      let computes = 0;
-      let structure = {
-         name: computable("name", name => {
-            computes++;
-            return name;
-         })
-      };
-      let state = {name: 'Joe'};
-      let selector = createStructuredSelector(structure).memoize();
-      assert.deepEqual(selector(state), {name: "Joe"});
-      selector(state);
-      assert.deepEqual(computes, 1);
-   });
-});
+import {createStructuredSelector} from './createStructuredSelector';
+import assert from 'assert';
+import {getSelector} from "./getSelector";
+import {computable} from "./computable";
+
+describe('createStructuredSelector', function() {
+
+   it('works', function () {
+      let structure = {
+         name: getSelector({bind: "name"})
+      };
+      let state = {name: 'Joe'};
+      let selector = createStructuredSelector(structure);
+      assert.deepEqual(selector(state), {name: "Joe"});
+   });
+
+   it('does not memoize by default', function () {
+      let computes = 0;
+      let structure = {
+         name: computable("name", name => {
+            computes++;
+            return name;
+         })
+      };
+      let state = {name: 'Joe'};
+      let selector = createStructuredSelector(structure);
+      assert.deepEqual(selector(state), {name: "Joe"});
+      selector(state);
+      assert.deepEqual(computes, 2);
+   });
+
+   it('supports memoize', function () {
+      let computes = 0;
+      let structure = {
+         name: computable("name", name => {
+            computes++;
+            return name;
+         })
+      };
+      let state = {name: 'Joe'};
+      let selector = createStructuredSelector(structure).memoize();
+      assert.deepEqual(selector(state), {name: "Joe"});
+      selector(state);
+      assert.deepEqual(computes, 1);
+   });
+});

package/src/data/defaultCompare.js

@@ -1,15 +1,15 @@
-export function defaultCompare(av, bv) {
-   if (av == null) {
-      if (bv == null)
-         return 0;
-      return -1;
-   }
-
-   if (bv == null || av > bv)
-      return 1;
-
-   if (av < bv)
-      return -1;
-
-   return 0;
+export function defaultCompare(av, bv) {
+   if (av == null) {
+      if (bv == null)
+         return 0;
+      return -1;
+   }
+
+   if (bv == null || av > bv)
+      return 1;
+
+   if (av < bv)
+      return -1;
+
+   return 0;
 }

package/src/data/diff/diffArrays.d.ts

@@ -1,15 +1,15 @@
-import { Record } from '../../core';
-
-interface BeforeAfterPair {
-   before: Record,
-   after: Record
-}
-
-interface ArrayDiff {
-   added: Record[],
-   unchanged: Record[],
-   removed: Record[],
-   changed: BeforeAfterPair[]
-}
-
-export function diffArrays(oldArray: Record[], newArray: Record[], keyFn: (Record) => any) : ArrayDiff;
+import { Record } from '../../core';
+
+interface BeforeAfterPair {
+   before: Record,
+   after: Record
+}
+
+interface ArrayDiff {
+   added: Record[],
+   unchanged: Record[],
+   removed: Record[],
+   changed: BeforeAfterPair[]
+}
+
+export function diffArrays(oldArray: Record[], newArray: Record[], keyFn: (Record) => any) : ArrayDiff;

package/src/data/diff/diffArrays.js

@@ -1,41 +1,41 @@
-import {isUndefined} from "../../util/isUndefined";
-
-export function diffArrays(oldArray, newArray, keyFn) {
-   if (!keyFn)
-      keyFn = e => e;
-
-   var map = new Map();
-
-   for (let i = 0; i < oldArray.length; i++)
-      map.set(keyFn(oldArray[i]), oldArray[i]);
-
-   var added = [],
-      changed = [],
-      unchanged = [];
-
-   for (let i = 0; i < newArray.length; i++) {
-      let el = newArray[i];
-      let k = keyFn(el);
-      let old = map.get(k);
-      if (isUndefined(old))
-         added.push(el);
-      else {
-         map.delete(k);
-         if (el == old)
-            unchanged.push(el);
-         else changed.push({
-            before: old,
-            after: el
-         });
-      }
-   }
-
-   var removed = Array.from(map.values());
-
-   return {
-      added,
-      changed,
-      unchanged,
-      removed
-   }
-}
+import {isUndefined} from "../../util/isUndefined";
+
+export function diffArrays(oldArray, newArray, keyFn) {
+   if (!keyFn)
+      keyFn = e => e;
+
+   var map = new Map();
+
+   for (let i = 0; i < oldArray.length; i++)
+      map.set(keyFn(oldArray[i]), oldArray[i]);
+
+   var added = [],
+      changed = [],
+      unchanged = [];
+
+   for (let i = 0; i < newArray.length; i++) {
+      let el = newArray[i];
+      let k = keyFn(el);
+      let old = map.get(k);
+      if (isUndefined(old))
+         added.push(el);
+      else {
+         map.delete(k);
+         if (el == old)
+            unchanged.push(el);
+         else changed.push({
+            before: old,
+            after: el
+         });
+      }
+   }
+
+   var removed = Array.from(map.values());
+
+   return {
+      added,
+      changed,
+      unchanged,
+      removed
+   }
+}

package/src/data/diff/diffs.spec.js

@@ -1,49 +1,49 @@
-import assert from 'assert';
-import {diffArrays} from './diffArrays';
-
-
-describe('diffArrays', function() {
-   it('should detect new elements', function () {
-      var a = [];
-      var b = [{k: 1}, {k: 2}]
-      var d = diffArrays(a, b);
-      assert.deepEqual(d, {
-         added: [{k: 1}, {k: 2}],
-         removed: [],
-         unchanged: [],
-         changed: []
-      });
-   });
-
-   it('should detect removed elements', function () {
-      var a = [];
-      var b = [{k: 1}, {k: 2}]
-      var d = diffArrays(b, a);
-      assert.deepEqual(d, {
-         removed: [{k: 1}, {k: 2}],
-         added: [],
-         unchanged: [],
-         changed: []
-      });
-   });
-
-   it('should detect changed elements', function () {
-      var a = [{k: 1, v: 2}];
-      var b = [{k: 1}, {k: 2}]
-      var d = diffArrays(a, b, x=>x.k);
-      assert.deepEqual(d, {
-         added: [{k: 2}],
-         removed: [],
-         unchanged: [],
-         changed: [{
-            after: {
-               k: 1
-            },
-            before: {
-               k: 1, v: 2
-            }
-         }]
-      });
-   });
-});
-
+import assert from 'assert';
+import {diffArrays} from './diffArrays';
+
+
+describe('diffArrays', function() {
+   it('should detect new elements', function () {
+      var a = [];
+      var b = [{k: 1}, {k: 2}]
+      var d = diffArrays(a, b);
+      assert.deepEqual(d, {
+         added: [{k: 1}, {k: 2}],
+         removed: [],
+         unchanged: [],
+         changed: []
+      });
+   });
+
+   it('should detect removed elements', function () {
+      var a = [];
+      var b = [{k: 1}, {k: 2}]
+      var d = diffArrays(b, a);
+      assert.deepEqual(d, {
+         removed: [{k: 1}, {k: 2}],
+         added: [],
+         unchanged: [],
+         changed: []
+      });
+   });
+
+   it('should detect changed elements', function () {
+      var a = [{k: 1, v: 2}];
+      var b = [{k: 1}, {k: 2}]
+      var d = diffArrays(a, b, x=>x.k);
+      assert.deepEqual(d, {
+         added: [{k: 2}],
+         removed: [],
+         unchanged: [],
+         changed: [{
+            after: {
+               k: 1
+            },
+            before: {
+               k: 1, v: 2
+            }
+         }]
+      });
+   });
+});
+

package/src/data/diff/index.d.ts

@@ -1 +1 @@
-export * from './diffArrays';
+export * from './diffArrays';

package/src/data/diff/index.js

@@ -1 +1 @@
-export * from './diffArrays';
+export * from './diffArrays';

package/src/data/enableFatArrowExpansion.d.ts

@@ -1 +1 @@
-export function enableFatArrowExpansion();
+export function enableFatArrowExpansion();