@mintjamsinc/ichigojs 0.1.0 → 0.1.2

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

@@ -31,7 +31,7 @@ export declare class VApplication {
     /**
      * Gets the bindings for the virtual application.
      */
-    get bindings(): VBindings;
+    get bindings(): VBindings | undefined;
     /**
      * Gets the log manager.
      */
@@ -40,27 +40,9 @@ export declare class VApplication {
      * Gets the function dependencies for the virtual application.
      */
     get functionDependencies(): Record<string, string[]>;
-    /**
-     * Gets the list of identifiers that can trigger updates.
-     */
-    get preparableIdentifiers(): string[];
     /**
      * Mounts the application.
      * @param selectors The CSS selectors to identify the root element.
      */
     mount(selectors: string): void;
-    /**
-     * Schedules a DOM update in the next microtask.
-     * Multiple calls within the same event loop will be batched into a single update.
-     */
-    scheduleUpdate(): void;
-    /**
-     * Executes an immediate DOM update.
-     */
-    update(): void;
-    /**
-     * Executes a callback after the next DOM update.
-     * @param callback The callback to execute.
-     */
-    nextTick(callback: () => void): void;
 }

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

@@ -1,9 +1,59 @@
+import { VBindingsInit } from "./VBindingsInit";
 /**
  * A dictionary representing bindings for a virtual node.
+ * The key is the binding name, and the value is the binding value.
+ * Supports hierarchical lookup through parent bindings.
  */
-export interface VBindings {
+export declare class VBindings {
+    #private;
     /**
-     * The key is the binding name, and the value is the binding value.
+     * Creates a new instance of VBindings.
+     * @param parent The parent bindings, if any.
      */
-    [key: string]: any;
+    constructor(args?: VBindingsInit);
+    /**
+     * Gets the raw bindings.
+     * If a key is not found locally, it searches parent bindings recursively.
+     */
+    get raw(): Record<string, any>;
+    /**
+     * Indicates whether there are any changed identifiers.
+     */
+    get hasChanges(): boolean;
+    /**
+     * Gets the list of changed identifiers.
+     */
+    get changes(): string[];
+    /**
+     * Indicates whether this is the root bindings (i.e., has no parent).
+     */
+    get isRoot(): boolean;
+    /**
+     * Clears the set of changed identifiers.
+     */
+    clearChanges(): void;
+    /**
+     * Sets a binding value.
+     * @param key The binding name.
+     * @param value The binding value.
+     */
+    set(key: string, value: any): void;
+    /**
+     * Gets a binding value.
+     * @param key The binding name.
+     * @returns The binding value, or undefined if not found.
+     */
+    get(key: string): any;
+    /**
+     * Checks if a binding exists.
+     * @param key The binding name.
+     * @param recursive Whether to search parent bindings. Default is true.
+     * @returns True if the binding exists, false otherwise.
+     */
+    has(key: string, recursive?: boolean): boolean;
+    /**
+     * Removes a local binding.
+     * @param key The binding name.
+     */
+    remove(key: string): void;
 }

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

@@ -0,0 +1,15 @@
+import { VBindings } from "./VBindings";
+/**
+ * Initialization arguments for bindings.
+ */
+export interface VBindingsInit {
+    /**
+     * The parent bindings, if any.
+     */
+    parent?: VBindings;
+    /**
+     * The change tracker, if any.
+     * @param identifier The identifier that changed.
+     */
+    onChange?: (identifier: string) => void;
+}

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

@@ -1,13 +1,12 @@
-import { VBindings } from "./VBindings";
 /**
  * Interface representing a preparer for VBindings in the virtual DOM.
  */
 export interface VBindingsPreparer {
     /**
-     * The list of identifiers that this preparer is concerned with.
-     * These identifiers are used to determine when the bindings need to be prepared.
+     * The list of identifiers that this preparer depends on.
+     * Changes to these identifiers may trigger the need to prepare bindings again.
      */
-    get identifiers(): string[];
+    get dependentIdentifiers(): string[];
     /**
      * The list of identifiers that can be prepared by this preparer.
      * This is a subset of the identifiers property.
@@ -17,7 +16,6 @@ export interface VBindingsPreparer {
      * Prepares the given VBindings for use in the virtual DOM.
      * This method is called before the bindings are applied to the DOM.
      * It allows for any necessary transformations or initializations of the bindings.
-     * @param bindings The original VBindings to be prepared.
      */
-    prepareBindings(bindings: VBindings): void;
+    prepareBindings(): void;
 }

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

@@ -5,10 +5,10 @@
  */
 export interface VDOMUpdater {
     /**
-     * A list of variable and function names that this updater is concerned with.
+     * The list of identifiers that this updater depends on.
      * Changes to these identifiers may trigger the updater to apply changes to the DOM.
      */
-    get identifiers(): string[];
+    get dependentIdentifiers(): string[];
     /**
      * Applies the changes from the virtual DOM to the actual DOM.
      * This method is called when the identifiers change or when an update is needed.

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

@@ -3,7 +3,11 @@ import { VBindings } from "./VBindings";
 import { VCloser } from "./VCloser";
 import { VDirectiveManager } from "./directives/VDirectiveManager";
 import { VNodeInit } from "./VNodeInit";
-import { VUpdateContext } from "./VUpdateContext";
+/**
+ * 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.
+ * This class is responsible for managing the state and behavior of the virtual node, including its bindings, directives, and child nodes.
+ */
 export declare class VNode {
     #private;
     /**
@@ -50,7 +54,7 @@ export declare class VNode {
     /**
      * The data bindings associated with this virtual node, if any.
      */
-    get bindings(): VBindings | undefined;
+    get bindings(): VBindings;
     /**
      * The directive manager associated with this virtual node.
      * This manages any directives applied to the node.
@@ -78,22 +82,44 @@ export declare class VNode {
      * The list of identifiers for this virtual node.
      * This includes variable and function names used in expressions.
      */
-    get identifiers(): string[];
+    get dependentIdentifiers(): string[];
     get preparableIdentifiers(): string[];
+    /**
+     * The DOM path of this virtual node.
+     * This is a string representation of the path from the root to this node,
+     * using the node names and their indices among siblings with the same name.
+     * For example: "DIV[0]/SPAN[1]/#text[0]"
+     * @return The DOM path as a string.
+     */
+    get domPath(): string;
     /**
      * Updates the virtual node and its children based on the current bindings.
      * This method evaluates any expressions in text nodes and applies effectors from directives.
      * It also recursively updates child virtual nodes.
      * @param context The context for the update operation.
+     * This includes the current bindings and a list of identifiers that have changed.
+     */
+    update(): void;
+    /**
+     * Forces an update of the virtual node and its children, regardless of changed identifiers.
+     * This method evaluates any expressions in text nodes and applies effectors from directives.
+     * It also recursively updates child virtual nodes.
+     * This is useful when an immediate update is needed, bypassing the usual change detection.
+     */
+    forceUpdate(): void;
+    /**
+     * Adds a child virtual node to this virtual node.
+     * @param child The child virtual node to add.
      */
-    update(context: VUpdateContext): void;
+    addChild(child: VNode): void;
     /**
-     * Adds a dependency on the specified virtual node.
-     * This means that if the specified node's bindings change, this node may need to be updated.
-     * @param dependentNode The virtual node to add as a dependency.
+     * Adds a dependent virtual node that relies on this node's bindings.
+     * @param dependent The dependent virtual node to add.
+     * @param dependentIdentifiers The identifiers that the dependent node relies on.
+     * If not provided, the dependent node's own identifiers will be used.
      * @returns A list of closers to unregister the dependency, or undefined if no dependency was added.
      */
-    addDependency(dependentNode: VNode): VCloser[] | undefined;
+    addDependent(dependent: VNode, dependentIdentifiers?: string[] | undefined): VCloser[] | undefined;
     /**
      * Cleans up any resources used by this virtual node.
      * This method is called when the virtual node is no longer needed.

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

@@ -1,6 +1,5 @@
 import { VApplication } from "./VApplication";
 import { VBindings } from "./VBindings";
-import { VBindingsPreparer } from "./VBindingsPreparer";
 import { VNode } from "./VNode";
 /**
  * Initialization arguments for a virtual node.
@@ -19,11 +18,13 @@ export interface VNodeInit {
      */
     parentVNode?: VNode;
     /**
-     * The data bindings associated with this virtual node.
+     * The bindings associated with this virtual node.
+     * This is optional and may be undefined if there are no bindings.
      */
-    bindings: VBindings;
+    bindings?: VBindings;
     /**
-     * The preparer for VBindings, if any.
+     * The set of identifiers that this node depends on.
+     * This is optional and may be undefined if there are no dependent identifiers.
      */
-    bindingsPreparer?: VBindingsPreparer;
+    dependentIdentifiers?: string[];
 }

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

@@ -44,6 +44,14 @@ export declare class VBindDirective implements VDirective {
      * @inheritdoc
      */
     get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
     /**
      * Indicates if this directive is binding the "key" attribute.
      * The "key" attribute is special and is used for optimizing rendering of lists.

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

@@ -30,6 +30,14 @@ export declare abstract class VConditionalDirective implements VDirective {
      * @inheritdoc
      */
     get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
     /**
      * The context for managing related conditional directives (v-if, v-else-if, v-else).
      */

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

@@ -4,6 +4,11 @@ import { VConditionalDirective } from "./VConditionalDirective";
  */
 export declare class VConditionalDirectiveContext {
     #private;
+    /**
+     * Gets a list of all variable and function names used in the expressions of the associated directives.
+     * This is useful for determining dependencies for re-evaluation when data changes.
+     */
+    get allDependentIdentifiers(): string[];
     /**
      * Adds a directive (v-else-if or v-else) to the conditional context.
      * @param directive The directive to add.

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

@@ -40,6 +40,23 @@ export interface VDirective {
      * If the directive does not need to update the DOM, this may return undefined.
      */
     get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * Indicates whether this directive requires the template content to be preserved.
+     * If true, the original template content will be kept intact and used as needed by the directive.
+     * This is typically true for directives that need to re-render or clone the template content,
+     * such as v-for and v-if.
+     * If false, the template content may be modified or removed as part of the directive's processing.
+     * Directives that do not need to preserve the original template content should return false.
+     * This property is used by the VNode to determine how to handle the template content.
+     * Note: This property should be implemented as a getter to allow dynamic evaluation based on directive state.
+     */
+    get templatize(): boolean;
+    /**
+     * Gets the list of dependent identifiers for this directive.
+     * These are the variable and function names that the directive depends on.
+     * @returns An array of dependent identifier names.
+     */
+    get dependentIdentifiers(): string[];
     /**
      * Cleans up any resources used by the directive.
      * This method is called when the directive is no longer needed.

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

@@ -44,6 +44,14 @@ export declare class VForDirective implements VDirective {
      * @inheritdoc
      */
     get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
     /**
      * @inheritdoc
      */

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

@@ -40,6 +40,14 @@ export declare class VModelDirective implements VDirective {
      * @inheritdoc
      */
     get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
     /**
      * @inheritdoc
      */

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

@@ -42,6 +42,14 @@ export declare class VOnDirective implements VDirective {
      * @inheritdoc
      */
     get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
     /**
      * @inheritdoc
      */

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

@@ -39,6 +39,14 @@ export declare class VShowDirective implements VDirective {
      * @inheritdoc
      */
     get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * @inheritdoc
+     */
+    get templatize(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get dependentIdentifiers(): string[];
     /**
      * Makes the node visible by resetting its display style.
      * If the node is already visible, no action is taken.

package/dist/types/ichigo/util/ReactiveProxy.d.ts

@@ -3,19 +3,20 @@
  */
 export declare class ReactiveProxy {
     /**
-     * A WeakMap to store the original target for each proxy.
-     * This allows us to avoid creating multiple proxies for the same object.
+     * A WeakMap to store the proxy for each target object and path combination.
+     * This prevents creating multiple proxies for the same object accessed from different paths.
      */
-    private static proxyMap;
+    private static proxyCache;
     /**
      * Creates a reactive proxy for the given object.
      * The proxy will call the onChange callback whenever a property is modified.
      *
      * @param target The object to make reactive.
-     * @param onChange Callback function to call when the object changes. Receives the changed key name.
+     * @param onChange Callback function to call when the object changes. Receives the full path of the changed property.
+     * @param path The current path in the object tree (used internally for nested objects).
      * @returns A reactive proxy of the target object.
      */
-    static create<T extends object>(target: T, onChange: (changedKey?: string) => void): T;
+    static create<T extends object>(target: T, onChange: (changedPath?: string) => void, path?: string): T;
     /**
      * Checks if the given object is a reactive proxy.
      *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintjamsinc/ichigojs",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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",
@@ -11,7 +11,7 @@
   "homepage": "https://github.com/mintjamsinc/ichigojs#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mintjamsinc/ichigojs.git"
+    "url": "git+https://github.com/mintjamsinc/ichigojs.git"
   },
   "bugs": {
     "url": "https://github.com/mintjamsinc/ichigojs/issues"