@mintjamsinc/ichigojs 0.1.2 → 0.1.3

package/dist/ichigo.umd.js

@@ -7169,6 +7169,10 @@
          * The change tracker, if any.
          */
         #onChange;
+        /**
+         * The logger instance.
+         */
+        #logger;
         /**
          * The set of changed identifiers.
          */
@@ -7184,6 +7188,10 @@
         constructor(args = {}) {
             this.#parent = args.parent;
             this.#onChange = args.onChange;
+            this.#logger = args.vApplication?.logManager.getLogger('VBindings');
+            if (this.#logger?.isDebugEnabled) {
+                this.#logger.debug(`VBindings created. Parent: ${this.#parent ? 'yes' : 'no'}`);
+            }
             this.#local = new Proxy({}, {
                 get: (obj, key) => {
                     if (Reflect.has(obj, key)) {
@@ -7208,6 +7216,7 @@
                             let path = '';
                             for (const part of changedPath?.split('.') || []) {
                                 path = path ? `${path}.${part}` : part;
+                                this.#logger?.debug(`Binding changed: ${path}`);
                                 this.#changes.add(path);
                             }
                             this.#onChange?.(changedPath);
@@ -7218,15 +7227,22 @@
                     // Detect changes
                     let hasChanged = oldValue !== newValue;
                     // Special handling for arrays: check length changes even if same object reference
-                    if (!hasChanged && Array.isArray(newValue)) {
+                    if (Array.isArray(newValue)) {
                         const cachedLength = this.#lengthCache.get(key);
                         const currentLength = newValue.length;
-                        if (cachedLength !== undefined && cachedLength !== currentLength) {
+                        if (!hasChanged && cachedLength !== undefined && cachedLength !== currentLength) {
                             hasChanged = true;
                         }
                         this.#lengthCache.set(key, currentLength);
                     }
                     if (hasChanged) {
+                        if (this.#logger?.isDebugEnabled) {
+                            const oldValueString = typeof oldValue === 'string' ? `"${oldValue}"` : JSON.stringify(oldValue) || 'undefined';
+                            const newValueString = typeof newValue === 'string' ? `"${newValue}"` : JSON.stringify(newValue) || 'undefined';
+                            const oldValuePreview = oldValueString.length > 100 ? `${oldValueString.substring(0, 100)}...` : oldValueString;
+                            const newValuePreview = newValueString.length > 100 ? `${newValueString.substring(0, 100)}...` : newValueString;
+                            this.#logger.debug(`Binding set on ${target === obj ? 'local' : 'parent'}: ${key}: ${oldValuePreview} -> ${newValuePreview}`);
+                        }
                         this.#changes.add(key);
                         this.#onChange?.(key);
                     }
@@ -7234,6 +7250,7 @@
                 },
                 deleteProperty: (obj, key) => {
                     const result = Reflect.deleteProperty(obj, key);
+                    this.#logger?.debug(`Binding deleted: ${key}`);
                     this.#changes.add(key);
                     this.#onChange?.(key);
                     return result;
@@ -8947,10 +8964,13 @@
             }
             // .number modifier: convert to number
             if (this.#modifiers.has('number')) {
-                const parsed = Number(result);
-                // Only convert if it's a valid number
-                if (!isNaN(parsed)) {
-                    result = parsed;
+                // Skip conversion if the value is empty string
+                if (result !== '') {
+                    const parsed = Number(result);
+                    // Only convert if it's a valid number
+                    if (!isNaN(parsed)) {
+                        result = parsed;
+                    }
                 }
             }
             return result;
@@ -9478,49 +9498,105 @@
     })(LogLevel || (LogLevel = {}));
 
     // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
+    /**
+     * A simple logger class for virtual applications.
+     */
     class VLogger {
+        /** The name of the logger. */
         #name;
+        /** The log manager instance. */
         #logManager;
         constructor(name, logManager) {
             this.#name = name;
             this.#logManager = logManager;
         }
+        /**
+         * Indicates whether the debug level is enabled.
+         */
+        get isDebugEnabled() {
+            return [LogLevel.DEBUG].includes(this.#logManager.logLevel);
+        }
+        /**
+         * Indicates whether the info level is enabled.
+         */
+        get isInfoEnabled() {
+            return [LogLevel.DEBUG, LogLevel.INFO].includes(this.#logManager.logLevel);
+        }
+        /**
+         * Indicates whether the warn level is enabled.
+         */
+        get isWarnEnabled() {
+            return [LogLevel.DEBUG, LogLevel.INFO, LogLevel.WARN].includes(this.#logManager.logLevel);
+        }
+        /**
+         * Logs a debug message.
+         * @param message The message to log.
+         */
         debug(message) {
-            if (![LogLevel.DEBUG].includes(this.#logManager.logLevel)) {
+            if (!this.isDebugEnabled) {
                 return;
             }
             console.debug(`[${this.#name}] ${LogLevel.DEBUG}: ${message}`);
         }
+        /**
+         * Logs an info message.
+         * @param message The message to log.
+         */
         info(message) {
-            if (![LogLevel.DEBUG, LogLevel.INFO].includes(this.#logManager.logLevel)) {
+            if (!this.isInfoEnabled) {
                 return;
             }
             console.info(`[${this.#name}] ${LogLevel.INFO}: ${message}`);
         }
+        /**
+         * Logs a warn message.
+         * @param message The message to log.
+         */
         warn(message) {
-            if (![LogLevel.DEBUG, LogLevel.INFO, LogLevel.WARN].includes(this.#logManager.logLevel)) {
+            if (!this.isWarnEnabled) {
                 return;
             }
             console.warn(`[${this.#name}] ${LogLevel.WARN}: ${message}`);
         }
+        /**
+         * Logs an error message.
+         * @param message The message to log.
+         */
         error(message) {
             console.error(`[${this.#name}] ${LogLevel.ERROR}: ${message}`);
         }
     }
 
     // Copyright (c) 2025 MintJams Inc. Licensed under MIT License.
+    /**
+     * Manages loggers and their log levels.
+     */
     class VLogManager {
+        /** The current log level. */
         #logLevel;
+        /** A map of logger instances by name. */
         #loggers = new Map();
         constructor(logLevel = LogLevel.INFO) {
             this.#logLevel = logLevel;
         }
+        /**
+         * Sets the log level for all loggers.
+         * @param level The log level to set.
+         */
         set logLevel(level) {
             this.#logLevel = level;
         }
+        /**
+         * Gets the current log level.
+         */
         get logLevel() {
             return this.#logLevel;
         }
+        /**
+         * Gets a logger by name, creating it if it doesn't exist.
+         * @param name The name of the logger.
+         * @returns The logger instance.
+         */
         getLogger(name) {
             if (this.#loggers.has(name)) {
                 return this.#loggers.get(name);
@@ -9692,7 +9768,8 @@
             this.#bindings = new VBindings({
                 onChange: (identifier) => {
                     this.#scheduleUpdate();
-                }
+                },
+                vApplication: this
             });
             // Inject utility methods into bindings
             this.#bindings.set('$nextTick', (callback) => this.#nextTick(callback));
@@ -9796,13 +9873,7 @@
                     // Track if the computed value actually changed
                     if (oldValue !== newValue) {
                         this.#bindings?.set(key, newValue);
-                        this.#bindings?.changes.forEach(id => {
-                            allChanges.add(id);
-                            const idx = id.indexOf('[');
-                            if (idx !== -1) {
-                                allChanges.add(id.substring(0, idx));
-                            }
-                        });
+                        allChanges.add(key);
                     }
                 }
                 catch (error) {