@ryanatkn/gro 0.119.1 → 0.120.1

package/dist/search_fs.js

@@ -1,22 +1,44 @@
-import glob from 'tiny-glob';
-import { stat } from 'node:fs/promises';
-import { sort_map, compare_simple_map_entries } from '@ryanatkn/belt/map.js';
-import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
 import { EMPTY_OBJECT } from '@ryanatkn/belt/object.js';
-import { exists } from './fs.js';
+import { to_array } from '@ryanatkn/belt/array.js';
+import { ensure_end } from '@ryanatkn/belt/string.js';
+import { isAbsolute, join } from 'node:path';
+import { existsSync, readdirSync } from 'node:fs';
 export const search_fs = async (dir, options = EMPTY_OBJECT) => {
-    const { filter, sort = compare_simple_map_entries, files_only = true } = options;
-    const final_dir = strip_end(dir, '/');
-    if (!(await exists(final_dir)))
-        return new Map();
-    const globbed = await glob(final_dir + '/**/*', { absolute: true, filesOnly: files_only });
-    const paths = new Map();
-    await Promise.all(globbed.map(async (g) => {
-        const path = strip_start(g, final_dir + '/');
-        const stats = await stat(g);
-        if (!filter || stats.isDirectory() || filter(path, stats)) {
-            paths.set(path, stats);
+    const { filter, file_filter, sort = default_sort, include_directories = false, cwd = process.cwd(), } = options;
+    const final_dir = ensure_end(cwd && !isAbsolute(dir) ? join(cwd, dir) : dir, '/');
+    const filters = !filter || (Array.isArray(filter) && !filter.length) ? undefined : to_array(filter);
+    const file_filters = !file_filter || (Array.isArray(file_filter) && !file_filter.length)
+        ? undefined
+        : to_array(file_filter);
+    if (!existsSync(final_dir))
+        return [];
+    const paths = [];
+    crawl(final_dir, paths, filters, file_filters, include_directories, null);
+    return sort ? paths.sort(typeof sort === 'boolean' ? default_sort : sort) : paths;
+};
+const default_sort = (a, b) => a.path.localeCompare(b.path);
+const crawl = (dir, paths, filters, file_filter, include_directories, base_dir) => {
+    // This sync version is significantly faster than using the `fs/promises` version -
+    // it doesn't parallelize but that's not the common case in Gro.
+    const dirents = readdirSync(dir, { withFileTypes: true });
+    for (const dirent of dirents) {
+        const { name, parentPath } = dirent;
+        const is_directory = dirent.isDirectory();
+        const id = parentPath + name;
+        const include = !filters || filters.every((f) => f(id, is_directory));
+        if (include) {
+            const path = base_dir === null ? name : base_dir + '/' + name;
+            if (is_directory) {
+                const dir_id = id + '/';
+                if (include_directories) {
+                    paths.push({ path, id: dir_id, is_directory: true });
+                }
+                crawl(dir_id, paths, filters, file_filter, include_directories, path);
+            }
+            else if (!file_filter || file_filter.every((f) => f(id))) {
+                paths.push({ path, id, is_directory: false });
+            }
         }
-    }));
-    return sort ? sort_map(paths, sort) : paths;
+    }
+    return paths;
 };

package/dist/search_fs.test.js

@@ -1,10 +1,8 @@
-import { suite } from 'uvu';
+import { test } from 'uvu';
 import * as assert from 'uvu/assert';
+import { resolve } from 'node:path';
 import { search_fs } from './search_fs.js';
-import { paths } from './paths.js';
-/* test__search_fs */
-const test__search_fs = suite('search_fs');
-test__search_fs('basic behavior', async () => {
+test('search_fs basic behavior', async () => {
     const ignored_path = 'test1.foo.ts';
     let has_ignored_path = false;
     const result = await search_fs('./src/fixtures', {
@@ -13,10 +11,10 @@ test__search_fs('basic behavior', async () => {
                 has_ignored_path = path.endsWith(ignored_path);
             return !path.endsWith(ignored_path);
         },
-        sort: (a, b) => -a[0].localeCompare(b[0]),
+        sort: (a, b) => a.path.localeCompare(b.path) * -1,
     });
     assert.ok(has_ignored_path); // makes sure the test isn't wrong
-    assert.equal(Array.from(result.keys()), [
+    const expected_files = [
         'test2.foo.ts',
         'test_ts.ts',
         'test_task_module.task_fixture.ts',
@@ -43,8 +41,8 @@ test__search_fs('basic behavior', async () => {
         'baz1/test1.baz.ts',
         'bar2/test2.bar.ts',
         'bar1/test1.bar.ts',
-    ].map((f) => paths.source + 'fixtures/' + f));
+    ];
+    assert.equal(result.map((f) => f.path), expected_files);
+    assert.equal(result.map((f) => f.id), expected_files.map((f) => resolve(`src/fixtures/${f}`)));
 });
-// TODO more tests
-test__search_fs.run();
-/* test__search_fs */
+test.run();

package/dist/src_json.js

@@ -2,8 +2,8 @@ import { z } from 'zod';
 import { join } from 'node:path';
 import { strip_start } from '@ryanatkn/belt/string.js';
 import { Project } from 'ts-morph';
+import { existsSync } from 'node:fs';
 import { paths, replace_extension } from './paths.js';
-import { exists } from './fs.js';
 import { transform_empty_object_to_undefined, } from './package_json.js';
 export const Src_Module_Declaration = z
     .object({
@@ -60,7 +60,7 @@ export const to_src_modules = async (exports, log, lib_path = paths.lib) => {
             return [k, src_module];
         }
         const source_file_id = join(lib_path, source_file_path);
-        if (!(await exists(source_file_id))) {
+        if (!existsSync(source_file_id)) {
             log?.warn('failed to infer source file from export path', k, '- the inferred file', source_file_id, 'does not exist');
             return null;
         }

package/dist/sveltekit_config.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="svelte" />
 import type { Config as SveltekitConfig } from '@sveltejs/kit';
 import type { CompileOptions, PreprocessorGroup, ModuleCompileOptions } from 'svelte/compiler';
 /**

package/dist/sveltekit_helpers.js

@@ -1,5 +1,5 @@
+import { existsSync } from 'node:fs';
 import { Package_Json, load_package_json } from './package_json.js';
-import { exists } from './fs.js';
 import { sveltekit_config_global } from './sveltekit_config_global.js';
 import { SVELTEKIT_CONFIG_FILENAME, SVELTEKIT_DEV_DIRNAME } from './path_constants.js';
 import { find_cli, spawn_cli } from './cli.js';
@@ -8,7 +8,7 @@ export const SVELTEKIT_CLI = 'svelte-kit';
 export const SVELTE_PACKAGE_CLI = 'svelte-package';
 export const SVELTE_PACKAGE_DEP_NAME = '@sveltejs/package';
 export const has_sveltekit_app = async () => {
-    if (!(await exists(SVELTEKIT_CONFIG_FILENAME))) {
+    if (!existsSync(SVELTEKIT_CONFIG_FILENAME)) {
         return { ok: false, message: `no SvelteKit config found at ${SVELTEKIT_CONFIG_FILENAME}` };
     }
     // TODO check for routes?
@@ -19,7 +19,7 @@ export const has_sveltekit_library = async (package_json, sveltekit_config = sve
     if (!has_sveltekit_app_result.ok) {
         return has_sveltekit_app_result;
     }
-    if (!(await exists(sveltekit_config.lib_path))) {
+    if (!existsSync(sveltekit_config.lib_path)) {
         return { ok: false, message: `no SvelteKit lib directory found at ${sveltekit_config.lib_path}` };
     }
     const pkg = package_json ?? (await load_package_json());
@@ -44,7 +44,7 @@ export const sveltekit_sync = async () => {
  * If the SvelteKit CLI is found and its `.svelte-kit` directory is not, run `svelte-kit sync`.
  */
 export const sveltekit_sync_if_obviously_needed = async () => {
-    if (await exists(SVELTEKIT_DEV_DIRNAME)) {
+    if (existsSync(SVELTEKIT_DEV_DIRNAME)) {
         return;
     }
     if (!(await find_cli(SVELTEKIT_CLI))) {

package/dist/sveltekit_shim_app.d.ts

@@ -6,5 +6,5 @@ export declare const sveltekit_shim_app_environment_matcher: RegExp;
  * @see https://kit.svelte.dev/docs/modules
  */
 export declare const sveltekit_shim_app_specifiers: Map<string, string>;
-export declare const render_sveltekit_shim_app_paths: (base_url?: Parsed_Sveltekit_Config['base_url'], assets_url?: Parsed_Sveltekit_Config['assets_url']) => string;
+export declare const render_sveltekit_shim_app_paths: (base_url?: Parsed_Sveltekit_Config["base_url"], assets_url?: Parsed_Sveltekit_Config["assets_url"]) => string;
 export declare const render_sveltekit_shim_app_environment: (dev: boolean) => string;

package/dist/sveltekit_shim_app_forms.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="@sveltejs/kit" />
 import type { applyAction as base_applyAction, deserialize as base_deserialize, enhance as base_enhance } from '$app/forms';
 export declare const applyAction: typeof base_applyAction;
 export declare const deserialize: typeof base_deserialize;

package/dist/sveltekit_shim_app_navigation.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="@sveltejs/kit" />
 import type { afterNavigate as base_afterNavigate, beforeNavigate as base_beforeNavigate, disableScrollHandling as base_disableScrollHandling, goto as base_goto, invalidate as base_invalidate, invalidateAll as base_invalidateAll, preloadCode as base_preloadCode, preloadData as base_preloadData } from '$app/navigation';
 export declare const afterNavigate: typeof base_afterNavigate;
 export declare const beforeNavigate: typeof base_beforeNavigate;

package/dist/sveltekit_shim_app_paths.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="@sveltejs/kit" />
 /**
  * This file is created dynamically by `render_sveltekit_shim_app_paths`
  * but exists here for the sake of the Node loader.

package/dist/sveltekit_shim_app_stores.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="@sveltejs/kit" />
 import type { getStores as base_getStores, navigating as base_navigating, page as base_page, updated as base_updated } from '$app/stores';
 export declare const getStores: typeof base_getStores;
 export declare const navigating: typeof base_navigating;

package/dist/sveltekit_shim_env.d.ts

@@ -1,4 +1,4 @@
 /**
  * Generates a module shim for SvelteKit's `$env` imports.
  */
-export declare const render_env_shim_module: (dev: boolean, mode: 'static' | 'dynamic', visibility: 'public' | 'private', public_prefix?: string, private_prefix?: string, env_dir?: string, env_files?: string[], ambient_env?: Record<string, string | undefined>) => Promise<string>;
+export declare const render_env_shim_module: (dev: boolean, mode: "static" | "dynamic", visibility: "public" | "private", public_prefix?: string, private_prefix?: string, env_dir?: string, env_files?: string[], ambient_env?: Record<string, string | undefined>) => Promise<string>;

package/dist/task.d.ts

@@ -1,8 +1,13 @@
 import type { Logger } from '@ryanatkn/belt/log.js';
 import type { z } from 'zod';
 import type { Timings } from '@ryanatkn/belt/timings.js';
+import type { Result } from '@ryanatkn/belt/result.js';
 import type { Args } from './args.js';
+import type { Path_Id } from './path.js';
 import type { Gro_Config } from './config.js';
+import type { Parsed_Sveltekit_Config } from './sveltekit_config.js';
+import { type Input_Path, type Resolved_Input_File, type Resolved_Input_Path } from './input_path.js';
+import { type Load_Modules_Failure, type Module_Meta } from './modules.js';
 export interface Task<T_Args = Args, // same as `z.infer<typeof Args>`
 T_Args_Schema extends z.ZodType = z.ZodType, T_Return = unknown> {
     run: (ctx: Task_Context<T_Args>) => Promise<T_Return>;
@@ -12,14 +17,16 @@ T_Args_Schema extends z.ZodType = z.ZodType, T_Return = unknown> {
 export interface Task_Context<T_Args = object> {
     args: T_Args;
     config: Gro_Config;
+    sveltekit_config: Parsed_Sveltekit_Config;
     log: Logger;
     timings: Timings;
     invoke_task: (task_name: string, args?: Args, config?: Gro_Config) => Promise<void>;
 }
 export declare const TASK_FILE_SUFFIX_TS = ".task.ts";
 export declare const TASK_FILE_SUFFIX_JS = ".task.js";
+export declare const TASK_FILE_SUFFIXES: string[];
 export declare const is_task_path: (path: string) => boolean;
-export declare const to_task_name: (id: Flavored<string, "Source_Id">, task_root_paths: string[]) => string;
+export declare const to_task_name: (id: Path_Id, task_root_dir: Path_Id) => string;
 /**
  * This is used by tasks to signal a known failure.
  * It's useful for cleaning up logging because
@@ -27,3 +34,60 @@ export declare const to_task_name: (id: Flavored<string, "Source_Id">, task_root
  */
 export declare class Task_Error extends Error {
 }
+export interface Found_Task {
+    input_path: Input_Path;
+    id: Path_Id;
+    task_root_dir: Path_Id;
+}
+export interface Found_Tasks {
+    resolved_input_files: Resolved_Input_File[];
+    resolved_input_files_by_input_path: Map<Input_Path, Resolved_Input_File[]>;
+    resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
+    resolved_input_paths: Resolved_Input_Path[];
+    resolved_input_paths_by_input_path: Map<Input_Path, Resolved_Input_Path[]>;
+    input_paths: Input_Path[];
+    task_root_dirs: Path_Id[];
+}
+export type Find_Tasks_Result = Result<{
+    value: Found_Tasks;
+}, Find_Modules_Failure>;
+export type Find_Modules_Failure = {
+    type: 'unmapped_input_paths';
+    unmapped_input_paths: Input_Path[];
+    resolved_input_paths: Resolved_Input_Path[];
+    resolved_input_paths_by_input_path: Map<Input_Path, Resolved_Input_Path[]>;
+    input_paths: Input_Path[];
+    task_root_dirs: Path_Id[];
+    reasons: string[];
+} | {
+    type: 'input_directories_with_no_files';
+    input_directories_with_no_files: Resolved_Input_Path[];
+    resolved_input_files: Resolved_Input_File[];
+    resolved_input_files_by_input_path: Map<Input_Path, Resolved_Input_File[]>;
+    resolved_input_files_by_root_dir: Map<Path_Id, Resolved_Input_File[]>;
+    resolved_input_paths: Resolved_Input_Path[];
+    resolved_input_paths_by_input_path: Map<Input_Path, Resolved_Input_Path[]>;
+    input_paths: Input_Path[];
+    task_root_dirs: Path_Id[];
+    reasons: string[];
+};
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export declare const find_tasks: (input_paths: Input_Path[], task_root_dirs: Path_Id[], config: Gro_Config, timings?: any) => Promise<Find_Tasks_Result>;
+export interface Loaded_Tasks {
+    modules: Task_Module_Meta[];
+    found_tasks: Found_Tasks;
+}
+export interface Task_Module {
+    task: Task;
+}
+export interface Task_Module_Meta extends Module_Meta<Task_Module> {
+    name: string;
+}
+export type Load_Tasks_Result = Result<{
+    value: Loaded_Tasks;
+}, Load_Tasks_Failure>;
+export type Load_Tasks_Failure = Load_Modules_Failure<Task_Module_Meta>;
+export declare const load_tasks: (found_tasks: Found_Tasks) => Promise<Load_Tasks_Result>;
+export declare const validate_task_module: (mod: Record<string, any>) => mod is Task_Module;

package/dist/task.js

@@ -1,21 +1,21 @@
 import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
+import { red } from 'kleur/colors';
+import { resolve_input_files, resolve_input_paths, } from './input_path.js';
+import { print_path } from './paths.js';
+import { search_fs } from './search_fs.js';
+import { load_modules } from './modules.js';
 export const TASK_FILE_SUFFIX_TS = '.task.ts';
 export const TASK_FILE_SUFFIX_JS = '.task.js';
+export const TASK_FILE_SUFFIXES = [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS]; // TODO from `Gro_Config`, but needs to be used everywhere the constants are
 export const is_task_path = (path) => path.endsWith(TASK_FILE_SUFFIX_TS) || path.endsWith(TASK_FILE_SUFFIX_JS);
-export const to_task_name = (id, task_root_paths) => {
-    // If the id is in any of the task root paths, use the longest available match and strip it.
-    // This is convoluted because we're not tracking which root path was resolved against the id.
-    // TODO improve the data flow of id from task root path so this is unnecessary
-    let longest_matching_path = '';
-    for (const path of task_root_paths) {
-        if (id.startsWith(path) && path.length > longest_matching_path.length) {
-            longest_matching_path = path;
-        }
-    }
-    const task_name = longest_matching_path
-        ? strip_start(strip_start(id, longest_matching_path), '/')
+export const to_task_name = (id, task_root_dir) => {
+    let task_name = id.startsWith(task_root_dir)
+        ? strip_start(strip_start(id, task_root_dir), '/')
         : id;
-    return strip_end(strip_end(task_name, TASK_FILE_SUFFIX_TS), TASK_FILE_SUFFIX_JS);
+    for (const suffix of TASK_FILE_SUFFIXES) {
+        task_name = strip_end(task_name, suffix);
+    }
+    return task_name;
 };
 /**
  * This is used by tasks to signal a known failure.
@@ -24,3 +24,76 @@ export const to_task_name = (id, task_root_paths) => {
  */
 export class Task_Error extends Error {
 }
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export const find_tasks = async (input_paths, task_root_dirs, config, timings) => {
+    // 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, resolved_input_paths_by_input_path, unmapped_input_paths } = await resolve_input_paths(input_paths, task_root_dirs, TASK_FILE_SUFFIXES);
+    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,
+            resolved_input_paths_by_input_path,
+            input_paths,
+            task_root_dirs,
+            reasons: unmapped_input_paths.map((input_path) => 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_resolve_input_files = timings?.start('resolve input files');
+    const { resolved_input_files, resolved_input_files_by_input_path, resolved_input_files_by_root_dir, input_directories_with_no_files, } = await resolve_input_files(resolved_input_paths, (id, options) => search_fs(id, {
+        ...options,
+        filter: config.search_filters,
+        file_filter: (p) => TASK_FILE_SUFFIXES.some((s) => p.endsWith(s)),
+    }));
+    timing_to_resolve_input_files?.();
+    // 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_input_path,
+            resolved_input_files_by_root_dir,
+            resolved_input_paths,
+            resolved_input_paths_by_input_path,
+            input_paths,
+            task_root_dirs,
+            reasons: input_directories_with_no_files.map(({ input_path }) => red(`Input directory contains no matching files: ${print_path(input_path)}`)),
+        };
+    }
+    return {
+        ok: true,
+        value: {
+            resolved_input_files,
+            resolved_input_files_by_input_path,
+            resolved_input_files_by_root_dir,
+            resolved_input_paths,
+            resolved_input_paths_by_input_path,
+            input_paths,
+            task_root_dirs,
+        },
+    };
+};
+export const load_tasks = async (found_tasks) => {
+    const loaded_modules = await load_modules(found_tasks.resolved_input_files, validate_task_module, (resolved_input_file, mod) => ({
+        id: resolved_input_file.id,
+        mod,
+        name: to_task_name(resolved_input_file.id, resolved_input_file.resolved_input_path.root_dir),
+    }));
+    if (!loaded_modules.ok) {
+        return loaded_modules;
+    }
+    return {
+        ok: true,
+        value: { modules: loaded_modules.modules, found_tasks },
+    };
+};
+export const validate_task_module = (mod) => !!mod.task && typeof mod.task.run === 'function';

package/dist/task.test.js

@@ -1,7 +1,9 @@
 import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { resolve } from 'node:path';
-import { is_task_path, to_task_name } from './task.js';
+import { is_task_path, to_task_name, validate_task_module, find_tasks, load_tasks } from './task.js';
+import * as actual_test_task_module from './test.task.js';
+import { create_empty_config } from './config.js';
 test('is_task_path basic behavior', () => {
     assert.ok(is_task_path('foo.task.ts'));
     assert.ok(is_task_path('foo.task.js'));
@@ -10,15 +12,27 @@ test('is_task_path basic behavior', () => {
     assert.ok(!is_task_path('bar/baz/foo.ts'));
 });
 test('to_task_name basic behavior', () => {
-    assert.is(to_task_name('foo.task.ts', []), 'foo');
-    assert.is(to_task_name('bar/baz/foo.task.ts', []), 'bar/baz/foo');
-    assert.is(to_task_name('a/b/c/foo.task.ts', ['a/b/c', 'a']), 'foo');
-    assert.is(to_task_name('a/b/c/foo.task.ts', ['a']), 'b/c/foo');
-    assert.is(to_task_name('a/b/c/foo.task.ts', ['a/b', 'a']), 'c/foo');
-    assert.is(to_task_name(resolve('node_modules/@ryanatkn/gro/dist/foo'), [
-        resolve('./'),
-        resolve('node_modules/@ryanatkn/gro/dist/'),
-    ]), 'foo', 'resolves to node_modules before the cwd');
-    assert.is(to_task_name(resolve('a/b'), [resolve('b')]), resolve('a/b'), 'falls back to the id when unresolved');
+    assert.is(to_task_name('foo.task.ts', process.cwd()), 'foo');
+    assert.is(to_task_name('bar/baz/foo.task.ts', process.cwd()), 'bar/baz/foo');
+    assert.is(to_task_name('a/b/c/foo.task.ts', 'a/b/c'), 'foo');
+    assert.is(to_task_name('a/b/c/foo.task.ts', 'a'), 'b/c/foo');
+    assert.is(to_task_name('a/b/c/foo.task.ts', 'a/b'), 'c/foo');
+    assert.is(to_task_name(resolve('a/b'), resolve('b')), resolve('a/b'), 'falls back to the id when unresolved');
+});
+// TODO if we import directly, svelte-package generates types in `src/fixtures`
+const test_task_module = await import('../fixtures/' + 'test_task_module.task_fixture'); // eslint-disable-line no-useless-concat
+const test_invalid_task_module = await import('../fixtures/' + 'test_invalid_task_module.js'); // eslint-disable-line no-useless-concat
+test('validate_task_module basic behavior', () => {
+    assert.ok(validate_task_module(test_task_module));
+    assert.ok(!validate_task_module(test_invalid_task_module));
+    assert.ok(!validate_task_module({ task: { run: {} } }));
+});
+test('load_tasks basic behavior', async () => {
+    const found = await find_tasks([resolve('src/lib/test'), resolve('src/lib/test.task.ts')], [resolve('src/lib')], create_empty_config());
+    assert.ok(found.ok);
+    const result = await load_tasks(found.value);
+    assert.ok(result.ok);
+    assert.is(result.value.modules.length, 1);
+    assert.is(result.value.modules[0].mod, actual_test_task_module);
 });
 test.run();

package/dist/task_logging.d.ts

@@ -1,8 +1,5 @@
-import { type Find_Modules_Result } from './modules.js';
-import { type Task_Module_Meta } from './task_module.js';
-import { type Input_Path } from './input_path.js';
-import { type Source_Id } from './paths.js';
-export declare const log_tasks: (log: Logger, dir_label: string, source_ids_by_input_path: Map<Input_Path, Source_Id[]>, task_root_paths: string[], log_intro?: boolean) => Promise<void>;
-export declare const log_gro_package_tasks: (input_path: Flavored<string, "Input_Path">, task_root_paths: string[], log: Logger) => Promise<Find_Modules_Result>;
+import type { Logger } from '@ryanatkn/belt/log.js';
+import type { Loaded_Tasks, Task_Module_Meta } from './task.js';
+export declare const log_tasks: (log: Logger, loaded_tasks: Loaded_Tasks, log_intro?: boolean) => Promise<void>;
 export declare const log_error_reasons: (log: Logger, reasons: string[]) => void;
 export declare const log_task_help: (log: Logger, meta: Task_Module_Meta) => void;

package/dist/task_logging.js

@@ -2,46 +2,28 @@ import { cyan, gray, green, red } from 'kleur/colors';
 import { plural } from '@ryanatkn/belt/string.js';
 import { print_value } from '@ryanatkn/belt/print.js';
 import { ZodFirstPartyTypeKind } from 'zod';
-import { find_modules, load_modules } from './modules.js';
-import { load_task_module } from './task_module.js';
-import { to_gro_input_path } from './input_path.js';
-import { print_path_or_gro_path } from './paths.js';
-import { is_task_path } from './task.js';
-import { search_fs } from './search_fs.js';
-export const log_tasks = async (log, dir_label, source_ids_by_input_path, task_root_paths, log_intro = true) => {
-    const source_ids = Array.from(source_ids_by_input_path.values()).flat();
-    if (source_ids.length) {
-        // Load all of the tasks so we can log their summary, and args for the `--help` flag.
-        const load_modules_result = await load_modules(source_ids_by_input_path, (id) => load_task_module(id, task_root_paths));
-        if (!load_modules_result.ok) {
-            log_error_reasons(log, load_modules_result.reasons);
-            process.exit(1);
-        }
-        const logged = [
-            `${log_intro ? '\n\n' : ''}${source_ids.length} task${plural(source_ids.length)} in ${dir_label}:\n`,
-        ];
-        if (log_intro) {
-            logged.unshift(`\n\n${gray('Run a task:')} gro [name]`, `\n${gray('View help:')}  gro [name] --help`);
+import { print_path } from './paths.js';
+export const log_tasks = async (log, loaded_tasks, log_intro = true) => {
+    const { modules, found_tasks } = loaded_tasks;
+    const { resolved_input_files_by_root_dir } = found_tasks;
+    const logged = [];
+    if (log_intro) {
+        logged.unshift(`\n\n${gray('Run a task:')} gro [name]`, `\n${gray('View help:')}  gro [name] --help`);
+    }
+    for (const [root_dir, resolved_input_files] of resolved_input_files_by_root_dir) {
+        const dir_label = print_path(root_dir);
+        if (!resolved_input_files.length) {
+            log.info(`No tasks found in ${dir_label}.`);
+            continue;
         }
-        const longest_task_name = to_max_length(load_modules_result.modules, (m) => m.name);
-        for (const meta of load_modules_result.modules) {
+        logged.push(`${log_intro ? '\n\n' : ''}${resolved_input_files.length} task${plural(resolved_input_files.length)} in ${dir_label}:\n`);
+        const longest_task_name = to_max_length(modules, (m) => m.name);
+        for (const resolved_input_file of resolved_input_files) {
+            const meta = modules.find((m) => m.id === resolved_input_file.id);
             logged.push('\n' + cyan(pad(meta.name, longest_task_name)), '  ', meta.mod.task.summary || '');
         }
-        log[log_intro ? 'info' : 'plain'](logged.join('') + '\n');
-    }
-    else {
-        log.info(`No tasks found in ${dir_label}.`);
-    }
-};
-export const log_gro_package_tasks = async (input_path, task_root_paths, log) => {
-    const gro_dir_input_path = to_gro_input_path(input_path);
-    const gro_dir_find_modules_result = await find_modules([gro_dir_input_path], (id) => search_fs(id, { filter: (path) => is_task_path(path) }));
-    if (gro_dir_find_modules_result.ok) {
-        const gro_path_data = gro_dir_find_modules_result.source_id_path_data_by_input_path.get(gro_dir_input_path);
-        // Log the Gro matches.
-        await log_tasks(log, print_path_or_gro_path(gro_path_data.id), gro_dir_find_modules_result.source_ids_by_input_path, task_root_paths);
     }
-    return gro_dir_find_modules_result;
+    log[log_intro ? 'info' : 'plain'](logged.join('') + '\n');
 };
 export const log_error_reasons = (log, reasons) => {
     for (const reason of reasons) {

package/dist/watch_dir.d.ts

@@ -1,5 +1,5 @@
 import { type WatchOptions } from 'chokidar';
-import type { Path_Stats, Path_Filter } from './path.js';
+import type { Path_Filter } from './path.js';
 export interface Watch_Node_Fs {
     init: () => Promise<void>;
     close: () => Promise<void>;
@@ -7,7 +7,7 @@ export interface Watch_Node_Fs {
 export interface Watcher_Change {
     type: Watcher_Change_Type;
     path: string;
-    stats: Path_Stats;
+    is_directory: boolean;
 }
 export type Watcher_Change_Type = 'create' | 'update' | 'delete';
 export interface Watcher_Change_Callback {

package/dist/watch_dir.js

@@ -1,8 +1,6 @@
 import chokidar, {} from 'chokidar';
-import { stat } from 'node:fs/promises';
 import { relative } from 'node:path';
-const FILE_STATS = { isDirectory: () => false };
-const DIR_STATS = { isDirectory: () => true };
+import { statSync } from 'node:fs';
 /**
  * Watch for changes on the filesystem using chokidar.
  */
@@ -12,37 +10,37 @@ export const watch_dir = ({ dir, on_change, filter, absolute = true, chokidar: c
         init: async () => {
             watcher = chokidar.watch(dir, chokidar_options);
             watcher.on('add', async (path, s) => {
-                const stats = s || (await stat(path));
+                const stats = s || statSync(path);
                 const final_path = absolute ? path : relative(dir, path);
-                if (filter && !filter(final_path, stats))
+                if (filter && !filter(final_path, stats.isDirectory()))
                     return;
-                on_change({ type: 'create', path: final_path, stats });
+                on_change({ type: 'create', path: final_path, is_directory: stats.isDirectory() });
             });
             watcher.on('addDir', async (path, s) => {
-                const stats = s || (await stat(path));
+                const stats = s || statSync(path);
                 const final_path = absolute ? path : relative(dir, path);
-                if (filter && !filter(final_path, stats))
+                if (filter && !filter(final_path, stats.isDirectory()))
                     return;
-                on_change({ type: 'create', path: final_path, stats });
+                on_change({ type: 'create', path: final_path, is_directory: stats.isDirectory() });
             });
             watcher.on('change', async (path, s) => {
-                const stats = s || (await stat(path));
+                const stats = s || statSync(path);
                 const final_path = absolute ? path : relative(dir, path);
-                if (filter && !filter(final_path, stats))
+                if (filter && !filter(final_path, stats.isDirectory()))
                     return;
-                on_change({ type: 'update', path: final_path, stats });
+                on_change({ type: 'update', path: final_path, is_directory: stats.isDirectory() });
             });
             watcher.on('unlink', (path) => {
                 const final_path = absolute ? path : relative(dir, path);
-                if (filter && !filter(final_path, FILE_STATS))
+                if (filter && !filter(final_path, false))
                     return;
-                on_change({ type: 'delete', path: final_path, stats: FILE_STATS });
+                on_change({ type: 'delete', path: final_path, is_directory: false });
             });
             watcher.on('unlinkDir', (path) => {
                 const final_path = absolute ? path : relative(dir, path);
-                if (filter && !filter(final_path, DIR_STATS))
+                if (filter && !filter(final_path, true))
                     return;
-                on_change({ type: 'delete', path: final_path, stats: DIR_STATS });
+                on_change({ type: 'delete', path: final_path, is_directory: true });
             });
             // wait until ready
             let resolve;