reptree 0.3.0 → 0.4.0

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,263 +429,124 @@ 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";
-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 };
   const schema = options.schema;
   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) {
-        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;
-            }
-            tree.setVertexProperty(id, internalKey, valueToPersistInternal);
-          }
-        };
-      }
-      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);
+  const { publicToInternal } = buildAliasMaps(aliases);
+  const obj = {};
+  Object.defineProperties(obj, {
+    $vertex: { get: () => tree.getVertex(id), enumerable: false, configurable: true },
+    $id: { get: () => id, enumerable: false, configurable: true },
+    $parentId: { get: () => tree.getVertex(id)?.parentId ?? null, enumerable: false, configurable: true },
+    $parent: { get: () => tree.getVertex(id)?.parent, enumerable: false, configurable: true },
+    $children: { get: () => tree.getChildren(id), enumerable: false, configurable: true },
+    $childrenIds: { get: () => tree.getChildrenIds(id), enumerable: false, configurable: true },
+    $moveTo: {
+      value: (parent) => {
+        const parentId = typeof parent === "object" && parent !== null ? parent.id || parent.$id : parent;
+        tree.moveVertex(id, parentId);
+      },
+      enumerable: false,
+      configurable: true,
+      writable: false
+    },
+    $delete: { value: () => tree.deleteVertex(id), enumerable: false, configurable: true, writable: false },
+    $observe: { value: (listener) => tree.observe(id, listener), enumerable: false, configurable: true, writable: false },
+    $observeChildren: {
+      value: (listener) => tree.observe(id, (events) => {
+        if (events.some((e) => e.type === "children")) {
+          listener(tree.getChildren(id));
         }
-        if (prop === "$newNamedChild") {
-          if (!cachedMethods.has(prop)) {
-            cachedMethods.set(prop, (name, props) => {
-              const vertex = tree.getVertex(id);
-              return vertex?.newNamedChild(name, props);
-            });
+      }),
+      enumerable: false,
+      configurable: true,
+      writable: false
+    },
+    $newChild: { value: (props) => tree.getVertex(id).newChild(props), enumerable: false, configurable: true, writable: false },
+    $newNamedChild: { value: (name, props) => tree.getVertex(id).newNamedChild(name, props), enumerable: false, configurable: true, writable: false },
+    $useTransients: {
+      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);
+            }
+            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;
           }
-          return cachedMethods.get(prop);
+        });
+        fn(transientProxy);
+      },
+      enumerable: false,
+      configurable: true,
+      writable: false
+    },
+    $commitTransients: { value: () => tree.commitTransients(id), enumerable: false, configurable: true, writable: false },
+    equals: {
+      value: function(other) {
+        if (other && typeof other === "object" && "$id" in other) {
+          return other.$id === id;
         }
+        return false;
+      },
+      enumerable: false,
+      configurable: true,
+      writable: false
+    }
+  });
+  const proxy = new Proxy(obj, {
+    get(target, prop, receiver) {
+      if (typeof prop !== "string") {
+        return Reflect.get(target, prop, receiver);
       }
-      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;
+      if (prop in target) {
+        return Reflect.get(target, prop, receiver);
       }
-      return tree.getVertexProperty(id, prop);
+      const rule = publicToInternal.get(prop);
+      const internalKey = rule?.internalKey ?? prop;
+      const rawValue = tree.getVertexProperty(id, internalKey, true);
+      return rule?.toPublic ? rule.toPublic(rawValue) : rawValue;
     },
-    set(_target, prop, value) {
-      if (typeof prop !== "string") return true;
-      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;
+    set(target, prop, value) {
+      if (typeof prop !== "string") {
+        return Reflect.set(target, prop, value);
       }
       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];
+          if (!res.success) throw new Error(`Invalid value for ${prop}`);
+          value = res.data;
         }
       }
       const rule = publicToInternal.get(prop);
-      if (rule) {
-        const converted = rule.toInternal ? rule.toInternal(value) : value;
-        tree.setVertexProperty(id, rule.internalKey, converted);
-        return true;
-      }
-      tree.setVertexProperty(id, prop, value);
+      const internalKey = rule?.internalKey ?? prop;
+      const internalValue = rule?.toInternal ? rule.toInternal(value) : value;
+      tree.setVertexProperty(id, internalKey, internalValue);
       return true;
     },
     deleteProperty(_target, prop) {
-      if (typeof prop !== "string") return true;
-      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)) {
+      if (typeof prop !== "string") {
         return true;
       }
       const rule = publicToInternal.get(prop);
-      if (rule) {
-        tree.setVertexProperty(id, rule.internalKey, void 0);
-        return true;
-      }
-      tree.setVertexProperty(id, prop, void 0);
+      const internalKey = rule?.internalKey ?? prop;
+      tree.setVertexProperty(id, internalKey, 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
@@ -757,6 +624,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);
@@ -1233,6 +1103,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;