@mintjamsinc/ichigojs 0.1.58 → 0.1.60

package/dist/types/ichigo/VNode.d.ts

@@ -3,6 +3,7 @@ import { VBindings } from "./VBindings";
 import { VCloser } from "./VCloser";
 import { VDirectiveManager } from "./directives/VDirectiveManager";
 import { VNodeInit } from "./VNodeInit";
+import { VFragmentRange } from "./util/VFragmentRange";
 /**
  * Represents a virtual node in the virtual DOM.
  * A virtual node corresponds to a real DOM node and contains additional information for data binding and directives.
@@ -91,6 +92,13 @@ export declare class VNode {
      * @returns A Map for storing user data.
      */
     get userData(): Map<string, any>;
+    /**
+     * The DOM range that bounds this VNode's expanded fragment content, if any.
+     * Set by directives that expand a <template> into a DocumentFragment
+     * (currently v-for and v-if).
+     */
+    get fragmentRange(): VFragmentRange | undefined;
+    set fragmentRange(range: VFragmentRange | undefined);
     /**
      * The DOM path of this virtual node.
      * This is a string representation of the path from the root to this node,

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

@@ -29,5 +29,7 @@ export declare enum StandardDirectiveName {
     /** Raw HTML content directive. */
     V_HTML = "v-html",
     /** Text content directive. */
-    V_TEXT = "v-text"
+    V_TEXT = "v-text",
+    /** Focus management directive. */
+    V_FOCUS = "v-focus"
 }

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

@@ -0,0 +1,87 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Directive for managing focus on form elements.
+ *
+ * Usage:
+ *     <input v-focus>                           Focus once on mount.
+ *     <input v-focus.select>                    Focus + select all on mount.
+ *     <input v-focus="isOpen">                  Focus when expression transitions from falsy to truthy.
+ *     <input v-focus.select="isOpen">           Conditional focus + select all.
+ *     <input v-focus.cursor-end="isOpen">       Conditional focus + place caret at end.
+ *
+ * Behavior notes:
+ * - Without an expression, the element is focused exactly once after mount.
+ * - With an expression, focus fires only on the falsy -> truthy edge,
+ *   so the user is not repeatedly re-focused on every reactive update.
+ * - If the value is already truthy on mount, the element is focused.
+ * - Focus is deferred via requestAnimationFrame so that elements which
+ *   become visible just before this directive runs (e.g. inside v-if /
+ *   display:none containers) can still receive focus reliably.
+ */
+export declare class VFocusDirective 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/util/VFragmentRange.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Represents a contiguous range of DOM nodes that conceptually belong to a single VNode
+ * whose source is a <template> element (and therefore expands to multiple sibling nodes
+ * when inserted into the DOM).
+ *
+ * The range is bounded by two comment markers (start and end). All nodes between the
+ * markers (inclusive) form the range. Move and remove operations always act on the
+ * entire range atomically via the DOM Range API, which prevents the marker pair from
+ * becoming desynchronized from the content it bounds.
+ *
+ * This abstraction replaces ad-hoc per-marker bookkeeping previously stored in
+ * {@link VNode.userData} by directives such as v-for and v-if.
+ */
+export declare class VFragmentRange {
+    #private;
+    private constructor();
+    /**
+     * Inserts content into a parent before the given reference sibling (or as last
+     * child when {@code refSibling} is null), wrapping it with start/end comment
+     * markers. Returns a {@link VFragmentRange} that tracks the inserted region.
+     *
+     * @param parent      The parent node to insert into.
+     * @param refSibling  The sibling to insert before (null = append).
+     * @param label       A short label used for the marker comment text (helps debugging).
+     * @param content     The content to insert. Typically a DocumentFragment cloned
+     *                    from a template's content, but any Node works.
+     */
+    static insert(parent: Node, refSibling: Node | null, label: string, content: Node): VFragmentRange;
+    /**
+     * The start marker (inclusive boundary).
+     */
+    get firstNode(): Comment;
+    /**
+     * The end marker (inclusive boundary).
+     */
+    get lastNode(): Comment;
+    /**
+     * Move the entire range (start marker through end marker, inclusive) to be
+     * inserted before {@code refSibling} under {@code parent}. If {@code refSibling}
+     * is null the range is appended.
+     *
+     * Implemented via the DOM Range API so that all nodes between the markers move
+     * together as a single contiguous block, regardless of how many or which kinds
+     * of nodes currently sit between them.
+     */
+    moveBefore(parent: Node, refSibling: Node | null): void;
+    /**
+     * Remove the entire range (start marker through end marker, inclusive) from its
+     * current parent. Safe to call even if the markers are already detached.
+     */
+    remove(): void;
+}

package/package.json

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