@mintjamsinc/ichigojs 0.1.6 → 0.1.7

package/dist/ichigo.umd.js

@@ -59,6 +59,7 @@
         StandardDirectiveName["V_ON"] = "v-on";
         StandardDirectiveName["V_BIND"] = "v-bind";
         StandardDirectiveName["V_MODEL"] = "v-model";
+        StandardDirectiveName["V_RESIZE"] = "v-resize";
     })(StandardDirectiveName || (StandardDirectiveName = {}));
 
     // This file was generated. Do not modify manually!
@@ -9309,7 +9310,7 @@
      *     @update="onUpdate"     - Called before the element is updated
      *     @updated="onUpdated"   - Called after the element is updated
      *     @unmount="onUnmount"   - Called before the element is removed from the DOM
-     *     @unmounted="onUnmounted" - Called after the element is removed from the DOM
+     *     @unmounted="onUnmounted" - Called after VNode cleanup is complete (element reference still available)
      *
      * This directive is essential for handling user interactions and lifecycle events in your application.
      * Note that the methods referenced in the directive should be defined in the component's methods object.
@@ -9585,7 +9586,7 @@
             };
         }
         /**
-         * Creates a wrapper function for DOM event handlers (with event parameter).
+         * Creates a wrapper function for DOM event handlers (with event and $ctx parameters).
          * @param expression The expression string to evaluate.
          * @returns A function that handles the event.
          */
@@ -9595,21 +9596,210 @@
             // Return a function that handles the event with proper scope
             return (event) => {
                 const bindings = vNode.bindings;
+                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
+                    // Pass event as first argument and $ctx as second argument
+                    return originalMethod(event, $ctx);
+                }
+                // For inline expressions, evaluate normally
+                // Note: inline expressions receive event and $ctx as parameters
+                const values = identifiers.map(id => vNode.bindings?.get(id));
+                const args = [...identifiers, 'event', '$ctx'].join(", ");
+                const funcBody = `return (${expression});`;
+                const func = new Function(args, funcBody);
+                return func.call(bindings?.raw, ...values, event, $ctx);
+            };
+        }
+    }
+
+    // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
+    /**
+     * Directive for observing element resize events using ResizeObserver.
+     * The `v-resize` directive allows you to respond to changes in an element's size.
+     *
+     * Example usage:
+     *     <div v-resize="handleResize">Resizable content</div>
+     *
+     * The handler receives ResizeObserverEntry array as the first argument and $ctx as the second:
+     *     handleResize(entries, $ctx) {
+     *       const { width, height } = entries[0].contentRect;
+     *       console.log(`Size: ${width}x${height}`);
+     *     }
+     *
+     * This directive is useful for responsive layouts, charts, and other components
+     * that need to adapt to size changes.
+     */
+    class VResizeDirective {
+        /**
+         * The virtual node to which this directive is applied.
+         */
+        #vNode;
+        /**
+         * A list of variable and function names used in the directive's expression.
+         */
+        #dependentIdentifiers;
+        /**
+         * The resize handler wrapper function.
+         */
+        #handlerWrapper;
+        /**
+         * The ResizeObserver instance.
+         */
+        #resizeObserver;
+        /**
+         * @param context The context for parsing the directive.
+         */
+        constructor(context) {
+            this.#vNode = context.vNode;
+            // Parse the expression to extract identifiers and create the handler wrapper
+            const expression = context.attribute.value;
+            if (expression) {
+                this.#dependentIdentifiers = ExpressionUtils.extractIdentifiers(expression, context.vNode.vApplication.functionDependencies);
+                this.#handlerWrapper = this.#createResizeHandlerWrapper(expression);
+            }
+            // Remove the directive attribute from the element
+            this.#vNode.node.removeAttribute(context.attribute.name);
+        }
+        /**
+         * @inheritdoc
+         */
+        get name() {
+            return StandardDirectiveName.V_RESIZE;
+        }
+        /**
+         * @inheritdoc
+         */
+        get vNode() {
+            return this.#vNode;
+        }
+        /**
+         * @inheritdoc
+         */
+        get needsAnchor() {
+            return false;
+        }
+        /**
+         * @inheritdoc
+         */
+        get bindingsPreparer() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get domUpdater() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get templatize() {
+            return false;
+        }
+        /**
+         * @inheritdoc
+         */
+        get dependentIdentifiers() {
+            return this.#dependentIdentifiers ?? [];
+        }
+        /**
+         * @inheritdoc
+         */
+        get onMount() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onMounted() {
+            if (!this.#handlerWrapper) {
+                return undefined;
+            }
+            const element = this.#vNode.node;
+            const handler = this.#handlerWrapper;
+            return () => {
+                // Create ResizeObserver and start observing
+                this.#resizeObserver = new ResizeObserver((entries) => {
+                    handler(entries);
+                });
+                this.#resizeObserver.observe(element);
+            };
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUpdate() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUpdated() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUnmount() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUnmounted() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        destroy() {
+            // Disconnect the ResizeObserver when the directive is destroyed
+            if (this.#resizeObserver) {
+                this.#resizeObserver.disconnect();
+                this.#resizeObserver = undefined;
+            }
+        }
+        /**
+         * Creates a wrapper function for resize handlers.
+         * @param expression The expression string to evaluate.
+         * @returns A function that handles the resize event.
+         */
+        #createResizeHandlerWrapper(expression) {
+            const identifiers = this.#dependentIdentifiers ?? [];
+            const vNode = this.#vNode;
+            // Return a function that handles the resize event with proper scope
+            return (entries) => {
+                const bindings = vNode.bindings;
+                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
-                    // This allows the method to access and modify bindings properties via 'this'
-                    return originalMethod(event);
+                    // Pass entries as first argument and $ctx as second argument
+                    return originalMethod(entries, $ctx);
                 }
                 // For inline expressions, evaluate normally
+                // Note: inline expressions receive entries and $ctx as parameters
                 const values = identifiers.map(id => vNode.bindings?.get(id));
-                const args = identifiers.join(", ");
+                const args = [...identifiers, 'entries', '$ctx'].join(", ");
                 const funcBody = `return (${expression});`;
                 const func = new Function(args, funcBody);
-                return func.call(bindings?.raw, ...values, event);
+                return func.call(bindings?.raw, ...values, entries, $ctx);
             };
         }
     }
@@ -9839,7 +10029,9 @@
                 context.attribute.name.startsWith(":") ||
                 // v-model, v-model.<modifier>
                 context.attribute.name === StandardDirectiveName.V_MODEL ||
-                context.attribute.name.startsWith(StandardDirectiveName.V_MODEL + ".")) {
+                context.attribute.name.startsWith(StandardDirectiveName.V_MODEL + ".") ||
+                // v-resize
+                context.attribute.name === StandardDirectiveName.V_RESIZE) {
                 return true;
             }
             return false;
@@ -9878,6 +10070,10 @@
                 context.attribute.name.startsWith(StandardDirectiveName.V_MODEL + ".")) {
                 return new VModelDirective(context);
             }
+            // v-resize
+            if (context.attribute.name === StandardDirectiveName.V_RESIZE) {
+                return new VResizeDirective(context);
+            }
             throw new Error(`The attribute "${context.attribute.name}" cannot be parsed by ${this.name}.`);
         }
     }