@ryanatkn/gro 0.117.0 → 0.118.0

package/dist/sveltekit_config.js

@@ -1,11 +1,15 @@
 import { join } from 'node:path';
-import { cwd } from 'node:process';
-import { SVELTEKIT_CONFIG_FILENAME } from './paths.js';
+import { SVELTEKIT_CONFIG_FILENAME } from './path_constants.js';
+/*
+
+This module is intended to have minimal dependencies to avoid over-imports in the CLI.
+
+*/
 /**
  * Loads a SvelteKit config at `dir`.
- * @returns
+ * @returns `null` if no config is found
  */
-export const load_sveltekit_config = async (dir = cwd()) => {
+export const load_sveltekit_config = async (dir = process.cwd()) => {
     try {
         return (await import(join(dir, SVELTEKIT_CONFIG_FILENAME))).default;
     }
@@ -19,7 +23,7 @@ export const load_sveltekit_config = async (dir = cwd()) => {
  * as a convenience wrapper around `load_sveltekit_config`.
  * Needed because SvelteKit doesn't expose its config resolver.
  */
-export const init_sveltekit_config = async (dir_or_config = cwd()) => {
+export const init_sveltekit_config = async (dir_or_config = process.cwd()) => {
     const sveltekit_config = typeof dir_or_config === 'string' ? await load_sveltekit_config(dir_or_config) : dir_or_config;
     const kit = sveltekit_config?.kit;
     const alias = kit?.alias;

package/dist/sveltekit_config_global.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The parsed SvelteKit config for the cwd, cached globally at the module level.
+ */
+export declare const sveltekit_config_global: import("./sveltekit_config.js").Parsed_Sveltekit_Config;

package/dist/sveltekit_config_global.js

@@ -0,0 +1,5 @@
+import { init_sveltekit_config } from './sveltekit_config.js';
+/**
+ * The parsed SvelteKit config for the cwd, cached globally at the module level.
+ */
+export const sveltekit_config_global = await init_sveltekit_config(); // always load it to keep things simple ahead

package/dist/sveltekit_helpers.d.ts

@@ -0,0 +1,4 @@
+import { Package_Json } from './package_json.js';
+import type { Parsed_Sveltekit_Config } from './sveltekit_config.js';
+export declare const has_sveltekit_app: () => Promise<boolean>;
+export declare const has_sveltekit_library: (package_json?: Package_Json, sveltekit_config?: Parsed_Sveltekit_Config) => Promise<boolean>;

package/dist/sveltekit_helpers.js

@@ -0,0 +1,12 @@
+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 } from './path_constants.js';
+export const has_sveltekit_app = () => exists(SVELTEKIT_CONFIG_FILENAME);
+export const has_sveltekit_library = async (package_json, sveltekit_config = sveltekit_config_global) => {
+    if (!(await has_sveltekit_app()) || !(await exists(sveltekit_config.lib_path))) {
+        return false;
+    }
+    const p = package_json ?? (await load_package_json());
+    return !!p.devDependencies?.['@sveltejs/package'] || !!p.dependencies?.['@sveltejs/package'];
+};

package/dist/sync.task.js

@@ -20,7 +20,10 @@ export const task = {
     run: async ({ args, invoke_task, config, log }) => {
         const { sveltekit, package_json, gen, install } = args;
         if (install) {
-            await spawn('npm', ['i']);
+            const result = await spawn('npm', ['i']);
+            if (!result.ok) {
+                throw new Task_Error('failed npm install');
+            }
         }
         if (sveltekit) {
             await sveltekit_sync();

package/dist/task.d.ts

@@ -19,7 +19,7 @@ export interface Task_Context<T_Args = object> {
 export declare const TASK_FILE_SUFFIX_TS = ".task.ts";
 export declare const TASK_FILE_SUFFIX_JS = ".task.js";
 export declare const is_task_path: (path: string) => boolean;
-export declare const to_task_name: (id: Flavored<string, "Source_Id">) => string;
+export declare const to_task_name: (id: Flavored<string, "Source_Id">, task_root_paths: string[]) => string;
 /**
  * This is used by tasks to signal a known failure.
  * It's useful for cleaning up logging because

package/dist/task.js

@@ -1,13 +1,17 @@
-import { strip_end } from '@ryanatkn/belt/string.js';
-import { import_id_to_lib_path } from './paths.js';
+import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
 export const TASK_FILE_SUFFIX_TS = '.task.ts';
 export const TASK_FILE_SUFFIX_JS = '.task.js';
 export const is_task_path = (path) => path.endsWith(TASK_FILE_SUFFIX_TS) || path.endsWith(TASK_FILE_SUFFIX_JS);
-// TODO use task root paths? what's the right behavior?
-export const to_task_name = (id) => {
-    const lib_path = import_id_to_lib_path(id);
-    const name = strip_end(strip_end(lib_path, TASK_FILE_SUFFIX_TS), TASK_FILE_SUFFIX_JS);
-    return name;
+export const to_task_name = (id, task_root_paths) => {
+    let base_path = id;
+    // If the id is in any of the task root paths, use the first match and strip it.
+    for (const task_root_path of task_root_paths) {
+        if (id.startsWith(task_root_path)) {
+            base_path = strip_start(strip_start(id, task_root_path), '/');
+            break;
+        }
+    }
+    return strip_end(strip_end(base_path, TASK_FILE_SUFFIX_TS), TASK_FILE_SUFFIX_JS);
 };
 /**
  * This is used by tasks to signal a known failure.

package/dist/task.test.js

@@ -1,22 +1,18 @@
-import { suite } from 'uvu';
+import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { is_task_path, to_task_name } from './task.js';
-/* test__is_task_path */
-const test__is_task_path = suite('is_task_path');
-test__is_task_path('basic behavior', () => {
+test('is_task_path basic behavior', () => {
     assert.ok(is_task_path('foo.task.ts'));
     assert.ok(is_task_path('foo.task.js'));
     assert.ok(!is_task_path('foo.ts'));
     assert.ok(is_task_path('bar/baz/foo.task.ts'));
     assert.ok(!is_task_path('bar/baz/foo.ts'));
 });
-test__is_task_path.run();
-/* test__is_task_path */
-/* test__to_task_name */
-const test__to_task_name = suite('to_task_name');
-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');
+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');
 });
-test__to_task_name.run();
-/* test__to_task_name */
+test.run();

package/dist/task_logging.d.ts

@@ -2,7 +2,7 @@ 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[]>, log_intro?: boolean) => Promise<void>;
-export declare const log_gro_package_tasks: (input_path: Flavored<string, "Input_Path">, log: Logger) => Promise<Find_Modules_Result>;
+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>;
 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

@@ -8,11 +8,11 @@ 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, log_intro = true) => {
+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, load_task_module);
+        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);
@@ -33,13 +33,13 @@ export const log_tasks = async (log, dir_label, source_ids_by_input_path, log_in
         log.info(`No tasks found in ${dir_label}.`);
     }
 };
-export const log_gro_package_tasks = async (input_path, log) => {
+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);
+        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;
 };

package/dist/task_module.d.ts

@@ -8,8 +8,8 @@ export interface Task_Module_Meta extends Module_Meta<Task_Module> {
     name: string;
 }
 export declare const validate_task_module: (mod: Record<string, any>) => mod is Task_Module;
-export declare const load_task_module: (id: string) => Promise<Load_Module_Result<Task_Module_Meta>>;
-export declare const find_task_modules: (input_paths: Input_Path[], root_dirs?: string[]) => Promise<ReturnType<typeof find_modules>>;
-export declare const load_task_modules: (input_paths: Input_Path[], root_dirs?: string[]) => Promise<ReturnType<typeof load_modules<Task_Module, Task_Module_Meta>> | ({
+export declare const load_task_module: (id: string, task_root_paths: string[]) => Promise<Load_Module_Result<Task_Module_Meta>>;
+export declare const find_task_modules: (input_paths: Input_Path[], task_root_paths: string[]) => Promise<ReturnType<typeof find_modules>>;
+export declare const load_task_modules: (input_paths: Input_Path[], task_root_paths: string[]) => Promise<ReturnType<typeof load_modules<Task_Module, Task_Module_Meta>> | ({
     ok: false;
 } & Find_Modules_Failure)>;

package/dist/task_module.js

@@ -3,16 +3,16 @@ import { to_task_name, is_task_path, TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS, }
 import { Input_Path, get_possible_source_ids } from './input_path.js';
 import { search_fs } from './search_fs.js';
 export const validate_task_module = (mod) => !!mod.task && typeof mod.task.run === 'function';
-export const load_task_module = async (id) => {
+export const load_task_module = async (id, task_root_paths) => {
     const result = await load_module(id, validate_task_module);
     if (!result.ok)
         return result;
-    return { ...result, mod: { ...result.mod, name: to_task_name(id) } }; // TODO this task name needs to use task root paths or cwd
+    return { ...result, mod: { ...result.mod, name: to_task_name(id, task_root_paths) } }; // TODO this task name needs to use task root paths or cwd
 };
-export const find_task_modules = async (input_paths, root_dirs) => find_modules(input_paths, (id) => search_fs(id, { filter: (path) => is_task_path(path) }), (input_path) => get_possible_source_ids(input_path, [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS], root_dirs));
-export const load_task_modules = async (input_paths, root_dirs) => {
-    const find_modules_result = await find_task_modules(input_paths, root_dirs);
+export const find_task_modules = async (input_paths, task_root_paths) => find_modules(input_paths, (id) => search_fs(id, { filter: (path) => is_task_path(path) }), (input_path) => get_possible_source_ids(input_path, [TASK_FILE_SUFFIX_TS, TASK_FILE_SUFFIX_JS], task_root_paths));
+export const load_task_modules = async (input_paths, task_root_paths) => {
+    const find_modules_result = await find_task_modules(input_paths, task_root_paths);
     if (!find_modules_result.ok)
         return find_modules_result;
-    return load_modules(find_modules_result.source_ids_by_input_path, load_task_module);
+    return load_modules(find_modules_result.source_ids_by_input_path, (id) => load_task_module(id, task_root_paths));
 };

package/dist/task_module.test.js

@@ -21,7 +21,7 @@ const test__load_task_module = suite('load_task_module');
 test__load_task_module('basic behavior', async () => {
     const name = 'fixtures/test_task_module.task_fixture.js';
     const id = resolve('src/' + name);
-    const result = await load_task_module(id);
+    const result = await load_task_module(id, []);
     assert.ok(result.ok);
     assert.is(result.mod.id, id);
     assert.is(result.mod.id, id);
@@ -30,7 +30,7 @@ test__load_task_module('basic behavior', async () => {
 });
 test__load_task_module('invalid module', async () => {
     const id = resolve('src/fixtures/test_invalid_task_module.js');
-    const result = await load_task_module(id);
+    const result = await load_task_module(id, []);
     assert.ok(!result.ok);
     if (result.type === 'invalid') {
         assert.is(result.id, id);
@@ -43,7 +43,7 @@ test__load_task_module('invalid module', async () => {
 });
 test__load_task_module('failing module', async () => {
     const id = resolve('src/fixtures/test_failing_task_module.js');
-    const result = await load_task_module(id);
+    const result = await load_task_module(id, []);
     assert.ok(!result.ok);
     if (result.type === 'importFailed') {
         assert.is(result.id, id);
@@ -58,10 +58,7 @@ test__load_task_module.run();
 /* test__load_task_modules */
 const test__load_task_modules = suite('load_task_modules');
 test__load_task_modules('basic behavior', async () => {
-    const result = await load_task_modules([
-        resolve('src/lib/test'),
-        resolve('src/lib/test.task.ts'),
-    ]);
+    const result = await load_task_modules([resolve('src/lib/test'), resolve('src/lib/test.task.ts')], [resolve('src/lib')]);
     assert.ok(result.ok);
     assert.is(result.modules.length, 1);
     assert.is(result.modules[0].mod, actual_test_task_module);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.117.0",
+  "version": "0.118.0",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "icon": "🌰",
@@ -69,7 +69,7 @@
     "@ryanatkn/fuz": "^0.102.1",
     "@ryanatkn/moss": "^0.4.0",
     "@sveltejs/adapter-static": "^3.0.2",
-    "@sveltejs/kit": "^2.5.13",
+    "@sveltejs/kit": "^2.5.15",
     "@sveltejs/package": "^2.3.2",
     "@sveltejs/vite-plugin-svelte": "^3.1.1",
     "@types/fs-extra": "^11.0.4",
@@ -306,6 +306,10 @@
       "default": "./dist/package.js",
       "types": "./dist/package.d.ts"
     },
+    "./path_constants.js": {
+      "default": "./dist/path_constants.js",
+      "types": "./dist/path_constants.d.ts"
+    },
     "./path.js": {
       "default": "./dist/path.js",
       "types": "./dist/path.d.ts"
@@ -322,6 +326,10 @@
       "default": "./dist/publish.task.js",
       "types": "./dist/publish.task.d.ts"
     },
+    "./register.js": {
+      "default": "./dist/register.js",
+      "types": "./dist/register.d.ts"
+    },
     "./release.task.js": {
       "default": "./dist/release.task.js",
       "types": "./dist/release.task.d.ts"
@@ -358,10 +366,18 @@
       "default": "./dist/svelte_helpers.js",
       "types": "./dist/svelte_helpers.d.ts"
     },
+    "./sveltekit_config_global.js": {
+      "default": "./dist/sveltekit_config_global.js",
+      "types": "./dist/sveltekit_config_global.d.ts"
+    },
     "./sveltekit_config.js": {
       "default": "./dist/sveltekit_config.js",
       "types": "./dist/sveltekit_config.d.ts"
     },
+    "./sveltekit_helpers.js": {
+      "default": "./dist/sveltekit_helpers.js",
+      "types": "./dist/sveltekit_helpers.d.ts"
+    },
     "./sveltekit_shim_app_environment.js": {
       "default": "./dist/sveltekit_shim_app_environment.js",
       "types": "./dist/sveltekit_shim_app_environment.d.ts"