@ryanatkn/gro 0.112.0

package/dist/run_gen.test.js

@@ -0,0 +1,182 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+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';
+const log = new Logger('test__gen'); // TODO test logger?
+/* test__gen */
+const test__gen = suite('gen');
+test__gen('basic behavior', async () => {
+    const source_id_a = resolve('src/foo.gen.ts');
+    const source_id_bc = resolve('src/bar/bc');
+    let file_a;
+    let file_b;
+    let file_c1;
+    let file_c2;
+    const mod_a = {
+        type: 'basic',
+        id: source_id_a,
+        mod: {
+            gen: async (ctx) => {
+                assert.is(ctx.origin_id, source_id_a);
+                if (file_a)
+                    throw Error('Already generated file_a');
+                file_a = {
+                    filename: 'foo.ts',
+                    content: 'file_a',
+                };
+                return file_a.content; // here we return the shorthand version
+            },
+        },
+    };
+    const mod_b = {
+        type: 'basic',
+        id: join(source_id_bc, 'mod_b.gen.ts'),
+        mod: {
+            gen: async (ctx) => {
+                assert.is(ctx.origin_id, mod_b.id);
+                if (file_b)
+                    throw Error('Already generated file_b');
+                file_b = {
+                    filename: 'output_b.ts',
+                    content: 'file_b',
+                };
+                return file_b;
+            },
+        },
+    };
+    const mod_c = {
+        type: 'basic',
+        id: join(source_id_bc, 'mod_c.gen.ts'),
+        mod: {
+            gen: async (ctx) => {
+                assert.is(ctx.origin_id, mod_c.id);
+                if (file_c1)
+                    throw Error('Already generated file_c1');
+                if (file_c2)
+                    throw Error('Already generated file_c2');
+                file_c1 = {
+                    filename: 'output_c1.ts',
+                    content: 'file_c1',
+                };
+                file_c2 = {
+                    filename: 'output_c2.ts',
+                    content: 'file_c2',
+                };
+                return [file_c1, file_c2];
+            },
+        },
+    };
+    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);
+    assert.is(gen_results.input_count, 3);
+    assert.is(gen_results.output_count, 4);
+    assert.is(gen_results.successes.length, 3);
+    assert.is(gen_results.failures.length, 0);
+    assert.is(gen_results.results.length, 3);
+    assert.is(gen_results.results[0], gen_results.successes[0]);
+    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(file_a);
+    assert.equal(result_a.files, [
+        {
+            content: file_a.content,
+            id: join(mod_a.id, '../', file_a.filename),
+            origin_id: mod_a.id,
+            format: true,
+        },
+    ]);
+    const result_b = gen_results.results[1];
+    assert.ok(result_b?.ok);
+    assert.ok(file_b);
+    assert.equal(result_b.files, [
+        {
+            content: `${file_b.content}/*FORMATTED*/`,
+            id: join(mod_b.id, '../', file_b.filename),
+            origin_id: mod_b.id,
+            format: true,
+        },
+    ]);
+    const result_c = gen_results.results[2];
+    assert.ok(result_c?.ok);
+    assert.ok(file_c1);
+    assert.ok(file_c2);
+    assert.equal(result_c.files, [
+        {
+            content: file_c1.content,
+            id: join(mod_c.id, '../', file_c1.filename),
+            origin_id: mod_c.id,
+            format: true,
+        },
+        {
+            content: file_c2.content,
+            id: join(mod_c.id, '../', file_c2.filename),
+            origin_id: mod_c.id,
+            format: true,
+        },
+    ]);
+});
+test__gen('failing gen function', async () => {
+    const source_id_a = resolve('src/foo.gen.ts');
+    const source_idB = resolve('src/bar/baz');
+    let file_b; // no file_a because it's never generated
+    let genError; // this error should be passed through to the result
+    // This is the failing gen module.
+    // It's ordered first to test that its failure doesn't cascade.
+    const mod_a = {
+        type: 'basic',
+        id: source_id_a,
+        mod: {
+            gen: async () => {
+                genError = Error('This fails for testing');
+                throw genError;
+            },
+        },
+    };
+    const mod_b = {
+        type: 'basic',
+        id: join(source_idB, 'mod_b.gen.ts'),
+        mod: {
+            gen: async (ctx) => {
+                assert.is(ctx.origin_id, mod_b.id);
+                if (file_b)
+                    throw Error('Already generated file_b');
+                file_b = {
+                    filename: 'output_b.ts',
+                    content: 'file_b',
+                };
+                return file_b;
+            },
+        },
+    };
+    const gen_modules_by_input_path = [mod_a, mod_b];
+    const gen_results = await run_gen(gen_modules_by_input_path, log, new Timings());
+    assert.is(gen_results.input_count, 2);
+    assert.is(gen_results.output_count, 1);
+    assert.is(gen_results.successes.length, 1);
+    assert.is(gen_results.failures.length, 1);
+    assert.is(gen_results.results.length, 2);
+    assert.is(gen_results.results[0], gen_results.failures[0]);
+    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.reason);
+    assert.ok(result_a.error);
+    const result_b = gen_results.results[1];
+    assert.ok(result_b?.ok);
+    assert.ok(file_b);
+    assert.equal(result_b.files, [
+        {
+            content: file_b.content,
+            id: join(mod_b.id, '../', file_b.filename),
+            origin_id: mod_b.id,
+            format: true,
+        },
+    ]);
+});
+test__gen.run();
+/* test__gen */

package/dist/run_task.d.ts

@@ -0,0 +1,13 @@
+import type { Task_Module_Meta } from './task_module.js';
+import { type Args } from './args.js';
+import type { invoke_task as base_invoke_task } from './invoke_task.js';
+import type { Gro_Config } from './config.js';
+export type Run_Task_Result = {
+    ok: true;
+    output: unknown;
+} | {
+    ok: false;
+    reason: string;
+    error: Error;
+};
+export declare const run_task: (task_meta: Task_Module_Meta, unparsed_args: Args, invoke_task: typeof base_invoke_task, config: Gro_Config, timings: Timings) => Promise<Run_Task_Result>;

package/dist/run_task.js

@@ -0,0 +1,44 @@
+import { cyan, red } from 'kleur/colors';
+import { print_log_label, System_Logger } from '@ryanatkn/belt/log.js';
+import { parse_args } from './args.js';
+import { print_task_help } from './print_task.js';
+import { Task_Error } from './task.js';
+export const run_task = async (task_meta, unparsed_args, invoke_task, config, timings) => {
+    const { task } = task_meta.mod;
+    const log = new System_Logger(print_log_label(task_meta.name));
+    if (unparsed_args.help) {
+        print_task_help(log, task_meta);
+        return { ok: true, output: null };
+    }
+    // Parse and validate args.
+    let args = unparsed_args;
+    if (task.Args) {
+        const parsed = parse_args(unparsed_args, task.Args);
+        if (!parsed.success) {
+            log.error(red(`Args validation failed:`), '\n', parsed.error.format());
+            throw new Task_Error(`Task args failed validation`);
+        }
+        args = parsed.data;
+    }
+    // Run the task.
+    let output;
+    try {
+        output = await task.run({
+            args,
+            config,
+            log,
+            timings,
+            invoke_task: (invoked_task_name, invoked_args = {}, invoked_config) => invoke_task(invoked_task_name, invoked_args, invoked_config || config, timings),
+        });
+    }
+    catch (err) {
+        return {
+            ok: false,
+            reason: red(err?.constructor?.name === 'Task_Error'
+                ? err.message
+                : `Unexpected error running task ${cyan(task_meta.name)}. If this is unexpected try running \`npm i\` and \`gro clean\`.`),
+            error: err,
+        };
+    }
+    return { ok: true, output };
+};

package/dist/run_task.test.d.ts

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

package/dist/run_task.test.js

@@ -0,0 +1,63 @@
+import { test } from 'uvu';
+import * as assert from 'uvu/assert';
+import { Timings } from '@ryanatkn/belt/timings.js';
+import { run_task } from './run_task.js';
+import { load_config } from './config.js';
+test('passes args and returns output', async () => {
+    const args = { a: 1, _: [] };
+    const result = await run_task({
+        name: 'testTask',
+        id: 'foo/testTask',
+        mod: {
+            task: {
+                run: ({ args }) => Promise.resolve(args),
+            },
+        },
+    }, args, () => Promise.resolve(), await load_config(), new Timings());
+    assert.ok(result.ok);
+    assert.is(result.output, args);
+});
+test('invokes a sub task', async () => {
+    const args = { a: 1, _: [] };
+    let invoked_task_name;
+    let invoked_args;
+    const result = await run_task({
+        name: 'testTask',
+        id: 'foo/testTask',
+        mod: {
+            task: {
+                run: async ({ args, invoke_task }) => {
+                    await invoke_task('bar/testTask', args);
+                    return args;
+                },
+            },
+        },
+    }, args, async (invoking_task_name, invoking_args) => {
+        invoked_task_name = invoking_task_name;
+        invoked_args = invoking_args;
+    }, await load_config(), new Timings());
+    assert.ok(result.ok);
+    assert.is(invoked_task_name, 'bar/testTask');
+    assert.is(invoked_args, args);
+    assert.is(result.output, args);
+});
+test('failing task', async () => {
+    let err;
+    const result = await run_task({
+        name: 'testTask',
+        id: 'foo/testTask',
+        mod: {
+            task: {
+                run: async () => {
+                    err = Error();
+                    throw err;
+                },
+            },
+        },
+    }, { _: [] }, async () => { }, // eslint-disable-line @typescript-eslint/no-empty-function
+    await load_config(), new Timings());
+    assert.ok(!result.ok);
+    assert.ok(result.reason);
+    assert.is(result.error, err);
+});
+test.run();

package/dist/search_fs.d.ts

@@ -0,0 +1,11 @@
+import { compare_simple_map_entries } from '@ryanatkn/belt/map.js';
+import type { Path_Stats, Path_Filter } from './path.js';
+export interface Search_Fs_Options {
+    filter?: Path_Filter;
+    /**
+     * Pass `null` to speed things up at the risk of volatile ordering.
+     */
+    sort?: typeof compare_simple_map_entries | null;
+    files_only?: boolean;
+}
+export declare const search_fs: (dir: string, options?: Search_Fs_Options) => Promise<Map<string, Path_Stats>>;

package/dist/search_fs.js

@@ -0,0 +1,22 @@
+import glob from 'tiny-glob';
+import { stat } from 'node:fs/promises';
+import { sort_map, compare_simple_map_entries } from '@ryanatkn/belt/map.js';
+import { strip_end, strip_start } from '@ryanatkn/belt/string.js';
+import { EMPTY_OBJECT } from '@ryanatkn/belt/object.js';
+import { exists } from './fs.js';
+export const search_fs = async (dir, options = EMPTY_OBJECT) => {
+    const { filter, sort = compare_simple_map_entries, files_only = true } = options;
+    const final_dir = strip_end(dir, '/');
+    if (!(await exists(final_dir)))
+        return new Map();
+    const globbed = await glob(final_dir + '/**/*', { absolute: true, filesOnly: files_only });
+    const paths = new Map();
+    await Promise.all(globbed.map(async (g) => {
+        const path = strip_start(g, final_dir + '/');
+        const stats = await stat(g);
+        if (!filter || stats.isDirectory() || filter(path, stats)) {
+            paths.set(path, stats);
+        }
+    }));
+    return sort ? sort_map(paths, sort) : paths;
+};

package/dist/search_fs.test.d.ts

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

package/dist/search_fs.test.js

@@ -0,0 +1,46 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { search_fs } from './search_fs.js';
+import { paths } from './paths.js';
+/* test__search_fs */
+const test__search_fs = suite('search_fs');
+test__search_fs('basic behavior', async () => {
+    const ignored_path = 'test1.foo.ts';
+    let has_ignored_path = false;
+    const result = await search_fs('./src/fixtures', {
+        filter: (path) => {
+            if (!has_ignored_path)
+                has_ignored_path = path.endsWith(ignored_path);
+            return !path.endsWith(ignored_path);
+        },
+        sort: (a, b) => -a[0].localeCompare(b[0]),
+    });
+    assert.ok(has_ignored_path); // makes sure the test isn't wrong
+    assert.equal(Array.from(result.keys()), [
+        'test2.foo.ts',
+        'test_ts.ts',
+        'test_task_module.task_fixture.ts',
+        'test_js.js',
+        'test_invalid_task_module.ts',
+        'test_file.other.ext',
+        'test_failing_task_module.ts',
+        'some_test_side_effect.ts',
+        'some_test_json.json',
+        'some_test_exports3.ts',
+        'some_test_exports2.ts',
+        'some_test_exports.ts',
+        'modules/some_test_ts.ts',
+        'modules/Some_Test_Svelte.svelte',
+        'modules/some_test_json.json',
+        'modules/some_test_css.css',
+        'changelog_example.md',
+        'changelog_cache.json',
+        'baz2/test2.baz.ts',
+        'baz1/test1.baz.ts',
+        'bar2/test2.bar.ts',
+        'bar1/test1.bar.ts',
+    ].map((f) => paths.source + 'fixtures/' + f));
+});
+// TODO more tests
+test__search_fs.run();
+/* test__search_fs */

package/dist/src_json.d.ts

@@ -0,0 +1,256 @@
+import { z } from 'zod';
+import { type Package_Json, type Package_Json_Exports } from './package_json.js';
+export declare const Src_Module_Declaration: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+}, z.ZodTypeAny, "passthrough">>;
+export type Src_Module_Declaration = z.infer<typeof Src_Module_Declaration>;
+export declare const Src_Module: z.ZodObject<{
+    path: z.ZodString;
+    declarations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    path: z.ZodString;
+    declarations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    path: z.ZodString;
+    declarations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, z.ZodTypeAny, "passthrough">>;
+export type Src_Module = z.infer<typeof Src_Module>;
+export declare const Src_Modules: z.ZodRecord<z.ZodString, z.ZodObject<{
+    path: z.ZodString;
+    declarations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    path: z.ZodString;
+    declarations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    path: z.ZodString;
+    declarations: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        name: z.ZodString;
+        kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+}, z.ZodTypeAny, "passthrough">>>;
+export type Src_Modules = z.infer<typeof Src_Modules>;
+/**
+ * @see https://github.com/ryanatkn/gro/blob/main/src/lib/docs/gro_plugin_sveltekit_app.md#well-known-src
+ */
+export declare const Src_Json: z.ZodIntersection<z.ZodRecord<z.ZodString, z.ZodUnknown>, z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodString;
+    modules: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, z.ZodTypeAny, "passthrough">>>, any, Record<string, z.objectInputType<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, z.ZodTypeAny, "passthrough">>>>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    name: z.ZodString;
+    version: z.ZodString;
+    modules: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, z.ZodTypeAny, "passthrough">>>, any, Record<string, z.objectInputType<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, z.ZodTypeAny, "passthrough">>>>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    name: z.ZodString;
+    version: z.ZodString;
+    modules: z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodObject<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, z.ZodTypeAny, "passthrough">>>, any, Record<string, z.objectInputType<{
+        path: z.ZodString;
+        declarations: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+            name: z.ZodString;
+            kind: z.ZodNullable<z.ZodEnum<["type", "function", "variable", "class"]>>;
+        }, z.ZodTypeAny, "passthrough">>, "many">;
+    }, 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 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>;