cx 22.4.0 → 22.4.1

package/src/data/ops/filter.spec.js

@@ -1,29 +1,29 @@
-import {Store} from '../Store';
-import {filter} from './filter';
-import assert from 'assert';
-
-describe('filter', function() {
-   it('should filter array elements', function () {
-      let store = new Store({
-         data: {
-            array: [1, 2, 3]
-         }
-      });
-
-      assert(store.update('array', filter, x => x > 1));
-      assert.deepEqual(store.get('array'), [2, 3]);
-   });
-
-   it('should work with undefined arrays', function () {
-      let store = new Store();
-      assert.equal(false, store.update('array', filter, x => x > 1));
-      assert.deepEqual(store.get('array'), undefined);
-   });
-
-   it('returns same array if all elements satisfy condition', function () {
-      let array = [1, 2, 3];
-      let store = new Store({ data: { array }});
-      assert.equal(false, store.update('array', filter, x => x > 0));
-      assert(store.get('array') === array);
-   });
-});
+import {Store} from '../Store';
+import {filter} from './filter';
+import assert from 'assert';
+
+describe('filter', function() {
+   it('should filter array elements', function () {
+      let store = new Store({
+         data: {
+            array: [1, 2, 3]
+         }
+      });
+
+      assert(store.update('array', filter, x => x > 1));
+      assert.deepEqual(store.get('array'), [2, 3]);
+   });
+
+   it('should work with undefined arrays', function () {
+      let store = new Store();
+      assert.equal(false, store.update('array', filter, x => x > 1));
+      assert.deepEqual(store.get('array'), undefined);
+   });
+
+   it('returns same array if all elements satisfy condition', function () {
+      let array = [1, 2, 3];
+      let store = new Store({ data: { array }});
+      assert.equal(false, store.update('array', filter, x => x > 0));
+      assert(store.get('array') === array);
+   });
+});

package/src/data/ops/findTreeNode.js

@@ -1,15 +1,15 @@
-export function findTreeNode(array, criteria, childrenField = '$children') {
-   if (!Array.isArray(array))
-      return false;
-
-   for (let i = 0; i < array.length; i++) {
-      if (criteria(array[i]))
-         return array[i];
-
-      let child = findTreeNode(array[i][childrenField], criteria, childrenField);
-      if (child)
-         return child;
-   }
-
-   return false;
-}
+export function findTreeNode(array, criteria, childrenField = '$children') {
+   if (!Array.isArray(array))
+      return false;
+
+   for (let i = 0; i < array.length; i++) {
+      if (criteria(array[i]))
+         return array[i];
+
+      let child = findTreeNode(array[i][childrenField], criteria, childrenField);
+      if (child)
+         return child;
+   }
+
+   return false;
+}

package/src/data/ops/findTreeNode.spec.js

@@ -1,24 +1,24 @@
-import {Store} from '../Store';
-import {findTreeNode} from './findTreeNode';
-import assert from 'assert';
-
-describe('removeTreeNodes', function() {
-   it('removes all nodes that satisfy criteria', function () {
-      let array = [{
-         id: 'n1',
-         value: 1,
-         children: [{
-            id: 'n11',
-            value: 2
-         }, {
-            id: 'n12',
-            value: 3
-         }]
-      }];
-
-      let node = findTreeNode(array, x => x.value == 3, 'children');
-
-      assert(node);
-      assert.equal(node.value, 3)
-   });
-});
+import {Store} from '../Store';
+import {findTreeNode} from './findTreeNode';
+import assert from 'assert';
+
+describe('removeTreeNodes', function() {
+   it('removes all nodes that satisfy criteria', function () {
+      let array = [{
+         id: 'n1',
+         value: 1,
+         children: [{
+            id: 'n11',
+            value: 2
+         }, {
+            id: 'n12',
+            value: 3
+         }]
+      }];
+
+      let node = findTreeNode(array, x => x.value == 3, 'children');
+
+      assert(node);
+      assert.equal(node.value, 3)
+   });
+});

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

@@ -1,10 +1,10 @@
-export * from './append';
-export * from './merge';
-export * from './filter';
-export * from './updateArray';
-export * from './updateTree';
-export * from './removeTreeNodes';
-export * from './findTreeNode';
-export * from './moveElement';
-export * from './insertElement';
-
+export * from './append';
+export * from './merge';
+export * from './filter';
+export * from './updateArray';
+export * from './updateTree';
+export * from './removeTreeNodes';
+export * from './findTreeNode';
+export * from './moveElement';
+export * from './insertElement';
+

package/src/data/ops/index.js

@@ -1,10 +1,10 @@
-export * from './append';
-export * from './merge';
-export * from './filter';
-export * from './updateArray';
-export * from './updateTree';
-export * from './removeTreeNodes';
-export * from './findTreeNode';
-export * from './moveElement';
-export * from './insertElement';
-
+export * from './append';
+export * from './merge';
+export * from './filter';
+export * from './updateArray';
+export * from './updateTree';
+export * from './removeTreeNodes';
+export * from './findTreeNode';
+export * from './moveElement';
+export * from './insertElement';
+

package/src/data/ops/insertElement.js

@@ -1,3 +1,3 @@
-export function insertElement(array, index, ...args) {
-   return [...array.slice(0, index), ...args, ...array.slice(index)];
+export function insertElement(array, index, ...args) {
+   return [...array.slice(0, index), ...args, ...array.slice(index)];
 }

package/src/data/ops/merge.d.ts

@@ -1,3 +1,3 @@
-import { Record } from '../../core';
-
-export function merge(item: Record, data: Record) : Record;
+import { Record } from '../../core';
+
+export function merge(item: Record, data: Record) : Record;

package/src/data/ops/merge.js

@@ -1,9 +1,9 @@
-import {Binding} from '../Binding';
-
-export function merge(item, data) {
-   let result = item;
-   if (data)
-      for (let key in data)
-         result = Binding.get(key).set(result, data[key]);
-   return result;
-}
+import {Binding} from '../Binding';
+
+export function merge(item, data) {
+   let result = item;
+   if (data)
+      for (let key in data)
+         result = Binding.get(key).set(result, data[key]);
+   return result;
+}

package/src/data/ops/merge.spec.js

@@ -1,27 +1,27 @@
-import {Store} from '../Store';
-import {merge} from './merge';
-import assert from 'assert';
-
-describe('merge', function() {
-   it('performs multiple set operations', function () {
-      let store = new Store({
-         data: {
-            person: { firstName: 'John', lastName: 'Doe'}
-         }
-      });
-
-      assert(store.update('person', merge, { firstName: 'Johny', age: 18 }));
-      assert.deepEqual(store.get('person'), { firstName: 'Johny', lastName: 'Doe', age: 18 });
-   });
-
-   it('does not modify data if not necessary', function () {
-      let store = new Store({
-         data: {
-            person: { firstName: 'John', lastName: 'Doe'}
-         }
-      });
-
-      assert(store.update('person', merge, { firstName: 'John' }) == false);
-      assert.deepEqual(store.get('person'), { firstName: 'John', lastName: 'Doe' });
-   });
-});
+import {Store} from '../Store';
+import {merge} from './merge';
+import assert from 'assert';
+
+describe('merge', function() {
+   it('performs multiple set operations', function () {
+      let store = new Store({
+         data: {
+            person: { firstName: 'John', lastName: 'Doe'}
+         }
+      });
+
+      assert(store.update('person', merge, { firstName: 'Johny', age: 18 }));
+      assert.deepEqual(store.get('person'), { firstName: 'Johny', lastName: 'Doe', age: 18 });
+   });
+
+   it('does not modify data if not necessary', function () {
+      let store = new Store({
+         data: {
+            person: { firstName: 'John', lastName: 'Doe'}
+         }
+      });
+
+      assert(store.update('person', merge, { firstName: 'John' }) == false);
+      assert.deepEqual(store.get('person'), { firstName: 'John', lastName: 'Doe' });
+   });
+});

package/src/data/ops/moveElement.js

@@ -1,14 +1,14 @@
-export function moveElement(array, sourceIndex, targetIndex) {
-   if (targetIndex == sourceIndex) return array;
-
-   let el = array[sourceIndex];
-   let res = [...array];
-   if (sourceIndex < targetIndex) {
-      for (let i = sourceIndex; i + 1 < targetIndex; i++) res[i] = res[i + 1];
-      targetIndex--;
-   } else {
-      for (let i = sourceIndex; i > targetIndex; i--) res[i] = res[i - 1];
-   }
-   res[targetIndex] = el;
-   return res;
+export function moveElement(array, sourceIndex, targetIndex) {
+   if (targetIndex == sourceIndex) return array;
+
+   let el = array[sourceIndex];
+   let res = [...array];
+   if (sourceIndex < targetIndex) {
+      for (let i = sourceIndex; i + 1 < targetIndex; i++) res[i] = res[i + 1];
+      targetIndex--;
+   } else {
+      for (let i = sourceIndex; i > targetIndex; i--) res[i] = res[i - 1];
+   }
+   res[targetIndex] = el;
+   return res;
 }

package/src/data/ops/removeTreeNodes.d.ts

@@ -1 +1 @@
-export function removeTreeNodes(array: any[], criteria: ((item?: any, index?: number) => boolean), childrenField?: string);
+export function removeTreeNodes(array: any[], criteria: ((item?: any, index?: number) => boolean), childrenField?: string);

package/src/data/ops/removeTreeNodes.js

@@ -1,5 +1,5 @@
-import { updateTree } from "./updateTree";
-
-export function removeTreeNodes(array, criteria, childrenField = "$children") {
-   return updateTree(array, null, () => false, childrenField, criteria);
-}
+import { updateTree } from "./updateTree";
+
+export function removeTreeNodes(array, criteria, childrenField = "$children") {
+   return updateTree(array, null, () => false, childrenField, criteria);
+}

package/src/data/ops/removeTreeNodes.spec.js

@@ -1,28 +1,28 @@
-import {Store} from '../Store';
-import {removeTreeNodes} from './removeTreeNodes';
-import assert from 'assert';
-
-describe('removeTreeNodes', function() {
-   it('removes all nodes that satisfy criteria', function () {
-      let store = new Store({
-         data: {array: [{
-            id: 'n1',
-            value: 1,
-            children: [{
-               id: 'n11',
-               value: 2
-            }, {
-               id: 'n12',
-               value: 3
-            }]
-         }]}
-      });
-
-      assert(store.update('array', removeTreeNodes, x => x.value > 1, 'children'));
-      assert.deepEqual(store.get('array'), [{
-         id: 'n1',
-         value: 1,
-         children: []
-      }]);
-   });
-});
+import {Store} from '../Store';
+import {removeTreeNodes} from './removeTreeNodes';
+import assert from 'assert';
+
+describe('removeTreeNodes', function() {
+   it('removes all nodes that satisfy criteria', function () {
+      let store = new Store({
+         data: {array: [{
+            id: 'n1',
+            value: 1,
+            children: [{
+               id: 'n11',
+               value: 2
+            }, {
+               id: 'n12',
+               value: 3
+            }]
+         }]}
+      });
+
+      assert(store.update('array', removeTreeNodes, x => x.value > 1, 'children'));
+      assert.deepEqual(store.get('array'), [{
+         id: 'n1',
+         value: 1,
+         children: []
+      }]);
+   });
+});

package/src/data/ops/updateArray.d.ts

@@ -1,6 +1,6 @@
-export function updateArray<T>(
-    array: T[],
-    updateCallback: (item: T, index?: number) => T,
-    itemFilter?: (item: T, index?: number) => boolean,
-    removeFilter?: (item: T, index?: number) => boolean
+export function updateArray<T>(
+    array: T[],
+    updateCallback: (item: T, index?: number) => T,
+    itemFilter?: (item: T, index?: number) => boolean,
+    removeFilter?: (item: T, index?: number) => boolean
 ) : T[];

package/src/data/ops/updateArray.js

@@ -1,24 +1,24 @@
-export function updateArray(array, updateCallback, itemFilter, removeFilter) {
-   
-   if (!array)
-      return array;
-   
-   let newArray = [];
-   let dirty = false;
-   
-   for (let index = 0; index < array.length; index++) {
-      let item = array[index];
-      if (removeFilter && removeFilter(item, index)) {
-         dirty = true;
-         continue;
-      }
-      if (!itemFilter || itemFilter(item, index)) {
-         let newItem = updateCallback(item, index);
-         newArray.push(newItem);
-         if (newItem !== item)
-            dirty = true;
-      } else
-         newArray.push(item);
-   }
-   return dirty ? newArray : array;
-}
+export function updateArray(array, updateCallback, itemFilter, removeFilter) {
+   
+   if (!array)
+      return array;
+   
+   let newArray = [];
+   let dirty = false;
+   
+   for (let index = 0; index < array.length; index++) {
+      let item = array[index];
+      if (removeFilter && removeFilter(item, index)) {
+         dirty = true;
+         continue;
+      }
+      if (!itemFilter || itemFilter(item, index)) {
+         let newItem = updateCallback(item, index);
+         newArray.push(newItem);
+         if (newItem !== item)
+            dirty = true;
+      } else
+         newArray.push(item);
+   }
+   return dirty ? newArray : array;
+}

package/src/data/ops/updateArray.spec.js

@@ -1,38 +1,38 @@
-import {Store} from '../Store';
-import {updateArray} from './updateArray';
-import assert from 'assert';
-
-describe('updateArray', function() {
-   it('updates all elements that satisfy criteria', function () {
-      let store = new Store({
-         data: {array: [1, 2, 3, 4, 5, 6]}
-      });
-
-      assert(store.update('array', updateArray, x => x + 1, x => x > 3));
-      assert.deepEqual(store.get('array'), [1, 2, 3, 5, 6, 7]);
-   });
-
-   it('does not modify data if not necessary', function () {
-      let array = [1, 2, 3, 4, 5, 6];
-      let store = new Store({
-         data: {array}
-      });
-
-      assert(false === store.update('array', updateArray, x => x + 1, x => x > 10));
-      assert(store.get('array') === array);
-   });
-
-   it('works with null or undefined', function () {
-      let store = new Store();
-      assert(false === store.update('array', updateArray, x => x + 1, x => x > 0));
-   });
-
-   it('can remove elements given the criteria', function () {
-      let store = new Store({
-         data: {array: [1, 2, 3, 4, 5, 6]}
-      });
-
-      assert(store.update('array', updateArray, x => x + 1, x => x > 3, x => x <= 3));
-      assert.deepEqual(store.get('array'), [5, 6, 7]);
-   });
-});
+import {Store} from '../Store';
+import {updateArray} from './updateArray';
+import assert from 'assert';
+
+describe('updateArray', function() {
+   it('updates all elements that satisfy criteria', function () {
+      let store = new Store({
+         data: {array: [1, 2, 3, 4, 5, 6]}
+      });
+
+      assert(store.update('array', updateArray, x => x + 1, x => x > 3));
+      assert.deepEqual(store.get('array'), [1, 2, 3, 5, 6, 7]);
+   });
+
+   it('does not modify data if not necessary', function () {
+      let array = [1, 2, 3, 4, 5, 6];
+      let store = new Store({
+         data: {array}
+      });
+
+      assert(false === store.update('array', updateArray, x => x + 1, x => x > 10));
+      assert(store.get('array') === array);
+   });
+
+   it('works with null or undefined', function () {
+      let store = new Store();
+      assert(false === store.update('array', updateArray, x => x + 1, x => x > 0));
+   });
+
+   it('can remove elements given the criteria', function () {
+      let store = new Store({
+         data: {array: [1, 2, 3, 4, 5, 6]}
+      });
+
+      assert(store.update('array', updateArray, x => x + 1, x => x > 3, x => x <= 3));
+      assert.deepEqual(store.get('array'), [5, 6, 7]);
+   });
+});

package/src/data/ops/updateTree.d.ts

@@ -1,7 +1,7 @@
-export function updateTree(
-   array: Cx.Record[],
-   updateCallback: (item?: Cx.Record, index?: number) => Cx.Record,
-   itemFilter?: (item?: Cx.Record, index?: number) => boolean,
-   childrenField?: string,
-   removeFilter?: (item?: Cx.Record, index?: number) => boolean
-): Cx.Record[];
+export function updateTree(
+   array: Cx.Record[],
+   updateCallback: (item?: Cx.Record, index?: number) => Cx.Record,
+   itemFilter?: (item?: Cx.Record, index?: number) => boolean,
+   childrenField?: string,
+   removeFilter?: (item?: Cx.Record, index?: number) => boolean
+): Cx.Record[];

package/src/data/ops/updateTree.js

@@ -1,25 +1,25 @@
-import {updateArray} from './updateArray';
-
-export function updateTree(array, updateCallback, itemFilter, childrenField, removeFilter) {
-   return updateArray(array, item => {
-      if (!itemFilter || itemFilter(item))
-         item = updateCallback(item);
-
-      let children = item[childrenField];
-      if (!Array.isArray(children))
-         return item;
-
-      let updatedChildren = updateTree(
-         children,
-         updateCallback,
-         itemFilter,
-         childrenField,
-         removeFilter
-      );
-
-      if (updatedChildren != children)
-         return { ...item, [childrenField]: updatedChildren };
-
-      return item;
-   }, null, removeFilter);
-}
+import {updateArray} from './updateArray';
+
+export function updateTree(array, updateCallback, itemFilter, childrenField, removeFilter) {
+   return updateArray(array, item => {
+      if (!itemFilter || itemFilter(item))
+         item = updateCallback(item);
+
+      let children = item[childrenField];
+      if (!Array.isArray(children))
+         return item;
+
+      let updatedChildren = updateTree(
+         children,
+         updateCallback,
+         itemFilter,
+         childrenField,
+         removeFilter
+      );
+
+      if (updatedChildren != children)
+         return { ...item, [childrenField]: updatedChildren };
+
+      return item;
+   }, null, removeFilter);
+}

package/src/data/ops/updateTree.spec.js

@@ -1,34 +1,34 @@
-import {Store} from '../Store';
-import {updateTree} from './updateTree';
-import assert from 'assert';
-
-describe('updateTree', function() {
-   it('updates all nodes that satisfy criteria', function () {
-      let store = new Store({
-         data: {array: [{
-            id: 'n1',
-            value: 1,
-            children: [{
-               id: 'n11',
-               value: 2
-            }, {
-               id: 'n12',
-               value: 3
-            }]
-         }]}
-      });
-
-      assert(store.update('array', updateTree, x => ({ ...x, value: x.value + 1}), x => x.value > 1, 'children'));
-      assert.deepEqual(store.get('array'), [{
-         id: 'n1',
-         value: 1,
-         children: [{
-            id: 'n11',
-            value: 3
-         }, {
-            id: 'n12',
-            value: 4
-         }]
-      }]);
-   });
-});
+import {Store} from '../Store';
+import {updateTree} from './updateTree';
+import assert from 'assert';
+
+describe('updateTree', function() {
+   it('updates all nodes that satisfy criteria', function () {
+      let store = new Store({
+         data: {array: [{
+            id: 'n1',
+            value: 1,
+            children: [{
+               id: 'n11',
+               value: 2
+            }, {
+               id: 'n12',
+               value: 3
+            }]
+         }]}
+      });
+
+      assert(store.update('array', updateTree, x => ({ ...x, value: x.value + 1}), x => x.value > 1, 'children'));
+      assert.deepEqual(store.get('array'), [{
+         id: 'n1',
+         value: 1,
+         children: [{
+            id: 'n11',
+            value: 3
+         }, {
+            id: 'n12',
+            value: 4
+         }]
+      }]);
+   });
+});