@ryanatkn/gro 0.117.0 → 0.119.0

package/dist/paths.d.ts

@@ -1,29 +1,9 @@
 import type { Flavored } from '@ryanatkn/belt/types.js';
 import { z } from 'zod';
-export declare const SOURCE_DIRNAME = "src";
-export declare const GRO_DIRNAME = ".gro";
-export declare const GRO_DIST_PREFIX = "dist_";
-export declare const SERVER_DIST_PATH = "dist_server";
-export declare const LIB_DIRNAME = "lib";
-export declare const ROUTES_DIRNAME = "routes";
-export declare const GRO_DEV_DIRNAME: string;
-export declare const SOURCE_DIR: string;
-export declare const GRO_DIR: string;
-export declare const GRO_DEV_DIR: string;
+export declare const LIB_DIRNAME: string;
 export declare const LIB_PATH: string;
 export declare const LIB_DIR: string;
-export declare const CONFIG_PATH = "gro.config.ts";
-export declare const README_FILENAME = "README.md";
-export declare const SVELTEKIT_CONFIG_FILENAME = "svelte.config.js";
-export declare const VITE_CONFIG_FILENAME = "vite.config.ts";
-export declare const SVELTEKIT_DEV_DIRNAME = ".svelte-kit";
-export declare const SVELTEKIT_BUILD_DIRNAME = "build";
-export declare const SVELTEKIT_DIST_DIRNAME = "dist";
-export declare const NODE_MODULES_DIRNAME = "node_modules";
-export declare const SVELTEKIT_VITE_CACHE_PATH: string;
-export declare const GITHUB_DIRNAME = ".github";
-export declare const GIT_DIRNAME = ".git";
-export declare const TSCONFIG_FILENAME = "tsconfig.json";
+export declare const ROUTES_DIRNAME: string;
 export interface Paths {
     root: string;
     source: string;
@@ -34,10 +14,6 @@ export interface Paths {
 }
 export declare const Source_Id: z.ZodString;
 export type Source_Id = Flavored<z.infer<typeof Source_Id>, 'Source_Id'>;
-export declare const Url: z.ZodString;
-export type Url = Flavored<z.infer<typeof Url>, 'Url'>;
-export declare const Email: z.ZodString;
-export type Email = Flavored<z.infer<typeof Email>, 'Email'>;
 export declare const create_paths: (root_dir: string) => Paths;
 export declare const paths_from_id: (id: string) => Paths;
 export declare const is_gro_id: (id: string) => boolean;

package/dist/paths.js

@@ -1,56 +1,33 @@
-import { join, extname, relative } from 'node:path';
+import { join, extname, relative, basename } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
 import { gray } from 'kleur/colors';
 import { z } from 'zod';
+import { GRO_CONFIG_PATH, GRO_DEV_DIR, GRO_DIR, SOURCE_DIR, SVELTEKIT_DIST_DIRNAME, } from './path_constants.js';
+import { sveltekit_config_global } from './sveltekit_config_global.js';
 /*
 
 A path `id` is an absolute path to the source/.gro/dist directory.
 It's the same name that Rollup uses.
 
 */
-// TODO pass these to `create_paths` and override from gro config
-// TODO this is kinda gross - do we want to maintain the convention to have the trailing slash in most usage?
-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 LIB_DIRNAME = 'lib'; // TODO use Svelte config `files.lib`
-export const ROUTES_DIRNAME = 'routes'; // TODO use Svelte config `files.lib`
-export const GRO_DEV_DIRNAME = GRO_DIRNAME + '/dev';
-export const SOURCE_DIR = SOURCE_DIRNAME + '/';
-export const GRO_DIR = GRO_DIRNAME + '/';
-export const GRO_DEV_DIR = GRO_DEV_DIRNAME + '/';
+export const LIB_DIRNAME = basename(sveltekit_config_global.lib_path);
 export const LIB_PATH = SOURCE_DIR + LIB_DIRNAME;
-export const LIB_DIR = LIB_PATH + '/'; // TODO @multiple get from the sveltekit config
-export const CONFIG_PATH = 'gro.config.ts';
-export const README_FILENAME = 'README.md';
-export const SVELTEKIT_CONFIG_FILENAME = 'svelte.config.js';
-export const VITE_CONFIG_FILENAME = 'vite.config.ts';
-export const SVELTEKIT_DEV_DIRNAME = '.svelte-kit'; // TODO use Svelte config value `outDir`
-export const SVELTEKIT_BUILD_DIRNAME = 'build';
-export const SVELTEKIT_DIST_DIRNAME = 'dist';
-export const NODE_MODULES_DIRNAME = 'node_modules';
-export const SVELTEKIT_VITE_CACHE_PATH = NODE_MODULES_DIRNAME + '/.vite';
-export const GITHUB_DIRNAME = '.github';
-export const GIT_DIRNAME = '.git';
-export const TSCONFIG_FILENAME = 'tsconfig.json';
+export const LIB_DIR = LIB_PATH + '/';
+export const ROUTES_DIRNAME = basename(sveltekit_config_global.routes_path);
+// TODO probably rename to `Path_Id` from `Source_Id`?
 // TODO Flavored doesn't work when used in schemas, use Zod brand instead? problem is ergonomics
 export const Source_Id = z.string();
-// TODO @multiple belongs elsewhere
-export const Url = z.string();
-// TODO @multiple belongs elsewhere
-export const Email = z.string();
 export const create_paths = (root_dir) => {
     // TODO remove reliance on trailing slash towards windows support
     const root = strip_end(root_dir, '/') + '/';
     return {
         root,
         source: root + SOURCE_DIR,
-        lib: root + LIB_DIR, // TODO @multiple get from the sveltekit config
+        lib: root + LIB_DIR,
         build: root + GRO_DIR,
         build_dev: root + GRO_DEV_DIR,
-        config: root + CONFIG_PATH,
+        config: root + GRO_CONFIG_PATH,
     };
 };
 export const paths_from_id = (id) => (is_gro_id(id) ? gro_paths : paths);
@@ -94,7 +71,7 @@ export const replace_extension = (path, new_extension) => {
 /**
  * Paths for the user repo.
  */
-export const paths = create_paths(process.cwd() + '/');
+export const paths = create_paths(process.cwd());
 export const GRO_PACKAGE_DIR = 'gro/';
 // TODO document these conditions with comments
 // TODO there's probably a more robust way to do this

package/dist/publish.task.d.ts

@@ -5,37 +5,40 @@ export declare const Args: z.ZodObject<{
     origin: z.ZodDefault<z.ZodBranded<z.ZodString, "Git_Origin">>;
     changelog: z.ZodDefault<z.ZodString>;
     preserve_changelog: z.ZodDefault<z.ZodBoolean>;
+    optional: z.ZodDefault<z.ZodBoolean>;
     dry: z.ZodDefault<z.ZodBoolean>;
     check: z.ZodDefault<z.ZodBoolean>;
     'no-check': z.ZodDefault<z.ZodBoolean>;
-    install: z.ZodDefault<z.ZodBoolean>;
-    'no-install': z.ZodDefault<z.ZodBoolean>;
     build: z.ZodDefault<z.ZodBoolean>;
     'no-build': z.ZodDefault<z.ZodBoolean>;
+    pull: z.ZodDefault<z.ZodBoolean>;
+    'no-pull': z.ZodDefault<z.ZodBoolean>;
 }, "strict", z.ZodTypeAny, {
     build: boolean;
-    install: boolean;
     origin: string & z.BRAND<"Git_Origin">;
+    pull: boolean;
     branch: string & z.BRAND<"Git_Branch">;
     changelog: string;
-    'no-install': boolean;
     check: boolean;
     dry: boolean;
     'no-build': boolean;
     preserve_changelog: boolean;
+    optional: boolean;
     'no-check': boolean;
+    'no-pull': boolean;
 }, {
     build?: boolean | undefined;
-    install?: boolean | undefined;
     origin?: string | undefined;
+    pull?: boolean | undefined;
     branch?: string | undefined;
     changelog?: string | undefined;
-    'no-install'?: boolean | undefined;
     check?: boolean | undefined;
     dry?: boolean | undefined;
     'no-build'?: boolean | undefined;
     preserve_changelog?: boolean | undefined;
+    optional?: boolean | undefined;
     'no-check'?: boolean | undefined;
+    'no-pull'?: boolean | undefined;
 }>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;

package/dist/publish.task.js

@@ -6,10 +6,10 @@ import { load_package_json, parse_repo_url } from './package_json.js';
 import { find_cli, spawn_cli } from './cli.js';
 import { exists } from './fs.js';
 import { IS_THIS_GRO } from './paths.js';
-import { has_sveltekit_library } from './gro_plugin_sveltekit_library.js';
+import { has_sveltekit_library } from './sveltekit_helpers.js';
 import { update_changelog } from './changelog.js';
 import { load_from_env } from './env.js';
-import { Git_Branch, Git_Origin, git_checkout, git_fetch, git_pull } from './git.js';
+import { Git_Branch, Git_Origin, git_check_clean_workspace, git_checkout, git_fetch, git_pull, } from './git.js';
 // publish.task.ts
 // - usage: `gro publish patch`
 // - forwards args to `npm version`: https://docs.npmjs.com/v6/commands/npm-version
@@ -28,6 +28,7 @@ export const Args = z
         description: 'opt out of linkifying and formatting the changelog from @changesets/changelog-git',
     })
         .default(false),
+    optional: z.boolean({ description: 'exit gracefully if there are no changesets' }).default(false),
     dry: z
         .boolean({ description: 'build and prepare to publish without actually publishing' })
         .default(false),
@@ -35,24 +36,23 @@ export const Args = z
     'no-check': z
         .boolean({ description: 'opt out of npm checking before publishing' })
         .default(false),
-    install: z.boolean({ description: 'dual of no-install' }).default(true),
-    'no-install': z
-        .boolean({ description: 'opt out of npm installing before building' })
-        .default(false),
     build: z.boolean({ description: 'dual of no-build' }).default(true),
     'no-build': z.boolean({ description: 'opt out of building' }).default(false),
+    pull: z.boolean({ description: 'dual of no-pull' }).default(true),
+    'no-pull': z.boolean({ description: 'opt out of git pull' }).default(false),
 })
     .strict();
 export const task = {
     summary: 'bump version, publish to npm, and git push',
     Args,
     run: async ({ args, log, invoke_task }) => {
-        const { branch, origin, changelog, preserve_changelog, dry, check, install, build } = args;
+        const { branch, origin, changelog, preserve_changelog, dry, check, build, pull, optional } = args;
         if (dry) {
             log.info(green('dry run!'));
         }
-        if (!(await has_sveltekit_library())) {
-            throw new Task_Error('gro publish failed to detect a library, run `npm i -D @sveltejs/package` to enable it');
+        const has_sveltekit_library_result = await has_sveltekit_library();
+        if (!has_sveltekit_library_result.ok) {
+            throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
         }
         // TODO hacky, ensures Gro bootstraps itself
         if (IS_THIS_GRO) {
@@ -60,12 +60,17 @@ export const task = {
         }
         const changelog_exists = await exists(changelog);
         if (!(await find_cli('changeset'))) {
-            throw new Task_Error('changeset command not found: install @changesets/cli locally or globally');
+            throw new Task_Error('changeset command not found, install @changesets/cli locally or globally');
         }
         // Make sure we're on the right branch:
         await git_fetch(origin, branch);
         await git_checkout(branch);
-        await git_pull(origin, branch);
+        if (pull) {
+            if (await git_check_clean_workspace()) {
+                throw new Task_Error('The git workspace is not clean, pass --no-pull to bypass git pull');
+            }
+            await git_pull(origin, branch);
+        }
         // Check before proceeding.
         if (check) {
             await invoke_task('check', { workspace: true });
@@ -82,7 +87,7 @@ export const task = {
         else {
             const package_json_before = await load_package_json();
             if (typeof package_json_before.version !== 'string') {
-                throw new Task_Error('failed to find package.json version');
+                throw new Task_Error('Failed to find package.json version');
             }
             const parsed_repo_url = parse_repo_url(package_json_before);
             if (!parsed_repo_url) {
@@ -105,11 +110,18 @@ export const task = {
             const package_json_after = await load_package_json();
             version = package_json_after.version;
             if (package_json_before.version === version) {
-                throw new Task_Error('changeset version failed: are there any changes?');
+                // The version didn't change.
+                // For now this is the best detection we have for a no-op `changeset version`.
+                if (optional) {
+                    return; // exit gracefully
+                }
+                else {
+                    throw new Task_Error('changeset version failed: are there any changes?');
+                }
             }
         }
         if (build) {
-            await invoke_task('build', { install });
+            await invoke_task('build');
         }
         if (dry) {
             log.info('publishing branch ' + branch);

package/dist/register.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/register.js

@@ -0,0 +1,2 @@
+import { register } from 'node:module';
+register('./loader.js', import.meta.url);

package/dist/reinstall.task.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+import { type Task } from './task.js';
+export declare const Args: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+export type Args = z.infer<typeof Args>;
+export declare const task: Task<Args>;

package/dist/reinstall.task.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+import { spawn } from '@ryanatkn/belt/process.js';
+import { rm } from 'fs/promises';
+import { Task_Error } from './task.js';
+import { LOCKFILE_FILENAME, NODE_MODULES_DIRNAME } from './path_constants.js';
+export const Args = z.object({}).strict();
+export const task = {
+    summary: `refreshes ${LOCKFILE_FILENAME} with the latest and cleanest deps`,
+    Args,
+    run: async ({ log }) => {
+        log.info('running the initial npm install');
+        const initial_install_result = await spawn('npm', ['i']);
+        if (!initial_install_result.ok) {
+            throw new Task_Error('Failed initial npm install');
+        }
+        // Deleting both the lockfile and node_modules upgrades to the latest minor/patch versions.
+        await Promise.all([rm(LOCKFILE_FILENAME), rm(NODE_MODULES_DIRNAME, { recursive: true })]);
+        log.info(`running npm install after deleting ${LOCKFILE_FILENAME} and ${NODE_MODULES_DIRNAME}, this can take a while...`);
+        const second_install_result = await spawn('npm', ['i']);
+        if (!second_install_result.ok) {
+            throw new Task_Error(`Failed npm install after deleting ${LOCKFILE_FILENAME} and ${NODE_MODULES_DIRNAME}`);
+        }
+        // Deleting the lockfile and reinstalling cleans the lockfile of unnecessary dep noise,
+        // like esbuild's many packages for each platform.
+        await rm(LOCKFILE_FILENAME);
+        log.info(`running npm install one last time to clean ${LOCKFILE_FILENAME}`);
+        const final_install_result = await spawn('npm', ['i']);
+        if (!final_install_result.ok) {
+            throw new Task_Error('Failed npm install');
+        }
+    },
+};

package/dist/release.task.js

@@ -1,18 +1,16 @@
 import { z } from 'zod';
-import { has_sveltekit_library } from './gro_plugin_sveltekit_library.js';
-import { has_sveltekit_app } from './gro_plugin_sveltekit_app.js';
+import { has_sveltekit_library, has_sveltekit_app } from './sveltekit_helpers.js';
 export const Args = z.object({}).strict();
 export const task = {
     summary: 'publish and deploy',
     Args,
     run: async ({ invoke_task }) => {
-        const publish = await has_sveltekit_library();
+        const publish = (await has_sveltekit_library()).ok;
         if (publish) {
-            await invoke_task('publish'); // TODO use `to_forwarded_args`
+            await invoke_task('publish', { optional: true });
         }
-        const deploy = await has_sveltekit_app();
-        if (deploy) {
-            await invoke_task('deploy', { build: !publish }); // TODO use `to_forwarded_args`
+        if ((await has_sveltekit_app()).ok) {
+            await invoke_task('deploy', { build: !publish });
         }
     },
 };

package/dist/resolve_node_specifier.js

@@ -1,6 +1,7 @@
 import { join } from 'node:path';
 import { Package_Json, load_package_json } from './package_json.js';
-import { NODE_MODULES_DIRNAME, Source_Id, paths } from './paths.js';
+import { Source_Id, paths } from './paths.js';
+import { NODE_MODULES_DIRNAME } from './path_constants.js';
 export const resolve_node_specifier = async (specifier, dir = paths.root, parent_url, cache, exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default') => {
     const parsed = parse_node_specifier(specifier);
     const subpath = './' + parsed.path;

package/dist/run.task.js

@@ -20,7 +20,7 @@ export const task = {
             return;
         }
         if (!(await exists(path))) {
-            throw new Task_Error('cannot find file to run at path: ' + path);
+            throw new Task_Error('Cannot find file to run at path: ' + path);
         }
         const loader_path = await resolve_gro_module_path('loader.js');
         const spawned = await spawn_with_loader(loader_path, path, argv);

package/dist/run_gen.d.ts

@@ -1,6 +1,7 @@
 import { type Gen_Module_Meta } from './gen_module.js';
 import { type Gen_Results } from './gen.js';
 import type { format_file as base_format_file } from './format_file.js';
+import type { Gro_Config } from './config.js';
 export declare const GEN_NO_PROD_MESSAGE = "gen runs only during development";
-export declare const run_gen: (gen_modules: Gen_Module_Meta[], log: Logger, timings: Timings, format_file?: typeof base_format_file) => Promise<Gen_Results>;
+export declare const run_gen: (gen_modules: Gen_Module_Meta[], config: Gro_Config, log: Logger, timings: Timings, format_file?: typeof base_format_file) => Promise<Gen_Results>;
 export declare const to_gen_import_path: (id: string) => string;

package/dist/run_gen.js

@@ -6,7 +6,7 @@ import { GEN_SCHEMA_PATH_SUFFIX } from './gen_module.js';
 import { to_gen_result, } from './gen.js';
 import { print_path, source_id_to_base_path } from './paths.js';
 export const GEN_NO_PROD_MESSAGE = 'gen runs only during development';
-export const run_gen = async (gen_modules, log, timings, format_file) => {
+export const run_gen = async (gen_modules, config, log, timings, format_file) => {
     let input_count = 0;
     let output_count = 0;
     const timing_for_run_gen = timings.start('run_gen');
@@ -15,7 +15,7 @@ export const run_gen = async (gen_modules, log, timings, format_file) => {
         const { id } = module_meta;
         const timing_for_module = timings.start(id);
         // Perform code generation by calling `gen` on the module.
-        const gen_ctx = { origin_id: id, log };
+        const gen_ctx = { origin_id: id, config, log };
         let raw_gen_result;
         try {
             switch (module_meta.type) {

package/dist/run_gen.test.js

@@ -4,6 +4,7 @@ import { resolve, join } from 'node:path';
 import { Logger } from '@ryanatkn/belt/log.js';
 import { Timings } from '@ryanatkn/belt/timings.js';
 import { run_gen } from './run_gen.js';
+import { load_config } from './config.js';
 const log = new Logger('test__gen'); // TODO test logger?
 /* test__gen */
 const test__gen = suite('gen');
@@ -69,7 +70,7 @@ test__gen('basic behavior', async () => {
         },
     };
     const gen_modules_by_input_path = [mod_a, mod_b, mod_c];
-    const gen_results = await run_gen(gen_modules_by_input_path, log, new Timings(), async (content, opts) => opts.filepath.endsWith('output_b.ts') ? `${content}/*FORMATTED*/` : content);
+    const gen_results = await run_gen(gen_modules_by_input_path, await load_config(), log, new Timings(), async (content, opts) => opts.filepath.endsWith('output_b.ts') ? `${content}/*FORMATTED*/` : content);
     assert.is(gen_results.input_count, 3);
     assert.is(gen_results.output_count, 4);
     assert.is(gen_results.successes.length, 3);
@@ -153,7 +154,7 @@ test__gen('failing gen function', async () => {
         },
     };
     const gen_modules_by_input_path = [mod_a, mod_b];
-    const gen_results = await run_gen(gen_modules_by_input_path, log, new Timings());
+    const gen_results = await run_gen(gen_modules_by_input_path, await load_config(), log, new Timings());
     assert.is(gen_results.input_count, 2);
     assert.is(gen_results.output_count, 1);
     assert.is(gen_results.successes.length, 1);

package/dist/run_task.js

@@ -28,7 +28,7 @@ export const run_task = async (task_meta, unparsed_args, invoke_task, config, ti
             config,
             log,
             timings,
-            invoke_task: (invoked_task_name, invoked_args = {}, invoked_config) => invoke_task(invoked_task_name, invoked_args, invoked_config || config, timings),
+            invoke_task: (invoked_task_name, invoked_args, invoked_config) => invoke_task(invoked_task_name, invoked_args, invoked_config || config, timings),
         });
     }
     catch (err) {

package/dist/sveltekit_config.d.ts

@@ -3,7 +3,7 @@ import type { Config as SveltekitConfig } from '@sveltejs/kit';
 import type { CompileOptions, PreprocessorGroup, ModuleCompileOptions } from 'svelte/compiler';
 /**
  * Loads a SvelteKit config at `dir`.
- * @returns
+ * @returns `null` if no config is found
  */
 export declare const load_sveltekit_config: (dir?: string) => Promise<SveltekitConfig | null>;
 /**

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,17 @@
+import type { Result } from '@ryanatkn/belt/result.js';
+import { Package_Json } from './package_json.js';
+import type { Parsed_Sveltekit_Config } from './sveltekit_config.js';
+export declare const SVELTEKIT_CLI = "svelte-kit";
+export declare const SVELTE_PACKAGE_CLI = "svelte-package";
+export declare const SVELTE_PACKAGE_DEP_NAME = "@sveltejs/package";
+export declare const has_sveltekit_app: () => Promise<Result<object, {
+    message: string;
+}>>;
+export declare const has_sveltekit_library: (package_json?: Package_Json, sveltekit_config?: Parsed_Sveltekit_Config) => Promise<Result<object, {
+    message: string;
+}>>;
+export declare const sveltekit_sync: () => Promise<void>;
+/**
+ * If the SvelteKit CLI is found and its `.svelte-kit` directory is not, run `svelte-kit sync`.
+ */
+export declare const sveltekit_sync_if_obviously_needed: () => Promise<void>;

package/dist/sveltekit_helpers.js

@@ -0,0 +1,54 @@
+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';
+import { Task_Error } from './task.js';
+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))) {
+        return { ok: false, message: `no SvelteKit config found at ${SVELTEKIT_CONFIG_FILENAME}` };
+    }
+    // TODO check for routes?
+    return { ok: true };
+};
+export const has_sveltekit_library = async (package_json, sveltekit_config = sveltekit_config_global) => {
+    const has_sveltekit_app_result = await has_sveltekit_app();
+    if (!has_sveltekit_app_result.ok) {
+        return has_sveltekit_app_result;
+    }
+    if (!(await exists(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());
+    if (!(pkg.devDependencies?.[SVELTE_PACKAGE_DEP_NAME] || pkg.dependencies?.[SVELTE_PACKAGE_DEP_NAME])) {
+        return {
+            ok: false,
+            message: `no dependency found in package.json for ${SVELTE_PACKAGE_DEP_NAME}, install it with \`npm i -D ${SVELTE_PACKAGE_DEP_NAME}\``,
+        };
+    }
+    return { ok: true };
+};
+export const sveltekit_sync = async () => {
+    if (!(await find_cli(SVELTEKIT_CLI))) {
+        throw new Task_Error(`Failed to find ${SVELTEKIT_CLI} CLI - do you need to run \`npm i\`?`);
+    }
+    const result = await spawn_cli(SVELTEKIT_CLI, ['sync']);
+    if (!result?.ok) {
+        throw new Task_Error(`Failed ${SVELTEKIT_CLI} sync`);
+    }
+};
+/**
+ * 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)) {
+        return;
+    }
+    if (!(await find_cli(SVELTEKIT_CLI))) {
+        return;
+    }
+    return sveltekit_sync();
+};

package/dist/sync.task.d.ts

@@ -27,4 +27,3 @@ export declare const Args: z.ZodObject<{
 }>;
 export type Args = z.infer<typeof Args>;
 export declare const task: Task<Args>;
-export declare const sveltekit_sync: () => Promise<void>;

package/dist/sync.task.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { spawn } from '@ryanatkn/belt/process.js';
 import { Task_Error } from './task.js';
 import { sync_package_json } from './package_json.js';
-import { find_cli, spawn_cli } from './cli.js';
+import { sveltekit_sync } from './sveltekit_helpers.js';
 export const Args = z
     .object({
     sveltekit: z.boolean({ description: 'dual of no-sveltekit' }).default(true),
@@ -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();
@@ -34,12 +37,3 @@ export const task = {
         }
     },
 };
-export const sveltekit_sync = async () => {
-    if (!(await find_cli('svelte-kit'))) {
-        throw new Task_Error('failed to find svelte-kit CLI - do you need to run `npm i`?');
-    }
-    const result = await spawn_cli('svelte-kit', ['sync']);
-    if (!result?.ok) {
-        throw new Task_Error(`failed svelte-kit 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.