@mintjamsinc/ichigojs 0.1.82 → 0.1.84

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

@@ -0,0 +1,118 @@
+import { VBindings } from "./VBindings";
+/**
+ * Options for expression evaluation.
+ */
+export interface ExpressionEvaluatorOptions {
+    /**
+     * Additional context variables to be available in the expression (e.g., 'event', '$ctx').
+     */
+    additionalContext?: Record<string, any>;
+    /**
+     * If true, allows assignment expressions (e.g., "count++", "value = 10").
+     * This is used by VOnDirective to support inline assignments.
+     * Default: false
+     */
+    allowAssignment?: boolean;
+    /**
+     * A custom function to rewrite the expression before evaluation.
+     * This is used by VOnDirective to transform identifiers into 'this.identifier' form.
+     */
+    rewriteExpression?: (expression: string, identifiers: string[]) => string;
+}
+/**
+ * A centralized expression evaluator that normalizes expression evaluation across all directives.
+ *
+ * This class provides:
+ * - Consistent identifier extraction and binding resolution
+ * - Unified global object whitelisting (Math, Date, JSON, etc.)
+ * - Expression caching for performance
+ * - Centralized error handling
+ * - Support for custom expression rewriting (for VOnDirective)
+ *
+ * Example usage:
+ * ```typescript
+ * const evaluator = ExpressionEvaluator.create(
+ *   "count + 1",
+ *   bindings,
+ *   functionDependencies
+ * );
+ * const result = evaluator.evaluate();
+ * ```
+ */
+export declare class ExpressionEvaluator {
+    /**
+     * Cache for compiled expression functions.
+     * Key: expression string
+     * Value: compiled function
+     */
+    private static readonly cache;
+    /**
+     * Global objects that are whitelisted for use in expressions.
+     * These objects are available to all expressions for convenience and compatibility.
+     */
+    private static readonly GLOBAL_WHITELIST;
+    /**
+     * The original expression string.
+     */
+    private readonly expression;
+    /**
+     * The identifiers extracted from the expression.
+     */
+    private readonly identifiers;
+    /**
+     * The bindings to use for evaluating the expression.
+     */
+    private readonly bindings;
+    /**
+     * The compiled function for evaluating the expression.
+     */
+    private readonly evaluatorFunc;
+    /**
+     * Additional context variables (e.g., 'event', '$ctx').
+     */
+    private readonly additionalContext?;
+    /**
+     * Private constructor. Use ExpressionEvaluator.create() to create instances.
+     */
+    private constructor();
+    /**
+     * Creates an ExpressionEvaluator instance.
+     *
+     * @param expression The expression string to evaluate.
+     * @param bindings The bindings to use for evaluating the expression.
+     * @param functionDependencies A dictionary mapping function names to their dependencies.
+     * @param options Optional configuration for the evaluator.
+     * @returns An ExpressionEvaluator instance.
+     */
+    static create(expression: string, bindings: VBindings, functionDependencies: Record<string, string[]>, options?: ExpressionEvaluatorOptions): ExpressionEvaluator;
+    /**
+     * Compiles an expression into a function.
+     *
+     * @param expression The expression string to compile.
+     * @param identifiers The identifiers extracted from the expression.
+     * @param options Optional configuration.
+     * @returns A compiled function.
+     */
+    private static compileExpression;
+    /**
+     * Evaluates the expression with the current bindings.
+     *
+     * @returns The result of the expression evaluation.
+     */
+    evaluate(): any;
+    /**
+     * Evaluates the expression and returns the result as a boolean.
+     *
+     * @returns The boolean result of the expression evaluation.
+     */
+    evaluateAsBoolean(): boolean;
+    /**
+     * Gets the list of identifiers extracted from the expression.
+     */
+    get dependentIdentifiers(): string[];
+    /**
+     * Clears the expression cache.
+     * This should be called sparingly, as it will force recompilation of all expressions.
+     */
+    static clearCache(): 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/VNode.d.ts

@@ -175,6 +175,7 @@ export declare class VNode {
      * 4. Unregister dependencies
      * 5. Clean up directive manager
      * 6. Call onUnmounted lifecycle hooks
+     * 7. Leave the parent's child list
      */
     destroy(): void;
 }

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/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/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/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/VLogLevel.d.ts

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

package/package.json

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