@hypen-space/core 0.4.82 → 0.4.84

package/src/state.ts

@@ -5,6 +5,8 @@
  * creating nested proxies repeatedly.
  */
 
+import { portable } from "./portable";
+
 // Symbol for proxy detection (more robust than string property)
 const IS_PROXY = Symbol.for('hypen.isProxy');
 const RAW_TARGET = Symbol.for('hypen.rawTarget');
@@ -126,82 +128,21 @@ function deepClone<T>(obj: T): T {
 }
 
 /**
- * Compare two values and detect changes with full paths
+ * Compare two values and detect changes with full paths.
+ *
+ * Thin wrapper over [`portable.diffState`] — the algorithm lives in
+ * the Rust engine at `hypen-engine-rs/src/portable/diff.rs` and is
+ * called through the WASM installed by `@hypen-space/server` /
+ * `@hypen-space/web-engine`. When `@hypen-space/core` is used
+ * standalone (no WASM available), a byte-identical TS fallback in
+ * `portable.ts` takes over.
  */
 function diffState(
   oldState: any,
   newState: any,
   basePath: string = ""
 ): StateChange {
-  const paths: StatePath[] = [];
-  const newValues: Record<StatePath, any> = {};
-
-  function diff(oldVal: any, newVal: any, path: string) {
-    // Handle null/undefined
-    if (oldVal === newVal) return;
-
-    // Different types or primitives
-    if (
-      typeof oldVal !== "object" ||
-      typeof newVal !== "object" ||
-      oldVal === null ||
-      newVal === null
-    ) {
-      if (oldVal !== newVal) {
-        paths.push(path);
-        newValues[path] = newVal;
-      }
-      return;
-    }
-
-    // Arrays
-    if (Array.isArray(oldVal) || Array.isArray(newVal)) {
-      if (
-        !Array.isArray(oldVal) ||
-        !Array.isArray(newVal) ||
-        oldVal.length !== newVal.length
-      ) {
-        paths.push(path);
-        newValues[path] = newVal;
-        return;
-      }
-
-      for (let i = 0; i < newVal.length; i++) {
-        const itemPath = path ? `${path}.${i}` : `${i}`;
-        diff(oldVal[i], newVal[i], itemPath);
-      }
-      return;
-    }
-
-    // Objects
-    const oldKeys = new Set(Object.keys(oldVal));
-    const newKeys = new Set(Object.keys(newVal));
-
-    // Check for added or changed keys
-    for (const key of newKeys) {
-      const propPath = path ? `${path}.${key}` : key;
-      if (!oldKeys.has(key)) {
-        // New property
-        paths.push(propPath);
-        newValues[propPath] = newVal[key];
-      } else {
-        // Existing property, recurse
-        diff(oldVal[key], newVal[key], propPath);
-      }
-    }
-
-    // Check for removed keys
-    for (const key of oldKeys) {
-      if (!newKeys.has(key)) {
-        const propPath = path ? `${path}.${key}` : key;
-        paths.push(propPath);
-        newValues[propPath] = undefined;
-      }
-    }
-  }
-
-  diff(oldState, newState, basePath);
-  return { paths, newValues };
+  return portable.diffState(oldState, newState, basePath);
 }
 
 /**

package/src/types.ts

@@ -6,7 +6,29 @@
  */
 
 export type Patch = {
-  type: "create" | "setProp" | "removeProp" | "setText" | "insert" | "move" | "remove" | "attachEvent" | "detachEvent";
+  /**
+   * Patch variant.
+   *
+   * `detach` / `attach` are used by the engine's Router subtree cache
+   * to keep off-screen route content alive between navigations. On
+   * `detach`, the renderer must unlink the subtree from its parent
+   * but keep the underlying native element (and its children) alive
+   * under the same id, so a later `attach` can reinsert it with zero
+   * rebuild. If `remove` arrives for a detached id instead, the
+   * subtree is torn down normally.
+   */
+  type:
+    | "create"
+    | "setProp"
+    | "removeProp"
+    | "setText"
+    | "insert"
+    | "move"
+    | "remove"
+    | "attachEvent"
+    | "detachEvent"
+    | "detach"
+    | "attach";
   id?: string;
   elementType?: string;
   props?: Record<string, any>;