@weave-framework/cli 0.2.0 → 0.2.53

package/dist/cli.js

@@ -411,13 +411,7 @@ var Parser = class {
     return this.src[this.pos];
   }
   readInterp() {
-    this.pos += 2;
-    const start = this.pos;
-    const end = this.src.indexOf("}}", this.pos);
-    if (end === -1) throw new ParseError("Unclosed {{ interpolation");
-    this.pos = end + 2;
-    const raw = this.src.slice(start, end);
-    return { expr: raw.trim(), offset: start + (raw.length - raw.trimStart().length) };
+    return this.readDoubleBracedExpr();
   }
   skipComment() {
     const end = this.src.indexOf("-->", this.pos);
@@ -684,12 +678,63 @@ function rewrite(expr, scope, ctxRef = "ctx") {
   };
   while (i < n) {
     const c = expr[i];
-    if (c === '"' || c === "'" || c === "`") {
+    if (c === '"' || c === "'") {
       const end = scanString(expr, i);
       copy(i, expr.slice(i, end));
       i = end;
       continue;
     }
+    if (c === "`") {
+      copy(i, "`");
+      let k = i + 1;
+      while (k < n) {
+        const ch = expr[k];
+        if (ch === "\\") {
+          copy(k, expr.slice(k, k + 2));
+          k += 2;
+          continue;
+        }
+        if (ch === "`") {
+          copy(k, "`");
+          k++;
+          break;
+        }
+        if (ch === "$" && expr[k + 1] === "{") {
+          copy(k, "${");
+          k += 2;
+          const exprStart = k;
+          let depth = 1;
+          while (k < n && depth > 0) {
+            const mc = expr[k];
+            if (mc === '"' || mc === "'" || mc === "`") {
+              k = scanString(expr, k);
+              continue;
+            }
+            if (mc === "{") depth++;
+            else if (mc === "}") {
+              depth--;
+              if (depth === 0) break;
+            }
+            k++;
+          }
+          const sub = rewrite(expr.slice(exprStart, k), scope, ctxRef);
+          if (sub.reactive) reactive = true;
+          flush();
+          const genStart = out.length;
+          for (const s of sub.segments) segments.push({ src: exprStart + s.src, gen: genStart + s.gen, len: s.len });
+          out += sub.code;
+          if (expr[k] === "}") {
+            copy(k, "}");
+            k++;
+          }
+          continue;
+        }
+        copy(k, ch);
+        k++;
+      }
+      i = k;
+      continue;
+    }
     if (ID_START.test(c)) {
       let j = i + 1;
       while (j < n && ID_CHAR.test(expr[j])) j++;
@@ -697,6 +742,11 @@ function rewrite(expr, scope, ctxRef = "ctx") {
       const isProperty = lastNonSpace(out) === ".";
       const binding = scope.get(name);
       if (binding && !isProperty) {
+        if (binding.kind !== "local") {
+          const prev = lastNonSpace(out);
+          const next = firstNonSpaceFrom(expr, j);
+          if ((prev === "{" || prev === ",") && (next === "," || next === "}")) insert(`${name}: `);
+        }
         if (binding.kind === "ctx") {
           insert(`${ctxRef}.`);
           copy(i, name);
@@ -736,6 +786,12 @@ function lastNonSpace(s) {
   }
   return "";
 }
+function firstNonSpaceFrom(s, from) {
+  for (let i = from; i < s.length; i++) {
+    if (!/\s/.test(s[i])) return s[i];
+  }
+  return "";
+}
 var NON_CTX = /* @__PURE__ */ new Set([
   // literals / keywords
   "true",
@@ -842,10 +898,47 @@ function freeIdentifiers(expr) {
   const n = expr.length;
   while (i < n) {
     const c = expr[i];
-    if (c === '"' || c === "'" || c === "`") {
+    if (c === '"' || c === "'") {
       i = scanString(expr, i);
       continue;
     }
+    if (c === "`") {
+      let k = i + 1;
+      while (k < n) {
+        const ch = expr[k];
+        if (ch === "\\") {
+          k += 2;
+          continue;
+        }
+        if (ch === "`") {
+          k++;
+          break;
+        }
+        if (ch === "$" && expr[k + 1] === "{") {
+          k += 2;
+          const start = k;
+          let depth = 1;
+          while (k < n && depth > 0) {
+            const mc = expr[k];
+            if (mc === '"' || mc === "'" || mc === "`") {
+              k = scanString(expr, k);
+              continue;
+            }
+            if (mc === "{") depth++;
+            else if (mc === "}") {
+              depth--;
+              if (depth === 0) break;
+            }
+            k++;
+          }
+          for (const id of freeIdentifiers(expr.slice(start, k))) out.add(id);
+          continue;
+        }
+        k++;
+      }
+      i = k;
+      continue;
+    }
     if (ID_START.test(c)) {
       let j = i + 1;
       while (j < n && ID_CHAR.test(expr[j])) j++;
@@ -1123,6 +1216,7 @@ function compileFragment(gen, nodes, scope, name, param = "", isHost = false) {
     html += "<!---->";
     const anchorVar = nodeExpr(path);
     const props = [];
+    const eventKeys = [];
     for (const attr of node.attrs) {
       switch (attr.type) {
         case "static":
@@ -1131,13 +1225,17 @@ function compileFragment(gen, nodes, scope, name, param = "", isHost = false) {
         case "attr":
           props.push(`get ${propKey(attr.name)}() { return ${rewrite(attr.expr, sc).code}; }`);
           break;
-        case "event":
-          props.push(`${propKey(onProp(attr.name))}: ${rewrite(attr.expr, sc).code}`);
+        case "event": {
+          const k = onProp(attr.name);
+          props.push(`${propKey(k)}: ${rewrite(attr.expr, sc).code}`);
+          eventKeys.push(k);
           break;
+        }
         default:
           throw new Error(`'${attr.type}' binding on <${node.tag}> is not supported yet (M5: props + on:event only)`);
       }
     }
+    if (eventKeys.length) props.push(`'$events': [${eventKeys.map((k) => JSON.stringify(k)).join(", ")}]`);
     const groups = /* @__PURE__ */ new Map();
     for (const child of node.children) {
       let target = child;
@@ -1620,89 +1718,120 @@ function skipString(s, start) {
 
 // packages/compiler/src/infer.ts
 var FOR_VARS = ["$index", "$count", "$first", "$last", "$even", "$odd"];
+function childLists(node) {
+  switch (node.type) {
+    case "element":
+    case "snippet":
+    case "key":
+      return [node.children];
+    case "if":
+      return node.branches.map((b) => b.children);
+    case "for":
+      return node.empty ? [node.children, node.empty] : [node.children];
+    case "switch":
+      return node.cases.map((c) => c.children);
+    case "defer":
+      return node.placeholder ? [node.children, node.placeholder] : [node.children];
+    case "await": {
+      const lists = [];
+      if (node.pending) lists.push(node.pending);
+      if (node.then) lists.push(node.then.children);
+      if (node.catch) lists.push(node.catch.children);
+      return lists;
+    }
+    default:
+      return [];
+  }
+}
 function inferCtxNames(nodes) {
   const used = /* @__PURE__ */ new Set();
-  const declared = /* @__PURE__ */ new Set();
-  const add = (expr) => {
-    if (expr) for (const id of freeIdentifiers(expr)) used.add(id);
+  const snippetNames = /* @__PURE__ */ new Set();
+  const collectSnippets = (list) => {
+    for (const node of list) {
+      if (node.type === "snippet") snippetNames.add(node.name);
+      for (const cl of childLists(node)) collectSnippets(cl);
+    }
+  };
+  collectSnippets(nodes);
+  const add = (expr, declared) => {
+    if (!expr) return;
+    for (const id of freeIdentifiers(expr)) {
+      if (!declared.has(id) && !snippetNames.has(id)) used.add(id);
+    }
   };
-  const walk2 = (list) => {
+  const walk2 = (list, parentDeclared) => {
+    let declared = parentDeclared;
     for (const node of list) {
       switch (node.type) {
         case "text":
           break;
         case "interp":
-          add(node.expr);
+          add(node.expr, declared);
           break;
         case "let":
-          add(node.expr);
-          declared.add(node.name);
+          add(node.expr, declared);
+          declared = new Set(declared).add(node.name);
           break;
         case "element":
           for (const attr of node.attrs) {
-            if (attr.type === "use") add(attr.name);
-            if (attr.type === "transition") add(attr.name);
-            if (attr.type !== "static") add(attr.expr);
+            if (attr.type === "use") add(attr.name, declared);
+            if (attr.type === "transition") add(attr.name, declared);
+            if (attr.type !== "static") add(attr.expr, declared);
           }
-          walk2(node.children);
+          walk2(node.children, declared);
           break;
         case "if":
           for (const br of node.branches) {
-            add(br.cond);
-            if (br.alias) declared.add(br.alias);
-            walk2(br.children);
+            add(br.cond, declared);
+            walk2(br.children, br.alias ? new Set(declared).add(br.alias) : declared);
           }
           break;
-        case "for":
-          add(node.list);
-          add(node.track);
-          declared.add(node.item);
-          for (const v of FOR_VARS) declared.add(v);
-          walk2(node.children);
-          if (node.empty) walk2(node.empty);
+        case "for": {
+          add(node.list, declared);
+          const inner = new Set(declared).add(node.item);
+          for (const v of FOR_VARS) inner.add(v);
+          add(node.track, inner);
+          walk2(node.children, inner);
+          if (node.empty) walk2(node.empty, declared);
           break;
+        }
         case "switch":
-          add(node.expr);
+          add(node.expr, declared);
           for (const c of node.cases) {
-            add(c.test);
-            walk2(c.children);
+            add(c.test, declared);
+            walk2(c.children, declared);
           }
           break;
         case "defer":
-          if (node.trigger.kind === "when") add(node.trigger.expr);
-          if (node.trigger.kind === "timer") add(node.trigger.ms);
-          walk2(node.children);
-          if (node.placeholder) walk2(node.placeholder);
+          if (node.trigger.kind === "when") add(node.trigger.expr, declared);
+          if (node.trigger.kind === "timer") add(node.trigger.ms, declared);
+          walk2(node.children, declared);
+          if (node.placeholder) walk2(node.placeholder, declared);
           break;
         case "await":
-          add(node.expr);
-          if (node.pending) walk2(node.pending);
-          if (node.then) {
-            if (node.then.alias) declared.add(node.then.alias);
-            walk2(node.then.children);
-          }
-          if (node.catch) {
-            if (node.catch.alias) declared.add(node.catch.alias);
-            walk2(node.catch.children);
-          }
+          add(node.expr, declared);
+          if (node.pending) walk2(node.pending, declared);
+          if (node.then) walk2(node.then.children, node.then.alias ? new Set(declared).add(node.then.alias) : declared);
+          if (node.catch) walk2(node.catch.children, node.catch.alias ? new Set(declared).add(node.catch.alias) : declared);
           break;
-        case "snippet":
-          declared.add(node.name);
-          for (const p of node.params) declared.add(p);
-          walk2(node.children);
+        case "snippet": {
+          const inner = new Set(declared);
+          for (const p of node.params) inner.add(p);
+          walk2(node.children, inner);
           break;
+        }
         case "render":
-          add(node.expr);
+          add(node.expr, declared);
           break;
         case "key":
-          add(node.expr);
-          walk2(node.children);
+          add(node.expr, declared);
+          walk2(node.children, declared);
           break;
       }
     }
   };
-  walk2(nodes);
-  return [...used].filter((n) => !declared.has(n)).sort();
+  walk2(nodes, /* @__PURE__ */ new Set());
+  return [...used].sort();
 }
 
 // packages/compiler/src/component.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weave-framework/cli",
-  "version": "0.2.0",
+  "version": "0.2.53",
   "description": "Weave CLI — `weave build`, `weave dev` (watch + live-reload), `weave check`, `weave routes`.",
   "type": "module",
   "bin": {