cx 25.10.1 → 26.0.1

package/src/data/ZoomIntoPropertyView.js

@@ -1,33 +0,0 @@
-import { Binding } from "./Binding";
-import { NestedDataView } from "./NestedDataView";
-
-export class ZoomIntoPropertyView extends NestedDataView {
-   getBaseData(parentStoreData) {
-      let x = this.binding.value(parentStoreData);
-      if (x != null && typeof x != "object") throw new Error("Zoomed value must be an object.");
-      return {
-         ...x,
-      };
-   }
-
-   embedAugmentData(result, parentStoreData) {
-      result[this.rootName] = parentStoreData;
-      super.embedAugmentData(result, parentStoreData);
-   }
-
-   setItem(path, value) {
-      if (path.indexOf(this.rootName + ".") == 0) this.store.setItem(path.substring(this.rootName.length + 1), value);
-      else if (this.isExtraKey(Binding.get(path).parts[0]))
-         super.setItem(path, value);
-      else super.setItem(this.binding.path + "." + path, value);
-   }
-
-   deleteItem(path) {
-      if (path.indexOf(this.rootName + ".") == 0) this.store.deleteItem(path.substring(this.rootName.length + 1));
-      else if (this.isExtraKey(Binding.get(path).parts[0]))
-         super.deleteItem(path);
-      else super.deleteItem(this.binding.path + "." + path);
-   }
-}
-
-ZoomIntoPropertyView.prototype.rootName = "$root";

package/src/data/ZoomIntoPropertyView.spec.js

@@ -1,65 +0,0 @@
-import assert from 'assert';
-
-import {Binding} from './Binding';
-import {Store} from './Store';
-import {ZoomIntoPropertyView} from './ZoomIntoPropertyView';
-
-describe('ZoomIntoPropertyView', () => {
-
-   const getZoom = () => {
-      let store = new Store({
-         data: {
-            a: 3,
-            item: {
-               firstName: 'Jack'
-            }
-         }
-      });
-
-      return new ZoomIntoPropertyView({
-         store: store,
-         binding: Binding.get('item')
-      });
-   };
-
-   it('allows direct access to properties of zoomed object', ()=> {
-      let zoom = getZoom();
-      assert.equal(zoom.get('firstName'), 'Jack');
-   });
-
-   it('allows access to outside data through $root', ()=> {
-      let zoom = getZoom();
-      assert.equal(zoom.get('$root.a'), 3);
-   });
-
-   it('correctly sets zoomed object', ()=> {
-      let zoom = getZoom();
-      zoom.set('firstName', 'Joe');
-      assert.equal(zoom.get('firstName'), 'Joe');
-   });
-
-   it('correctly sets zoomed values', ()=> {
-      let zoom = getZoom();
-      zoom.set('firstName', 'Joe');
-      assert.equal(zoom.get('firstName'), 'Joe');
-      assert.equal(zoom.get('$root.item.firstName'), 'Joe');
-   });
-
-   it('correctly sets outside values', ()=> {
-      let zoom = getZoom();
-      zoom.set('$root.a', 6);
-      assert.equal(zoom.get('$root.a'), 6);
-   });
-
-   it('correctly deletes zoomed values', ()=> {
-      let zoom = getZoom();
-      zoom.delete('firstName');
-      assert.equal(zoom.get('firstName'), undefined);
-   });
-
-   it('correctly deletes outside values', ()=> {
-      let zoom = getZoom();
-      zoom.delete('$root.a');
-      assert.equal(zoom.get('$root.a'), undefined);
-   });
-});

package/src/data/comparer.d.ts

@@ -1,7 +0,0 @@
-import {Sorter} from '../core';
-
-export function getComparer(sorters: Sorter[], dataAccessor?: (any) => any, compare?: (a: any, b: any) => number) : (a: any, b: any) => number;
-
-export function indexSorter(sorters: Sorter[], dataAccessor?: (any) => any, compare?: (a: any, b: any) => number) : (data: any[]) => number[];
-
-export function sorter(sorters: Sorter[], dataAccessor?: (any) => any, compare?: (a: any, b: any) => number) : (data: any[]) => any[];

package/src/data/comparer.js

@@ -1,54 +0,0 @@
-import { getSelector } from "./getSelector";
-import { isDefined } from "../util/isDefined";
-import { defaultCompare } from "./defaultCompare";
-
-export function getComparer(sorters, dataAccessor, comparer) {
-   let resolvedSorters = (sorters || []).map((s) => {
-      let selector = isDefined(s.value) ? getSelector(s.value) : s.field ? (x) => x[s.field] : () => null;
-      return {
-         getter: dataAccessor ? (x) => selector(dataAccessor(x)) : selector,
-         factor: s.direction && s.direction[0].toLowerCase() == "d" ? -1 : 1,
-         compare: s.comparer || s.compare || comparer || defaultCompare,
-      };
-   });
-
-   return function (a, b) {
-      let d, av, bv;
-      for (let i = 0; i < resolvedSorters.length; i++) {
-         d = resolvedSorters[i];
-         av = d.getter(a);
-         bv = d.getter(b);
-
-         // show nulls always on the bottom
-         if (av == null) {
-            if (bv == null) continue;
-            else return 1;
-         }
-         if (bv == null) return -1;
-
-         let r = d.compare(av, bv);
-         if (r == 0) continue;
-         return d.factor * r;
-      }
-      return 0;
-   };
-}
-
-export function indexSorter(sorters, dataAccessor, compare) {
-   let cmp = getComparer(sorters, dataAccessor, compare);
-   return function (data) {
-      let result = Array.from({ length: data.length }, (v, k) => k);
-      result.sort((ia, ib) => cmp(data[ia], data[ib]));
-      return result;
-   };
-}
-
-export function sorter(sorters, dataAccessor, compare) {
-   let cmp = getComparer(sorters, dataAccessor, compare);
-
-   return function (data) {
-      let result = [...data];
-      result.sort(cmp);
-      return result;
-   };
-}

package/src/data/computable.d.ts

@@ -1,125 +0,0 @@
-import { AccessorChain, Record } from "../core";
-
-interface Computable<V = any> {
-   (data: Record): V;
-   memoize(warmupData?: Record): (data: Record) => any;
-}
-
-export function computable(callback: () => any): Computable;
-export function computable(p1: string, computeFn: (v1: any) => any): Computable;
-export function computable(p1: string, p2: string, computeFn: (v1: any, v2: any) => any): Computable;
-export function computable(
-   p1: string,
-   p2: string,
-   p3: string,
-   computeFn: (v1: any, v2: any, v3: any) => any
-): Computable;
-export function computable(
-   p1: string,
-   p2: string,
-   p3: string,
-   p4: string,
-   computeFn: (v1: any, v2: any, v3: any, v4: any) => any
-): Computable;
-export function computable(
-   p1: string,
-   p2: string,
-   p3: string,
-   p4: string,
-   p5: string,
-   computeFn: (v1: any, v2: any, v3: any, v4: any, v5: any) => any
-): Computable;
-export function computable(
-   p1: string,
-   p2: string,
-   p3: string,
-   p4: string,
-   p5: string,
-   p6: string,
-   computeFn: (v1: any, v2: any, v3: any, v4: any, v5: any, v6: any) => any
-): Computable;
-export function computable(
-   p1: string,
-   p2: string,
-   p3: string,
-   p4: string,
-   p5: string,
-   p6: string,
-   p7: string,
-   computeFn: (v1: any, v2: any, v3: any, v4: any, v5: any, v6: any, v7: any) => any
-): Computable;
-export function computable(
-   p1: string,
-   p2: string,
-   p3: string,
-   p4: string,
-   p5: string,
-   p6: string,
-   p7: string,
-   p8: string,
-   computeFn: (v1: any, v2: any, v3: any, v4: any, v5: any, v6: any, v7: any, v8: any) => any
-): Computable;
-
-export function computable<V1, R>(arg1: AccessorChain<V1>, compute: (v1: V1) => R): Computable<R>;
-export function computable<V1, V2, R>(
-   arg1: AccessorChain<V1>,
-   arg2: AccessorChain<V2>,
-   compute: (v1: V1, v2: V2) => R
-): Computable<R>;
-
-export function computable<V1, V2, V3, R>(
-   arg1: AccessorChain<V1>,
-   arg2: AccessorChain<V2>,
-   arg3: AccessorChain<V3>,
-   compute: (v1: V1, v2: V2, v3: V3) => R
-): Computable<R>;
-
-export function computable<V1, V2, V3, V4, R>(
-   arg1: AccessorChain<V1>,
-   arg2: AccessorChain<V2>,
-   arg3: AccessorChain<V3>,
-   arg4: AccessorChain<V4>,
-   compute: (v1: V1, v2: V2, v3: V3, v4: V4) => R
-): Computable<R>;
-
-export function computable<V1, V2, V3, V4, V5, R>(
-   arg1: AccessorChain<V1>,
-   arg2: AccessorChain<V2>,
-   arg3: AccessorChain<V3>,
-   arg4: AccessorChain<V4>,
-   arg5: AccessorChain<V5>,
-   compute: (v1: V1, v2: V2, v3: V3, v4: V4, v5: V5) => R
-): Computable<R>;
-
-export function computable<V1, V2, V3, V4, V5, V6, R>(
-   arg1: AccessorChain<V1>,
-   arg2: AccessorChain<V2>,
-   arg3: AccessorChain<V3>,
-   arg4: AccessorChain<V4>,
-   arg5: AccessorChain<V5>,
-   arg6: AccessorChain<V6>,
-   compute: (v1: V1, v2: V2, v3: V3, v4: V4, v5: V5, v6: V6) => R
-): Computable<R>;
-
-export function computable<V1, V2, V3, V4, V5, V6, V7, R>(
-   arg1: AccessorChain<V1>,
-   arg2: AccessorChain<V2>,
-   arg3: AccessorChain<V3>,
-   arg4: AccessorChain<V4>,
-   arg5: AccessorChain<V5>,
-   arg6: AccessorChain<V6>,
-   arg7: AccessorChain<V7>,
-   compute: (v1: V1, v2: V2, v3: V3, v4: V4, v5: V5, v6: V6, v7: V7) => R
-): Computable<R>;
-
-export function computable<V1, V2, V3, V4, V5, V6, V7, V8, R>(
-   arg1: AccessorChain<V1>,
-   arg2: AccessorChain<V2>,
-   arg3: AccessorChain<V3>,
-   arg4: AccessorChain<V4>,
-   arg5: AccessorChain<V5>,
-   arg6: AccessorChain<V6>,
-   arg7: AccessorChain<V7>,
-   arg8: AccessorChain<V8>,
-   compute: (v1: V1, v2: V2, v3: V3, v4: V4, v5: V5, v6: V6, v7: V7, v8: V8) => R
-): Computable<R>;

package/src/data/computable.js

@@ -1,56 +0,0 @@
-import { Binding } from "./Binding";
-import { isString } from "../util/isString";
-import { isFunction } from "../util/isFunction";
-import { isAccessorChain } from "./createAccessorModelProxy";
-
-export function computable(...selectorsAndCompute) {
-   if (selectorsAndCompute.length == 0)
-      throw new Error("computable requires at least a compute function to be passed in arguments.");
-
-   let compute = selectorsAndCompute[selectorsAndCompute.length - 1];
-   if (typeof compute != "function") throw new Error("Last argument to the computable function should be a function.");
-
-   let inputs = [],
-      a;
-
-   for (let i = 0; i + 1 < selectorsAndCompute.length; i++) {
-      a = selectorsAndCompute[i];
-      if (isString(a) || isAccessorChain(a)) inputs.push(Binding.get(a.toString()).value);
-      else if (a.memoize) inputs.push(a.memoize());
-      else if (isFunction(a)) inputs.push(a);
-      else throw new Error(`Invalid selector type '${typeof a}' received.`);
-   }
-
-   function memoize(warmupData) {
-      let lastValue,
-         lastArgs = warmupData && inputs.map((s) => s(warmupData));
-
-      return function (data) {
-         let dirty = false;
-
-         if (!lastArgs) {
-            lastArgs = Array.from({ length: inputs.length });
-            dirty = true;
-         }
-
-         for (let i = 0; i < inputs.length; i++) {
-            let v = inputs[i](data);
-            if (v === lastArgs[i]) continue;
-            lastArgs[i] = v;
-            dirty = true;
-         }
-
-         if (dirty) lastValue = compute.apply(null, lastArgs);
-
-         return lastValue;
-      };
-   }
-
-   let selector = (data) =>
-      compute.apply(
-         null,
-         inputs.map((s) => s(data))
-      );
-   selector.memoize = memoize;
-   return selector;
-}

package/src/data/computable.spec.js

@@ -1,55 +0,0 @@
-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 +0,0 @@
-import { AccessorChain } from "../core";
-
-export function isAccessorChain(value: any): boolean;
-export function isAccessorChain<V>(value: any): value is AccessorChain<V>;
-
-export function createAccessorModelProxy<M>(basePath: string = ""): AccessorChain<M>;

package/src/data/createAccessorModelProxy.js

@@ -1,43 +0,0 @@
-const emptyFn = () => {};
-
-export function createAccessorModelProxy(chain = "") {
-   let lastOp = null;
-
-   const proxy = new Proxy(emptyFn, {
-      get: (_, name) => {
-         if (typeof name !== "string") return proxy;
-
-         switch (name) {
-            case "isAccessorChain":
-               return true;
-
-            case "toString":
-            case "valueOf":
-            case "nameOf":
-               lastOp = name;
-               return proxy;
-         }
-
-         let newChain = chain;
-         if (newChain.length > 0) newChain += ".";
-         newChain += name;
-         return createAccessorModelProxy(newChain);
-      },
-
-      apply() {
-         switch (lastOp) {
-            case "nameOf":
-               const lastDotIndex = chain.lastIndexOf(".");
-               return lastDotIndex > 0 ? chain.substring(lastDotIndex + 1) : chain;
-
-            default:
-               return chain;
-         }
-      },
-   });
-   return proxy;
-}
-
-export function isAccessorChain(value) {
-   return value != null && !!value.isAccessorChain;
-}

package/src/data/createStructuredSelector.d.ts

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

package/src/data/createStructuredSelector.js

@@ -1,43 +0,0 @@
-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 +0,0 @@
-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.d.ts

@@ -1 +0,0 @@
-export function defaultCompare(av, bv) : number;

package/src/data/defaultCompare.js

@@ -1,15 +0,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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-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 +0,0 @@
-export * from './diffArrays';

package/src/data/diff/index.js

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

package/src/data/enableFatArrowExpansion.d.ts

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