@mintjamsinc/ichigojs 0.1.4 → 0.1.6

package/dist/ichigo.umd.js

@@ -7678,6 +7678,13 @@
          * This is optional and may be undefined if the node has not been templatized.
          */
         #templatized;
+        /**
+         * User data storage for lifecycle directives.
+         * This provides a Proxy-free space where developers can store arbitrary data
+         * associated with this VNode. The data is automatically cleaned up when the
+         * VNode is destroyed.
+         */
+        #userData;
         /**
          * Creates an instance of the virtual node.
          * @param args The initialization arguments for the virtual node.
@@ -7889,6 +7896,18 @@
             this.#preparableIdentifiers = preparableIdentifiers.length === 0 ? [] : [...new Set(preparableIdentifiers)];
             return this.#preparableIdentifiers;
         }
+        /**
+         * Gets the user data storage for this virtual node.
+         * This is lazily initialized and provides a Proxy-free space for storing
+         * arbitrary data associated with lifecycle directives.
+         * @returns A Map for storing user data.
+         */
+        get userData() {
+            if (!this.#userData) {
+                this.#userData = new Map();
+            }
+            return this.#userData;
+        }
         /**
          * The DOM path of this virtual node.
          * This is a string representation of the path from the root to this node,
@@ -8095,6 +8114,14 @@
         /**
          * Cleans up any resources used by this virtual node.
          * This method is called when the virtual node is no longer needed.
+         *
+         * Cleanup order:
+         * 1. Call onUnmount lifecycle hooks
+         * 2. Auto-cleanup userData (close() on Closeable objects)
+         * 3. Recursively destroy child nodes
+         * 4. Unregister dependencies
+         * 5. Clean up directive manager
+         * 6. Call onUnmounted lifecycle hooks
          */
         destroy() {
             // If no directive requires template preservation, call onUnmount for directives that do not templatize
@@ -8103,6 +8130,23 @@
                     d.onUnmount?.();
                 });
             }
+            // Clean up user data, calling close() on any Closeable objects
+            // This happens after onUnmount but before other cleanup, allowing users to
+            // perform custom cleanup in onUnmount while having automatic cleanup of userData
+            if (this.#userData) {
+                for (const [key, value] of this.#userData.entries()) {
+                    try {
+                        // If the value has a close() method (Closeable pattern), call it
+                        if (value && typeof value === 'object' && typeof value.close === 'function') {
+                            value.close();
+                        }
+                    }
+                    catch (error) {
+                        this.#vApplication.logManager.getLogger(this.constructor.name).error(`Error closing user data '${key}': ${error}`);
+                    }
+                }
+                this.#userData.clear();
+            }
             // Recursively destroy child nodes
             if (this.#childVNodes) {
                 for (const childVNode of this.#childVNodes) {
@@ -9507,7 +9551,7 @@
             return ['mount', 'mounted', 'update', 'updated', 'unmount', 'unmounted'].includes(eventName);
         }
         /**
-         * Creates a wrapper function for lifecycle hooks (with element parameter).
+         * Creates a wrapper function for lifecycle hooks (with context parameter).
          * @param expression The expression string to evaluate.
          * @returns A function that handles the lifecycle hook.
          */
@@ -9517,22 +9561,27 @@
             // Return a function that handles the lifecycle hook with proper scope
             return () => {
                 const bindings = vNode.bindings;
-                const el = vNode.node;
+                const $ctx = {
+                    element: vNode.node,
+                    vnode: vNode,
+                    userData: vNode.userData
+                };
                 // If the expression is just a method name, call it with bindings as 'this'
                 const trimmedExpr = expression.trim();
                 if (identifiers.includes(trimmedExpr) && typeof bindings?.get(trimmedExpr) === 'function') {
                     const methodName = trimmedExpr;
                     const originalMethod = bindings?.get(methodName);
-                    // Call the method with bindings as 'this' context and element as parameter
-                    // This allows the method to access the DOM element and bindings
-                    return originalMethod(el);
+                    // Call the method with bindings as 'this' context and context as parameter
+                    // This allows the method to access the DOM element, VNode, and userData
+                    return originalMethod($ctx);
                 }
-                // For inline expressions, evaluate normally with element parameter
+                // For inline expressions, evaluate normally with $ctx parameter
+                // Note: $ctx is a reserved variable name for lifecycle context
                 const values = identifiers.map(id => vNode.bindings?.get(id));
-                const args = [...identifiers, 'el'].join(", ");
+                const args = [...identifiers, '$ctx'].join(", ");
                 const funcBody = `return (${expression});`;
                 const func = new Function(args, funcBody);
-                return func.call(bindings?.raw, ...values, el);
+                return func.call(bindings?.raw, ...values, $ctx);
             };
         }
         /**