cx 24.6.2 → 24.6.4

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();

package/src/data/enableFatArrowExpansion.js

@@ -1,6 +1,6 @@
-import {expandFatArrows} from '../util/expandFatArrows';
-import {plugFatArrowExpansion} from './Expression';
-
-export function enableFatArrowExpansion() {
-   plugFatArrowExpansion(expandFatArrows);
-}
+import {expandFatArrows} from '../util/expandFatArrows';
+import {plugFatArrowExpansion} from './Expression';
+
+export function enableFatArrowExpansion() {
+   plugFatArrowExpansion(expandFatArrows);
+}

package/src/data/getAccessor.d.ts

@@ -1,9 +1,9 @@
-import {View} from "./View";
-
-export interface Accessor {
-   get: (data: any) => any;
-   set?: (value: any, store: View) => boolean;
-   bindInstance?(instance: any): Accessor;
-}
-
+import {View} from "./View";
+
+export interface Accessor {
+   get: (data: any) => any;
+   set?: (value: any, store: View) => boolean;
+   bindInstance?(instance: any): Accessor;
+}
+
 export function getAccessor(accessor) : Accessor;

package/src/data/getAccessor.js

@@ -1,61 +1,61 @@
-import { Binding, isBinding } from "./Binding";
-import { isSelector } from "./isSelector";
-import { getSelector } from "./getSelector";
-import { isObject } from "../util/isObject";
-import { isAccessorChain } from "./createAccessorModelProxy";
-
-/*
-   Accessor provides a common ground between refs and bindings.
-   Refs offer simplicity, bindings have better performance with more arguments.
-   Accessor works as a common interface which works with both patterns.
- */
-
-export function getAccessor(accessor, options) {
-   if (accessor == null) return null;
-
-   if (isObject(accessor)) {
-      if (accessor.isAccessor || accessor.isRef) return accessor;
-      if (isBinding(accessor)) {
-         let binding = Binding.get(accessor);
-         return {
-            get: binding.value,
-            set: (v, store) => store.set(binding.path, v),
-            isAccessor: true,
-         };
-      }
-   }
-
-   if (isAccessorChain(accessor)) {
-      let binding = Binding.get(accessor);
-      return {
-         get: binding.value,
-         set: (v, store) => store.set(binding.path, v),
-         isAccessor: true,
-      };
-   }
-
-   if (isSelector(accessor)) {
-      let selector = getSelector(accessor);
-      if (accessor && accessor.set)
-         return {
-            get: selector,
-            isAccessor: true,
-            bindInstance(instance) {
-               return {
-                  get: selector,
-                  set: (value) => accessor.set(value, instance),
-                  isAccessor: true,
-               };
-            },
-         };
-
-      return {
-         get: selector,
-         isAccessor: true,
-      };
-   }
-
-   return {
-      get: () => accessor,
-   };
-}
+import { Binding, isBinding } from "./Binding";
+import { isSelector } from "./isSelector";
+import { getSelector } from "./getSelector";
+import { isObject } from "../util/isObject";
+import { isAccessorChain } from "./createAccessorModelProxy";
+
+/*
+   Accessor provides a common ground between refs and bindings.
+   Refs offer simplicity, bindings have better performance with more arguments.
+   Accessor works as a common interface which works with both patterns.
+ */
+
+export function getAccessor(accessor, options) {
+   if (accessor == null) return null;
+
+   if (isObject(accessor)) {
+      if (accessor.isAccessor || accessor.isRef) return accessor;
+      if (isBinding(accessor)) {
+         let binding = Binding.get(accessor);
+         return {
+            get: binding.value,
+            set: (v, store) => store.set(binding.path, v),
+            isAccessor: true,
+         };
+      }
+   }
+
+   if (isAccessorChain(accessor)) {
+      let binding = Binding.get(accessor);
+      return {
+         get: binding.value,
+         set: (v, store) => store.set(binding.path, v),
+         isAccessor: true,
+      };
+   }
+
+   if (isSelector(accessor)) {
+      let selector = getSelector(accessor);
+      if (accessor && accessor.set)
+         return {
+            get: selector,
+            isAccessor: true,
+            bindInstance(instance) {
+               return {
+                  get: selector,
+                  set: (value) => accessor.set(value, instance),
+                  isAccessor: true,
+               };
+            },
+         };
+
+      return {
+         get: selector,
+         isAccessor: true,
+      };
+   }
+
+   return {
+      get: () => accessor,
+   };
+}

package/src/data/getSelector.d.ts

@@ -1,3 +1,3 @@
-import { Selector } from '../core';
-
-export function getSelector(config: any) : Selector<any>;
+import { Selector } from '../core';
+
+export function getSelector(config: any) : Selector<any>;