r-state-tree 0.6.3 → 0.7.0

package/dist/r-state-tree.js

@@ -58,6 +58,140 @@ const modelType = {
   type: "model"
   /* model */
 };
+const computedType = {
+  type: "computed"
+  /* computed */
+};
+function makeDecorator(type) {
+  return function(value, context) {
+    context.metadata[context.name] = type;
+    return value;
+  };
+}
+function makeChildDecorator(typeObj) {
+  return function(valueOrChildType, context) {
+    if (context !== void 0) {
+      return makeDecorator(typeObj)(valueOrChildType, context);
+    }
+    const childCtor = valueOrChildType;
+    const typeWithCtor = typeObj(childCtor);
+    const decorator = function(value, context2) {
+      return makeDecorator(typeWithCtor)(value, context2);
+    };
+    decorator.type = typeWithCtor?.type;
+    decorator.childType = childCtor;
+    return decorator;
+  };
+}
+const child = makeChildDecorator(childType);
+const modelRef = makeChildDecorator(modelRefType);
+const model = makeDecorator(modelType);
+const id = makeDecorator(idType);
+const state = makeDecorator(stateType);
+function hasConfigLike(value) {
+  if (!value) return false;
+  const t = typeof value;
+  if (t !== "object" && t !== "function") return false;
+  return "type" in value;
+}
+function normalizeEntry(entry) {
+  if (!entry) return void 0;
+  if (hasConfigLike(entry)) return entry;
+  if (typeof entry === "function") {
+    if (entry === id) return idType;
+    if (entry === state) return stateType;
+    if (entry === model) return modelType;
+    if (entry === child) return childType;
+    if (entry === modelRef) return modelRefType;
+    return void 0;
+  }
+  return void 0;
+}
+function getConfigType(entry) {
+  const normalized = normalizeEntry(entry);
+  return normalized && hasConfigLike(normalized) ? normalized.type : void 0;
+}
+function getConfigChildType(entry) {
+  const normalized = normalizeEntry(entry);
+  if (!normalized || !hasConfigLike(normalized)) return void 0;
+  if (typeof normalized === "function") {
+    return normalized.childType;
+  }
+  return normalized.childType;
+}
+function getParentConstructor(Ctor) {
+  return Ctor?.prototype ? Object.getPrototypeOf(Ctor.prototype)?.constructor : void 0;
+}
+function getCtorChain(ctor) {
+  const chain = [];
+  let node = ctor;
+  while (node) {
+    chain.push(node);
+    const parent = getParentConstructor(node);
+    if (!parent || parent === Object || parent === Function) {
+      break;
+    }
+    node = parent;
+  }
+  chain.reverse();
+  return chain;
+}
+function getMetadataSymbol() {
+  const sym = Symbol.metadata;
+  return typeof sym === "symbol" ? sym : void 0;
+}
+function getOwnMetadata(ctor) {
+  const metadataSymbol = getMetadataSymbol();
+  if (!metadataSymbol) return void 0;
+  return Object.prototype.hasOwnProperty.call(ctor, metadataSymbol) ? ctor[metadataSymbol] : void 0;
+}
+function getOwnStaticTypes(ctor) {
+  return Object.prototype.hasOwnProperty.call(ctor, "types") ? ctor.types : void 0;
+}
+function mergeInto(target, source2) {
+  if (!source2 || typeof source2 !== "object") return;
+  for (const key of Reflect.ownKeys(source2)) {
+    const value = source2[key];
+    const normalized = normalizeEntry(value);
+    if (normalized) {
+      target[key] = normalized;
+    }
+  }
+}
+const configurationCache = /* @__PURE__ */ new WeakMap();
+function refsEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (a[i].ctor !== b[i].ctor) return false;
+    if (a[i].typesRef !== b[i].typesRef) return false;
+    if (a[i].metaRef !== b[i].metaRef) return false;
+  }
+  return true;
+}
+function getConfigurationForCtor(ctor) {
+  if (!ctor) return {};
+  const chain = getCtorChain(ctor);
+  const refs = chain.map((c) => ({
+    ctor: c,
+    typesRef: getOwnStaticTypes(c),
+    metaRef: getOwnMetadata(c)
+  }));
+  const cached = configurationCache.get(ctor);
+  if (cached && refsEqual(cached.refs, refs)) {
+    return cached.merged;
+  }
+  const merged = {};
+  for (let i = 0; i < refs.length; i++) {
+    const { typesRef, metaRef } = refs[i];
+    mergeInto(merged, metaRef);
+    mergeInto(merged, typesRef);
+  }
+  configurationCache.set(ctor, { refs, merged });
+  return merged;
+}
+function getConfigurationValue(ctor, key) {
+  return getConfigurationForCtor(ctor)[key];
+}
 function isNonPrimitive(val) {
   return val != null && (typeof val === "object" || typeof val === "function");
 }
@@ -74,10 +208,12 @@ function getPropertyType(key, obj) {
   if (plain) {
     return "observable";
   }
-  const metadata = obj.constructor[Symbol.metadata];
-  const config = metadata?.[key];
+  const config = getConfigurationValue(
+    obj.constructor,
+    key
+  );
   if (config) {
-    switch (config.type) {
+    switch (getConfigType(config)) {
       case ObservableCfgTypes.computed:
         return "computed";
       case ModelCfgTypes.state:
@@ -616,11 +752,12 @@ function signal(value) {
 }
 function computed(value, context) {
   if (context && typeof context === "object" && "kind" in context) {
-    context.metadata[context.name] = { type: "computed" };
+    context.metadata[context.name] = computedType;
     return value;
   }
   return internalCreateComputed(value).c;
 }
+computed.type = computedType.type;
 function source(obj) {
   return getSource(obj);
 }
@@ -1470,9 +1607,22 @@ function createFilterMethod(method) {
     function(callback, thisArg) {
       const adm = getAdministration(this);
       adm.reportObserved();
-      return adm.source[method]((_element, index) => {
-        return callback.call(thisArg, this[index], index, this);
-      });
+      const observedInput = [];
+      observedInput.length = adm.source.length;
+      const keys = Object.keys(adm.source);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const idx = Number(key);
+        if (!Number.isNaN(idx)) {
+          observedInput[idx] = this[idx];
+        }
+      }
+      return Array.prototype[method].call(
+        observedInput,
+        (_element, index) => {
+          return callback.call(thisArg, this[index], index, this);
+        }
+      );
     }
   );
 }
@@ -1480,7 +1630,22 @@ function createReduceMethod(method) {
   return createMethod(method, function() {
     const adm = getAdministration(this);
     adm.reportObserved();
-    return adm.source[method].apply(adm.source, arguments);
+    const observedInput = [];
+    observedInput.length = adm.source.length;
+    const keys = Object.keys(adm.source);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const idx = Number(key);
+      if (!Number.isNaN(idx)) {
+        observedInput[idx] = this[idx];
+      }
+    }
+    const args = Array.from(arguments);
+    const callback = args[0];
+    args[0] = (acc, _element, index) => {
+      return callback(acc, this[index], index, this);
+    };
+    return Array.prototype[method].apply(observedInput, args);
   });
 }
 class DateAdministration extends Administration {
@@ -1714,7 +1879,7 @@ function getDiff(o1, o2, getConfig) {
   for (let i = 0; i < keys.length; i++) {
     const key = keys[i];
     if (obj1[key] !== obj2[key]) {
-      if (config?.[key]?.type === CommonCfgTypes.child) {
+      if (getConfigType(config?.[key]) === CommonCfgTypes.child) {
         const value = obj2[key];
         if (Array.isArray(value)) {
           diff[key] = value.map((model2, index) => {
@@ -1823,7 +1988,7 @@ class StoreAdministration extends PreactObjectAdministration {
           return target.key;
         }
         const adm = getAdministration(target);
-        switch (adm.configuration[name]?.type) {
+        switch (getConfigType(adm.configuration[name])) {
           case CommonCfgTypes.child:
             return adm.getStore(name);
           case StoreCfgTypes.model:
@@ -1840,7 +2005,7 @@ class StoreAdministration extends PreactObjectAdministration {
         if (name === "props") {
           throw new Error(`r-state-tree: ${name} is read-only`);
         }
-        if (adm.configuration[name]?.type === StoreCfgTypes.model) {
+        if (getConfigType(adm.configuration[name]) === StoreCfgTypes.model) {
           if (value !== void 0) {
             throw new Error(`r-state-tree: model ${String(name)} is read-only`);
           }
@@ -2117,9 +2282,6 @@ function updateStore(store, props) {
   return store;
 }
 class Store {
-  static get types() {
-    return this[Symbol.metadata];
-  }
   props;
   constructor(props) {
     if (!initEnabled$1) {
@@ -2131,7 +2293,9 @@ class Store {
     );
     const adm = getStoreAdm(observable2);
     adm.setConfiguration(
-      () => this.constructor.types ?? {}
+      () => getConfigurationForCtor(
+        this.constructor
+      ) ?? {}
     );
     adm.write("props", getObservable({}));
     updateProps(observable2.props, props);
@@ -2367,8 +2531,9 @@ function getModelAdm(model2) {
 }
 function getIdKey(Ctor) {
   if (!ctorIdKeyMap.has(Ctor)) {
-    const key = Object.keys(Ctor.types).find(
-      (prop) => Ctor.types[prop].type === ModelCfgTypes.id
+    const config = getConfigurationForCtor(Ctor);
+    const key = Object.keys(config).find(
+      (prop) => config[prop]?.type === ModelCfgTypes.id
     ) ?? null;
     ctorIdKeyMap.set(Ctor, key);
   }
@@ -2417,6 +2582,12 @@ function validateModelChildValue(value, propertyName) {
   );
 }
 class ModelAdministration extends PreactObjectAdministration {
+  getCfgType(name) {
+    return getConfigType(this.configuration[name]);
+  }
+  getCfgChildType(name) {
+    return getConfigChildType(this.configuration[name]);
+  }
   static proxyTraps = Object.assign(
     {},
     PreactObjectAdministration.proxyTraps,
@@ -2426,7 +2597,7 @@ class ModelAdministration extends PreactObjectAdministration {
         if (prop === "parent") {
           return target.parent;
         }
-        switch (adm.configuration[prop]?.type) {
+        switch (adm.getCfgType(prop)) {
           case ModelCfgTypes.modelRef:
             if (Array.isArray(adm.source[prop])) {
               return adm.getModelRefs(prop);
@@ -2443,7 +2614,7 @@ class ModelAdministration extends PreactObjectAdministration {
         const adm = getAdministration(target);
         adm.writeInProgress.add(name);
         try {
-          switch (adm.configuration[name]?.type) {
+          switch (adm.getCfgType(name)) {
             case ModelCfgTypes.modelRef: {
               Array.isArray(value) ? adm.setModelRefs(name, value) : adm.setModelRef(name, value);
               return true;
@@ -2478,7 +2649,7 @@ class ModelAdministration extends PreactObjectAdministration {
       defineProperty(target, name, desc) {
         const adm = getAdministration(target);
         if (desc && "value" in desc && !adm.writeInProgress.has(name)) {
-          switch (adm.configuration[name]?.type) {
+          switch (adm.getCfgType(name)) {
             case ModelCfgTypes.modelRef:
             case CommonCfgTypes.child:
             case ModelCfgTypes.id: {
@@ -2542,6 +2713,39 @@ class ModelAdministration extends PreactObjectAdministration {
       });
     }
   }
+  hydrateStateValue(currentValue, snapshotValue) {
+    if (currentValue instanceof Signal) {
+      currentValue.value = this.hydrateStateValue(
+        currentValue.value,
+        snapshotValue
+      );
+      return currentValue;
+    }
+    if (Array.isArray(currentValue) && Array.isArray(snapshotValue)) {
+      const nextItems = snapshotValue.map(
+        (item, index) => this.hydrateStateValue(currentValue[index], item)
+      );
+      currentValue.splice(0, currentValue.length, ...nextItems);
+      return currentValue;
+    }
+    if (isPlainObject(currentValue) && isPlainObject(snapshotValue)) {
+      const currentRecord = currentValue;
+      const snapshotRecord = snapshotValue;
+      Object.keys(snapshotRecord).forEach((key) => {
+        currentRecord[key] = this.hydrateStateValue(
+          currentRecord[key],
+          snapshotRecord[key]
+        );
+      });
+      Object.keys(currentRecord).forEach((key) => {
+        if (!(key in snapshotRecord)) {
+          delete currentRecord[key];
+        }
+      });
+      return currentValue;
+    }
+    return snapshotValue;
+  }
   setId(name, v) {
     const id2 = getIdentifier(this.proxy);
     if (id2 === v) {
@@ -2732,7 +2936,7 @@ class ModelAdministration extends PreactObjectAdministration {
   }
   toJSON() {
     return Object.keys(this.configuration).reduce((json, key) => {
-      switch (this.configuration[key].type) {
+      switch (getConfigType(this.configuration[key])) {
         case ModelCfgTypes.state: {
           json[key] = clone(this.proxy[key], key);
           break;
@@ -2789,7 +2993,8 @@ class ModelAdministration extends PreactObjectAdministration {
   }
   loadSnapshot(snapshot) {
     const ensureChildTypes = (key) => {
-      if (!this.configuration[key].childType) {
+      const childType2 = this.getCfgChildType(key);
+      if (!childType2) {
         throw new Error(
           "r-state-tree: child constructor must be specified to load snapshots with child/children. eg: `@child(ChildCtor) MyChild`"
         );
@@ -2797,80 +3002,85 @@ class ModelAdministration extends PreactObjectAdministration {
       return true;
     };
     onSnapshotLoad(() => {
-      Object.keys(snapshot).forEach((key) => {
-        const { type, childType: childType2 } = this.configuration[key] ?? {};
-        const value = snapshot[key];
-        switch (type) {
-          case ModelCfgTypes.state:
-            this.proxy[key] = value;
-            break;
-          case ModelCfgTypes.modelRef:
-            if (Array.isArray(value)) {
-              if (value?.[0] instanceof Model) {
-                this.proxy[key] = value;
-              } else {
-                this.source[key] = value.map(
-                  (snapshot2) => getSnapshotRefId(snapshot2)
-                );
-                this.referencedAtoms?.get(key)?.reportChanged();
-              }
-              break;
-            } else if (value instanceof Model) {
-              this.proxy[key] = value;
-            } else {
-              this.source[key] = getSnapshotRefId(value);
-              this.referencedAtoms?.get(key)?.reportChanged();
-            }
-            break;
-          case ModelCfgTypes.id:
-            this.setId(key, value);
-            break;
-          case CommonCfgTypes.child:
-            let model2;
-            if (Array.isArray(value)) {
-              const Ctor = childType2;
-              this.proxy[key] = value?.map(
-                (snapshot2, index) => {
-                  snapshot2 = snapshot2 ?? {};
-                  let model22;
-                  if (snapshot2 instanceof Model) {
-                    model22 = snapshot2;
+      untracked(() => {
+        batch(() => {
+          Object.keys(snapshot).forEach((key) => {
+            const type = this.getCfgType(key);
+            const childType2 = this.getCfgChildType(key);
+            const value = snapshot[key];
+            switch (type) {
+              case ModelCfgTypes.state:
+                this.proxy[key] = this.hydrateStateValue(this.proxy[key], value);
+                break;
+              case ModelCfgTypes.modelRef:
+                if (Array.isArray(value)) {
+                  if (value?.[0] instanceof Model) {
+                    this.proxy[key] = value;
                   } else {
-                    ensureChildTypes(key);
-                    const id2 = childType2 && getSnapshotId(snapshot2, Ctor);
-                    const foundModel = id2 != null ? getModelById(this.root.proxy, id2) : this.proxy[key][index];
-                    const adm = foundModel && getModelAdm(foundModel);
-                    if (adm && foundModel.parent === this.proxy && adm?.parentName === key) {
-                      adm.loadSnapshot(snapshot2);
-                      model22 = foundModel;
-                    } else {
-                      model22 = Ctor.create(snapshot2);
+                    this.source[key] = value.map(
+                      (snapshot2) => getSnapshotRefId(snapshot2)
+                    );
+                    this.referencedAtoms?.get(key)?.reportChanged();
+                  }
+                  break;
+                } else if (value instanceof Model) {
+                  this.proxy[key] = value;
+                } else {
+                  this.source[key] = getSnapshotRefId(value);
+                  this.referencedAtoms?.get(key)?.reportChanged();
+                }
+                break;
+              case ModelCfgTypes.id:
+                this.setId(key, value);
+                break;
+              case CommonCfgTypes.child:
+                let model2;
+                if (Array.isArray(value)) {
+                  const Ctor = childType2;
+                  this.proxy[key] = value?.map(
+                    (snapshot2, index) => {
+                      snapshot2 = snapshot2 ?? {};
+                      let model22;
+                      if (snapshot2 instanceof Model) {
+                        model22 = snapshot2;
+                      } else {
+                        ensureChildTypes(key);
+                        const id2 = childType2 && getSnapshotId(snapshot2, Ctor);
+                        const foundModel = id2 != null ? getModelById(this.root.proxy, id2) : this.proxy[key][index];
+                        const adm = foundModel && getModelAdm(foundModel);
+                        if (adm && foundModel.parent === this.proxy && adm?.parentName === key) {
+                          adm.loadSnapshot(snapshot2);
+                          model22 = foundModel;
+                        } else {
+                          model22 = Ctor.create(snapshot2);
+                        }
+                      }
+                      return model22;
                     }
+                  );
+                  break;
+                } else if (value instanceof Model) {
+                  model2 = value;
+                } else {
+                  ensureChildTypes(key);
+                  const id2 = childType2 && getSnapshotId(value, childType2);
+                  if (id2 != null && this.proxy[key] && id2 === getIdentifier(this.proxy[key])) {
+                    const adm = getModelAdm(this.proxy[key]);
+                    adm.loadSnapshot(value);
+                    model2 = this.proxy[key];
+                  } else {
+                    model2 = childType2.create(value);
                   }
-                  return model22;
                 }
-              );
-              break;
-            } else if (value instanceof Model) {
-              model2 = value;
-            } else {
-              ensureChildTypes(key);
-              const id2 = childType2 && getSnapshotId(value, childType2);
-              if (id2 != null && this.proxy[key] && id2 === getIdentifier(this.proxy[key])) {
-                const adm = getModelAdm(this.proxy[key]);
-                adm.loadSnapshot(value);
-                model2 = this.proxy[key];
-              } else {
-                model2 = childType2.create(value);
-              }
+                this.proxy[key] = model2;
+                break;
+              default:
+                console.warn(
+                  `r-state-tree: invalid key '${key}' found in snapshot, ignored.`
+                );
             }
-            this.proxy[key] = model2;
-            break;
-          default:
-            console.warn(
-              `r-state-tree: invalid key '${key}' found in snapshot, ignored.`
-            );
-        }
+          });
+        });
       });
     });
   }
@@ -2887,9 +3097,6 @@ class ModelAdministration extends PreactObjectAdministration {
 }
 let initEnabled = false;
 class Model {
-  static get types() {
-    return this[Symbol.metadata];
-  }
   static childTypes = {};
   static create(snapshot, ...args) {
     let instance;
@@ -2916,7 +3123,9 @@ class Model {
     );
     const adm = getModelAdm(observable2);
     adm.setConfiguration(
-      () => this.constructor.types ?? {}
+      () => getConfigurationForCtor(
+        this.constructor
+      ) ?? {}
     );
     return observable2;
   }
@@ -3062,29 +3271,6 @@ function toObservableTreeInternal(value, ancestorPath, path) {
   }
   return value;
 }
-function makeDecorator(type) {
-  return function(value, context) {
-    context.metadata[context.name] = type;
-    return value;
-  };
-}
-function makeChildDecorator(typeObj) {
-  return function(valueOrChildType, context) {
-    if (context !== void 0) {
-      return makeDecorator(typeObj)(valueOrChildType, context);
-    }
-    const childCtor = valueOrChildType;
-    return function(value, context2) {
-      const typeWithCtor = typeObj(childCtor);
-      return makeDecorator(typeWithCtor)(value, context2);
-    };
-  };
-}
-const child = makeChildDecorator(childType);
-const modelRef = makeChildDecorator(modelRefType);
-const model = makeDecorator(modelType);
-const id = makeDecorator(idType);
-const state = makeDecorator(stateType);
 export {
   Model,
   Observable,

package/dist/store/Store.d.ts

@@ -9,7 +9,7 @@ export declare function createStore<K extends Store<any>, T extends Record<strin
 export declare function updateStore<K extends Store<T>, T extends Record<string, any>>(store: K, props: CreateStoreProps<T>): K;
 export declare function types<T extends Store>(config: Partial<StoreConfiguration<T>>): Partial<StoreConfiguration<T>>;
 export default class Store<PropsType extends Record<string, any> = StoreProps<Props>> {
-    static get types(): StoreConfiguration<unknown>;
+    static types?: StoreConfiguration<unknown>;
     props: StoreProps<PropsType>;
     constructor(props: StoreProps<PropsType>);
     get key(): string | number | undefined;

package/dist/types.d.ts

@@ -45,11 +45,12 @@ export declare enum ObservableCfgTypes {
     computed = "computed"
 }
 export type ConfigurationTypes = CommonCfgTypes | ModelCfgTypes | StoreCfgTypes | ObservableCfgTypes;
-export type ConfigurationType = {
+export type ConfigurationValue = {
     type: ConfigurationTypes;
     childType?: Function;
     [key: string]: unknown;
 };
+export type ConfigurationType = ConfigurationValue | Function;
 export type ModelConfiguration<T> = Record<PropertyKey, ConfigurationType>;
 export type StoreConfiguration<T> = Record<PropertyKey, ConfigurationType>;
 export type Configuration<T> = ModelConfiguration<T> | StoreConfiguration<T>;
@@ -69,14 +70,14 @@ export type RefSnapshot = {
     [key: string]: IdType;
     [key: number]: IdType;
 };
-export declare const childType: ((childType: Function) => ConfigurationType) & {
+export declare const childType: ((childType: Function) => ConfigurationValue) & {
     type: CommonCfgTypes;
 };
-export declare const stateType: ConfigurationType;
-export declare const modelRefType: ((childType: Function) => ConfigurationType) & {
+export declare const stateType: ConfigurationValue;
+export declare const modelRefType: ((childType: Function) => ConfigurationValue) & {
     type: ModelCfgTypes;
 };
-export declare const idType: ConfigurationType;
-export declare const modelType: ConfigurationType;
-export declare const computedType: ConfigurationType;
+export declare const idType: ConfigurationValue;
+export declare const modelType: ConfigurationValue;
+export declare const computedType: ConfigurationValue;
 export {};