@ryanatkn/gro 0.118.0 → 0.119.1

package/dist/task.js

@@ -3,15 +3,19 @@ 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);
 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;
+    // 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;
         }
     }
-    return strip_end(strip_end(base_path, TASK_FILE_SUFFIX_TS), TASK_FILE_SUFFIX_JS);
+    const task_name = longest_matching_path
+        ? strip_start(strip_start(id, longest_matching_path), '/')
+        : id;
+    return strip_end(strip_end(task_name, TASK_FILE_SUFFIX_TS), TASK_FILE_SUFFIX_JS);
 };
 /**
  * This is used by tasks to signal a known failure.

package/dist/task.test.js

@@ -1,5 +1,6 @@
 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';
 test('is_task_path basic behavior', () => {
     assert.ok(is_task_path('foo.task.ts'));
@@ -14,5 +15,10 @@ test('to_task_name basic behavior', () => {
     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');
 });
 test.run();

package/dist/task_logging.js

@@ -111,11 +111,9 @@ const to_args_schema_type = ({ _def }) => {
         case ZodFirstPartyTypeKind.ZodUnion:
             return 'string | string[]'; // TODO support unions of arbitrary types, or more hardcoded ones as needed
         default: {
-            if ('type' in _def) {
-                return to_args_schema_type(_def.type);
-            }
-            else if ('innerType' in _def) {
-                return to_args_schema_type(_def.innerType);
+            const subschema = to_subschema(_def);
+            if (subschema) {
+                return to_args_schema_type(subschema);
             }
             else {
                 throw Error('Unknown zod type ' + t);
@@ -124,18 +122,34 @@ const to_args_schema_type = ({ _def }) => {
     }
 };
 const to_args_schema_description = ({ _def }) => {
-    if (_def.description)
+    if (_def.description) {
         return _def.description;
-    if ('innerType' in _def) {
-        return to_args_schema_description(_def.innerType);
+    }
+    const subschema = to_subschema(_def);
+    if (subschema) {
+        return to_args_schema_description(subschema);
     }
     return '';
 };
 const to_args_schema_default = ({ _def }) => {
-    if (_def.defaultValue)
+    if (_def.defaultValue) {
         return _def.defaultValue();
-    if ('innerType' in _def) {
-        return to_args_schema_default(_def.innerType);
+    }
+    const subschema = to_subschema(_def);
+    if (subschema) {
+        return to_args_schema_default(subschema);
+    }
+    return undefined;
+};
+const to_subschema = (_def) => {
+    if ('type' in _def) {
+        return _def.type;
+    }
+    else if ('innerType' in _def) {
+        return _def.innerType;
+    }
+    else if ('schema' in _def) {
+        return _def.schema;
     }
     return undefined;
 };

package/dist/typecheck.task.js

@@ -3,7 +3,7 @@ import { z } from 'zod';
 import { Task_Error } from './task.js';
 import { print_command_args, serialize_args, to_forwarded_args } from './args.js';
 import { find_cli, spawn_cli } from './cli.js';
-import { sveltekit_sync } from './sync.task.js';
+import { sveltekit_sync } from './sveltekit_helpers.js';
 export const Args = z.object({}).strict();
 export const task = {
     summary: 'run tsc on the project without emitting any files',

package/dist/upgrade.task.d.ts

@@ -1,7 +1,8 @@
 import { z } from 'zod';
-import type { Task } from './task.js';
+import { type Task } from './task.js';
 export declare const Args: z.ZodObject<{
     _: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    only: z.ZodEffects<z.ZodDefault<z.ZodUnion<[z.ZodString, z.ZodArray<z.ZodString, "many">]>>, string[], string | string[] | undefined>;
     origin: z.ZodDefault<z.ZodBranded<z.ZodString, "Git_Origin">>;
     force: z.ZodDefault<z.ZodBoolean>;
     pull: z.ZodDefault<z.ZodBoolean>;
@@ -14,6 +15,7 @@ export declare const Args: z.ZodObject<{
     dry: boolean;
     force: boolean;
     'no-pull': boolean;
+    only: string[];
 }, {
     _?: string[] | undefined;
     origin?: string | undefined;
@@ -21,6 +23,7 @@ export declare const Args: z.ZodObject<{
     dry?: boolean | undefined;
     force?: boolean | undefined;
     'no-pull'?: boolean | undefined;
+    only?: string | string[] | undefined;
 }>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;

package/dist/upgrade.task.js

@@ -1,10 +1,18 @@
 import { spawn } from '@ryanatkn/belt/process.js';
 import { z } from 'zod';
+import { Task_Error } from './task.js';
 import { load_package_json } from './package_json.js';
 import { Git_Origin, git_pull } from './git.js';
+import { spawn_cli } from './cli.js';
 export const Args = z
     .object({
     _: z.array(z.string(), { description: 'names of deps to exclude from the upgrade' }).default([]),
+    only: z
+        .union([z.string(), z.array(z.string())], {
+        description: 'names of deps to include in the upgrade',
+    })
+        .default([])
+        .transform((v) => (Array.isArray(v) ? v : [v])),
     origin: Git_Origin.describe('git origin to deploy to').default('origin'),
     force: z.boolean({ description: 'if true, print out the planned upgrades' }).default(false),
     pull: z.boolean({ description: 'dual of no-pull' }).default(true),
@@ -15,14 +23,23 @@ export const Args = z
 export const task = {
     summary: 'upgrade deps',
     Args,
-    run: async ({ args, log, invoke_task }) => {
-        const { _, origin, force, pull, dry } = args;
+    run: async ({ args, log }) => {
+        const { _, only, origin, force, pull, dry } = args;
+        if (_.length && only.length) {
+            throw new Task_Error('Cannot call `gro upgrade` with both rest args and --only.');
+        }
         // TODO maybe a different task that pulls and does other things, like `gro ready`
         if (pull) {
             await git_pull(origin);
         }
         const package_json = await load_package_json();
-        const deps = to_deps(package_json).filter((d) => !_.includes(d.key));
+        const all_deps = to_deps(package_json);
+        const deps = only.length
+            ? all_deps.filter((d) => only.includes(d.key))
+            : all_deps.filter((d) => !_.includes(d.key));
+        if (only.length && only.length !== deps.length) {
+            throw new Task_Error(`Some deps to upgrade were not found: ${only.filter((o) => !deps.find((d) => d.key === o)).join(', ')}`);
+        }
         const upgrade_items = to_upgrade_items(deps);
         log.info(`upgrading:`, upgrade_items.join(' '));
         const install_args = ['install'].concat(upgrade_items);
@@ -34,7 +51,8 @@ export const task = {
             install_args.push('--force');
         }
         await spawn('npm', install_args);
-        await invoke_task('sync');
+        // Sync in a new process to pick up any changes after installing, avoiding some errors.
+        await spawn_cli('gro', ['sync']);
     },
 };
 const to_deps = (package_json) => {
@@ -46,4 +64,11 @@ const to_deps = (package_json) => {
         : [];
     return prod_deps.concat(dev_deps);
 };
-const to_upgrade_items = (deps) => deps.map((dep) => dep.key + (dep.value.includes('-next.') ? '@next' : '@latest'));
+// TODO hacky and limited
+// TODO probably want to pass through exact deps as well, e.g. @foo/bar@1
+const to_upgrade_items = (deps) => deps.map((dep) => {
+    if (dep.key.endsWith('@next') || dep.key.endsWith('@latest')) {
+        return dep.key;
+    }
+    return dep.key + (dep.value.includes('-next.') ? '@next' : '@latest');
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.118.0",
+  "version": "0.119.1",
   "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.15",
+    "@sveltejs/kit": "^2.5.16",
     "@sveltejs/package": "^2.3.2",
     "@sveltejs/vite-plugin-svelte": "^3.1.1",
     "@types/fs-extra": "^11.0.4",
@@ -78,7 +78,7 @@
     "@typescript-eslint/parser": "^7.13.0",
     "esbuild": "^0.20.2",
     "eslint": "^8.57.0",
-    "eslint-plugin-svelte": "^2.39.3",
+    "eslint-plugin-svelte": "^2.39.4",
     "svelte": "^5.0.0-next.155",
     "svelte-check": "^3.8.0",
     "typescript": "^5.4.5",
@@ -330,6 +330,10 @@
       "default": "./dist/register.js",
       "types": "./dist/register.d.ts"
     },
+    "./reinstall.task.js": {
+      "default": "./dist/reinstall.task.js",
+      "types": "./dist/reinstall.task.d.ts"
+    },
     "./release.task.js": {
       "default": "./dist/release.task.js",
       "types": "./dist/release.task.d.ts"