@mintjamsinc/ichigojs 0.1.0

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

@@ -0,0 +1,19 @@
+import { VNode } from "../VNode";
+/**
+ * The context for parsing a directive.
+ * This interface provides the necessary information required during the parsing of a directive from an HTML attribute.
+ * It includes references to the application instance, the virtual node being processed, the HTML element containing the directive, and the specific attribute representing the directive.
+ * Implementations of directive parsers can utilize this context to access relevant data and perform parsing operations effectively.
+ */
+export interface VDirectiveParseContext {
+    /**
+     * The virtual node being processed.
+     * This property represents the specific virtual node that is associated with the directive being parsed.
+     */
+    vNode: VNode;
+    /**
+     * The attribute representing the directive.
+     * This property contains the actual HTML attribute that holds the directive information, allowing parsers to extract its name and value.
+     */
+    attribute: Attr;
+}

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

@@ -0,0 +1,31 @@
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+/**
+ * Interface for parsing directives from HTML attributes.
+ * Each implementation of this interface should provide logic to determine if it can parse a given attribute and to perform the parsing.
+ * Implementations should handle specific directive syntaxes and convert them into corresponding `VDirective` instances.
+ * Example implementations could include parsers for `v-bind`, `v-if`, `v-for`, and other custom directives.
+ * This interface helps in modularizing the directive parsing logic, making it easier to extend and maintain.
+ * When implementing this interface, ensure that the `canParse` method accurately identifies attributes that the parser can handle, and the `parse` method correctly transforms those attributes into directive instances.
+ * This design allows for a flexible and scalable approach to handling various directives in a templating system.
+ */
+export interface VDirectiveParser {
+    /**
+     * The name of the directive parser.
+     * This property provides a human-readable identifier for the parser, which can be useful for logging, debugging, or displaying information about the parser in user interfaces.
+     */
+    get name(): string;
+    /**
+     * Determines if the parser can handle the given attribute.
+     * @param context The context containing the element and attribute to parse.
+     * @returns `true` if the parser can handle the attribute; otherwise, `false`.
+     */
+    canParse(context: VDirectiveParseContext): boolean;
+    /**
+     * Parses the given attribute into a directive.
+     * @param context The context containing the element and attribute to parse.
+     * @returns The parsed directive.
+     * @throws Error if the attribute cannot be parsed by this parser.
+     */
+    parse(context: VDirectiveParseContext): VDirective;
+}

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

@@ -0,0 +1,26 @@
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDirectiveParser } from "./VDirectiveParser";
+export declare class VDirectiveParserRegistry {
+    #private;
+    /**
+     * Gets the list of registered directive parsers.
+     * @returns The list of registered directive parsers.
+     */
+    get parsers(): VDirectiveParser[];
+    /**
+     * Registers a directive parser.
+     * @param parser The directive parser to register.
+     */
+    register(parser: VDirectiveParser): void;
+    /**
+     * Unregisters a directive parser.
+     * @param parser The directive parser to unregister.
+     */
+    unregister(parser: VDirectiveParser): void;
+    /**
+     * Finds a directive parser that can parse the given context.
+     * @param context The context for parsing the directive.
+     * @returns A directive parser that can parse the given context, or null if no suitable parser is found.
+     */
+    findParser(context: VDirectiveParseContext): VDirectiveParser | null;
+}

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

@@ -0,0 +1,21 @@
+import { VConditionalDirective } from "./VConditionalDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+/**
+ * Directive for conditional rendering in the virtual DOM.
+ * This directive renders an element if the preceding v-if or v-else-if directive evaluated to false.
+ * For example:
+ *     <div v-else>This div is rendered if the previous v-if or v-else-if was false.</div>
+ * The element and its children are included in the DOM only if the preceding v-if or v-else-if expression evaluates to false.
+ * If the preceding expression is true, this element and its children are not rendered.
+ * This directive must be used immediately after a v-if or v-else-if directive.
+ */
+export declare class VElseDirective extends VConditionalDirective {
+    /**
+     * @param context The context for parsing the directive.
+     */
+    constructor(context: VDirectiveParseContext);
+    /**
+     * @inheritdoc
+     */
+    get name(): string;
+}

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

@@ -0,0 +1,20 @@
+import { VConditionalDirective } from "./VConditionalDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+/**
+ * Directive for conditional rendering in the virtual DOM.
+ * This directive renders an element based on a boolean expression, but only if preceding v-if or v-else-if directives were false.
+ * For example:
+ *     <div v-else-if="isAlternativeVisible">This div is conditionally rendered.</div>
+ * The element and its children are included in the DOM only if the expression evaluates to true AND no preceding condition was met.
+ * This directive must be used after a v-if or another v-else-if directive.
+ */
+export declare class VElseIfDirective extends VConditionalDirective {
+    /**
+     * @param context The context for parsing the directive.
+     */
+    constructor(context: VDirectiveParseContext);
+    /**
+     * @inheritdoc
+     */
+    get name(): string;
+}

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

@@ -0,0 +1,51 @@
+import { VNode } from "../VNode";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+/**
+ * Directive for rendering a list of items using a loop.
+ * This directive iterates over a collection and renders a template for each item.
+ * Example usage:
+ *     <ul>
+ *       <li v-for="item in items" :key="item.id">{{ item.name }}</li>
+ *     </ul>
+ * In this example, the v-for directive iterates over the items array, rendering an <li> element for each item.
+ * The :key attribute is used to provide a unique identifier for each item, which helps with efficient updates and rendering.
+ * The directive supports iterating over arrays and objects. When iterating over an object, you can access both the key and value.
+ * For example:
+ *     <div v-for="(value, key) in object">{{ key }}: {{ value }}</div>
+ * This will render each key-value pair in the object.
+ * Note that the v-for directive requires a unique key for each item to optimize rendering performance.
+ */
+export declare class VForDirective 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
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,20 @@
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VConditionalDirective } from "./VConditionalDirective";
+/**
+ * Directive for conditional rendering in the virtual DOM.
+ * This directive conditionally renders elements based on a boolean expression.
+ * For example:
+ *     <div v-if="isVisible">This div is conditionally rendered.</div>
+ * The element and its children are included in the DOM only if the expression evaluates to true.
+ * If the expression is false, the element and its children are not rendered.
+ */
+export declare class VIfDirective extends VConditionalDirective {
+    /**
+     * @param context The context for parsing the directive.
+     */
+    constructor(context: VDirectiveParseContext);
+    /**
+     * @inheritdoc
+     */
+    get name(): string;
+}

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

@@ -0,0 +1,47 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Directive for two-way data binding on form input elements.
+ * This directive binds the value of an input element to a data property and updates the property when the input value changes.
+ * Example usage:
+ *     <input v-model="username" />
+ * In this example, the v-model directive binds the value of the input element to the username data property.
+ * When the user types in the input field, the username property is automatically updated with the new value.
+ * This directive supports various input types, including text, checkbox, radio, and select elements.
+ * For checkboxes and radio buttons, it binds to boolean or specific values accordingly.
+ * For select elements, it binds to the selected option's value.
+ */
+export declare class VModelDirective 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
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,49 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Directive for binding event listeners to DOM elements.
+ * The `v-on` directive allows you to listen to DOM events and execute specified methods when those events are triggered.
+ * The syntax for using the `v-on` directive is `v-on:event="methodName"`, where `event` is the name of the event to listen for (e.g., `click`, `mouseover`, etc.), and `methodName` is the name of the method to be called when the event occurs.
+ * Example usage:
+ *     <button v-on:click="handleClick">Click Me</button>
+ * In this example, when the button is clicked, the `handleClick` method will be executed.
+ * You can also use the shorthand `@event` instead of `v-on:event`. For example, `@click="handleClick"` is equivalent to `v-on:click="handleClick"`.
+ * The `v-on` directive supports event modifiers such as `.stop`, `.prevent`, `.capture`, `.self`, and `.once` to modify the behavior of the event listener.
+ * For example, `v-on:click.stop="handleClick"` will stop the event from propagating up the DOM tree.
+ * This directive is essential for handling user interactions in your application.
+ * Note that the methods referenced in the directive should be defined in the component's methods object.
+ */
+export declare class VOnDirective 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
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,57 @@
+import { VNode } from "../VNode";
+import { VBindingsPreparer } from "../VBindingsPreparer";
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDOMUpdater } from "../VDOMUpdater";
+/**
+ * Directive for conditionally displaying an element.
+ * This directive shows or hides an element based on a boolean expression.
+ * For example:
+ *     <div v-show="isVisible">This element is conditionally visible.</div>
+ * The element is included in the DOM regardless of the expression's value, but its visibility is controlled via CSS (display property).
+ * If the expression evaluates to true, the element is visible; if false, it is hidden (display: none).
+ * This directive is useful for toggling visibility without removing the element from the DOM.
+ * Note that this directive does not support v-else or v-else-if.
+ */
+export declare class VShowDirective 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;
+    /**
+     * Makes the node visible by resetting its display style.
+     * If the node is already visible, no action is taken.
+     */
+    visibleNode(): void;
+    /**
+     * Hides the node by setting its display style to "none".
+     * This effectively removes the node from the layout.
+     * If the node is already hidden, no action is taken.
+     */
+    invisibleNode(): void;
+    /**
+     * @inheritdoc
+     */
+    destroy(): void;
+}

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

@@ -0,0 +1,20 @@
+import { VDirective } from "./VDirective";
+import { VDirectiveParseContext } from "./VDirectiveParseContext";
+import { VDirectiveParser } from "./VDirectiveParser";
+/**
+ * The directive parser for standard directives.
+ */
+export declare class VStandardDirectiveParser implements VDirectiveParser {
+    /**
+     * @inheritdoc
+     */
+    get name(): string;
+    /**
+     * @inheritdoc
+     */
+    canParse(context: VDirectiveParseContext): boolean;
+    /**
+     * @inheritdoc
+     */
+    parse(context: VDirectiveParseContext): VDirective;
+}

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

@@ -0,0 +1,10 @@
+import { VBindings } from "../VBindings";
+export declare class BindingsUtils {
+    /**
+     * Gets the identifiers that have changed between two sets of bindings.
+     * @param oldBindings The old set of bindings.
+     * @param newBindings The new set of bindings.
+     * @returns An array of identifiers that have changed.
+     */
+    static getChangedIdentifiers(oldBindings: VBindings, newBindings: VBindings): string[];
+}

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

@@ -0,0 +1,15 @@
+export declare class ExpressionUtils {
+    /**
+     * Extracts variable and function names used in the expression.
+     * @param expression The expression string to analyze.
+     * @param functionDependencies A dictionary mapping function names to their dependencies.
+     * @returns An array of identifier names.
+     */
+    static extractIdentifiers(expression: string, functionDependencies: Record<string, string[]>): string[];
+    /**
+     * Analyzes the dependencies of functions in the provided dictionary.
+     * @param functions A dictionary mapping function names to their implementations.
+     * @returns A dictionary mapping function names to arrays of their dependencies.
+     */
+    static analyzeFunctionDependencies(functions: Record<string, Function>): Record<string, string[]>;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Log level enumeration.
+ */
+export declare enum LogLevel {
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error"
+}

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

@@ -0,0 +1,34 @@
+/**
+ * Utility class for creating reactive proxies that automatically track changes.
+ */
+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.
+     */
+    private static proxyMap;
+    /**
+     * 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.
+     * @returns A reactive proxy of the target object.
+     */
+    static create<T extends object>(target: T, onChange: (changedKey?: string) => void): T;
+    /**
+     * Checks if the given object is a reactive proxy.
+     *
+     * @param obj The object to check.
+     * @returns True if the object is a reactive proxy, false otherwise.
+     */
+    static isReactive(obj: any): boolean;
+    /**
+     * Unwraps a reactive proxy to get the original object.
+     * If the object is not a proxy, returns it as-is.
+     *
+     * @param obj The object to unwrap.
+     * @returns The original object.
+     */
+    static unwrap<T>(obj: T): T;
+}

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

@@ -0,0 +1,9 @@
+/**
+ * Log level enumeration.
+ */
+export declare enum VLogLevel {
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error"
+}

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

@@ -0,0 +1,9 @@
+import { VLogger } from "./VLogger";
+import { LogLevel } from "./LogLevel";
+export declare class VLogManager {
+    #private;
+    constructor(logLevel?: LogLevel);
+    set logLevel(level: LogLevel);
+    get logLevel(): LogLevel;
+    getLogger(name: string): VLogger;
+}

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

@@ -0,0 +1,9 @@
+import { VLogManager } from "./VLogManager";
+export declare class VLogger {
+    #private;
+    constructor(name: string, logManager: VLogManager);
+    debug(message: string): void;
+    info(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+}

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { VDOM } from './ichigo/VDOM';

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@mintjamsinc/ichigojs",
+  "version": "0.1.0",
+  "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",
+  "types": "./dist/types/index.d.ts",
+  "type": "module",
+  "author": "MintJams Inc.",
+  "license": "MIT",
+  "homepage": "https://github.com/mintjamsinc/ichigojs#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mintjamsinc/ichigojs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mintjamsinc/ichigojs/issues"
+  },
+  "keywords": [
+    "virtual-dom",
+    "reactive",
+    "framework",
+    "vdom",
+    "ui",
+    "typescript",
+    "vue-like",
+    "lightweight",
+    "reactive-proxy",
+    "computed-properties",
+    "two-way-binding"
+  ],
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rollup -c",
+    "prepare": "npm run build",
+    "test": "npm run build && node --test"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^28.0.6",
+    "@rollup/plugin-node-resolve": "^16.0.1",
+    "@rollup/plugin-terser": "^0.4.4",
+    "esbuild": "^0.21.5",
+    "rollup": "^4.52.0",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "typedoc": "^0.28.13",
+    "typescript": "^5.9.2"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/ichigo.esm.js",
+      "require": "./dist/ichigo.umd.js",
+      "types": "./dist/types/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "acorn": "^8.14.0",
+    "acorn-walk": "^8.3.4"
+  }
+}