@ryanatkn/gro 0.128.0 → 0.129.1

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);

package/dist/plugin.test.js

@@ -1,7 +1,7 @@
 import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { replace_plugin } from './plugin.js';
-test('replace_plugin', async () => {
+test('replace_plugin', () => {
     const a = { name: 'a' };
     const b = { name: 'b' };
     const c = { name: 'c' };
@@ -32,13 +32,13 @@ test('replace_plugin', async () => {
     assert.is(p[1], b2);
     assert.is(p[2], c2);
 });
-test('replace_plugin without an array', async () => {
+test('replace_plugin without an array', () => {
     const a = { name: 'a' };
     const a2 = { name: 'a' };
     const p = replace_plugin(a, a2);
     assert.is(p[0], a2);
 });
-test('replace_plugin throws if it cannot find the given name', async () => {
+test('replace_plugin throws if it cannot find the given name', () => {
     const a = { name: 'a' };
     const plugins = [a];
     let err;

package/dist/publish.task.js

@@ -52,7 +52,7 @@ export const task = {
         if (dry) {
             log.info(green('dry run!'));
         }
-        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);
         }
@@ -88,7 +88,7 @@ export const task = {
             log.info('dry run, skipping changeset version');
         }
         else {
-            const package_json_before = await load_package_json();
+            const package_json_before = load_package_json();
             if (typeof package_json_before.version !== 'string') {
                 throw new Task_Error('Failed to find package.json version');
             }
@@ -104,13 +104,13 @@ export const task = {
                 throw Error('npm version failed: no commits were made: see the error above');
             }
             if (!preserve_changelog) {
-                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');
                 }
                 await update_changelog(parsed_repo_url.owner, parsed_repo_url.repo, changelog, token, log);
             }
-            const package_json_after = await load_package_json();
+            const package_json_after = load_package_json();
             version = package_json_after.version;
             if (package_json_before.version === version) {
                 // The version didn't change.

package/dist/reinstall.task.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { spawn } from '@ryanatkn/belt/process.js';
-import { rm } from 'fs/promises';
+import { rm } from 'node:fs/promises';
 import { Task_Error } from './task.js';
 import { LOCKFILE_FILENAME, NODE_MODULES_DIRNAME } from './path_constants.js';
 export const Args = z.object({}).strict();

package/dist/release.task.js

@@ -5,11 +5,11 @@ export const task = {
     summary: 'publish and deploy',
     Args,
     run: async ({ invoke_task }) => {
-        const publish = (await has_sveltekit_library()).ok;
+        const publish = has_sveltekit_library().ok;
         if (publish) {
             await invoke_task('publish', { optional: true });
         }
-        if ((await has_sveltekit_app()).ok) {
+        if (has_sveltekit_app().ok) {
             await invoke_task('deploy', { build: !publish });
         }
     },

package/dist/resolve.task.js

@@ -9,7 +9,7 @@ export const Args = z
 export const task = {
     summary: 'diagnostic that logs resolved filesystem info for the given input paths',
     Args,
-    run: async ({ args, config, log }) => {
+    run: ({ args, config, log }) => {
         const { _ } = args;
         log.info('raw input paths:', _);
         const input_paths = to_input_paths(_);

package/dist/resolve_node_specifier.d.ts

@@ -1,6 +1,6 @@
 import { Package_Json } from './package_json.js';
 import type { Path_Id } from './path.js';
-export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_url?: string, cache?: Record<string, Package_Json>, exports_key?: string) => Promise<Path_Id>;
+export declare const resolve_node_specifier: (specifier: string, dir?: string, parent_url?: string, cache?: Record<string, Package_Json>, exports_key?: string) => Path_Id;
 export interface Parsed_Node_Specifier {
     name: string;
     path: string;

package/dist/resolve_node_specifier.js

@@ -2,11 +2,11 @@ import { join } from 'node:path';
 import { Package_Json, load_package_json } from './package_json.js';
 import { 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') => {
+export const resolve_node_specifier = (specifier, dir = paths.root, parent_url, cache, exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default') => {
     const parsed = parse_node_specifier(specifier);
     const subpath = './' + parsed.path;
     const package_dir = join(dir, NODE_MODULES_DIRNAME, parsed.name);
-    const package_json = await load_package_json(package_dir, cache);
+    const package_json = load_package_json(package_dir, cache);
     const exported = package_json.exports?.[subpath];
     if (!exported) {
         // same error message as Node

package/dist/resolve_node_specifier.test.js

@@ -2,16 +2,16 @@ import { test } from 'uvu';
 import * as assert from 'uvu/assert';
 import { resolve_node_specifier } from './resolve_node_specifier.js';
 import { paths } from './paths.js';
-test('resolves a JS specifier', async () => {
-    assert.is(await resolve_node_specifier('@ryanatkn/fuz/tome.js'), paths.root + 'node_modules/@ryanatkn/fuz/dist/tome.js');
+test('resolves a JS specifier', () => {
+    assert.is(resolve_node_specifier('@ryanatkn/fuz/tome.js'), paths.root + 'node_modules/@ryanatkn/fuz/dist/tome.js');
 });
-test('resolves a Svelte specifier', async () => {
-    assert.is(await resolve_node_specifier('@ryanatkn/fuz/Library.svelte'), paths.root + 'node_modules/@ryanatkn/fuz/dist/Library.svelte');
+test('resolves a Svelte specifier', () => {
+    assert.is(resolve_node_specifier('@ryanatkn/fuz/Library.svelte'), paths.root + 'node_modules/@ryanatkn/fuz/dist/Library.svelte');
 });
-test('throws for a specifier that does not exist', async () => {
+test('throws for a specifier that does not exist', () => {
     let err;
     try {
-        await resolve_node_specifier('@ryanatkn/fuz/this_does_not_exist');
+        resolve_node_specifier('@ryanatkn/fuz/this_does_not_exist');
     }
     catch (_err) {
         err = _err;

package/dist/resolve_specifier.d.ts

@@ -13,4 +13,4 @@ export interface Resolved_Specifier {
  * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
  * @returns
  */
-export declare const resolve_specifier: (path: string, dir: string) => Promise<Resolved_Specifier>;
+export declare const resolve_specifier: (path: string, dir: string) => Resolved_Specifier;

package/dist/resolve_specifier.js

@@ -10,7 +10,7 @@ import { replace_extension } from './paths.js';
  * @param passthrough_extensions - used to support specifiers that have no file extention, which Vite supports, so we do our best effort
  * @returns
  */
-export const resolve_specifier = async (path, dir) => {
+export const resolve_specifier = (path, dir) => {
     const absolute_path = isAbsolute(path) ? path : join(dir, path);
     let mapped_path;
     let path_id;

package/dist/resolve_specifier.test.js

@@ -4,60 +4,60 @@ import { join } from 'node:path';
 import { resolve_specifier } from './resolve_specifier.js';
 import { paths } from './paths.js';
 const dir = paths.source + 'fixtures/';
-test('resolves a specifier to a file that exists with an unknown file extension', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_file.other.ext'), dir), {
+test('resolves a specifier to a file that exists with an unknown file extension', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_file.other.ext'), dir), {
         specifier: './test_file.other.ext',
         path_id: join(dir, 'test_file.other.ext'),
         namespace: undefined,
     });
 });
-test('resolves a ts specifier', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_ts.ts'), dir), {
+test('resolves a ts specifier', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_ts.ts'), dir), {
         specifier: './test_ts.js',
         path_id: join(dir, 'test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
-test('resolves relative ts specifiers', async () => {
-    assert.equal(await resolve_specifier('./test_ts.ts', dir), {
+test('resolves relative ts specifiers', () => {
+    assert.equal(resolve_specifier('./test_ts.ts', dir), {
         specifier: './test_ts.js',
         path_id: join(dir, 'test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
-    assert.equal(await resolve_specifier('./a/b/test_ts.ts', dir), {
+    assert.equal(resolve_specifier('./a/b/test_ts.ts', dir), {
         specifier: './a/b/test_ts.js',
         path_id: join(dir, 'a/b/test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
-    assert.equal(await resolve_specifier('../../test_ts.ts', dir), {
+    assert.equal(resolve_specifier('../../test_ts.ts', dir), {
         specifier: '../../test_ts.js',
         path_id: join(dir, '../../test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
-test('resolves an extensionless specifier', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_ts'), dir), {
+test('resolves an extensionless specifier', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_ts'), dir), {
         specifier: './test_ts.js',
         path_id: join(dir, 'test_ts.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
-test('resolves a js specifier', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_js.js'), dir), {
+test('resolves a js specifier', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_js.js'), dir), {
         specifier: './test_js.js',
         path_id: join(dir, 'test_js.js'),
         namespace: 'sveltekit_local_imports_js',
     });
 });
-test('resolves a js specifier as ts for a file that does not exist', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_missing.js'), dir), {
+test('resolves a js specifier as ts for a file that does not exist', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_missing.js'), dir), {
         specifier: './test_missing.js',
         path_id: join(dir, 'test_missing.ts'),
         namespace: 'sveltekit_local_imports_ts',
     });
 });
-test('resolves an extensionless specifier for a file that does not exist', async () => {
-    assert.equal(await resolve_specifier(join(dir, 'test_missing'), dir), {
+test('resolves an extensionless specifier for a file that does not exist', () => {
+    assert.equal(resolve_specifier(join(dir, 'test_missing'), dir), {
         specifier: './test_missing.js',
         path_id: join(dir, 'test_missing.ts'),
         namespace: 'sveltekit_local_imports_ts',

package/dist/run.task.js

@@ -22,7 +22,7 @@ export const task = {
         if (!existsSync(path)) {
             throw new Task_Error('Cannot find file to run at path: ' + path);
         }
-        const loader_path = await resolve_gro_module_path('loader.js');
+        const loader_path = resolve_gro_module_path('loader.js');
         const spawned = await spawn_with_loader(loader_path, path, argv);
         if (!spawned.ok) {
             throw new Task_Error(`\`gro run ${path}\` failed with exit code ${spawned.code}`);

package/dist/run_gen.test.js

@@ -18,7 +18,7 @@ test__gen('basic behavior', async () => {
     const mod_a = {
         id: path_id_a,
         mod: {
-            gen: async (ctx) => {
+            gen: (ctx) => {
                 assert.is(ctx.origin_id, path_id_a);
                 if (file_a)
                     throw Error('Already generated file_a');
@@ -33,7 +33,7 @@ test__gen('basic behavior', async () => {
     const mod_b = {
         id: join(path_id_bc, 'mod_b.gen.ts'),
         mod: {
-            gen: async (ctx) => {
+            gen: (ctx) => {
                 assert.is(ctx.origin_id, mod_b.id);
                 if (file_b)
                     throw Error('Already generated file_b');
@@ -48,7 +48,7 @@ test__gen('basic behavior', async () => {
     const mod_c = {
         id: join(path_id_bc, 'mod_c.gen.ts'),
         mod: {
-            gen: async (ctx) => {
+            gen: (ctx) => {
                 assert.is(ctx.origin_id, mod_c.id);
                 if (file_c1)
                     throw Error('Already generated file_c1');
@@ -67,7 +67,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, await load_config(), 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(), (content, opts) => Promise.resolve(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);
@@ -77,7 +77,7 @@ test__gen('basic behavior', async () => {
     assert.is(gen_results.results[1], gen_results.successes[1]);
     assert.is(gen_results.results[2], gen_results.successes[2]);
     const result_a = gen_results.results[0];
-    assert.ok(result_a?.ok);
+    assert.ok(result_a.ok);
     assert.ok(file_a);
     assert.equal(result_a.files, [
         {
@@ -88,7 +88,7 @@ test__gen('basic behavior', async () => {
         },
     ]);
     const result_b = gen_results.results[1];
-    assert.ok(result_b?.ok);
+    assert.ok(result_b.ok);
     assert.ok(file_b);
     assert.equal(result_b.files, [
         {
@@ -99,7 +99,7 @@ test__gen('basic behavior', async () => {
         },
     ]);
     const result_c = gen_results.results[2];
-    assert.ok(result_c?.ok);
+    assert.ok(result_c.ok);
     assert.ok(file_c1);
     assert.ok(file_c2);
     assert.equal(result_c.files, [
@@ -127,7 +127,7 @@ test__gen('failing gen function', async () => {
     const mod_a = {
         id: path_id_a,
         mod: {
-            gen: async () => {
+            gen: () => {
                 genError = Error('This fails for testing');
                 throw genError;
             },
@@ -136,7 +136,7 @@ test__gen('failing gen function', async () => {
     const mod_b = {
         id: join(path_idB, 'mod_b.gen.ts'),
         mod: {
-            gen: async (ctx) => {
+            gen: (ctx) => {
                 assert.is(ctx.origin_id, mod_b.id);
                 if (file_b)
                     throw Error('Already generated file_b');
@@ -159,11 +159,11 @@ test__gen('failing gen function', async () => {
     assert.is(gen_results.results[1], gen_results.successes[0]);
     const result_a = gen_results.results[0];
     assert.ok(result_a);
-    assert.ok(!result_a?.ok);
+    assert.ok(!result_a.ok);
     assert.ok(result_a.reason);
     assert.ok(result_a.error);
     const result_b = gen_results.results[1];
-    assert.ok(result_b?.ok);
+    assert.ok(result_b.ok);
     assert.ok(file_b);
     assert.equal(result_b.files, [
         {

package/dist/run_task.js

@@ -30,7 +30,7 @@ export const run_task = async (task_meta, unparsed_args, invoke_task, config, ti
             sveltekit_config: sveltekit_config_global,
             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/run_task.test.js

@@ -32,9 +32,10 @@ test('invokes a sub task', async () => {
                 },
             },
         },
-    }, args, async (invoking_task_name, invoking_args) => {
+    }, args, (invoking_task_name, invoking_args) => {
         invoked_task_name = invoking_task_name;
         invoked_args = invoking_args;
+        return Promise.resolve();
     }, await load_config(), new Timings());
     assert.ok(result.ok);
     assert.is(invoked_task_name, 'bar/testTask');
@@ -48,7 +49,7 @@ test('failing task', async () => {
         id: 'foo/testTask',
         mod: {
             task: {
-                run: async () => {
+                run: () => {
                     err = Error();
                     throw err;
                 },

package/dist/src_json.d.ts

@@ -248,9 +248,7 @@ export declare const Src_Json: z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodU
     }, z.ZodTypeAny, "passthrough">>>>;
 }, z.ZodTypeAny, "passthrough">>>;
 export type Src_Json = z.infer<typeof Src_Json>;
-export interface Map_Src_Json {
-    (src_json: Src_Json): Src_Json | null | Promise<Src_Json | null>;
-}
-export declare const create_src_json: (package_json: Package_Json, log?: any, lib_path?: string) => Promise<Src_Json>;
+export type Map_Src_Json = (src_json: Src_Json) => Src_Json | null | Promise<Src_Json | null>;
+export declare const create_src_json: (package_json: Package_Json, log?: any, lib_path?: string) => Src_Json;
 export declare const serialize_src_json: (src_json: Src_Json) => string;
-export declare const to_src_modules: (exports: Package_Json_Exports | undefined, log?: any, lib_path?: string) => Promise<Src_Modules | undefined>;
+export declare const to_src_modules: (exports: Package_Json_Exports | undefined, log?: any, lib_path?: string) => Src_Modules | undefined;

package/dist/src_json.js

@@ -32,23 +32,22 @@ z
     modules: Src_Modules.transform(transform_empty_object_to_undefined).optional(),
 })
     .passthrough());
-export const create_src_json = async (package_json, log, lib_path) => {
-    return Src_Json.parse({
-        name: package_json.name,
-        version: package_json.version,
-        modules: await to_src_modules(package_json.exports, log, lib_path),
-    });
-};
+export const create_src_json = (package_json, log, lib_path) => Src_Json.parse({
+    name: package_json.name,
+    version: package_json.version,
+    modules: to_src_modules(package_json.exports, log, lib_path),
+});
 export const serialize_src_json = (src_json) => {
     const parsed = Src_Json.parse(src_json); // TODO can parse do the logic that normalize does? see `.transform`
     return JSON.stringify(parsed, null, 2) + '\n';
 };
-export const to_src_modules = async (exports, log, lib_path = paths.lib) => {
+export const to_src_modules = (exports, log, lib_path = paths.lib) => {
     if (!exports)
-        return undefined;
+        return;
     const project = new Project();
     project.addSourceFilesAtPaths('src/**/*.ts'); // TODO dir? maybe rewrite with `lib_path`?
-    return Object.fromEntries((await Promise.all(Object.entries(exports).map(async ([k, _v]) => {
+    return Object.fromEntries(Object.entries(exports)
+        .map(([k, _v]) => {
         // TODO hacky - doesn't handle any but the normal mappings, also add a helper?
         const source_file_path = k === '.' || k === './'
             ? 'index.ts'
@@ -68,8 +67,6 @@ export const to_src_modules = async (exports, log, lib_path = paths.lib) => {
         const source_file = project.getSourceFile((f) => f.getFilePath().endsWith(source_file_path)); // TODO expected this to work without the callback, according to my read of the docs it is, but `project.getSourceFile(source_file_path)` fails
         if (source_file) {
             for (const [name, decls] of source_file.getExportedDeclarations()) {
-                if (!decls)
-                    continue;
                 // TODO how to correctly handle multiples?
                 for (const decl of decls) {
                     // TODO helper
@@ -106,5 +103,6 @@ export const to_src_modules = async (exports, log, lib_path = paths.lib) => {
         }
         const src_module = { path: source_file_path, declarations };
         return [k, src_module];
-    }))).filter(Boolean));
+    })
+        .filter((v) => v !== null));
 };

package/dist/src_json.test.js

@@ -3,8 +3,8 @@ import * as assert from 'uvu/assert';
 import { to_src_modules } from './src_json.js';
 import { to_package_exports } from './package_json.js';
 import { paths } from './paths.js';
-test('to_package_modules', async () => {
-    assert.equal(await to_src_modules(to_package_exports([
+test('to_package_modules', () => {
+    assert.equal(to_src_modules(to_package_exports([
         'fixtures/modules/some_test_css.css',
         'fixtures/modules/Some_Test_Svelte.svelte',
         'fixtures/modules/some_test_ts.ts',

package/dist/sveltekit_config.js

@@ -13,7 +13,7 @@ export const load_sveltekit_config = async (dir = process.cwd()) => {
     try {
         return (await import(join(dir, SVELTEKIT_CONFIG_FILENAME))).default;
     }
-    catch (err) {
+    catch (_err) {
         return null;
     }
 };

package/dist/sveltekit_helpers.d.ts

@@ -7,12 +7,12 @@ export declare const SVELTE_CHECK_CLI = "svelte-check";
 export declare const SVELTE_PACKAGE_CLI = "svelte-package";
 export declare const SVELTE_PACKAGE_DEP_NAME = "@sveltejs/package";
 export declare const VITE_CLI = "vite";
-export declare const has_sveltekit_app: () => Promise<Result<object, {
+export declare const has_sveltekit_app: () => Result<object, {
     message: string;
-}>>;
-export declare const has_sveltekit_library: (package_json?: Package_Json, sveltekit_config?: Parsed_Sveltekit_Config) => Promise<Result<object, {
+}>;
+export declare const has_sveltekit_library: (package_json?: Package_Json, sveltekit_config?: Parsed_Sveltekit_Config) => Result<object, {
     message: string;
-}>>;
+}>;
 export declare const sveltekit_sync: (sveltekit_cli?: string | Cli) => Promise<void>;
 /**
  * If the SvelteKit CLI is found and its `.svelte-kit` directory is not, run `svelte-kit sync`.

package/dist/sveltekit_helpers.js

@@ -9,22 +9,22 @@ export const SVELTE_CHECK_CLI = 'svelte-check';
 export const SVELTE_PACKAGE_CLI = 'svelte-package';
 export const SVELTE_PACKAGE_DEP_NAME = '@sveltejs/package';
 export const VITE_CLI = 'vite';
-export const has_sveltekit_app = async () => {
+export const has_sveltekit_app = () => {
     if (!existsSync(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();
+export const has_sveltekit_library = (package_json, sveltekit_config = sveltekit_config_global) => {
+    const has_sveltekit_app_result = has_sveltekit_app();
     if (!has_sveltekit_app_result.ok) {
         return has_sveltekit_app_result;
     }
     if (!existsSync(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());
+    const pkg = package_json ?? load_package_json();
     if (!(pkg.devDependencies?.[SVELTE_PACKAGE_DEP_NAME] || pkg.dependencies?.[SVELTE_PACKAGE_DEP_NAME])) {
         return {
             ok: false,

package/dist/sveltekit_shim_env.d.ts

@@ -1,4 +1,4 @@
 /**
  * Generates a module shim for SvelteKit's `$env` imports.
  */
-export declare const render_env_shim_module: (dev: boolean, mode: "static" | "dynamic", visibility: "public" | "private", public_prefix?: string, private_prefix?: string, env_dir?: string, env_files?: string[], ambient_env?: Record<string, string | undefined>) => Promise<string>;
+export declare const render_env_shim_module: (dev: boolean, mode: "static" | "dynamic", visibility: "public" | "private", public_prefix?: string, private_prefix?: string, env_dir?: string, env_files?: string[], ambient_env?: Record<string, string | undefined>) => string;

package/dist/sveltekit_shim_env.js

@@ -3,8 +3,8 @@ import { load_env } from './env.js';
 /**
  * Generates a module shim for SvelteKit's `$env` imports.
  */
-export const render_env_shim_module = async (dev, mode, visibility, public_prefix = 'PUBLIC_', private_prefix = '', env_dir, env_files, ambient_env) => {
-    const env = await load_env(dev, visibility, public_prefix, private_prefix, env_dir, env_files, ambient_env);
+export const render_env_shim_module = (dev, mode, visibility, public_prefix = 'PUBLIC_', private_prefix = '', env_dir, env_files, ambient_env) => {
+    const env = load_env(dev, visibility, public_prefix, private_prefix, env_dir, env_files, ambient_env);
     if (mode === 'static') {
         return `// shim for $env/static/${visibility}
 // @see https://github.com/sveltejs/kit/issues/1485