@sola-air-ui/compiler 1.5.3 → 1.6.0

package/README.md

@@ -36,7 +36,7 @@ npx sola build App.sola
 npx sola-check src/
 ```
 
-`sola-check` validates `.sola` files on disk (pass `--json` for machine-readable output), reporting syntax errors (`SOLA000`) and unbalanced or malformed `{#if}` / `{#each}` / `{:else}` blocks (`SOLA001`).
+`sola-check` validates `.sola` files on disk (pass `--json` for machine-readable output), reporting syntax errors (`SOLA000`) and unbalanced or malformed `{#if}` / `{#each}` / `{:else}` blocks (`SOLA001`), and state written with `.set()` or `.update()` instead of assignment (`SOLA002`), which compiles but throws when it runs.
 
 ## What a `.sola` file looks like
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sola-air-ui/compiler",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "description": "Compiler for Sola single-file components (.sola) \u2014 transforms template + script + style to ES modules",
   "type": "module",
   "main": "./src/index.js",

package/src/check.js

@@ -11,9 +11,52 @@ import { compile } from './index.js';
 
 export const RULES = {
   SOLA000: 'compile error',
-  SOLA001: 'unbalanced block'
+  SOLA001: 'unbalanced block',
+  SOLA002: 'state written with .set() or .update()'
 };
 
+// Text of every <script> body. Plain index search, so `</script >` and odd
+// casing are handled the same way the browser would end the element.
+function scriptBodies(source) {
+  const lower = source.toLowerCase();
+  const bodies = [];
+  let from = 0;
+  for (;;) {
+    const open = lower.indexOf('<script', from);
+    if (open < 0) break;
+    const start = lower.indexOf('>', open);
+    if (start < 0) break;
+    const end = lower.indexOf('</script', start);
+    bodies.push(source.slice(start + 1, end < 0 ? source.length : end));
+    if (end < 0) break;
+    from = end + 8;
+  }
+  return bodies.join('\n');
+}
+
+// A `$state` / `$persist` name is its signal getter, so `count.set(1)` compiles
+// to `count().set(1)` and throws when it runs. State is written by assignment.
+function checkSetterCalls(source, add) {
+  const scripts = scriptBodies(source);
+  const names = new Set();
+  for (const m of scripts.matchAll(/\b(?:let|var|const)\s+([\w$]+)\s*=\s*\$(?:state|persist)\s*\(/g)) names.add(m[1]);
+  if (!names.size) return;
+  const blank = (m) => m.replace(/[^\n]/g, ' ');
+  const code = source
+    .replace(/<style\b[^>]*>[\s\S]*?<\/style>/gi, blank)
+    .replace(/<!--[\s\S]*?-->/g, blank)
+    .replace(/\/\*[\s\S]*?\*\//g, blank)
+    .replace(/(^|[^:])\/\/[^\n]*/g, (m, pre) => pre + blank(m.slice(pre.length)));
+  const call = /(?<![\w$.])([\w$]+)(\(\))?\s*\.\s*(set|update)\s*\(/g;
+  let m;
+  while ((m = call.exec(code))) {
+    const [, name, , method] = m;
+    if (!names.has(name)) continue;
+    const fix = method === 'set' ? `${name} = value` : `${name} = fn(${name})`;
+    add(m.index, 'error', 'SOLA002', `\`${name}.${method}()\` throws at runtime: \`${name}\` is state, which is written by assignment. Use \`${fix}\`.`);
+  }
+}
+
 // Blank out <script> and <style> bodies and HTML comments, keeping newlines so
 // line numbers hold. A commented-out block is not a block.
 function maskNonTemplate(source) {
@@ -68,6 +111,8 @@ export function checkSource(source, filename = 'component.sola') {
     });
   }
 
+  checkSetterCalls(source, add);
+
   const template = maskNonTemplate(source);
   const tag = /\{(#if|#each|\/if|\/each|:else)(?![\w])/g;
   const stack = [];
@@ -105,7 +150,7 @@ export function checkSource(source, filename = 'component.sola') {
               add(at, 'error', 'SOLA001', '`{:else if}` is missing a condition. It renders as literal text.');
             }
           } else {
-            add(at, 'error', 'SOLA001', '`{:else}` unexpected token (use `{:else}` or `{:else if <condition>}`). It renders as literal text.');
+            add(at, 'error', 'SOLA001', '`{:else}` has extra text after it (use `{:else}` or `{:else if <condition>}`). It renders as literal text.');
           }
         }
       }

package/src/index.js

@@ -73,9 +73,9 @@ function addScopeToCompound(compound, scopeHash) {
 //   :global(body)        →  body
 // The scope class always goes on the last compound that is not global.
 function scopeSelector(selector, scopeHash) {
-  const tokens = [];       // alternating compounds and combinators
+  const pieces = [];       // alternating compounds and combinators
   let depth = 0, cur = '', comb = '';
-  const flushCompound = () => { if (cur) { tokens.push({ compound: cur }); cur = ''; } };
+  const flushCompound = () => { if (cur) { pieces.push({ compound: cur }); cur = ''; } };
   for (let i = 0; i < selector.length; i++) {
     const c = selector[i];
     if (c === '(' || c === '[') depth++;
@@ -85,15 +85,15 @@ function scopeSelector(selector, scopeHash) {
       comb += c;
       continue;
     }
-    if (comb) { tokens.push({ comb }); comb = ''; }
+    if (comb) { pieces.push({ comb }); comb = ''; }
     cur += c;
   }
   flushCompound();
-  if (comb) tokens.push({ comb });
+  if (comb) pieces.push({ comb });
 
   let last = -1;
-  for (let i = 0; i < tokens.length; i++) {
-    const t = tokens[i];
+  for (let i = 0; i < pieces.length; i++) {
+    const t = pieces[i];
     if (t.compound === undefined) continue;
     const m = t.compound.match(/^:global\(([\s\S]*)\)$/);
     // A comma list must stay grouped, or `.a :global(.x, .y)` would turn into
@@ -105,8 +105,8 @@ function scopeSelector(selector, scopeHash) {
       t.global = true;
     } else { last = i; }
   }
-  if (last >= 0) tokens[last].compound = addScopeToCompound(tokens[last].compound, scopeHash);
-  return tokens.map(t => t.compound ?? t.comb).join('');
+  if (last >= 0) pieces[last].compound = addScopeToCompound(pieces[last].compound, scopeHash);
+  return pieces.map(t => t.compound ?? t.comb).join('');
 }
 
 function scopeSelectorList(selector, scopeHash) {

package/types/check.d.ts

@@ -7,8 +7,8 @@ export interface Diagnostic {
   /** 1-based. */
   column: number;
   severity: 'error' | 'warning';
-  /** SOLA000 compile error, SOLA001 unbalanced block. */
-  code: 'SOLA000' | 'SOLA001';
+  /** SOLA000 compile error, SOLA001 unbalanced block, SOLA002 state written with .set() or .update(). */
+  code: 'SOLA000' | 'SOLA001' | 'SOLA002';
   message: string;
 }