@mintjamsinc/ichigojs 0.1.21 → 0.1.22

package/dist/ichigo.esm.js

@@ -7417,6 +7417,16 @@ class ReactiveProxy {
      * This prevents creating multiple proxies for the same object accessed from different paths.
      */
     static proxyCache = new WeakMap();
+    /**
+     * A WeakMap to track which objects are proxies, mapping proxy -> original target.
+     * This prevents double-wrapping of already proxied objects.
+     */
+    static proxyToTarget = new WeakMap();
+    /**
+     * A WeakSet to track objects marked as "raw" (non-reactive).
+     * These objects will not be wrapped with Proxy.
+     */
+    static rawObjects = new WeakSet();
     /**
      * Creates a reactive proxy for the given object.
      * The proxy will call the onChange callback whenever a property is modified.
@@ -7431,9 +7441,19 @@ class ReactiveProxy {
         if (typeof target !== 'object' || target === null) {
             return target;
         }
+        // Don't wrap objects marked as raw (non-reactive)
+        if (this.rawObjects.has(target)) {
+            return target;
+        }
         // Don't wrap built-in objects that have internal slots
         // These objects require their methods to be called with the correct 'this' context
-        if (target instanceof Date || target instanceof RegExp || target instanceof Error) {
+        // Use Object.prototype.toString for more reliable type checking
+        const typeTag = Object.prototype.toString.call(target);
+        if (typeTag === '[object Date]' || typeTag === '[object RegExp]' || typeTag === '[object Error]') {
+            return target;
+        }
+        // Check if the target is already a proxy - if so, return it as-is to prevent double-wrapping
+        if (this.proxyToTarget.has(target)) {
             return target;
         }
         // Check if we already have a proxy for this target with this path
@@ -7454,8 +7474,14 @@ class ReactiveProxy {
                 const value = Reflect.get(obj, key);
                 // If the value is an object or array, make it reactive too
                 if (typeof value === 'object' && value !== null) {
+                    // Don't wrap objects marked as raw (non-reactive)
+                    if (ReactiveProxy.rawObjects.has(value)) {
+                        return value;
+                    }
                     // Don't wrap built-in objects that have internal slots
-                    if (value instanceof Date || value instanceof RegExp || value instanceof Error) {
+                    // Use Object.prototype.toString for more reliable type checking
+                    const valueTypeTag = Object.prototype.toString.call(value);
+                    if (valueTypeTag === '[object Date]' || valueTypeTag === '[object RegExp]' || valueTypeTag === '[object Error]') {
                         return value;
                     }
                     // Build the nested path
@@ -7497,6 +7523,8 @@ class ReactiveProxy {
         });
         // Cache the proxy for this path
         pathMap.set(path, proxy);
+        // Track that this proxy wraps the target to prevent double-wrapping
+        this.proxyToTarget.set(proxy, target);
         return proxy;
     }
     /**
@@ -7520,6 +7548,32 @@ class ReactiveProxy {
         // In a full implementation, we'd need to store a reverse mapping
         return obj;
     }
+    /**
+     * Marks an object as "raw" (non-reactive).
+     * Objects marked as raw will not be wrapped with Proxy when accessed from reactive objects.
+     * This is useful for objects that should not be reactive, such as:
+     * - Objects with private fields (class instances with # fields)
+     * - Third-party library instances
+     * - Objects used only for method calls
+     *
+     * @param obj The object to mark as raw.
+     * @returns The same object (for chaining).
+     */
+    static markRaw(obj) {
+        if (typeof obj === 'object' && obj !== null) {
+            this.rawObjects.add(obj);
+        }
+        return obj;
+    }
+    /**
+     * Checks if an object is marked as raw (non-reactive).
+     *
+     * @param obj The object to check.
+     * @returns True if the object is marked as raw, false otherwise.
+     */
+    static isRaw(obj) {
+        return typeof obj === 'object' && obj !== null && this.rawObjects.has(obj);
+    }
 }
 
 // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
@@ -11253,6 +11307,7 @@ class VApplication {
         });
         // Inject utility methods into bindings
         this.#bindings.set('$nextTick', (callback) => this.#nextTick(callback));
+        this.#bindings.set('$markRaw', (obj) => ReactiveProxy.markRaw(obj));
         // Add methods
         if (this.#options.methods) {
             for (const [key, method] of Object.entries(this.#options.methods)) {
@@ -11267,7 +11322,13 @@ class VApplication {
         }
         // Add data properties
         if (this.#options.data) {
-            const data = this.#options.data();
+            // Create a $ctx context object with utility functions for data()
+            // This provides the same $markRaw access as in lifecycle hooks (@mount, etc.)
+            const $ctx = {
+                $markRaw: (obj) => ReactiveProxy.markRaw(obj)
+            };
+            // Call data() with $ctx as 'this'
+            const data = this.#options.data.call($ctx);
             if (data && typeof data === 'object') {
                 for (const [key, value] of Object.entries(data)) {
                     this.#bindings.set(key, value);
@@ -11445,5 +11506,5 @@ class VDOM {
     }
 }
 
-export { VComponent, VComponentRegistry, VDOM };
+export { ReactiveProxy, VComponent, VComponentRegistry, VDOM };
 //# sourceMappingURL=ichigo.esm.js.map