@ryanatkn/gro 0.116.2 → 0.117.0

package/dist/input_path.test.js

@@ -1,68 +1,47 @@
-import { suite } from 'uvu';
+import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { resolve } from 'node:path';
-import { resolve_input_path, resolve_input_paths, load_source_ids_by_input_path, get_possible_source_ids, } from './input_path.js';
-import { paths } from './paths.js';
-/* test__resolve_input_path */
-const test__resolve_input_path = suite('resolve_input_path');
-test__resolve_input_path('basic behavior', () => {
-    const target = resolve('dist/foo/bar.ts');
-    assert.is(resolve_input_path('foo/bar.ts'), target);
-    assert.is(resolve_input_path('src/lib/foo/bar.ts'), target);
-    assert.is(resolve_input_path('./src/lib/foo/bar.ts'), target);
-    assert.is(resolve_input_path('./foo/bar.ts'), target); // questionable
-    assert.is(resolve_input_path(target), target);
-    assert.is.not(resolve_input_path('bar.ts'), target);
+import { to_input_path, to_input_paths, load_source_ids_by_input_path, get_possible_source_ids, } from './input_path.js';
+import { GRO_DIST_DIR, paths } from './paths.js';
+test('to_input_path', () => {
+    assert.is(to_input_path(resolve('foo.ts')), resolve('foo.ts'));
+    assert.is(to_input_path('./foo.ts'), resolve('foo.ts'));
+    assert.is(to_input_path('foo.ts'), 'foo.ts');
+    assert.is(to_input_path('gro/foo'), GRO_DIST_DIR + 'foo');
+    // trailing slashes are preserved:
+    assert.is(to_input_path(resolve('foo/bar/')), resolve('foo/bar/'));
+    assert.is(to_input_path('./foo/bar/'), resolve('foo/bar/'));
+    assert.is(to_input_path('foo/bar/'), 'foo/bar/');
 });
-test__resolve_input_path('directories', () => {
-    const target_dir = resolve('dist/foo/bar');
-    assert.is(resolve_input_path('foo/bar'), target_dir);
-    assert.is(resolve_input_path('foo/bar/'), target_dir);
-    assert.is(resolve_input_path('./foo/bar'), target_dir);
-    assert.is(resolve_input_path('./foo/bar/'), target_dir);
-    assert.is.not(resolve_input_path('bar'), target_dir);
-});
-test__resolve_input_path.run();
-/* test__resolve_input_path */
-/* test__resolve_input_paths */
-const test__resolve_input_paths = suite('resolve_input_paths');
-test__resolve_input_paths('resolves multiple input path forms', () => {
-    assert.equal(resolve_input_paths(['foo/bar.ts', 'baz', './']), [
-        resolve('dist/foo/bar.ts'),
-        resolve('dist/baz'),
-        resolve('dist') + '/',
+test('to_input_paths', () => {
+    assert.equal(to_input_paths([resolve('foo/bar.ts'), './baz', 'foo']), [
+        resolve('foo/bar.ts'),
+        resolve('baz'),
+        'foo',
     ]);
 });
-test__resolve_input_paths.run();
-/* test__resolve_input_paths */
-/* test__get_possible_source_ids */
-const test__get_possible_source_ids = suite('get_possible_source_ids');
-test__get_possible_source_ids('in the gro directory', () => {
+test('get_possible_source_ids in the gro directory', () => {
     const input_path = resolve('src/foo/bar');
     assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [
         input_path,
         input_path + '.baz.ts',
-        input_path + '/bar.baz.ts',
     ]);
 });
-test__get_possible_source_ids('does not repeat the extension', () => {
+test('get_possible_source_ids does not repeat the extension', () => {
     const input_path = resolve('src/foo/bar.baz.ts');
     assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [input_path]);
 });
-test__get_possible_source_ids('does not repeat with the same root directory', () => {
+test('get_possible_source_ids does not repeat with the same root directory', () => {
     const input_path = resolve('src/foo/bar.baz.ts');
     assert.equal(get_possible_source_ids(input_path, ['.baz.ts'], [paths.root, paths.root]), [
         input_path,
     ]);
 });
-test__get_possible_source_ids('implied to be a directory by trailing slash', () => {
+test('get_possible_source_ids implied to be a directory by trailing slash', () => {
     const input_path = resolve('src/foo/bar') + '/';
     assert.equal(get_possible_source_ids(input_path, ['.baz.ts']), [input_path]);
 });
-test__get_possible_source_ids.run();
-/* test__get_possible_source_ids */
-/* test__load_source_ids_by_input_path */
-const test__load_source_ids_by_input_path = suite('load_source_ids_by_input_path', async () => {
+test('load_source_ids_by_input_path', async () => {
     const test_files = {
         'fake/test1.bar.ts': new Map([['fake/test1.bar.ts', { isDirectory: () => false }]]),
         'fake/test2.bar.ts': new Map([['fake/test2.bar.ts', { isDirectory: () => false }]]),
@@ -102,5 +81,4 @@ const test__load_source_ids_by_input_path = suite('load_source_ids_by_input_path
         input_directories_with_no_files: ['fake/nomatches'],
     });
 });
-test__load_source_ids_by_input_path.run();
-/* test__load_source_ids_by_input_path */
+test.run();

package/dist/invoke_task.d.ts

@@ -17,4 +17,4 @@ import type { Gro_Config } from './config.js';
  * there are some subtle differences in the complex logical branches.
  * The comments describe each condition.
  */
-export declare const invoke_task: (task_name: string, args: Args, config: Gro_Config, timings?: any) => Promise<void>;
+export declare const invoke_task: (task_name: Flavored<string, "Raw_Input_Path">, args: Args, config: Gro_Config, timings?: any) => Promise<void>;

package/dist/invoke_task.js

@@ -1,17 +1,15 @@
 import { cyan, red, gray } from 'kleur/colors';
-import { Logger, System_Logger, print_log_label } from '@ryanatkn/belt/log.js';
+import { System_Logger, print_log_label } from '@ryanatkn/belt/log.js';
 import { create_stopwatch, Timings } from '@ryanatkn/belt/timings.js';
 import { print_ms, print_timings } from '@ryanatkn/belt/print.js';
 import { to_forwarded_args } from './args.js';
 import { run_task } from './run_task.js';
-import { resolve_input_path } from './input_path.js';
-import { is_task_path } from './task.js';
-import { is_gro_id, is_this_project_gro, print_path, print_path_or_gro_path, gro_sveltekit_dist_dir, to_gro_input_path, } from './paths.js';
-import { find_modules, load_modules } from './modules.js';
+import { to_input_path, Raw_Input_Path } from './input_path.js';
+import { is_gro_id, IS_THIS_GRO, print_path, print_path_or_gro_path } from './paths.js';
+import { load_modules } from './modules.js';
 import { find_task_modules, load_task_module } from './task_module.js';
 import { load_gro_package_json } from './package_json.js';
-import { log_available_tasks, log_error_reasons } from './print_task.js';
-import { search_fs } from './search_fs.js';
+import { log_tasks, log_error_reasons, log_gro_package_tasks } from './task_logging.js';
 /**
  * Invokes Gro tasks by name using the filesystem as the source.
  *
@@ -33,6 +31,10 @@ export const invoke_task = async (task_name, args, config, timings = new Timings
     const log = new System_Logger(print_log_label(task_name || 'gro'));
     log.info('invoking', task_name ? cyan(task_name) : 'gro');
     const total_timing = create_stopwatch();
+    const finish = () => {
+        print_timings(timings, log);
+        log.info(`🕒 ${print_ms(total_timing())}`);
+    };
     // Check if the caller just wants to see the version.
     if (!task_name && (args.version || args.v)) {
         const gro_package_json = await load_gro_package_json();
@@ -41,100 +43,89 @@ export const invoke_task = async (task_name, args, config, timings = new Timings
         return;
     }
     // Resolve the input path for the provided task name.
-    const input_path = resolve_input_path(task_name);
+    const input_path = to_input_path(task_name);
     // Find the task or directory specified by the `input_path`.
     // Fall back to searching the Gro directory as well.
-    const find_modules_result = await find_task_modules([input_path], undefined, [
-        gro_sveltekit_dist_dir,
-    ]);
-    if (find_modules_result.ok) {
-        // Found a match either in the current working directory or Gro's directory.
-        const path_data = find_modules_result.source_id_path_data_by_input_path.get(input_path); // this is null safe because result is ok
-        if (!path_data.isDirectory) {
-            // The input path matches a file, so load and run it.
-            // Try to load the task module.
-            const load_modules_result = await load_modules(find_modules_result.source_ids_by_input_path, load_task_module);
-            if (load_modules_result.ok) {
-                // We found a task module. Run it!
-                // `path_data` is not a directory, so there's a single task module here.
-                const task = load_modules_result.modules[0];
-                log.info(`→ ${cyan(task.name)} ${(task.mod.task.summary && gray(task.mod.task.summary)) || ''}`);
-                const timing_to_run_task = timings.start('run task ' + task_name);
-                const result = await run_task(task, { ...args, ...to_forwarded_args(`gro ${task.name}`) }, invoke_task, config, timings);
-                timing_to_run_task();
-                if (result.ok) {
-                    log.info(`✓ ${cyan(task.name)}`);
-                }
-                else {
-                    log.info(`${red('🞩')} ${cyan(task.name)}`);
-                    log_error_reasons(log, [result.reason]);
-                    throw result.error;
-                }
+    const find_modules_result = await find_task_modules([input_path], config.task_root_paths);
+    if (!find_modules_result.ok) {
+        if (find_modules_result.type === 'input_directories_with_no_files') {
+            // The input path matched a directory, but it contains no matching files.
+            if (IS_THIS_GRO ||
+                // this is null safe because of the failure type
+                is_gro_id(find_modules_result.source_id_path_data_by_input_path.get(input_path).id)) {
+                // If the directory is inside Gro, just log the errors.
+                log_error_reasons(log, find_modules_result.reasons);
+                process.exit(1);
             }
             else {
-                log_error_reasons(log, load_modules_result.reasons);
-                process.exit(1);
+                // If there's a matching directory in the current working directory,
+                // but it has no matching files, we still want to search Gro's directory.
+                const gro_dir_find_modules_result = await log_gro_package_tasks(input_path, log);
+                // TODO this doesn't seem to be working as commented, test this condition in another repo (maybe like "gro sync" when there's a "src/lib/sync" folder)
+                if (!gro_dir_find_modules_result.ok) {
+                    // Log the original errors, not the Gro-specific ones.
+                    log_error_reasons(log, find_modules_result.reasons);
+                    process.exit(1);
+                }
+                finish();
+                return;
             }
         }
         else {
-            // The input path matches a directory. Log the tasks but don't run them.
-            if (is_this_project_gro) {
-                // Is the Gro directory the same as the cwd? Log the matching files.
-                await log_available_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path);
-            }
-            else if (is_gro_id(path_data.id)) {
-                // TODO delete this?
-                // Does the Gro directory contain the matching files? Log them.
-                await log_available_tasks(log, print_path_or_gro_path(path_data.id), find_modules_result.source_ids_by_input_path);
+            // Some unknown find modules result failure happened, so log it out.
+            // (currently, just "unmapped_input_paths")
+            log_error_reasons(log, find_modules_result.reasons);
+            process.exit(1);
+        }
+    }
+    // Found a match either in the current working directory or Gro's directory.
+    const path_data = find_modules_result.source_id_path_data_by_input_path.get(input_path); // this is null safe because result is ok
+    if (!path_data.isDirectory) {
+        // The input path matches a file, so load and run it.
+        // Try to load the task module.
+        const load_modules_result = await load_modules(find_modules_result.source_ids_by_input_path, load_task_module);
+        if (load_modules_result.ok) {
+            // We found a task module. Run it!
+            // `path_data` is not a directory, so there's a single task module here.
+            const task = load_modules_result.modules[0];
+            log.info(`→ ${cyan(task.name)} ${(task.mod.task.summary && gray(task.mod.task.summary)) || ''}`);
+            const timing_to_run_task = timings.start('run task ' + task_name);
+            const result = await run_task(task, { ...args, ...to_forwarded_args(`gro ${task.name}`) }, invoke_task, config, timings);
+            timing_to_run_task();
+            if (result.ok) {
+                log.info(`✓ ${cyan(task.name)}`);
             }
             else {
-                // The Gro directory is not the same as the cwd
-                // and it doesn't contain the matching files.
-                // Find all of the possible matches in the Gro directory as well,
-                // and log everything out.
-                // Ignore any errors - the directory may not exist or have any files!
-                const gro_dir_find_modules_result = await to_gro_dir_find_modules_result(input_path, log);
-                // Then log the current working directory matches.
-                await log_available_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path, !gro_dir_find_modules_result.ok);
+                log.info(`${red('🞩')} ${cyan(task.name)}`);
+                log_error_reasons(log, [result.reason]);
+                throw result.error;
             }
         }
-    }
-    else if (find_modules_result.type === 'input_directories_with_no_files') {
-        // The input path matched a directory, but it contains no matching files.
-        if (is_this_project_gro ||
-            // this is null safe because of the failure type
-            is_gro_id(find_modules_result.source_id_path_data_by_input_path.get(input_path).id)) {
-            // If the directory is inside Gro, just log the errors.
-            log_error_reasons(log, find_modules_result.reasons);
-            process.exit(1);
-        }
         else {
-            // If there's a matching directory in the current working directory,
-            // but it has no matching files, we still want to search Gro's directory.
-            const gro_dir_find_modules_result = await to_gro_dir_find_modules_result(input_path, log);
-            if (!gro_dir_find_modules_result.ok) {
-                // Log the original errors, not the Gro-specific ones.
-                log_error_reasons(log, find_modules_result.reasons);
-                process.exit(1);
-            }
+            log_error_reasons(log, load_modules_result.reasons);
+            process.exit(1);
         }
     }
     else {
-        // Some other find modules result failure happened, so log it out.
-        // (currently, just "unmapped_input_paths")
-        log_error_reasons(log, find_modules_result.reasons);
-        process.exit(1);
-    }
-    print_timings(timings, log);
-    log.info(`🕒 ${print_ms(total_timing())}`);
-};
-const to_gro_dir_find_modules_result = async (input_path, 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_available_tasks(log, print_path_or_gro_path(gro_path_data.id), gro_dir_find_modules_result.source_ids_by_input_path);
+        // The input path matches a directory. Log the tasks but don't run them.
+        if (IS_THIS_GRO) {
+            // Is the Gro directory the same as the cwd? Log the matching files.
+            await log_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path);
+        }
+        else if (is_gro_id(path_data.id)) {
+            // TODO delete this? merge behavior with the block above/below?
+            // Does the Gro directory contain the matching files? Log them.
+            await log_tasks(log, print_path_or_gro_path(path_data.id), find_modules_result.source_ids_by_input_path);
+        }
+        else {
+            // The Gro directory is not the same as the cwd and it doesn't contain the matching files.
+            // Find all of the possible matches in both the current project and the Gro directory,
+            // and log everything out.
+            // Ignore any errors - the directory may not exist or have any files!
+            const gro_dir_find_modules_result = await log_gro_package_tasks(input_path, log);
+            // Then log the current working directory matches.
+            await log_tasks(log, print_path(path_data.id), find_modules_result.source_ids_by_input_path, !gro_dir_find_modules_result.ok);
+        }
     }
-    return gro_dir_find_modules_result;
+    finish();
 };

package/dist/modules.d.ts

@@ -1,4 +1,5 @@
 import type { Result } from '@ryanatkn/belt/result.js';
+import { Input_Path } from './input_path.js';
 import type { Path_Data } from './path.js';
 import { type Source_Id } from './paths.js';
 export interface Module_Meta<T_Module extends Record<string, any> = Record<string, any>> {
@@ -22,19 +23,19 @@ export type Load_Module_Failure = {
 };
 export declare const load_module: <T extends Record<string, any>>(id: string, validate?: (mod: Record<string, any>) => mod is T) => Promise<Load_Module_Result<Module_Meta<T>>>;
 export type Find_Modules_Result = Result<{
-    source_ids_by_input_path: Map<string, string[]>;
-    source_id_path_data_by_input_path: Map<string, Path_Data>;
+    source_ids_by_input_path: Map<Input_Path, Source_Id[]>;
+    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
 }, Find_Modules_Failure>;
 export type Find_Modules_Failure = {
     type: 'unmapped_input_paths';
-    source_id_path_data_by_input_path: Map<string, Path_Data>;
-    unmapped_input_paths: string[];
+    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
+    unmapped_input_paths: Input_Path[];
     reasons: string[];
 } | {
     type: 'input_directories_with_no_files';
-    source_ids_by_input_path: Map<string, string[]>;
-    source_id_path_data_by_input_path: Map<string, Path_Data>;
-    input_directories_with_no_files: string[];
+    source_ids_by_input_path: Map<Input_Path, Source_Id[]>;
+    source_id_path_data_by_input_path: Map<Input_Path, Path_Data>;
+    input_directories_with_no_files: Input_Path[];
     reasons: string[];
 };
 export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<{
@@ -45,5 +46,8 @@ export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<{
     reasons: string[];
     modules: T_Module_Meta[];
 }>;
-export declare const find_modules: (input_paths: string[], custom_search_fs?: (dir: string, options?: import("./search_fs.js").Search_Fs_Options) => Promise<Map<string, import("./path.js").Path_Stats>>, get_possible_source_ids?: (input_path: string) => string[], timings?: any) => Promise<Find_Modules_Result>;
-export declare const load_modules: <Module_Type extends Record<string, any>, T_Module_Meta extends Module_Meta<Module_Type>>(source_ids_by_input_path: Map<string, string[]>, load_module_by_id: (source_id: Source_Id) => Promise<Load_Module_Result<T_Module_Meta>>, timings?: any) => Promise<Load_Modules_Result<T_Module_Meta>>;
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
+export declare const find_modules: (input_paths: Input_Path[], custom_search_fs?: (dir: string, options?: import("./search_fs.js").Search_Fs_Options) => Promise<Map<string, import("./path.js").Path_Stats>>, get_possible_source_ids?: (input_path: Input_Path) => Source_Id[], timings?: any) => Promise<Find_Modules_Result>;
+export declare const load_modules: <Module_Type extends Record<string, any>, T_Module_Meta extends Module_Meta<Module_Type>>(source_ids_by_input_path: Map<Input_Path, Source_Id[]>, load_module_by_id: (source_id: Source_Id) => Promise<Load_Module_Result<T_Module_Meta>>, timings?: any) => Promise<Load_Modules_Result<T_Module_Meta>>;

package/dist/modules.js

@@ -1,7 +1,7 @@
 import { red } from 'kleur/colors';
 import { Unreachable_Error } from '@ryanatkn/belt/error.js';
 import { print_error } from '@ryanatkn/belt/print.js';
-import { load_source_path_data_by_input_path, load_source_ids_by_input_path } from './input_path.js';
+import { load_source_path_data_by_input_path, load_source_ids_by_input_path, Input_Path, } from './input_path.js';
 import { paths_from_id, print_path, print_path_or_gro_path } from './paths.js';
 import { search_fs } from './search_fs.js';
 export const load_module = async (id, validate) => {
@@ -17,11 +17,9 @@ export const load_module = async (id, validate) => {
     }
     return { ok: true, mod: { id, mod } };
 };
-/*
-
-Finds modules from input paths. (see `src/lib/input_path.ts` for more)
-
-*/
+/**
+ * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+ */
 export const find_modules = async (input_paths, custom_search_fs = search_fs, get_possible_source_ids, timings) => {
     // Check which extension variation works - if it's a directory, prefer others first!
     const timing_to_map_input_paths = timings?.start('map input paths');
@@ -53,13 +51,7 @@ export const find_modules = async (input_paths, custom_search_fs = search_fs, ge
         }
         : { ok: true, source_ids_by_input_path, source_id_path_data_by_input_path };
 };
-/*
-
-Load modules by source id.
-
-TODO parallelize, originally it needed to be serial for a specific usecase we no longer have
-
-*/
+// TODO parallelize, originally it needed to be serial for a specific usecase we no longer have
 export const load_modules = async (source_ids_by_input_path, // TODO maybe make this a flat array and remove `input_path`?
 load_module_by_id, timings) => {
     const timing_to_load_modules = timings?.start('load modules');

package/dist/package.d.ts

@@ -302,10 +302,6 @@ export declare const package_json: {
             default: string;
             types: string;
         };
-        './print_task.js': {
-            default: string;
-            types: string;
-        };
         './publish.task.js': {
             default: string;
             types: string;
@@ -382,6 +378,10 @@ export declare const package_json: {
             default: string;
             types: string;
         };
+        './task_logging.js': {
+            default: string;
+            types: string;
+        };
         './task_module.js': {
             default: string;
             types: string;
@@ -775,13 +775,6 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
-        './print_task.js': {
-            path: string;
-            declarations: {
-                name: string;
-                kind: string;
-            }[];
-        };
         './publish.task.js': {
             path: string;
             declarations: {
@@ -915,6 +908,13 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
+        './task_logging.js': {
+            path: string;
+            declarations: {
+                name: string;
+                kind: string;
+            }[];
+        };
         './task_module.js': {
             path: string;
             declarations: never[];

package/dist/package.gen.js

@@ -1,5 +1,5 @@
 import { load_package_json } from './package_json.js';
-import { is_this_project_gro, to_root_path } from './paths.js';
+import { IS_THIS_GRO, to_root_path } from './paths.js';
 import { create_src_json } from './src_json.js';
 // TODO rename? `Package_Json + Src_Json = package.ts` currently, idk
 // TODO consider an api that uses magic imports like SvelteKit's `$app`, like `$repo/package.json`
@@ -14,8 +14,8 @@ export const gen = async ({ origin_id }) => {
     return `
 // generated by ${to_root_path(origin_id)}
 
-import type {Package_Json} from '${is_this_project_gro ? './package_json.js' : '@ryanatkn/gro/package_json.js'}';
-import type {Src_Json} from '${is_this_project_gro ? './src_json.js' : '@ryanatkn/gro/src_json.js'}';
+import type {Package_Json} from '${IS_THIS_GRO ? './package_json.js' : '@ryanatkn/gro/package_json.js'}';
+import type {Src_Json} from '${IS_THIS_GRO ? './src_json.js' : '@ryanatkn/gro/src_json.js'}';
 
 export const package_json = ${JSON.stringify(package_json)} satisfies Package_Json;