@chilts/weave 0.6.0 → 0.8.0

package/dist/cli/check.d.ts

@@ -0,0 +1,14 @@
+export interface CheckOptions {
+    inputPath: string;
+    outputPath: string;
+    /** tsconfig.json to check against; defaults to the nearest one above the cwd. */
+    project?: string;
+}
+/**
+ * `weave check`: compile the templates, type-check the whole tsconfig program
+ * with the compiled views added, and print every diagnostic — those in a
+ * compiled view at its .weave location. Progress goes to stderr and
+ * diagnostics to stdout. Returns the exit code: 1 if anything failed.
+ */
+export declare function check(options: CheckOptions): number;
+//# sourceMappingURL=check.d.ts.map

package/dist/cli/check.js

@@ -0,0 +1,133 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { mapDiagnostic, formatDiagnostic } from '../diagnostics/index.js';
+import { compileFiles, discoverFiles, pruneOrphans, singleOutputFile } from './index.js';
+// tsc's "No inputs were found in config file". The compiled views are added
+// as roots, so a tsconfig whose include matches nothing is still fine.
+const NO_INPUTS = 18003;
+/**
+ * The project's own typescript, so `check` agrees with the user's `tsc`.
+ * Falls back to one weave itself can resolve. Not a dependency of weave: only
+ * `check` needs it, and only when it runs.
+ */
+function loadTypeScript() {
+    for (const base of [path.join(process.cwd(), 'noop.js'), import.meta.url]) {
+        try {
+            return createRequire(base)('typescript');
+        }
+        catch {
+            // Try the next location.
+        }
+    }
+    return undefined;
+}
+// Relative to the cwd when it is under it, so the path is short and editors
+// resolve it against the directory `weave check` ran in.
+function displayPath(file) {
+    const rel = path.relative(process.cwd(), file);
+    return rel.startsWith('..') || path.isAbsolute(rel) ? file : rel;
+}
+function readSource(file) {
+    try {
+        return readFileSync(file, 'utf-8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function compilePairs(inputPath, outputPath) {
+    if (inputPath.endsWith('.weave')) {
+        return [{ inputFile: inputPath, outputFile: singleOutputFile(inputPath, outputPath) }];
+    }
+    let files;
+    try {
+        files = discoverFiles(inputPath);
+    }
+    catch (err) {
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+            return `${inputPath}: no such file or directory`;
+        }
+        return `${inputPath}: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    if (files.length === 0)
+        return `no .weave files found in ${inputPath}`;
+    return files.map(relPath => ({
+        inputFile: path.join(inputPath, relPath),
+        outputFile: path.join(outputPath, relPath.replace(/\.weave$/, '.ts')),
+    }));
+}
+/**
+ * `weave check`: compile the templates, type-check the whole tsconfig program
+ * with the compiled views added, and print every diagnostic — those in a
+ * compiled view at its .weave location. Progress goes to stderr and
+ * diagnostics to stdout. Returns the exit code: 1 if anything failed.
+ */
+export function check(options) {
+    const ts = loadTypeScript();
+    if (!ts) {
+        console.error('weave: check needs the "typescript" package — npm i -D typescript');
+        return 1;
+    }
+    const project = options.project ?? ts.findConfigFile(process.cwd(), ts.sys.fileExists);
+    if (!project) {
+        console.error('weave: no tsconfig.json found; pass one with --project');
+        return 1;
+    }
+    if (!ts.sys.fileExists(project)) {
+        console.error(`weave: ${project}: no such file`);
+        return 1;
+    }
+    const pairs = compilePairs(options.inputPath, options.outputPath);
+    if (typeof pairs === 'string') {
+        console.error(`weave: ${pairs}`);
+        return 1;
+    }
+    const log = (msg) => console.error(msg);
+    const { written, failed } = compileFiles(pairs, true, log);
+    if (!options.inputPath.endsWith('.weave'))
+        pruneOrphans(options.inputPath, options.outputPath, log);
+    const config = ts.readConfigFile(project, ts.sys.readFile);
+    const parsed = config.error
+        ? undefined
+        : ts.parseJsonConfigFileContent(config.config, ts.sys, path.dirname(path.resolve(project)), { noEmit: true }, project);
+    const rootNames = new Set((parsed?.fileNames ?? []).map(f => path.resolve(f)));
+    for (const file of written)
+        rootNames.add(path.resolve(file));
+    const diagnostics = config.error
+        ? [config.error]
+        : parsed.errors.filter(d => d.code !== NO_INPUTS);
+    if (!config.error) {
+        const program = ts.createProgram([...rootNames], parsed.options);
+        diagnostics.push(...ts.getPreEmitDiagnostics(program));
+    }
+    const errorFiles = new Set(failed.map(f => path.resolve(f)));
+    let errors = failed.length;
+    for (const d of diagnostics) {
+        const isError = d.category === ts.DiagnosticCategory.Error;
+        const message = (isError ? '' : 'warning: ')
+            + ts.flattenDiagnosticMessageText(d.messageText, '\n') + ` TS${d.code}`;
+        if (!d.file || d.start === undefined) {
+            console.log(`weave: ${message}`);
+            if (isError)
+                errors++;
+            continue;
+        }
+        const { line, character } = d.file.getLineAndCharacterOfPosition(d.start);
+        const diag = { file: d.file.fileName, line: line + 1, col: character + 1, message };
+        const mapped = mapDiagnostic(diag) ?? diag;
+        const source = mapped === diag ? d.file.text : readSource(mapped.file);
+        console.log(formatDiagnostic({ ...mapped, file: displayPath(mapped.file) }, source));
+        if (isError) {
+            errors++;
+            errorFiles.add(path.resolve(mapped.file));
+        }
+    }
+    if (errors === 0)
+        return 0;
+    const noun = errors === 1 ? 'error' : 'errors';
+    const where = errorFiles.size > 1 ? ` in ${errorFiles.size} files` : '';
+    console.log(`\nFound ${errors} ${noun}${where}.`);
+    return 1;
+}
+//# sourceMappingURL=check.js.map

package/dist/cli/index.d.ts

@@ -1,3 +1,6 @@
+import type { IncludeResolver } from '../codegen/index.js';
+import { formatCodeFrame } from '../diagnostics/index.js';
+import { check } from './check.js';
 interface CompileArgs {
     mode: 'compile';
     inputPath: string;
@@ -10,24 +13,59 @@ interface WatchArgs {
     outputPath: string;
     sourcemap: boolean;
 }
+interface CheckArgs {
+    mode: 'check';
+    inputPath: string;
+    outputPath: string;
+    project?: string;
+}
 interface HelpArgs {
     mode: 'help';
 }
-type CliArgs = CompileArgs | WatchArgs | HelpArgs;
+type CliArgs = CompileArgs | WatchArgs | CheckArgs | HelpArgs;
 export declare class UsageError extends Error {
     constructor(message: string);
 }
 export declare function parseArgs(argv: string[]): CliArgs;
 export declare function usage(): string;
 export declare function discoverFiles(inputDir: string): string[];
-export declare function pruneOrphans(inputDir: string, outputDir: string): void;
+export declare function pruneOrphans(inputDir: string, outputDir: string, log?: (msg: string) => void): void;
 export declare function formatElapsed(ms: number): string;
-export declare function formatCodeFrame(source: string, line: number, col: number): string;
+export { formatCodeFrame, check };
 export declare function formatError(filePath: string, err: unknown, source?: string): string;
+/** Resolves `include` paths against the including file and reads their mixins. */
+export declare function includeResolver(inputFile: string): IncludeResolver;
+/**
+ * Absolute paths of the .weave files a template includes. A template that does
+ * not lex or parse includes nothing as far as the watcher is concerned — its
+ * own compile reports the error.
+ */
+export declare function includedFiles(inputFile: string, source: string): string[];
+/**
+ * Templates under inputDir (relative paths) that include relPath. An includer's
+ * import line is built from the mixins its includes define, so it must be
+ * recompiled when one of them changes. Includes do not re-export, so only
+ * direct includers are affected.
+ */
+export declare function findIncluders(inputDir: string, relPath: string): string[];
 export declare function compileFile(inputFile: string, outputFile: string, sourcemap?: boolean): void;
 export declare function compileDir(inputDir: string, outputDir: string, sourcemap?: boolean): boolean;
+/** Where single-file mode writes: <output> itself if it is a .ts, else a file inside it. */
+export declare function singleOutputFile(inputPath: string, outputPath: string): string;
+export interface CompilePair {
+    inputFile: string;
+    outputFile: string;
+}
+/**
+ * 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 declare function compileFiles(pairs: CompilePair[], sourcemap: boolean, log?: (msg: string) => void): {
+    written: string[];
+    failed: string[];
+};
 export declare function watchDir(inputDir: string, outputDir: string, sourcemap?: boolean): () => void;
 export declare function reconcile(inputDir: string, outputDir: string, sourcemap: boolean, pending: Map<string, ReturnType<typeof setTimeout>>): void;
 export declare function main(argv: string[]): void;
-export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/cli/index.js

@@ -1,9 +1,11 @@
-import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, existsSync, unlinkSync, rmdirSync, watch, } from 'node:fs';
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, statSync, existsSync, unlinkSync, rmdirSync, rmSync, watch, } from 'node:fs';
 import path from 'node:path';
-import { compile, compileWithSourceMap } from '../codegen/index.js';
-import { LexerError } from '../lexer/index.js';
-import { ParserError } from '../parser/index.js';
+import { compile, compileWithSourceMap, definedMixins } from '../codegen/index.js';
+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;
@@ -173,6 +211,69 @@ export function formatError(filePath, err, source) {
     }
     return result;
 }
+/** Resolves `include` paths against the including file and reads their mixins. */
+export function includeResolver(inputFile) {
+    return includePath => {
+        const file = path.resolve(path.dirname(inputFile), includePath + '.weave');
+        let source;
+        try {
+            source = readFileSync(file, 'utf-8');
+        }
+        catch (err) {
+            if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+                throw new Error(`${path.relative(process.cwd(), file)}: no such file`, { cause: err });
+            }
+            throw err;
+        }
+        return definedMixins(parse(lex(source)));
+    };
+}
+/**
+ * Absolute paths of the .weave files a template includes. A template that does
+ * not lex or parse includes nothing as far as the watcher is concerned — its
+ * own compile reports the error.
+ */
+export function includedFiles(inputFile, source) {
+    if (!/^include\s/m.test(source))
+        return [];
+    let doc;
+    try {
+        doc = parse(lex(source));
+    }
+    catch {
+        return [];
+    }
+    return doc.children.flatMap(c => c.type === 'Include' ? [path.resolve(path.dirname(inputFile), c.path + '.weave')] : []);
+}
+/**
+ * Templates under inputDir (relative paths) that include relPath. An includer's
+ * import line is built from the mixins its includes define, so it must be
+ * recompiled when one of them changes. Includes do not re-export, so only
+ * direct includers are affected.
+ */
+export function findIncluders(inputDir, relPath) {
+    const target = path.resolve(inputDir, relPath);
+    let files;
+    try {
+        files = discoverFiles(inputDir);
+    }
+    catch {
+        return [];
+    }
+    return files.filter(file => {
+        if (file === relPath)
+            return false;
+        const inFile = path.join(inputDir, file);
+        let source;
+        try {
+            source = readFileSync(inFile, 'utf-8');
+        }
+        catch {
+            return false;
+        }
+        return includedFiles(inFile, source).includes(target);
+    });
+}
 function writeCompiled(inputFile, outputFile, source, sourcemap) {
     const start = performance.now();
     if (sourcemap) {
@@ -181,15 +282,19 @@ function writeCompiled(inputFile, outputFile, source, sourcemap) {
         const { code, sourceMap } = compileWithSourceMap(source, {
             file: basename,
             sourceFile: sourceRelPath,
+            resolveInclude: includeResolver(inputFile),
         });
         mkdirSync(path.dirname(outputFile), { recursive: true });
         writeFileSync(outputFile, code + `//# sourceMappingURL=${basename}.map\n`);
         writeFileSync(outputFile + '.map', JSON.stringify(sourceMap));
     }
     else {
-        const result = compile(source);
+        const result = compile(source, { resolveInclude: includeResolver(inputFile) });
         mkdirSync(path.dirname(outputFile), { recursive: true });
         writeFileSync(outputFile, result);
+        // A map from an earlier sourcemap build no longer matches this .ts,
+        // and pruning keeps it because the .weave still exists.
+        rmSync(outputFile + '.map', { force: true });
     }
     return performance.now() - start;
 }
@@ -216,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;
@@ -259,6 +391,13 @@ export function watchDir(inputDir, outputDir, sourcemap = true) {
         pending.set(relPath, setTimeout(() => {
             pending.delete(relPath);
             compileWatchedFile(inputDir, outputDir, relPath, sourcemap);
+            // Compiled directly rather than scheduled, so an include cycle
+            // cannot keep re-triggering itself. One with its own pending
+            // timer will be compiled by that.
+            for (const includer of findIncluders(inputDir, relPath)) {
+                if (!pending.has(includer))
+                    compileWatchedFile(inputDir, outputDir, includer, sourcemap);
+            }
         }, 50));
     };
     const isDir = (relPath) => {
@@ -355,9 +494,9 @@ export function watchDir(inputDir, outputDir, sourcemap = true) {
     };
 }
 // Walk the input dir and recompile any .weave whose .ts output is missing or
-// older than the source. Files with a pending debounce timer are skipped so we
-// never race an edit the watcher is already handling — this only catches
-// changes whose fs.watch event was dropped.
+// older than the source or any file it includes. Files with a pending debounce
+// timer are skipped so we never race an edit the watcher is already handling —
+// this only catches changes whose fs.watch event was dropped.
 export function reconcile(inputDir, outputDir, sourcemap, pending) {
     let files;
     try {
@@ -386,9 +525,6 @@ export function reconcile(inputDir, outputDir, sourcemap, pending) {
         catch {
             outMtime = undefined;
         }
-        // Up to date — the watcher already handled this file.
-        if (outMtime !== undefined && outMtime >= sourceMtime)
-            continue;
         let source;
         try {
             source = readFileSync(inFile, 'utf-8');
@@ -396,6 +532,20 @@ export function reconcile(inputDir, outputDir, sourcemap, pending) {
         catch {
             continue;
         }
+        // The output also depends on the mixins each include defines, so an
+        // include edited since the last compile makes it stale too.
+        let newestMtime = sourceMtime;
+        for (const included of includedFiles(inFile, source)) {
+            try {
+                newestMtime = Math.max(newestMtime, statSync(included).mtimeMs);
+            }
+            catch {
+                // A missing include is reported when the template compiles.
+            }
+        }
+        // Up to date — the watcher already handled this file.
+        if (outMtime !== undefined && outMtime >= newestMtime)
+            continue;
         try {
             const elapsed = writeCompiled(inFile, outFile, source, sourcemap);
             console.log(`${outFile} (reconciled, ${formatElapsed(elapsed)})`);
@@ -444,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);
@@ -451,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);

package/dist/codegen/index.d.ts

@@ -5,22 +5,36 @@ export interface GenerateResult {
     code: string;
     mappings: Mapping[];
 }
+/**
+ * Lists the mixins defined by the `.weave` file an `include` path names.
+ * The path is exactly as written after `include`; throw if it cannot be read.
+ */
+export type IncludeResolver = (includePath: string) => string[];
+export interface GenerateOptions {
+    /**
+     * Without a resolver, a lone `include` is assumed to provide every called
+     * mixin not defined in this file, and more than one `include` is an error.
+     */
+    resolveInclude?: IncludeResolver;
+}
 export declare class CodegenError extends Error {
     readonly line: number;
     readonly col: number;
     constructor(message: string, line: number, col: number);
 }
+/** Names of the mixins a document defines at top level. */
+export declare function definedMixins(doc: DocumentNode): string[];
 /** Generate a TypeScript expression from a single AST node. */
 export declare function generateExpr(node: AstNode): string;
 /** Generate TypeScript source from a DocumentNode. */
-export declare function generate(doc: DocumentNode): GenerateResult;
+export declare function generate(doc: DocumentNode, options?: GenerateOptions): GenerateResult;
 /** Full pipeline: source string → TypeScript source. */
-export declare function compile(source: string): string;
+export declare function compile(source: string, options?: GenerateOptions): string;
 /** Full pipeline with source map generation. */
 export declare function compileWithSourceMap(source: string, opts: {
     file: string;
     sourceFile: string;
-}): {
+} & GenerateOptions): {
     code: string;
     sourceMap: SourceMap;
 };