@mintjamsinc/ichigojs 0.1.0

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

@@ -0,0 +1,66 @@
+import { VLogManager } from "./util/VLogManager";
+import { VApplicationOptions } from "./VApplicationOptions";
+import { VBindings } from "./VBindings";
+import { VNode } from "./VNode";
+import type { VDirectiveParserRegistry } from "./directives/VDirectiveParserRegistry";
+import { VComponentRegistry } from "./components/VComponentRegistry";
+/**
+ * Represents a virtual application instance.
+ */
+export declare class VApplication {
+    #private;
+    /**
+     * Creates an instance of the virtual application.
+     * @param options The application options.
+     * @param directiveParserRegistry The global directive parser registry.
+     * @param componentRegistry The global component registry.
+     */
+    constructor(options: VApplicationOptions, directiveParserRegistry: VDirectiveParserRegistry, componentRegistry: VComponentRegistry);
+    /**
+     * Gets the global directive parser registry.
+     */
+    get directiveParserRegistry(): VDirectiveParserRegistry;
+    /**
+     * Gets the global component registry.
+     */
+    get componentRegistry(): VComponentRegistry;
+    /**
+     * Gets the root virtual node.
+     */
+    get rootVNode(): VNode | undefined;
+    /**
+     * Gets the bindings for the virtual application.
+     */
+    get bindings(): VBindings;
+    /**
+     * Gets the log manager.
+     */
+    get logManager(): VLogManager;
+    /**
+     * 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/VApplicationOptions.d.ts

@@ -0,0 +1,28 @@
+import { LogLevel } from "./util/LogLevel";
+export interface VApplicationOptions {
+    /**
+     * A function that returns the initial data for the application.
+     * @returns The initial data for the application.
+     */
+    data: () => unknown;
+    /**
+     * A dictionary of computed properties for the application.
+     * Each key is the name of the computed property, and the value is a function that computes its value.
+     */
+    computed?: {
+        [key: string]: () => unknown;
+    };
+    /**
+     * A dictionary of methods for the application.
+     * Each key is the name of the method, and the value is a function that implements the method.
+     */
+    methods?: {
+        [key: string]: (...args: unknown[]) => unknown;
+    };
+    /**
+     * The log level for the application.
+     * This property determines the verbosity of logging output.
+     * If not specified, the default log level will be used.
+     */
+    logLevel?: LogLevel;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * A dictionary representing bindings for a virtual node.
+ */
+export interface VBindings {
+    /**
+     * The key is the binding name, and the value is the binding value.
+     */
+    [key: string]: any;
+}

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

@@ -0,0 +1,23 @@
+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.
+     */
+    get identifiers(): string[];
+    /**
+     * The list of identifiers that can be prepared by this preparer.
+     * This is a subset of the identifiers property.
+     */
+    get preparableIdentifiers(): string[];
+    /**
+     * 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;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Interface representing a closer for effector registration.
+ */
+export interface VCloser {
+    /**
+     * Closes the effector registration, cleaning up any resources used.
+     */
+    close(): void;
+}

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

@@ -0,0 +1,2 @@
+export declare class VComponent {
+}

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

@@ -0,0 +1,2 @@
+export declare class VComponentRegistry {
+}

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

@@ -0,0 +1,30 @@
+import { VComponentRegistry } from './components/VComponentRegistry';
+import { VDirectiveParserRegistry } from './directives/VDirectiveParserRegistry';
+import { VApplication } from './VApplication';
+/**
+ * The main entry point for the virtual DOM library.
+ */
+export declare class VDOM {
+    #private;
+    /**
+     * Gets the component registry.
+     * @return {VComponentRegistry} The component registry.
+     */
+    static get componentRegistry(): VComponentRegistry;
+    /**
+     * Gets the directive parser registry.
+     * @return {VDirectiveParserRegistry} The directive parser registry.
+     */
+    static get directiveParserRegistry(): VDirectiveParserRegistry;
+    /**
+     * Checks if the current environment supports the required features.
+     * @return {boolean} True if supported, false otherwise.
+     */
+    static get isSupported(): boolean;
+    /**
+     * Creates a virtual application instance.
+     * @param options The options for the virtual application.
+     * @returns The created virtual application instance.
+     */
+    static createApp(options: any): VApplication;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Interface representing an updater for the virtual DOM.
+ * An implementation of this interface is responsible for applying changes
+ * from the virtual DOM to the actual DOM.
+ */
+export interface VDOMUpdater {
+    /**
+     * A list of variable and function names that this updater is concerned with.
+     * Changes to these identifiers may trigger the updater to apply changes to the DOM.
+     */
+    get identifiers(): 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.
+     */
+    applyToDOM(): void;
+}

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

@@ -0,0 +1,102 @@
+import { VApplication } from "./VApplication";
+import { VBindings } from "./VBindings";
+import { VCloser } from "./VCloser";
+import { VDirectiveManager } from "./directives/VDirectiveManager";
+import { VNodeInit } from "./VNodeInit";
+import { VUpdateContext } from "./VUpdateContext";
+export declare class VNode {
+    #private;
+    /**
+     * Creates an instance of the virtual node.
+     * @param args The initialization arguments for the virtual node.
+     */
+    constructor(args: VNodeInit);
+    /**
+     * The application instance associated with this virtual node.
+     */
+    get vApplication(): VApplication;
+    /**
+     * The node associated with this virtual node.
+     */
+    get node(): Node;
+    /**
+     * The type of the node associated with this virtual node.
+     */
+    get nodeType(): number;
+    /**
+     * The name of the node associated with this virtual node.
+     */
+    get nodeName(): string;
+    /**
+     * The parent virtual node, if any.
+     * This is optional and may be undefined for the root node.
+     */
+    get parentVNode(): VNode | undefined;
+    /**
+     * The child virtual nodes, if any.
+     * This is optional and may be undefined if there are no child nodes.
+     */
+    get childVNodes(): VNode[] | undefined;
+    /**
+     * The previous sibling virtual node, if any.
+     * This is optional and may be undefined if there is no previous sibling.
+     */
+    get previousSibling(): VNode | undefined;
+    /**
+     * The next sibling virtual node, if any.
+     * This is optional and may be undefined if there is no next sibling.
+     */
+    get nextSibling(): VNode | undefined;
+    /**
+     * The data bindings associated with this virtual node, if any.
+     */
+    get bindings(): VBindings | undefined;
+    /**
+     * The directive manager associated with this virtual node.
+     * This manages any directives applied to the node.
+     */
+    get directiveManager(): VDirectiveManager | undefined;
+    /**
+     * The anchor comment node used to mark the position of the element in the DOM.
+     * This is used for directives that may remove the element from the DOM,
+     * allowing it to be re-inserted at the correct position later.
+     * This is optional and may be undefined if not applicable.
+     */
+    get anchorNode(): Comment | undefined;
+    /**
+     * Indicates whether the node is currently in the DOM.
+     * This checks if the node has a parent that is not a document fragment.
+     * @return True if the node is in the DOM, otherwise false.
+     */
+    get isInDOM(): boolean;
+    /**
+     * Indicates whether this virtual node is the root node (i.e., has no parent).
+     * @return True if this is the root node, otherwise false.
+     */
+    get isRoot(): boolean;
+    /**
+     * The list of identifiers for this virtual node.
+     * This includes variable and function names used in expressions.
+     */
+    get identifiers(): string[];
+    get preparableIdentifiers(): 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.
+     */
+    update(context: VUpdateContext): 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.
+     * @returns A list of closers to unregister the dependency, or undefined if no dependency was added.
+     */
+    addDependency(dependentNode: VNode): VCloser[] | undefined;
+    /**
+     * Cleans up any resources used by this virtual node.
+     * This method is called when the virtual node is no longer needed.
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,29 @@
+import { VApplication } from "./VApplication";
+import { VBindings } from "./VBindings";
+import { VBindingsPreparer } from "./VBindingsPreparer";
+import { VNode } from "./VNode";
+/**
+ * Initialization arguments for a virtual node.
+ */
+export interface VNodeInit {
+    /**
+     * The DOM node associated with this virtual node.
+     */
+    node: Node;
+    /**
+     * The virtual application instance this node belongs to.
+     */
+    vApplication: VApplication;
+    /**
+     * The parent virtual node, if any.
+     */
+    parentVNode?: VNode;
+    /**
+     * The data bindings associated with this virtual node.
+     */
+    bindings: VBindings;
+    /**
+     * The preparer for VBindings, if any.
+     */
+    bindingsPreparer?: VBindingsPreparer;
+}

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

@@ -0,0 +1,29 @@
+import { VBindings } from "./VBindings";
+/**
+ * A class to evaluate text with embedded expressions in the form of {{...}}.
+ * It extracts identifiers from the expressions and evaluates them using provided bindings.
+ */
+export declare class VTextEvaluator {
+    #private;
+    /**
+     * Constructs a VTextEvaluator instance.
+     * @param text The text containing embedded expressions in the form of {{...}}.
+     * @param functionDependencies A dictionary mapping function names to their dependencies.
+     */
+    constructor(text: string, functionDependencies: Record<string, string[]>);
+    /**
+     * Checks if the given text contains any expressions in the form of {{...}}.
+     * @param text The text to check.
+     * @returns True if the text contains expressions, false otherwise.
+     */
+    static containsExpression(text: string): boolean;
+    /**
+     * Gets the list of identifiers extracted from the text expressions.
+     */
+    get identifiers(): string[];
+    /**
+     * Evaluates the text with the provided bindings and returns the resulting string.
+     * @param bindings The bindings to use for evaluating the expressions.
+     */
+    evaluate(bindings: VBindings): string;
+}

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

@@ -0,0 +1,21 @@
+import { VBindings } from "./VBindings";
+/**
+ * Context provided during the update of the virtual DOM.
+ * This context includes the current bindings and a list of identifiers that have changed.
+ */
+export interface VUpdateContext {
+    /**
+     * The current bindings.
+     */
+    bindings: VBindings;
+    /**
+     * A list of variable and function names whose values have changed.
+     */
+    changedIdentifiers: string[];
+    /**
+     * Indicates if this is the initial update.
+     * This flag is true when the update is being performed for the first time after the VNode's creation.
+     * It can be used to optimize rendering or initialization logic that should only run once.
+     */
+    isInitial?: boolean;
+}

package/dist/types/ichigo/components/VComponent.d.ts

@@ -0,0 +1,2 @@
+export declare class VComponent {
+}

package/dist/types/ichigo/components/VComponentRegistry.d.ts

@@ -0,0 +1,2 @@
+export declare class VComponentRegistry {
+}

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

@@ -0,0 +1,10 @@
+export declare enum StandardDirectiveName {
+    V_IF = "v-if",
+    V_ELSE_IF = "v-else-if",
+    V_ELSE = "v-else",
+    V_SHOW = "v-show",
+    V_FOR = "v-for",
+    V_ON = "v-on",
+    V_BIND = "v-bind",
+    V_MODEL = "v-model"
+}

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

@@ -0,0 +1,61 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Directive for binding dynamic attributes to DOM elements.
+ * The `v-bind` directive allows you to bind HTML attributes to expressions in your data model.
+ * The syntax for using the `v-bind` directive is `v-bind:attribute="expression"`, where `attribute` is the name of the HTML attribute you want to bind (e.g., `src`, `href`, `class`, etc.), and `expression` is a JavaScript expression that evaluates to the value you want to assign to that attribute.
+ * Example usage:
+ *     <img v-bind:src="imageSrc" />
+ * The value of `imageSrc` should be defined in the component's data object.
+ * When the value of `imageSrc` changes, the `src` attribute of the `<img>` element will automatically update to reflect the new value.
+ * This directive is particularly useful for dynamically updating attributes based on user interactions or other data changes in your application.
+ * It helps keep the DOM in sync with the underlying data model, making it easier to build reactive user interfaces.
+ * The `v-bind` directive can also be used with shorthand syntax using a colon (:).
+ * For example, `:src="imageSrc"` is equivalent to `v-bind:src="imageSrc"`.
+ * This shorthand syntax is often used for brevity and improved readability in templates.
+ * Overall, the `v-bind` directive is a powerful tool for creating dynamic and responsive web applications by allowing seamless integration between the data model and the DOM.
+ */
+export declare class VBindDirective 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;
+    /**
+     * Indicates if this directive is binding the "key" attribute.
+     * The "key" attribute is special and is used for optimizing rendering of lists.
+     * If this directive is binding the "key" attribute, it will be handled by the VForDirective.
+     */
+    get isKey(): boolean;
+    /**
+     * Gets the original expression string from the directive.
+     */
+    get expression(): string | undefined;
+    /**
+     * @inheritdoc
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,24 @@
+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.
+     */
+    get identifiers(): string[];
+    /**
+     * The list of identifiers that can be prepared by this preparer.
+     * This is a subset of the identifiers property.
+     */
+    get preparableIdentifiers(): string[];
+    /**
+     * Prepares the VBindings for the virtual node.
+     * 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.
+     * @returns The prepared VBindings.
+     */
+    prepareBindings(bindings: VBindings): VBindings;
+}

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

@@ -0,0 +1,47 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VConditionalDirectiveContext } from "./VConditionalDirectiveContext";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+export declare abstract class VConditionalDirective implements VDirective {
+    #private;
+    /**
+     * @param context The context for parsing the directive.
+     */
+    constructor(context: VDirectiveParseContext);
+    /**
+     * @inheritdoc
+     */
+    abstract get name(): string;
+    /**
+     * @inheritdoc
+     */
+    get vNode(): VNode;
+    /**
+     * @inheritdoc
+     */
+    get needsAnchor(): boolean;
+    /**
+     * @inheritdoc
+     */
+    get bindingsPreparer(): VBindingsPreparer | undefined;
+    /**
+     * @inheritdoc
+     */
+    get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * The context for managing related conditional directives (v-if, v-else-if, v-else).
+     */
+    get conditionalContext(): VConditionalDirectiveContext;
+    /**
+     * Indicates whether the condition for this directive is currently met.
+     * For v-if and v-else-if, this depends on the evaluation of their expressions.
+     * For v-else, this is always true.
+     */
+    get conditionIsMet(): boolean;
+    /**
+     * @inheritdoc
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,19 @@
+import { VConditionalDirective } from "./VConditionalDirective";
+/**
+ * Context for managing related conditional directives (v-if, v-else-if, v-else).
+ */
+export declare class VConditionalDirectiveContext {
+    #private;
+    /**
+     * Adds a directive (v-else-if or v-else) to the conditional context.
+     * @param directive The directive to add.
+     */
+    addDirective(directive: VConditionalDirective): void;
+    /**
+     * Checks if any preceding directive's condition is met.
+     * This is used to determine if a v-else-if or v-else directive should be rendered.
+     * @param directive The directive to check against.
+     * @returns True if any preceding directive's condition is met, otherwise false.
+     */
+    isPrecedingConditionMet(directive: VConditionalDirective): boolean;
+}

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

@@ -0,0 +1,17 @@
+/**
+ * Interface representing an updater for the virtual DOM.
+ * An implementation of this interface is responsible for applying changes
+ * from the virtual DOM to the actual DOM.
+ */
+export interface VDOMUpdater {
+    /**
+     * A list of variable and function names that this updater is concerned with.
+     * Changes to these identifiers may trigger the updater to apply changes to the DOM.
+     */
+    get identifiers(): 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.
+     */
+    applyToDOM(): void;
+}

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

@@ -0,0 +1,48 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Interface representing a directive in the virtual DOM.
+ */
+export interface VDirective {
+    /**
+     * The name of the directive (e.g., "v-if", "v-for").
+     */
+    get name(): string;
+    /**
+     * The virtual node to which this directive is applied.
+     */
+    get vNode(): VNode;
+    /**
+     * Indicates whether this directive requires an anchor comment node for insertion/removal.
+     * This is typically true for directives that may remove the element from the DOM,
+     * such as v-if and v-for.
+     * If true, the VNode will create an anchor comment node to mark the position of the element in the DOM.
+     * This allows the element to be re-inserted at the correct position later.
+     * If false, no anchor node is created and the element remains in the DOM at all times.
+     * Directives that do not remove the element from the DOM should return false.
+     * This property is used by the VNode to determine whether to create an anchor node.
+     * It is also used by the VDOM to manage insertion and removal of nodes.
+     * Note: This property should be implemented as a getter to allow dynamic evaluation based on directive state.
+     */
+    get needsAnchor(): boolean;
+    /**
+     * Gets the preparer for the VBindings associated with this directive.
+     * This preparer is responsible for preparing the bindings before they are applied to the DOM.
+     * For example, a directive may need to transform or filter the bindings based on its logic.
+     * If the directive does not need to prepare bindings, this may return undefined.
+     */
+    get bindingsPreparer(): VBindingsPreparer | undefined;
+    /**
+     * Gets the updater for applying changes from the virtual DOM to the actual DOM.
+     * This updater is responsible for applying any changes made by the directive to the DOM.
+     * For example, a directive may need to show/hide elements, update attributes, etc.
+     * If the directive does not need to update the DOM, this may return undefined.
+     */
+    get domUpdater(): VDOMUpdater | undefined;
+    /**
+     * Cleans up any resources used by the directive.
+     * This method is called when the directive is no longer needed.
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,39 @@
+import { VDirective } from "./VDirective";
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDOMUpdater } from "../VDOMUpdater";
+import { VBindDirective } from "./VBindDirective";
+export declare class VDirectiveManager {
+    #private;
+    constructor(vNode: VNode);
+    /**
+     * The list of directives associated with the virtual node.
+     * This may be undefined if there are no directives.
+     */
+    get directives(): VDirective[] | undefined;
+    /**
+     * The anchor comment node used for certain directives.
+     * This may be undefined if no directive requires an anchor.
+     */
+    get anchorNode(): Comment | undefined;
+    /**
+     * The list of bindings preparers from the associated directives.
+     * This may be undefined if no directive provides a bindings preparer.
+     */
+    get bindingsPreparers(): VBindingsPreparer[] | undefined;
+    /**
+     * The list of DOM updaters from the associated directives.
+     * This may be undefined if no directive provides a DOM updater.
+     */
+    get domUpdaters(): VDOMUpdater[] | undefined;
+    /**
+     * Gets the directive that binds the ":key" or "v-bind:key" attribute, if any.
+     * This directive is special and is used for optimizing rendering of lists.
+     * If no such directive exists, this returns undefined.
+     */
+    get keyDirective(): VBindDirective | undefined;
+    /**
+     * Cleans up any resources used by the directive handler.
+     */
+    destroy(): void;
+}