rip-lang 3.13.124 → 3.13.126

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rip-lang",
-  "version": "3.13.124",
+  "version": "3.13.126",
   "description": "A modern language that compiles to JavaScript",
   "type": "module",
   "main": "src/compiler.js",

package/src/compiler.js

@@ -2709,11 +2709,11 @@ export class CodeGenerator {
   generateSwitchCaseBody(body, context) {
     let code = '';
     let hasFlow = this.hasExplicitControlFlow(body);
+    let stmts = this.unwrapBlock(body);
     if (hasFlow) {
-      for (let s of this.unwrapBlock(body)) code += this.indent() + this.generate(s, 'statement') + ';\n';
+      for (let s of stmts) code += this.indent() + this.generate(s, 'statement') + ';\n';
     } else if (context === 'value') {
       if (this.is(body, 'block') && body.length > 2) {
-        let stmts = body.slice(1);
         for (let i = 0; i < stmts.length; i++) {
           if (i === stmts.length - 1) code += this.indent() + `return ${this.generate(stmts[i], 'value')};\n`;
           else code += this.indent() + this.generate(stmts[i], 'statement') + ';\n';
@@ -2722,8 +2722,13 @@ export class CodeGenerator {
         code += this.indent() + `return ${this.extractExpression(body)};\n`;
       }
     } else {
-      if (this.is(body, 'block') && body.length > 1) {
-        for (let s of body.slice(1)) code += this.indent() + this.generate(s, 'statement') + ';\n';
+      if (stmts.length === 1 && this.is(stmts[0], 'if') && !this.hasStatementInBranch(stmts[0]) && !this.hasNestedMultiStatement(stmts[0])) {
+        let [_, condition, thenBranch, ...elseBranches] = stmts[0];
+        let thenExpr = this.extractExpression(this.unwrapIfBranch(thenBranch));
+        let elseExpr = this.buildTernaryChain(elseBranches);
+        code += this.indent() + `(${this.unwrap(this.generate(condition, 'value'))} ? ${thenExpr} : ${elseExpr});\n`;
+      } else if (this.is(body, 'block') && body.length > 1) {
+        for (let s of stmts) code += this.indent() + this.generate(s, 'statement') + ';\n';
       } else {
         code += this.indent() + this.generate(body, 'statement') + ';\n';
       }

package/src/components.js

@@ -236,18 +236,20 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       if (!inRender) return 1;
 
       // ─────────────────────────────────────────────────────────────────────
-      // Expression output: = expr → text node (stamp .text, skip tag detection)
+      // Expression output: = expr → synthetic text node __text__(expr)
       // ─────────────────────────────────────────────────────────────────────
       if (tag === '=' && i > 0) {
         let prev = tokens[i - 1][0];
         if (prev === 'TERMINATOR' || prev === 'INDENT' || prev === 'RENDER') {
-          tokens.splice(i, 1);
-          if (tokens[i] && tokens[i][0] === 'IDENTIFIER') {
-            let val = tokens[i][1];
-            if (typeof val === 'string') { val = new String(val); tokens[i][1] = val; }
-            val.text = true;
-          }
-          return 0;
+          const textToken = gen('IDENTIFIER', '__text__', token);
+          const callStart = gen('CALL_START', '(', token);
+          tokens.splice(i, 1, textToken, callStart);
+          this.detectEnd(i + 2,
+            (t) => t[0] === 'TERMINATOR' || t[0] === 'OUTDENT',
+            (t, j) => tokens.splice(j, 0, gen('CALL_END', ')', t)),
+            { returnOnNegativeLevel: true }
+          );
+          return 2;
         }
       }
 
@@ -432,7 +434,8 @@ export function installComponentSupport(CodeGenerator, Lexer) {
 
         let isTemplateElement = false;
         let prevTag = i > 0 ? tokens[i - 1][0] : null;
-        let isAfterControlFlow = prevTag === 'IF' || prevTag === 'UNLESS' || prevTag === 'WHILE' || prevTag === 'UNTIL' || prevTag === 'WHEN';
+        let isAfterControlFlow = prevTag === 'IF' || prevTag === 'UNLESS' || prevTag === 'WHILE' || prevTag === 'UNTIL' || prevTag === 'WHEN' ||
+                                 prevTag === 'FORIN' || prevTag === 'FOROF' || prevTag === 'FORAS' || prevTag === 'FORASAWAIT' || prevTag === 'BY';
 
         // Detect __clsx CALL_END early — OUTDENT tokens inside multi-line .()
         // args prevent startsWithTag from seeing the template tag, so we check
@@ -1604,6 +1607,20 @@ export function installComponentSupport(CodeGenerator, Lexer) {
       return this.generateTemplateLoop(sexpr);
     }
 
+    // Synthetic text node inserted by rewriteRender for `= expr`
+    if (headStr === '__text__') {
+      const expr = rest[0] ?? 'undefined';
+      const textVar = this.newTextVar();
+      const exprCode = this.generateInComponent(expr, 'value');
+      if (this.hasReactiveDeps(expr)) {
+        this._createLines.push(`${textVar} = document.createTextNode('');`);
+        this._pushEffect(`${textVar}.data = String(${exprCode});`);
+      } else {
+        this._createLines.push(`${textVar} = document.createTextNode(String(${exprCode}));`);
+      }
+      return textVar;
+    }
+
     // General expression (computed value, function call, binary op, etc.)
     const textVar = this.newTextVar();
     const exprCode = this.generateInComponent(sexpr, 'value');

package/src/lexer.js

@@ -1476,7 +1476,8 @@ export class Lexer {
         [indent, outdent] = this.makeIndentation();
         if (tag === 'THEN') indent.fromThen = true;
         tokens.splice(i + 1, 0, indent);
-        this.detectEnd(i + 2, condition, action);
+        if (tag === 'THEN' && this.singleLineOwner(i) === 'LEADING_WHEN') this.detectWhenThenEnd(i + 2, condition, action);
+        else this.detectEnd(i + 2, condition, action);
         if (tag === 'THEN') tokens.splice(i, 1);
         return 1;
       }
@@ -1485,6 +1486,35 @@ export class Lexer {
     });
   }
 
+  singleLineOwner(i) {
+    let starters = new Set(['LEADING_WHEN', 'IF', 'POST_IF', 'UNLESS', 'POST_UNLESS', 'ELSE', 'CATCH', 'TRY', 'FINALLY', '->', '=>']);
+    for (let j = i - 1; j >= 0; j--) {
+      let token = this.tokens[j];
+      let tag = token?.[0];
+      if (starters.has(tag)) return tag;
+      if (LINE_BREAK.has(tag) || token?.newLine) return null;
+    }
+    return null;
+  }
+
+  detectWhenThenEnd(i, condition, action) {
+    let levels = 0;
+    let nestedInlineBranches = 0;
+    while (i < this.tokens.length) {
+      let token = this.tokens[i];
+      let tag = token[0];
+      if (levels === 0) {
+        if (tag === 'THEN' && this.singleLineOwner(i) !== 'LEADING_WHEN') nestedInlineBranches++;
+        else if (tag === 'ELSE' && nestedInlineBranches > 0) nestedInlineBranches--;
+        else if (condition.call(this, token, i)) return action.call(this, token, i);
+      }
+      if (EXPRESSION_START.has(tag)) levels++;
+      if (EXPRESSION_END.has(tag)) levels--;
+      if (levels < 0) return action.call(this, token, i);
+      i++;
+    }
+  }
+
   tagPostfixConditionals() {
     let original = null;