@fuzdev/gro 0.192.0

package/dist/gro_plugin_server.d.ts

@@ -0,0 +1,80 @@
+import * as esbuild from 'esbuild';
+import type { Config as SvelteConfig } from '@sveltejs/kit';
+import type { Result } from '@fuzdev/fuz_util/result.js';
+import type { PathId } from '@fuzdev/fuz_util/path.js';
+import type { Plugin } from './plugin.ts';
+export declare const SERVER_SOURCE_ID: PathId;
+export declare const has_server: (path?: PathId) => Promise<Result<object, {
+    message: string;
+}>>;
+export interface GroPluginServerOptions {
+    /**
+     * same as esbuild's `entryPoints`
+     */
+    entry_points?: Array<string>;
+    /**
+     * @default cwd
+     */
+    dir?: string;
+    /**
+     * Returns the `Outpaths` given a `dev` param.
+     * Decoupling this from plugin creation allows it to be created generically,
+     * so the build and dev tasks can be the source of truth for `dev`.
+     */
+    outpaths?: CreateOutpaths;
+    /**
+     * @default ```SvelteKit's `.env`, `.env.development`, and `.env.production````
+     */
+    env_files?: Array<string>;
+    /**
+     * @default process.env
+     */
+    ambient_env?: Record<string, string>;
+    /**
+     * @default ```loaded from `${cwd}/${SVELTE_CONFIG_FILENAME}````
+     */
+    svelte_config?: SvelteConfig;
+    /**
+     * @default 'esnext'
+     */
+    target?: string;
+    /**
+     * Optionally map the esbuild options.
+     * @default identity
+     */
+    esbuild_build_options?: (base_options: esbuild.BuildOptions) => esbuild.BuildOptions;
+    /**
+     * Milliseconds to throttle rebuilds.
+     * Should be longer than it takes to build to avoid backpressure.
+     * @default 1000
+     */
+    rebuild_throttle_delay?: number;
+    /**
+     * The CLI command to run the server, like `'node'` or `'bun'` or `'deno'`.
+     * Receives the path to the server js file as its argument.
+     * @default 'node'
+     */
+    cli_command?: string;
+    /**
+     * Whether to run the server or not after building.
+     * @default dev
+     */
+    run?: boolean;
+}
+export interface Outpaths {
+    /**
+     * @default '.gro/dev' or 'dist_server'
+     */
+    outdir: string;
+    /**
+     * @default 'src/lib'
+     */
+    outbase: string;
+    /**
+     * @default 'server.js'
+     */
+    outname: string;
+}
+export type CreateOutpaths = (dev: boolean) => Outpaths;
+export declare const gro_plugin_server: ({ entry_points, dir, outpaths, env_files, ambient_env, svelte_config, target, esbuild_build_options, rebuild_throttle_delay, cli_command, run, }?: GroPluginServerOptions) => Plugin;
+//# sourceMappingURL=gro_plugin_server.d.ts.map

package/dist/gro_plugin_server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gro_plugin_server.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro_plugin_server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,EAAC,MAAM,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;AAI1D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,4BAA4B,CAAC;AAGvD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAErD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAcxC,eAAO,MAAM,gBAAgB,QAA0D,CAAC;AAExF,eAAO,MAAM,UAAU,GACtB,aAAuB,KACrB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAK3C,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACtC;;OAEG;IACH,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC7B;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1B;;OAEG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC;;OAEG;IACH,aAAa,CAAC,EAAE,YAAY,CAAC;IAC7B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,CAAC,YAAY,EAAE,OAAO,CAAC,YAAY,KAAK,OAAO,CAAC,YAAY,CAAC;IACrF;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACd;AAED,MAAM,WAAW,QAAQ;IACxB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,QAAQ,CAAC;AAExD,eAAO,MAAM,iBAAiB,GAAI,mJAgB/B,sBAA2B,KAAG,MAsJhC,CAAC"}

package/dist/gro_plugin_server.js

@@ -0,0 +1,167 @@
+import { spawn_restartable_process } from '@fuzdev/fuz_util/process.js';
+import * as esbuild from 'esbuild';
+import { join, resolve } from 'node:path';
+import { identity } from '@fuzdev/fuz_util/function.js';
+import { strip_before, strip_end } from '@fuzdev/fuz_util/string.js';
+import { fs_exists } from '@fuzdev/fuz_util/fs.js';
+import { throttle } from '@fuzdev/fuz_util/throttle.js';
+import { base_path_to_path_id, LIB_DIRNAME, paths } from "./paths.js";
+import { GRO_DEV_DIRNAME, SERVER_DIST_PATH } from "./constants.js";
+import { parse_svelte_config, default_svelte_config } from "./svelte_config.js";
+import { esbuild_plugin_sveltekit_shim_app } from "./esbuild_plugin_sveltekit_shim_app.js";
+import { esbuild_plugin_sveltekit_shim_env } from "./esbuild_plugin_sveltekit_shim_env.js";
+import { print_build_result, to_define_import_meta_env } from "./esbuild_helpers.js";
+import { esbuild_plugin_sveltekit_shim_alias } from "./esbuild_plugin_sveltekit_shim_alias.js";
+import { esbuild_plugin_external_worker } from "./esbuild_plugin_external_worker.js";
+import { esbuild_plugin_sveltekit_local_imports } from "./esbuild_plugin_sveltekit_local_imports.js";
+import { esbuild_plugin_svelte } from "./esbuild_plugin_svelte.js";
+// TODO sourcemap as a hoisted option? disable for production by default - or like `outpaths`, passed a `dev` param
+export const SERVER_SOURCE_ID = base_path_to_path_id(LIB_DIRNAME + '/server/server.ts');
+export const has_server = async (path = SERVER_SOURCE_ID) => {
+    if (!(await fs_exists(path))) {
+        return { ok: false, message: `no server file found at ${path}` };
+    }
+    return { ok: true };
+};
+export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = process.cwd(), outpaths = (dev) => ({
+    outdir: join(dir, dev ? GRO_DEV_DIRNAME : SERVER_DIST_PATH),
+    outbase: paths.lib,
+    outname: 'server/server.js',
+}), env_files, ambient_env, svelte_config, target = 'esnext', esbuild_build_options = identity, rebuild_throttle_delay = 1000, cli_command, run, // `dev` default is not available in this scope
+ } = {}) => {
+    let build_ctx;
+    let cleanup_watch;
+    let server_process;
+    let deps;
+    return {
+        name: 'gro_plugin_server',
+        setup: async ({ dev, watch, timings, log, config, filer }) => {
+            const parsed_svelte_config = !svelte_config && strip_end(dir, '/') === process.cwd()
+                ? default_svelte_config
+                : await parse_svelte_config({
+                    dir_or_config: svelte_config ?? dir,
+                    config_filename: config.svelte_config_filename,
+                });
+            const { alias, base_url, assets_url, env_dir, private_prefix, public_prefix, svelte_compile_options, svelte_compile_module_options, svelte_preprocessors, } = parsed_svelte_config;
+            const { outbase, outdir, outname } = outpaths(dev);
+            const server_outpath = join(outdir, outname);
+            const timing_to_esbuild_create_context = timings.start('create build context');
+            const build_options = esbuild_build_options({
+                outdir,
+                outbase,
+                format: 'esm',
+                platform: 'node',
+                packages: 'external',
+                bundle: true,
+                target,
+                metafile: watch,
+            });
+            build_ctx = await esbuild.context({
+                entryPoints: entry_points.map((path) => resolve(dir, path)),
+                plugins: [
+                    esbuild_plugin_sveltekit_shim_app({ dev, base_url, assets_url }),
+                    esbuild_plugin_sveltekit_shim_env({
+                        dev,
+                        public_prefix,
+                        private_prefix,
+                        env_dir,
+                        env_files,
+                        ambient_env,
+                    }),
+                    esbuild_plugin_sveltekit_shim_alias({ dir, alias }),
+                    esbuild_plugin_external_worker({
+                        dev,
+                        build_options,
+                        dir,
+                        svelte_compile_options,
+                        svelte_compile_module_options,
+                        svelte_preprocessors,
+                        alias,
+                        base_url,
+                        public_prefix,
+                        private_prefix,
+                        env_dir,
+                        env_files,
+                        ambient_env,
+                        log,
+                    }),
+                    esbuild_plugin_svelte({
+                        dev,
+                        base_url,
+                        dir,
+                        svelte_compile_options,
+                        svelte_compile_module_options,
+                        svelte_preprocessors,
+                    }),
+                    esbuild_plugin_sveltekit_local_imports(),
+                ],
+                define: to_define_import_meta_env(dev, base_url),
+                ...build_options,
+            });
+            timing_to_esbuild_create_context();
+            const rebuild = throttle(async () => {
+                let build_result;
+                try {
+                    build_result = await build_ctx.rebuild();
+                }
+                catch (error) {
+                    log.error('[gro_plugin_server] build failed', error);
+                    return;
+                }
+                const { metafile } = build_result;
+                if (!metafile)
+                    return;
+                print_build_result(log, build_result);
+                deps = parse_deps(metafile.inputs, dir);
+                void server_process?.restart();
+            }, { delay: rebuild_throttle_delay });
+            await rebuild();
+            if (watch) {
+                cleanup_watch = await filer.watch((change) => {
+                    if (!deps?.has(change.path)) {
+                        return;
+                    }
+                    void rebuild();
+                });
+            }
+            if (!(await fs_exists(server_outpath))) {
+                throw Error(`Node server failed to start due to missing file: ${server_outpath}`);
+            }
+            if (run || dev) {
+                const cli_args = [];
+                if (dev) {
+                    cli_args.push('-C', 'development'); // same as `--conditions`
+                }
+                cli_args.push(server_outpath);
+                server_process = spawn_restartable_process(cli_command ?? config.js_cli, cli_args);
+            }
+        },
+        teardown: async () => {
+            if (cleanup_watch) {
+                cleanup_watch();
+                cleanup_watch = undefined;
+            }
+            if (server_process) {
+                const s = server_process; // avoid possible issue where a build is in progress, don't want to issue a restart, could be fixed upstream in `spawn_restartable_process`
+                server_process = undefined;
+                await s.kill();
+            }
+            if (build_ctx) {
+                await build_ctx.dispose();
+                build_ctx = undefined;
+            }
+        },
+    };
+};
+/**
+ * The esbuild metafile contains the paths in `entryPoints` relative to the `dir`
+ * even though we're resolving them to absolute paths before passing them to esbuild,
+ * so we resolve them here relative to the `dir`.
+ */
+const parse_deps = (metafile_inputs, dir) => {
+    const deps = new Set();
+    for (const key in metafile_inputs) {
+        deps.add(resolve(dir, strip_before(key, ':')));
+    }
+    return deps;
+};

package/dist/gro_plugin_sveltekit_app.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from './plugin.ts';
+export interface GroPluginSveltekitAppOptions {
+    /**
+     * The Vite CLI to use.
+     */
+    vite_cli?: string;
+}
+export declare const gro_plugin_sveltekit_app: ({ vite_cli, }?: GroPluginSveltekitAppOptions) => Plugin;
+//# sourceMappingURL=gro_plugin_sveltekit_app.d.ts.map

package/dist/gro_plugin_sveltekit_app.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gro_plugin_sveltekit_app.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro_plugin_sveltekit_app.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAGxC,MAAM,WAAW,4BAA4B;IAC5C;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,wBAAwB,GAAI,gBAEtC,4BAAiC,KAAG,MAuCtC,CAAC"}

package/dist/gro_plugin_sveltekit_app.js

@@ -0,0 +1,42 @@
+import { args_serialize } from '@fuzdev/fuz_util/args.js';
+import { spawn_result_to_message } from '@fuzdev/fuz_util/process.js';
+import { to_forwarded_args } from "./args.js";
+import { find_cli, spawn_cli, spawn_cli_process } from "./cli.js";
+import { VITE_CLI } from "./constants.js";
+import { TaskError } from "./task.js";
+export const gro_plugin_sveltekit_app = ({ vite_cli = VITE_CLI, } = {}) => {
+    let sveltekit_process = undefined;
+    return {
+        name: 'gro_plugin_sveltekit_app',
+        setup: async ({ dev, watch, log, config }) => {
+            const found_vite_cli = await find_cli(vite_cli);
+            if (!found_vite_cli)
+                throw Error(`Failed to find Vite CLI \`${vite_cli}\`, do you need to run \`${config.pm_cli} i\`?`);
+            if (dev) {
+                // `vite dev` in development mode
+                if (watch) {
+                    const serialized_args = ['dev', ...args_serialize(to_forwarded_args(vite_cli))];
+                    sveltekit_process = await spawn_cli_process(found_vite_cli, serialized_args, log);
+                }
+                else {
+                    log.debug(`the SvelteKit app plugin is loaded but will not output anything` +
+                        ' because `dev` is true and `watch` is false');
+                }
+            }
+            else {
+                // `vite build` in production mode
+                const serialized_args = ['build', ...args_serialize(to_forwarded_args(vite_cli))];
+                const spawned = await spawn_cli(found_vite_cli, serialized_args, log);
+                if (!spawned?.ok) {
+                    throw new TaskError(`${vite_cli} build failed: ${spawned ? spawn_result_to_message(spawned) : 'unknown error'}`);
+                }
+            }
+        },
+        teardown: async () => {
+            if (sveltekit_process) {
+                sveltekit_process.child.kill();
+                await sveltekit_process.closed;
+            }
+        },
+    };
+};

package/dist/gro_plugin_sveltekit_library.d.ts

@@ -0,0 +1,16 @@
+import type { Plugin } from './plugin.ts';
+import { type SveltePackageOptions } from './sveltekit_helpers.ts';
+export interface GroPluginSveltekitLibraryOptions {
+    /**
+     * The options passed to the SvelteKit packaging CLI.
+     * @see https://kit.svelte.dev/docs/packaging#options
+     */
+    svelte_package_options?: SveltePackageOptions;
+    /**
+     * The SvelteKit packaging CLI to use. Defaults to `svelte-package`.
+     * @see https://kit.svelte.dev/docs/packaging
+     */
+    svelte_package_cli?: string;
+}
+export declare const gro_plugin_sveltekit_library: ({ svelte_package_options, svelte_package_cli, }?: GroPluginSveltekitLibraryOptions) => Plugin;
+//# sourceMappingURL=gro_plugin_sveltekit_library.d.ts.map

package/dist/gro_plugin_sveltekit_library.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gro_plugin_sveltekit_library.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/gro_plugin_sveltekit_library.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAGxC,OAAO,EAAqB,KAAK,oBAAoB,EAAC,MAAM,wBAAwB,CAAC;AAGrF,MAAM,WAAW,gCAAgC;IAChD;;;OAGG;IACH,sBAAsB,CAAC,EAAE,oBAAoB,CAAC;IAC9C;;;OAGG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,eAAO,MAAM,4BAA4B,GAAI,kDAG1C,gCAAqC,KAAG,MAsC1C,CAAC"}

package/dist/gro_plugin_sveltekit_library.js

@@ -0,0 +1,34 @@
+import { print_spawn_result, spawn, spawn_result_to_message } from '@fuzdev/fuz_util/process.js';
+import { TaskError } from "./task.js";
+import { package_json_load } from "./package_json.js";
+import { run_svelte_package } from "./sveltekit_helpers.js";
+import { SVELTE_PACKAGE_CLI } from "./constants.js";
+export const gro_plugin_sveltekit_library = ({ svelte_package_options, svelte_package_cli = SVELTE_PACKAGE_CLI, } = {}) => {
+    return {
+        name: 'gro_plugin_sveltekit_library',
+        setup: async ({ dev, log, config }) => {
+            if (!dev) {
+                const package_json = await package_json_load();
+                await run_svelte_package(package_json, svelte_package_options, svelte_package_cli, log, config.pm_cli);
+            }
+        },
+        adapt: async ({ log, timings, config }) => {
+            const package_json = await package_json_load();
+            // link the CLI binaries if they exist
+            if (package_json.bin) {
+                const timing_to_link = timings.start(`${config.pm_cli} link`);
+                await Promise.all(Object.values(package_json.bin).map(async (bin_path) => {
+                    const chmod_result = await spawn('chmod', ['+x', bin_path]);
+                    if (!chmod_result.ok)
+                        log.error(`chmod on bin path ${bin_path} failed: ${spawn_result_to_message(chmod_result)}`);
+                }));
+                log.info(`linking`);
+                const link_result = await spawn(config.pm_cli, ['link', '-f']); // TODO don't use `-f` unless necessary or at all?
+                if (!link_result.ok) {
+                    throw new TaskError(`Failed to link. ${print_spawn_result(link_result)}`);
+                }
+                timing_to_link();
+            }
+        },
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/** @nodocs */
+export type { GroConfig, CreateGroConfig, RawGroConfig } from './gro_config.ts';
+/** @nodocs */
+export { type Plugin, plugin_replace } from './plugin.ts';
+/** @nodocs */
+export type { Gen, GenContext } from './gen.ts';
+/** @nodocs */
+export { type Task, type TaskContext, TaskError } from './task.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAAA,cAAc;AACd,YAAY,EAAC,SAAS,EAAE,eAAe,EAAE,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAC9E,cAAc;AACd,OAAO,EAAC,KAAK,MAAM,EAAE,cAAc,EAAC,MAAM,aAAa,CAAC;AACxD,cAAc;AACd,YAAY,EAAC,GAAG,EAAE,UAAU,EAAC,MAAM,UAAU,CAAC;AAC9C,cAAc;AACd,OAAO,EAAC,KAAK,IAAI,EAAE,KAAK,WAAW,EAAE,SAAS,EAAC,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,4 @@
+/** @nodocs */
+export { plugin_replace } from "./plugin.js";
+/** @nodocs */
+export { TaskError } from "./task.js";

package/dist/input_path.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+import type { Flavored } from '@fuzdev/fuz_util/types.js';
+import type { PathId, ResolvedPath } from '@fuzdev/fuz_util/path.js';
+export declare const InputPath: z.ZodString;
+export type InputPath = Flavored<z.infer<typeof InputPath>, 'InputPath'>;
+export declare const RawInputPath: z.ZodString;
+export type RawInputPath = Flavored<z.infer<typeof RawInputPath>, 'RawInputPath'>;
+/**
+ * Raw input paths are paths that users provide to Gro to reference files for tasks and gen.
+ *
+ * A raw input path can be to a file or directory in the following forms:
+ *
+ * - an absolute path, preserved
+ * - an explicit relative path, e.g. `./src/foo`, resolved to `root_path` which defaults to the cwd
+ * - an implicit relative path, e.g. `src/foo`, preserved
+ * - an implicit relative path prefixed with `gro/`, transformed to absolute in the Gro directory
+ *
+ * Thus, input paths are either absolute or implicitly relative.
+ */
+export declare const to_input_path: (raw_input_path: RawInputPath, root_path?: string) => InputPath;
+export declare const to_input_paths: (raw_input_paths: Array<RawInputPath>, root_path?: string) => Array<InputPath>;
+export interface PossiblePath {
+    id: PathId;
+    input_path: InputPath;
+    root_dir: PathId;
+}
+/**
+ * Gets a list of possible source ids for each input path with `extensions`,
+ * duplicating each under `root_dirs`, without checking the filesystem.
+ */
+export declare const get_possible_paths: (input_path: InputPath, root_dirs: Array<PathId>, extensions: Array<string>) => Promise<Array<PossiblePath>>;
+export interface ResolvedInputPath {
+    input_path: InputPath;
+    id: PathId;
+    is_directory: boolean;
+    root_dir: PathId;
+}
+export interface ResolvedInputFile {
+    id: PathId;
+    input_path: InputPath;
+    resolved_input_path: ResolvedInputPath;
+}
+export interface ResolvedInputPaths {
+    resolved_input_paths: Array<ResolvedInputPath>;
+    possible_paths_by_input_path: Map<InputPath, Array<PossiblePath>>;
+    unmapped_input_paths: Array<InputPath>;
+}
+/**
+ * Gets the path data for each input path, checking the filesystem for the possibilities
+ * and stopping at the first existing file or falling back to the first existing directory.
+ * If none is found for an input path, it's added to `unmapped_input_paths`.
+ */
+export declare const resolve_input_paths: (input_paths: Array<InputPath>, root_dirs: Array<PathId>, extensions: Array<string>) => Promise<ResolvedInputPaths>;
+export interface ResolvedInputFiles {
+    resolved_input_files: Array<ResolvedInputFile>;
+    resolved_input_files_by_root_dir: Map<PathId, Array<ResolvedInputFile>>;
+    input_directories_with_no_files: Array<InputPath>;
+}
+/**
+ * Finds all of the matching files for the given input paths.
+ * De-dupes source ids.
+ */
+export declare const resolve_input_files: (resolved_input_paths: Array<ResolvedInputPath>, search?: (dir: string) => Promise<Array<ResolvedPath>>) => Promise<ResolvedInputFiles>;
+//# sourceMappingURL=input_path.d.ts.map

package/dist/input_path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"input_path.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/input_path.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AACtB,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,2BAA2B,CAAC;AACxD,OAAO,KAAK,EAAW,MAAM,EAAE,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAM7E,eAAO,MAAM,SAAS,aAAa,CAAC;AACpC,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,EAAE,WAAW,CAAC,CAAC;AAEzE,eAAO,MAAM,YAAY,aAAa,CAAC;AACvC,MAAM,MAAM,YAAY,GAAG,QAAQ,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,EAAE,cAAc,CAAC,CAAC;AAElF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,aAAa,GACzB,gBAAgB,YAAY,EAC5B,kBAAyB,KACvB,SAOF,CAAC;AAEF,eAAO,MAAM,cAAc,GAC1B,iBAAiB,KAAK,CAAC,YAAY,CAAC,EACpC,YAAY,MAAM,KAChB,KAAK,CAAC,SAAS,CAA4D,CAAC;AAE/E,MAAM,WAAW,YAAY;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,SAAS,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC9B,YAAY,SAAS,EACrB,WAAW,KAAK,CAAC,MAAM,CAAC,EACxB,YAAY,KAAK,CAAC,MAAM,CAAC,KACvB,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAiC7B,CAAC;AAEF,MAAM,WAAW,iBAAiB;IACjC,UAAU,EAAE,SAAS,CAAC;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,OAAO,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,iBAAiB;IACjC,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,SAAS,CAAC;IACtB,mBAAmB,EAAE,iBAAiB,CAAC;CACvC;AAED,MAAM,WAAW,kBAAkB;IAClC,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC/C,4BAA4B,EAAE,GAAG,CAAC,SAAS,EAAE,KAAK,CAAC,YAAY,CAAC,CAAC,CAAC;IAClE,oBAAoB,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;CACvC;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC/B,aAAa,KAAK,CAAC,SAAS,CAAC,EAC7B,WAAW,KAAK,CAAC,MAAM,CAAC,EACxB,YAAY,KAAK,CAAC,MAAM,CAAC,KACvB,OAAO,CAAC,kBAAkB,CAkD5B,CAAC;AAEF,MAAM,WAAW,kBAAkB;IAClC,oBAAoB,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IAC/C,gCAAgC,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC,CAAC;IACxE,+BAA+B,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;CAClD;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,GAC/B,sBAAsB,KAAK,CAAC,iBAAiB,CAAC,EAC9C,SAAQ,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,KAAK,CAAC,YAAY,CAAC,CAAa,KAC/D,OAAO,CAAC,kBAAkB,CAgE5B,CAAC"}

package/dist/input_path.js

@@ -0,0 +1,199 @@
+import { dirname, isAbsolute, join, resolve } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { fs_exists, fs_search } from '@fuzdev/fuz_util/fs.js';
+import { strip_start } from '@fuzdev/fuz_util/string.js';
+import { z } from 'zod';
+import { GRO_PACKAGE_DIR, GRO_DIST_DIR } from "./paths.js";
+import { TASK_FILE_SUFFIX_JS } from "./task.js";
+// TODO Flavored doesn't work when used in schemas, use Zod brand instead? problem is ergonomics
+export const InputPath = z.string();
+export const RawInputPath = z.string();
+/**
+ * Raw input paths are paths that users provide to Gro to reference files for tasks and gen.
+ *
+ * A raw input path can be to a file or directory in the following forms:
+ *
+ * - an absolute path, preserved
+ * - an explicit relative path, e.g. `./src/foo`, resolved to `root_path` which defaults to the cwd
+ * - an implicit relative path, e.g. `src/foo`, preserved
+ * - an implicit relative path prefixed with `gro/`, transformed to absolute in the Gro directory
+ *
+ * Thus, input paths are either absolute or implicitly relative.
+ */
+export const to_input_path = (raw_input_path, root_path = process.cwd()) => {
+    if (raw_input_path.startsWith(GRO_PACKAGE_DIR)) {
+        return GRO_DIST_DIR + strip_start(raw_input_path, GRO_PACKAGE_DIR);
+    }
+    else if (raw_input_path[0] === '.') {
+        return resolve(root_path, raw_input_path);
+    }
+    return raw_input_path;
+};
+export const to_input_paths = (raw_input_paths, root_path) => raw_input_paths.map((p) => to_input_path(p, root_path));
+/**
+ * Gets a list of possible source ids for each input path with `extensions`,
+ * duplicating each under `root_dirs`, without checking the filesystem.
+ */
+export const get_possible_paths = async (input_path, root_dirs, extensions) => {
+    const possible_paths = new Set();
+    const add_possible_paths = (path, root_dir) => {
+        // Specifically for paths to the Gro package dist, optimize by only looking for `.task.js`.
+        if (path.startsWith(GRO_DIST_DIR)) {
+            possible_paths.add({
+                id: (path.endsWith('/') || path.endsWith(TASK_FILE_SUFFIX_JS)
+                    ? path
+                    : path + TASK_FILE_SUFFIX_JS),
+                input_path,
+                root_dir,
+            });
+        }
+        else {
+            possible_paths.add({ id: path, input_path, root_dir });
+            if (!path.endsWith('/') && !extensions.some((e) => path.endsWith(e))) {
+                for (const extension of extensions) {
+                    possible_paths.add({ id: path + extension, input_path, root_dir });
+                }
+            }
+        }
+    };
+    if (isAbsolute(input_path)) {
+        const exists = await fs_exists(input_path);
+        const is_directory = exists && (await stat(input_path)).isDirectory();
+        add_possible_paths(input_path, is_directory ? input_path : dirname(input_path));
+    }
+    else {
+        for (const root_dir of root_dirs) {
+            add_possible_paths(join(root_dir, input_path), root_dir);
+        }
+    }
+    return Array.from(possible_paths);
+};
+/**
+ * Gets the path data for each input path, checking the filesystem for the possibilities
+ * and stopping at the first existing file or falling back to the first existing directory.
+ * If none is found for an input path, it's added to `unmapped_input_paths`.
+ */
+export const resolve_input_paths = async (input_paths, root_dirs, extensions) => {
+    const resolved_input_paths = [];
+    const possible_paths_by_input_path = new Map();
+    const unmapped_input_paths = [];
+    for (const input_path of input_paths) {
+        let found_file = null;
+        let found_dirs = null;
+        // eslint-disable-next-line no-await-in-loop
+        const possible_paths = await get_possible_paths(input_path, root_dirs, extensions);
+        possible_paths_by_input_path.set(input_path, possible_paths);
+        // Find the first existing file path or fallback to the first directory path.
+        for (const possible_path of possible_paths) {
+            // eslint-disable-next-line no-await-in-loop
+            if (!(await fs_exists(possible_path.id)))
+                continue;
+            // eslint-disable-next-line no-await-in-loop
+            const stats = await stat(possible_path.id);
+            if (stats.isDirectory()) {
+                found_dirs ??= [];
+                found_dirs.push([{ id: possible_path.id, is_directory: stats.isDirectory() }, possible_path]);
+            }
+            else {
+                found_file = [{ id: possible_path.id, is_directory: stats.isDirectory() }, possible_path];
+                break;
+            }
+        }
+        if (found_file) {
+            resolved_input_paths.push({
+                input_path,
+                id: found_file[0].id,
+                is_directory: found_file[0].is_directory,
+                root_dir: found_file[1].root_dir,
+            });
+        }
+        else if (found_dirs) {
+            for (const found_dir of found_dirs) {
+                resolved_input_paths.push({
+                    input_path,
+                    id: found_dir[0].id,
+                    is_directory: found_dir[0].is_directory,
+                    root_dir: found_dir[1].root_dir,
+                });
+            }
+        }
+        else {
+            unmapped_input_paths.push(input_path);
+        }
+    }
+    return {
+        resolved_input_paths,
+        possible_paths_by_input_path,
+        unmapped_input_paths,
+    };
+};
+/**
+ * Finds all of the matching files for the given input paths.
+ * De-dupes source ids.
+ */
+export const resolve_input_files = async (resolved_input_paths, search = fs_search) => {
+    const resolved_input_files = [];
+    // Add all input paths initially, and remove each when resolved to a file.
+    const existing_path_ids = new Set();
+    let remaining = resolved_input_paths.slice();
+    const handle_found = (input_path, id) => {
+        remaining = remaining.filter((r) => !(r.id === id || r.input_path === input_path || r.input_path === id));
+    };
+    // TODO parallelize but would need to de-dupe and retain order
+    for (const resolved_input_path of resolved_input_paths) {
+        const { input_path, id, is_directory } = resolved_input_path;
+        if (is_directory) {
+            // Handle input paths that resolve to directories.
+            // eslint-disable-next-line no-await-in-loop
+            const files = await search(id);
+            if (!files.length)
+                continue;
+            const path_ids = [];
+            for (const { path, is_directory } of files) {
+                if (is_directory)
+                    continue;
+                const path_id = join(id, path);
+                if (!existing_path_ids.has(path_id)) {
+                    existing_path_ids.add(path_id);
+                    path_ids.push(path_id);
+                }
+                handle_found(input_path, path_id);
+            }
+            if (!path_ids.length)
+                continue;
+            const resolved_input_files_for_input_path = [];
+            for (const path_id of path_ids) {
+                const resolved_input_file = {
+                    id: path_id,
+                    input_path,
+                    resolved_input_path,
+                };
+                resolved_input_files.push(resolved_input_file);
+                resolved_input_files_for_input_path.push(resolved_input_file);
+            }
+        }
+        else {
+            if (!existing_path_ids.has(id)) {
+                // Handle input paths that resolve to files.
+                existing_path_ids.add(id);
+                const resolved_input_file = { id, input_path, resolved_input_path };
+                resolved_input_files.push(resolved_input_file);
+            }
+            handle_found(input_path, id);
+        }
+    }
+    return {
+        resolved_input_files,
+        resolved_input_files_by_root_dir: resolved_input_files.reduce((map, resolved_input_file) => {
+            const { root_dir } = resolved_input_file.resolved_input_path;
+            if (map.has(root_dir)) {
+                map.get(root_dir).push(resolved_input_file);
+            }
+            else {
+                map.set(root_dir, [resolved_input_file]);
+            }
+            return map;
+        }, new Map()),
+        input_directories_with_no_files: remaining.map((r) => r.input_path),
+    };
+};

package/dist/invoke.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=invoke.d.ts.map

package/dist/invoke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invoke.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/invoke.ts"],"names":[],"mappings":""}