snice 3.10.1 → 3.10.3

package/dist/index.esm.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.
@@ -1490,10 +1490,12 @@ function matchesKeyboardFilter(event, filter) {
  * 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';
@@ -1535,7 +1537,7 @@ class ConditionalIfPart extends Part {
 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;
@@ -3010,17 +3012,19 @@ function applyElementFunctionality(constructor) {
                     }
                 }
             }
-            // 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;
                     }
                 }
@@ -3280,16 +3284,18 @@ function property(options) {
         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 = {
@@ -3318,8 +3324,9 @@ function property(options) {
                         // 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]) {