@ryanatkn/gro 0.121.1 → 0.123.0

package/README.md

@@ -122,7 +122,7 @@ lint       run eslint
 publish    bump version, publish to npm, and git push
 reinstall  refreshes package-lock.json with the latest and cleanest deps
 release    publish and deploy
-resolve    run `gro gen`, update `package.json`, and optionally `npm i` to sync up
+resolve    diagnostic that logs resolved filesystem info for the given input paths
 run        execute a file with the loader, like `node` but works for TypeScript
 sync       run `gro gen`, update `package.json`, and optionally `npm i` to sync up
 test       run tests with uvu

package/dist/config.js

@@ -20,17 +20,13 @@ export const create_empty_config = () => ({
  * Customize via `search_filters` in the `Gro_Config`.
  * See the test cases for the exact behavior.
  */
-export const DEFAULT_SEARCH_EXCLUDER = new RegExp(`(${[
-    '\\.[^/]+',
-    // TODO probably change to `pkg.name` instead of this catch-all
-    `${NODE_MODULES_DIRNAME}(?!/(@[^/]+/)?gro/${SVELTEKIT_DIST_DIRNAME})`,
-    // `${NODE_MODULES_DIRNAME}(?!/(@.+?/)?gro/${SVELTEKIT_DIST_DIRNAME})`,
-    SVELTEKIT_BUILD_DIRNAME,
-    `(?<!(^|/)gro/)${SVELTEKIT_DIST_DIRNAME}`,
-    SERVER_DIST_PATH,
-]
-    .map((p) => '(^|/)' + p)
-    .join('|')})($|/)`, 'u');
+export const DEFAULT_SEARCH_EXCLUDER = new RegExp(`(${'(^|/)\\.[^/]+' + // exclude all `.`-prefixed directories
+    // TODO probably change to `pkg.name` instead of this catch-all (also `gro` below)
+    `|(^|/)${NODE_MODULES_DIRNAME}(?!/(@[^/]+/)?gro/${SVELTEKIT_DIST_DIRNAME})` + // exclude `node_modules` unless it's to the Gro directory
+    `|(^|/)${SVELTEKIT_BUILD_DIRNAME}` + // exclude the SvelteKit build directory
+    `|(^|/)(?<!(^|/)gro/)${SVELTEKIT_DIST_DIRNAME}` + // exclude the SvelteKit dist directory unless it's in the Gro directory
+    `|(^|/)${SERVER_DIST_PATH}` // exclude the Gro server plugin dist directory
+})($|/)`, 'u');
 const default_map_package_json = async (package_json) => {
     if (package_json.exports) {
         package_json.exports = Object.fromEntries(Object.entries(package_json.exports).filter(([k]) => !DEFAULT_EXPORTS_EXCLUDER.test(k)));

package/dist/docs/tasks.md

@@ -19,7 +19,7 @@ What is a `Task`? See [`task.md`](./task.md).
 - [publish](../publish.task.ts) - bump version, publish to npm, and git push
 - [reinstall](../reinstall.task.ts) - refreshes package-lock.json with the latest and cleanest deps
 - [release](../release.task.ts) - publish and deploy
-- [resolve](../resolve.task.ts) - diagnostic that logs the info resolved from the filesystem for the given input paths
+- [resolve](../resolve.task.ts) - diagnostic that logs resolved filesystem info for the given input paths
 - [run](../run.task.ts) - execute a file with the loader, like `node` but works for TypeScript
 - [sync](../sync.task.ts) - run `gro gen`, update `package.json`, and optionally `npm i` to sync up
 - [test](../test.task.ts) - run tests with uvu

package/dist/gen.d.ts

@@ -85,10 +85,8 @@ export declare const analyze_gen_result: (file: Gen_File) => Promise<Analyzed_Ge
 export declare const write_gen_results: (gen_results: Gen_Results, analyzed_gen_results: Analyzed_Gen_Result[], log: Logger) => Promise<void>;
 export interface Found_Genfiles {
     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[]>;
 }
 export type Find_Genfiles_Result = Result<{
     value: Found_Genfiles;
@@ -97,16 +95,13 @@ export type Find_Genfiles_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[]>;
     reasons: string[];
 } | {
     type: 'input_directories_with_no_files';
-    input_directories_with_no_files: Resolved_Input_Path[];
+    input_directories_with_no_files: 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[]>;
     reasons: string[];
 };
 /**

package/dist/gen.js

@@ -136,7 +136,7 @@ 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, resolved_input_paths_by_input_path, unmapped_input_paths } = resolve_input_paths(input_paths, root_dirs, extensions);
+    const { resolved_input_paths, unmapped_input_paths } = 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) {
@@ -145,13 +145,12 @@ export const find_genfiles = async (input_paths, root_dirs, config, timings) =>
             type: 'unmapped_input_paths',
             unmapped_input_paths,
             resolved_input_paths,
-            resolved_input_paths_by_input_path,
             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_search_fs = timings?.start('find files');
-    const { resolved_input_files, resolved_input_files_by_input_path, resolved_input_files_by_root_dir, input_directories_with_no_files, } = resolve_input_files(resolved_input_paths, (id) => search_fs(id, {
+    const { resolved_input_files, resolved_input_files_by_root_dir, input_directories_with_no_files } = resolve_input_files(resolved_input_paths, (id) => search_fs(id, {
         filter: config.search_filters,
         file_filter: (p) => extensions.some((e) => p.includes(e)),
     }));
@@ -163,21 +162,17 @@ export const find_genfiles = async (input_paths, root_dirs, config, timings) =>
             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,
-            reasons: input_directories_with_no_files.map(({ input_path }) => red(`Input directory contains no matching files: ${print_path(input_path)}`)),
+            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,
         },
     };
 };

package/dist/gen.test.js

@@ -247,6 +247,5 @@ test('find_genfiles_result finds gen modules in a directory', async () => {
     const find_genfiles_result = await find_genfiles(['docs'], [paths.lib], create_empty_config());
     assert.ok(find_genfiles_result.ok);
     assert.ok(find_genfiles_result.value.resolved_input_paths.length);
-    assert.ok(find_genfiles_result.value.resolved_input_paths_by_input_path.size);
 });
 test.run();

package/dist/gro_plugin_gen.js

@@ -45,7 +45,7 @@ export const plugin = () => {
             // making us miss `build` events for gen dependencies,
             // so we run `gen` here even if it's usually wasteful.
             const found = await find_genfiles([paths.source], root_dirs, config);
-            if (found.ok && found.resolved_input_files_by_input_path.size > 0) {
+            if (found.ok && found.value.resolved_input_files.size > 0) {
                 await gen();
             }
             // Do we need to just generate everything once and exit?

package/dist/input_path.d.ts

@@ -42,7 +42,6 @@ export interface Resolved_Input_File {
 }
 export interface Resolved_Input_Paths {
     resolved_input_paths: Resolved_Input_Path[];
-    resolved_input_paths_by_input_path: Map<Input_Path, Resolved_Input_Path[]>;
     possible_paths_by_input_path: Map<Input_Path, Possible_Path[]>;
     unmapped_input_paths: Input_Path[];
 }
@@ -54,12 +53,11 @@ export interface Resolved_Input_Paths {
 export declare const resolve_input_paths: (input_paths: Input_Path[], root_dirs: Path_Id[], extensions: string[]) => Resolved_Input_Paths;
 export interface Resolved_Input_Files {
     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[]>;
-    input_directories_with_no_files: Resolved_Input_Path[];
+    input_directories_with_no_files: Input_Path[];
 }
 /**
  * Finds all of the matching files for the given input paths.
  * De-dupes source ids.
  */
-export declare const resolve_input_files: (resolved_input_paths: Resolved_Input_Path[], custom_search_fs?: (dir: string) => Resolved_Path[]) => Resolved_Input_Files;
+export declare const resolve_input_files: (resolved_input_paths: Resolved_Input_Path[], search?: (dir: string) => Resolved_Path[]) => Resolved_Input_Files;

package/dist/input_path.js

@@ -122,15 +122,6 @@ export const resolve_input_paths = (input_paths, root_dirs, extensions) => {
     }
     return {
         resolved_input_paths,
-        resolved_input_paths_by_input_path: resolved_input_paths.reduce((map, resolved_input_path) => {
-            if (map.has(resolved_input_path.input_path)) {
-                map.get(resolved_input_path.input_path).push(resolved_input_path);
-            }
-            else {
-                map.set(resolved_input_path.input_path, [resolved_input_path]);
-            }
-            return map;
-        }, new Map()),
         possible_paths_by_input_path,
         unmapped_input_paths,
     };
@@ -139,61 +130,58 @@ export const resolve_input_paths = (input_paths, root_dirs, extensions) => {
  * Finds all of the matching files for the given input paths.
  * De-dupes source ids.
  */
-export const resolve_input_files = (resolved_input_paths, custom_search_fs = search_fs) => {
+export const resolve_input_files = (resolved_input_paths, search = search_fs) => {
     const resolved_input_files = [];
-    const resolved_input_files_by_input_path = new Map();
-    const input_directories_with_no_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) {
-            const files = custom_search_fs(id);
-            if (files.length) {
-                const path_ids = [];
-                let has_files = false;
-                for (const { path, is_directory } of files) {
-                    if (is_directory)
-                        continue;
-                    has_files = true;
-                    const path_id = join(id, path);
-                    if (!existing_path_ids.has(path_id)) {
-                        existing_path_ids.add(path_id);
-                        path_ids.push(path_id);
-                    }
-                }
-                if (path_ids.length) {
-                    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);
-                    }
-                    resolved_input_files_by_input_path.set(input_path, resolved_input_files_for_input_path);
-                }
-                if (!has_files) {
-                    input_directories_with_no_files.push(resolved_input_path);
+            // Handle input paths that resolve to directories.
+            const files = 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);
                 }
-                // do callers ever need `input_directories_with_duplicate_files`?
+                handle_found(input_path, path_id);
             }
-            else {
-                input_directories_with_no_files.push(resolved_input_path);
+            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)) {
-            existing_path_ids.add(id);
-            const resolved_input_file = { id, input_path, resolved_input_path };
-            resolved_input_files.push(resolved_input_file);
-            resolved_input_files_by_input_path.set(input_path, [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_input_path,
         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)) {
@@ -204,6 +192,6 @@ export const resolve_input_files = (resolved_input_paths, custom_search_fs = sea
             }
             return map;
         }, new Map()),
-        input_directories_with_no_files,
+        input_directories_with_no_files: remaining.map((r) => r.input_path),
     };
 };

package/dist/input_path.test.js

@@ -92,25 +92,30 @@ test('get_possible_paths implied to be a directory by trailing slash', () => {
 });
 test('resolve_input_files', async () => {
     const test_files = {
-        'fake/test1.ext.ts': [{ id: '', path: 'fake/test1.ext.ts', is_directory: false }],
-        'fake/test2.ext.ts': [{ id: '', path: 'fake/test2.ext.ts', is_directory: false }],
+        'fake/test1.ext.ts': [
+            { id: 'fake/test1.ext.ts', path: 'fake/test1.ext.ts', is_directory: false },
+        ],
+        'fake/test2.ext.ts': [
+            { id: 'fake/test2.ext.ts', path: 'fake/test2.ext.ts', is_directory: false },
+        ],
         'fake/test3': [
-            { id: '', path: 'fake/test3', is_directory: true },
-            { id: '', path: 'a.ts', is_directory: false },
-            { id: '', path: 'b.ts', is_directory: false },
+            { id: 'fake/test3', path: 'fake/test3', is_directory: true },
+            { id: 'a.ts', path: 'a.ts', is_directory: false },
+            { id: 'b.ts', path: 'b.ts', is_directory: false },
         ],
         // duplicate
         'fake/': [
-            { id: '', path: 'fake/test3', is_directory: true },
-            { id: '', path: 'test3/a.ts', is_directory: false },
+            { id: 'fake/test3', path: 'fake/test3', is_directory: true },
+            { id: 'test3/a.ts', path: 'test3/a.ts', is_directory: false },
         ],
         // duplicate and not
         fake: [
-            { id: '', path: 'fake/test3', is_directory: true },
-            { id: '', path: 'test3/a.ts', is_directory: false },
-            { id: '', path: 'test3/c.ts', is_directory: false },
+            { id: 'fake/test3', path: 'fake/test3', is_directory: true },
+            { id: 'test3/a.ts', path: 'test3/a.ts', is_directory: false },
+            { id: 'test3/c.ts', path: 'test3/c.ts', is_directory: false },
         ],
-        'fake/nomatches': [{ id: '', path: 'fake/nomatches', is_directory: true }],
+        'fake/nomatches': [{ id: 'fake/nomatches', path: 'fake/nomatches', is_directory: true }],
+        fake2: [{ id: 'test.ext.ts', path: 'test.ext.ts', is_directory: false }],
     };
     const a = {
         id: 'fake/test1.ext.ts',
@@ -131,58 +136,70 @@ test('resolve_input_files', async () => {
         root_dir: process.cwd(),
     };
     const d = {
-        id: 'fake/',
+        id: 'fake',
         is_directory: true,
-        input_path: 'fake/',
+        input_path: 'fake',
         root_dir: process.cwd(),
     };
     const e = {
-        id: 'fake',
+        id: 'fake/nomatches',
         is_directory: true,
-        input_path: 'fake',
+        input_path: 'fake/nomatches',
         root_dir: process.cwd(),
     };
+    // These two have the same id from different directory input paths.
     const f = {
-        id: 'fake/nomatches',
+        id: 'fake2',
         is_directory: true,
-        input_path: 'fake/nomatches',
+        input_path: 'fake2',
+        root_dir: process.cwd(),
+    };
+    const g = {
+        id: 'fake2',
+        is_directory: true,
+        input_path: './fake2/',
+        root_dir: process.cwd(),
+    };
+    // These two have the same id from different file input paths.
+    const h = {
+        id: 'fake3/test.ext.ts',
+        is_directory: false,
+        input_path: 'fake3/test.ext.ts',
         root_dir: process.cwd(),
     };
-    const result = resolve_input_files([a, b, c, d, e, f], (id) => test_files[id]);
+    const i = {
+        id: 'fake3/test.ext.ts',
+        is_directory: false,
+        input_path: 'fake3/test',
+        root_dir: process.cwd(),
+    };
+    const result = resolve_input_files([a, b, c, d, e, f, g, h, i], (dir) => test_files[dir]);
     const resolved_input_files = [
         { id: a.id, input_path: a.input_path, resolved_input_path: a },
         { id: b.id, input_path: b.input_path, resolved_input_path: b },
         { id: 'fake/test3/a.ts', input_path: c.input_path, resolved_input_path: c },
         { id: 'fake/test3/b.ts', input_path: c.input_path, resolved_input_path: c },
-        { id: 'fake/test3/c.ts', input_path: e.input_path, resolved_input_path: e },
+        { id: 'fake/test3/c.ts', input_path: d.input_path, resolved_input_path: d },
+        { id: 'fake2/test.ext.ts', input_path: f.input_path, resolved_input_path: f },
+        { id: 'fake3/test.ext.ts', input_path: h.input_path, resolved_input_path: h },
     ];
     assert.equal(result, {
         resolved_input_files,
-        resolved_input_files_by_input_path: new Map([
-            ['fake/test1.ext.ts', [{ id: a.id, input_path: a.input_path, resolved_input_path: a }]],
-            ['fake/test2', [{ id: b.id, input_path: b.input_path, resolved_input_path: b }]],
-            [
-                'fake/test3',
-                [
-                    { id: 'fake/test3/a.ts', input_path: c.input_path, resolved_input_path: c },
-                    { id: 'fake/test3/b.ts', input_path: c.input_path, resolved_input_path: c },
-                ],
-            ],
-            ['fake', [{ id: 'fake/test3/c.ts', input_path: e.input_path, resolved_input_path: e }]],
-        ]),
         resolved_input_files_by_root_dir: new Map([
             [
                 process.cwd(),
                 [
-                    { id: 'fake/test1.ext.ts', input_path: 'fake/test1.ext.ts', resolved_input_path: a },
-                    { id: 'fake/test2.ext.ts', input_path: 'fake/test2', resolved_input_path: b },
-                    { id: 'fake/test3/a.ts', input_path: 'fake/test3', resolved_input_path: c },
-                    { id: 'fake/test3/b.ts', input_path: 'fake/test3', resolved_input_path: c },
-                    { id: 'fake/test3/c.ts', input_path: 'fake', resolved_input_path: e },
+                    { id: 'fake/test1.ext.ts', input_path: a.input_path, resolved_input_path: a },
+                    { id: 'fake/test2.ext.ts', input_path: b.input_path, resolved_input_path: b },
+                    { id: 'fake/test3/a.ts', input_path: c.input_path, resolved_input_path: c },
+                    { id: 'fake/test3/b.ts', input_path: c.input_path, resolved_input_path: c },
+                    { id: 'fake/test3/c.ts', input_path: d.input_path, resolved_input_path: d },
+                    { id: 'fake2/test.ext.ts', input_path: f.input_path, resolved_input_path: f },
+                    { id: 'fake3/test.ext.ts', input_path: h.input_path, resolved_input_path: h },
                 ],
             ],
         ]),
-        input_directories_with_no_files: [f],
+        input_directories_with_no_files: [e.input_path],
     });
 });
 test.run();

package/dist/package.js

@@ -1,7 +1,7 @@
 // generated by src/lib/package.gen.ts
 export const package_json = {
     name: '@ryanatkn/gro',
-    version: '0.121.1',
+    version: '0.123.0',
     description: 'task runner and toolkit extending SvelteKit',
     motto: 'generate, run, optimize',
     icon: '🌰',
@@ -33,10 +33,10 @@ export const package_json = {
     ],
     files: ['dist'],
     dependencies: {
-        '@ryanatkn/belt': '^0.20.10',
+        '@ryanatkn/belt': '^0.21.0',
         chokidar: '^3.6.0',
         dotenv: '^16.4.5',
-        'es-module-lexer': '^1.5.3',
+        'es-module-lexer': '^1.5.4',
         kleur: '^4.1.5',
         mri: '^1.2.0',
         prettier: '^3.3.2',
@@ -50,21 +50,21 @@ export const package_json = {
         '@changesets/changelog-git': '^0.2.0',
         '@changesets/types': '^6.0.0',
         '@ryanatkn/eslint-config': '^0.1.3',
-        '@ryanatkn/fuz': '^0.103.0',
-        '@ryanatkn/moss': '^0.4.0',
+        '@ryanatkn/fuz': '^0.104.1',
+        '@ryanatkn/moss': '^0.5.0',
         '@sveltejs/adapter-static': '^3.0.2',
         '@sveltejs/kit': '^2.5.17',
         '@sveltejs/package': '^2.3.2',
         '@sveltejs/vite-plugin-svelte': '^3.1.1',
         '@types/fs-extra': '^11.0.4',
         '@types/node': '^20.14.8',
-        '@typescript-eslint/eslint-plugin': '^7.13.1',
-        '@typescript-eslint/parser': '^7.13.1',
+        '@typescript-eslint/eslint-plugin': '^7.14.1',
+        '@typescript-eslint/parser': '^7.14.1',
         esbuild: '^0.20.2',
         eslint: '^8.57.0',
-        'eslint-plugin-svelte': '^2.40.0',
+        'eslint-plugin-svelte': '^2.41.0',
         svelte: '^5.0.0-next.164',
-        'svelte-check': '^3.8.1',
+        'svelte-check': '^3.8.2',
         typescript: '^5.5.2',
         uvu: '^0.5.6',
     },
@@ -256,7 +256,7 @@ export const package_json = {
 };
 export const src_json = {
     name: '@ryanatkn/gro',
-    version: '0.121.1',
+    version: '0.123.0',
     modules: {
         '.': {
             path: 'index.ts',

package/dist/path_constants.js

@@ -8,7 +8,7 @@ If any of these become customizable from SvelteKit or Gro's configs, move them t
 export const SOURCE_DIRNAME = 'src';
 export const GRO_DIRNAME = '.gro';
 export const GRO_DIST_PREFIX = 'dist_'; //
-export const SERVER_DIST_PATH = 'dist_server'; // TODO should all of these be `_PATH` or should this be `DIRNAME`?
+export const SERVER_DIST_PATH = 'dist_server'; // TODO should all of these be `_PATH` or should this be `DIRNAME`? also, add `_PLUGIN` to this name?
 export const GRO_DEV_DIRNAME = GRO_DIRNAME + '/dev';
 export const SOURCE_DIR = SOURCE_DIRNAME + '/';
 export const GRO_DIR = GRO_DIRNAME + '/';

package/dist/resolve.task.js

@@ -7,7 +7,7 @@ export const Args = z
 })
     .strict();
 export const task = {
-    summary: 'diagnostic that logs the info resolved from the filesystem for the given input paths',
+    summary: 'diagnostic that logs resolved filesystem info for the given input paths',
     Args,
     run: async ({ args, config, log }) => {
         const { _ } = args;

package/dist/task.d.ts

@@ -26,7 +26,7 @@ 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: Path_Id, task_root_dir: Path_Id) => string;
+export declare const to_task_name: (id: Path_Id, task_root_dir: Path_Id, input_path: Input_Path, root_path: Path_Id) => string;
 /**
  * This is used by tasks to signal a known failure.
  * It's useful for cleaning up logging because
@@ -41,10 +41,8 @@ export interface Found_Task {
 }
 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[];
 }
@@ -55,18 +53,15 @@ 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[];
+    input_directories_with_no_files: 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[];
@@ -89,5 +84,5 @@ 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 load_tasks: (found_tasks: Found_Tasks, root_path?: Path_Id) => Promise<Load_Tasks_Result>;
 export declare const validate_task_module: (mod: Record<string, any>) => mod is Task_Module;

package/dist/task.js

@@ -1,5 +1,6 @@
 import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
 import { red } from 'kleur/colors';
+import { isAbsolute, join, relative } from 'node:path';
 import { resolve_input_files, resolve_input_paths, } from './input_path.js';
 import { print_path } from './paths.js';
 import { search_fs } from './search_fs.js';
@@ -8,13 +9,16 @@ 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_dir) => {
+export const to_task_name = (id, task_root_dir, input_path, root_path) => {
     let task_name = id.startsWith(task_root_dir)
         ? strip_start(strip_start(id, task_root_dir), '/')
         : id;
     for (const suffix of TASK_FILE_SUFFIXES) {
         task_name = strip_end(task_name, suffix);
     }
+    if (isAbsolute(input_path)) {
+        return relative(root_path, join(input_path, task_name));
+    }
     return task_name;
 };
 /**
@@ -30,7 +34,7 @@ export class Task_Error extends Error {
 export const find_tasks = (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 } = resolve_input_paths(input_paths, task_root_dirs, TASK_FILE_SUFFIXES);
+    const { resolved_input_paths, unmapped_input_paths } = 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) {
@@ -39,7 +43,6 @@ export const find_tasks = (input_paths, task_root_dirs, config, timings) => {
             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.`)),
@@ -47,7 +50,7 @@ export const find_tasks = (input_paths, task_root_dirs, config, timings) => {
     }
     // 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, } = resolve_input_files(resolved_input_paths, (id) => search_fs(id, {
+    const { resolved_input_files, resolved_input_files_by_root_dir, input_directories_with_no_files } = resolve_input_files(resolved_input_paths, (id) => search_fs(id, {
         filter: config.search_filters,
         file_filter: (p) => TASK_FILE_SUFFIXES.some((s) => p.endsWith(s)),
     }));
@@ -59,33 +62,29 @@ export const find_tasks = (input_paths, task_root_dirs, config, timings) => {
             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)}`)),
+            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) => {
+export const load_tasks = async (found_tasks, root_path = process.cwd()) => {
     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),
+        name: to_task_name(resolved_input_file.id, resolved_input_file.resolved_input_path.root_dir, resolved_input_file.resolved_input_path.input_path, root_path),
     }));
     if (!loaded_modules.ok) {
         return loaded_modules;

package/dist/task.test.js

@@ -12,12 +12,15 @@ 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', 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');
+    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('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b/d'), '../c/foo');
+    assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b'), 'c/foo');
+    assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.121.1",
+  "version": "0.123.0",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "icon": "🌰",
@@ -45,10 +45,10 @@
     "dist"
   ],
   "dependencies": {
-    "@ryanatkn/belt": "^0.20.10",
+    "@ryanatkn/belt": "^0.21.0",
     "chokidar": "^3.6.0",
     "dotenv": "^16.4.5",
-    "es-module-lexer": "^1.5.3",
+    "es-module-lexer": "^1.5.4",
     "kleur": "^4.1.5",
     "mri": "^1.2.0",
     "prettier": "^3.3.2",
@@ -65,21 +65,21 @@
     "@changesets/changelog-git": "^0.2.0",
     "@changesets/types": "^6.0.0",
     "@ryanatkn/eslint-config": "^0.1.3",
-    "@ryanatkn/fuz": "^0.103.0",
-    "@ryanatkn/moss": "^0.4.0",
+    "@ryanatkn/fuz": "^0.104.1",
+    "@ryanatkn/moss": "^0.5.0",
     "@sveltejs/adapter-static": "^3.0.2",
     "@sveltejs/kit": "^2.5.17",
     "@sveltejs/package": "^2.3.2",
     "@sveltejs/vite-plugin-svelte": "^3.1.1",
     "@types/fs-extra": "^11.0.4",
     "@types/node": "^20.14.8",
-    "@typescript-eslint/eslint-plugin": "^7.13.1",
-    "@typescript-eslint/parser": "^7.13.1",
+    "@typescript-eslint/eslint-plugin": "^7.14.1",
+    "@typescript-eslint/parser": "^7.14.1",
     "esbuild": "^0.20.2",
     "eslint": "^8.57.0",
-    "eslint-plugin-svelte": "^2.40.0",
+    "eslint-plugin-svelte": "^2.41.0",
     "svelte": "^5.0.0-next.164",
-    "svelte-check": "^3.8.1",
+    "svelte-check": "^3.8.2",
     "typescript": "^5.5.2",
     "uvu": "^0.5.6"
   },