reptree 0.2.4 → 0.3.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

@@ -438,6 +438,8 @@ function toPublicObject(tree, id, internalToPublic) {
 }
 var RESERVED_METHOD_USE_TRANSIENT = "useTransient";
 var RESERVED_METHOD_COMMIT_TRANSIENTS = "commitTransients";
+var VERTEX_PROPS = ["$id", "$parentId", "$parent", "$children", "$childrenIds"];
+var VERTEX_METHODS = ["$moveTo", "$delete", "$observe", "$observeChildren", "$newChild", "$newNamedChild"];
 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 };
@@ -445,6 +447,7 @@ function bindVertex(tree, id, schemaOrOptions) {
   const aliases = options.aliases ?? defaultAliases;
   const includeInternalKeys = options.includeInternalKeys ?? false;
   const { publicToInternal, internalToPublic } = buildAliasMaps(aliases);
+  const cachedMethods = /* @__PURE__ */ new Map();
   return new Proxy({}, {
     get(_target, prop) {
       if (prop === RESERVED_METHOD_USE_TRANSIENT) {
@@ -533,6 +536,67 @@ function bindVertex(tree, id, schemaOrOptions) {
           }
         };
       }
+      if (typeof prop === "string") {
+        if (prop === "$id") return id;
+        if (prop === "$parentId") return tree.getVertex(id)?.parentId ?? null;
+        if (prop === "$parent") {
+          const vertex = tree.getVertex(id);
+          return vertex?.parent;
+        }
+        if (prop === "$children") return tree.getChildren(id);
+        if (prop === "$childrenIds") return tree.getChildrenIds(id);
+        if (prop === "$moveTo") {
+          if (!cachedMethods.has(prop)) {
+            cachedMethods.set(prop, (parent) => {
+              const parentId = typeof parent === "object" && parent !== null ? parent.id || parent.$id : parent;
+              tree.moveVertex(id, parentId);
+            });
+          }
+          return cachedMethods.get(prop);
+        }
+        if (prop === "$delete") {
+          if (!cachedMethods.has(prop)) {
+            cachedMethods.set(prop, () => tree.deleteVertex(id));
+          }
+          return cachedMethods.get(prop);
+        }
+        if (prop === "$observe") {
+          if (!cachedMethods.has(prop)) {
+            cachedMethods.set(prop, (listener) => tree.observe(id, listener));
+          }
+          return cachedMethods.get(prop);
+        }
+        if (prop === "$observeChildren") {
+          if (!cachedMethods.has(prop)) {
+            cachedMethods.set(prop, (listener) => {
+              return tree.observe(id, (events) => {
+                if (events.some((e) => e.type === "children")) {
+                  listener(tree.getChildren(id));
+                }
+              });
+            });
+          }
+          return cachedMethods.get(prop);
+        }
+        if (prop === "$newChild") {
+          if (!cachedMethods.has(prop)) {
+            cachedMethods.set(prop, (props) => {
+              const vertex = tree.getVertex(id);
+              return vertex?.newChild(props);
+            });
+          }
+          return cachedMethods.get(prop);
+        }
+        if (prop === "$newNamedChild") {
+          if (!cachedMethods.has(prop)) {
+            cachedMethods.set(prop, (name, props) => {
+              const vertex = tree.getVertex(id);
+              return vertex?.newNamedChild(name, props);
+            });
+          }
+          return cachedMethods.get(prop);
+        }
+      }
       if (typeof prop !== "string") return void 0;
       const rule = publicToInternal.get(prop);
       if (rule) {
@@ -546,6 +610,12 @@ function bindVertex(tree, id, schemaOrOptions) {
       if (prop === RESERVED_METHOD_USE_TRANSIENT || prop === RESERVED_METHOD_COMMIT_TRANSIENTS) {
         return true;
       }
+      if (VERTEX_PROPS.includes(prop)) {
+        return true;
+      }
+      if (VERTEX_METHODS.includes(prop)) {
+        return true;
+      }
       if (schema?.shape && schema.shape[prop]) {
         const field = schema.shape[prop];
         if (field.safeParse) {
@@ -576,6 +646,12 @@ function bindVertex(tree, id, schemaOrOptions) {
       if (prop === RESERVED_METHOD_USE_TRANSIENT || prop === RESERVED_METHOD_COMMIT_TRANSIENTS) {
         return true;
       }
+      if (VERTEX_PROPS.includes(prop)) {
+        return true;
+      }
+      if (VERTEX_METHODS.includes(prop)) {
+        return true;
+      }
       const rule = publicToInternal.get(prop);
       if (rule) {
         tree.setVertexProperty(id, rule.internalKey, void 0);