snice 3.10.1 → 3.10.3

package/dist/index.iife.js

@@ -1,5 +1,5 @@
 /*!
- * snice v3.10.0
+ * snice v3.10.2
  * Imperative TypeScript framework for building vanilla web components with decorators, differential rendering, routing, and controllers. No virtual DOM, no build complexity.
  * (c) 2024
  * Released under the MIT License.
@@ -1493,10 +1493,12 @@ var Snice = (function (exports) {
      * ConditionalIfPart handles <if> conditional rendering
      * Removes/inserts DOM nodes based on condition
      */
+    // Sentinel value to distinguish "not yet set" from undefined
+    const NOT_SET = Symbol('not-set');
     class ConditionalIfPart extends Part {
         constructor(ifElement) {
             super();
-            this.value = undefined;
+            this.value = NOT_SET;
             this.fragment = null;
             this.ifElement = ifElement;
             this.ifElement.style.display = 'contents';
@@ -1538,7 +1540,7 @@ var Snice = (function (exports) {
     class ConditionalCasePart extends Part {
         constructor(caseElement) {
             super();
-            this.value = undefined;
+            this.value = NOT_SET;
             this.childrenMap = new Map();
             this.fragments = new Map();
             this.defaultChild = null;
@@ -3013,17 +3015,19 @@ var Snice = (function (exports) {
                         }
                     }
                 }
-                // Apply any properties that were set before element was connected
-                // BUT only if they don't have an HTML attribute (don't override HTML attributes)
+                // Clear pre-init values for properties that have HTML attributes
+                // This prevents field initializers from overwriting HTML attributes later
                 if (this[PRE_INIT_PROPERTY_VALUES]) {
-                    for (const [propName, propValue] of this[PRE_INIT_PROPERTY_VALUES]) {
-                        // Remove from map first so getter doesn't return it during setter call
-                        this[PRE_INIT_PROPERTY_VALUES].delete(propName);
-                        // Only apply pre-init value if NO HTML attribute exists
-                        // This prevents field initializers from overwriting HTML attributes
+                    for (const [propName, propValue] of Array.from(this[PRE_INIT_PROPERTY_VALUES].entries())) {
                         const propOptions = properties?.get(propName);
                         const attributeName = typeof propOptions?.attribute === 'string' ? propOptions.attribute : propName.toLowerCase();
-                        if (!this.hasAttribute(attributeName)) {
+                        if (this.hasAttribute(attributeName)) {
+                            // Attribute exists - remove from PRE_INIT to prevent overwriting
+                            this[PRE_INIT_PROPERTY_VALUES].delete(propName);
+                        }
+                        else {
+                            // No attribute - apply the pre-init value
+                            this[PRE_INIT_PROPERTY_VALUES].delete(propName);
                             this[propName] = propValue;
                         }
                     }
@@ -3283,16 +3287,18 @@ var Snice = (function (exports) {
             context.metadata[PROPERTIES].set(propertyKey, options || {});
             // Return a field initializer function for new decorators
             return function (initialValue) {
+                // Ensure constructor[PROPERTIES] exists
+                const constructor = this.constructor;
+                if (!constructor[PROPERTIES]) {
+                    constructor[PROPERTIES] = new Map();
+                }
                 // Detect type from initial value if not explicitly provided
                 const finalOptions = { ...options };
                 if (!finalOptions.type && initialValue !== undefined) {
                     finalOptions.type = detectType(initialValue);
-                    // Update the metadata with the detected type
-                    const constructor = this.constructor;
-                    if (constructor[PROPERTIES]) {
-                        constructor[PROPERTIES].set(propertyKey, finalOptions);
-                    }
                 }
+                // Always store property options on constructor for runtime access
+                constructor[PROPERTIES].set(propertyKey, finalOptions);
                 // Set up the property descriptor on first access
                 if (!Object.hasOwnProperty.call(this.constructor.prototype, propertyKey)) {
                     const descriptor = {
@@ -3321,8 +3327,9 @@ var Snice = (function (exports) {
                             // Get old value by calling the getter (which reads from attribute)
                             const oldValue = this[propertyKey];
                             // Check if value actually changed
-                            if (oldValue === newValue)
+                            if (oldValue === newValue) {
                                 return;
+                            }
                             // Don't reflect to DOM until connectedCallback has started
                             // This prevents field initializers from overwriting HTML attributes
                             if (!this[PROPERTIES_INITIALIZED]) {