@ryanatkn/gro 0.128.0 → 0.129.1

package/README.md

@@ -1,6 +1,6 @@
-# gro <img src="static/favicon.png" width="32" height="32">
+# gro <img src="static/logo.svg" alt="a pixelated green oak acorn with a glint of sun" width="32" height="32">
 
-<img src="static/favicon.png" align="right" width="192" height="192">
+[<img src="static/logo.svg" alt="a pixelated green oak acorn with a glint of sun" align="right" width="192" height="192">](https://gro.ryanatkn.com/)
 
 > task runner and toolkit extending SvelteKit 🌰 generate, run, optimize
 
@@ -237,13 +237,13 @@ For more see [the tasks index](/src/lib/docs/tasks.md),
 
 ```bash
 npm i
-npm run build # build and link `gro` - needed only once
-gro build # same as `npm run build` when the `gro` CLI is available
+npm run bootstrap # build and link `gro` without itself - needed only once
+gro build # same as `npm run bootstrap` when the `gro` CLI is available
 gro test # make sure everything looks good - same as `npm test`
 gro test some.test another.test
 
 # use your development version of `gro` locally in another project:
-gro build # updates the `gro` CLI, same as `npm run build`
+gro build # updates the `gro` CLI, same as `npm run bootstrap`
 cd ../otherproject
 npm link ../gro # from `otherproject/`
 gro build # from `../gro` on changes

package/dist/args.d.ts

@@ -54,6 +54,6 @@ export declare const to_raw_rest_args: (argv?: string[]) => string[];
  * the `command` `'eslint'` returns `eslintarg1 --eslintarg2`
  * and `'tsc'` returns `--tscarg1` and `--tscarg2`.
  */
-export declare const to_forwarded_args: (command: string, raw_rest_args?: string[], cache?: Record<string, Args>) => Args;
-export declare const to_forwarded_args_by_command: (raw_rest_args?: string[]) => Record<string, Args>;
+export declare const to_forwarded_args: (command: string, raw_rest_args?: string[], cache?: Record<string, Args | undefined>) => Args;
+export declare const to_forwarded_args_by_command: (raw_rest_args?: string[]) => Record<string, Args | undefined>;
 export declare const print_command_args: (serialized_args: string[]) => string;

package/dist/args.js

@@ -69,7 +69,7 @@ export const serialize_args = (args) => {
 export const to_task_args = (argv = process.argv) => {
     const forwarded_index = argv.indexOf('--');
     const args = mri(forwarded_index === -1 ? argv.slice(2) : argv.slice(2, forwarded_index));
-    const task_name = args._.shift() || '';
+    const task_name = args._.shift() ?? '';
     if (!args._.length)
         delete args._; // enable schema defaults
     return { task_name, args };
@@ -87,7 +87,7 @@ export const to_raw_rest_args = (argv = process.argv) => {
  * the `command` `'eslint'` returns `eslintarg1 --eslintarg2`
  * and `'tsc'` returns `--tscarg1` and `--tscarg2`.
  */
-export const to_forwarded_args = (command, raw_rest_args, cache = to_forwarded_args_by_command(raw_rest_args)) => cache[command] || {};
+export const to_forwarded_args = (command, raw_rest_args, cache = to_forwarded_args_by_command(raw_rest_args)) => cache[command] ?? {};
 export const to_forwarded_args_by_command = (raw_rest_args = to_raw_rest_args()) => {
     // Parse each segment of `argv` separated by `--`.
     const argvs = [];

package/dist/changelog.js

@@ -1,4 +1,4 @@
-import { readFile, writeFile } from 'fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 import { z } from 'zod';
 import { github_fetch_commit_prs } from './github.js';
 /**

package/dist/changelog.test.js

@@ -1,11 +1,11 @@
 import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { Logger } from '@ryanatkn/belt/log.js';
-import { readFile, writeFile } from 'fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 import { update_changelog } from './changelog.js';
 import { load_from_env } from './env.js';
 const log = new Logger();
-const token = await load_from_env('GITHUB_TOKEN_SECRET');
+const token = load_from_env('GITHUB_TOKEN_SECRET');
 if (!token) {
     log.warn('the env var GITHUB_TOKEN_SECRET was not found, so API calls with be unauthorized');
 }

package/dist/changeset.task.js

@@ -5,11 +5,11 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { existsSync, readdirSync } from 'node:fs';
 import { Task_Error } from './task.js';
-import { load_package_json } from './package_json.js';
 import { find_cli, spawn_cli } from './cli.js';
 import { Git_Origin, git_check_fully_staged_workspace, git_push_to_create } from './git.js';
 import { has_sveltekit_library } from './sveltekit_helpers.js';
 import { CHANGESET_CLI, CHANGESET_DIR, Changeset_Access, Changeset_Bump, CHANGESET_PUBLIC_ACCESS, CHANGESET_RESTRICTED_ACCESS, } from './changeset_helpers.js';
+import { load_package_json } from './package_json.js';
 export const Args = z
     .object({
     /**
@@ -44,7 +44,7 @@ export const task = {
     summary: 'call changeset with gro patterns',
     Args,
     run: async (ctx) => {
-        const { invoke_task, args: { _, minor, major, dir, access: access_arg, changelog, install, origin, changeset_cli }, log, } = ctx;
+        const { invoke_task, args: { _, minor, major, dir, access: access_arg, changelog, install, origin, changeset_cli }, log, sveltekit_config, } = ctx;
         const message = _.join(' ');
         if (!message && (minor || major))
             throw new Task_Error('cannot bump version without a message');
@@ -55,8 +55,8 @@ export const task = {
         if (!found_changeset_cli) {
             throw new Task_Error('changeset command not found: install @changesets/cli locally or globally');
         }
-        const package_json = await load_package_json();
-        const has_sveltekit_library_result = await has_sveltekit_library(package_json);
+        const package_json = load_package_json();
+        const has_sveltekit_library_result = has_sveltekit_library(package_json, sveltekit_config);
         if (!has_sveltekit_library_result.ok) {
             throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
         }
@@ -84,7 +84,7 @@ export const task = {
         await invoke_task('sync'); // after the `npm i` above, and in all cases
         if (message) {
             // TODO see the helper below, simplify this to CLI flags when support is added to Changesets
-            const changeset_adder = await create_changeset_adder(package_json.name, dir, message, bump);
+            const changeset_adder = create_changeset_adder(package_json.name, dir, message, bump);
             await spawn_cli(found_changeset_cli, ['add', '--empty'], log);
             await changeset_adder();
             if (!(await git_check_fully_staged_workspace())) {
@@ -102,7 +102,7 @@ export const task = {
  * TODO ideally this wouldn't exist and we'd use CLI flags, but they doesn't exist yet
  * @see https://github.com/changesets/changesets/pull/1121
  */
-const create_changeset_adder = async (repo_name, dir, message, bump) => {
+const create_changeset_adder = (repo_name, dir, message, bump) => {
     const filenames_before = readdirSync(dir);
     return async () => {
         const filenames_after = readdirSync(dir);

package/dist/cli.js

@@ -16,7 +16,7 @@ export const find_cli = (name, cwd = process.cwd(), options) => {
         return { name, id: local_id, kind: 'local' };
     }
     const { stdout } = spawnSync('which', [name], options);
-    const global_id = stdout?.toString().trim();
+    const global_id = stdout.toString().trim();
     if (!global_id)
         return null;
     return { name, id: global_id, kind: 'global' };

package/dist/config.d.ts

@@ -39,9 +39,7 @@ export interface Raw_Gro_Config {
     task_root_dirs?: string[];
     search_filters?: Path_Filter | Path_Filter[] | null;
 }
-export interface Create_Gro_Config {
-    (base_config: Gro_Config): Raw_Gro_Config | Promise<Raw_Gro_Config>;
-}
+export type Create_Gro_Config = (base_config: Gro_Config) => Raw_Gro_Config | Promise<Raw_Gro_Config>;
 export declare const create_empty_config: () => Gro_Config;
 /**
  * The regexp used by default to exclude directories and files

package/dist/config.js

@@ -11,7 +11,7 @@ export const create_empty_config = () => ({
         paths.lib,
         IS_THIS_GRO ? null : paths.root,
         IS_THIS_GRO ? null : GRO_DIST_DIR,
-    ].filter(Boolean),
+    ].filter((v) => v !== null),
     search_filters: [(id) => !DEFAULT_SEARCH_EXCLUDER.test(id)],
 });
 /**
@@ -27,7 +27,7 @@ export const DEFAULT_SEARCH_EXCLUDER = new RegExp(`(${'(^|/)\\.[^/]+' + // exclu
     `|(^|/)(?<!(^|/)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) => {
+const default_map_package_json = (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/deploy.task.js

@@ -12,7 +12,7 @@ import { empty_dir } from './fs.js';
 import { git_check_clean_workspace, git_checkout, git_local_branch_exists, git_remote_branch_exists, Git_Origin, Git_Branch, git_delete_local_branch, git_push_to_create, git_reset_branch_to_first_commit, git_pull, git_fetch, git_check_setting_pull_rebase, git_clone_locally, git_current_branch_name, } from './git.js';
 // docs at ./docs/deploy.md
 // terminal command for testing:
-// npm run build && rm -rf .gro && clear && gro deploy --source no-git-workspace --no-build --dry
+// npm run bootstrap && rm -rf .gro && clear && gro deploy --source no-git-workspace --no-build --dry
 // TODO customize
 const dir = process.cwd();
 const INITIAL_FILE_PATH = '.gitkeep';

package/dist/docs/README.gen.md.js

@@ -10,7 +10,7 @@ import { search_fs } from '../search_fs.js';
 /**
  * Renders a simple index of a possibly nested directory of files.
  */
-export const gen = async ({ origin_id }) => {
+export const gen = ({ origin_id }) => {
     // TODO need to get this from project config or something
     const root_path = parse_path_segments(paths.root).at(-1);
     const origin_dir = dirname(origin_id);

package/dist/docs/dev.md

@@ -35,6 +35,6 @@ See [plugin.md](plugin.md) to learn more.
 
 <p align="center">
   <a href="https://github.com/ryanatkn/gro">
-    <img src="static/favicon.png" width="192" height="192">
+    <img src="static/logo.svg" alt="a pixelated green oak acorn with a glint of sun" width="192" height="192">
   </a>
 </p>

package/dist/docs/package_json.md

@@ -18,7 +18,8 @@ behavior designed for public open source projects:
   containing additional information about the source modules,
   mapping it with the optional
   [`well_known_src_json` option](./gro_plugin_sveltekit_app.md#well_known_src_json).
-- If you opt in with `well_known_src_files`,
+- If you define a truthy value for the
+  [`well_known_src_files` option](./gro_plugin_sveltekit_app.md#well_known_src_files),
   `gro_plugin_sveltekit_app` outputs `.well-known/src/` by
   copying over `src/` during `vite build`, filtered by `well_known_src_files` if it's a function.
   This is costly (usually more than doubling the final output size

package/dist/env.d.ts

@@ -1,4 +1,4 @@
-export declare const load_env: (dev: boolean, visibility: "public" | "private", public_prefix: string, private_prefix: string, env_dir?: string, env_files?: string[], ambient_env?: NodeJS.ProcessEnv) => Promise<Record<string, string>>;
+export declare const load_env: (dev: boolean, visibility: "public" | "private", public_prefix: string, private_prefix: string, env_dir?: string, env_files?: string[], ambient_env?: NodeJS.ProcessEnv) => Record<string, string>;
 export declare const merge_envs: (envs: Array<Record<string, string | undefined>>, visibility: "public" | "private", public_prefix: string, private_prefix: string) => Record<string, string>;
 export declare const is_private_env: (key: string, public_prefix: string, private_prefix: string) => boolean;
 export declare const is_public_env: (key: string, public_prefix: string, private_prefix: string) => boolean;
@@ -6,4 +6,4 @@ export declare const is_public_env: (key: string, public_prefix: string, private
  * Loads a single env value without merging it into `process.env`.
  * By default searches process.env, then a local `.env` if one exists, then `../.env` if it exists.
  */
-export declare const load_from_env: (key: string, paths?: string[]) => Promise<string | undefined>;
+export declare const load_from_env: (key: string, paths?: string[]) => string | undefined;

package/dist/env.js

@@ -1,18 +1,17 @@
 import dotenv from 'dotenv';
-import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
-import { existsSync } from 'node:fs';
-export const load_env = async (dev, visibility, public_prefix, private_prefix, env_dir, env_files = ['.env', '.env.' + (dev ? 'development' : 'production')], ambient_env = process.env) => {
-    const envs = await Promise.all(env_files
-        .map(async (path) => (await load(env_dir === undefined ? path : resolve(env_dir, path))))
-        .filter(Boolean));
+import { existsSync, readFileSync } from 'node:fs';
+export const load_env = (dev, visibility, public_prefix, private_prefix, env_dir, env_files = ['.env', '.env.' + (dev ? 'development' : 'production')], ambient_env = process.env) => {
+    const envs = env_files
+        .map((path) => load(env_dir === undefined ? path : resolve(env_dir, path)))
+        .filter((v) => v !== undefined);
     envs.push(ambient_env);
     return merge_envs(envs, visibility, public_prefix, private_prefix);
 };
-const load = async (path) => {
+const load = (path) => {
     if (!existsSync(path))
-        return undefined;
-    const loaded = await readFile(path, 'utf8');
+        return;
+    const loaded = readFileSync(path, 'utf8');
     return dotenv.parse(loaded);
 };
 export const merge_envs = (envs, visibility, public_prefix, private_prefix) => {
@@ -35,11 +34,11 @@ export const is_public_env = (key, public_prefix, private_prefix) => key.startsW
  * Loads a single env value without merging it into `process.env`.
  * By default searches process.env, then a local `.env` if one exists, then `../.env` if it exists.
  */
-export const load_from_env = async (key, paths = ['.env', '../.env']) => {
+export const load_from_env = (key, paths = ['.env', '../.env']) => {
     if (process.env[key])
         return process.env[key];
     for (const path of paths) {
-        const env = await load(path); // eslint-disable-line no-await-in-loop
+        const env = load(path);
         if (env?.[key])
             return env[key];
     }

package/dist/esbuild_helpers.js

@@ -25,7 +25,8 @@ export const to_define_import_meta_env = (dev, base_url, ssr = true, mode = dev
     [import_meta_env + 'PROD']: JSON.stringify(!dev),
     [import_meta_env + 'SSR']: JSON.stringify(ssr),
     [import_meta_env + 'MODE']: JSON.stringify(mode),
-    [import_meta_env + 'BASE_URL']: JSON.stringify(base_url || '/'), // it appears SvelteKit's `''` translates to Vite's `'/'`, so this intentionally falls back for falsy values, not just undefined
+    // it appears SvelteKit's `''` translates to Vite's `'/'`, so this intentionally falls back for falsy values, not just undefined
+    [import_meta_env + 'BASE_URL']: JSON.stringify(base_url || '/'), // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing
 });
 export const ts_transform_options = {
     target: 'esnext',

package/dist/esbuild_plugin_external_worker.js

@@ -42,7 +42,7 @@ export const esbuild_plugin_external_worker = ({ dev, build_options, dir = proce
             return building;
         };
         build.onResolve({ filter: /\.worker(|\.js|\.ts)$/u }, async ({ path, resolveDir }) => {
-            const parsed = await resolve_specifier(path, resolveDir);
+            const parsed = resolve_specifier(path, resolveDir);
             const { specifier, path_id, namespace } = parsed;
             const build_result = await build_worker(path_id);
             if (log)

package/dist/esbuild_plugin_svelte.js

@@ -15,7 +15,7 @@ export const esbuild_plugin_svelte = (options = {}) => {
                         filename,
                         ...svelte_compile_module_options,
                     });
-                    const contents = js.map ? js.code + '//# sourceMappingURL=' + js.map.toUrl() : js.code;
+                    const contents = js.code + '//# sourceMappingURL=' + js.map.toUrl();
                     return {
                         contents,
                         warnings: warnings.map((w) => convert_svelte_message_to_esbuild(filename, source, w)),
@@ -34,12 +34,12 @@ export const esbuild_plugin_svelte = (options = {}) => {
                         : null;
                     // TODO handle preprocessor sourcemaps, same as in loader - merge?
                     if (preprocessed?.code)
-                        source = preprocessed?.code;
+                        source = preprocessed.code;
                     const { js, warnings } = compile(source, {
                         filename,
                         ...svelte_compile_options,
                     });
-                    const contents = js.map ? js.code + '//# sourceMappingURL=' + js.map.toUrl() : js.code;
+                    const contents = js.code + '//# sourceMappingURL=' + js.map.toUrl();
                     return {
                         contents,
                         warnings: warnings.map((w) => convert_svelte_message_to_esbuild(filename, source, w)),

package/dist/esbuild_plugin_sveltekit_local_imports.js

@@ -9,11 +9,11 @@ import { resolve_specifier } from './resolve_specifier.js';
 export const esbuild_plugin_sveltekit_local_imports = () => ({
     name: 'sveltekit_local_imports',
     setup: (build) => {
-        build.onResolve({ filter: /^(\/|\.)/u }, async (args) => {
+        build.onResolve({ filter: /^(\/|\.)/u }, (args) => {
             const { path, importer } = args;
             if (!importer)
                 return { path };
-            const { path_id, namespace } = await resolve_specifier(path, dirname(importer));
+            const { path_id, namespace } = resolve_specifier(path, dirname(importer));
             return { path: path_id, namespace }; // `namespace` may be `undefined`, but esbuild needs the absolute path for json etc
         });
         build.onLoad({ filter: /.*/u, namespace: 'sveltekit_local_imports_ts' }, async ({ path }) => ({

package/dist/esbuild_plugin_sveltekit_shim_env.js

@@ -5,13 +5,13 @@ export const esbuild_plugin_sveltekit_shim_env = ({ dev, public_prefix, private_
         const namespace = 'sveltekit_shim_env';
         const filter = /^\$env\/(static|dynamic)\/(public|private)$/u;
         build.onResolve({ filter }, ({ path }) => ({ path, namespace }));
-        build.onLoad({ filter: /.*/u, namespace }, async ({ path }) => {
+        build.onLoad({ filter: /.*/u, namespace }, ({ path }) => {
             const matches = filter.exec(path);
             const mode = matches[1];
             const visibility = matches[2];
             return {
                 loader: 'ts',
-                contents: await render_env_shim_module(dev, mode, visibility, public_prefix, private_prefix, env_dir, env_files, ambient_env),
+                contents: render_env_shim_module(dev, mode, visibility, public_prefix, private_prefix, env_dir, env_files, ambient_env),
             };
         });
     },

package/dist/format_file.js

@@ -11,7 +11,7 @@ let cached_base_options;
 export const format_file = async (content, options, base_options = cached_base_options) => {
     const final_base_options = base_options !== undefined
         ? base_options
-        : (cached_base_options = (await load_package_json()).prettier);
+        : (cached_base_options = load_package_json().prettier);
     let final_options = options;
     if (options.filepath && !options.parser) {
         const { filepath, ...rest } = options;
@@ -22,7 +22,7 @@ export const format_file = async (content, options, base_options = cached_base_o
     try {
         return await prettier.format(content, { ...final_base_options, ...final_options });
     }
-    catch (err) {
+    catch (_err) {
         return content;
     }
 };

package/dist/gen.d.ts

@@ -9,19 +9,17 @@ import { Input_Path, type Resolved_Input_File, type Resolved_Input_Path } from '
 export declare const GEN_FILE_PATTERN_TEXT = "gen";
 export declare const GEN_FILE_PATTERN: string;
 export declare const is_gen_path: (path: string) => boolean;
-export type Gen_Result = {
+export interface Gen_Result {
     origin_id: Path_Id;
     files: Gen_File[];
-};
+}
 export interface Gen_File {
     id: Path_Id;
     content: string;
     origin_id: Path_Id;
     format: boolean;
 }
-export interface Gen {
-    (ctx: Gen_Context): Raw_Gen_Result | Promise<Raw_Gen_Result>;
-}
+export type Gen = (ctx: Gen_Context) => Raw_Gen_Result | Promise<Raw_Gen_Result>;
 export interface Gen_Context {
     config: Gro_Config;
     sveltekit_config: Parsed_Sveltekit_Config;
@@ -45,28 +43,28 @@ export declare const Gen_Config: z.ZodObject<{
     imports?: Record<string, string> | undefined;
 }>;
 export type Gen_Config = z.infer<typeof Gen_Config>;
-export type Gen_Results = {
+export interface Gen_Results {
     results: Genfile_Module_Result[];
     successes: Genfile_Module_Result_Success[];
     failures: Genfile_Module_Result_Failure[];
     input_count: number;
     output_count: number;
     elapsed: number;
-};
+}
 export type Genfile_Module_Result = Genfile_Module_Result_Success | Genfile_Module_Result_Failure;
-export type Genfile_Module_Result_Success = {
+export interface Genfile_Module_Result_Success {
     ok: true;
     id: Path_Id;
     files: Gen_File[];
     elapsed: number;
-};
-export type Genfile_Module_Result_Failure = {
+}
+export interface Genfile_Module_Result_Failure {
     ok: false;
     id: Path_Id;
     reason: string;
     error: Error;
     elapsed: number;
-};
+}
 export declare const to_gen_result: (origin_id: Path_Id, raw_result: Raw_Gen_Result) => Gen_Result;
 export declare const to_output_file_name: (filename: string) => string;
 export type Analyzed_Gen_Result = {
@@ -107,7 +105,7 @@ export type Find_Genfiles_Failure = {
 /**
  * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
  */
-export declare const find_genfiles: (input_paths: Input_Path[], root_dirs: Path_Id[], config: Gro_Config, timings?: any) => Promise<Find_Genfiles_Result>;
+export declare const find_genfiles: (input_paths: Input_Path[], root_dirs: Path_Id[], config: Gro_Config, timings?: any) => Find_Genfiles_Result;
 export interface Genfile_Module {
     gen: Gen;
 }

package/dist/gen.js

@@ -42,7 +42,7 @@ const to_output_file_id = (origin_id, raw_file_name) => {
     if (raw_file_name === '') {
         throw Error(`Output file name cannot be an empty string`);
     }
-    const filename = raw_file_name || to_output_file_name(basename(origin_id));
+    const filename = raw_file_name ?? to_output_file_name(basename(origin_id));
     if (isAbsolute(filename))
         return filename;
     const dir = dirname(origin_id);
@@ -132,7 +132,7 @@ export const write_gen_results = async (gen_results, analyzed_gen_results, log)
 /**
  * Finds modules from input paths. (see `src/lib/input_path.ts` for more)
  */
-export const find_genfiles = async (input_paths, root_dirs, config, timings) => {
+export const find_genfiles = (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');
@@ -186,4 +186,4 @@ export const load_genfiles = async (found_genfiles, timings) => {
         value: { modules: loaded_modules.modules, found_genfiles },
     };
 };
-export const validate_gen_module = (mod) => typeof mod?.gen === 'function';
+export const validate_gen_module = (mod) => typeof mod.gen === 'function';

package/dist/gen.task.js

@@ -30,7 +30,7 @@ export const task = {
         const { _: raw_input_paths, root_dirs, check } = args;
         const input_paths = to_input_paths(raw_input_paths);
         // load all of the gen modules
-        const found = await find_genfiles(input_paths, root_dirs, config, timings);
+        const found = find_genfiles(input_paths, root_dirs, config, timings);
         if (!found.ok) {
             if (found.type === 'input_directories_with_no_files') {
                 // TODO maybe let this error like the normal case, but only call `gro gen` if we find gen files? problem is the args would need to be hoisted to callers like `gro sync`

package/dist/gen.test.js

@@ -239,12 +239,9 @@ test('validate_gen_module basic behavior', () => {
     assert.ok(validate_gen_module({ gen: Function.prototype }));
     assert.ok(!validate_gen_module({ gen: {} }));
     assert.ok(!validate_gen_module({ task: { run: {} } }));
-    assert.ok(!validate_gen_module(undefined));
-    assert.ok(!validate_gen_module(null));
-    assert.ok(!validate_gen_module(false));
 });
-test('find_genfiles_result finds gen modules in a directory', async () => {
-    const find_genfiles_result = await find_genfiles(['docs'], [paths.lib], create_empty_config());
+test('find_genfiles_result finds gen modules in a directory', () => {
+    const find_genfiles_result = find_genfiles(['docs'], [paths.lib], create_empty_config());
     assert.ok(find_genfiles_result.ok);
     assert.ok(find_genfiles_result.value.resolved_input_paths.length);
 });

package/dist/git.d.ts

@@ -1,4 +1,4 @@
-import type { SpawnOptions } from 'child_process';
+import type { SpawnOptions } from 'node:child_process';
 import { z } from 'zod';
 export declare const Git_Origin: z.ZodBranded<z.ZodString, "Git_Origin">;
 export type Git_Origin = z.infer<typeof Git_Origin>;
@@ -42,7 +42,7 @@ export declare const git_pull: (origin?: Git_Origin, branch?: Git_Branch, option
 /**
  * Calls `git push` and throws if anything goes wrong.
  */
-export declare const git_push: (origin: Git_Origin, branch: Git_Branch, options?: SpawnOptions, set_upstream?: boolean) => Promise<void>;
+export declare const git_push: (origin: Git_Origin, branch?: Git_Branch, options?: SpawnOptions, set_upstream?: boolean) => Promise<void>;
 /**
  * Calls `git push` and throws if anything goes wrong.
  */

package/dist/gro.config.default.js

@@ -13,7 +13,7 @@ import { has_sveltekit_app, has_sveltekit_library } from './sveltekit_helpers.js
  */
 const config = async (cfg) => {
     const [has_sveltekit_library_result, has_server_result, has_sveltekit_app_result] = await Promise.all([has_sveltekit_library(), has_server(), has_sveltekit_app()]);
-    cfg.plugins = async () => [
+    cfg.plugins = () => [
         has_sveltekit_library_result.ok ? gro_plugin_sveltekit_library() : null,
         has_server_result.ok ? gro_plugin_server() : null,
         has_sveltekit_app_result.ok

package/dist/gro.js

@@ -11,9 +11,9 @@ and it also provides special handling for the case
 where we're running Gro inside Gro's own repo for development.
 
 */
-const invoke_path = await resolve_gro_module_path('invoke.js');
+const invoke_path = resolve_gro_module_path('invoke.js');
 const loader_path = join(invoke_path, '../loader.js');
 const spawned = await spawn_with_loader(loader_path, invoke_path, process.argv.slice(2));
 if (!spawned.ok) {
-    process.exit(spawned.code || 1);
+    process.exit(spawned.code || 1); // eslint-disable-line @typescript-eslint/prefer-nullish-coalescing
 }

package/dist/gro_helpers.d.ts

@@ -33,10 +33,15 @@ import { type Spawn_Result } from '@ryanatkn/belt/process.js';
  * When using the global CLI, this uses the global Gro installation.
  *
  */
-export declare const resolve_gro_module_path: (path?: string) => Promise<string>;
+export declare const resolve_gro_module_path: (path?: string) => string;
 /**
  * Runs a file using the Gro loader.
  *
+ * Uses conditional exports to correctly set up `esm-env` as development by default,
+ * so if you want production set `NODE_ENV=production`.
+ *
+ * @see https://nodejs.org/api/packages.html#conditional-exports
+ *
  * @param loader_path path to loader
  * @param invoke_path path to file to spawn with `node`
  */

package/dist/gro_helpers.js

@@ -1,8 +1,7 @@
-import { realpath } from 'node:fs/promises';
+import { realpathSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawn } from '@ryanatkn/belt/process.js';
-import { existsSync } from 'node:fs';
 import { NODE_MODULES_DIRNAME, SVELTEKIT_DIST_DIRNAME } from './path_constants.js';
 /*
 
@@ -43,12 +42,12 @@ This module is intended to have minimal dependencies to avoid over-imports in th
  * When using the global CLI, this uses the global Gro installation.
  *
  */
-export const resolve_gro_module_path = async (path = '') => {
+export const resolve_gro_module_path = (path = '') => {
     const gro_bin_path = resolve(NODE_MODULES_DIRNAME, '.bin/gro');
     // case 1
     // Prefer any locally installed version of Gro.
     if (existsSync(gro_bin_path)) {
-        return join(await realpath(gro_bin_path), '..', path);
+        return join(realpathSync(gro_bin_path), '..', path);
     }
     // case 2
     // If running Gro inside its own repo, require the local dist.
@@ -65,16 +64,28 @@ export const resolve_gro_module_path = async (path = '') => {
 /**
  * Runs a file using the Gro loader.
  *
+ * Uses conditional exports to correctly set up `esm-env` as development by default,
+ * so if you want production set `NODE_ENV=production`.
+ *
+ * @see https://nodejs.org/api/packages.html#conditional-exports
+ *
  * @param loader_path path to loader
  * @param invoke_path path to file to spawn with `node`
  */
-export const spawn_with_loader = async (loader_path, invoke_path, argv) => spawn('node', [
-    '--import',
-    `data:text/javascript,
+export const spawn_with_loader = (loader_path, invoke_path, argv) => {
+    const args = [
+        '--import',
+        // This does the same as `$lib/register.ts` but without the cost of importing another file.
+        `data:text/javascript,
 			import {register} from "node:module";
 			import {pathToFileURL} from "node:url";
 			register("${loader_path}", pathToFileURL("./"));`,
-    '--enable-source-maps',
-    invoke_path,
-    ...argv,
-]);
+        '--enable-source-maps', // because TypeScript
+    ];
+    // In almost all cases we want the exports condition to be `"development"`.
+    if (process.env.NODE_ENV !== 'production') {
+        args.push('-C', 'development'); // same as `--conditions`
+    }
+    args.push(invoke_path, ...argv);
+    return spawn('node', args);
+};