r-state-tree 0.6.1 → 0.6.3

package/dist/r-state-tree.cjs

@@ -66,20 +66,13 @@ function isPropertyKey(val) {
   return typeof val === "string" || typeof val === "number" || typeof val === "symbol";
 }
 function getPropertyType(key, obj) {
-  const ctor = obj.constructor;
-  const hasMetadata = ctor != null && ctor[Symbol.metadata] !== void 0;
+  const plain = isPlainObject(obj);
   const descriptor = getPropertyDescriptor$1(obj, key);
   if (descriptor?.value && typeof descriptor.value === "function") {
     return "action";
   }
   const isAccessor = descriptor && (typeof descriptor.get === "function" || typeof descriptor.set === "function");
-  if (!hasMetadata) {
-    if (descriptor?.get) {
-      return "computed";
-    }
-    if (isAccessor) {
-      return null;
-    }
+  if (plain) {
     return "observable";
   }
   const metadata = obj.constructor[Symbol.metadata];
@@ -96,7 +89,10 @@ function getPropertyType(key, obj) {
         return "observable";
     }
   }
-  return isAccessor ? null : "observable";
+  if (isAccessor) {
+    return null;
+  }
+  return "observable";
 }
 function getPropertyDescriptor$1(obj, key) {
   let node = obj;
@@ -336,7 +332,7 @@ class ObjectAdministration extends Administration {
   }
   getType(key) {
     let type = this.types.get(key);
-    if (type === void 0) {
+    if (type === void 0 && !this.types.has(key)) {
       type = getPropertyType(key, this.source);
       this.types.set(key, type);
     }
@@ -354,58 +350,50 @@ class ObjectAdministration extends Administration {
     if (type === "computed") {
       return resolveNode(this.getComputed(key));
     }
+    if (type === null) {
+      return void 0;
+    }
     return resolveNode(this.valuesMap.getOrCreate(key, this.source[key]));
   }
   read(key, receiver = this.proxy) {
     const type = this.getType(key);
+    if (type === "computed") {
+      if (receiver === this.proxy) {
+        return this.callComputed(key);
+      }
+      this.atom.reportObserved();
+      return Reflect.get(this.source, key, receiver);
+    }
     if (type === null) {
       return Reflect.get(this.source, key, receiver);
     }
-    switch (type) {
-      case "observable":
-      case "action": {
-        if (key in this.source) {
-          this.valuesMap.reportObserved(key, this.source[key]);
-        }
-        this.atom.reportObserved();
-        if (this.atom.observing) {
-          this.hasMap.reportObserved(key);
-        }
-        if (type === "observable") {
-          const value = Reflect.get(this.source, key, receiver);
-          const shouldWrap = this.explicitObservables.has(key) || isObservable(value);
-          if (shouldWrap && value && typeof value === "object" && !Object.isFrozen(value)) {
-            const desc = getPropertyDescriptor$1(this.source, key);
-            if (desc && !desc.configurable && !desc.writable) {
-              return value;
-            }
-            const existingAdm = getAdministration(value);
-            if (existingAdm) {
-              return existingAdm.proxy;
-            }
-          }
+    this.atom.reportObserved();
+    if (this.atom.observing) {
+      this.hasMap.reportObserved(key);
+    }
+    const value = Reflect.get(this.source, key, receiver);
+    this.valuesMap.reportObserved(key, value);
+    if (type === "observable") {
+      const shouldWrap = this.explicitObservables.has(key) || isObservable(value);
+      if (shouldWrap && value && typeof value === "object" && !Object.isFrozen(value)) {
+        const desc = getPropertyDescriptor$1(this.source, key);
+        if (desc && !desc.configurable && !desc.writable) {
           return value;
         }
-        return getAction(
-          Reflect.get(this.source, key, receiver)
-        );
-      }
-      case "computed": {
-        if (receiver === this.proxy) {
-          return this.callComputed(key);
+        const existingAdm = getAdministration(value);
+        if (existingAdm) {
+          return existingAdm.proxy;
         }
-        this.atom.reportObserved();
-        return Reflect.get(this.source, key, receiver);
       }
-      default:
-        throw new Error(`unknown type passed to configure`);
+      return value;
     }
+    return getAction(value);
   }
   explicitObservables = /* @__PURE__ */ new Set();
   write(key, newValue) {
     const type = this.getType(key);
     if (type === null) {
-      return this.set(key, newValue);
+      return Reflect.set(this.source, key, newValue, this.proxy);
     }
     if (type === "computed") {
       return signalsCore.batch(() => this.set(key, newValue));
@@ -590,8 +578,24 @@ function createListener(callback) {
   };
   return listener;
 }
+function internalCreateComputed(fn) {
+  const version = signalsCore.signal(0);
+  const c = signalsCore.computed(
+    () => {
+      version.value;
+      return fn();
+    },
+    {
+      unwatched() {
+        version.value++;
+      }
+    }
+  );
+  return { c, version };
+}
 function createComputed(fn, context = null) {
-  const c = signalsCore.computed(context ? fn.bind(context) : fn);
+  const bound = context ? fn.bind(context) : fn;
+  const { c } = internalCreateComputed(bound);
   return {
     node: c,
     get() {
@@ -600,6 +604,7 @@ function createComputed(fn, context = null) {
     clear: () => {
       signalsCore.untracked(() => {
         c._value = void 0;
+        c._globalVersion = -1;
       });
     }
   };
@@ -615,7 +620,7 @@ function computed(value, context) {
     context.metadata[context.name] = { type: "computed" };
     return value;
   }
-  return signalsCore.computed(value);
+  return internalCreateComputed(value).c;
 }
 function source(obj) {
   return getSource(obj);

package/dist/r-state-tree.js

@@ -1,4 +1,4 @@
-import { batch, signal as signal$1, Signal, computed as computed$1, untracked, effect } from "@preact/signals-core";
+import { batch, signal as signal$1, Signal, untracked, effect, computed as computed$1 } from "@preact/signals-core";
 import { Signal as Signal2, batch as batch2, effect as effect2, untracked as untracked2 } from "@preact/signals-core";
 var lib = {};
 var hasRequiredLib;
@@ -65,20 +65,13 @@ function isPropertyKey(val) {
   return typeof val === "string" || typeof val === "number" || typeof val === "symbol";
 }
 function getPropertyType(key, obj) {
-  const ctor = obj.constructor;
-  const hasMetadata = ctor != null && ctor[Symbol.metadata] !== void 0;
+  const plain = isPlainObject(obj);
   const descriptor = getPropertyDescriptor$1(obj, key);
   if (descriptor?.value && typeof descriptor.value === "function") {
     return "action";
   }
   const isAccessor = descriptor && (typeof descriptor.get === "function" || typeof descriptor.set === "function");
-  if (!hasMetadata) {
-    if (descriptor?.get) {
-      return "computed";
-    }
-    if (isAccessor) {
-      return null;
-    }
+  if (plain) {
     return "observable";
   }
   const metadata = obj.constructor[Symbol.metadata];
@@ -95,7 +88,10 @@ function getPropertyType(key, obj) {
         return "observable";
     }
   }
-  return isAccessor ? null : "observable";
+  if (isAccessor) {
+    return null;
+  }
+  return "observable";
 }
 function getPropertyDescriptor$1(obj, key) {
   let node = obj;
@@ -335,7 +331,7 @@ class ObjectAdministration extends Administration {
   }
   getType(key) {
     let type = this.types.get(key);
-    if (type === void 0) {
+    if (type === void 0 && !this.types.has(key)) {
       type = getPropertyType(key, this.source);
       this.types.set(key, type);
     }
@@ -353,58 +349,50 @@ class ObjectAdministration extends Administration {
     if (type === "computed") {
       return resolveNode(this.getComputed(key));
     }
+    if (type === null) {
+      return void 0;
+    }
     return resolveNode(this.valuesMap.getOrCreate(key, this.source[key]));
   }
   read(key, receiver = this.proxy) {
     const type = this.getType(key);
+    if (type === "computed") {
+      if (receiver === this.proxy) {
+        return this.callComputed(key);
+      }
+      this.atom.reportObserved();
+      return Reflect.get(this.source, key, receiver);
+    }
     if (type === null) {
       return Reflect.get(this.source, key, receiver);
     }
-    switch (type) {
-      case "observable":
-      case "action": {
-        if (key in this.source) {
-          this.valuesMap.reportObserved(key, this.source[key]);
-        }
-        this.atom.reportObserved();
-        if (this.atom.observing) {
-          this.hasMap.reportObserved(key);
-        }
-        if (type === "observable") {
-          const value = Reflect.get(this.source, key, receiver);
-          const shouldWrap = this.explicitObservables.has(key) || isObservable(value);
-          if (shouldWrap && value && typeof value === "object" && !Object.isFrozen(value)) {
-            const desc = getPropertyDescriptor$1(this.source, key);
-            if (desc && !desc.configurable && !desc.writable) {
-              return value;
-            }
-            const existingAdm = getAdministration(value);
-            if (existingAdm) {
-              return existingAdm.proxy;
-            }
-          }
+    this.atom.reportObserved();
+    if (this.atom.observing) {
+      this.hasMap.reportObserved(key);
+    }
+    const value = Reflect.get(this.source, key, receiver);
+    this.valuesMap.reportObserved(key, value);
+    if (type === "observable") {
+      const shouldWrap = this.explicitObservables.has(key) || isObservable(value);
+      if (shouldWrap && value && typeof value === "object" && !Object.isFrozen(value)) {
+        const desc = getPropertyDescriptor$1(this.source, key);
+        if (desc && !desc.configurable && !desc.writable) {
           return value;
         }
-        return getAction(
-          Reflect.get(this.source, key, receiver)
-        );
-      }
-      case "computed": {
-        if (receiver === this.proxy) {
-          return this.callComputed(key);
+        const existingAdm = getAdministration(value);
+        if (existingAdm) {
+          return existingAdm.proxy;
         }
-        this.atom.reportObserved();
-        return Reflect.get(this.source, key, receiver);
       }
-      default:
-        throw new Error(`unknown type passed to configure`);
+      return value;
     }
+    return getAction(value);
   }
   explicitObservables = /* @__PURE__ */ new Set();
   write(key, newValue) {
     const type = this.getType(key);
     if (type === null) {
-      return this.set(key, newValue);
+      return Reflect.set(this.source, key, newValue, this.proxy);
     }
     if (type === "computed") {
       return batch(() => this.set(key, newValue));
@@ -589,8 +577,24 @@ function createListener(callback) {
   };
   return listener;
 }
+function internalCreateComputed(fn) {
+  const version = signal$1(0);
+  const c = computed$1(
+    () => {
+      version.value;
+      return fn();
+    },
+    {
+      unwatched() {
+        version.value++;
+      }
+    }
+  );
+  return { c, version };
+}
 function createComputed(fn, context = null) {
-  const c = computed$1(context ? fn.bind(context) : fn);
+  const bound = context ? fn.bind(context) : fn;
+  const { c } = internalCreateComputed(bound);
   return {
     node: c,
     get() {
@@ -599,6 +603,7 @@ function createComputed(fn, context = null) {
     clear: () => {
       untracked(() => {
         c._value = void 0;
+        c._globalVersion = -1;
       });
     }
   };
@@ -614,7 +619,7 @@ function computed(value, context) {
     context.metadata[context.name] = { type: "computed" };
     return value;
   }
-  return computed$1(value);
+  return internalCreateComputed(value).c;
 }
 function source(obj) {
   return getSource(obj);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "r-state-tree",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "reactive state management library",
   "main": "dist/r-state-tree.cjs",
   "module": "dist/r-state-tree.js",