cx 25.11.1 → 26.0.1

package/src/data/StructuredSelector.js

@@ -1,132 +0,0 @@
-import { Binding } from "./Binding";
-import { Expression } from "./Expression";
-import { StringTemplate } from "./StringTemplate";
-import { createStructuredSelector } from "../data/createStructuredSelector";
-import { getSelector } from "../data/getSelector";
-import { isFunction } from "../util/isFunction";
-import { isUndefined } from "../util/isUndefined";
-import { isDefined } from "../util/isDefined";
-import { isArray } from "../util/isArray";
-import { isAccessorChain } from "./createAccessorModelProxy";
-import { isString } from "../util/isString";
-
-function defaultValue(pv) {
-   if (typeof pv == "object" && pv && pv.structured) return pv.defaultValue;
-
-   return pv;
-}
-
-function getSelectorConfig(props, values, nameMap) {
-   let functions = {},
-      structures = {},
-      defaultValues = {},
-      constants,
-      p,
-      v,
-      pv,
-      constant = true;
-
-   for (p in props) {
-      v = values[p];
-      pv = props[p];
-
-      if (isUndefined(v) && pv && (pv.bind || pv.tpl || pv.expr)) v = pv;
-
-      if (v === null) {
-         if (!constants) constants = {};
-         constants[p] = null;
-      } else if (typeof v == "object") {
-         if (v.bind) {
-            if (isUndefined(v.defaultValue) && v != pv) v.defaultValue = defaultValue(pv);
-            if (isDefined(v.defaultValue)) defaultValues[v.bind] = v.defaultValue;
-            nameMap[p] = v.bind;
-            functions[p] = Binding.get(v.bind).value;
-            constant = false;
-         } else if (v.expr) {
-            functions[p] = Expression.get(v.expr);
-            constant = false;
-         } else if (v.get) {
-            functions[p] = v.get;
-            constant = false;
-         } else if (isString(v.tpl)) {
-            functions[p] = StringTemplate.get(v.tpl);
-            constant = false;
-         } else if (pv && typeof pv == "object" && pv.structured) {
-            if (isArray(v)) functions[p] = getSelector(v);
-            else {
-               let s = getSelectorConfig(v, v, {});
-               structures[p] = s;
-               Object.assign(defaultValues, s.defaultValues);
-            }
-            constant = false;
-         } else {
-            if (!constants) constants = {};
-            constants[p] = v;
-         }
-      } else if (isFunction(v)) {
-         if (isAccessorChain(v)) {
-            let path = v.toString();
-            nameMap[p] = path;
-            functions[p] = Binding.get(path).value;
-         } else functions[p] = v;
-         constant = false;
-      } else {
-         if (isUndefined(v)) {
-            if (isUndefined(pv)) continue;
-            v = defaultValue(pv);
-         }
-
-         if (isUndefined(v)) continue;
-
-         if (!constants) constants = {};
-
-         constants[p] = v;
-      }
-   }
-
-   return {
-      functions,
-      structures,
-      defaultValues,
-      constants,
-      constant,
-   };
-}
-
-function createSelector({ functions, structures, constants, defaultValues }) {
-   let selector = {};
-
-   for (let n in functions) {
-      selector[n] = functions[n];
-   }
-
-   for (let n in structures) selector[n] = createSelector(structures[n]);
-
-   return createStructuredSelector(selector, constants);
-}
-
-export class StructuredSelector {
-   constructor({ props, values }) {
-      this.nameMap = {};
-      this.config = getSelectorConfig(props, values, this.nameMap);
-   }
-
-   init(store) {
-      store.init(this.config.defaultValues);
-   }
-
-   create(memoize = true) {
-      let selector = createSelector(this.config);
-      if (memoize && selector.memoize) return selector.memoize();
-      return selector;
-   }
-
-   createStoreSelector() {
-      if (this.config.constant) {
-         let result = { ...this.config.constants };
-         return () => result;
-      }
-      let selector = this.create();
-      return (store) => selector(store.getData());
-   }
-}

package/src/data/StructuredSelector.spec.js

@@ -1,113 +0,0 @@
-import { StructuredSelector } from "./StructuredSelector";
-import assert from "assert";
-import { createAccessorModelProxy } from "./createAccessorModelProxy";
-
-describe("StructuredSelector", function () {
-   describe("#create()", function () {
-      it("constants", function () {
-         var x = {};
-         var s = new StructuredSelector({
-            props: {
-               a: undefined,
-               b: undefined,
-            },
-            values: {
-               a: 1,
-               b: 2,
-            },
-         }).create(x);
-
-         assert.deepEqual(s(x), { a: 1, b: 2 });
-      });
-
-      it("bindings", function () {
-         var x = { a: 1, b: 2 };
-         var s = new StructuredSelector({
-            props: {
-               a: undefined,
-               b: undefined,
-            },
-            values: {
-               a: { bind: "b" },
-               b: { bind: "a" },
-            },
-         }).create(x);
-
-         assert.deepEqual(s(x), { a: 2, b: 1 });
-      });
-
-      it("templates", function () {
-         var x = { a: 1, b: 2 };
-         var s = new StructuredSelector({
-            props: {
-               a: undefined,
-               b: undefined,
-            },
-            values: {
-               a: { tpl: "b{a}" },
-               b: { tpl: "a{b}" },
-            },
-         }).create(x);
-
-         assert.deepEqual(s(x), { a: "b1", b: "a2" });
-      });
-
-      it("structured", function () {
-         var x = { a: 1, b: 2 };
-         var s = new StructuredSelector({
-            props: {
-               a: {
-                  structured: true,
-               },
-               b: undefined,
-            },
-            values: {
-               a: {
-                  x: { expr: "{a} == 1" },
-                  y: { expr: "{b} == 1" },
-               },
-               b: { tpl: "a{b}" },
-            },
-         }).create(x);
-
-         assert.deepEqual(s(x), { a: { x: true, y: false }, b: "a2" });
-      });
-   });
-
-   it("structures do not change if data doesn't change", function () {
-      var x = { a: 1, b: 2 };
-      var s = new StructuredSelector({
-         props: {
-            a: {
-               structured: true,
-            },
-         },
-         values: {
-            a: {
-               x: { expr: "{a} == 1" },
-               y: { expr: "{b} == 1" },
-            },
-            b: { tpl: "a{b}" },
-         },
-      }).create(x);
-
-      let r1 = s(x);
-      let r2 = s(x);
-
-      assert.equal(r1, r2);
-   });
-
-   it("structures do not change if data doesn't change", function () {
-      var x = { a: { b: 2 } };
-      var m = createAccessorModelProxy();
-      var s = new StructuredSelector({
-         props: {
-            b: undefined,
-         },
-         values: {
-            b: m.a.b,
-         },
-      }).create(x);
-      assert.deepEqual(s(x), { b: 2 });
-   });
-});

package/src/data/SubscribableView.d.ts

@@ -1,11 +0,0 @@
-import {View, ViewConfig} from './View';
-
-
-
-export class SubscribableView extends View {
-   constructor(config?: ViewConfig);
-
-   unsubscribeAll(): void;
-
-   async: boolean;
-}

package/src/data/SubscribableView.js

@@ -1,54 +0,0 @@
-import { View } from "./View";
-import { SubscriberList } from "../util/SubscriberList";
-
-export class SubscribableView extends View {
-   constructor(config) {
-      super(config);
-      this.subscribers = new SubscriberList();
-      this.changes = [];
-   }
-
-   subscribe(callback) {
-      return this.subscribers.subscribe(callback);
-   }
-
-   unsubscribeAll() {
-      this.subscribers.clear();
-   }
-
-   doNotify(path) {
-      if (this.notificationsSuspended) return;
-
-      if (!this.async) {
-         this.subscribers.notify([path]);
-      } else {
-         this.changes.push(path || "");
-         if (!this.scheduled) {
-            this.scheduled = true;
-            setTimeout(() => {
-               this.scheduled = false;
-               let changes = this.changes;
-               this.changes = [];
-               this.subscribers.notify(changes);
-            }, 0);
-         }
-      }
-   }
-
-   silently(callback) {
-      this.notificationsSuspended = (this.notificationsSuspended || 0) + 1;
-      let wasDirty = this.dirty,
-         dirty;
-      this.dirty = false;
-      try {
-         callback(this);
-      } finally {
-         this.notificationsSuspended--;
-         dirty = this.dirty;
-         this.dirty = wasDirty;
-      }
-      return dirty;
-   }
-}
-
-SubscribableView.prototype.async = false;

package/src/data/View.d.ts

@@ -1,155 +0,0 @@
-import { AccessorChain } from "../core";
-import { Binding } from "./Binding";
-import { Ref } from "./Ref";
-
-declare type Path = string | Binding;
-
-export interface ViewConfig {
-   store?: View;
-
-   /* When set, the root data object of the parent store will be preserved (no virtual properties will be added), i.e. $record. */
-   immutable?: boolean;
-
-   /* When set, instructs the child views not to modify its data object (same effect as setting immutable on child stores). */
-   sealed?: boolean;
-}
-
-export interface ViewMethods<D = Record<string, any>> {
-   getData(): D;
-
-   init(path: Path, value: any): boolean;
-   init<V>(path: AccessorChain<V>, value: V): boolean;
-
-   set(path: Path, value: any): boolean;
-   set<T extends Record<string, any>>(changes: T): boolean;
-   set<V>(path: AccessorChain<V>, value: V): boolean;
-
-   get(path: Path): any;
-   get(paths: Path[]): any[];
-   get(...paths: Path[]): any[];
-   get<V>(path: AccessorChain<V>): V;
-   get<T extends any[]>(...paths: { [K in keyof T]: AccessorChain<T[K]> }): T;
-   get<T extends any[]>(paths: { [K in keyof T]: AccessorChain<T[K]> }): T;
-
-   /**
-    * Removes data from the Store.
-    * @param paths - One or more paths to be deleted.
-    * @return {boolean}
-    */
-   delete(path: Path): boolean;
-   delete(paths: Path[]): boolean;
-   delete(...paths: Path[]): boolean;
-   delete<V>(path: AccessorChain<V>): boolean;
-   delete<T extends any[]>(...paths: { [K in keyof T]: AccessorChain<T[K]> }): boolean;
-   delete<T extends any[]>(paths: { [K in keyof T]: AccessorChain<T[K]> }): boolean;
-
-   toggle(path: Path): boolean;
-
-   update(updateFn: (currentValue: D, ...args) => D, ...args): boolean;
-   update(path: Path, updateFn: (currentValue: any, ...args) => any, ...args): boolean;
-   update<V, A extends any[]>(
-      path: AccessorChain<V>,
-      updateFn: (currentValue: V, ...args: A) => V,
-      ...args: A
-   ): boolean;
-
-   /**
-    *  Mutates the content of the store using Immer
-    */
-   mutate(updateFn: (currentValue: D, ...args) => D, ...args): boolean;
-   mutate(path: Path, updateFn: (currentValue: any, ...args) => any, ...args): boolean;
-   mutate<V, A extends any[]>(
-      path: AccessorChain<V>,
-      updateFn: (currentValue: V, ...args: A) => void,
-      ...args: A
-   ): boolean;
-
-   ref<T = any>(path: string | AccessorChain<T>, defaultValue?: T): Ref<T>;
-}
-
-export class View<D = any> implements ViewMethods<D> {
-   constructor(config?: ViewConfig);
-
-   getData(): D;
-
-   init(path: Path, value: any): boolean;
-   init<V>(path: AccessorChain<V>, value: V): boolean;
-
-   set(path: Path, value: any): boolean;
-   set<T extends Record<string, any>>(changes: T): boolean;
-   set<V>(path: AccessorChain<V>, value: V): boolean;
-
-   /**
-    * Copies the value stored under the `from` path and saves it under the `to` path.
-    * @param from - Origin path.
-    * @param to - Destination path.
-    */
-   copy(from: Path, to: Path): boolean;
-   copy<V>(from: AccessorChain<V>, to: AccessorChain<V>): boolean;
-
-   move(from: Path, to: Path): boolean;
-   move<V>(from: AccessorChain<V>, to: AccessorChain<V>): boolean;
-
-   /**
-    * Removes data from the Store.
-    * @param paths - Any number or an array of paths to be deleted.
-    * @return {boolean}
-    */
-   delete(path: Path): boolean;
-   delete(paths: Path[]): boolean;
-   delete(...paths: Path[]): boolean;
-   delete<V>(path: AccessorChain<V>): boolean;
-   delete<T extends any[]>(...paths: { [K in keyof T]: AccessorChain<T[K]> }): boolean;
-   delete<T extends any[]>(paths: { [K in keyof T]: AccessorChain<T[K]> }): boolean;
-
-   clear(): void;
-
-   get(path: Path): any;
-   get(paths: Path[]): any;
-   get(...paths: Path[]): any;
-   get<V>(path: AccessorChain<V>): V;
-   get<T extends any[]>(...paths: { [K in keyof T]: AccessorChain<T[K]> }): T;
-   get<T extends any[]>(paths: { [K in keyof T]: AccessorChain<T[K]> }): T;
-
-   toggle(path: Path): boolean;
-   toggle(path: AccessorChain<boolean>): boolean;
-
-   update(updateFn: (currentValue: D, ...args) => any, ...args): boolean;
-   update(path: Path, updateFn: (currentValue: any, ...args) => any, ...args): boolean;
-   update<V, A extends any[]>(
-      path: AccessorChain<V>,
-      updateFn: (currentValue: V, ...args: A) => V,
-      ...args: A
-   ): boolean;
-
-   mutate(updateFn: (currentValue: D, ...args) => void, ...args): boolean;
-   mutate(path: Path, updateFn: (currentValue: any, ...args) => void, ...args): boolean;
-   mutate<V, A extends any[]>(
-      path: AccessorChain<V>,
-      updateFn: (currentValue: V, ...args: A) => void,
-      ...args: A
-   ): boolean;
-
-   /**
-    * `batch` method can be used to perform multiple Store operations silently
-    * and re-render the application only once afterwards. The Store instance
-    * is passed to the `callback` function.
-    * @param callback - Function that will perform multiple Store operations
-    * @return {boolean}
-    */
-   batch(callback: (store: View) => void): boolean;
-
-   silently(callback: () => void): boolean;
-
-   notify(path?: string): void;
-
-   subscribe(callback: (changes?) => void): () => void;
-
-   load(data: Record<string, any>): boolean;
-
-   dispatch(action): void;
-
-   getMethods(): ViewMethods;
-
-   ref<T = any>(path: string | AccessorChain<T>, defaultValue?: T): Ref<T>;
-}

package/src/data/View.js

@@ -1,182 +0,0 @@
-import { Binding } from "./Binding";
-import { isArray } from "../util/isArray";
-import { isDefined } from "../util/isDefined";
-import { StoreRef } from "./StoreRef";
-import { isObject } from "../util/isObject";
-import { isFunction } from "../util/isFunction";
-
-export class View {
-   constructor(config) {
-      Object.assign(this, config);
-      this.cache = {
-         version: -1,
-      };
-      if (this.store) this.setStore(this.store);
-   }
-
-   getData() {
-      throw new Error("abstract method");
-   }
-
-   init(path, value) {
-      if (typeof path == "object" && path != null) {
-         let changed = false;
-         for (let key in path)
-            if (path.hasOwnProperty(key) && this.get(key) === undefined && this.setItem(key, path[key])) changed = true;
-         return changed;
-      }
-      let binding = Binding.get(path);
-      if (this.get(binding.path) === undefined) return this.setItem(binding.path, value);
-      return false;
-   }
-
-   set(path, value) {
-      if (isObject(path)) {
-         let changed = false;
-         for (let key in path) if (path.hasOwnProperty(key) && this.setItem(key, path[key])) changed = true;
-         return changed;
-      }
-      let binding = Binding.get(path);
-      return this.setItem(binding.path, value);
-   }
-
-   copy(from, to) {
-      let value = this.get(from);
-      this.set(to, value);
-   }
-
-   move(from, to) {
-      this.batch(() => {
-         this.copy(from, to);
-         this.delete(from);
-      });
-   }
-
-   //protected
-   setItem(path, value) {
-      if (this.store) return this.store.setItem(path, value);
-      throw new Error("abstract method");
-   }
-
-   delete(path) {
-      if (arguments.length > 1) path = Array.from(arguments);
-      if (isArray(path)) return path.map((arg) => this.delete(arg)).some(Boolean);
-
-      let binding = Binding.get(path);
-      return this.deleteItem(binding.path);
-   }
-
-   //protected
-   deleteItem(path) {
-      if (this.store) return this.store.deleteItem(path);
-
-      throw new Error("abstract method");
-   }
-
-   clear() {
-      if (this.store) return this.store.clear();
-
-      throw new Error("abstract method");
-   }
-
-   get(path) {
-      let storeData = this.getData();
-
-      if (arguments.length > 1) path = Array.from(arguments);
-
-      if (isArray(path)) return path.map((arg) => Binding.get(arg).value(storeData));
-
-      return Binding.get(path).value(storeData);
-   }
-
-   toggle(path) {
-      return this.set(path, !this.get(path));
-   }
-
-   update(path, updateFn, ...args) {
-      if (arguments.length == 1 && isFunction(path))
-         return this.load(path.apply(null, [this.getData(), updateFn, ...args]));
-      return this.set(path, updateFn.apply(null, [this.get(path), ...args]));
-   }
-
-   batch(callback) {
-      let dirty = this.silently(callback);
-      if (dirty) this.notify();
-      return dirty;
-   }
-
-   silently(callback) {
-      if (this.store) return this.store.silently(callback);
-
-      throw new Error("abstract method");
-   }
-
-   notify(path) {
-      if (this.notificationsSuspended) this.dirty = true;
-      else this.doNotify(path);
-   }
-
-   doNotify(path) {
-      if (this.store) return this.store.notify(path);
-
-      throw new Error("abstract method");
-   }
-
-   subscribe(callback) {
-      if (this.store) return this.store.subscribe(callback);
-
-      throw new Error("abstract method");
-   }
-
-   load(data) {
-      return this.batch((store) => {
-         for (let key in data) store.set(key, data[key]);
-      });
-   }
-
-   dispatch(action) {
-      if (this.store) return this.store.dispatch(action);
-
-      throw new Error("The underlying store doesn't support dispatch.");
-   }
-
-   getMeta() {
-      return this.meta;
-   }
-
-   setStore(store) {
-      this.store = store;
-      this.meta = store.getMeta();
-   }
-
-   ref(path, defaultValue) {
-      if (isDefined(defaultValue)) this.init(path, defaultValue);
-      return StoreRef.create({
-         store: this,
-         path,
-      });
-   }
-
-   getMethods() {
-      return {
-         getData: this.getData.bind(this),
-         set: this.set.bind(this),
-         get: this.get.bind(this),
-         update: this.update.bind(this),
-         delete: this.delete.bind(this),
-         toggle: this.toggle.bind(this),
-         init: this.init.bind(this),
-         ref: this.ref.bind(this),
-         mutate: this.ref.bind(this),
-      };
-   }
-}
-
-View.prototype.sealed = false; //indicate that data should be copied before virtual items are added
-
-//Immer integration point
-View.prototype.mutate = function () {
-   throw new Error(
-      "Mutate requires Immer. Please install 'immer' and 'cx-immer' packages and enable store mutation by calling enableImmerMutate()."
-   );
-};

package/src/data/ZoomIntoPropertyView.d.ts

@@ -1,11 +0,0 @@
-import {View, ViewConfig} from './View';
-import {Binding} from './Binding';
-
-interface ZoomIntoPropertyViewConfig extends ViewConfig {
-   rootName?: string,
-   binding: Binding
-}
-
-export class ZoomIntoPropertyView extends View {
-   constructor(config?: ZoomIntoPropertyViewConfig);
-}

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";