@ryanatkn/gro 0.173.1 → 0.174.0

package/src/lib/dev.task.ts

@@ -4,6 +4,7 @@ import type {Task} from './task.ts';
 import {Plugins, type Plugin_Context} from './plugin.ts';
 import {clean_fs} from './clean_fs.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({
 	watch: z.boolean().meta({description: 'dual of no-watch'}).default(true),
 	'no-watch': z
@@ -20,6 +21,7 @@ export type Args = z.infer<typeof Args>;
 
 export type DevTask_Context = Plugin_Context<Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'start SvelteKit and other dev plugins',
 	Args,

package/src/lib/filer.ts

@@ -1,5 +1,5 @@
 import {EMPTY_OBJECT} from '@ryanatkn/belt/object.js';
-import {existsSync, readFileSync, statSync} from 'node:fs';
+import {readFileSync, statSync} from 'node:fs';
 import {dirname, resolve} from 'node:path';
 import type {Omit_Strict} from '@ryanatkn/belt/types.js';
 import {isBuiltin} from 'node:module';
@@ -217,13 +217,23 @@ export class Filer {
 	#update(id: Path_Id): Disknode | null {
 		const file = this.get_or_create(id);
 
-		const stats = existsSync(id) ? statSync(id) : null;
+		let stats: ReturnType<typeof statSync> | null = null;
+		let new_contents: string | null = null; // TODO need to lazily load contents, probably turn `Disknode` into a class
+
+		try {
+			stats = statSync(id);
+			new_contents = readFileSync(id, 'utf8');
+		} catch (err) {
+			if ((err as NodeJS.ErrnoException).code !== 'ENOENT') {
+				throw err;
+			}
+			// ENOENT: file doesn't exist, treat as deleted
+		}
+
 		const old_mtime = file.mtime;
 		file.ctime = stats?.ctimeMs ?? null;
 		file.mtime = stats?.mtimeMs ?? null;
 
-		const new_contents = stats ? readFileSync(id, 'utf8') : null; // TODO need to lazily load contents, probably turn `Disknode` into a class
-
 		if (file.mtime === old_mtime && file.contents === new_contents) {
 			return null;
 		}

package/src/lib/format.task.ts

@@ -5,6 +5,7 @@ import {Task_Error, type Task} from './task.ts';
 import {format_directory} from './format_directory.ts';
 import {paths} from './paths.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({
 	check: z
 		.boolean()
@@ -13,6 +14,7 @@ export const Args = z.strictObject({
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'format source files',
 	Args,

package/src/lib/gen.task.ts

@@ -19,6 +19,7 @@ import {
 } from './gen.ts';
 import {SOURCE_DIRNAME} from './constants.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({
 	_: z
 		.array(Raw_Input_Path)
@@ -35,6 +36,7 @@ export const Args = z.strictObject({
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'run code generation scripts',
 	Args,

package/src/lib/gro_config.ts

@@ -16,7 +16,7 @@ import {
 } from './constants.ts';
 import create_default_config from './gro.config.default.ts';
 import type {Create_Config_Plugins} from './plugin.ts';
-import type {Map_Package_Json} from './package_json.ts';
+import type {Package_Json_Mapper} from './package_json.ts';
 import type {Parsed_Svelte_Config} from './svelte_config.ts';
 import {to_hash} from './hash.ts';
 
@@ -42,7 +42,7 @@ export interface Gro_Config extends Raw_Gro_Config {
 	 * The `package_json` argument may be mutated, but the return value is what's used by the caller.
 	 * Returning `null` is a no-op for the caller.
 	 */
-	map_package_json: Map_Package_Json | null;
+	map_package_json: Package_Json_Mapper | null;
 	/**
 	 * The root directories to search for tasks given implicit relative input paths.
 	 * Defaults to `./src/lib`, then the cwd, then the Gro package dist.
@@ -79,7 +79,7 @@ export interface Gro_Config extends Raw_Gro_Config {
  */
 export interface Raw_Gro_Config {
 	plugins?: Create_Config_Plugins;
-	map_package_json?: Map_Package_Json | null;
+	map_package_json?: Package_Json_Mapper | null;
 	task_root_dirs?: Array<string>;
 	search_filters?: Path_Filter | Array<Path_Filter> | null;
 	js_cli?: string;

package/src/lib/gro_plugin_sveltekit_app.ts

@@ -4,10 +4,14 @@ import {dirname, join} from 'node:path';
 
 import type {Plugin} from './plugin.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
-import {serialize_package_json, type Map_Package_Json, load_package_json} from './package_json.ts';
+import {
+	serialize_package_json,
+	type Package_Json_Mapper,
+	load_package_json,
+} from './package_json.ts';
 import {Task_Error} from './task.ts';
 import {find_cli, spawn_cli, spawn_cli_process} from './cli.ts';
-import {type Map_Src_Json, serialize_src_json, create_src_json} from './src_json.ts';
+import {type Src_Json_Mapper, src_json_serialize, src_json_create} from './src_json.ts';
 import {EXPORTS_EXCLUDER_DEFAULT} from './gro_config.ts';
 import {default_svelte_config} from './svelte_config.ts';
 import {SOURCE_DIRNAME, VITE_CLI} from './constants.ts';
@@ -23,13 +27,13 @@ export interface Gro_Plugin_Sveltekit_App_Options {
 	 * If truthy, adds `/.well-known/package.json` to the static output.
 	 * If a function, maps the value.
 	 */
-	well_known_package_json?: boolean | Map_Package_Json;
+	well_known_package_json?: boolean | Package_Json_Mapper;
 
 	/**
 	 * If truthy, adds `/.well-known/src.json` and `/.well-known/src/` to the static output.
 	 * If a function, maps the value.
 	 */
-	well_known_src_json?: boolean | Map_Src_Json;
+	well_known_src_json?: boolean | Src_Json_Mapper;
 
 	/**
 	 * If truthy, copies `src/` to `/.well-known/src/` to the static output.
@@ -91,7 +95,7 @@ export const gro_plugin_sveltekit_app = ({
 
 				// `.well-known/src.json` and `.well-known/src/`
 				const final_package_json = mapped_package_json ?? package_json;
-				const src_json = create_src_json(final_package_json, undefined, log);
+				const src_json = src_json_create(final_package_json, undefined, log);
 				if (well_known_src_json === undefined) {
 					well_known_src_json = final_package_json.public; // eslint-disable-line no-param-reassign
 				}
@@ -100,7 +104,7 @@ export const gro_plugin_sveltekit_app = ({
 					: well_known_src_json === true
 						? src_json
 						: await well_known_src_json(src_json);
-				const serialized_src_json = mapped_src_json && serialize_src_json(mapped_src_json);
+				const serialized_src_json = mapped_src_json && src_json_serialize(mapped_src_json);
 
 				// TODO this strategy means the files aren't available during development --
 				// maybe a Vite middleware is best? what if this plugin added its plugin to your `vite.config.ts`?

package/src/lib/index.ts

@@ -1,4 +1,8 @@
+/** @nodocs */
 export type {Gro_Config, Create_Gro_Config, Raw_Gro_Config} from './gro_config.ts';
+/** @nodocs */
 export {type Plugin, replace_plugin} from './plugin.ts';
+/** @nodocs */
 export type {Gen, Gen_Context} from './gen.ts';
+/** @nodocs */
 export {type Task, type Task_Context, Task_Error} from './task.ts';

package/src/lib/lint.task.ts

@@ -7,12 +7,14 @@ import {find_cli, spawn_cli} from './cli.ts';
 
 const ESLINT_CLI = 'eslint';
 
+/** @nodocs */
 export const Args = z.strictObject({
 	_: z.array(z.string()).meta({description: 'paths to serve'}).default([]),
 	eslint_cli: z.string().meta({description: 'the ESLint CLI to use'}).default(ESLINT_CLI),
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'run eslint',
 	Args,

package/src/lib/loader.ts

@@ -76,6 +76,7 @@ const aliases = Object.entries(alias);
 const RAW_MATCHER = /(%3Fraw|\.css|\.svg)$/; // TODO others? configurable?
 const NODE_MODULES_MATCHER = new RegExp(escape_regexp('/' + NODE_MODULES_DIRNAME + '/'), 'u');
 
+/** @nodocs */
 export const load: LoadHook = async (url, context, nextLoad) => {
 	// console.log(`url`, url);
 	if (SVELTEKIT_SHIM_APP_PATHS_MATCHER.test(url)) {
@@ -184,6 +185,7 @@ export const load: LoadHook = async (url, context, nextLoad) => {
 	return nextLoad(url, context);
 };
 
+/** @nodocs */
 export const resolve: ResolveHook = async (specifier, context, nextResolve) => {
 	let s = specifier;
 

package/src/lib/package_json.ts

@@ -20,7 +20,7 @@ import {search_fs} from './search_fs.ts';
 import {has_sveltekit_library} from './sveltekit_helpers.ts';
 import {GITHUB_REPO_MATCHER} from './github.ts';
 
-export type Map_Package_Json = (
+export type Package_Json_Mapper = (
 	package_json: Package_Json,
 ) => Package_Json | null | Promise<Package_Json | null>;
 
@@ -52,7 +52,7 @@ export const load_package_json = (
 };
 
 export const sync_package_json = async (
-	map_package_json: Map_Package_Json,
+	map_package_json: Package_Json_Mapper,
 	log: Logger,
 	write = true,
 	dir = paths.root,

package/src/lib/parse_exports.ts

@@ -2,7 +2,7 @@ import ts from 'typescript';
 import {extname} from 'node:path';
 import type {Flavored} from '@ryanatkn/belt/types.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
-import type {Src_Module_Declaration_Kind} from '@ryanatkn/belt/src_json.js';
+import type {Identifier_Kind} from '@ryanatkn/belt/src_json.js';
 import type {Path_Id} from '@ryanatkn/belt/path.js';
 
 import {TS_MATCHER} from './constants.ts';
@@ -10,7 +10,7 @@ import {Parse_Exports_Context} from './parse_exports_context.ts';
 
 export interface Declaration {
 	name: string;
-	kind: Src_Module_Declaration_Kind | null;
+	kind: Identifier_Kind | null;
 }
 
 export type Export_Declaration = Flavored<Declaration, 'Export_Declaration'>;

package/src/lib/parse_exports_context.ts

@@ -1,6 +1,6 @@
 import ts from 'typescript';
 import type {Logger} from '@ryanatkn/belt/log.js';
-import type {Src_Module_Declaration_Kind} from '@ryanatkn/belt/src_json.js';
+import type {Identifier_Kind} from '@ryanatkn/belt/src_json.js';
 
 import type {Export_Declaration} from './parse_exports.ts';
 
@@ -13,7 +13,7 @@ export class Parse_Exports_Context {
 	// Map of source file paths to their symbols
 	readonly #file_symbols: Map<string, ts.Symbol> = new Map();
 	// Cache for resolved symbols to avoid repeated resolution
-	readonly #symbol_kind_cache: Map<ts.Symbol, Src_Module_Declaration_Kind> = new Map();
+	readonly #symbol_kind_cache: Map<ts.Symbol, Identifier_Kind> = new Map();
 
 	readonly log: Logger | undefined;
 	debug = process.env.DEBUG_EXPORTS === 'true';
@@ -75,10 +75,7 @@ export class Parse_Exports_Context {
 	/**
 	 * Determine the kind of an export based on its symbol.
 	 */
-	#determine_export_kind(
-		source_file: ts.SourceFile,
-		symbol: ts.Symbol,
-	): Src_Module_Declaration_Kind {
+	#determine_export_kind(source_file: ts.SourceFile, symbol: ts.Symbol): Identifier_Kind {
 		// Check if this is a type-only export (no value export)
 		if (this.#is_type_only_export(source_file, symbol)) {
 			return 'type';
@@ -118,7 +115,7 @@ export class Parse_Exports_Context {
 	/**
 	 * Infer the declaration kind from a symbol's declaration and type information.
 	 */
-	#infer_declaration_kind(symbol: ts.Symbol): Src_Module_Declaration_Kind {
+	#infer_declaration_kind(symbol: ts.Symbol): Identifier_Kind {
 		// Check symbol flags first for direct type matching
 		if (this.#is_class_symbol(symbol)) {
 			return 'class';
@@ -185,7 +182,7 @@ export class Parse_Exports_Context {
 	/**
 	 * Infer the declaration kind from a specific declaration node.
 	 */
-	#infer_kind_from_declaration(decl: ts.Declaration): Src_Module_Declaration_Kind | null {
+	#infer_kind_from_declaration(decl: ts.Declaration): Identifier_Kind | null {
 		if (ts.isFunctionDeclaration(decl)) {
 			return 'function';
 		}

package/src/lib/publish.task.ts

@@ -19,6 +19,7 @@ import {update_changelog} from './changelog.ts';
 import {load_from_env} from './env.ts';
 import {CHANGESET_CLI} from './changeset_helpers.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({
 	branch: Git_Branch.describe('branch to publish from').default('main'),
 	origin: Git_Origin.describe('git origin to publish from').default('origin'),
@@ -50,10 +51,18 @@ export const Args = z.strictObject({
 	'no-build': z.boolean().meta({description: 'opt out of building'}).default(false),
 	pull: z.boolean().meta({description: 'dual of no-pull'}).default(true),
 	'no-pull': z.boolean().meta({description: 'opt out of git pull'}).default(false),
+	sync: z.boolean().meta({description: 'dual of no-sync'}).default(true),
+	'no-sync': z.boolean().meta({description: 'opt out of gro sync'}).default(false),
+	install: z.boolean().meta({description: 'dual of no-install'}).default(true),
+	'no-install': z
+		.boolean()
+		.meta({description: 'opt out of installing packages before publishing'})
+		.default(false),
 	changeset_cli: z.string().meta({description: 'the changeset CLI to use'}).default(CHANGESET_CLI),
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'bump version, publish to the configured registry, and git push',
 	Args,
@@ -67,6 +76,8 @@ export const task: Task<Args> = {
 			check,
 			build,
 			pull,
+			sync,
+			install,
 			optional,
 			changeset_cli,
 		} = args;
@@ -104,7 +115,11 @@ export const task: Task<Args> = {
 
 		// Install packages to ensure deps are current.
 		// Handles cases like branch switches where package.json changed.
-		await invoke_task('sync', {install: true});
+		// Skip gen because it will run after version bump.
+		if (sync || install) {
+			if (!sync) log.warn('sync is false but install is true, so running sync for install only');
+			await invoke_task('sync', {install, gen: false});
+		}
 
 		// Check before proceeding, defaults to true.
 		if (check) {
@@ -151,6 +166,10 @@ export const task: Task<Args> = {
 				await update_changelog(parsed_repo_url.owner, parsed_repo_url.repo, changelog, token, log);
 			}
 
+			// Regenerate files that depend on package.json version.
+			// The check above ensures gen is updated.
+			await invoke_task('gen');
+
 			const package_json_after_versioning = load_package_json();
 			version = package_json_after_versioning.version!;
 			if (package_json.version === version) {

package/src/lib/reinstall.task.ts

@@ -5,9 +5,11 @@ import {rm} from 'node:fs/promises';
 import {Task_Error, type Task} from './task.ts';
 import {LOCKFILE_FILENAME, NODE_MODULES_DIRNAME} from './constants.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({});
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: `refreshes ${LOCKFILE_FILENAME} with the latest and cleanest deps`,
 	Args,

package/src/lib/release.task.ts

@@ -4,9 +4,11 @@ import type {Task} from './task.ts';
 import {has_sveltekit_library, has_sveltekit_app} from './sveltekit_helpers.ts';
 import {load_package_json} from './package_json.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({});
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'publish and deploy',
 	Args,

package/src/lib/resolve.task.ts

@@ -4,12 +4,14 @@ import {styleText as st} from 'node:util';
 import {TASK_FILE_SUFFIXES, type Task} from './task.ts';
 import {resolve_input_paths, to_input_paths} from './input_path.ts';
 
+/** @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),
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'diagnostic that logs resolved filesystem info for the given input paths',
 	Args,

package/src/lib/run.task.ts

@@ -9,6 +9,7 @@ import {resolve_gro_module_path, spawn_with_loader} from './gro_helpers.ts';
 // and I'm not using it for anything that couldn't be done with Node directly atm.
 // It could potentially be more useful if I keep building on the task system.
 
+/** @nodocs */
 export const Args = z.strictObject({
 	_: z
 		.array(z.string())
@@ -17,6 +18,7 @@ export const Args = z.strictObject({
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'execute a file with the loader, like `node` but works for TypeScript',
 	Args,

package/src/lib/src_json.ts

@@ -3,7 +3,7 @@ import {ensure_end, strip_start} from '@ryanatkn/belt/string.js';
 import {existsSync} from 'node:fs';
 import ts from 'typescript';
 import type {Package_Json, Package_Json_Exports} from '@ryanatkn/belt/package_json.js';
-import {Src_Json, Src_Modules} from '@ryanatkn/belt/src_json.js';
+import {Src_Json, type Module_Json, type Identifier_Kind} from '@ryanatkn/belt/src_json.js';
 import type {Logger} from '@ryanatkn/belt/log.js';
 
 import {paths, replace_extension} from './paths.ts';
@@ -11,9 +11,9 @@ import {parse_exports} from './parse_exports.ts';
 import {TS_MATCHER, SVELTE_MATCHER, JSON_MATCHER, CSS_MATCHER} from './constants.ts';
 import {search_fs} from './search_fs.ts';
 
-export type Map_Src_Json = (src_json: Src_Json) => Src_Json | null | Promise<Src_Json | null>;
+export type Src_Json_Mapper = (src_json: Src_Json) => Src_Json | null | Promise<Src_Json | null>;
 
-export const create_src_json = (
+export const src_json_create = (
 	package_json: Package_Json,
 	lib_path?: string,
 	log?: Logger,
@@ -21,19 +21,19 @@ export const create_src_json = (
 	Src_Json.parse({
 		name: package_json.name,
 		version: package_json.version,
-		modules: to_src_modules(package_json.exports, lib_path, log),
+		modules: src_modules_create(package_json.exports, lib_path, log),
 	});
 
-export const serialize_src_json = (src_json: Src_Json): string => {
-	const parsed = Src_Json.parse(src_json); // TODO can parse do the logic that normalize does? see `.transform`
+export const src_json_serialize = (src_json: Src_Json): string => {
+	const parsed = Src_Json.parse(src_json);
 	return JSON.stringify(parsed, null, 2) + '\n';
 };
 
-export const to_src_modules = (
+export const src_modules_create = (
 	exports: Package_Json_Exports | undefined,
 	lib_path = paths.lib,
 	log?: Logger,
-): Src_Modules | undefined => {
+): Array<Module_Json> | undefined => {
 	if (!exports) return;
 
 	const file_paths = collect_file_paths(exports, lib_path);
@@ -58,25 +58,26 @@ export const to_src_modules = (
 		);
 	}
 
-	const result: Src_Modules = {};
+	const result: Array<Module_Json> = [];
 
 	// Process each file
-	for (const {export_key, file_path} of file_paths) {
+	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).map(({name, kind}) => ({
-			name,
-			kind,
-		}));
+		const identifiers = parse_exports(file_path, program, undefined, log)
+			.filter((d): d is {name: string; kind: Identifier_Kind} => d.kind !== null) // TODO maybe dont filter out?
+			.map(({name, kind}) => ({name, kind}));
 
-		result[export_key] = declarations.length
-			? {
-					path: relative_path,
-					declarations,
-				}
-			: {
-					path: relative_path,
-				};
+		result.push(
+			identifiers.length
+				? {
+						path: relative_path,
+						identifiers,
+					}
+				: {
+						path: relative_path,
+					},
+		);
 	}
 
 	return result;

package/src/lib/sync.task.ts

@@ -5,6 +5,7 @@ import {Task_Error, type Task} from './task.ts';
 import {sync_package_json} from './package_json.ts';
 import {sveltekit_sync} from './sveltekit_helpers.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({
 	sveltekit: z.boolean().meta({description: 'dual of no-sveltekit'}).default(true),
 	'no-sveltekit': z.boolean().meta({description: 'opt out of svelte-kit sync'}).default(false),
@@ -16,6 +17,7 @@ export const Args = z.strictObject({
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'run `gro gen`, update `package.json`, and optionally install packages to sync up',
 	Args,

package/src/lib/test.task.ts

@@ -8,6 +8,7 @@ import {serialize_args, to_implicit_forwarded_args} from './args.ts';
 import {VITEST_CLI} from './constants.ts';
 import {paths} from './paths.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({
 	_: z.array(z.string()).meta({description: 'file patterns to filter tests'}).default(['.test.']),
 	dir: z.string().meta({description: 'working directory for tests'}).default(paths.source),
@@ -22,6 +23,7 @@ export const Args = z.strictObject({
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'run tests with vitest',
 	Args,

package/src/lib/typecheck.task.ts

@@ -9,6 +9,7 @@ import {configure_colored_output_with_path_replacement} from './child_process_lo
 import {paths} from './paths.ts';
 import {SVELTE_CHECK_CLI} from './constants.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({
 	svelte_check_cli: z
 		.string()
@@ -26,6 +27,7 @@ export const Args = z.strictObject({
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'run svelte-check or tsc on the project without emitting any files',
 	Args,

package/src/lib/upgrade.task.ts

@@ -9,6 +9,7 @@ import {spawn_cli} from './cli.ts';
 import {serialize_args, to_forwarded_args} from './args.ts';
 import {NODE_MODULES_DIRNAME} from './constants.ts';
 
+/** @nodocs */
 export const Args = z.strictObject({
 	_: z
 		.array(z.string())
@@ -45,6 +46,7 @@ export const Args = z.strictObject({
 });
 export type Args = z.infer<typeof Args>;
 
+/** @nodocs */
 export const task: Task<Args> = {
 	summary: 'upgrade deps',
 	Args,

package/dist/package.d.ts

@@ -1,5 +0,0 @@
-import type { Package_Json } from '@ryanatkn/belt/package_json.js';
-import type { Src_Json } from '@ryanatkn/belt/src_json.js';
-export declare const package_json: Package_Json;
-export declare const src_json: Src_Json;
-//# sourceMappingURL=package.d.ts.map

package/dist/package.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/package.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,4BAA4B,CAAC;AAEzD,eAAO,MAAM,YAAY,EAAE,YAkGnB,CAAC;AAET,eAAO,MAAM,QAAQ,EAAE,QAuwBf,CAAC"}

package/dist/package.gen.d.ts

@@ -1,8 +0,0 @@
-import type { Gen } from './gen.ts';
-/**
- * A convenience `gen` file that outputs `$lib/package.ts`,
- * which mirrors `package.json` but in TypeScript,
- * allowing apps to import typesafe data from their own `package.json`.
- */
-export declare const gen: Gen;
-//# sourceMappingURL=package.gen.d.ts.map

package/dist/package.gen.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"package.gen.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/package.gen.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,GAAG,EAAC,MAAM,UAAU,CAAC;AAMlC;;;;GAIG;AACH,eAAO,MAAM,GAAG,EAAE,GAwBjB,CAAC"}

package/dist/package.gen.js

@@ -1,30 +0,0 @@
-import { load_package_json } from "./package_json.js";
-import { create_src_json } from "./src_json.js";
-// TODO rename? `Package_Json + Src_Json = package.ts` currently, idk
-// TODO consider an api that uses magic imports like SvelteKit's `$app`, like `$repo/package.json`
-/**
- * A convenience `gen` file that outputs `$lib/package.ts`,
- * which mirrors `package.json` but in TypeScript,
- * allowing apps to import typesafe data from their own `package.json`.
- */
-export const gen = ({ origin_path, log }) => {
-    const package_json = load_package_json();
-    // TODO this can error with bad json data, do we need to update the package.json here first?
-    // similarly do this in other places too?
-    // part of the problem is that the package_json actually has a dependency on each of its exports and their deps,
-    // but only when they're added/removed right? see gro_plugin_gen for details
-    const src_json = create_src_json(package_json, undefined, log);
-    const is_this_belt = package_json.name === '@ryanatkn/belt'; // TODO more robust?
-    return `
-// generated by ${origin_path}
-
-import type {Package_Json} from '${is_this_belt ? '$lib/package_json.js' : '@ryanatkn/belt/package_json.js'}';
-import type {Src_Json} from '${is_this_belt ? '$lib/src_json.js' : '@ryanatkn/belt/src_json.js'}';
-
-export const package_json: Package_Json = ${JSON.stringify(package_json)} as any;
-
-export const src_json: Src_Json = ${JSON.stringify(src_json)} as any;
-
-// generated by ${origin_path}
-	`;
-};