@sola-air-ui/compiler 1.3.0 → 1.4.0

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "@sola-air-ui/compiler",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Compiler for Sola single-file components (.sola) \u2014 transforms template + script + style to ES modules",
   "type": "module",
   "main": "./src/index.js",
   "bin": {
-    "sola": "src/cli.js"
+    "sola": "src/cli.js",
+    "sola-check": "src/check-cli.js"
   },
   "exports": {
-    ".": "./src/index.js"
+    ".": "./src/index.js",
+    "./check": {
+      "types": "./types/check.d.ts",
+      "default": "./src/check.js"
+    }
   },
   "scripts": {
     "test": "node test/compiler.test.js"

package/src/check-cli.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { checkFiles, RULES } from './check.js';
+
+const args = process.argv.slice(2);
+
+if (args.includes('-h') || args.includes('--help')) {
+  console.log(`
+  Usage:
+    sola-check [paths...] [options]
+
+  Checks .sola files for compile errors and for unbalanced template blocks.
+  The compiler accepts an unclosed {#if} or a stray {/each} without an error
+  and renders it as literal text. With no paths it checks the current directory. node_modules, dist and .git
+  are skipped.
+
+  Options:
+    --strict      Exit 1 on warnings as well as errors (no rule warns yet)
+    --json        Print diagnostics as JSON
+    -h, --help    Show this help message
+
+  Rules:
+${Object.entries(RULES).map(([code, text]) => `    ${code}  ${text}`).join('\n')}
+  `);
+  process.exit(0);
+}
+
+const strict = args.includes('--strict');
+const json = args.includes('--json');
+const targets = args.filter((a) => !a.startsWith('-'));
+
+let result;
+try {
+  result = checkFiles(targets.length ? targets : ['.']);
+} catch (err) {
+  console.error(`sola-check: ${err.message}`);
+  process.exit(2);
+}
+
+const { files, diagnostics } = result;
+const errors = diagnostics.filter((d) => d.severity === 'error').length;
+const warnings = diagnostics.length - errors;
+
+if (json) {
+  console.log(JSON.stringify({ files: files.length, errors, warnings, diagnostics }, null, 2));
+} else {
+  for (const d of diagnostics) {
+    console.log(`${d.file}:${d.line}:${d.column}  ${d.severity}  ${d.code}  ${d.message}`);
+  }
+  const noun = files.length === 1 ? 'file' : 'files';
+  console.log(`${diagnostics.length ? '\n' : ''}${files.length} ${noun} checked: ${errors} error${errors === 1 ? '' : 's'}, ${warnings} warning${warnings === 1 ? '' : 's'}`);
+}
+
+process.exit(errors || (strict && warnings) ? 1 : 0);

package/src/check.js

@@ -0,0 +1,102 @@
+// Static checks for .sola files.
+//
+// The compiler accepts an unbalanced block (an unclosed `{#if}`, a stray
+// `{/each}` or `{:else}`) without an error and emits it as literal text, so a
+// file can compile and then show `{#if ...}` on the page. These checks catch
+// that before it ships.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { compile } from './index.js';
+
+export const RULES = {
+  SOLA000: 'compile error',
+  SOLA001: 'unbalanced block'
+};
+
+// Blank out <script> and <style> bodies, keeping newlines so line numbers hold.
+function maskNonTemplate(source) {
+  return source.replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, (m) => m.replace(/[^\n]/g, ' '));
+}
+
+function position(source, index) {
+  const before = source.slice(0, index);
+  const line = before.split('\n').length;
+  return { line, column: index - before.lastIndexOf('\n') };
+}
+
+/**
+ * Check one component's source. Returns diagnostics:
+ * `{ file, line, column, severity: 'error' | 'warning', code, message }`.
+ */
+export function checkSource(source, filename = 'component.sola') {
+  const diagnostics = [];
+  const add = (index, severity, code, message) =>
+    diagnostics.push({ file: filename, ...position(source, index), severity, code, message });
+
+  try {
+    compile(source, { filename, sourcemap: false });
+  } catch (err) {
+    const m = /\(line (\d+), col (\d+)\)/.exec(err.message);
+    diagnostics.push({
+      file: filename,
+      line: m ? Number(m[1]) : 1,
+      column: m ? Number(m[2]) : 1,
+      severity: 'error',
+      code: 'SOLA000',
+      message: err.message.replace(/^\[sola compiler\]\s*/, '').split('\n').map((s) => s.trim()).filter(Boolean).join(' ')
+    });
+  }
+
+  const template = maskNonTemplate(source);
+  const tag = /\{(#if|#each|\/if|\/each|:else)(?![\w])/g;
+  const stack = [];
+  let match;
+  while ((match = tag.exec(template))) {
+    const kind = match[1];
+    const at = match.index;
+    if (kind === '#if' || kind === '#each') {
+      stack.push({ kind: kind.slice(1), at });
+    } else if (kind === ':else') {
+      if (stack.at(-1)?.kind !== 'if') add(at, 'error', 'SOLA001', '`{:else}` outside an `{#if}` block. It renders as literal text.');
+    } else {
+      const want = kind.slice(1);
+      const open = stack.pop();
+      if (!open) add(at, 'error', 'SOLA001', `\`{/${want}}\` has no matching \`{#${want}}\`. It renders as literal text.`);
+      else if (open.kind !== want) add(at, 'error', 'SOLA001', `\`{/${want}}\` closes \`{#${open.kind}}\` from line ${position(source, open.at).line}.`);
+    }
+  }
+  for (const open of stack) add(open.at, 'error', 'SOLA001', `\`{#${open.kind}}\` is never closed. It renders as literal text.`);
+
+  return diagnostics.sort((a, b) => a.line - b.line || a.column - b.column);
+}
+
+const SKIP_DIRS = new Set(['node_modules', 'dist', 'build', '.git', '.svelte-kit', '.vercel']);
+
+/** Find every .sola file under the given files or directories. */
+export function findSolaFiles(targets) {
+  const files = [];
+  const walk = (p) => {
+    const stat = fs.statSync(p);
+    if (stat.isFile()) {
+      if (p.endsWith('.sola')) files.push(p);
+      return;
+    }
+    for (const entry of fs.readdirSync(p, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (!SKIP_DIRS.has(entry.name)) walk(path.join(p, entry.name));
+      } else if (entry.name.endsWith('.sola')) {
+        files.push(path.join(p, entry.name));
+      }
+    }
+  };
+  for (const t of targets) walk(t);
+  return files.sort();
+}
+
+/** Check files on disk. Returns `{ files, diagnostics }`. */
+export function checkFiles(targets) {
+  const files = findSolaFiles(targets);
+  const diagnostics = files.flatMap((f) => checkSource(fs.readFileSync(f, 'utf8'), f));
+  return { files, diagnostics };
+}

package/src/index.js

@@ -976,6 +976,14 @@ export function compile(source, options = {}) {
           edits.push({ start: call.end, end: call.end, replacement: ')' });
         }
 
+        // $effect(fn) as a bare statement: the form the docs show. It compiles to
+        // createEffect(fn); the declaration form (const stop = $effect(fn)) is below.
+        if (node.type === 'ExpressionStatement' && node.expression.type === 'CallExpression' &&
+            node.expression.callee.type === 'Identifier' && node.expression.callee.name === '$effect') {
+          const callee = node.expression.callee;
+          edits.push({ start: callee.start, end: callee.end, replacement: 'createEffect' });
+        }
+
         // $state()/$derived()/$effect()/$intent()/$data() macro declarations.
         // Bracket edits (head + tail) leave the argument expression in place so
         // the reactive rewrite pass below can still auto-call signals inside it.

package/types/check.d.ts

@@ -0,0 +1,24 @@
+// Type declarations for @sola-air-ui/compiler/check.
+
+export interface Diagnostic {
+  file: string;
+  /** 1-based. */
+  line: number;
+  /** 1-based. */
+  column: number;
+  severity: 'error' | 'warning';
+  /** SOLA000 compile error, SOLA001 unbalanced block. */
+  code: 'SOLA000' | 'SOLA001';
+  message: string;
+}
+
+export const RULES: Record<Diagnostic['code'], string>;
+
+/** Check one component's source text. */
+export function checkSource(source: string, filename?: string): Diagnostic[];
+
+/** Every .sola file under the given files or directories, skipping node_modules, dist and .git. */
+export function findSolaFiles(targets: string[]): string[];
+
+/** Check .sola files on disk. */
+export function checkFiles(targets: string[]): { files: string[]; diagnostics: Diagnostic[] };