reptree 0.2.4 → 0.4.0-alpha.0

package/README.md

@@ -26,7 +26,7 @@ npm install reptree
 ### Reactive vertex with Zod (optional)
 
 ```ts
-import { RepTree, bindVertex } from 'reptree';
+import { RepTree } from 'reptree';
 import { z } from 'zod';
 
 const tree = new RepTree('peer1');
@@ -35,11 +35,7 @@ const v = root.newChild();
 
 const Person = z.object({ name: z.string(), age: z.number().int().min(0) });
 
-// Helper function form
-const person = bindVertex(tree, v.id, Person);
-
-// Or via instance method on Vertex
-// const person = v.bind(Person);
+const person = v.bind(Person);
 
 person.name = 'Alice'; // validated and persisted
 person.age = 33;       // validated and persisted
@@ -50,7 +46,7 @@ person.age = 33;       // validated and persisted
 - `name` ↔ `_n`
 - `createdAt` ↔ `_c` (Date exposed, ISO stored)
 
-These aliases are applied by default when using `bindVertex` or `vertex.bind()`.
+These aliases are applied by default when using `vertex.bind()`.
 
 ```ts
 person.name = 'Alice';          // writes _n

package/dist/index.cjs

@@ -187,6 +187,12 @@ var VertexState = class {
   removeTransientProperty(key) {
     this.transientProperties = this.transientProperties.filter((p) => p.key !== key);
   }
+  getTransientProperties() {
+    return this.transientProperties;
+  }
+  clearAllTransientProperties() {
+    this.transientProperties = [];
+  }
 };
 
 // src/TreeState.ts
@@ -423,159 +429,286 @@ function buildAliasMaps(aliases) {
   }
   return { publicToInternal, internalToPublic };
 }
-function toPublicObject(tree, id, internalToPublic) {
-  const obj = {};
-  for (const { key, value } of tree.getVertexProperties(id)) {
-    const rule = internalToPublic.get(key);
-    if (rule) {
-      const converted = rule.toPublic ? rule.toPublic(value) : value;
-      obj[rule.publicKey] = converted;
-    } else {
-      obj[key] = value;
-    }
-  }
-  return obj;
-}
-var RESERVED_METHOD_USE_TRANSIENT = "useTransient";
-var RESERVED_METHOD_COMMIT_TRANSIENTS = "commitTransients";
 function bindVertex(tree, id, schemaOrOptions) {
   const isOptions = typeof schemaOrOptions === "object" && schemaOrOptions !== null && (Object.prototype.hasOwnProperty.call(schemaOrOptions, "aliases") || Object.prototype.hasOwnProperty.call(schemaOrOptions, "includeInternalKeys") || Object.prototype.hasOwnProperty.call(schemaOrOptions, "schema"));
   const options = isOptions ? schemaOrOptions : { schema: schemaOrOptions };
   const schema = options.schema;
   const aliases = options.aliases ?? defaultAliases;
-  const includeInternalKeys = options.includeInternalKeys ?? false;
   const { publicToInternal, internalToPublic } = buildAliasMaps(aliases);
-  return new Proxy({}, {
-    get(_target, prop) {
-      if (prop === RESERVED_METHOD_USE_TRANSIENT) {
-        return (fn) => {
-          const transientProxy = new Proxy({}, {
-            get(_t, p) {
-              if (typeof p !== "string") return void 0;
-              const rule2 = publicToInternal.get(p);
-              if (rule2) {
-                const raw = tree.getVertexProperty(id, rule2.internalKey);
-                return rule2.toPublic ? rule2.toPublic(raw) : raw;
-              }
-              return tree.getVertexProperty(id, p);
-            },
-            set(_t, p, value) {
-              if (typeof p !== "string") return true;
-              if (schema?.shape && schema.shape[p]) {
-                const field = schema.shape[p];
-                if (field.safeParse) {
-                  const res = field.safeParse(value);
-                  if (!res.success) throw new Error(`Invalid value for ${String(p)}`);
-                  value = res.data ?? value;
-                }
-              } else if (schema?.safeParse) {
-                const next = { ...toPublicObject(tree, id, internalToPublic), [p]: value };
-                const res = schema.safeParse(next);
-                if (!res.success) throw new Error(`Invalid value for ${String(p)}`);
-                const parsed = res.data;
-                if (parsed && Object.prototype.hasOwnProperty.call(parsed, p)) {
-                  value = parsed[p];
-                }
-              }
-              const rule2 = publicToInternal.get(p);
-              if (rule2) {
-                const converted = rule2.toInternal ? rule2.toInternal(value) : value;
-                tree.setTransientVertexProperty(id, rule2.internalKey, converted);
-                return true;
-              }
-              tree.setTransientVertexProperty(id, p, value);
-              return true;
-            },
-            deleteProperty(_t, p) {
-              if (typeof p !== "string") return true;
-              const rule2 = publicToInternal.get(p);
-              if (rule2) {
-                tree.setTransientVertexProperty(id, rule2.internalKey, void 0);
-                return true;
-              }
-              tree.setTransientVertexProperty(id, p, void 0);
-              return true;
-            }
-          });
-          fn(transientProxy);
-        };
-      }
-      if (prop === RESERVED_METHOD_COMMIT_TRANSIENTS) {
-        return () => {
-          const entries = tree.getVertexProperties(id);
-          const currentPublic = schema?.safeParse ? toPublicObject(tree, id, internalToPublic) : void 0;
-          for (const { key: internalKey, value: overlayValue } of entries) {
-            const persistentValue = tree.getVertexProperty(id, internalKey, false);
-            if (overlayValue === persistentValue) continue;
-            const aliasRule = internalToPublic.get(internalKey);
-            const publicKey = aliasRule ? aliasRule.publicKey : internalKey;
-            const publicValue = aliasRule && aliasRule.toPublic ? aliasRule.toPublic(overlayValue) : overlayValue;
-            let valueToPersistInternal = overlayValue;
-            if (schema?.shape && schema.shape[publicKey]) {
-              const field = schema.shape[publicKey];
-              if (field.safeParse) {
-                const res = field.safeParse(publicValue);
-                if (!res.success) throw new Error(`Invalid value for ${String(publicKey)}`);
-                const coerced = res.data;
-                const maybeInternal = aliasRule && aliasRule.toInternal ? aliasRule.toInternal(coerced) : coerced;
-                valueToPersistInternal = maybeInternal;
-              }
-            } else if (schema?.safeParse && currentPublic) {
-              const nextPublic = { ...currentPublic, [publicKey]: publicValue };
-              const res = schema.safeParse(nextPublic);
-              if (!res.success) throw new Error("Invalid values for commitTransients");
-              const parsed = res.data;
-              const parsedPublic = Object.prototype.hasOwnProperty.call(parsed, publicKey) ? parsed[publicKey] : publicValue;
-              const maybeInternal = aliasRule && aliasRule.toInternal ? aliasRule.toInternal(parsedPublic) : parsedPublic;
-              valueToPersistInternal = maybeInternal;
+  const obj = {};
+  let isObserverUpdate = false;
+  const propsToDefine = /* @__PURE__ */ new Set();
+  if (schema?.shape) {
+    Object.keys(schema.shape).forEach((key) => propsToDefine.add(key));
+    aliases.forEach((alias) => propsToDefine.add(alias.publicKey));
+  }
+  const localValues = /* @__PURE__ */ new Map();
+  propsToDefine.forEach((publicKey) => {
+    const rule = publicToInternal.get(publicKey);
+    const internalKey = rule?.internalKey ?? publicKey;
+    const rawValue = tree.getVertexProperty(id, internalKey);
+    const publicValue = rule?.toPublic ? rule.toPublic(rawValue) : rawValue;
+    localValues.set(publicKey, publicValue);
+  });
+  propsToDefine.forEach((publicKey) => {
+    const rule = publicToInternal.get(publicKey);
+    const storageKey = `_${publicKey}_value`;
+    obj[storageKey] = localValues.get(publicKey);
+    Object.defineProperty(obj, publicKey, {
+      get: function() {
+        const internalKey = rule?.internalKey ?? publicKey;
+        const rawValue = tree.getVertexProperty(id, internalKey, true);
+        const publicValue = rule?.toPublic ? rule.toPublic(rawValue) : rawValue;
+        if (this[storageKey] !== publicValue) {
+          this[storageKey] = publicValue;
+        }
+        return publicValue;
+      },
+      set: function(value) {
+        if (schema?.shape && schema.shape[publicKey]) {
+          const field = schema.shape[publicKey];
+          if (field.safeParse) {
+            const res = field.safeParse(value);
+            if (!res.success) throw new Error(`Invalid value for ${publicKey}`);
+            value = res.data;
+          }
+        }
+        this[storageKey] = value;
+        if (!isObserverUpdate) {
+          const internalKey = rule?.internalKey ?? publicKey;
+          const internalValue = rule?.toInternal ? rule.toInternal(value) : value;
+          tree.setVertexProperty(id, internalKey, internalValue);
+        }
+      },
+      enumerable: true,
+      configurable: true
+    });
+  });
+  const cachedMethods = /* @__PURE__ */ new Map();
+  const getCachedMethod = (name, factory) => {
+    if (!cachedMethods.has(name)) {
+      cachedMethods.set(name, factory());
+    }
+    return cachedMethods.get(name);
+  };
+  Object.defineProperties(obj, {
+    $id: {
+      get: () => id,
+      set: () => {
+      },
+      // No-op setter (silently ignore)
+      enumerable: false,
+      configurable: true
+    },
+    $parentId: {
+      get: () => tree.getVertex(id)?.parentId ?? null,
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    $parent: {
+      get: () => tree.getVertex(id)?.parent,
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    $children: {
+      get: () => tree.getChildren(id),
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    $childrenIds: {
+      get: () => tree.getChildrenIds(id),
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    $moveTo: {
+      get: () => getCachedMethod("$moveTo", () => (parent) => {
+        const parentId = typeof parent === "object" && parent !== null ? parent.id || parent.$id : parent;
+        tree.moveVertex(id, parentId);
+      }),
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    $delete: {
+      get: () => getCachedMethod("$delete", () => () => tree.deleteVertex(id)),
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    $observe: {
+      get: () => getCachedMethod("$observe", () => (listener) => tree.observe(id, listener)),
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    $observeChildren: {
+      get: () => getCachedMethod("$observeChildren", () => (listener) => {
+        return tree.observe(id, (events) => {
+          if (events.some((e) => e.type === "children")) {
+            listener(tree.getChildren(id));
+          }
+        });
+      }),
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    $newChild: {
+      get: () => getCachedMethod("$newChild", () => (props) => {
+        const vertex = tree.getVertex(id);
+        return vertex?.newChild(props);
+      }),
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    $newNamedChild: {
+      get: () => getCachedMethod("$newNamedChild", () => (name, props) => {
+        const vertex = tree.getVertex(id);
+        return vertex?.newNamedChild(name, props);
+      }),
+      set: () => {
+      },
+      // No-op setter
+      enumerable: false,
+      configurable: true
+    },
+    useTransient: {
+      value: function(fn) {
+        const transientProxy = new Proxy({}, {
+          set(_, prop, value) {
+            if (typeof prop === "string") {
+              const rule = publicToInternal.get(prop);
+              const internalKey = rule?.internalKey ?? prop;
+              const internalValue = rule?.toInternal ? rule.toInternal(value) : value;
+              tree.setTransientVertexProperty(id, internalKey, internalValue);
             }
-            tree.setVertexProperty(id, internalKey, valueToPersistInternal);
+            return true;
+          },
+          get(_, prop) {
+            if (typeof prop !== "string") return void 0;
+            const rule = publicToInternal.get(prop);
+            const internalKey = rule?.internalKey ?? prop;
+            const rawValue = tree.getVertexProperty(id, internalKey, true);
+            return rule?.toPublic ? rule.toPublic(rawValue) : rawValue;
           }
-        };
+        });
+        fn(transientProxy);
+      },
+      enumerable: false,
+      configurable: true
+    },
+    commitTransients: {
+      value: function() {
+        tree.commitTransients(id);
+      },
+      enumerable: false,
+      configurable: true
+    },
+    equals: {
+      value: function(other) {
+        if (other && typeof other === "object" && "$id" in other) {
+          return other.$id === id;
+        }
+        return obj === other;
+      },
+      enumerable: false,
+      configurable: true
+    }
+  });
+  tree.observe(id, (events) => {
+    isObserverUpdate = true;
+    for (const e of events) {
+      if (e.type === "property") {
+        const propEvent = e;
+        const rule = internalToPublic.get(propEvent.key);
+        if (rule) {
+          const publicKey = rule.publicKey;
+          const publicValue = rule.toPublic ? rule.toPublic(propEvent.value) : propEvent.value;
+          const storageKey = `_${publicKey}_value`;
+          if (storageKey in obj) {
+            obj[storageKey] = publicValue;
+          }
+        }
+      }
+    }
+    isObserverUpdate = false;
+  });
+  if (schema) {
+    return obj;
+  }
+  const proxy = new Proxy(obj, {
+    get(target, prop) {
+      if (typeof prop !== "string") {
+        return target[prop];
+      }
+      if (prop in target || prop.startsWith("$") || prop === "equals") {
+        return target[prop];
       }
-      if (typeof prop !== "string") return void 0;
       const rule = publicToInternal.get(prop);
       if (rule) {
-        const raw = tree.getVertexProperty(id, rule.internalKey);
-        return rule.toPublic ? rule.toPublic(raw) : raw;
+        const internalKey = rule.internalKey;
+        const rawValue2 = tree.getVertexProperty(id, internalKey);
+        const result = rule.toPublic ? rule.toPublic(rawValue2) : rawValue2;
+        return result;
       }
-      return tree.getVertexProperty(id, prop);
+      const rawValue = tree.getVertexProperty(id, prop);
+      return rawValue;
     },
-    set(_target, prop, value) {
-      if (typeof prop !== "string") return true;
-      if (prop === RESERVED_METHOD_USE_TRANSIENT || prop === RESERVED_METHOD_COMMIT_TRANSIENTS) {
+    set(target, prop, value) {
+      if (typeof prop !== "string") {
+        target[prop] = value;
         return true;
       }
-      if (schema?.shape && schema.shape[prop]) {
-        const field = schema.shape[prop];
-        if (field.safeParse) {
-          const res = field.safeParse(value);
-          if (!res.success) throw new Error(`Invalid value for ${String(prop)}`);
-          value = res.data ?? value;
-        }
-      } else if (schema?.safeParse) {
-        const next = { ...toPublicObject(tree, id, internalToPublic), [prop]: value };
-        const res = schema.safeParse(next);
-        if (!res.success) throw new Error(`Invalid value for ${String(prop)}`);
-        const parsed = res.data;
-        if (parsed && Object.prototype.hasOwnProperty.call(parsed, prop)) {
-          value = parsed[prop];
-        }
+      const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+      if (descriptor && descriptor.set) {
+        target[prop] = value;
+        return true;
       }
       const rule = publicToInternal.get(prop);
       if (rule) {
-        const converted = rule.toInternal ? rule.toInternal(value) : value;
-        tree.setVertexProperty(id, rule.internalKey, converted);
+        const internalKey = rule.internalKey;
+        const internalValue = rule.toInternal ? rule.toInternal(value) : value;
+        tree.setVertexProperty(id, internalKey, internalValue);
         return true;
       }
       tree.setVertexProperty(id, prop, value);
       return true;
     },
-    deleteProperty(_target, prop) {
-      if (typeof prop !== "string") return true;
-      if (prop === RESERVED_METHOD_USE_TRANSIENT || prop === RESERVED_METHOD_COMMIT_TRANSIENTS) {
+    deleteProperty(target, prop) {
+      if (typeof prop !== "string") {
+        delete target[prop];
         return true;
       }
+      const storageKey = `_${prop}_value`;
+      if (storageKey in target) {
+        delete target[storageKey];
+      }
+      if (prop in target) {
+        delete target[prop];
+      }
       const rule = publicToInternal.get(prop);
       if (rule) {
         tree.setVertexProperty(id, rule.internalKey, void 0);
@@ -583,27 +716,9 @@ function bindVertex(tree, id, schemaOrOptions) {
       }
       tree.setVertexProperty(id, prop, void 0);
       return true;
-    },
-    has(_target, prop) {
-      if (typeof prop !== "string") return false;
-      if (schema?.shape && Object.prototype.hasOwnProperty.call(schema.shape, prop)) return true;
-      if (includeInternalKeys) {
-        return publicToInternal.has(prop) || internalToPublic.has(prop);
-      }
-      return false;
-    },
-    ownKeys() {
-      const keys = /* @__PURE__ */ new Set();
-      for (const k of Object.keys(schema?.shape ?? {})) keys.add(k);
-      if (includeInternalKeys) {
-        for (const rule of aliases) keys.add(rule.internalKey);
-      }
-      return Array.from(keys);
-    },
-    getOwnPropertyDescriptor() {
-      return { enumerable: true, configurable: true };
     }
   });
+  return proxy;
 }
 
 // src/Vertex.ts
@@ -681,6 +796,9 @@ var Vertex = class _Vertex {
     }
     this.tree.setTransientVertexProperty(this.id, key, value);
   }
+  commitTransients() {
+    this.tree.commitTransients(this.id);
+  }
   setProperties(props) {
     for (const [key, value] of Object.entries(props)) {
       this.setProperty(key, value);
@@ -1157,6 +1275,20 @@ var _RepTree = class _RepTree {
     this.localOps.push(op);
     this.applyProperty(op);
   }
+  commitTransients(vertexId) {
+    const vertex = this.state.getVertex(vertexId);
+    if (!vertex) {
+      return;
+    }
+    const transientProps = vertex.getTransientProperties();
+    for (const prop of transientProps) {
+      this.setVertexProperty(vertexId, prop.key, prop.value);
+    }
+    for (const prop of transientProps) {
+      this.transientPropertiesAndTheirOpIds.delete(`${prop.key}@${vertexId}`);
+    }
+    vertex.clearAllTransientProperties();
+  }
   setVertexProperty(vertexId, key, value) {
     this.lamportClock++;
     let opValue;