@fuzdev/gro 0.192.0

package/dist/release.task.js

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { has_sveltekit_library, has_sveltekit_app } from "./sveltekit_helpers.js";
+import { package_json_load } from "./package_json.js";
+/** @nodocs */
+export const Args = z.strictObject({});
+/** @nodocs */
+export const task = {
+    summary: 'publish and deploy',
+    Args,
+    run: async ({ invoke_task }) => {
+        const package_json = await package_json_load();
+        const publish = (await has_sveltekit_library(package_json)).ok;
+        if (publish) {
+            await invoke_task('publish', { optional: true });
+        }
+        if ((await has_sveltekit_app()).ok) {
+            await invoke_task('deploy', { build: !publish });
+        }
+    },
+};

package/dist/resolve.task.d.ts

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    _: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strict>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=resolve.task.d.ts.map

package/dist/resolve.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/resolve.task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAGtB,OAAO,EAAqB,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAGxD,cAAc;AACd,eAAO,MAAM,IAAI;;;kBAGf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA4B3B,CAAC"}

package/dist/resolve.task.js

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { styleText as st } from 'node:util';
+import { TASK_FILE_SUFFIXES } from "./task.js";
+import { resolve_input_paths, to_input_paths } from "./input_path.js";
+/** @nodocs */
+export const Args = z.strictObject({
+    _: z.array(z.string()).meta({ description: 'the input paths to resolve' }).default(['']),
+    verbose: z.boolean().meta({ description: 'log diagnostics' }).default(false),
+});
+/** @nodocs */
+export const task = {
+    summary: 'diagnostic that logs resolved filesystem info for the given input paths',
+    Args,
+    run: async ({ args, config, log }) => {
+        const { _, verbose } = args;
+        if (verbose)
+            log.info('raw input paths:', _);
+        const input_paths = to_input_paths(_);
+        if (verbose)
+            log.info('input paths:', input_paths);
+        const { task_root_dirs } = config;
+        if (verbose)
+            log.info('task root paths:', task_root_dirs);
+        const { resolved_input_paths, possible_paths_by_input_path, unmapped_input_paths } = await resolve_input_paths(input_paths, task_root_dirs, TASK_FILE_SUFFIXES);
+        if (verbose)
+            log.info('resolved_input_paths:', resolved_input_paths);
+        if (verbose)
+            log.info('possible_paths_by_input_path:', possible_paths_by_input_path);
+        if (verbose)
+            log.info('unmapped_input_paths:', unmapped_input_paths);
+        for (const p of resolved_input_paths) {
+            log.info('resolved:', st('green', p.id));
+        }
+        if (!resolved_input_paths.length) {
+            log.warn(st('yellow', 'no input paths were resolved'));
+        }
+    },
+};

package/dist/resolve_specifier.d.ts

@@ -0,0 +1,22 @@
+import type { PathId } from '@fuzdev/fuz_util/path.js';
+export interface ResolvedSpecifier {
+    /**
+     * The resolved filesystem path for the specifier.
+     */
+    path_id: PathId;
+    /**
+     * Same as `path_id` but includes `?raw` and other querystrings. (currently none)
+     */
+    path_id_with_querystring: string;
+    specifier: string;
+    mapped_specifier: string;
+    namespace: undefined | 'sveltekit_local_imports_ts' | 'sveltekit_local_imports_js';
+    raw: boolean;
+}
+/**
+ * Maps an import `specifier` relative to `dir`,
+ * and infer the correct extension following Vite conventions.
+ * If no `.js` file is found for the specifier on the filesystem, it assumes `.ts`.
+ */
+export declare const resolve_specifier: (specifier: string, dir: string) => Promise<ResolvedSpecifier>;
+//# sourceMappingURL=resolve_specifier.d.ts.map

package/dist/resolve_specifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve_specifier.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/resolve_specifier.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAMrD,MAAM,WAAW,iBAAiB;IACjC;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,wBAAwB,EAAE,MAAM,CAAC;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,SAAS,EAAE,SAAS,GAAG,4BAA4B,GAAG,4BAA4B,CAAC;IACnF,GAAG,EAAE,OAAO,CAAC;CACb;AAED;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAC7B,WAAW,MAAM,EACjB,KAAK,MAAM,KACT,OAAO,CAAC,iBAAiB,CAiD3B,CAAC"}

package/dist/resolve_specifier.js

@@ -0,0 +1,57 @@
+import { extname, isAbsolute, join, relative } from 'node:path';
+import { fs_exists } from '@fuzdev/fuz_util/fs.js';
+import { replace_extension } from "./paths.js";
+/**
+ * Maps an import `specifier` relative to `dir`,
+ * and infer the correct extension following Vite conventions.
+ * If no `.js` file is found for the specifier on the filesystem, it assumes `.ts`.
+ */
+export const resolve_specifier = async (specifier, dir) => {
+    const raw = specifier.endsWith('?raw'); // TODO more robust detection? other values?
+    const final_specifier = raw ? specifier.substring(0, specifier.length - 4) : specifier;
+    const absolute_path = isAbsolute(final_specifier) ? final_specifier : join(dir, final_specifier);
+    let mapped_path;
+    let path_id;
+    let namespace;
+    const ext = extname(absolute_path);
+    const is_js = ext === '.js';
+    const is_ts = ext === '.ts';
+    if (!is_js && !is_ts && (await fs_exists(absolute_path))) {
+        // unrecognized extension and the file exists
+        mapped_path = absolute_path;
+        path_id = absolute_path;
+    }
+    else if (is_ts) {
+        // explicitly ts
+        mapped_path = replace_extension(absolute_path, '.js');
+        path_id = absolute_path;
+        namespace = 'sveltekit_local_imports_ts';
+    }
+    else {
+        // extensionless, or js that points to ts, or just js
+        const js_id = is_js ? absolute_path : absolute_path + '.js';
+        const ts_id = is_js ? replace_extension(absolute_path, '.ts') : absolute_path + '.ts';
+        const [ts_exists, js_exists] = await Promise.all([fs_exists(ts_id), fs_exists(js_id)]);
+        if (!ts_exists && js_exists) {
+            mapped_path = js_id;
+            path_id = js_id;
+            namespace = 'sveltekit_local_imports_js';
+        }
+        else {
+            mapped_path = js_id;
+            path_id = ts_id;
+            namespace = 'sveltekit_local_imports_ts';
+        }
+    }
+    let mapped_specifier = relative(dir, mapped_path);
+    if (mapped_specifier[0] !== '.')
+        mapped_specifier = './' + mapped_specifier;
+    return {
+        path_id,
+        path_id_with_querystring: raw ? path_id + '?raw' : path_id,
+        raw,
+        specifier,
+        mapped_specifier,
+        namespace,
+    };
+};

package/dist/run.task.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { type Task } from './task.ts';
+/**
+ * Runs a TypeScript file with Gro's loader, forwarding all args to the script.
+ * Useful for scripts that need SvelteKit shims ($lib, $env, etc).
+ *
+ * @module
+ */
+/** @nodocs */
+export declare const Args: z.ZodObject<{
+    _: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$catchall<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>]>>>;
+export type Args = z.infer<typeof Args>;
+/** @nodocs */
+export declare const task: Task<Args>;
+//# sourceMappingURL=run.task.d.ts.map

package/dist/run.task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/run.task.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAItB,OAAO,EAAY,KAAK,IAAI,EAAC,MAAM,WAAW,CAAC;AAE/C;;;;;GAKG;AAEH,cAAc;AACd,eAAO,MAAM,IAAI;;8JAWf,CAAC;AACH,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AAExC,cAAc;AACd,eAAO,MAAM,IAAI,EAAE,IAAI,CAAC,IAAI,CA+B3B,CAAC"}

package/dist/run.task.js

@@ -0,0 +1,52 @@
+import { args_serialize } from '@fuzdev/fuz_util/args.js';
+import { fs_exists } from '@fuzdev/fuz_util/fs.js';
+import { spawn_result_to_message } from '@fuzdev/fuz_util/process.js';
+import { styleText as st } from 'node:util';
+import { z } from 'zod';
+import { to_implicit_forwarded_args } from "./args.js";
+import { resolve_gro_module_path, spawn_with_loader } from "./gro_helpers.js";
+import { TaskError } from "./task.js";
+/**
+ * Runs a TypeScript file with Gro's loader, forwarding all args to the script.
+ * Useful for scripts that need SvelteKit shims ($lib, $env, etc).
+ *
+ * @module
+ */
+/** @nodocs */
+export const Args = z
+    .object({
+    _: z.array(z.string()).meta({ description: 'the file path to run' }).default([]),
+})
+    .catchall(z.union([
+    z.string(),
+    z.number(),
+    z.boolean(),
+    z.array(z.union([z.string(), z.number(), z.boolean()])),
+]));
+/** @nodocs */
+export const task = {
+    summary: 'execute a file with the loader, like `node` but works for TypeScript',
+    Args,
+    run: async ({ args, log }) => {
+        const { _, ...forwarded_args } = args;
+        const [path, ...positional_argv] = _;
+        if (!path) {
+            log.info(st('green', '\n\nUsage: ') + st('cyan', 'gro run path/to/file.ts [...args]\n'));
+            return;
+        }
+        if (!(await fs_exists(path))) {
+            throw new TaskError('Cannot find file to run at path: ' + path);
+        }
+        // Get args after `--` without requiring a command name.
+        // This allows `gro run script.ts -- --help` to pass --help to the script.
+        const implicit_args = to_implicit_forwarded_args();
+        // Reconstruct argv: positional args + explicit named args + implicit args after --
+        const named_argv = args_serialize({ ...forwarded_args, ...implicit_args });
+        const full_argv = [...positional_argv, ...named_argv];
+        const loader_path = resolve_gro_module_path('loader.js');
+        const spawned = await spawn_with_loader(loader_path, path, full_argv);
+        if (!spawned.ok) {
+            throw new TaskError(`\`gro run ${path}\` failed: ${spawn_result_to_message(spawned)}`);
+        }
+    },
+};

package/dist/run_gen.d.ts

@@ -0,0 +1,10 @@
+import type { Timings } from '@fuzdev/fuz_util/timings.js';
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import { type GenResults, type GenfileModuleMeta } from './gen.ts';
+import type { format_file as base_format_file } from './format_file.ts';
+import type { GroConfig } from './gro_config.ts';
+import type { Filer } from './filer.ts';
+import type { InvokeTask } from './task.ts';
+export declare const GEN_NO_PROD_MESSAGE = "gen runs only during development";
+export declare const run_gen: (gen_modules: Array<GenfileModuleMeta>, config: GroConfig, filer: Filer, log: Logger, timings: Timings, invoke_task: InvokeTask, format_file?: typeof base_format_file) => Promise<GenResults>;
+//# sourceMappingURL=run_gen.d.ts.map

package/dist/run_gen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run_gen.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/run_gen.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AACzD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAGpD,OAAO,EACN,KAAK,UAAU,EAGf,KAAK,iBAAiB,EAItB,MAAM,UAAU,CAAC;AAElB,OAAO,KAAK,EAAC,WAAW,IAAI,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AACtE,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAE/C,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,WAAW,CAAC;AAE1C,eAAO,MAAM,mBAAmB,qCAAqC,CAAC;AAEtE,eAAO,MAAM,OAAO,GACnB,aAAa,KAAK,CAAC,iBAAiB,CAAC,EACrC,QAAQ,SAAS,EACjB,OAAO,KAAK,EACZ,KAAK,MAAM,EACX,SAAS,OAAO,EAChB,aAAa,UAAU,EACvB,cAAc,OAAO,gBAAgB,KACnC,OAAO,CAAC,UAAU,CA6EpB,CAAC"}

package/dist/run_gen.js

@@ -0,0 +1,73 @@
+import { styleText as st } from 'node:util';
+import { print_error } from '@fuzdev/fuz_util/print.js';
+import { map_concurrent } from '@fuzdev/fuz_util/async.js';
+import { to_gen_result, normalize_gen_config, } from "./gen.js";
+import { print_path, to_root_path } from "./paths.js";
+import { default_svelte_config } from "./svelte_config.js";
+export const GEN_NO_PROD_MESSAGE = 'gen runs only during development';
+export const run_gen = async (gen_modules, config, filer, log, timings, invoke_task, format_file) => {
+    let input_count = 0;
+    let output_count = 0;
+    const timing_for_run_gen = timings.start('run_gen');
+    const results = await map_concurrent(gen_modules, async (module_meta) => {
+        input_count++;
+        const { id } = module_meta;
+        const timing_for_module = timings.start(id);
+        const gen_config = normalize_gen_config(module_meta.mod.gen);
+        const gen_ctx = {
+            config,
+            svelte_config: default_svelte_config,
+            filer,
+            log,
+            timings,
+            invoke_task,
+            origin_id: id,
+            origin_path: to_root_path(id),
+            changed_file_id: undefined,
+        };
+        let raw_gen_result;
+        try {
+            raw_gen_result = await gen_config.generate(gen_ctx);
+        }
+        catch (error) {
+            return {
+                ok: false,
+                id,
+                error,
+                reason: st('red', `Error generating ${print_path(id)}`),
+                elapsed: timing_for_module(),
+            };
+        }
+        // Convert the module's return value to a normalized form.
+        const gen_result = to_gen_result(id, raw_gen_result);
+        // Format the files if needed.
+        const files = format_file
+            ? await map_concurrent(gen_result.files, async (file) => {
+                if (!file.format)
+                    return file;
+                try {
+                    return { ...file, content: await format_file(file.content, { filepath: file.id }) };
+                }
+                catch (error) {
+                    log.error(st('red', `Error formatting ${print_path(file.id)} via ${print_path(id)}`), print_error(error));
+                    return file;
+                }
+            }, 10)
+            : gen_result.files;
+        output_count += files.length;
+        return {
+            ok: true,
+            id,
+            files,
+            elapsed: timing_for_module(),
+        };
+    }, 10);
+    return {
+        results,
+        successes: results.filter((r) => r.ok),
+        failures: results.filter((r) => !r.ok),
+        input_count,
+        output_count,
+        elapsed: timing_for_run_gen(),
+    };
+};

package/dist/run_task.d.ts

@@ -0,0 +1,17 @@
+import { type Args } from '@fuzdev/fuz_util/args.js';
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { Timings } from '@fuzdev/fuz_util/timings.js';
+import type { Filer } from './filer.ts';
+import type { GroConfig } from './gro_config.ts';
+import type { invoke_task as base_invoke_task } from './invoke_task.ts';
+import { type TaskModuleMeta } from './task.ts';
+export type RunTaskResult = {
+    ok: true;
+    output: unknown;
+} | {
+    ok: false;
+    reason: string;
+    error: Error;
+};
+export declare const run_task: (task_meta: TaskModuleMeta, unparsed_args: Args, invoke_task: typeof base_invoke_task, config: GroConfig, filer: Filer, log: Logger, timings: Timings) => Promise<RunTaskResult>;
+//# sourceMappingURL=run_task.d.ts.map

package/dist/run_task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run_task.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/run_task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,KAAK,IAAI,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AACpD,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,6BAA6B,CAAC;AAIzD,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,YAAY,CAAC;AACtC,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAC,WAAW,IAAI,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAEtE,OAAO,EAAY,KAAK,cAAc,EAAC,MAAM,WAAW,CAAC;AAGzD,MAAM,MAAM,aAAa,GACtB;IACA,EAAE,EAAE,IAAI,CAAC;IACT,MAAM,EAAE,OAAO,CAAC;CACf,GACD;IACA,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;CACZ,CAAC;AAEL,eAAO,MAAM,QAAQ,GACpB,WAAW,cAAc,EACzB,eAAe,IAAI,EACnB,aAAa,OAAO,gBAAgB,EACpC,QAAQ,SAAS,EACjB,OAAO,KAAK,EACZ,KAAK,MAAM,EACX,SAAS,OAAO,KACd,OAAO,CAAC,aAAa,CAiDvB,CAAC"}

package/dist/run_task.js

@@ -0,0 +1,45 @@
+import { args_parse } from '@fuzdev/fuz_util/args.js';
+import { styleText as st } from 'node:util';
+import { z } from 'zod';
+import { default_svelte_config } from "./svelte_config.js";
+import { TaskError } from "./task.js";
+import { log_task_help } from "./task_logging.js";
+export const run_task = async (task_meta, unparsed_args, invoke_task, config, filer, log, timings) => {
+    const { task } = task_meta.mod;
+    if (unparsed_args.help) {
+        log_task_help(log, task_meta);
+        return { ok: true, output: null };
+    }
+    // Parse and validate args.
+    let args = unparsed_args;
+    if (task.Args) {
+        const parsed = args_parse(unparsed_args, task.Args);
+        if (!parsed.success) {
+            throw new TaskError(`Failed task args validation for task '${task_meta.name}':\n${z.prettifyError(parsed.error)}`);
+        }
+        args = parsed.data;
+    }
+    // Run the task.
+    let output; // TODO generic
+    try {
+        output = await task.run({
+            args,
+            config,
+            svelte_config: default_svelte_config,
+            filer,
+            log,
+            timings,
+            invoke_task: (invoked_task_name, invoked_args, invoked_config) => invoke_task(invoked_task_name, invoked_args, invoked_config ?? config, filer, timings, log),
+        });
+    }
+    catch (error) {
+        return {
+            ok: false,
+            reason: st('red', error?.constructor?.name === 'TaskError'
+                ? error.message
+                : `Unexpected error running task ${st('cyan', task_meta.name)}. If this is unexpected try running \`${config.pm_cli} install\` and \`gro clean\`.`),
+            error,
+        };
+    }
+    return { ok: true, output };
+};

package/dist/source_json.d.ts

@@ -0,0 +1,7 @@
+import type { PackageJson, PackageJsonExports } from '@fuzdev/fuz_util/package_json.js';
+import { SourceJson, type ModuleJson } from '@fuzdev/fuz_util/source_json.js';
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+export type SourceJsonMapper = (source_json: SourceJson) => SourceJson | null | Promise<SourceJson | null>;
+export declare const source_json_create: (package_json: PackageJson, lib_path?: string, log?: Logger) => Promise<SourceJson>;
+export declare const source_json_modules_create: (exports: PackageJsonExports | undefined, lib_path?: string, log?: Logger) => Promise<Array<ModuleJson> | undefined>;
+//# sourceMappingURL=source_json.d.ts.map

package/dist/source_json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source_json.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/source_json.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,WAAW,EAAE,kBAAkB,EAAC,MAAM,kCAAkC,CAAC;AACtF,OAAO,EAAC,UAAU,EAAE,KAAK,UAAU,EAAuB,MAAM,iCAAiC,CAAC;AAClG,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAMpD,MAAM,MAAM,gBAAgB,GAAG,CAC9B,WAAW,EAAE,UAAU,KACnB,UAAU,GAAG,IAAI,GAAG,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAC;AAEpD,eAAO,MAAM,kBAAkB,GAC9B,cAAc,WAAW,EACzB,WAAW,MAAM,EACjB,MAAM,MAAM,KACV,OAAO,CAAC,UAAU,CAKlB,CAAC;AAEJ,eAAO,MAAM,0BAA0B,GACtC,SAAS,kBAAkB,GAAG,SAAS,EACvC,iBAAoB,EACpB,MAAM,MAAM,KACV,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAgDvC,CAAC"}

package/dist/source_json.js

@@ -0,0 +1,145 @@
+import { join } from 'node:path';
+import { ensure_end, strip_start } from '@fuzdev/fuz_util/string.js';
+import { fs_exists, fs_search } from '@fuzdev/fuz_util/fs.js';
+import ts from 'typescript';
+import { SourceJson } from '@fuzdev/fuz_util/source_json.js';
+import { paths, replace_extension } from "./paths.js";
+import { parse_exports } from "./parse_exports.js";
+import { TS_MATCHER, SVELTE_MATCHER, JSON_MATCHER, CSS_MATCHER } from "./constants.js";
+export const source_json_create = async (package_json, lib_path, log) => SourceJson.parse({
+    name: package_json.name,
+    version: package_json.version,
+    modules: await source_json_modules_create(package_json.exports, lib_path, log),
+});
+export const source_json_modules_create = async (exports, lib_path = paths.lib, log) => {
+    if (!exports)
+        return;
+    const file_paths = await collect_file_paths(exports, lib_path);
+    // Create a TypeScript program for all TypeScript files
+    const ts_files = file_paths
+        .filter(({ file_path }) => TS_MATCHER.test(file_path))
+        .map(({ file_path }) => file_path);
+    let program;
+    if (ts_files.length > 0) {
+        program = ts.createProgram(ts_files, 
+        // TODO get from tsconfig?
+        {
+            target: ts.ScriptTarget.ESNext,
+            module: ts.ModuleKind.ESNext,
+            moduleResolution: ts.ModuleResolutionKind.NodeNext,
+            verbatimModuleSyntax: true,
+            isolatedModules: true,
+        });
+    }
+    const result = [];
+    // Process each file
+    for (const { file_path } of file_paths) {
+        const relative_path = file_path.replace(ensure_end(lib_path, '/'), '');
+        const declarations = parse_exports(file_path, program, undefined, log)
+            .filter((d) => d.kind !== null) // TODO maybe dont filter out?
+            .map(({ name, kind }) => ({ name, kind }));
+        result.push(declarations.length
+            ? {
+                path: relative_path,
+                declarations,
+            }
+            : {
+                path: relative_path,
+            });
+    }
+    return result;
+};
+const collect_file_paths = async (exports, lib_path) => {
+    const file_paths = [];
+    // Handle string exports (single default export)
+    if (typeof exports === 'string') {
+        const source_file = await infer_source_from_export(exports, lib_path);
+        if (source_file) {
+            file_paths.push({ export_key: '.', file_path: source_file });
+        }
+        else {
+            throw Error(`Failed to infer source file from package.json string export "${exports}" - no matching file found in ${lib_path}`);
+        }
+        return file_paths;
+    }
+    // Handle object exports
+    for (const k in exports) {
+        // Skip package.json
+        if (k === './package.json')
+            continue;
+        // Check if this is a pattern export
+        if (k.includes('*')) {
+            // Handle pattern exports by finding matching files in lib
+            // eslint-disable-next-line no-await-in-loop
+            const matching_files = await fs_search(lib_path, {
+                file_filter: (path) => {
+                    const p = path.replace(ensure_end(lib_path, '/'), '');
+                    // Only match files in the root directory (no subdirectories)
+                    if (p.includes('/'))
+                        return false;
+                    // Match based on the export pattern
+                    if (k === './*.js') {
+                        return TS_MATCHER.test(p) && !p.endsWith('.d.ts') && !p.endsWith('.test.ts');
+                    }
+                    else if (k === './*.svelte') {
+                        return SVELTE_MATCHER.test(p);
+                    }
+                    else if (k === './*.json') {
+                        return JSON_MATCHER.test(p);
+                    }
+                    else if (k === './*.css') {
+                        return CSS_MATCHER.test(p);
+                    }
+                    return false;
+                },
+            });
+            // Add each matching file
+            for (const file of matching_files) {
+                let export_path;
+                if (file.path.endsWith('.ts')) {
+                    export_path = './' + file.path.replace('.ts', '.js');
+                }
+                else {
+                    export_path = './' + file.path;
+                }
+                file_paths.push({ export_key: export_path, file_path: file.id });
+            }
+        }
+        else {
+            // Handle explicit exports (non-patterns)
+            // eslint-disable-next-line no-await-in-loop
+            const source_file = await infer_source_from_export(k, lib_path);
+            if (source_file) {
+                file_paths.push({ export_key: k, file_path: source_file });
+            }
+            else {
+                throw Error(`Failed to infer source file from package.json export path ${k} - no matching file found in ${lib_path}`);
+            }
+        }
+    }
+    return file_paths;
+};
+const infer_source_from_export = async (export_path, lib_path) => {
+    // Handle index specially
+    if (export_path === '.' || export_path === './') {
+        const index_ts = join(lib_path, 'index.ts');
+        if (await fs_exists(index_ts))
+            return index_ts;
+        const index_js = join(lib_path, 'index.js');
+        if (await fs_exists(index_js))
+            return index_js;
+        return null;
+    }
+    const clean_path = strip_start(export_path, './');
+    // For .js exports, try .ts first
+    if (clean_path.endsWith('.js')) {
+        const ts_path = join(lib_path, replace_extension(clean_path, '.ts'));
+        if (await fs_exists(ts_path))
+            return ts_path;
+    }
+    // Try the exact path
+    const exact_path = join(lib_path, clean_path);
+    if (await fs_exists(exact_path))
+        return exact_path;
+    return null;
+};

package/dist/svelte_config.d.ts

@@ -0,0 +1,57 @@
+import type { Config as SvelteConfig } from '@sveltejs/kit';
+import type { CompileOptions, ModuleCompileOptions, PreprocessorGroup } from 'svelte/compiler';
+/**
+ * Loads a SvelteKit config at `dir`.
+ * @returns `null` if no config is found
+ */
+export declare const load_svelte_config: ({ dir, config_filename, }?: {
+    dir?: string;
+    config_filename?: string;
+}) => Promise<SvelteConfig | null>;
+/**
+ * A subset of SvelteKit's config in a form that Gro uses
+ * because SvelteKit doesn't expose its config resolver.
+ * Flattens things out to keep them simple and easy to pass around,
+ * and doesn't deal with most properties, but includes the full `svelte_config`.
+ * The `base` and `assets` in particular are renamed for clarity with Gro's internal systems,
+ * so these properties become first-class vocabulary inside Gro.
+ */
+export interface ParsedSvelteConfig {
+    svelte_config: SvelteConfig | null;
+    alias: Record<string, string>;
+    base_url: '' | `/${string}` | undefined;
+    assets_url: '' | `http://${string}` | `https://${string}` | undefined;
+    /**
+     * Same as the SvelteKit `files.assets`.
+     */
+    assets_path: string;
+    /**
+     * Same as the SvelteKit `files.lib`.
+     */
+    lib_path: string;
+    /**
+     * Same as the SvelteKit `files.routes`.
+     */
+    routes_path: string;
+    env_dir: string | undefined;
+    private_prefix: string | undefined;
+    public_prefix: string | undefined;
+    svelte_compile_options: CompileOptions;
+    svelte_compile_module_options: ModuleCompileOptions;
+    svelte_preprocessors: PreprocessorGroup | Array<PreprocessorGroup> | undefined;
+}
+/**
+ * Returns Gro-relevant properties of a SvelteKit config
+ * as a convenience wrapper around `load_svelte_config`.
+ * Needed because SvelteKit doesn't expose its config resolver.
+ */
+export declare const parse_svelte_config: ({ dir_or_config, config_filename, }?: {
+    dir_or_config?: string | SvelteConfig;
+    config_filename?: string;
+}) => Promise<ParsedSvelteConfig>;
+export declare const to_default_compile_module_options: ({ dev, generate, filename, rootDir, warningFilter, }: CompileOptions) => ModuleCompileOptions;
+/**
+ * The parsed SvelteKit config for the cwd, cached globally at the module level.
+ */
+export declare const default_svelte_config: ParsedSvelteConfig;
+//# sourceMappingURL=svelte_config.d.ts.map

package/dist/svelte_config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte_config.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte_config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,IAAI,YAAY,EAAC,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAC,cAAc,EAAE,oBAAoB,EAAE,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AAe7F;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAU,4BAGtC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,CAAA;CAAgB,KAAG,OAAO,CAAC,YAAY,GAAG,IAAI,CAMvF,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAElC,aAAa,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B,QAAQ,EAAE,EAAE,GAAG,IAAI,MAAM,EAAE,GAAG,SAAS,CAAC;IACxC,UAAU,EAAE,EAAE,GAAG,UAAU,MAAM,EAAE,GAAG,WAAW,MAAM,EAAE,GAAG,SAAS,CAAC;IAGtE;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB,OAAO,EAAE,MAAM,GAAG,SAAS,CAAC;IAC5B,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,sBAAsB,EAAE,cAAc,CAAC;IACvC,6BAA6B,EAAE,oBAAoB,CAAC;IACpD,oBAAoB,EAAE,iBAAiB,GAAG,KAAK,CAAC,iBAAiB,CAAC,GAAG,SAAS,CAAC;CAC/E;AAGD;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAU,sCAGvC;IACF,aAAa,CAAC,EAAE,MAAM,GAAG,YAAY,CAAC;IACtC,eAAe,CAAC,EAAE,MAAM,CAAC;CACV,KAAG,OAAO,CAAC,kBAAkB,CA8C5C,CAAC;AAEF,eAAO,MAAM,iCAAiC,GAAI,sDAM/C,cAAc,KAAG,oBAA2E,CAAC;AAEhG;;GAEG;AACH,eAAO,MAAM,qBAAqB,oBAA8B,CAAC"}