rip-lang 3.13.89 → 3.13.91

package/package.json

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

package/src/browser.js

@@ -197,12 +197,15 @@ async function processRipScripts() {
     es.addEventListener('reload', (e) => {
       if (e.data === 'styles') {
         const t = Date.now();
+        let refreshed = 0;
         document.querySelectorAll('link[rel="stylesheet"]').forEach(l => {
           if (new URL(l.href).origin !== location.origin) return;
           const url = new URL(l.href);
           url.searchParams.set('_r', t);
           l.href = url.toString();
+          refreshed++;
         });
+        if (!refreshed) location.reload();
       } else {
         location.reload();
       }

package/src/components.js

@@ -1129,18 +1129,29 @@ export function installComponentSupport(CodeGenerator, Lexer) {
     // Call expression: (tag.class args...) or ((tag.class) args...)
     if (Array.isArray(head)) {
       // Nested dynamic class call: (((. div __clsx) "classes") children)
+      // Also handles combined: (((. (. div step-card) __clsx) "classes") children)
       if (Array.isArray(head[0]) && head[0][0] === '.' &&
           (head[0][2] === '__clsx' || (head[0][2] instanceof String && head[0][2].valueOf() === '__clsx'))) {
-        const tag = typeof head[0][1] === 'string' ? head[0][1] : head[0][1].valueOf();
+        const tagExpr = head[0][1];
         const classExprs = head.slice(1);
+        if (Array.isArray(tagExpr)) {
+          const { tag, classes, id } = this.collectTemplateClasses(tagExpr);
+          if (tag) {
+            const staticArgs = classes.map(c => `"${c}"`);
+            return this.generateDynamicTag(tag, classExprs, rest, staticArgs, id);
+          }
+        }
+        const tag = typeof tagExpr === 'string' ? tagExpr : tagExpr.valueOf();
         return this.generateDynamicTag(tag, classExprs, rest);
       }
 
       const { tag, classes, id } = this.collectTemplateClasses(head);
       if (tag && this.isHtmlTag(tag)) {
-        // Dynamic class syntax: div.("classes") → (. div __clsx) "classes"
-        if (classes.length === 1 && classes[0] === '__clsx') {
-          return this.generateDynamicTag(tag, rest, []);
+        // Dynamic class syntax: div.("classes") or div.card.("classes")
+        if (classes.length > 0 && classes[classes.length - 1] === '__clsx') {
+          const staticClasses = classes.slice(0, -1);
+          const staticArgs = staticClasses.map(c => `"${c}"`);
+          return this.generateDynamicTag(tag, rest, [], staticArgs, id);
         }
         return this.generateTag(tag, classes, rest, id);
       }
@@ -1314,18 +1325,19 @@ export function installComponentSupport(CodeGenerator, Lexer) {
   // generateDynamicTag — tag with .() CLSX dynamic classes
   // --------------------------------------------------------------------------
 
-  proto.generateDynamicTag = function(tag, classExprs, children) {
+  proto.generateDynamicTag = function(tag, classExprs, children, staticClassArgs, id) {
     const elVar = this.newElementVar();
     if (SVG_TAGS.has(tag) || this._svgDepth > 0) {
       this._createLines.push(`${elVar} = document.createElementNS('${SVG_NS}', '${tag}');`);
     } else {
       this._createLines.push(`${elVar} = document.createElement('${tag}');`);
     }
+    if (id) this._createLines.push(`${elVar}.id = '${id}';`);
 
     const autoWireClaimed = this._claimAutoWire(elVar);
 
     // Defer className emission so class: attributes can merge with .() classes
-    const classArgs = classExprs.map(e => this.generateInComponent(e, 'value'));
+    const classArgs = [...(staticClassArgs || []), ...classExprs.map(e => this.generateInComponent(e, 'value'))];
     const prevClassArgs = this._pendingClassArgs;
     const prevClassEl = this._pendingClassEl;
     this._pendingClassArgs = classArgs;

package/src/lexer.js

@@ -1100,11 +1100,63 @@ export class Lexer {
     return len;
   }
 
+  // --------------------------------------------------------------------------
+  // Word Literal: %w[foo bar baz] → ["foo", "bar", "baz"]
+  // --------------------------------------------------------------------------
+
+  wordLiteral() {
+    if (this.chunk[0] !== '%' || this.chunk[1] !== 'w') return 0;
+    let opener = this.chunk[2];
+    if (!opener || /\s/.test(opener)) return 0;
+
+    let PAIRS = {'[': ']', '(': ')', '{': '}', '<': '>'};
+    let closer = PAIRS[opener] || opener;
+    let paired = closer !== opener;
+
+    // Scan for the closing delimiter, counting nested pairs
+    let depth = 1;
+    let i = 3;
+    while (i < this.chunk.length && depth > 0) {
+      let ch = this.chunk[i];
+      if (ch === '\\') { i += 2; continue; }
+      if (paired && ch === opener) depth++;
+      if (ch === closer) depth--;
+      if (depth > 0) i++;
+    }
+    if (depth !== 0) return 0;
+
+    let content = this.chunk.slice(3, i);
+    let total = i + 1; // %w + opener + content + closer
+
+    // Split on whitespace, handling backslash-space escapes
+    let words = [];
+    if (content.trim()) {
+      let raw = content.trim().split(/(?<!\\)\s+/);
+      for (let w of raw) {
+        words.push(w.replace(/\\ /g, ' '));
+      }
+    }
+
+    // Emit tokens: [ STRING , STRING , STRING ]
+    this.emit('[', '[', {len: total});
+    for (let j = 0; j < words.length; j++) {
+      if (j > 0) this.emit(',', ',');
+      this.emit('STRING', `"${words[j]}"`);
+    }
+    this.emit(']', ']');
+
+    return total;
+  }
+
   // --------------------------------------------------------------------------
   // 9. Literal Token (operators, punctuation, everything else)
   // --------------------------------------------------------------------------
 
   literalToken() {
+    // %w word literal: %w[foo bar baz] → ["foo", "bar", "baz"]
+    let wl = this.wordLiteral();
+    if (wl) return wl;
+
     let match = OPERATOR_RE.exec(this.chunk);
     let val = match ? match[0] : this.chunk.charAt(0);
     let tag = val;