@ryanatkn/gro 0.129.0 → 0.129.1

package/dist/gro_plugin_sveltekit_app.js

@@ -1,6 +1,5 @@
-import { cp, mkdir, rm, writeFile } from 'node:fs/promises';
+import { cpSync, mkdirSync, rmSync, writeFileSync, existsSync } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { existsSync } from 'node:fs';
 import { serialize_args, to_forwarded_args } from './args.js';
 import { serialize_package_json, load_package_json } from './package_json.js';
 import { Task_Error } from './task.js';
@@ -32,7 +31,7 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
             else {
                 // `vite build` in production mode
                 // `.well-known/package.json`
-                const package_json = await load_package_json(); // TODO put in plugin context? same with sveltekit config?
+                const package_json = load_package_json(); // TODO put in plugin context? same with sveltekit config?
                 if (well_known_package_json === undefined) {
                     well_known_package_json = package_json.public; // eslint-disable-line no-param-reassign
                 }
@@ -43,8 +42,8 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
                         : await well_known_package_json(package_json);
                 const serialized_package_json = mapped_package_json && serialize_package_json(mapped_package_json);
                 // `.well-known/src.json` and `.well-known/src/`
-                const final_package_json = mapped_package_json || package_json;
-                const src_json = await create_src_json(final_package_json);
+                const final_package_json = mapped_package_json ?? package_json;
+                const src_json = create_src_json(final_package_json);
                 if (well_known_src_json === undefined) {
                     well_known_src_json = final_package_json.public; // eslint-disable-line no-param-reassign
                 }
@@ -61,13 +60,13 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
                 const { assets_path } = sveltekit_config_global;
                 const cleanups = [
                     serialized_package_json
-                        ? await create_temporarily(join(assets_path, '.well-known/package.json'), serialized_package_json)
+                        ? create_temporarily(join(assets_path, '.well-known/package.json'), serialized_package_json)
                         : null,
                     serialized_src_json
-                        ? await create_temporarily(join(assets_path, '.well-known/src.json'), serialized_src_json)
+                        ? create_temporarily(join(assets_path, '.well-known/src.json'), serialized_src_json)
                         : null,
                     serialized_src_json && well_known_src_files
-                        ? await copy_temporarily(SOURCE_DIRNAME, assets_path, '.well-known', well_known_src_files === true
+                        ? copy_temporarily(SOURCE_DIRNAME, assets_path, '.well-known', well_known_src_files === true
                             ? (file_path) => !DEFAULT_EXPORTS_EXCLUDER.test(file_path)
                             : well_known_src_files)
                         : null,
@@ -78,10 +77,13 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
                      * to tell GitHub Pages to treat the outputs as plain static files.
                      */
                     host_target === 'github_pages'
-                        ? await create_temporarily(join(assets_path, '.nojekyll'), '')
+                        ? create_temporarily(join(assets_path, '.nojekyll'), '')
                         : null,
-                ].filter(Boolean);
-                const cleanup = () => Promise.all(cleanups.map((c) => c()));
+                ].filter((v) => v != null);
+                const cleanup = () => {
+                    for (const c of cleanups)
+                        c();
+                };
                 try {
                     const serialized_args = ['build', ...serialize_args(to_forwarded_args(vite_cli))];
                     const spawned = await spawn_cli(found_vite_cli, serialized_args, log);
@@ -90,10 +92,10 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
                     }
                 }
                 catch (err) {
-                    await cleanup();
+                    cleanup();
                     throw err;
                 }
-                await cleanup();
+                cleanup();
             }
         },
         teardown: async () => {
@@ -105,29 +107,33 @@ export const gro_plugin_sveltekit_app = ({ host_target = 'github_pages', well_kn
     };
 };
 // TODO probably extract these, and create a common helper or merge them
-const copy_temporarily = async (source_path, dest_dir, dest_base_dir = '', filter) => {
+const copy_temporarily = (source_path, dest_dir, dest_base_dir = '', filter) => {
     const path = join(dest_dir, dest_base_dir, source_path);
     const dir = dirname(path);
     const dir_already_exists = existsSync(dir);
     let root_created_dir;
     if (!dir_already_exists) {
-        root_created_dir = await to_root_dir_that_doesnt_exist(dir);
+        root_created_dir = to_root_dir_that_doesnt_exist(dir);
         if (!root_created_dir)
             throw Error();
-        await mkdir(dir, { recursive: true });
+        mkdirSync(dir, { recursive: true });
     }
     const path_already_exists = existsSync(path);
     if (!path_already_exists) {
-        await cp(source_path, path, { recursive: true, filter });
+        cpSync(source_path, path, { recursive: true, filter });
     }
-    return async () => {
+    return () => {
         if (!dir_already_exists) {
             if (!root_created_dir)
                 throw Error();
-            await rm(root_created_dir, { recursive: true });
+            if (existsSync(root_created_dir)) {
+                rmSync(root_created_dir, { recursive: true });
+            }
         }
         else if (!path_already_exists) {
-            await rm(path, { recursive: true });
+            if (existsSync(path)) {
+                rmSync(path, { recursive: true });
+            }
         }
     };
 };
@@ -138,28 +144,32 @@ const copy_temporarily = async (source_path, dest_dir, dest_base_dir = '', filte
  * @param contents
  * @returns cleanup function that deletes the file and any created dirs
  */
-const create_temporarily = async (path, contents) => {
+const create_temporarily = (path, contents) => {
     const dir = dirname(path);
     const dir_already_exists = existsSync(dir);
     let root_created_dir;
     if (!dir_already_exists) {
-        root_created_dir = await to_root_dir_that_doesnt_exist(dir);
+        root_created_dir = to_root_dir_that_doesnt_exist(dir);
         if (!root_created_dir)
             throw Error();
-        await mkdir(dir, { recursive: true });
+        mkdirSync(dir, { recursive: true });
     }
     const path_already_exists = existsSync(path);
     if (!path_already_exists) {
-        await writeFile(path, contents, 'utf8');
+        writeFileSync(path, contents, 'utf8');
     }
-    return async () => {
+    return () => {
         if (!dir_already_exists) {
             if (!root_created_dir)
                 throw Error();
-            await rm(root_created_dir, { recursive: true });
+            if (existsSync(root_created_dir)) {
+                rmSync(root_created_dir, { recursive: true });
+            }
         }
         else if (!path_already_exists) {
-            await rm(path);
+            if (existsSync(path)) {
+                rmSync(path);
+            }
         }
     };
 };
@@ -168,7 +178,7 @@ const create_temporarily = async (path, contents) => {
  * for `/a/b/DOESNT_EXIST/NOR_THIS/ETC` returns `/a/b/DOESNT_EXIST`
  * where `/a/b` does exist on the filesystem and `DOESNT_EXIST` is not one of its subdirectories.
  */
-const to_root_dir_that_doesnt_exist = async (dir) => {
+const to_root_dir_that_doesnt_exist = (dir) => {
     let prev;
     let d = dir;
     do {

package/dist/gro_plugin_sveltekit_library.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin, Plugin_Context } from './plugin.js';
+import type { Plugin } from './plugin.js';
 import { type Svelte_Package_Options } from './sveltekit_helpers.js';
 export interface Options {
     /**
@@ -12,4 +12,4 @@ export interface Options {
      */
     svelte_package_cli?: string;
 }
-export declare const gro_plugin_sveltekit_library: ({ svelte_package_options, svelte_package_cli, }?: Options) => Plugin<Plugin_Context>;
+export declare const gro_plugin_sveltekit_library: ({ svelte_package_options, svelte_package_cli, }?: Options) => Plugin;

package/dist/gro_plugin_sveltekit_library.js

@@ -8,7 +8,7 @@ export const gro_plugin_sveltekit_library = ({ svelte_package_options, svelte_pa
     return {
         name: 'gro_plugin_sveltekit_library',
         setup: async ({ log }) => {
-            const has_sveltekit_library_result = await has_sveltekit_library();
+            const has_sveltekit_library_result = has_sveltekit_library();
             if (!has_sveltekit_library_result.ok) {
                 throw new Task_Error('Failed to find SvelteKit library: ' + has_sveltekit_library_result.message);
             }
@@ -23,7 +23,7 @@ export const gro_plugin_sveltekit_library = ({ svelte_package_options, svelte_pa
             await spawn_cli(found_svelte_package_cli, serialized_args, log);
         },
         adapt: async ({ log, timings }) => {
-            const package_json = await load_package_json();
+            const package_json = load_package_json();
             // `npm link`
             if (package_json.bin) {
                 const timing_to_npm_link = timings.start('npm link');

package/dist/input_path.test.js

@@ -90,7 +90,7 @@ test('get_possible_paths implied to be a directory by trailing slash', () => {
         { id: input_path, input_path: resolve('src/foo/bar') + '/', root_dir: resolve('src/foo') },
     ]);
 });
-test('resolve_input_files', async () => {
+test('resolve_input_files', () => {
     const test_files = {
         'fake/test1.ext.ts': [
             { id: 'fake/test1.ext.ts', path: 'fake/test1.ext.ts', is_directory: false },

package/dist/invoke_task.js

@@ -43,7 +43,7 @@ export const invoke_task = async (task_name, args, config, initial_timings = nul
     };
     // 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();
+        const gro_package_json = load_gro_package_json();
         log.info(`${gray('v')}${cyan(gro_package_json.version)}`);
         finish();
         return;
@@ -70,7 +70,7 @@ export const invoke_task = async (task_name, args, config, initial_timings = nul
     const loaded_tasks = loaded.value;
     if (resolved_input_files.length > 1 || resolved_input_files[0].resolved_input_path.is_directory) {
         // The input path matches a directory. Log the tasks but don't run them.
-        await log_tasks(log, loaded_tasks);
+        log_tasks(log, loaded_tasks);
         finish();
         return;
     }
@@ -78,7 +78,7 @@ export const invoke_task = async (task_name, args, config, initial_timings = nul
     if (loaded_tasks.modules.length !== 1)
         throw Error('expected one loaded task'); // run only one task at a time
     const task = loaded_tasks.modules[0];
-    log.info(`→ ${cyan(task.name)} ${(task.mod.task.summary && gray(task.mod.task.summary)) || ''}`);
+    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();

package/dist/lint.task.js

@@ -2,12 +2,11 @@ import { print_spawn_result } from '@ryanatkn/belt/process.js';
 import { z } from 'zod';
 import { Task_Error } from './task.js';
 import { serialize_args, to_forwarded_args } from './args.js';
-import { SOURCE_DIRNAME } from './path_constants.js';
 import { find_cli, spawn_cli } from './cli.js';
 const ESLINT_CLI = 'eslint';
 export const Args = z
     .object({
-    _: z.array(z.string(), { description: 'paths to serve' }).default([SOURCE_DIRNAME]),
+    _: z.array(z.string(), { description: 'paths to serve' }).default([]),
     eslint_cli: z.string({ description: 'the ESLint CLI to use' }).default(ESLINT_CLI),
 })
     .strict();

package/dist/loader.js

@@ -122,7 +122,7 @@ export const load = async (url, context, nextLoad) => {
             return {
                 format: 'module',
                 shortCircuit: true,
-                source: await render_env_shim_module(dev, mode, visibility, public_prefix, private_prefix, env_dir),
+                source: render_env_shim_module(dev, mode, visibility, public_prefix, private_prefix, env_dir),
             };
         }
     }
@@ -164,13 +164,13 @@ export const resolve = async (specifier, context, nextResolve) => {
         if (SVELTE_MATCHER.test(path) || JSON_MATCHER.test(path)) {
             // Match the behavior of Vite and esbuild for Svelte and JSON imports.
             // TODO maybe `.ts` too
-            const path_id = await resolve_node_specifier(path, dir, parent_url, package_json_cache);
+            const path_id = resolve_node_specifier(path, dir, parent_url, package_json_cache);
             return { url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true };
         }
         else {
             return nextResolve(path, context);
         }
     }
-    const { path_id } = await resolve_specifier(path, dirname(fileURLToPath(parent_url)));
+    const { path_id } = resolve_specifier(path, dirname(fileURLToPath(parent_url)));
     return { url: pathToFileURL(path_id).href, format: 'module', shortCircuit: true };
 };

package/dist/package.d.ts

@@ -21,9 +21,14 @@ export declare const package_json: {
     bugs: string;
     funding: string;
     scripts: {
-        build: string;
+        bootstrap: string;
         start: string;
+        dev: string;
+        build: string;
+        check: string;
         test: string;
+        preview: string;
+        deploy: string;
     };
     type: string;
     engines: {
@@ -62,23 +67,15 @@ export declare const package_json: {
         '@sveltejs/vite-plugin-svelte': string;
         '@types/fs-extra': string;
         '@types/node': string;
-        '@typescript-eslint/eslint-plugin': string;
-        '@typescript-eslint/parser': string;
         esbuild: string;
         eslint: string;
         'eslint-plugin-svelte': string;
         svelte: string;
         'svelte-check': string;
         typescript: string;
+        'typescript-eslint': string;
         uvu: string;
     };
-    eslintConfig: {
-        root: boolean;
-        extends: string;
-        rules: {
-            'no-console': number;
-        };
-    };
     prettier: {
         plugins: string[];
         useTabs: boolean;

package/dist/package.gen.js

@@ -8,9 +8,9 @@ import { create_src_json } from './src_json.js';
  * which mirrors `package.json` but in TypeScript,
  * allowing apps to import typesafe data from their own `package.json`.
  */
-export const gen = async ({ origin_id }) => {
-    const package_json = await load_package_json();
-    const src_json = await create_src_json(package_json);
+export const gen = ({ origin_id }) => {
+    const package_json = load_package_json();
+    const src_json = create_src_json(package_json);
     return `
 // generated by ${to_root_path(origin_id)}
 

package/dist/package.js

@@ -1,7 +1,7 @@
 // generated by src/lib/package.gen.ts
 export const package_json = {
     name: '@ryanatkn/gro',
-    version: '0.129.0',
+    version: '0.129.1',
     description: 'task runner and toolkit extending SvelteKit',
     motto: 'generate, run, optimize',
     glyph: '🌰',
@@ -15,9 +15,14 @@ export const package_json = {
     bugs: 'https://github.com/ryanatkn/gro/issues',
     funding: 'https://www.ryanatkn.com/funding',
     scripts: {
-        build: 'rm -rf .gro dist && svelte-kit sync && svelte-package && chmod +x ./dist/gro.js && npm link -f',
+        bootstrap: 'rm -rf .gro dist && svelte-kit sync && svelte-package && chmod +x ./dist/gro.js && npm link -f',
         start: 'gro dev',
+        dev: 'gro dev',
+        build: 'gro build',
+        check: 'gro check',
         test: 'gro test',
+        preview: 'vite preview',
+        deploy: 'gro deploy',
     },
     type: 'module',
     engines: { node: '>=20.12' },
@@ -34,7 +39,7 @@ export const package_json = {
         'typescript',
     ],
     dependencies: {
-        '@ryanatkn/belt': '^0.24.1',
+        '@ryanatkn/belt': '^0.24.2',
         chokidar: '^3.6.0',
         dotenv: '^16.4.5',
         'es-module-lexer': '^1.5.4',
@@ -46,30 +51,28 @@ export const package_json = {
         tslib: '^2.6.3',
         zod: '^3.23.8',
     },
-    peerDependencies: { esbuild: '^0.21', svelte: '^5.0.0-next.0' },
+    peerDependencies: { esbuild: '^0.21.0', svelte: '^5.0.0-next.0' },
     devDependencies: {
         '@changesets/changelog-git': '^0.2.0',
         '@changesets/types': '^6.0.0',
-        '@ryanatkn/eslint-config': '^0.1.3',
-        '@ryanatkn/fuz': '^0.107.0',
-        '@ryanatkn/moss': '^0.6.3',
+        '@ryanatkn/eslint-config': '^0.4.0',
+        '@ryanatkn/fuz': '^0.108.2',
+        '@ryanatkn/moss': '^0.7.0',
         '@sveltejs/adapter-static': '^3.0.2',
         '@sveltejs/kit': '^2.5.18',
         '@sveltejs/package': '^2.3.2',
         '@sveltejs/vite-plugin-svelte': '^3.1.1',
         '@types/fs-extra': '^11.0.4',
-        '@types/node': '^20.14.9',
-        '@typescript-eslint/eslint-plugin': '^7.14.1',
-        '@typescript-eslint/parser': '^7.14.1',
+        '@types/node': '^20.14.10',
         esbuild: '^0.21.5',
-        eslint: '^8.57.0',
+        eslint: '^9.6.0',
         'eslint-plugin-svelte': '^2.41.0',
-        svelte: '^5.0.0-next.167',
+        svelte: '^5.0.0-next.175',
         'svelte-check': '^3.8.4',
-        typescript: '^5.5.2',
+        typescript: '^5.5.3',
+        'typescript-eslint': '^8.0.0-alpha.39',
         uvu: '^0.5.6',
     },
-    eslintConfig: { root: true, extends: '@ryanatkn', rules: { 'no-console': 1 } },
     prettier: {
         plugins: ['prettier-plugin-svelte'],
         useTabs: true,
@@ -263,7 +266,7 @@ export const package_json = {
 };
 export const src_json = {
     name: '@ryanatkn/gro',
-    version: '0.129.0',
+    version: '0.129.1',
     modules: {
         '.': {
             path: 'index.ts',

package/dist/package_json.d.ts

@@ -337,17 +337,15 @@ export declare const Package_Json: z.ZodObject<{
     exports: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>]>>>, any, Record<string, string | Record<string, string> | undefined>>>;
 }, z.ZodTypeAny, "passthrough">>;
 export type Package_Json = z.infer<typeof Package_Json>;
-export interface Map_Package_Json {
-    (package_json: Package_Json): Package_Json | null | Promise<Package_Json | null>;
-}
+export type Map_Package_Json = (package_json: Package_Json) => Package_Json | null | Promise<Package_Json | null>;
 export declare const EMPTY_PACKAGE_JSON: Package_Json;
-export declare const load_package_json: (dir?: string, cache?: Record<string, Package_Json>) => Promise<Package_Json>;
+export declare const load_package_json: (dir?: string, cache?: Record<string, Package_Json>) => Package_Json;
 export declare const sync_package_json: (map_package_json: Map_Package_Json, log: Logger, check?: boolean, dir?: string, exports_dir?: string) => Promise<{
     package_json: Package_Json | null;
     changed: boolean;
 }>;
-export declare const load_gro_package_json: () => Promise<Package_Json>;
-export declare const write_package_json: (serialized_package_json: string) => Promise<void>;
+export declare const load_gro_package_json: () => Package_Json;
+export declare const write_package_json: (serialized_package_json: string) => void;
 export declare const serialize_package_json: (package_json: Package_Json) => string;
 /**
  * Updates package.json. Writes to the filesystem only when contents change.

package/dist/package_json.js

@@ -1,8 +1,7 @@
 import { z } from 'zod';
 import { join } from 'node:path';
-import { readFile, writeFile } from 'node:fs/promises';
-import { count_graphemes, plural } from '@ryanatkn/belt/string.js';
-import { strip_end } from '@ryanatkn/belt/string.js';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { count_graphemes, plural, strip_end } from '@ryanatkn/belt/string.js';
 import { red } from '@ryanatkn/belt/styletext.js';
 import { paths, gro_paths, IS_THIS_GRO, replace_extension } from './paths.js';
 import { SVELTEKIT_DIST_DIRNAME } from './path_constants.js';
@@ -16,7 +15,7 @@ export const Email = z.string();
 // TODO move this where?
 export const transform_empty_object_to_undefined = (val) => {
     if (val && Object.keys(val).length === 0) {
-        return undefined;
+        return;
     }
     return val;
 };
@@ -111,15 +110,15 @@ export const Package_Json = z
 })
     .passthrough();
 export const EMPTY_PACKAGE_JSON = { name: '', version: '' };
-export const load_package_json = async (dir = IS_THIS_GRO ? gro_paths.root : paths.root, cache) => {
+export const load_package_json = (dir = IS_THIS_GRO ? gro_paths.root : paths.root, cache) => {
     let package_json;
     if (cache && dir in cache) {
         return cache[dir];
     }
     try {
-        package_json = JSON.parse(await load_package_json_contents(dir));
+        package_json = JSON.parse(load_package_json_contents(dir));
     }
-    catch (err) {
+    catch (_err) {
         return EMPTY_PACKAGE_JSON;
     }
     package_json = parse_package_json(Package_Json, package_json);
@@ -131,7 +130,7 @@ export const sync_package_json = async (map_package_json, log, check = false, di
     const exported_files = search_fs(exports_dir);
     const exported_paths = exported_files.map((f) => f.path);
     const updated = await update_package_json(dir, async (package_json) => {
-        if ((await has_sveltekit_library(package_json)).ok) {
+        if (has_sveltekit_library(package_json).ok) {
             const exports = to_package_exports(exported_paths);
             package_json.exports = exports;
         }
@@ -148,16 +147,16 @@ export const sync_package_json = async (map_package_json, log, check = false, di
 };
 export const load_gro_package_json = () => load_package_json(gro_paths.root);
 // TODO probably make this nullable and make callers handle failures
-const load_package_json_contents = (dir) => readFile(join(dir, 'package.json'), 'utf8');
-export const write_package_json = async (serialized_package_json) => {
-    await writeFile(join(paths.root, 'package.json'), serialized_package_json);
+const load_package_json_contents = (dir) => readFileSync(join(dir, 'package.json'), 'utf8');
+export const write_package_json = (serialized_package_json) => {
+    writeFileSync(join(paths.root, 'package.json'), serialized_package_json);
 };
 export const serialize_package_json = (package_json) => JSON.stringify(parse_package_json(Package_Json, package_json), null, 2) + '\n';
 /**
  * Updates package.json. Writes to the filesystem only when contents change.
  */
 export const update_package_json = async (dir = paths.root, update, write = true) => {
-    const original_contents = await load_package_json_contents(dir);
+    const original_contents = load_package_json_contents(dir);
     const original = JSON.parse(original_contents);
     const updated = await update(original);
     if (updated === null) {
@@ -168,7 +167,7 @@ export const update_package_json = async (dir = paths.root, update, write = true
         return { package_json: original, changed: false };
     }
     if (write)
-        await write_package_json(updated_contents);
+        write_package_json(updated_contents);
     return { package_json: updated, changed: true };
 };
 const is_index = (path) => path === 'index.ts' || path === 'index.js';
@@ -232,11 +231,11 @@ export const parse_repo_url = (package_json) => {
             : repository.url
         : undefined;
     if (!repo_url) {
-        return undefined;
+        return;
     }
     const parsed_repo_url = GITHUB_REPO_MATCHER.exec(strip_end(strip_end(repo_url, '/'), '.git'));
     if (!parsed_repo_url) {
-        return undefined;
+        return;
     }
     const [, owner, repo] = parsed_repo_url;
     return { owner, repo };

package/dist/package_json.test.js

@@ -1,26 +1,26 @@
 import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { Package_Json, load_package_json, parse_repo_url, serialize_package_json, to_package_exports, } from './package_json.js';
-test('load_package_json', async () => {
-    const package_json = await load_package_json();
+test('load_package_json', () => {
+    const package_json = load_package_json();
     assert.ok(package_json);
     const parsed = Package_Json.parse(package_json);
     assert.ok(parsed);
     serialize_package_json(package_json);
 });
-test('load_package_json with cache', async () => {
+test('load_package_json with cache', () => {
     const cache = {};
-    const package_json1 = await load_package_json(undefined, cache);
+    const package_json1 = load_package_json(undefined, cache);
     assert.ok(package_json1);
     assert.is(Object.keys(cache).length, 1);
-    const package_json2 = await load_package_json(undefined, cache);
+    const package_json2 = load_package_json(undefined, cache);
     assert.is(Object.keys(cache).length, 1);
     assert.is(package_json1, package_json2);
 });
-test('Package_Json.parse', async () => {
+test('Package_Json.parse', () => {
     Package_Json.parse({ name: 'abc', version: '123' });
 });
-test('Package_Json.parse fails with bad data', async () => {
+test('Package_Json.parse fails with bad data', () => {
     let err;
     try {
         Package_Json.parse({ version: '123' });
@@ -30,10 +30,10 @@ test('Package_Json.parse fails with bad data', async () => {
     }
     assert.ok(err);
 });
-test('serialize_package_json', async () => {
+test('serialize_package_json', () => {
     serialize_package_json({ name: 'abc', version: '123' });
 });
-test('serialize_package_json fails with bad data', async () => {
+test('serialize_package_json fails with bad data', () => {
     let err;
     try {
         serialize_package_json({ version: '123' });
@@ -43,7 +43,7 @@ test('serialize_package_json fails with bad data', async () => {
     }
     assert.ok(err);
 });
-test('to_package_exports', async () => {
+test('to_package_exports', () => {
     assert.equal(to_package_exports(['a/b.ts']), {
         './package.json': './package.json',
         './a/b.js': {
@@ -76,8 +76,8 @@ test('to_package_exports', async () => {
         },
     });
 });
-test('parse_repo_url', async () => {
-    const parsed = parse_repo_url(await load_package_json());
+test('parse_repo_url', () => {
+    const parsed = parse_repo_url(load_package_json());
     assert.is(parsed?.owner, 'ryanatkn');
     assert.is(parsed?.repo, 'gro');
 });

package/dist/path.d.ts

@@ -10,10 +10,6 @@ export interface Path_Info {
 export interface Resolved_Path extends Path_Info {
     path: string;
 }
-export interface Path_Filter {
-    (path: string, is_directory: boolean): boolean;
-}
-export interface File_Filter {
-    (path: string): boolean;
-}
+export type Path_Filter = (path: string, is_directory: boolean) => boolean;
+export type File_Filter = (path: string) => boolean;
 export declare const to_file_path: (path_or_url: string | URL) => string;

package/dist/plugin.d.ts

@@ -9,9 +9,7 @@ export interface Plugin<T_Plugin_Context extends Plugin_Context = Plugin_Context
     adapt?: (ctx: T_Plugin_Context) => void | Promise<void>;
     teardown?: (ctx: T_Plugin_Context) => void | Promise<void>;
 }
-export interface Create_Config_Plugins<T_Plugin_Context extends Plugin_Context = Plugin_Context> {
-    (ctx: T_Plugin_Context): (Plugin<T_Plugin_Context> | null | Array<Plugin<T_Plugin_Context> | null>) | Promise<Plugin<T_Plugin_Context> | null | Array<Plugin<T_Plugin_Context> | null>>;
-}
+export type Create_Config_Plugins<T_Plugin_Context extends Plugin_Context = Plugin_Context> = (ctx: T_Plugin_Context) => (Plugin<T_Plugin_Context> | null | Array<Plugin<T_Plugin_Context> | null>) | Promise<Plugin<T_Plugin_Context> | null | Array<Plugin<T_Plugin_Context> | null>>;
 export interface Plugin_Context<T_Args = object> extends Task_Context<T_Args> {
     dev: boolean;
     watch: boolean;

package/dist/plugin.js

@@ -10,7 +10,7 @@ export class Plugins {
     static async create(ctx) {
         const { timings } = ctx;
         const timing_to_create = timings.start('plugins.create');
-        const instances = to_array(await ctx.config.plugins(ctx)).filter(Boolean);
+        const instances = to_array(await ctx.config.plugins(ctx)).filter((v) => v !== null); // TODO remove cast, should infer the type predicate? `Type '(Plugin<Plugin_Context<object>> | null)[]' is not assignable to type 'Plugin<Plugin_Context<object>>[]'.`
         const plugins = new Plugins(ctx, instances);
         timing_to_create();
         return plugins;
@@ -70,7 +70,7 @@ export class Plugins {
  * @returns `plugins` with `new_plugin` at the index of the plugin with `name`
  */
 export const replace_plugin = (plugins, new_plugin, name = new_plugin.name) => {
-    const array = to_array(plugins).filter(Boolean);
+    const array = to_array(plugins).filter((v) => v !== null);
     const index = array.findIndex((p) => p.name === name);
     if (index === -1)
         throw Error('Failed to find plugin to replace: ' + name);