@fuzdev/gro 0.192.0

package/dist/format_file.d.ts

@@ -0,0 +1,9 @@
+import prettier from 'prettier';
+/**
+ * Formats a file with Prettier.
+ * @param content
+ * @param options
+ * @param base_options - defaults to the the cwd's package.json `prettier` value
+ */
+export declare const format_file: (content: string, options: prettier.Options, base_options?: prettier.Options | null | undefined) => Promise<string>;
+//# sourceMappingURL=format_file.d.ts.map

package/dist/format_file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format_file.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/format_file.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,MAAM,UAAU,CAAC;AAOhC;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GACvB,SAAS,MAAM,EACf,SAAS,QAAQ,CAAC,OAAO,EACzB,eAAc,QAAQ,CAAC,OAAO,GAAG,IAAI,GAAG,SAA+B,KACrE,OAAO,CAAC,MAAM,CAgBhB,CAAC"}

package/dist/format_file.js

@@ -0,0 +1,42 @@
+import prettier from 'prettier';
+import { extname } from 'node:path';
+import { package_json_load } from "./package_json.js";
+let cached_base_options;
+/**
+ * Formats a file with Prettier.
+ * @param content
+ * @param options
+ * @param base_options - defaults to the the cwd's package.json `prettier` value
+ */
+export const format_file = async (content, options, base_options = cached_base_options) => {
+    const final_base_options = base_options !== undefined
+        ? base_options
+        : (cached_base_options = (await package_json_load()).prettier);
+    let final_options = options;
+    if (options.filepath && !options.parser) {
+        const { filepath, ...rest } = options;
+        const parser = infer_parser(filepath);
+        if (parser)
+            final_options = { ...rest, parser };
+    }
+    try {
+        return await prettier.format(content, { ...final_base_options, ...final_options });
+    }
+    catch (_err) {
+        return content;
+    }
+};
+// This is just a simple convenience for callers so they can pass a file path.
+// They can provide the Prettier `options.parser` for custom extensions.
+const infer_parser = (path) => {
+    const extension = extname(path).substring(1);
+    switch (extension) {
+        case 'svelte':
+        case 'xml': {
+            return extension;
+        }
+        default: {
+            return null;
+        }
+    }
+};

package/dist/gen.d.ts

@@ -0,0 +1,142 @@
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { Result } from '@fuzdev/fuz_util/result.js';
+import type { Timings } from '@fuzdev/fuz_util/timings.js';
+import type { PathId } from '@fuzdev/fuz_util/path.js';
+import type { GroConfig } from './gro_config.ts';
+import type { ParsedSvelteConfig } from './svelte_config.ts';
+import { type LoadModulesFailure, type ModuleMeta } from './modules.ts';
+import { InputPath, type ResolvedInputFile, type ResolvedInputPath } from './input_path.ts';
+import type { Filer } from './filer.ts';
+import type { InvokeTask } from './task.ts';
+export declare const GEN_FILE_PATTERN_TEXT = "gen";
+export declare const GEN_FILE_PATTERN: string;
+export declare const is_gen_path: (path: string) => boolean;
+export interface GenResult {
+    origin_id: PathId;
+    files: Array<GenFile>;
+}
+export interface GenFile {
+    id: PathId;
+    content: string;
+    origin_id: PathId;
+    format: boolean;
+}
+export type GenDependencies = 'all' | GenDependenciesConfig | GenDependenciesResolver;
+export interface GenDependenciesConfig {
+    patterns?: Array<RegExp>;
+    files?: Array<PathId>;
+}
+export type GenDependenciesResolver = (ctx: GenContext) => GenDependenciesConfig | 'all' | null | Promise<GenDependenciesConfig | 'all' | null>;
+export type Gen = GenFunction | GenConfig;
+export type GenFunction = (ctx: GenContext) => RawGenResult | Promise<RawGenResult>;
+export interface GenConfig {
+    generate: GenFunction;
+    dependencies?: GenDependencies;
+}
+export interface GenContext {
+    config: GroConfig;
+    svelte_config: ParsedSvelteConfig;
+    filer: Filer;
+    log: Logger;
+    timings: Timings;
+    invoke_task: InvokeTask;
+    /**
+     * Same as `import.meta.url` but in path form.
+     */
+    origin_id: PathId;
+    /**
+     * The `origin_id` relative to the root dir.
+     */
+    origin_path: string;
+    /**
+     * The file that triggered dependency checking.
+     * Only available when resolving dependencies dynamically.
+     * `undefined` during actual generation.
+     */
+    changed_file_id: PathId | undefined;
+}
+export type RawGenResult = string | RawGenFile | null | Array<RawGenResult>;
+export interface RawGenFile {
+    content: string;
+    filename?: string;
+    format?: boolean;
+}
+export interface GenResults {
+    results: Array<GenfileModuleResult>;
+    successes: Array<GenfileModuleResultSuccess>;
+    failures: Array<GenfileModuleResultFailure>;
+    input_count: number;
+    output_count: number;
+    elapsed: number;
+}
+export type GenfileModuleResult = GenfileModuleResultSuccess | GenfileModuleResultFailure;
+export interface GenfileModuleResultSuccess {
+    ok: true;
+    id: PathId;
+    files: Array<GenFile>;
+    elapsed: number;
+}
+export interface GenfileModuleResultFailure {
+    ok: false;
+    id: PathId;
+    reason: string;
+    error: Error;
+    elapsed: number;
+}
+export declare const to_gen_result: (origin_id: PathId, raw_result: RawGenResult) => GenResult;
+export declare const to_output_file_name: (filename: string) => string;
+export type AnalyzedGenResult = {
+    file: GenFile;
+    existing_content: string;
+    is_new: false;
+    has_changed: boolean;
+} | {
+    file: GenFile;
+    existing_content: null;
+    is_new: true;
+    has_changed: true;
+};
+export declare const analyze_gen_results: (gen_results: GenResults) => Promise<Array<AnalyzedGenResult>>;
+export declare const analyze_gen_result: (file: GenFile) => Promise<AnalyzedGenResult>;
+export declare const write_gen_results: (gen_results: GenResults, analyzed_gen_results: Array<AnalyzedGenResult>, log: Logger) => Promise<void>;
+export interface FoundGenfiles {
+    resolved_input_files: Array<ResolvedInputFile>;
+    resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+    resolved_input_paths: Array<ResolvedInputPath>;
+}
+export type FindGenfilesResult = Result<{
+    value: FoundGenfiles;
+}, FindGenfilesFailure>;
+export type FindGenfilesFailure = {
+    type: 'unmapped_input_paths';
+    unmapped_input_paths: Array<InputPath>;
+    resolved_input_paths: Array<ResolvedInputPath>;
+    reasons: Array<string>;
+} | {
+    type: 'input_directories_with_no_files';
+    input_directories_with_no_files: Array<InputPath>;
+    resolved_input_files: Array<ResolvedInputFile>;
+    resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+    resolved_input_paths: Array<ResolvedInputPath>;
+    reasons: Array<string>;
+};
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export declare const find_genfiles: (input_paths: Array<InputPath>, root_dirs: Array<PathId>, config: GroConfig, timings?: Timings) => Promise<FindGenfilesResult>;
+export interface GenfileModule {
+    gen: Gen;
+}
+export type GenfileModuleMeta = ModuleMeta<GenfileModule>;
+export interface LoadedGenfiles {
+    modules: Array<GenfileModuleMeta>;
+    found_genfiles: FoundGenfiles;
+}
+export type LoadGenfilesResult = Result<{
+    value: LoadedGenfiles;
+}, LoadGenfilesFailure>;
+export type LoadGenfilesFailure = LoadModulesFailure<GenfileModuleMeta>;
+export declare const load_genfiles: (found_genfiles: FoundGenfiles, timings?: Timings) => Promise<LoadGenfilesResult>;
+export declare const validate_gen_module: (mod: Record<string, any>) => mod is GenfileModule;
+export declare const normalize_gen_config: (gen: Gen) => GenConfig;
+//# sourceMappingURL=gen.d.ts.map

package/dist/gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gen.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAGpD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,4BAA4B,CAAC;AACvD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAKrD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAe,KAAK,kBAAkB,EAAE,KAAK,UAAU,EAAC,MAAM,cAAc,CAAC;AACpF,OAAO,EACN,SAAS,EAGT,KAAK,iBAAiB,EACtB,KAAK,iBAAiB,EACtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AAE1C,eAAO,MAAM,qBAAqB,QAAQ,CAAC;AAC3C,eAAO,MAAM,gBAAgB,QAAoC,CAAC;AAElE,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,OAA0C,CAAC;AAEtF,MAAM,WAAW,SAAS;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;CACtB;AACD,MAAM,WAAW,OAAO;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,qBAAqB,GAAG,uBAAuB,CAAC;AAEtF,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB,KAAK,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACtB;AAED,MAAM,MAAM,uBAAuB,GAAG,CACrC,GAAG,EAAE,UAAU,KACX,qBAAqB,GAAG,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,qBAAqB,GAAG,KAAK,GAAG,IAAI,CAAC,CAAC;AAE1F,MAAM,MAAM,GAAG,GAAG,WAAW,GAAG,SAAS,CAAC;AAE1C,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,EAAE,UAAU,KAAK,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;AAGpF,MAAM,WAAW,SAAS;IACzB,QAAQ,EAAE,WAAW,CAAC;IACtB,YAAY,CAAC,EAAE,eAAe,CAAC;CAG/B;AAED,MAAM,WAAW,UAAU;IAC1B,MAAM,EAAE,SAAS,CAAC;IAClB,aAAa,EAAE,kBAAkB,CAAC;IAClC,KAAK,EAAE,KAAK,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAGD,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI,GAAG,KAAK,CAAC,YAAY,CAAC,CAAC;AAC5E,MAAM,WAAW,UAAU;IAC1B,OAAO,EAAE,MAAM,CAAC;IAGhB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,UAAU;IAC1B,OAAO,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACpC,SAAS,EAAE,KAAK,CAAC,0BAA0B,CAAC,CAAC;IAC7C,QAAQ,EAAE,KAAK,CAAC,0BAA0B,CAAC,CAAC;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CAChB;AACD,MAAM,MAAM,mBAAmB,GAAG,0BAA0B,GAAG,0BAA0B,CAAC;AAC1F,MAAM,WAAW,0BAA0B;IAC1C,EAAE,EAAE,IAAI,CAAC;IACT,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;CAChB;AACD,MAAM,WAAW,0BAA0B;IAC1C,EAAE,EAAE,KAAK,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,aAAa,GAAI,WAAW,MAAM,EAAE,YAAY,YAAY,KAAG,SAK3E,CAAC;AAmCF,eAAO,MAAM,mBAAmB,GAAI,UAAU,MAAM,KAAG,MA2BtD,CAAC;AAYF,MAAM,MAAM,iBAAiB,GAC1B;IACA,IAAI,EAAE,OAAO,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,MAAM,EAAE,KAAK,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;CACpB,GACD;IACA,IAAI,EAAE,OAAO,CAAC;IACd,gBAAgB,EAAE,IAAI,CAAC;IACvB,MAAM,EAAE,IAAI,CAAC;IACb,WAAW,EAAE,IAAI,CAAC;CACjB,CAAC;AAEL,eAAO,MAAM,mBAAmB,GAC/B,aAAa,UAAU,KACrB,OAAO,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAGlC,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,MAAM,OAAO,KAAG,OAAO,CAAC,iBAAiB,CAqBjF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC7B,aAAa,UAAU,EACvB,sBAAsB,KAAK,CAAC,iBAAiB,CAAC,EAC9C,KAAK,MAAM,KACT,OAAO,CAAC,IAAI,CAqBd,CAAC;AAEF,MAAM,WAAW,aAAa;IAC7B,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC/C,gCAAgC,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACxE,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;CAC/C;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC;IAAC,KAAK,EAAE,aAAa,CAAA;CAAC,EAAE,mBAAmB,CAAC,CAAC;AACrF,MAAM,MAAM,mBAAmB,GAC5B;IACA,IAAI,EAAE,sBAAsB,CAAC;IAC7B,oBAAoB,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IACvC,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC/C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACtB,GACD;IACA,IAAI,EAAE,iCAAiC,CAAC;IACxC,+BAA+B,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IAClD,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC/C,gCAAgC,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACxE,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC/C,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACtB,CAAC;AAEL;;GAEG;AACH,eAAO,MAAM,aAAa,GACzB,aAAa,KAAK,CAAC,SAAS,CAAC,EAC7B,WAAW,KAAK,CAAC,MAAM,CAAC,EACxB,QAAQ,SAAS,EACjB,UAAU,OAAO,KACf,OAAO,CAAC,kBAAkB,CA6D5B,CAAC;AAEF,MAAM,WAAW,aAAa;IAC7B,GAAG,EAAE,GAAG,CAAC;CACT;AAED,MAAM,MAAM,iBAAiB,GAAG,UAAU,CAAC,aAAa,CAAC,CAAC;AAE1D,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAClC,cAAc,EAAE,aAAa,CAAC;CAC9B;AAED,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC;IAAC,KAAK,EAAE,cAAc,CAAA;CAAC,EAAE,mBAAmB,CAAC,CAAC;AACtF,MAAM,MAAM,mBAAmB,GAAG,kBAAkB,CAAC,iBAAiB,CAAC,CAAC;AAExE,eAAO,MAAM,aAAa,GACzB,gBAAgB,aAAa,EAC7B,UAAU,OAAO,KACf,OAAO,CAAC,kBAAkB,CAc5B,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,KAAK,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,KAAG,GAAG,IAAI,aAMrE,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,KAAK,GAAG,KAAG,SACE,CAAC"}

package/dist/gen.js

@@ -0,0 +1,199 @@
+import { join, basename, dirname, isAbsolute } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { styleText as st } from 'node:util';
+import { each_concurrent, map_concurrent } from '@fuzdev/fuz_util/async.js';
+import { fs_search } from '@fuzdev/fuz_util/fs.js';
+import { print_path } from "./paths.js";
+import { load_modules } from "./modules.js";
+import { InputPath, resolve_input_files, resolve_input_paths, } from "./input_path.js";
+export const GEN_FILE_PATTERN_TEXT = 'gen';
+export const GEN_FILE_PATTERN = '.' + GEN_FILE_PATTERN_TEXT + '.';
+export const is_gen_path = (path) => path.includes(GEN_FILE_PATTERN);
+export const to_gen_result = (origin_id, raw_result) => {
+    return {
+        origin_id,
+        files: to_gen_files(origin_id, raw_result),
+    };
+};
+const to_gen_files = (origin_id, raw_result) => {
+    if (raw_result === null) {
+        return [];
+    }
+    else if (typeof raw_result === 'string') {
+        return [to_gen_file(origin_id, { content: raw_result })];
+    }
+    else if (Array.isArray(raw_result)) {
+        const files = raw_result.flatMap((f) => to_gen_files(origin_id, f));
+        validate_gen_files(files);
+        return files;
+    }
+    return [to_gen_file(origin_id, raw_result)];
+};
+const to_gen_file = (origin_id, raw_gen_file) => {
+    const { content, filename, format = true } = raw_gen_file;
+    const id = to_output_file_id(origin_id, filename);
+    return { id, content, origin_id, format };
+};
+const to_output_file_id = (origin_id, raw_file_name) => {
+    if (raw_file_name === '') {
+        throw Error(`Output file name cannot be an empty string`);
+    }
+    const filename = raw_file_name ?? to_output_file_name(basename(origin_id));
+    if (isAbsolute(filename))
+        return filename;
+    const dir = dirname(origin_id);
+    const output_file_id = join(dir, filename);
+    if (output_file_id === origin_id) {
+        throw Error('Gen origin and output file ids cannot be the same');
+    }
+    return output_file_id;
+};
+export const to_output_file_name = (filename) => {
+    const parts = filename.split('.');
+    const gen_pattern_index = parts.indexOf(GEN_FILE_PATTERN_TEXT);
+    if (gen_pattern_index === -1) {
+        throw Error(`Invalid gen file name - '${GEN_FILE_PATTERN_TEXT}' not found in '${filename}'`);
+    }
+    if (gen_pattern_index !== parts.lastIndexOf(GEN_FILE_PATTERN_TEXT)) {
+        throw Error(`Invalid gen file name - multiple instances of '${GEN_FILE_PATTERN_TEXT}' found in '${filename}'`);
+    }
+    if (gen_pattern_index < parts.length - 3) {
+        // This check is technically unneccessary,
+        // but ensures a consistent file naming convention.
+        throw Error(`Invalid gen file name - only one additional extension is allowed to follow '${GEN_FILE_PATTERN}' in '${filename}'`);
+    }
+    const final_parts = [];
+    const has_different_ext = gen_pattern_index === parts.length - 3;
+    const length = has_different_ext ? parts.length - 1 : parts.length;
+    for (let i = 0; i < length; i++) {
+        if (i === gen_pattern_index)
+            continue; // skip the `.gen.` pattern
+        if (i === length - 1 && parts[i] === '')
+            continue; // allow empty extension
+        final_parts.push(parts[i]);
+    }
+    return final_parts.join('.');
+};
+const validate_gen_files = (files) => {
+    const ids = new Set();
+    for (const file of files) {
+        if (ids.has(file.id)) {
+            throw Error(`Duplicate gen file id: ${file.id}`);
+        }
+        ids.add(file.id);
+    }
+};
+export const analyze_gen_results = async (gen_results) => {
+    const files = gen_results.successes.flatMap((result) => result.files);
+    return map_concurrent(files, (file) => analyze_gen_result(file), 10);
+};
+export const analyze_gen_result = async (file) => {
+    let existing_content;
+    try {
+        existing_content = await readFile(file.id, 'utf8');
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return {
+                file,
+                existing_content: null,
+                is_new: true,
+                has_changed: true,
+            };
+        }
+        throw error;
+    }
+    return {
+        file,
+        existing_content,
+        is_new: false,
+        has_changed: file.content !== existing_content,
+    };
+};
+export const write_gen_results = async (gen_results, analyzed_gen_results, log) => {
+    const files = gen_results.successes.flatMap((result) => result.files);
+    await each_concurrent(files, async (file) => {
+        const analyzed = analyzed_gen_results.find((r) => r.file.id === file.id);
+        if (!analyzed)
+            throw Error('Expected to find analyzed result: ' + file.id);
+        const log_args = [print_path(file.id), 'generated from', print_path(file.origin_id)];
+        if (analyzed.is_new) {
+            log.info('writing new', ...log_args);
+            await mkdir(dirname(file.id), { recursive: true });
+            await writeFile(file.id, file.content);
+        }
+        else if (analyzed.has_changed) {
+            log.info('writing changed', ...log_args);
+            await writeFile(file.id, file.content);
+        }
+        else {
+            log.info('skipping unchanged', ...log_args);
+        }
+    }, 10);
+};
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export const find_genfiles = async (input_paths, root_dirs, config, timings) => {
+    const extensions = [GEN_FILE_PATTERN];
+    // Check which extension variation works - if it's a directory, prefer others first!
+    const timing_to_resolve_input_paths = timings?.start('resolve input paths');
+    const { resolved_input_paths, unmapped_input_paths } = await resolve_input_paths(input_paths, root_dirs, extensions);
+    timing_to_resolve_input_paths?.();
+    // Error if any input path could not be mapped.
+    if (unmapped_input_paths.length) {
+        return {
+            ok: false,
+            type: 'unmapped_input_paths',
+            unmapped_input_paths,
+            resolved_input_paths,
+            reasons: unmapped_input_paths.map((input_path) => st('red', `Input path ${print_path(input_path)} cannot be mapped to a file or directory.`)),
+        };
+    }
+    // Find all of the files for any directories.
+    const timing_to_fs_search = timings?.start('find files');
+    const { resolved_input_files, resolved_input_files_by_root_dir, input_directories_with_no_files } = await resolve_input_files(resolved_input_paths, async (id) => await fs_search(id, {
+        filter: config.search_filters,
+        file_filter: (p) => extensions.some((e) => p.includes(e)),
+    }));
+    timing_to_fs_search?.();
+    // Error if any input path has no files. (means we have an empty directory)
+    if (input_directories_with_no_files.length) {
+        return {
+            ok: false,
+            type: 'input_directories_with_no_files',
+            input_directories_with_no_files,
+            resolved_input_files,
+            resolved_input_files_by_root_dir,
+            resolved_input_paths,
+            reasons: input_directories_with_no_files.map((input_path) => st('red', `Input directory contains no matching files: ${print_path(input_path)}`)),
+        };
+    }
+    return {
+        ok: true,
+        value: {
+            resolved_input_files,
+            resolved_input_files_by_root_dir,
+            resolved_input_paths,
+        },
+    };
+};
+export const load_genfiles = async (found_genfiles, timings) => {
+    const loaded_modules = await load_modules(found_genfiles.resolved_input_files, validate_gen_module, (resolved_input_file, mod) => ({ id: resolved_input_file.id, mod }), timings);
+    if (!loaded_modules.ok) {
+        return loaded_modules;
+    }
+    return {
+        ok: true,
+        value: { modules: loaded_modules.modules, found_genfiles },
+    };
+};
+export const validate_gen_module = (mod) => {
+    if (typeof mod.gen === 'function')
+        return true;
+    if (typeof mod.gen === 'object' && mod.gen !== null && typeof mod.gen.generate === 'function') {
+        return true;
+    }
+    return false;
+};
+export const normalize_gen_config = (gen) => typeof gen === 'function' ? { generate: gen } : gen;

package/dist/gen.task.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    _: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    root_dirs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    check: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=gen.task.d.ts.map

package/dist/gen.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gen.task.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAgB/C,cAAc;AACd,eAAO,MAAM,IAAI;;;;kBAUf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CAqG3B,CAAC"}

package/dist/gen.task.js

@@ -0,0 +1,149 @@
+import { styleText as st } from 'node:util';
+import { print_ms, print_error } from '@fuzdev/fuz_util/print.js';
+import { plural } from '@fuzdev/fuz_util/string.js';
+import { z } from 'zod';
+import { TaskError } from "./task.js";
+import { run_gen } from "./run_gen.js";
+import { RawInputPath, to_input_paths } from "./input_path.js";
+import { format_file } from "./format_file.js";
+import { print_path } from "./paths.js";
+import { log_error_reasons } from "./task_logging.js";
+import { write_gen_results, analyze_gen_results, find_genfiles, load_genfiles, } from "./gen.js";
+import { SOURCE_DIRNAME } from "./constants.js";
+/** @nodocs */
+export const Args = z.strictObject({
+    _: z.array(RawInputPath).meta({ description: 'input paths to generate' }).default([SOURCE_DIRNAME]),
+    root_dirs: z
+        .array(z.string())
+        .meta({ description: 'root directories to resolve input paths against' }) // TODO `PathId` schema
+        .default([process.cwd()]),
+    check: z
+        .boolean()
+        .meta({ description: 'exit with a nonzero code if any files need to be generated' })
+        .default(false),
+});
+/** @nodocs */
+export const task = {
+    summary: 'run code generation scripts',
+    Args,
+    run: async ({ args, filer, log, timings, config, invoke_task }) => {
+        const { _: raw_input_paths, root_dirs, check } = args;
+        const input_paths = to_input_paths(raw_input_paths);
+        // load all of the gen modules
+        const found = await find_genfiles(input_paths, root_dirs, config, timings);
+        if (!found.ok) {
+            if (found.type === 'input_directories_with_no_files') {
+                // TODO maybe let this error like the normal case, but only call `gro gen` if we find gen files? problem is the args would need to be hoisted to callers like `gro sync`
+                log.info('no gen modules found in ' + input_paths.join(', '));
+                return;
+            }
+            else {
+                log_error_reasons(log, found.reasons);
+                throw new TaskError('Failed to find gen modules.');
+            }
+        }
+        const found_genfiles = found.value;
+        log.info('gen files', found_genfiles.resolved_input_files.map((f) => f.id));
+        const loaded = await load_genfiles(found_genfiles, timings);
+        if (!loaded.ok) {
+            log_error_reasons(log, loaded.reasons);
+            throw new TaskError('Failed to load gen modules.');
+        }
+        const loaded_genfiles = loaded.value;
+        // run `gen` on each of the modules
+        const timing_to_generate_code = timings.start('generate code'); // TODO this ignores `gen_results.elapsed` - should it return `Timings` instead?
+        const gen_results = await run_gen(loaded_genfiles.modules, config, filer, log, timings, invoke_task, format_file);
+        timing_to_generate_code();
+        const fail_count = gen_results.failures.length;
+        const analyzed_gen_results = await analyze_gen_results(gen_results);
+        if (check) {
+            // check if any files changed, and if so, throw errors,
+            // but if there are gen failures, skip the check and defer to their errors
+            if (!fail_count) {
+                log.info('checking generated files for changes');
+                const timing_to_check_results = timings.start('check results for changes');
+                timing_to_check_results();
+                let has_unexpected_changes = false;
+                for (const analyzed of analyzed_gen_results) {
+                    if (!analyzed.has_changed)
+                        continue;
+                    has_unexpected_changes = true;
+                    log.error(st('red', `Generated file ${print_path(analyzed.file.id)} via ${print_path(analyzed.file.origin_id)} ${analyzed.is_new ? 'is new' : 'has changed'}.`));
+                }
+                if (has_unexpected_changes) {
+                    throw new TaskError('Failed gen check. Some generated files have unexpectedly changed.' +
+                        ' Run `gro gen` and try again.');
+                }
+                log.info('check passed, no files have changed');
+            }
+        }
+        else {
+            const timing_to_output_results = timings.start('output results');
+            await write_gen_results(gen_results, analyzed_gen_results, log);
+            timing_to_output_results();
+        }
+        // collect and format output with summary
+        const output_lines = collect_output_lines(gen_results, analyzed_gen_results);
+        const new_count = analyzed_gen_results.filter((r) => r.is_new).length;
+        const changed_count = analyzed_gen_results.filter((r) => r.has_changed && !r.is_new).length;
+        const unchanged_count = analyzed_gen_results.filter((r) => !r.is_new && !r.has_changed).length;
+        const error_count = gen_results.failures.length;
+        log.info(format_gen_output(output_lines) +
+            `\n\n\t${new_count} ${st(new_count > 0 ? 'green' : 'gray', 'new')}, ${changed_count} ${st(changed_count > 0 ? 'cyan' : 'gray', 'changed')}, ${unchanged_count} ${st('gray', 'unchanged')}${error_count ? `, ${error_count} ${st('red', 'error' + plural(error_count))}` : ''} from ${gen_results.input_count} input file${plural(gen_results.input_count)}`);
+        if (fail_count) {
+            for (const result of gen_results.failures) {
+                log.error(result.reason, '\n', print_error(result.error));
+            }
+            throw new TaskError(`Failed to generate ${fail_count} file${plural(fail_count)}.`);
+        }
+    },
+};
+const format_gen_status = (analyzed) => {
+    if (!analyzed)
+        return { symbol: '?', color: 'gray', text: 'unknown' };
+    if (analyzed.is_new)
+        return { symbol: '●', color: 'green', text: 'new' };
+    if (analyzed.has_changed)
+        return { symbol: '◐', color: 'cyan', text: 'changed' };
+    return { symbol: '○', color: 'gray', text: 'unchanged' };
+};
+const collect_output_lines = (gen_results, analyzed_gen_results) => {
+    const output_lines = [];
+    for (const result of gen_results.results) {
+        if (result.ok) {
+            for (const file of result.files) {
+                const analyzed = analyzed_gen_results.find((a) => a.file.id === file.id);
+                output_lines.push({
+                    status: format_gen_status(analyzed),
+                    elapsed: print_ms(result.elapsed),
+                    source: print_path(result.id),
+                    target: print_path(file.id),
+                    is_error: false,
+                });
+            }
+        }
+        else {
+            output_lines.push({
+                status: { symbol: '🞩', color: 'red', text: 'error' },
+                elapsed: print_ms(result.elapsed),
+                source: print_path(result.id),
+                target: st('red', result.error.stack || result.error.message || 'error'),
+                is_error: true,
+            });
+        }
+    }
+    return output_lines;
+};
+const format_gen_output = (output_lines) => {
+    // calculate column widths for alignment
+    const max_elapsed_length = Math.max(...output_lines.map((l) => l.elapsed.length));
+    const max_source_length = Math.max(...output_lines.map((l) => l.source.length));
+    // format the output lines
+    let log_result = 'gen results:';
+    for (const line of output_lines) {
+        const elapsed_text = line.elapsed.padStart(max_elapsed_length);
+        const source_text = line.source.padEnd(max_source_length);
+        log_result += `\n\t${st(line.status.color, line.status.symbol)}  ${elapsed_text}  ${source_text} → ${line.target}`;
+    }
+    return log_result;
+};

package/dist/gen_helpers.d.ts

@@ -0,0 +1,11 @@
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { Timings } from '@fuzdev/fuz_util/timings.js';
+import type { PathId } from '@fuzdev/fuz_util/path.js';
+import type { GroConfig } from './gro_config.ts';
+import { type Filer } from './filer.ts';
+import type { InvokeTask } from './task.ts';
+/**
+ * Check if a file change should trigger a gen file.
+ */
+export declare const should_trigger_gen: (gen_file_id: PathId, changed_file_id: PathId, config: GroConfig, filer: Filer, log: Logger, timings: Timings, invoke_task: InvokeTask) => Promise<boolean>;
+//# sourceMappingURL=gen_helpers.d.ts.map

package/dist/gen_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gen_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gen_helpers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AACzD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAErD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAoB,KAAK,KAAK,EAAC,MAAM,YAAY,CAAC;AACzD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AAY1C;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC9B,aAAa,MAAM,EACnB,iBAAiB,MAAM,EACvB,QAAQ,SAAS,EACjB,OAAO,KAAK,EACZ,KAAK,MAAM,EACX,SAAS,OAAO,EAChB,aAAa,UAAU,KACrB,OAAO,CAAC,OAAO,CAqCjB,CAAC"}

package/dist/gen_helpers.js

@@ -0,0 +1,76 @@
+import { resolve } from 'node:path';
+import { filter_dependents } from "./filer.js";
+import { normalize_gen_config, validate_gen_module, } from "./gen.js";
+import { default_svelte_config } from "./svelte_config.js";
+import { to_root_path } from "./paths.js";
+import { load_module } from "./modules.js";
+/**
+ * Check if a file change should trigger a gen file.
+ */
+export const should_trigger_gen = async (gen_file_id, changed_file_id, config, filer, log, timings, invoke_task) => {
+    // Always trigger if the gen file itself changed
+    const is_self_change = gen_file_id === changed_file_id;
+    if (is_self_change)
+        return true;
+    // Check if gen file depends on the changed file (directly or transitively)
+    const changed_disknode = filer.get_by_id(changed_file_id);
+    let should_bust_cache = false;
+    if (changed_disknode) {
+        const dependents = filter_dependents(changed_disknode, filer.get_by_id, (id) => id === gen_file_id);
+        should_bust_cache = dependents.has(gen_file_id);
+    }
+    // Resolve dependencies (with cache busting if the changed file is a dependency of the gen file)
+    const dependencies = await resolve_gen_dependencies(gen_file_id, changed_file_id, should_bust_cache, config, filer, log, timings, invoke_task);
+    if (!dependencies)
+        return false;
+    return (dependencies === 'all' ||
+        dependencies.patterns?.some((p) => p.test(changed_file_id)) ||
+        dependencies.files?.includes(changed_file_id) ||
+        false);
+};
+/**
+ * Resolve dependencies for a gen file.
+ * Uses cache-busting only when the gen file itself changes,
+ * otherwise relies on Node's module caching.
+ */
+const resolve_gen_dependencies = async (gen_file_id, changed_file_id, bust_cache, config, filer, log, timings, invoke_task) => {
+    const result = await load_module(gen_file_id, validate_gen_module, bust_cache);
+    if (!result.ok) {
+        if (result.type === 'failed_import') {
+            log.error(`Failed to import ${gen_file_id}:`, result.error);
+        }
+        return null;
+    }
+    const gen_config = normalize_gen_config(result.mod.gen);
+    if (!gen_config.dependencies) {
+        return null;
+    }
+    let dependencies = gen_config.dependencies;
+    if (typeof dependencies === 'function') {
+        const gen_ctx = {
+            config,
+            svelte_config: default_svelte_config,
+            filer,
+            log,
+            timings,
+            invoke_task,
+            origin_id: gen_file_id,
+            origin_path: to_root_path(gen_file_id),
+            changed_file_id,
+        };
+        dependencies = await dependencies(gen_ctx);
+    }
+    if (dependencies === null || dependencies === 'all') {
+        return dependencies;
+    }
+    // At this point, dependencies is either 'all' or GenDependenciesConfig
+    // For static dependencies, also normalize empty objects
+    if (!dependencies.patterns?.length && !dependencies.files?.length) {
+        return null;
+    }
+    // Normalize file paths to absolute paths
+    if (dependencies.files) {
+        dependencies.files = dependencies.files.map((f) => resolve(f));
+    }
+    return dependencies;
+};