@mintjamsinc/ichigojs 0.1.73 → 0.1.75

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

@@ -47,6 +47,11 @@ export declare class VApplication {
      * Gets the function dependencies for the virtual application.
      */
     get functionDependencies(): Record<string, string[]>;
+    /**
+     * Gets the template references registered via the `ref` directive (Vue's `$refs`). The same
+     * object is exposed to data(), methods, and expressions as `$refs`. Non-reactive by design.
+     */
+    get refs(): Record<string, Element | Element[]>;
     /**
      * Mounts the application.
      * @param target The CSS selector string or HTMLElement to mount the application to.
@@ -70,4 +75,26 @@ export declare class VApplication {
      * @returns An array of dependent identifiers.
      */
     resolveDependentIdentifiers(computedName: string, value: any): string[];
+    /**
+     * Registers a template reference under the given name. Called by the `ref` directive during the
+     * mount phase. When {@param asArray} is true (the element lives inside a `v-for`), references
+     * accumulate into an array in registration order; otherwise the name holds a single element.
+     *
+     * Mutates the raw (non-reactive) `$refs` object directly, so this never schedules a render.
+     *
+     * @param name The ref name.
+     * @param element The element (or component host element) to register.
+     * @param asArray Whether to collect into an array (refs used inside a v-for).
+     */
+    registerRef(name: string, element: Element, asArray: boolean): void;
+    /**
+     * Removes a template reference registered under the given name. Called by the `ref` directive
+     * during the unmount phase. The removal is identity-safe: an entry is only cleared when it still
+     * points at {@param element}, so a newly mounted element that reused the name is never clobbered
+     * by the teardown of the element it replaced.
+     *
+     * @param name The ref name.
+     * @param element The element whose registration should be removed.
+     */
+    unregisterRef(name: string, element: Element): void;
 }

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

@@ -38,6 +38,17 @@ export declare class VBindings {
      * @param value The binding value.
      */
     set(key: string, value: any): void;
+    /**
+     * Sets a binding value in THIS scope's own local store, without walking up to a
+     * parent scope. Used for scope-local variables (e.g. v-for loop items) that must
+     * shadow — never overwrite — an inherited binding of the same name. Contrast with
+     * {@link set}, which retargets a write of an inherited key to the owning parent so
+     * that reassignments mutate the original; a loop variable named like a root data /
+     * method / computed key (e.g. `t`) would otherwise clobber it.
+     * @param key The binding name.
+     * @param value The binding value.
+     */
+    setLocal(key: string, value: any): void;
     /**
      * Gets a binding value.
      * @param key The binding name.

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

@@ -31,5 +31,7 @@ export declare enum StandardDirectiveName {
     /** Text content directive. */
     V_TEXT = "v-text",
     /** Focus management directive. */
-    V_FOCUS = "v-focus"
+    V_FOCUS = "v-focus",
+    /** Template reference directive (Vue's `ref` / `$refs`). */
+    REF = "ref"
 }

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

@@ -0,0 +1,94 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Directive for registering template references (Vue's `ref` / `$refs`).
+ *
+ * Usage:
+ *     <input ref="search">                     Static name. $refs.search === the element.
+ *     <my-card ref="card"></my-card>           On a component: $refs.card === the host element.
+ *     <li v-for="i in items" ref="rows">       Inside v-for: $refs.rows === array of elements.
+ *     <input :ref="dynamicName">               Dynamic name from an expression (evaluated at mount).
+ *     <input :ref="el => collect(el)">          Function ref: called with the element on mount,
+ *                                              and with null on unmount (great for v-for / dynamic).
+ *
+ * Behavior notes:
+ * - The reference is registered during the mount phase (before any `@mounted` hook fires) and
+ *   removed during the unmount phase, mirroring Vue's lifecycle for `$refs`.
+ * - `$refs` is intentionally NON-reactive: registering or clearing a ref never schedules a render
+ *   and must not be used to drive reactive template output (this matches Vue).
+ * - When the same `ref` name appears inside a `v-for` (i.e. one of the element's ancestors is a
+ *   `v-for` template), the entries are collected into an array, in registration order. Reused
+ *   v-for rows are not re-registered, so the array order is not guaranteed to match DOM order after
+ *   reordering — the same caveat Vue documents.
+ * - Cleanup is identity-safe: a ref slot (or array entry) is only cleared when it still points at
+ *   THIS element, so a freshly mounted element that reused the name is never clobbered by the
+ *   teardown of the element it replaced.
+ *
+ * The directive is purely lifecycle-driven: it has no DOM updater and never templatizes the node.
+ */
+export declare class VRefDirective 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/VStandardDirectiveParser.d.ts

@@ -5,6 +5,7 @@ import { VDirectiveParser } from "./VDirectiveParser";
  * The directive parser for standard directives.
  */
 export declare class VStandardDirectiveParser implements VDirectiveParser {
+    #private;
     /**
      * @inheritdoc
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintjamsinc/ichigojs",
-  "version": "0.1.73",
+  "version": "0.1.75",
   "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",