@ryanatkn/gro 0.129.3 → 0.129.5

package/src/lib/package_json.test.ts

@@ -0,0 +1,101 @@
+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', () => {
+	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', () => {
+	const cache = {};
+	const package_json1 = load_package_json(undefined, cache);
+	assert.ok(package_json1);
+	assert.is(Object.keys(cache).length, 1);
+	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', () => {
+	Package_Json.parse({name: 'abc', version: '123'});
+});
+
+test('Package_Json.parse fails with bad data', () => {
+	let err;
+	try {
+		Package_Json.parse({version: '123'});
+	} catch (_err) {
+		err = _err;
+	}
+	assert.ok(err);
+});
+
+test('serialize_package_json', () => {
+	serialize_package_json({name: 'abc', version: '123'});
+});
+
+test('serialize_package_json fails with bad data', () => {
+	let err;
+	try {
+		serialize_package_json({version: '123'} as any);
+	} catch (_err) {
+		err = _err;
+	}
+	assert.ok(err);
+});
+
+test('to_package_exports', () => {
+	assert.equal(to_package_exports(['a/b.ts']), {
+		'./package.json': './package.json',
+		'./a/b.js': {
+			default: './dist/a/b.js',
+			types: './dist/a/b.d.ts',
+		},
+	});
+	assert.equal(
+		to_package_exports([
+			'a/b/Some_Test_Svelte.svelte',
+			'a/b/some_test_ts.ts',
+			'a/b/some_test_json.json',
+			'index.ts',
+		]),
+		{
+			'.': {
+				default: './dist/index.js',
+				types: './dist/index.d.ts',
+			},
+			'./package.json': './package.json',
+			'./a/b/some_test_json.json': {
+				default: './dist/a/b/some_test_json.json',
+			},
+			'./a/b/Some_Test_Svelte.svelte': {
+				svelte: './dist/a/b/Some_Test_Svelte.svelte',
+				default: './dist/a/b/Some_Test_Svelte.svelte',
+				types: './dist/a/b/Some_Test_Svelte.svelte.d.ts',
+			},
+			'./a/b/some_test_ts.js': {
+				default: './dist/a/b/some_test_ts.js',
+				types: './dist/a/b/some_test_ts.d.ts',
+			},
+		},
+	);
+});
+
+test('parse_repo_url', () => {
+	const parsed = parse_repo_url(load_package_json());
+	assert.is(parsed?.owner, 'ryanatkn');
+	assert.is(parsed?.repo, 'gro');
+});
+
+test.run();

package/src/lib/package_json.ts

@@ -0,0 +1,330 @@
+import {z} from 'zod';
+import {join} from 'node:path';
+import {readFileSync, writeFileSync} from 'node:fs';
+import {count_graphemes, plural, strip_end} from '@ryanatkn/belt/string.js';
+import type {Logger} from '@ryanatkn/belt/log.js';
+import type {Flavored} from '@ryanatkn/belt/types.js';
+import {red} from '@ryanatkn/belt/styletext.js';
+
+import {paths, gro_paths, IS_THIS_GRO, replace_extension} from './paths.js';
+import {SVELTEKIT_DIST_DIRNAME} from './path_constants.js';
+import {search_fs} from './search_fs.js';
+import {has_sveltekit_library} from './sveltekit_helpers.js';
+import {GITHUB_REPO_MATCHER} from './github.js';
+
+// TODO @multiple belongs elsewhere
+export const Url = z.string();
+export type Url = Flavored<z.infer<typeof Url>, 'Url'>;
+
+// TODO @multiple belongs elsewhere
+export const Email = z.string();
+export type Email = Flavored<z.infer<typeof Email>, 'Email'>;
+
+// TODO move this where?
+export const transform_empty_object_to_undefined = (val: any): any => {
+	if (val && Object.keys(val).length === 0) {
+		return;
+	}
+	return val;
+};
+
+export const Package_Json_Repository = z.union([
+	z.string(),
+	z
+		.object({
+			type: z.string(),
+			url: Url,
+			directory: z.string().optional(),
+		})
+		.passthrough(),
+]);
+export type Package_Json_Repository = z.infer<typeof Package_Json_Repository>;
+
+export const Package_Json_Author = z.union([
+	z.string(),
+	z
+		.object({
+			name: z.string(),
+			email: Email.optional(),
+			url: Url.optional(),
+		})
+		.passthrough(),
+]);
+export type Package_Json_Author = z.infer<typeof Package_Json_Author>;
+
+export const Package_Json_Funding = z.union([
+	z.string(),
+	z
+		.object({
+			type: z.string(),
+			url: Url,
+		})
+		.passthrough(),
+]);
+export type Package_Json_Funding = z.infer<typeof Package_Json_Funding>;
+
+export const Package_Json_Exports = z.record(
+	z.union([z.string(), z.record(z.string())]).optional(),
+);
+export type Package_Json_Exports = z.infer<typeof Package_Json_Exports>;
+
+/**
+ * @see https://docs.npmjs.com/cli/v10/configuring-npm/package-json
+ */
+export const Package_Json = z
+	.object({
+		// according to the npm docs, `name` and `version` are the only required properties
+		name: z.string(),
+		version: z.string(),
+		private: z.boolean({description: 'disallow npm publish'}).optional(),
+		public: z
+			.boolean({
+				description:
+					'a Gro extension that enables publishing `.well-known/package.json` and `.well-known/src`',
+			})
+			.optional(),
+		description: z.string().optional(),
+		motto: z
+			.string({description: "a Gro extension that's a short phrase that represents this project"})
+			.optional(),
+		glyph: z
+			.string({
+				description:
+					"a Gro extension that's a single unicode character that represents this project",
+			})
+			.refine((v) => count_graphemes(v) === 1, 'must be a single unicode character')
+			.optional(),
+		logo: z
+			.string({
+				description:
+					"a Gro extension that's a link relative to the `homepage` to an image that represents this project",
+			})
+			.optional(),
+		logo_alt: z
+			.string({description: "a Gro extension that's the alt text for the `logo`"})
+			.optional(),
+		license: z.string().optional(),
+		scripts: z.record(z.string()).optional(),
+		homepage: Url.optional(),
+		author: z.union([z.string(), Package_Json_Author.optional()]),
+		repository: z.union([z.string(), Url, Package_Json_Repository]).optional(),
+		contributors: z.array(z.union([z.string(), Package_Json_Author])).optional(),
+		bugs: z
+			.union([z.string(), z.object({url: Url.optional(), email: Email.optional()}).passthrough()])
+			.optional(),
+		funding: z
+			.union([Url, Package_Json_Funding, z.array(z.union([Url, Package_Json_Funding]))])
+			.optional(),
+		keywords: z.array(z.string()).optional(),
+
+		type: z.string().optional(),
+		engines: z.record(z.string()).optional(),
+		os: z.array(z.string()).optional(),
+		cpu: z.array(z.string()).optional(),
+
+		dependencies: z.record(z.string()).optional(),
+		devDependencies: z.record(z.string()).optional(),
+		peerDependencies: z.record(z.string()).optional(),
+		peerDependenciesMeta: z.record(z.record(z.string())).optional(),
+		optionalDependencies: z.record(z.string()).optional(),
+
+		bin: z.record(z.string()).optional(),
+		sideEffects: z.array(z.string()).optional(),
+		files: z.array(z.string()).optional(),
+		exports: Package_Json_Exports.transform(transform_empty_object_to_undefined).optional(),
+	})
+	.passthrough();
+export type Package_Json = z.infer<typeof Package_Json>;
+
+export type Map_Package_Json = (
+	package_json: Package_Json,
+) => Package_Json | null | Promise<Package_Json | null>;
+
+export const EMPTY_PACKAGE_JSON: Package_Json = {name: '', version: ''};
+
+export const load_package_json = (
+	dir = IS_THIS_GRO ? gro_paths.root : paths.root,
+	cache?: Record<string, Package_Json>,
+): Package_Json => {
+	let package_json: Package_Json;
+	if (cache && dir in cache) {
+		return cache[dir];
+	}
+	try {
+		package_json = JSON.parse(load_package_json_contents(dir));
+	} catch (_err) {
+		return EMPTY_PACKAGE_JSON;
+	}
+	package_json = parse_package_json(Package_Json, package_json);
+	if (cache) cache[dir] = package_json;
+	return package_json;
+};
+
+export const sync_package_json = async (
+	map_package_json: Map_Package_Json,
+	log: Logger,
+	check = false,
+	dir = paths.root,
+	exports_dir = paths.lib,
+): Promise<{package_json: Package_Json | null; changed: boolean}> => {
+	const exported_files = search_fs(exports_dir);
+	const exported_paths = exported_files.map((f) => f.path);
+	const updated = await update_package_json(
+		dir,
+		async (package_json) => {
+			if (has_sveltekit_library(package_json).ok) {
+				const exports = to_package_exports(exported_paths);
+				package_json.exports = exports;
+			}
+			const mapped = await map_package_json(package_json);
+			return mapped ? parse_package_json(Package_Json, mapped) : mapped;
+		},
+		!check,
+	);
+
+	const exports_count =
+		updated.changed && updated.package_json?.exports
+			? Object.keys(updated.package_json.exports).length
+			: 0;
+	log.info(
+		updated.changed
+			? `updated package.json exports with ${exports_count} total export${plural(exports_count)}`
+			: 'no changes to exports in package.json',
+	);
+
+	return updated;
+};
+
+export const load_gro_package_json = (): Package_Json => load_package_json(gro_paths.root);
+
+// TODO probably make this nullable and make callers handle failures
+const load_package_json_contents = (dir: string): string =>
+	readFileSync(join(dir, 'package.json'), 'utf8');
+
+export const write_package_json = (serialized_package_json: string): void => {
+	writeFileSync(join(paths.root, 'package.json'), serialized_package_json);
+};
+
+export const serialize_package_json = (package_json: Package_Json): string =>
+	JSON.stringify(parse_package_json(Package_Json, package_json), null, 2) + '\n';
+
+/**
+ * Updates package.json. Writes to the filesystem only when contents change.
+ */
+export const update_package_json = async (
+	dir = paths.root,
+	update: (package_json: Package_Json) => Package_Json | null | Promise<Package_Json | null>,
+	write = true,
+): Promise<{package_json: Package_Json | null; changed: boolean}> => {
+	const original_contents = load_package_json_contents(dir);
+	const original = JSON.parse(original_contents);
+	const updated = await update(original);
+	if (updated === null) {
+		return {package_json: original, changed: false};
+	}
+	const updated_contents = serialize_package_json(updated);
+	if (updated_contents === original_contents) {
+		return {package_json: original, changed: false};
+	}
+	if (write) write_package_json(updated_contents);
+	return {package_json: updated, changed: true};
+};
+
+const is_index = (path: string): boolean => path === 'index.ts' || path === 'index.js';
+
+export const to_package_exports = (paths: string[]): Package_Json_Exports => {
+	const sorted = paths
+		.slice()
+		.sort((a, b) => (is_index(a) ? -1 : is_index(b) ? 1 : a.localeCompare(b)));
+	// Add the package.json after the index, if one exists.
+	// Including the `./` here ensures we don't conflict with any potential `$lib/package.json`.
+	const final_sorted = is_index(sorted[0])
+		? [sorted[0]].concat('./package.json', sorted.slice(1))
+		: ['./package.json'].concat(sorted);
+	const exports: Package_Json_Exports = {};
+	for (const path of final_sorted) {
+		if (path === './package.json') {
+			exports['./package.json'] = './package.json';
+		} else if (path.endsWith('.json.d.ts')) {
+			const json_path = path.substring(0, path.length - 5);
+			exports['./' + json_path] = {
+				types: IMPORT_PREFIX + path,
+				default: IMPORT_PREFIX + json_path, // assuming a matching json file
+			};
+		} else if (path.endsWith('.ts') && !path.endsWith('.d.ts')) {
+			const js_path = replace_extension(path, '.js');
+			const key = is_index(path) ? '.' : './' + js_path;
+			exports[key] = {
+				types: IMPORT_PREFIX + replace_extension(path, '.d.ts'),
+				default: IMPORT_PREFIX + js_path,
+			};
+		} else if (path.endsWith('.js')) {
+			const key = is_index(path) ? '.' : './' + path;
+			exports[key] = {
+				types: IMPORT_PREFIX + replace_extension(path, '.d.ts'), // assuming JSDoc types
+				default: IMPORT_PREFIX + path,
+			};
+		} else if (path.endsWith('.svelte')) {
+			exports['./' + path] = {
+				types: IMPORT_PREFIX + path + '.d.ts',
+				svelte: IMPORT_PREFIX + path,
+				default: IMPORT_PREFIX + path, // needed for loader imports
+			};
+		} else {
+			exports['./' + path] = {
+				default: IMPORT_PREFIX + path,
+			};
+		}
+	}
+	return parse_or_throw_formatted_error('package.json#exports', Package_Json_Exports, exports);
+};
+
+const IMPORT_PREFIX = './' + SVELTEKIT_DIST_DIRNAME + '/';
+
+export const parse_repo_url = (
+	package_json: Package_Json,
+): {owner: string; repo: string} | undefined => {
+	const {repository} = package_json;
+	const repo_url = repository
+		? typeof repository === 'string'
+			? repository
+			: repository.url
+		: undefined;
+	if (!repo_url) {
+		return;
+	}
+	const parsed_repo_url = GITHUB_REPO_MATCHER.exec(strip_end(strip_end(repo_url, '/'), '.git'));
+	if (!parsed_repo_url) {
+		return;
+	}
+	const [, owner, repo] = parsed_repo_url;
+	return {owner, repo};
+};
+
+/**
+ * Parses a `Package_Json` object but preserves the order of the original keys.
+ */
+const parse_package_json = (schema: typeof Package_Json, value: any): Package_Json => {
+	const parsed = parse_or_throw_formatted_error('package.json', schema, value);
+	const keys = Object.keys(value);
+	return Object.fromEntries(
+		Object.entries(parsed).sort(([a], [b]) => keys.indexOf(a) - keys.indexOf(b)),
+	) as any;
+};
+
+// TODO maybe extract to zod helpers? see also everything in `task_logging.ts`
+const parse_or_throw_formatted_error = <T extends z.ZodTypeAny>(
+	name: string,
+	schema: T,
+	value: any,
+): z.infer<T> => {
+	const parsed = schema.safeParse(value);
+	if (!parsed.success) {
+		let msg = red(`Failed to parse ${name}:\n`);
+		for (const issue of parsed.error.issues) {
+			msg += red(`\n\t"${issue.path}" ${issue.message}\n`);
+		}
+		throw Error(msg);
+	}
+	return parsed.data;
+};

package/src/lib/package_meta.ts

@@ -0,0 +1,86 @@
+import {strip_start, strip_end} from '@ryanatkn/belt/string.js';
+
+import type {Package_Json, Url} from './package_json.js';
+import type {Src_Json} from './src_json.js';
+
+// TODO needs refactoring, more clarity
+export interface Package_Meta {
+	url: Url;
+	package_json: Package_Json;
+	src_json: Src_Json;
+	name: string; // '@ryanatkn/fuz_library';
+	repo_name: string; // fuz_library
+	repo_url: Url | null; // 'https://github.com/ryanatkn/fuz';
+	/**
+	 * the is the github user/org, not npm
+	 */
+	owner_name: string | null; // 'fuz-dev';
+	homepage_url: Url | null; // 'https://www.fuz.dev/';
+	npm_url: Url | null; // 'https://npmjs.com/package/@ryanatkn/fuz_library';
+	changelog_url: Url | null;
+	published: boolean;
+}
+
+export const parse_package_meta = (
+	url: Url,
+	package_json: Package_Json,
+	src_json: Src_Json,
+): Package_Meta => {
+	const {name} = package_json;
+
+	// TODO hacky
+	const parse_repo = (r: string | null | undefined) => {
+		if (!r) return null;
+		return strip_end(strip_start(strip_end(r, '.git'), 'git+'), '/');
+	};
+
+	const repo_url = parse_repo(
+		package_json.repository
+			? typeof package_json.repository === 'string'
+				? package_json.repository
+				: package_json.repository.url
+			: null,
+	);
+
+	const homepage_url = package_json.homepage ?? null;
+
+	const published =
+		!package_json.private && !!package_json.exports && package_json.version !== '0.0.1';
+
+	// TODO generic registries
+	const npm_url = published ? 'https://www.npmjs.com/package/' + package_json.name : null;
+
+	const changelog_url = published && repo_url ? repo_url + '/blob/main/CHANGELOG.md' : null;
+
+	const repo_name = parse_repo_name(name);
+
+	const owner_name = repo_url ? strip_start(repo_url, 'https://github.com/').split('/')[0] : null;
+
+	return {
+		url,
+		package_json,
+		src_json,
+		name,
+		repo_name,
+		repo_url,
+		owner_name,
+		homepage_url,
+		npm_url,
+		changelog_url,
+		published,
+	};
+};
+
+// TODO proper parsing
+export const parse_repo_name = (name: string): string =>
+	name[0] === '@' ? name.split('/')[1] : name;
+
+export const parse_org_url = (pkg: Package_Meta): string | null => {
+	const {repo_name, repo_url} = pkg;
+	if (!repo_url) return null;
+	const suffix = '/' + repo_name;
+	if (repo_url.endsWith(suffix)) {
+		return strip_end(repo_url, suffix);
+	}
+	return null;
+};

package/src/lib/path.ts

@@ -0,0 +1,23 @@
+import {fileURLToPath} from 'node:url';
+import type {Flavored} from '@ryanatkn/belt/types.js';
+
+/**
+ * An absolute path on the filesystem. Named "id" to be consistent with Rollup.
+ */
+export type Path_Id = Flavored<string, 'Path_Id'>;
+
+export interface Path_Info {
+	id: Path_Id;
+	is_directory: boolean;
+}
+
+export interface Resolved_Path extends Path_Info {
+	path: string;
+}
+
+export type Path_Filter = (path: string, is_directory: boolean) => boolean;
+
+export type File_Filter = (path: string) => boolean;
+
+export const to_file_path = (path_or_url: string | URL): string =>
+	typeof path_or_url === 'string' ? path_or_url : fileURLToPath(path_or_url.href);

package/src/lib/path_constants.ts

@@ -0,0 +1,30 @@
+/*
+
+This module is intended to have no dependencies to avoid over-imports in the CLI and loader.
+If any of these become customizable from SvelteKit or Gro's configs, move them to `./paths.ts`.
+
+*/
+
+// TODO the slashes here are kinda gross - do we want to maintain the convention to have the trailing slash in most usage?
+
+export const SOURCE_DIRNAME = 'src';
+export const GRO_DIRNAME = '.gro';
+export const GRO_DIST_PREFIX = 'dist_'; //
+export const SERVER_DIST_PATH = 'dist_server'; // TODO should all of these be `_PATH` or should this be `DIRNAME`? also, add `_PLUGIN` to this name?
+export const GRO_DEV_DIRNAME = GRO_DIRNAME + '/dev';
+export const SOURCE_DIR = SOURCE_DIRNAME + '/';
+export const GRO_DIR = GRO_DIRNAME + '/';
+export const GRO_DEV_DIR = GRO_DEV_DIRNAME + '/';
+export const GRO_CONFIG_PATH = 'gro.config.ts';
+export const README_FILENAME = 'README.md';
+export const SVELTEKIT_CONFIG_FILENAME = 'svelte.config.js';
+export const VITE_CONFIG_FILENAME = 'vite.config.ts';
+export const NODE_MODULES_DIRNAME = 'node_modules';
+export const LOCKFILE_FILENAME = 'package-lock.json';
+export const SVELTEKIT_DEV_DIRNAME = '.svelte-kit'; // TODO use Svelte config value `outDir`
+export const SVELTEKIT_BUILD_DIRNAME = 'build';
+export const SVELTEKIT_DIST_DIRNAME = 'dist';
+export const SVELTEKIT_VITE_CACHE_PATH = NODE_MODULES_DIRNAME + '/.vite';
+export const GITHUB_DIRNAME = '.github';
+export const GIT_DIRNAME = '.git';
+export const TSCONFIG_FILENAME = 'tsconfig.json';

package/src/lib/paths.test.ts

@@ -0,0 +1,77 @@
+import {suite} from 'uvu';
+import * as assert from 'uvu/assert';
+import {resolve, join} from 'node:path';
+
+import {
+	create_paths,
+	paths,
+	gro_paths,
+	is_gro_id,
+	to_root_path,
+	path_id_to_base_path,
+	base_path_to_path_id,
+} from './paths.js';
+
+/* test__create_paths */
+const test__create_paths = suite('create_paths');
+
+test__create_paths('basic behavior', () => {
+	const root = resolve('../fake');
+	const p = create_paths(root);
+	assert.is(p.root, join(root, '/'));
+	assert.is(p.source, join(root, 'src/'));
+});
+
+test__create_paths('paths object has the same identity as the gro_paths object', () => {
+	assert.is(paths, gro_paths); // because we're testing inside the Gro project
+});
+
+test__create_paths.run();
+/* test__create_paths */
+
+/* test__is_gro_id */
+const test__is_gro_id = suite('is_gro_id');
+
+test__is_gro_id('basic behavior', () => {
+	assert.ok(is_gro_id(resolve(paths.source)));
+	assert.ok(!is_gro_id(resolve('../fake/src')));
+});
+
+test__is_gro_id.run();
+/* test__is_gro_id */
+
+/* test__to_root_path */
+const test__to_root_path = suite('to_root_path');
+
+test__to_root_path('basic behavior', () => {
+	assert.is(to_root_path(resolve('foo/bar')), 'foo/bar');
+	assert.is(to_root_path(resolve('./')), './');
+	assert.is(to_root_path(resolve('./')), './');
+});
+
+test__to_root_path.run();
+/* test__to_root_path */
+
+/* test__path_id_to_base_path */
+const test__path_id_to_base_path = suite('path_id_to_base_path');
+
+test__path_id_to_base_path('basic behavior', () => {
+	assert.is(path_id_to_base_path(resolve('src/foo/bar/baz.ts')), 'foo/bar/baz.ts');
+});
+
+test__path_id_to_base_path.run();
+/* test__path_id_to_base_path */
+
+/* test__base_path_to_path_id */
+const test__base_path_to_path_id = suite('base_path_to_path_id');
+
+test__base_path_to_path_id('basic behavior', () => {
+	assert.is(base_path_to_path_id('foo/bar/baz.ts'), resolve('src/foo/bar/baz.ts'));
+});
+
+test__base_path_to_path_id('does not change extension', () => {
+	assert.is(base_path_to_path_id('foo/bar/baz.js'), resolve('src/foo/bar/baz.js'));
+});
+
+test__base_path_to_path_id.run();
+/* test__base_path_to_path_id */