@mintjamsinc/ichigojs 0.1.6 → 0.1.8

package/dist/types/ichigo/directives/StandardDirectiveName.d.ts

@@ -6,5 +6,7 @@ export declare enum StandardDirectiveName {
     V_FOR = "v-for",
     V_ON = "v-on",
     V_BIND = "v-bind",
-    V_MODEL = "v-model"
+    V_MODEL = "v-model",
+    V_RESIZE = "v-resize",
+    V_INTERSECTION = "v-intersection"
 }

package/dist/types/ichigo/directives/VBindDirective.d.ts

@@ -58,6 +58,15 @@ export declare class VBindDirective implements VDirective {
      * If this directive is binding the "key" attribute, it will be handled by the VForDirective.
      */
     get isKey(): boolean;
+    /**
+     * Indicates if this directive is binding the "options" attribute or any of its sub-properties (e.g., "options.intersection").
+     * The "options" attribute is special and is used for passing options to certain directives like VIntersectionDirective.
+     */
+    get isOptions(): boolean;
+    /**
+     * Gets the name of the attribute being bound (e.g., "src", "class", "options", "options.intersection").
+     */
+    get attributeName(): string | undefined;
     /**
      * Gets the original expression string from the directive.
      */

package/dist/types/ichigo/directives/VDirective.d.ts

@@ -84,7 +84,8 @@ export interface VDirective {
     get onUnmount(): (() => void) | undefined;
     /**
      * Lifecycle hook called after the directive is unmounted from the DOM.
-     * This is called once, after the element is removed from the DOM.
+     * This is called once, after VNode cleanup is complete.
+     * The element reference is still available at this point.
      */
     get onUnmounted(): (() => void) | undefined;
     /**

package/dist/types/ichigo/directives/VDirectiveManager.d.ts

@@ -3,6 +3,11 @@ import { VNode } from "../VNode";
 import { VBindingsPreparer } from "../VBindingsPreparer";
 import { VDOMUpdater } from "../VDOMUpdater";
 import { VBindDirective } from "./VBindDirective";
+/**
+ * Manages directives associated with a virtual node (VNode).
+ * This class is responsible for parsing, storing, and managing the lifecycle of directives.
+ * It also provides access to bindings preparers and DOM updaters from the associated directives.
+ */
 export declare class VDirectiveManager {
     #private;
     constructor(vNode: VNode);
@@ -32,6 +37,19 @@ export declare class VDirectiveManager {
      * If no such directive exists, this returns undefined.
      */
     get keyDirective(): VBindDirective | undefined;
+    /**
+     * Gets a record of VBindDirectives for options specific to certain directives.
+     * The keys are directive names (e.g., 'options', 'options.intersection').
+     */
+    get optionsDirectives(): Record<string, VBindDirective | undefined>;
+    /**
+     * Gets the VBindDirective for options specific to the given directive name.
+     * Searches in order: `:options.{directive}` -> `:options`
+     *
+     * @param directive The directive name (e.g., 'intersection', 'resize')
+     * @returns The VBindDirective instance or undefined
+     */
+    optionsDirective(directive: string): VBindDirective | undefined;
     /**
      * Cleans up any resources used by the directive handler.
      */

package/dist/types/ichigo/directives/VIntersectionDirective.d.ts

@@ -0,0 +1,91 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Directive for observing element intersection with viewport or ancestor elements using IntersectionObserver.
+ * The `v-intersection` directive allows you to respond to changes in an element's visibility.
+ *
+ * Example usage:
+ *     <div v-intersection="handleIntersection">Observable content</div>
+ *     <div v-intersection="handleIntersection" :options.intersection="{threshold: 0.5}">Observable content</div>
+ *
+ * The handler receives IntersectionObserverEntry array as the first argument and $ctx as the second:
+ *     handleIntersection(entries, $ctx) {
+ *       const entry = entries[0];
+ *       if (entry.isIntersecting) {
+ *         console.log('Element is visible!');
+ *       }
+ *     }
+ *
+ * Options can be provided via :options or :options.intersection attribute:
+ *     :options="{root: null, threshold: 0.5, rootMargin: '0px'}"
+ *     :options.intersection="{root: null, threshold: 0.5, rootMargin: '0px'}"
+ *
+ * This directive is useful for lazy-loading, infinite scrolling, animation triggers,
+ * and other features that depend on element visibility.
+ */
+export declare class VIntersectionDirective implements VDirective {
+    #private;
+    /**
+     * @param context The context for parsing the directive.
+     */
+    constructor(context: VDirectiveParseContext);
+    /**
+     * @inheritdoc
+     */
+    get name(): string;
+    /**
+     * @inheritdoc
+     */
+    get vNode(): VNode;
+    /**
+     * @inheritdoc
+     */
+    get needsAnchor(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get bindingsPreparer(): VBindingsPreparer | undefined;
+    /**
+     * @inheritdoc
+     */
+    get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
+    /**
+     * @inheritdoc
+     */
+    get onMount(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onMounted(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUpdate(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUpdated(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUnmount(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUnmounted(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    destroy(): void;
+}

package/dist/types/ichigo/directives/VOnDirective.d.ts

@@ -19,8 +19,8 @@ import { VDOMUpdater } from "../VDOMUpdater";
  *     @mounted="onMounted"   - Called after the element is inserted into the DOM
  *     @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
+ *     @unmount="onUnmount"   - Called before VNode cleanup begins
+ *     @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.

package/dist/types/ichigo/directives/VResizeDirective.d.ts

@@ -0,0 +1,84 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * 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.
+ */
+export declare class VResizeDirective implements VDirective {
+    #private;
+    /**
+     * @param context The context for parsing the directive.
+     */
+    constructor(context: VDirectiveParseContext);
+    /**
+     * @inheritdoc
+     */
+    get name(): string;
+    /**
+     * @inheritdoc
+     */
+    get vNode(): VNode;
+    /**
+     * @inheritdoc
+     */
+    get needsAnchor(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get bindingsPreparer(): VBindingsPreparer | undefined;
+    /**
+     * @inheritdoc
+     */
+    get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
+    /**
+     * @inheritdoc
+     */
+    get onMount(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onMounted(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUpdate(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUpdated(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUnmount(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    get onUnmounted(): (() => void) | undefined;
+    /**
+     * @inheritdoc
+     */
+    destroy(): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintjamsinc/ichigojs",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "ichigo.js - Simple and intuitive reactive framework. Lightweight, fast, and user-friendly virtual DOM library",
   "main": "./dist/ichigo.umd.js",
   "module": "./dist/ichigo.esm.js",