@znight/cli 0.1.2 → 0.1.4

package/README.md

@@ -136,8 +136,9 @@ my-service/
 
 ## `znight generate`
 
-Runs the compiler and writes `src/.znight/container.generated.ts` when its content changed. Compiler
-diagnostics are printed with code frames; any error exits with code 1 (and nothing is written).
+Runs the compiler and writes `src/.znight/container.generated.ts` when its content changed, with the
+extra files compiler extensions emit next to it (an SDL schema...). Compiler diagnostics are printed
+with code frames; any error exits with code 1 (and nothing is written).
 
 ```sh
 znight generate            # ✓ Generated src/.znight/container.generated.ts (12 providers, 30 files, 48ms)
@@ -196,8 +197,9 @@ npx tsc --noEmit
 npx znight build
 ```
 
-`--check` names every generated file that is missing or out of date: the module and, in library
-mode (`library: true`), `dist/znight.providers.json`. A build that cleans `dist/` (tsdown, `tsc --build
+`--check` names every generated file that is missing or out of date: the module, the extra files of
+the compiler extensions (`extraFiles`) and, in library mode (`library: true`),
+`dist/znight.providers.json`. A build that cleans `dist/` (tsdown, `tsc --build
 --clean`...) deletes that manifest, which `package.json` points to: run `znight generate` after such a
 build (the Vite plugin writes it itself at the end of `vite build`).
 
@@ -457,16 +459,16 @@ and the schematics are exported too.
 The CLI drives the project's `@znight/compiler` through its programmatic API (spec §6.2) and only
 relies on these shapes (each is optional; missing pieces are emulated):
 
-| Export                                                           | Used for                                                                                                        |
-| ---------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
-| `generate(options)`                                              | `znight generate`; `written: string[]` tells whether the file changed                                           |
-| `generate({ ...options, check })`                                | `znight generate --check`; `stale: boolean`, `staleFiles: string[]` (else compared with `diskCode` / `library`) |
-| `createCompiler(options)`                                        | `znight generate --watch`: `generate(changes)` (`{ changed, added, removed }`), `isOutFile(file)`, `watchFiles` |
-| `includeRoots(compiler)`                                         | `--watch`: the directories to watch recursively (else the whole project)                                        |
-| `isRelevantChange(compiler, kind, file, watched, roots)`         | `--watch`: the file events that trigger a compile (else every event but the generated module)                   |
-| `compile(options)`                                               | fallback of the above (writes `diskCode`, else `code`)                                                          |
-| `formatDiagnostics(diagnostics, { color, cwd, summary: false })` | diagnostics output (a plain formatter otherwise)                                                                |
-| `loadZnightConfig(root)`                                         | `znight generate`: `{ file, options }` of `znight.config.*` / `ZNIGHT_CONFIG`                                   |
+| Export                                                           | Used for                                                                                                                       |
+| ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ |
+| `generate(options)`                                              | `znight generate`; `written: string[]` tells whether the file changed                                                          |
+| `generate({ ...options, check })`                                | `znight generate --check`; `stale: boolean`, `staleFiles: string[]` (else compared with `diskCode` / `extraFiles` / `library`) |
+| `createCompiler(options)`                                        | `znight generate --watch`: `generate(changes)` (`{ changed, added, removed }`), `isOutFile(file)`, `watchFiles`                |
+| `includeRoots(compiler)`                                         | `--watch`: the directories to watch recursively (else the whole project)                                                       |
+| `isRelevantChange(compiler, kind, file, watched, roots)`         | `--watch`: the file events that trigger a compile (else every event but the generated module)                                  |
+| `compile(options)`                                               | fallback of the above (writes `diskCode`, else `code`, and `extraFiles`)                                                       |
+| `formatDiagnostics(diagnostics, { color, cwd, summary: false })` | diagnostics output (a plain formatter otherwise)                                                                               |
+| `loadZnightConfig(root)`                                         | `znight generate`: `{ file, options }` of `znight.config.*` / `ZNIGHT_CONFIG`                                                  |
 
 `znight build` and `znight dev` use the `znight()` Vite plugin of the project's Vite config, found by
 its name (`znight`) among the plugins of the config:

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as main } from "./main-BWsiUsxN.mjs";
+import { n as main } from "./main-DUyElIVZ.mjs";
 // src/cli.ts
 /**
 * The `znight` binary. Everything lives in `main()`; this file only wires the process: arguments,

package/dist/index.d.mts

@@ -36,6 +36,12 @@ interface ZnightOptions {
   readonly aliases?: readonly StringAliasLike[] | undefined;
   readonly [option: string]: unknown;
 }
+/** A file emitted by a compiler extension next to the generated module (`CompileResult.extraFiles`, §6.2). */
+interface ExtraFileLike {
+  /** Absolute path. */
+  readonly file: string;
+  readonly content: string;
+}
 /** What the CLI reads from a compile result (`CompileResult`, §6.2). */
 interface CompileResultLike {
   /** Content of the generated module (with errors: a module throwing them, or empty). */
@@ -50,6 +56,8 @@ interface CompileResultLike {
   } | undefined;
   /** Files the result depends on (`createCompiler()` results). */
   readonly watchFiles?: readonly string[] | undefined;
+  /** Files emitted by compiler extensions (an SDL schema...), absent from compilers without them. */
+  readonly extraFiles?: readonly ExtraFileLike[] | undefined;
 }
 /** Result of {@link CompilerApi.generate}. */
 interface GenerateResultLike extends CompileResultLike {
@@ -61,9 +69,9 @@ interface CheckResultLike extends CompileResultLike {
   /** The generated files on disk are missing or differ from what would be generated. */
   readonly stale: boolean;
   /**
-   * The generated files that are missing or out of date (the module, and `znight.providers.json` in
-   * library mode). Empty when `stale` is `false`; empty or absent with `stale` when the compiler
-   * does not say which file is stale.
+   * The generated files that are missing or out of date (the module, the extra files of the
+   * extensions, and `znight.providers.json` in library mode). Empty when `stale` is `false`; empty or
+   * absent with `stale` when the compiler does not say which file is stale.
    */
   readonly staleFiles?: readonly string[] | undefined;
 }

package/dist/index.mjs

@@ -1 +1 @@
-export { d as AppSupervisor, t as COMMANDS, _ as CancelledError, v as CliError, s as DEFAULT_FEATURES, y as ExitCode, c as FEATURES, l as HTTP_ADAPTERS, u as PACKAGE_MANAGERS, r as SCHEMATICS, b as UsageError, m as adaptCompilerModule, p as cliVersion, f as createContext, g as defineCommand, i as findSchematic, h as loadCompiler, n as main, a as planSchematic, o as renderProject } from "./main-BWsiUsxN.mjs";
+export { d as AppSupervisor, t as COMMANDS, _ as CancelledError, v as CliError, s as DEFAULT_FEATURES, y as ExitCode, c as FEATURES, l as HTTP_ADAPTERS, u as PACKAGE_MANAGERS, r as SCHEMATICS, b as UsageError, m as adaptCompilerModule, p as cliVersion, f as createContext, g as defineCommand, i as findSchematic, h as loadCompiler, n as main, a as planSchematic, o as renderProject } from "./main-DUyElIVZ.mjs";

package/dist/{main-BWsiUsxN.mjs → main-DUyElIVZ.mjs}

@@ -408,7 +408,8 @@ function adaptCompilerModule(module) {
 			return written(await generate(options), before);
 		}
 		const result = await compileOnly(options);
-		const changed = !hasErrors(result.diagnostics) && writeIfChanged(result.outFile, result.diskCode ?? result.code);
+		let changed = false;
+		if (!hasErrors(result.diagnostics)) for (const output of outputsOf(result, false)) changed = writeIfChanged(output.file, output.content) || changed;
 		return {
 			...result,
 			written: changed
@@ -451,21 +452,34 @@ function adaptCompilerModule(module) {
 	};
 }
 /**
-* The generated files of a compile result that differ from the disk: the module, and
-* `znight.providers.json` in library mode. None with errors (nothing would be written).
+* The generated files of a compile result: the module, the extra files of the extensions and, with
+* `library`, `znight.providers.json` in library mode (`generate()` of the compiler writes the module
+* and the extra files; library mode is a compiler feature).
 */
-function staleOutputs(result) {
-	if (hasErrors(result.diagnostics)) return [];
+function outputsOf(result, library) {
 	const outputs = [{
 		file: result.outFile,
 		content: result.diskCode ?? result.code
 	}];
+	for (const extra of result.extraFiles ?? []) outputs.push({
+		file: extra.file,
+		content: extra.content
+	});
 	const { file, content } = result.library ?? {};
-	if (typeof file === "string" && typeof content === "string") outputs.push({
+	if (library && typeof file === "string" && typeof content === "string") outputs.push({
 		file,
 		content
 	});
-	return outputs.filter((output) => readText(output.file) !== output.content).map((output) => output.file);
+	return outputs;
+}
+/**
+* The generated files of a compile result that differ from the disk: the module, the extra files of
+* the extensions and `znight.providers.json` in library mode. None with errors (nothing would be
+* written).
+*/
+function staleOutputs(result) {
+	if (hasErrors(result.diagnostics)) return [];
+	return outputsOf(result, true).filter((output) => readText(output.file) !== output.content).map((output) => output.file);
 }
 /** Absolute path of the generated module for `options`. */
 function resolveOutFile(options) {
@@ -1979,6 +1993,15 @@ function staleFilesOf(result) {
 	}
 	return [...stale].sort((a, b) => Number(b === result.outFile) - Number(a === result.outFile));
 }
+/**
+* The hint of a missing generated file: the module, an extra file of the compiler extensions (an SDL
+* schema...) or the library manifest (`dist/znight.providers.json`).
+*/
+function missingHint(path, outFile, extraFiles) {
+	if (path === outFile) return "run \"znight generate\" (it is git-ignored: generate it before tsc and tests)";
+	if (extraFiles.has(path)) return "run \"znight generate\" (a compiler extension generates it from the sources)";
+	return "run \"znight generate\" after the build: a build cleaning dist/ (tsdown, tsc --build --clean...) deletes it";
+}
 async function check(cli, compiler, options) {
 	const root = options.root ?? cli.cwd;
 	const started = performance.now();
@@ -1990,11 +2013,11 @@ async function check(cli, compiler, options) {
 	}
 	const file = displayPath(result.outFile, cli.cwd);
 	const stale = staleFilesOf(result);
+	const extraFiles = new Set(result.extraFiles?.map((extra) => extra.file));
 	for (const path of stale) {
 		const shown = displayPath(path, cli.cwd);
-		const hint = path === result.outFile ? "run \"znight generate\" (it is git-ignored: generate it before tsc and tests)" : "run \"znight generate\" after the build: a build cleaning dist/ (tsdown, tsc --build --clean...) deletes it";
 		if (existsSync(path)) cli.reporter.error(`${shown} is out of date`, ["run \"znight generate\""]);
-		else cli.reporter.error(`${shown} is missing`, [hint]);
+		else cli.reporter.error(`${shown} is missing`, [missingHint(path, result.outFile, extraFiles)]);
 	}
 	if (stale.length > 0) return 1;
 	cli.reporter.success(`${cli.colors.bold(file)} is up to date ${cli.colors.dim(`(${statsOf(result, performance.now() - started)})`)}`);
@@ -3862,4 +3885,4 @@ function stackOf(error) {
 }
 export { CancelledError as _, planSchematic as a, UsageError as b, FEATURES as c, AppSupervisor as d, createContext as f, defineCommand as g, loadCompiler as h, findSchematic as i, HTTP_ADAPTERS as l, adaptCompilerModule as m, main as n, renderProject as o, cliVersion as p, SCHEMATICS as r, DEFAULT_FEATURES as s, COMMANDS as t, PACKAGE_MANAGERS as u, CliError as v, ExitCode as y };
 
-//# sourceMappingURL=main-BWsiUsxN.mjs.map
+//# sourceMappingURL=main-DUyElIVZ.mjs.map