@mintjamsinc/ichigojs 0.1.29 → 0.1.31

package/dist/ichigo.cjs

@@ -171,6 +171,10 @@
         StandardDirectiveName["V_PERFORMANCE"] = "v-performance";
         /** Component directive. */
         StandardDirectiveName["V_COMPONENT"] = "v-component";
+        /** Raw HTML content directive. */
+        StandardDirectiveName["V_HTML"] = "v-html";
+        /** Text content directive. */
+        StandardDirectiveName["V_TEXT"] = "v-text";
     })(StandardDirectiveName || (StandardDirectiveName = {}));
 
     // This file was generated. Do not modify manually!
@@ -8178,6 +8182,59 @@
     }
 
     // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
+    /**
+     * List of standard JavaScript global objects that should be available in expressions.
+     * These are used as fallbacks when the identifier is not found in the bindings.
+     */
+    const GLOBAL_OBJECTS = {
+        // Math and numbers
+        Math,
+        Number,
+        BigInt,
+        Infinity,
+        NaN,
+        // String and text
+        String,
+        // Boolean
+        Boolean,
+        // Objects and arrays
+        Object,
+        Array,
+        // Date and time
+        Date,
+        // JSON
+        JSON,
+        // Regular expressions
+        RegExp,
+        // Errors
+        Error,
+        TypeError,
+        RangeError,
+        SyntaxError,
+        ReferenceError,
+        // Other utilities
+        parseInt,
+        parseFloat,
+        isNaN,
+        isFinite,
+        encodeURI,
+        encodeURIComponent,
+        decodeURI,
+        decodeURIComponent,
+        // Collections
+        Map,
+        Set,
+        WeakMap,
+        WeakSet,
+        // Promises
+        Promise,
+        // Symbols
+        Symbol,
+        // Console (for debugging)
+        console,
+        // undefined is a special case
+        undefined,
+    };
     /**
      * A class to evaluate text with embedded expressions in the form of {{...}}.
      * It extracts identifiers from the expressions and evaluates them using provided bindings.
@@ -8225,7 +8282,18 @@
                 let result = text;
                 evaluators.forEach((evaluator, i) => {
                     // Gather the current values of the identifiers from the bindings
-                    const values = evaluator.ids.map(id => bindings.get(id));
+                    // Fall back to global objects if not found in bindings
+                    const values = evaluator.ids.map(id => {
+                        const value = bindings.get(id);
+                        if (value !== undefined) {
+                            return value;
+                        }
+                        // Check if it's a global object
+                        if (id in GLOBAL_OBJECTS) {
+                            return GLOBAL_OBJECTS[id];
+                        }
+                        return undefined;
+                    });
                     // Evaluate the expression and replace {{...}} in the text
                     result = result.replace(matches[i][0], String(evaluator.func(...values)));
                 });
@@ -9751,6 +9819,140 @@
         }
     }
 
+    // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
+    /**
+     * Directive for setting raw HTML content of an element.
+     * This directive evaluates an expression and sets the result as the innerHTML of the element.
+     * For example:
+     *     <div v-html="htmlContent"></div>
+     * The element's innerHTML will be replaced with the value of htmlContent.
+     *
+     * WARNING: Dynamically rendering arbitrary HTML can be very dangerous because it can easily lead to XSS attacks.
+     * Only use v-html on trusted content and never on user-provided content.
+     */
+    class VHtmlDirective {
+        /**
+         * The virtual node to which this directive is applied.
+         */
+        #vNode;
+        /**
+         * The expression evaluator for this directive.
+         */
+        #evaluator;
+        /**
+         * @param context The context for parsing the directive.
+         */
+        constructor(context) {
+            this.#vNode = context.vNode;
+            // Parse the expression and create the evaluator
+            const expression = context.attribute.value;
+            if (!context.vNode.bindings) {
+                throw new Error('VHtmlDirective requires bindings');
+            }
+            this.#evaluator = ExpressionEvaluator.create(expression, context.vNode.bindings, context.vNode.vApplication.functionDependencies);
+            // Remove the directive attribute from the element
+            this.#vNode.node.removeAttribute(context.attribute.name);
+        }
+        /**
+         * @inheritdoc
+         */
+        get name() {
+            return StandardDirectiveName.V_HTML;
+        }
+        /**
+         * @inheritdoc
+         */
+        get vNode() {
+            return this.#vNode;
+        }
+        /**
+         * @inheritdoc
+         */
+        get needsAnchor() {
+            return false;
+        }
+        /**
+         * @inheritdoc
+         */
+        get bindingsPreparer() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get domUpdater() {
+            const identifiers = this.#evaluator.dependentIdentifiers;
+            const evaluator = this.#evaluator;
+            const vNode = this.#vNode;
+            // Create an updater that sets the innerHTML
+            const updater = {
+                get dependentIdentifiers() {
+                    return identifiers;
+                },
+                applyToDOM() {
+                    const element = vNode.node;
+                    const htmlContent = evaluator.evaluate();
+                    element.innerHTML = htmlContent ?? '';
+                }
+            };
+            return updater;
+        }
+        /**
+         * @inheritdoc
+         */
+        get templatize() {
+            return false;
+        }
+        /**
+         * @inheritdoc
+         */
+        get dependentIdentifiers() {
+            return this.#evaluator.dependentIdentifiers;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onMount() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onMounted() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUpdate() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUpdated() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUnmount() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUnmounted() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        destroy() {
+            // No specific cleanup needed for this directive
+        }
+    }
+
     // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
     /**
      * Directive for conditional rendering in the virtual DOM.
@@ -11262,6 +11464,140 @@
         }
     }
 
+    // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
+    /**
+     * Directive for setting text content of an element.
+     * This directive evaluates an expression and sets the result as the textContent of the element.
+     * For example:
+     *     <div v-text="message"></div>
+     * The element's textContent will be replaced with the value of message.
+     *
+     * Unlike v-html, this directive safely escapes HTML content, preventing XSS attacks.
+     * Use this directive when you want to display plain text.
+     */
+    class VTextDirective {
+        /**
+         * The virtual node to which this directive is applied.
+         */
+        #vNode;
+        /**
+         * The expression evaluator for this directive.
+         */
+        #evaluator;
+        /**
+         * @param context The context for parsing the directive.
+         */
+        constructor(context) {
+            this.#vNode = context.vNode;
+            // Parse the expression and create the evaluator
+            const expression = context.attribute.value;
+            if (!context.vNode.bindings) {
+                throw new Error('VTextDirective requires bindings');
+            }
+            this.#evaluator = ExpressionEvaluator.create(expression, context.vNode.bindings, context.vNode.vApplication.functionDependencies);
+            // Remove the directive attribute from the element
+            this.#vNode.node.removeAttribute(context.attribute.name);
+        }
+        /**
+         * @inheritdoc
+         */
+        get name() {
+            return StandardDirectiveName.V_TEXT;
+        }
+        /**
+         * @inheritdoc
+         */
+        get vNode() {
+            return this.#vNode;
+        }
+        /**
+         * @inheritdoc
+         */
+        get needsAnchor() {
+            return false;
+        }
+        /**
+         * @inheritdoc
+         */
+        get bindingsPreparer() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get domUpdater() {
+            const identifiers = this.#evaluator.dependentIdentifiers;
+            const evaluator = this.#evaluator;
+            const vNode = this.#vNode;
+            // Create an updater that sets the textContent
+            const updater = {
+                get dependentIdentifiers() {
+                    return identifiers;
+                },
+                applyToDOM() {
+                    const element = vNode.node;
+                    const textContent = evaluator.evaluate();
+                    element.textContent = textContent ?? '';
+                }
+            };
+            return updater;
+        }
+        /**
+         * @inheritdoc
+         */
+        get templatize() {
+            return false;
+        }
+        /**
+         * @inheritdoc
+         */
+        get dependentIdentifiers() {
+            return this.#evaluator.dependentIdentifiers;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onMount() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onMounted() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUpdate() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUpdated() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUnmount() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        get onUnmounted() {
+            return undefined;
+        }
+        /**
+         * @inheritdoc
+         */
+        destroy() {
+            // No specific cleanup needed for this directive
+        }
+    }
+
     // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
     /**
      * The directive parser for standard directives.
@@ -11299,7 +11635,11 @@
                 context.attribute.name === StandardDirectiveName.V_PERFORMANCE ||
                 // v-component, v-component.<modifier>
                 context.attribute.name === StandardDirectiveName.V_COMPONENT ||
-                context.attribute.name.startsWith(StandardDirectiveName.V_COMPONENT + ".")) {
+                context.attribute.name.startsWith(StandardDirectiveName.V_COMPONENT + ".") ||
+                // v-html
+                context.attribute.name === StandardDirectiveName.V_HTML ||
+                // v-text
+                context.attribute.name === StandardDirectiveName.V_TEXT) {
                 return true;
             }
             return false;
@@ -11355,6 +11695,14 @@
                 context.attribute.name.startsWith(StandardDirectiveName.V_COMPONENT + ".")) {
                 return new VComponentDirective(context);
             }
+            // v-html
+            if (context.attribute.name === StandardDirectiveName.V_HTML) {
+                return new VHtmlDirective(context);
+            }
+            // v-text
+            if (context.attribute.name === StandardDirectiveName.V_TEXT) {
+                return new VTextDirective(context);
+            }
             throw new Error(`The attribute "${context.attribute.name}" cannot be parsed by ${this.name}.`);
         }
     }