@ryanatkn/gro 0.129.4 → 0.129.5

package/src/lib/paths.ts

@@ -0,0 +1,101 @@
+import {join, extname, relative, basename} from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {strip_end} from '@ryanatkn/belt/string.js';
+import {gray} from '@ryanatkn/belt/styletext.js';
+
+import {
+	GRO_CONFIG_PATH,
+	GRO_DEV_DIR,
+	GRO_DIR,
+	SOURCE_DIR,
+	SVELTEKIT_DIST_DIRNAME,
+} from './path_constants.js';
+import {sveltekit_config_global} from './sveltekit_config_global.js';
+import type {Path_Id} from './path.js';
+
+/*
+
+A path `id` is an absolute path to the source/.gro/dist directory.
+It's the same name that Rollup uses.
+
+*/
+
+export const LIB_DIRNAME = basename(sveltekit_config_global.lib_path);
+export const LIB_PATH = SOURCE_DIR + LIB_DIRNAME;
+export const LIB_DIR = LIB_PATH + '/';
+export const ROUTES_DIRNAME = basename(sveltekit_config_global.routes_path);
+
+export interface Paths {
+	root: string;
+	source: string;
+	lib: string;
+	build: string;
+	build_dev: string;
+	config: string;
+}
+
+export const create_paths = (root_dir: string): Paths => {
+	// TODO remove reliance on trailing slash towards windows support
+	const root = strip_end(root_dir, '/') + '/';
+	return {
+		root,
+		source: root + SOURCE_DIR,
+		lib: root + LIB_DIR,
+		build: root + GRO_DIR,
+		build_dev: root + GRO_DEV_DIR,
+		config: root + GRO_CONFIG_PATH,
+	};
+};
+
+export const infer_paths = (id: Path_Id): Paths => (is_gro_id(id) ? gro_paths : paths);
+export const is_gro_id = (id: Path_Id): boolean => id.startsWith(strip_end(gro_paths.root, '/')); // strip `/` in case we're looking at the Gro root without a trailing slash
+
+// '/home/me/app/src/foo/bar/baz.ts' → 'src/foo/bar/baz.ts'
+export const to_root_path = (id: Path_Id, p = infer_paths(id)): string =>
+	relative(p.root, id) || './';
+
+// '/home/me/app/src/foo/bar/baz.ts' → 'foo/bar/baz.ts'
+export const path_id_to_base_path = (path_id: Path_Id, p = infer_paths(path_id)): string =>
+	relative(p.source, path_id);
+
+// TODO base_path is an obsolete concept, it was a remnant from forcing `src/`
+// 'foo/bar/baz.ts' → '/home/me/app/src/foo/bar/baz.ts'
+export const base_path_to_path_id = (base_path: string, p = infer_paths(base_path)): Path_Id =>
+	join(p.source, base_path);
+
+export const print_path = (path: string, p = infer_paths(path)): string => {
+	let final_path =
+		strip_end(path, '/') === strip_end(GRO_DIST_DIR, '/') ? 'gro' : to_root_path(path, p);
+	final_path =
+		final_path === 'gro' ? final_path : final_path[0] === '.' ? final_path : './' + final_path;
+	return gray(final_path);
+};
+
+export const replace_extension = (path: string, new_extension: string): string => {
+	const {length} = extname(path);
+	return (length === 0 ? path : path.substring(0, path.length - length)) + new_extension;
+};
+
+/**
+ * Paths for the user repo.
+ */
+export const paths = create_paths(process.cwd());
+
+export const GRO_PACKAGE_DIR = 'gro/';
+// TODO document these conditions with comments
+// TODO there's probably a more robust way to do this
+const filename = fileURLToPath(import.meta.url);
+const gro_package_dir_path = join(
+	filename,
+	filename.includes('/gro/src/lib/')
+		? '../../../'
+		: filename.includes('/gro/dist/')
+			? '../../'
+			: '../',
+);
+export const IS_THIS_GRO = gro_package_dir_path === paths.root;
+/**
+ * Paths for the Gro package being used by the user repo.
+ */
+export const gro_paths = IS_THIS_GRO ? paths : create_paths(gro_package_dir_path);
+export const GRO_DIST_DIR = gro_paths.root + SVELTEKIT_DIST_DIRNAME + '/';

package/src/lib/plugin.test.ts

@@ -0,0 +1,57 @@
+import {test} from 'uvu';
+import * as assert from 'uvu/assert';
+
+import {replace_plugin} from './plugin.js';
+
+test('replace_plugin', () => {
+	const a = {name: 'a'};
+	const b = {name: 'b'};
+	const c = {name: 'c'};
+	const plugins = [a, b, c];
+	const a2 = {name: 'a'};
+	const b2 = {name: 'b'};
+	const c2 = {name: 'c'};
+	let p = plugins;
+	p = replace_plugin(p, a2);
+	assert.is(p[0], a2);
+	assert.is(p[1], b);
+	assert.is(p[2], c);
+	p = replace_plugin(p, b2);
+	assert.is(p[0], a2);
+	assert.is(p[1], b2);
+	assert.is(p[2], c);
+	// allows duplicate names in the array
+	p = replace_plugin(p, c2, 'a');
+	assert.is(p[0], c2);
+	assert.is(p[1], b2);
+	assert.is(p[2], c);
+	p = replace_plugin(p, a2, 'c');
+	assert.is(p[0], a2);
+	assert.is(p[1], b2);
+	assert.is(p[2], c);
+	p = replace_plugin(p, c2);
+	assert.is(p[0], a2);
+	assert.is(p[1], b2);
+	assert.is(p[2], c2);
+});
+
+test('replace_plugin without an array', () => {
+	const a = {name: 'a'};
+	const a2 = {name: 'a'};
+	const p = replace_plugin(a, a2);
+	assert.is(p[0], a2);
+});
+
+test('replace_plugin throws if it cannot find the given name', () => {
+	const a = {name: 'a'};
+	const plugins = [a];
+	let err;
+	try {
+		replace_plugin(plugins, {name: 'b'});
+	} catch (_err) {
+		err = _err;
+	}
+	if (!err) assert.unreachable('should have failed');
+});
+
+test.run();

package/src/lib/plugin.ts

@@ -0,0 +1,113 @@
+import {to_array} from '@ryanatkn/belt/array.js';
+
+import type {Task_Context} from './task.js';
+
+/**
+ * Gro `Plugin`s enable custom behavior during `gro dev` and `gro build`.
+ * In contrast, `Adapter`s use the results of `gro build` to produce final artifacts.
+ */
+export interface Plugin<T_Plugin_Context extends Plugin_Context = Plugin_Context> {
+	name: string;
+	setup?: (ctx: T_Plugin_Context) => void | Promise<void>;
+	adapt?: (ctx: T_Plugin_Context) => void | Promise<void>;
+	teardown?: (ctx: T_Plugin_Context) => void | Promise<void>;
+}
+
+export type Create_Config_Plugins<T_Plugin_Context extends Plugin_Context = Plugin_Context> = (
+	ctx: T_Plugin_Context,
+) =>
+	| (Plugin<T_Plugin_Context> | null | Array<Plugin<T_Plugin_Context> | null>)
+	| Promise<Plugin<T_Plugin_Context> | null | Array<Plugin<T_Plugin_Context> | null>>;
+
+export interface Plugin_Context<T_Args = object> extends Task_Context<T_Args> {
+	dev: boolean;
+	watch: boolean;
+}
+
+export class Plugins<T_Plugin_Context extends Plugin_Context> {
+	/* prefer `Plugins.create` to the constructor */
+	constructor(
+		private ctx: T_Plugin_Context,
+		private instances: Plugin[],
+	) {}
+
+	static async create<T_Plugin_Context extends Plugin_Context>(
+		ctx: T_Plugin_Context,
+	): Promise<Plugins<T_Plugin_Context>> {
+		const {timings} = ctx;
+		const timing_to_create = timings.start('plugins.create');
+		const instances: Plugin[] = to_array(await ctx.config.plugins(ctx)).filter(
+			(v) => v !== null,
+		) as Plugin[]; // TODO remove cast, should infer the type predicate? `Type '(Plugin<Plugin_Context<object>> | null)[]' is not assignable to type 'Plugin<Plugin_Context<object>>[]'.`
+		const plugins = new Plugins(ctx, instances);
+		timing_to_create();
+		return plugins;
+	}
+
+	async setup(): Promise<void> {
+		const {ctx, instances} = this;
+		if (!instances.length) return;
+		const {timings, log} = ctx;
+		const timing_to_setup = timings.start('plugins.setup');
+		for (const plugin of instances) {
+			if (!plugin.setup) continue;
+			log.debug('setup plugin', plugin.name);
+			const timing = timings.start(`setup:${plugin.name}`);
+			await plugin.setup(ctx); // eslint-disable-line no-await-in-loop
+			timing();
+		}
+		timing_to_setup();
+	}
+
+	async adapt(): Promise<void> {
+		const {ctx, instances} = this;
+		const {timings} = ctx;
+		const timing_to_run_adapters = timings.start('plugins.adapt');
+		for (const plugin of instances) {
+			if (!plugin.adapt) continue;
+			const timing = timings.start(`adapt:${plugin.name}`);
+			await plugin.adapt(ctx); // eslint-disable-line no-await-in-loop
+			timing();
+		}
+		timing_to_run_adapters();
+	}
+
+	async teardown(): Promise<void> {
+		const {ctx, instances} = this;
+		if (!instances.length) return;
+		const {timings, log} = ctx;
+		const timing_to_teardown = timings.start('plugins.teardown');
+		for (const plugin of instances) {
+			if (!plugin.teardown) continue;
+			log.debug('teardown plugin', plugin.name);
+			const timing = timings.start(`teardown:${plugin.name}`);
+			await plugin.teardown(ctx); // eslint-disable-line no-await-in-loop
+			timing();
+		}
+		timing_to_teardown();
+	}
+}
+
+/**
+ * Replaces a plugin by name in `plugins` without mutating the param.
+ * Throws if the plugin name cannot be found.
+ * @param plugins - accepts the same types as the return value of `Create_Config_Plugins`
+ * @param new_plugin
+ * @param name - @default new_plugin.name
+ * @returns `plugins` with `new_plugin` at the index of the plugin with `name`
+ */
+export const replace_plugin = <
+	T_Plugins extends T_Plugin | null | Array<T_Plugin | null>,
+	T_Plugin extends Plugin,
+>(
+	plugins: T_Plugins,
+	new_plugin: Plugin,
+	name = new_plugin.name,
+): T_Plugin[] => {
+	const array = to_array(plugins).filter((v) => v !== null);
+	const index = array.findIndex((p) => p.name === name);
+	if (index === -1) throw Error('Failed to find plugin to replace: ' + name);
+	const replaced = array.slice();
+	replaced[index] = new_plugin;
+	return replaced as T_Plugin[];
+};

package/src/lib/publish.task.ts

@@ -0,0 +1,194 @@
+import {spawn} from '@ryanatkn/belt/process.js';
+import {z} from 'zod';
+import {green, cyan} from '@ryanatkn/belt/styletext.js';
+import {existsSync} from 'node:fs';
+
+import {Task_Error, type Task} from './task.js';
+import {load_package_json, parse_repo_url} from './package_json.js';
+import {find_cli, spawn_cli} from './cli.js';
+import {IS_THIS_GRO} from './paths.js';
+import {has_sveltekit_library} from './sveltekit_helpers.js';
+import {update_changelog} from './changelog.js';
+import {load_from_env} from './env.js';
+import {
+	Git_Branch,
+	Git_Origin,
+	git_check_clean_workspace,
+	git_checkout,
+	git_fetch,
+	git_pull,
+} from './git.js';
+import {CHANGESET_CLI} from './changeset_helpers.js';
+
+// publish.task.ts
+// - usage: `gro publish patch`
+// - forwards args to `npm version`: https://docs.npmjs.com/v6/commands/npm-version
+// - runs the production build
+// - publishes to npm from the `main` branch, configurable with `--branch`
+// - syncs commits and tags to the configured main branch
+
+export const Args = z
+	.object({
+		branch: Git_Branch.describe('branch to publish from').default('main'),
+		origin: Git_Origin.describe('git origin to publish from').default('origin'),
+		changelog: z
+			.string({description: 'file name and path of the changelog'})
+			.default('CHANGELOG.md'),
+		preserve_changelog: z
+			.boolean({
+				description:
+					'opt out of linkifying and formatting the changelog from @changesets/changelog-git',
+			})
+			.default(false),
+		optional: z.boolean({description: 'exit gracefully if there are no changesets'}).default(false),
+		dry: z
+			.boolean({description: 'build and prepare to publish without actually publishing'})
+			.default(false),
+		check: z.boolean({description: 'dual of no-check'}).default(true),
+		'no-check': z
+			.boolean({description: 'opt out of npm checking before publishing'})
+			.default(false),
+		build: z.boolean({description: 'dual of no-build'}).default(true),
+		'no-build': z.boolean({description: 'opt out of building'}).default(false),
+		pull: z.boolean({description: 'dual of no-pull'}).default(true),
+		'no-pull': z.boolean({description: 'opt out of git pull'}).default(false),
+		changeset_cli: z.string({description: 'the changeset CLI to use'}).default(CHANGESET_CLI),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'bump version, publish to npm, and git push',
+	Args,
+	run: async ({args, log, invoke_task}): Promise<void> => {
+		const {
+			branch,
+			origin,
+			changelog,
+			preserve_changelog,
+			dry,
+			check,
+			build,
+			pull,
+			optional,
+			changeset_cli,
+		} = args;
+		if (dry) {
+			log.info(green('dry run!'));
+		}
+
+		const has_sveltekit_library_result = has_sveltekit_library();
+		if (!has_sveltekit_library_result.ok) {
+			throw new Task_Error(
+				'Failed to find SvelteKit library: ' + has_sveltekit_library_result.message,
+			);
+		}
+
+		// TODO hacky, ensures Gro bootstraps itself
+		if (IS_THIS_GRO) {
+			await spawn('npm', ['run', 'build']);
+		}
+
+		const changelog_exists = existsSync(changelog);
+
+		const found_changeset_cli = find_cli(changeset_cli);
+		if (!found_changeset_cli) {
+			throw new Task_Error(
+				'changeset command not found, install @changesets/cli locally or globally',
+			);
+		}
+
+		// Make sure we're on the right branch:
+		await git_fetch(origin, branch);
+		await git_checkout(branch);
+		if (pull) {
+			if (await git_check_clean_workspace()) {
+				throw new Task_Error('The git workspace is not clean, pass --no-pull to bypass git pull');
+			}
+			await git_pull(origin, branch);
+		}
+
+		// Check before proceeding.
+		if (check) {
+			await invoke_task('check', {workspace: true});
+		}
+
+		let version!: string;
+
+		// Bump the version so the package.json is updated before building:
+		// TODO problem here is build may fail and put us in a bad state,
+		// but I don't see how we could do this to robustly
+		// have the new version in the build without building twice -
+		// maybe the code should catch the error and revert the version and delete the tag?
+		if (dry) {
+			log.info('dry run, skipping changeset version');
+		} else {
+			const package_json_before = load_package_json();
+			if (typeof package_json_before.version !== 'string') {
+				throw new Task_Error('Failed to find package.json version');
+			}
+			const parsed_repo_url = parse_repo_url(package_json_before);
+			if (!parsed_repo_url) {
+				throw new Task_Error(
+					'package.json `repository` must contain a repo url (and GitHub only for now, sorry),' +
+						' like `git+https://github.com/ryanatkn/gro.git` or `https://github.com/ryanatkn/gro`' +
+						' or an object with the `url` key',
+				);
+			}
+
+			// This is the first line that alters the repo.
+
+			const npmVersionResult = await spawn_cli(found_changeset_cli, ['version'], log);
+			if (!npmVersionResult?.ok) {
+				throw Error('npm version failed: no commits were made: see the error above');
+			}
+
+			if (!preserve_changelog) {
+				const token = load_from_env('GITHUB_TOKEN_SECRET');
+				if (!token) {
+					log.warn(
+						'the env var GITHUB_TOKEN_SECRET was not found, so API calls with be unauthorized',
+					);
+				}
+				await update_changelog(parsed_repo_url.owner, parsed_repo_url.repo, changelog, token, log);
+			}
+
+			const package_json_after = load_package_json();
+			version = package_json_after.version!;
+			if (package_json_before.version === version) {
+				// The version didn't change.
+				// For now this is the best detection we have for a no-op `changeset version`.
+				if (optional) {
+					return; // exit gracefully
+				} else {
+					throw new Task_Error(`\`${changeset_cli} version\` failed: are there any changes?`);
+				}
+			}
+		}
+
+		if (build) {
+			await invoke_task('build');
+		}
+
+		if (dry) {
+			log.info('publishing branch ' + branch);
+			log.info(green('dry run complete!'));
+			return;
+		}
+
+		const npm_publish_result = await spawn_cli(found_changeset_cli, ['publish'], log);
+		if (!npm_publish_result?.ok) {
+			throw new Task_Error(
+				`\`${changeset_cli} publish\` failed - revert the version tag or run it again manually`,
+			);
+		}
+
+		if (!changelog_exists && existsSync(changelog)) {
+			await spawn('git', ['add', changelog]);
+		}
+		await spawn('git', ['commit', '-a', '-m', `publish v${version}`]);
+		await spawn('git', ['push', '--follow-tags']);
+
+		log.info(green(`published to branch ${cyan(branch)}!`));
+	},
+};

package/src/lib/register.ts

@@ -0,0 +1,3 @@
+import {register} from 'node:module';
+
+register('./loader.js', import.meta.url);

package/src/lib/reinstall.task.ts

@@ -0,0 +1,42 @@
+import {z} from 'zod';
+import {spawn} from '@ryanatkn/belt/process.js';
+import {rm} from 'node:fs/promises';
+
+import {Task_Error, type Task} from './task.js';
+import {LOCKFILE_FILENAME, NODE_MODULES_DIRNAME} from './path_constants.js';
+
+export const Args = z.object({}).strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: `refreshes ${LOCKFILE_FILENAME} with the latest and cleanest deps`,
+	Args,
+	run: async ({log}): Promise<void> => {
+		log.info('running the initial npm install');
+		const initial_install_result = await spawn('npm', ['i']);
+		if (!initial_install_result.ok) {
+			throw new Task_Error('Failed initial npm install');
+		}
+
+		// Deleting both the lockfile and node_modules upgrades to the latest minor/patch versions.
+		await Promise.all([rm(LOCKFILE_FILENAME), rm(NODE_MODULES_DIRNAME, {recursive: true})]);
+		log.info(
+			`running npm install after deleting ${LOCKFILE_FILENAME} and ${NODE_MODULES_DIRNAME}, this can take a while...`,
+		);
+		const second_install_result = await spawn('npm', ['i']);
+		if (!second_install_result.ok) {
+			throw new Task_Error(
+				`Failed npm install after deleting ${LOCKFILE_FILENAME} and ${NODE_MODULES_DIRNAME}`,
+			);
+		}
+
+		// Deleting the lockfile and reinstalling cleans the lockfile of unnecessary dep noise,
+		// like esbuild's many packages for each platform.
+		await rm(LOCKFILE_FILENAME);
+		log.info(`running npm install one last time to clean ${LOCKFILE_FILENAME}`);
+		const final_install_result = await spawn('npm', ['i']);
+		if (!final_install_result.ok) {
+			throw new Task_Error('Failed npm install');
+		}
+	},
+};

package/src/lib/release.task.ts

@@ -0,0 +1,21 @@
+import {z} from 'zod';
+
+import type {Task} from './task.js';
+import {has_sveltekit_library, has_sveltekit_app} from './sveltekit_helpers.js';
+
+export const Args = z.object({}).strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'publish and deploy',
+	Args,
+	run: async ({invoke_task}) => {
+		const publish = has_sveltekit_library().ok;
+		if (publish) {
+			await invoke_task('publish', {optional: true});
+		}
+		if (has_sveltekit_app().ok) {
+			await invoke_task('deploy', {build: !publish});
+		}
+	},
+};

package/src/lib/resolve.task.ts

@@ -0,0 +1,43 @@
+import {z} from 'zod';
+import {green, yellow} from '@ryanatkn/belt/styletext.js';
+
+import {TASK_FILE_SUFFIXES, type Task} from './task.js';
+import {resolve_input_paths, to_input_paths} from './input_path.js';
+
+export const Args = z
+	.object({
+		_: z.array(z.string(), {description: 'the input paths to resolve'}).default(['']),
+		verbose: z.boolean({description: 'log diagnostics'}).default(false),
+	})
+	.strict();
+export type Args = z.infer<typeof Args>;
+
+export const task: Task<Args> = {
+	summary: 'diagnostic that logs resolved filesystem info for the given input paths',
+	Args,
+	run: ({args, config, log}): void => {
+		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} =
+			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:', green(p.id));
+		}
+
+		if (!resolved_input_paths.length) {
+			log.warn(yellow('no input paths were resolved'));
+		}
+	},
+};

package/src/lib/resolve_node_specifier.test.ts

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

package/src/lib/resolve_node_specifier.ts

@@ -0,0 +1,55 @@
+import {join} from 'node:path';
+
+import {Package_Json, load_package_json} from './package_json.js';
+import type {Path_Id} from './path.js';
+import {paths} from './paths.js';
+import {NODE_MODULES_DIRNAME} from './path_constants.js';
+
+export const resolve_node_specifier = (
+	specifier: string,
+	dir = paths.root,
+	parent_url?: string,
+	cache?: Record<string, Package_Json>,
+	exports_key = specifier.endsWith('.svelte') ? 'svelte' : 'default',
+): Path_Id => {
+	const parsed = parse_node_specifier(specifier);
+	const subpath = './' + parsed.path;
+	const package_dir = join(dir, NODE_MODULES_DIRNAME, parsed.name);
+	const package_json = load_package_json(package_dir, cache);
+	const exported = package_json.exports?.[subpath];
+	if (!exported) {
+		// same error message as Node
+		throw Error(
+			`[ERR_PACKAGE_PATH_NOT_EXPORTED]: Package subpath '${subpath}' is not defined by "exports" in ${package_dir}/package.json` +
+				(parent_url ? ` imported from ${parent_url}` : ''),
+		);
+	}
+	const path_id = join(package_dir, exported[exports_key]);
+	return path_id;
+};
+
+export interface Parsed_Node_Specifier {
+	name: string;
+	path: string;
+}
+
+export const parse_node_specifier = (specifier: string): Parsed_Node_Specifier => {
+	let idx!: number;
+	if (specifier[0] === '@') {
+		// get the index of the second `/`
+		let count = 0;
+		for (let i = 0; i < specifier.length; i++) {
+			if (specifier[i] === '/') count++;
+			if (count === 2) {
+				idx = i;
+				break;
+			}
+		}
+	} else {
+		idx = specifier.indexOf('/');
+	}
+	return {
+		name: specifier.substring(0, idx),
+		path: specifier.substring(idx + 1),
+	};
+};