@chilts/weave 0.7.0 → 0.8.0

package/dist/cli/index.js

@@ -4,6 +4,8 @@ import { compile, compileWithSourceMap, definedMixins } from '../codegen/index.j
 import { lex, LexerError } from '../lexer/index.js';
 import { parse, ParserError } from '../parser/index.js';
 import { CodegenError } from '../codegen/index.js';
+import { formatCodeFrame } from '../diagnostics/index.js';
+import { check } from './check.js';
 export class UsageError extends Error {
     constructor(message) {
         super(message);
@@ -16,6 +18,9 @@ export function parseArgs(argv) {
     if (argv.includes('--help') || argv.includes('-h')) {
         return { mode: 'help' };
     }
+    if (argv[0] === 'check') {
+        return parseCheckArgs(argv.slice(1));
+    }
     const isWatch = argv.includes('--watch') || argv.includes('-w');
     const noSourcemap = argv.includes('--no-sourcemap');
     const positional = argv.filter(a => !FLAGS.includes(a));
@@ -35,12 +40,51 @@ export function parseArgs(argv) {
     }
     return { mode: 'compile', inputPath, outputPath, sourcemap: !noSourcemap };
 }
+function parseCheckArgs(argv) {
+    let project;
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--project' || arg === '-p') {
+            project = argv[++i];
+            if (project === undefined)
+                throw new UsageError(`${arg} requires a path`);
+        }
+        else if (arg.startsWith('--project=')) {
+            project = arg.slice('--project='.length);
+        }
+        else if (arg === '--watch' || arg === '-w') {
+            throw new UsageError('check does not support --watch yet');
+        }
+        else if (arg === '--no-sourcemap') {
+            throw new UsageError('check always writes source maps; --no-sourcemap is not allowed');
+        }
+        else {
+            positional.push(arg);
+        }
+    }
+    if (positional.length < 2) {
+        throw new UsageError('missing required arguments');
+    }
+    if (positional.length > 2) {
+        throw new UsageError('too many arguments');
+    }
+    const args = { mode: 'check', inputPath: positional[0], outputPath: positional[1] };
+    if (project !== undefined)
+        args.project = project;
+    return args;
+}
 export function usage() {
     return [
         'Usage: weave [--watch] [--no-sourcemap] <input> <output>',
+        '       weave check [--project <tsconfig>] <input> <output>',
         '',
         '  Compile .weave templates to TypeScript.',
         '',
+        '  check compiles the templates, then type-checks the project with the',
+        '  TypeScript compiler and reports each error at its .weave location. It',
+        '  exits 1 if there are any errors. It needs the typescript package.',
+        '',
         '  <input>   A .weave file or directory containing .weave files',
         '  <output>  Output .ts file or directory for compiled output',
         '',
@@ -50,11 +94,13 @@ export function usage() {
         'Options:',
         '  --watch, -w     Watch for changes and recompile (directory mode only)',
         '  --no-sourcemap  Disable source map generation',
+        '  --project, -p   tsconfig.json for check (default: nearest to the cwd)',
         '',
         'Examples:',
         '  weave views/ lib/views/               Compile all templates',
         '  weave views/page.weave lib/views/page.ts   Compile single file',
         '  weave --watch views/ lib/views/        Watch and recompile on changes',
+        '  weave check views/ lib/views/         Compile and type-check',
     ].join('\n');
 }
 export function discoverFiles(inputDir) {
@@ -98,7 +144,7 @@ function walkAll(dir, base, files, dirs) {
 // gone is an orphan and is removed, so a deleted template stops being compiled
 // into the app. Files weave never emits — anything that is not .ts/.ts.map — are
 // left where they are, as are directories that still hold one of them.
-export function pruneOrphans(inputDir, outputDir) {
+export function pruneOrphans(inputDir, outputDir, log = console.log) {
     const files = [];
     const dirs = [];
     try {
@@ -117,7 +163,7 @@ export function pruneOrphans(inputDir, outputDir) {
         const outFile = path.join(outputDir, relPath);
         try {
             unlinkSync(outFile);
-            console.log(`${outFile} (removed)`);
+            log(`${outFile} (removed)`);
         }
         catch {
             // Already gone, or not ours to delete.
@@ -142,15 +188,7 @@ export function formatElapsed(ms) {
         return `${Math.round(ms)}ms`;
     return `${(ms / 1000).toFixed(2)}s`;
 }
-export function formatCodeFrame(source, line, col) {
-    const lines = source.split('\n');
-    if (line < 1 || line > lines.length)
-        return '';
-    const sourceLine = lines[line - 1];
-    const lineNum = String(line);
-    const gutter = ' '.repeat(lineNum.length);
-    return `\n ${lineNum} | ${sourceLine}\n ${gutter} | ${' '.repeat(col - 1)}^`;
-}
+export { formatCodeFrame, check };
 export function formatError(filePath, err, source) {
     let line;
     let col;
@@ -183,7 +221,7 @@ export function includeResolver(inputFile) {
         }
         catch (err) {
             if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
-                throw new Error(`${path.relative(process.cwd(), file)}: no such file`);
+                throw new Error(`${path.relative(process.cwd(), file)}: no such file`, { cause: err });
             }
             throw err;
         }
@@ -283,22 +321,49 @@ export function compileDir(inputDir, outputDir, sourcemap = true) {
         console.error(`weave: no .weave files found in ${inputDir}`);
         process.exit(1);
     }
-    let hasErrors = false;
-    for (const relPath of files) {
-        const inFile = path.join(inputDir, relPath);
-        const outFile = path.join(outputDir, relPath.replace(/\.weave$/, '.ts'));
-        const source = readFileSync(inFile, 'utf-8');
+    const pairs = files.map(relPath => ({
+        inputFile: path.join(inputDir, relPath),
+        outputFile: path.join(outputDir, relPath.replace(/\.weave$/, '.ts')),
+    }));
+    const { failed } = compileFiles(pairs, sourcemap);
+    pruneOrphans(inputDir, outputDir);
+    return failed.length > 0;
+}
+/** Where single-file mode writes: <output> itself if it is a .ts, else a file inside it. */
+export function singleOutputFile(inputPath, outputPath) {
+    return outputPath.endsWith('.ts')
+        ? outputPath
+        : path.join(outputPath, path.basename(inputPath).replace(/\.weave$/, '.ts'));
+}
+/**
+ * Compile each pair, logging one line per success and printing each error to
+ * stderr. Returns the outputs written and the inputs that failed, so a caller
+ * can decide what a failure means.
+ */
+export function compileFiles(pairs, sourcemap, log = console.log) {
+    const written = [];
+    const failed = [];
+    for (const { inputFile, outputFile } of pairs) {
+        let source;
         try {
-            const elapsed = writeCompiled(inFile, outFile, source, sourcemap);
-            console.log(`${outFile} (${formatElapsed(elapsed)})`);
+            source = readFileSync(inputFile, 'utf-8');
         }
         catch (err) {
-            console.error(formatError(inFile, err, source));
-            hasErrors = true;
+            console.error(formatError(inputFile, err));
+            failed.push(inputFile);
+            continue;
+        }
+        try {
+            const elapsed = writeCompiled(inputFile, outputFile, source, sourcemap);
+            log(`${outputFile} (${formatElapsed(elapsed)})`);
+            written.push(outputFile);
+        }
+        catch (err) {
+            console.error(formatError(inputFile, err, source));
+            failed.push(inputFile);
         }
     }
-    pruneOrphans(inputDir, outputDir);
-    return hasErrors;
+    return { written, failed };
 }
 // How often the reconciliation pass runs (see reconcile()).
 const RECONCILE_INTERVAL_MS = 2000;
@@ -529,6 +594,12 @@ export function main(argv) {
         console.log(usage());
         process.exit(0);
     }
+    if (args.mode === 'check') {
+        const code = check(args);
+        if (code !== 0)
+            process.exit(code);
+        return;
+    }
     const { inputPath, outputPath, sourcemap } = args;
     if (args.mode === 'watch') {
         watchDir(inputPath, outputPath, sourcemap);
@@ -536,9 +607,7 @@ export function main(argv) {
     }
     if (inputPath.endsWith('.weave')) {
         // Single-file mode
-        const outFile = outputPath.endsWith('.ts')
-            ? outputPath
-            : path.join(outputPath, path.basename(inputPath).replace(/\.weave$/, '.ts'));
+        const outFile = singleOutputFile(inputPath, outputPath);
         const source = readFileSync(inputPath, 'utf-8');
         try {
             const elapsed = writeCompiled(inputPath, outFile, source, sourcemap);