@sprlab/wccompiler 0.16.3 → 0.16.5

package/lib/codegen.js

@@ -58,19 +58,43 @@ function slotPropRef(source, signalNames, computedNames, propNames) {
 }
 
 /**
- * Wrap an expression in parentheses if it contains a ternary operator.
- * This prevents operator precedence issues when combining with ?? (nullish coalescing).
+ * Wrap an expression in parentheses if it contains operators that could have
+ * precedence issues when combined with ?? (nullish coalescing).
+ *
+ * This prevents bugs like: this._count() || 'No items' ?? ''
+ * which JavaScript interprets as: this._count() || ('No items' ?? '')
+ *
+ * Operators that need wrapping:
+ * - Ternary: ? :
+ * - Logical OR: ||
+ * - Logical AND: &&
+ * - Nullish coalescing: ?? (nested)
  *
  * @param {string} expr - Expression to potentially wrap
- * @returns {string} - Wrapped expression if it contains ternary, otherwise unchanged
+ * @returns {string} - Wrapped expression if it contains risky operators, otherwise unchanged
  */
 function wrapTernaryExpr(expr) {
   const trimmed = expr.trim();
-  // Check if expression contains ternary operator (? followed by :)
-  // Simple heuristic: if it has both ? and :, wrap it
-  if (trimmed.includes('?') && trimmed.includes(':')) {
+  
+  // Check for operators that have lower precedence than ?? or can cause ambiguity
+  // Ternary operator (? :)
+  const hasTernary = trimmed.includes('?') && trimmed.includes(':');
+  
+  // Logical OR (||)
+  const hasLogicalOr = trimmed.includes('||');
+  
+  // Logical AND (&&)
+  const hasLogicalAnd = trimmed.includes('&&');
+  
+  // Nested nullish coalescing (??)
+  // If expression contains ??, wrap it to avoid conflict with the trailing ?? ''
+  const hasNullish = trimmed.includes('??');
+  
+  // Wrap if any risky operator is found
+  if (hasTernary || hasLogicalOr || hasLogicalAnd || hasNullish) {
     return `(${trimmed})`;
   }
+  
   return trimmed;
 }
 
@@ -1572,8 +1596,9 @@ export function generateComponent(parseResult, options = {}) {
         lines.push('    }));');
       } else {
         // String expression: set className
+        // Wrap ternary/logical expressions to prevent precedence issues
         lines.push('    this.__disposers.push(__effect(() => {');
-        lines.push(`      this.${ab.varName}.className = ${expr};`);
+        lines.push(`      this.${ab.varName}.className = ${wrapTernaryExpr(expr)};`);
         lines.push('    }));');
       }
     } else if (ab.kind === 'style') {
@@ -1930,6 +1955,24 @@ export function generateComponent(parseResult, options = {}) {
     lines.push('');
   }
 
+  // Wrapper methods for defineModel signals (dual getter/setter)
+  // These act as the interface between template code and internal signals
+  // - As getter (no args): returns signal value
+  // - As setter (with arg): calls _modelSet_* to update and dispatch events
+  if (modelDefs.length > 0) {
+    lines.push('  // --- Model wrapper methods ---');
+    for (const md of modelDefs) {
+      lines.push(`  _${md.name}(val) {`);
+      lines.push(`    if (arguments.length === 0) {`);
+      lines.push(`      return this._m_${md.name}();`);
+      lines.push(`    } else {`);
+      lines.push(`      this._modelSet_${md.name}(val);`);
+      lines.push(`    }`);
+      lines.push(`  }`);
+      lines.push('');
+    }
+  }
+
   // __scopedSlots instance getter and registerSlotRenderer (if scoped slots exist)
   if (scopedSlotNames.length > 0) {
     lines.push('  get __scopedSlots() { return this.constructor.__scopedSlots || []; }');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sprlab/wccompiler",
-  "version": "0.16.3",
+  "version": "0.16.5",
   "description": "Zero-runtime compiler that transforms .wcc single-file components into native web components with signals-based reactivity",
   "type": "module",
   "exports": {