cx 24.4.0 → 24.4.2

package/src/data/isSelector.js

@@ -1,26 +1,26 @@
-export function isSelector(config) {
-
-   if (config == null)
-      return true;
-
-   switch (typeof config) {
-      case 'object':
-         if (config.type || config.$type)
-            return false;
-         return !!(config.bind || config.tpl || config.expr || config.get);
-
-      case 'function':
-         return true;
-
-      case 'string':
-         return true;
-
-      case 'number':
-         return true;
-
-      case 'boolean':
-         return true;
-   }
-
-   return false;
-}
+export function isSelector(config) {
+
+   if (config == null)
+      return true;
+
+   switch (typeof config) {
+      case 'object':
+         if (config.type || config.$type)
+            return false;
+         return !!(config.bind || config.tpl || config.expr || config.get);
+
+      case 'function':
+         return true;
+
+      case 'string':
+         return true;
+
+      case 'number':
+         return true;
+
+      case 'boolean':
+         return true;
+   }
+
+   return false;
+}

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

@@ -1 +1 @@
-export function append<T = any>(array: T[], ...items: T[]): T[];
+export function append<T = any>(array: T[], ...items: T[]): T[];

package/src/data/ops/append.js

@@ -1,7 +1,7 @@
-export function append(array, ...items) {
-   if (items.length == 0)
-      return array;
-   if (!array)
-      return items;
-   return [...array, ...items];
-}
+export function append(array, ...items) {
+   if (items.length == 0)
+      return array;
+   if (!array)
+      return items;
+   return [...array, ...items];
+}

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

@@ -1,28 +1,28 @@
-import {Store} from '../Store';
-import {append} from './append';
-import assert from 'assert';
-
-describe('append', function() {
-   it('should add elements to an array', function () {
-      let store = new Store({
-         data: {
-            array: []
-         }
-      });
-
-      assert(store.update('array', append, 1));
-      assert.deepEqual(store.get('array'), [1]);
-   });
-
-   it('should work with undefined arrays', function () {
-      let store = new Store();
-      assert(store.update('array', append, 1));
-      assert.deepEqual(store.get('array'), [1]);
-   });
-
-   it('accepts multiple arguments', function () {
-      let store = new Store();
-      assert(store.update('array', append, 1, 2, 3));
-      assert.deepEqual(store.get('array'), [1, 2, 3]);
-   });
-});
+import {Store} from '../Store';
+import {append} from './append';
+import assert from 'assert';
+
+describe('append', function() {
+   it('should add elements to an array', function () {
+      let store = new Store({
+         data: {
+            array: []
+         }
+      });
+
+      assert(store.update('array', append, 1));
+      assert.deepEqual(store.get('array'), [1]);
+   });
+
+   it('should work with undefined arrays', function () {
+      let store = new Store();
+      assert(store.update('array', append, 1));
+      assert.deepEqual(store.get('array'), [1]);
+   });
+
+   it('accepts multiple arguments', function () {
+      let store = new Store();
+      assert(store.update('array', append, 1, 2, 3));
+      assert.deepEqual(store.get('array'), [1, 2, 3]);
+   });
+});

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

@@ -1 +1 @@
-export function filter<T = any>(array: T[], callback: (item: T, index: number, array: T[]) => boolean): T[];
+export function filter<T = any>(array: T[], callback: (item: T, index: number, array: T[]) => boolean): T[];

package/src/data/ops/filter.js

@@ -1,8 +1,8 @@
-export function filter(array, callback) {
-   if (array == null)
-      return array;
-   let result = array.filter(callback);
-   if (result.length == array.length)
-      return array;
-   return result;
-}
+export function filter(array, callback) {
+   if (array == null)
+      return array;
+   let result = array.filter(callback);
+   if (result.length == array.length)
+      return array;
+   return result;
+}

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.d.ts

@@ -1 +1 @@
-export function findTreeNode<T = any>(array: T[], criteria: (item?: T) => boolean, childrenField?: string): T | false;
+export function findTreeNode<T = any>(array: T[], criteria: (item?: T) => boolean, childrenField?: string): T | false;

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/findTreePath.d.ts

@@ -1,6 +1,6 @@
-export function findTreePath<T>(
-   array: T[],
-   criteria: (item: T) => boolean,
-   childrenField = "$children",
-   currentPath: T[] = []
-): T[] | false;
+export function findTreePath<T>(
+   array: T[],
+   criteria: (item: T) => boolean,
+   childrenField = "$children",
+   currentPath: T[] = []
+): T[] | false;

package/src/data/ops/findTreePath.js

@@ -1,16 +1,16 @@
-export function findTreePath(array, criteria, childrenField = "$children", currentPath = []) {
-   if (!Array.isArray(array)) return false;
-
-   for (let i = 0; i < array.length; i++) {
-      currentPath.push(array[i]);
-
-      if (criteria(array[i])) return currentPath;
-
-      let childPath = findTreePath(array[i][childrenField], criteria, childrenField, currentPath);
-      if (childPath) return childPath;
-
-      currentPath.pop();
-   }
-
-   return false;
-}
+export function findTreePath(array, criteria, childrenField = "$children", currentPath = []) {
+   if (!Array.isArray(array)) return false;
+
+   for (let i = 0; i < array.length; i++) {
+      currentPath.push(array[i]);
+
+      if (criteria(array[i])) return currentPath;
+
+      let childPath = findTreePath(array[i][childrenField], criteria, childrenField, currentPath);
+      if (childPath) return childPath;
+
+      currentPath.pop();
+   }
+
+   return false;
+}

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 "./findTreePath";
+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 "./findTreePath";

package/src/data/ops/index.js

@@ -1,11 +1,11 @@
-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 './findTreePath';
-
+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 './findTreePath';
+

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

@@ -1 +1 @@
-export function insertElement<T = any>(array: T[], index: number, ...args: T[]): T[];
+export function insertElement<T = any>(array: T[], index: number, ...args: T[]): T[];

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.d.ts

@@ -1 +1 @@
-export function moveElement<T>(array: T[], sourceIndex: number, targetIndex: number): T[];
+export function moveElement<T>(array: T[], sourceIndex: number, targetIndex: number): T[];

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,5 +1,5 @@
-export function removeTreeNodes<T = any>(
-   array: T[],
-   criteria: (item?: T, index?: number) => boolean,
-   childrenField?: string
-): T[];
+export function removeTreeNodes<T = any>(
+   array: T[],
+   criteria: (item?: T, index?: number) => boolean,
+   childrenField?: string
+): T[];

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[];