revojs 0.2.43 → 0.2.45

package/dist/bin/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/index.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { createCommandTree, runCommands } from "../commands/index.js";
+import { createRunnableDevEnvironment, createServer, isRunnableDevEnvironment, loadEnv } from "vite";
+import { parseArgs } from "util";
+//#region src/bin/index.ts
+var args = process.argv.slice(2);
+var parsed = parseArgs({
+	args,
+	strict: false,
+	allowPositionals: true,
+	options: { environment: {
+		type: "string",
+		short: "e"
+	} }
+});
+var server = await createServer({
+	appType: "custom",
+	environments: { command: {
+		consumer: "server",
+		dev: { createEnvironment(name, config) {
+			return createRunnableDevEnvironment(name, config);
+		} }
+	} },
+	server: {
+		middlewareMode: true,
+		hmr: false
+	}
+});
+var environment = typeof parsed.values.environment === "string" ? server.environments[parsed.values.environment] : server.environments.command ?? Object.values(server.environments).find((environment) => isRunnableDevEnvironment(environment) && environment.config.consumer === "server") ?? Object.values(server.environments).find(isRunnableDevEnvironment);
+if (!environment || !isRunnableDevEnvironment(environment)) {
+	await server.close();
+	throw new Error(typeof parsed.values.environment === "string" ? `No runnable environment named "${parsed.values.environment}" found.` : "No runnable Vite environment found.");
+}
+var environments = new Array();
+for (const [name, entry] of Object.entries(server.environments)) if (isRunnableDevEnvironment(entry)) environments.push({
+	name,
+	description: [entry.config.consumer, name === "ssr" ? "default" : void 0].filter(Boolean).join(", ")
+});
+environments.sort((a, b) => a.name.localeCompare(b.name));
+try {
+	const commands = await environment.runner.import("#commands").then((module) => module.default);
+	process.exitCode = await runCommands({
+		name: "revojs",
+		description: "Commands are discovered from ./commands (via the revojs \"commands\" source) and run inside the project's Vite dev server, sharing the same module graph and virtuals.",
+		args,
+		tree: await createCommandTree(commands),
+		flags: [{
+			name: "environment",
+			description: "Vite dev environment used for command execution",
+			short: "e",
+			type: "string"
+		}],
+		sections: { Environments: environments },
+		async run(command, context) {
+			const { createScope, VARIABLE_CONTEXT } = await environment.runner.import("revojs");
+			await command.run(await createScope({ context: { [VARIABLE_CONTEXT]: loadEnv(environment.config.mode, environment.config.envDir, "") } }), {
+				...context,
+				environment
+			});
+		}
+	});
+} catch (error) {
+	console.error(error);
+	process.exitCode = 1;
+} finally {
+	await server.close();
+}
+//#endregion
+export {};

package/dist/commands/index.d.ts

@@ -1,2 +1,75 @@
-#!/usr/bin/env node
-export {};
+import { parseArgs, type ParseArgsOptionDescriptor, type ParseArgsOptionsConfig } from "node:util";
+import type { RunnableDevEnvironment } from "vite";
+import type { Scope } from "../scope";
+import type { Awaitable } from "../shared";
+export type CommandValues<T extends ParseArgsOptionsConfig> = ReturnType<typeof parseArgs<{
+    options: T;
+    allowPositionals: true;
+    strict: true;
+}>>["values"];
+export type CommandLoaders = Record<string, Record<string, () => Promise<Command<CommandArguments>>>>;
+export interface CommandArgument extends ParseArgsOptionDescriptor {
+    description?: string;
+}
+export type CommandArguments = ParseArgsOptionsConfig & Record<string, CommandArgument>;
+export interface CommandContext<T extends ParseArgsOptionsConfig = ParseArgsOptionsConfig> {
+    input: Array<string>;
+    arguments: CommandValues<T>;
+    environment?: RunnableDevEnvironment;
+}
+export interface Command<T extends ParseArgsOptionsConfig = ParseArgsOptionsConfig> {
+    description?: string;
+    arguments?: T;
+    run: (scope: Scope, context: CommandContext<T>) => Awaitable<void>;
+}
+export interface CommandTree {
+    value?: Command<CommandArguments>;
+    children: Record<string, CommandTree>;
+}
+export interface CommandHelpEntry {
+    name: string;
+    description?: string;
+}
+export interface CommandFlag {
+    name: string;
+    description?: string;
+    multiple?: boolean;
+    short?: string;
+    type: "string" | "boolean";
+}
+export interface CommandMatch {
+    tree: CommandTree;
+    path: Array<string>;
+    command?: Command<CommandArguments>;
+}
+export interface CommandHelpOptions {
+    name: string;
+    description?: string;
+    match: CommandMatch;
+    flags?: Array<CommandFlag>;
+    sections?: Record<string, Array<CommandHelpEntry>>;
+}
+export interface CommandRunOptions {
+    name: string;
+    description?: string;
+    args: Array<string>;
+    tree: CommandTree;
+    flags?: Array<CommandFlag>;
+    sections?: Record<string, Array<CommandHelpEntry>>;
+    run: (command: Command<CommandArguments>, context: CommandContext<CommandArguments>) => Awaitable<void>;
+}
+export declare function defineCommand<const T extends ParseArgsOptionsConfig>(command: Command<T>): Command<T>;
+export declare function createCommandTree(commands: CommandLoaders): Promise<CommandTree>;
+export declare function findCommand(tree: CommandTree, positionals: Array<string>): CommandMatch;
+export declare function formatSection(title: string, entries: Array<CommandHelpEntry>): string[];
+export declare function formatFlag(flag: CommandFlag): string;
+export declare function formatHelp(options: CommandHelpOptions): string;
+export declare function parseCommand(command: Command<CommandArguments>, args: Array<string>, path: Array<string>): {
+    values: {
+        [longOption: string]: string | boolean | undefined;
+    } & {
+        help?: string | boolean | undefined;
+    };
+    positionals: string[];
+};
+export declare function runCommands(options: CommandRunOptions): Promise<0 | 1>;

package/dist/commands/index.js

@@ -1,153 +1,137 @@
-#!/usr/bin/env node
-import { createRunnableDevEnvironment, createServer, isRunnableDevEnvironment, loadEnv } from "vite";
-import { parseArgs } from "util";
+import { parseArgs } from "node:util";
 //#region src/commands/index.ts
-function help() {
-	const environmentMeta = new Array();
-	for (const [name, environment] of Object.entries(server.environments)) if (isRunnableDevEnvironment(environment)) environmentMeta.push({
-		name,
-		description: [environment.config.consumer, name === "ssr" ? "default" : void 0].filter(Boolean).join(", ")
-	});
-	const flagMeta = new Array();
-	for (const [name, descriptor] of Object.entries(command?.arguments ?? {})) flagMeta.push({
+function defineCommand(command) {
+	return command;
+}
+async function createCommandTree(commands) {
+	const tree = { children: {} };
+	for (const source of Object.values(commands)) for (const [path, value] of Object.entries(source)) {
+		let node = tree;
+		for (const segment of path.replace(/\\/g, "/").replace(/(^|\/)index$/, "").split("/").filter(Boolean)) node = node.children[segment] ??= { children: {} };
+		node.value = await value();
+	}
+	return tree;
+}
+function findCommand(tree, positionals) {
+	const path = new Array();
+	let node = tree;
+	if (positionals[0] !== "help") for (const positional of positionals) {
+		const child = node.children[positional];
+		if (!child) break;
+		node = child;
+		path.push(positional);
+	}
+	return {
+		tree: node,
+		path,
+		command: node.value
+	};
+}
+function formatSection(title, entries) {
+	if (entries.length === 0) return [];
+	const width = Math.max(...entries.map((entry) => entry.name.length));
+	return [
+		"",
+		`${title}:`,
+		...entries.map((entry) => `  ${entry.name.padEnd(width)}  ${entry.description ?? ""}`.trimEnd())
+	];
+}
+function formatFlag(flag) {
+	return [flag.short ? `-${flag.short}` : void 0, flag.type === "string" ? `--${flag.name}=<value>${flag.multiple ? "..." : ""}` : `--${flag.name}`].filter(Boolean).join(", ");
+}
+function formatHelp(options) {
+	const flags = new Array();
+	for (const [name, descriptor] of Object.entries(options.match.command?.arguments ?? {})) flags.push({
 		name,
 		description: descriptor.description,
 		multiple: descriptor.multiple,
 		short: descriptor.short,
 		type: descriptor.type
 	});
-	flagMeta.push({
+	flags.push({
 		name: "help",
 		description: "Show help",
 		short: "h",
 		type: "boolean"
-	}, {
-		name: "environment",
-		description: "Vite dev environment used for command execution",
-		short: "e",
-		type: "string"
-	});
-	const commandMeta = new Array();
-	for (const [name, child] of Object.entries(node.children)) {
+	}, ...options.flags ?? []);
+	const commands = new Array();
+	for (const [name, child] of Object.entries(options.match.tree.children)) {
 		let target = child;
 		while (target && !target.value) target = Object.values(target.children)[0];
-		commandMeta.push({
+		commands.push({
 			name,
 			description: target?.value?.description
 		});
 	}
-	environmentMeta.sort((a, b) => a.name.localeCompare(b.name));
-	commandMeta.sort((a, b) => a.name.localeCompare(b.name));
+	commands.sort((a, b) => a.name.localeCompare(b.name));
 	const lines = new Array();
-	lines.push(`Usage: ${["revojs", ...path].join(" ")} [flags]${commandMeta.length > 0 ? " [command]" : ""}`);
-	const description = command?.description ?? (path.length === 0 ? "Commands are discovered from ./commands (via the revojs \"commands\" source) and run inside the project's Vite dev server, sharing the same module graph and virtuals." : void 0);
+	lines.push(`Usage: ${[options.name, ...options.match.path].join(" ")} [flags]${commands.length > 0 ? " [command]" : ""}`);
+	const description = options.match.command?.description ?? (options.match.path.length === 0 ? options.description : void 0);
 	if (description) lines.push("", description);
-	lines.push(...section("Environments", environmentMeta), ...section("Flags", flagMeta.map((flag) => ({
-		name: [flag.short ? `-${flag.short}` : void 0, flag.type === "string" ? `--${flag.name}=<value>${flag.multiple ? "..." : ""}` : `--${flag.name}`].filter(Boolean).join(", "),
+	for (const [title, entries] of Object.entries(options.sections ?? {})) lines.push(...formatSection(title, entries));
+	lines.push(...formatSection("Flags", flags.map((flag) => ({
+		name: formatFlag(flag),
 		description: flag.description
-	}))), ...section("Commands", commandMeta));
-	console.log(lines.join("\n"));
+	}))), ...formatSection("Commands", commands));
+	return lines.join("\n");
 }
-function section(title, entries) {
-	if (entries.length === 0) return [];
-	const width = Math.max(...entries.map((entry) => entry.name.length));
-	return [
-		"",
-		`${title}:`,
-		...entries.map((entry) => `  ${entry.name.padEnd(width)}  ${entry.description ?? ""}`.trimEnd())
-	];
+function parseCommand(command, args, path) {
+	const consumable = [...path];
+	return parseArgs({
+		args: args.filter((argument) => {
+			const index = consumable.indexOf(argument);
+			if (index === -1) return true;
+			consumable.splice(index, 1);
+			return false;
+		}),
+		strict: false,
+		allowPositionals: true,
+		options: {
+			...command.arguments,
+			help: {
+				type: "boolean",
+				short: "h",
+				description: "Show this help"
+			}
+		}
+	});
 }
-var args = process.argv.slice(2);
-var parsed = parseArgs({
-	args,
-	strict: false,
-	allowPositionals: true,
-	options: {
-		help: {
+async function runCommands(options) {
+	const parsed = parseArgs({
+		args: options.args,
+		strict: false,
+		allowPositionals: true,
+		options: { help: {
 			type: "boolean",
 			short: "h",
 			default: false
-		},
-		environment: {
-			type: "string",
-			short: "e"
-		}
-	}
-});
-var server = await createServer({
-	appType: "custom",
-	environments: { command: {
-		consumer: "server",
-		dev: { createEnvironment(name, config) {
-			return createRunnableDevEnvironment(name, config);
 		} }
-	} },
-	server: {
-		middlewareMode: true,
-		hmr: false
+	});
+	const helpRequested = parsed.values.help === true || parsed.positionals[0] === "help";
+	const match = findCommand(options.tree, parsed.positionals);
+	const help = () => {
+		console.log(formatHelp({
+			name: options.name,
+			description: options.description,
+			match,
+			flags: options.flags,
+			sections: options.sections
+		}));
+	};
+	if (!match.command || helpRequested) {
+		help();
+		return helpRequested || match.command ? 0 : 1;
 	}
-});
-var environment = typeof parsed.values.environment === "string" ? server.environments[parsed.values.environment] : server.environments.command ?? Object.values(server.environments).find((environment) => isRunnableDevEnvironment(environment) && environment.config.consumer === "server") ?? Object.values(server.environments).find(isRunnableDevEnvironment);
-if (!environment || !isRunnableDevEnvironment(environment)) {
-	await server.close();
-	throw new Error(typeof parsed.values.environment === "string" ? `No runnable environment named "${parsed.values.environment}" found.` : "No runnable Vite environment found.");
-}
-var commands = await environment.runner.import("#commands").then((module) => module.default);
-var radix = { children: {} };
-for (const source of Object.values(commands)) for (const [path, value] of Object.entries(source)) {
-	let node = radix;
-	for (const segment of path.replace(/\\/g, "/").split("/")) node = node.children[segment] ??= { children: {} };
-	node.value = await value();
-}
-var helpRequested = parsed.values.help === true || parsed.positionals[0] === "help";
-var path = new Array();
-var node = radix;
-if (parsed.positionals[0] !== "help") for (const positional of parsed.positionals) {
-	const child = node.children[positional];
-	if (!child) break;
-	node = child;
-	path.push(positional);
-}
-var command = node.value;
-try {
-	if (command && !helpRequested) {
-		const consumable = [...path];
-		const context = parseArgs({
-			args: args.filter((argument) => {
-				const index = consumable.indexOf(argument);
-				if (index === -1) return true;
-				consumable.splice(index, 1);
-				return false;
-			}),
-			strict: false,
-			allowPositionals: true,
-			options: {
-				...command.arguments,
-				help: {
-					type: "boolean",
-					short: "h",
-					description: "Show this help"
-				}
-			}
-		});
-		if (context.values.help) help();
-		else {
-			const { createScope, VARIABLE_CONTEXT } = await environment.runner.import("revojs");
-			await command.run(await createScope({ context: { [VARIABLE_CONTEXT]: loadEnv(environment.config.mode, environment.config.envDir, "") } }), {
-				input: context.positionals,
-				arguments: context.values,
-				environment
-			});
-		}
-	} else {
+	const context = parseCommand(match.command, options.args, match.path);
+	if (context.values.help) {
 		help();
-		process.exitCode = helpRequested || command ? 0 : 1;
+		return 0;
 	}
-} catch (error) {
-	console.error(error);
-	process.exitCode = 1;
-} finally {
-	await server.close();
+	await options.run(match.command, {
+		input: context.positionals,
+		arguments: context.values
+	});
+	return 0;
 }
 //#endregion
-export {};
+export { createCommandTree, defineCommand, findCommand, formatFlag, formatHelp, formatSection, parseCommand, runCommands };

package/dist/module/index.d.ts

@@ -1,14 +1,5 @@
-import type { parseArgs } from "node:util";
-import { type ParseArgsOptionDescriptor, type ParseArgsOptionsConfig } from "node:util";
-import type { RunnableDevEnvironment } from "vite";
 import { type PluginOption, type UserConfig } from "vite";
-import type { Scope } from "../scope/index.ts";
 import { type Awaitable, type Mergeable } from "../shared/index.ts";
-export type CommandValues<T extends ParseArgsOptionsConfig> = ReturnType<typeof parseArgs<{
-    options: T;
-    allowPositionals: true;
-    strict: true;
-}>>["values"];
 export type Consumer = "client" | "server";
 export type Template = (consumer: Consumer) => Awaitable<undefined | string>;
 export type Variable = StringVariable | NumberVariable | BooleanVariable | EnumVariable;
@@ -31,20 +22,6 @@ export type ModuleInput<TModules extends ReadonlyArray<Module>> = Mergeable<Conf
     modules?: TModules;
 };
 export type ModuleSetupResult<TName extends string, TConfig, TDependencies extends ReadonlyArray<Module> = []> = void | (Mergeable<Config> & Mergeable<Record<TName, TConfig>> & Mergeable<InferModuleConfigs<TDependencies>>);
-export interface CommandArgument extends ParseArgsOptionDescriptor {
-    description?: string;
-}
-export type CommandArguments = ParseArgsOptionsConfig & Record<string, CommandArgument>;
-export interface CommandContext<T extends ParseArgsOptionsConfig = ParseArgsOptionsConfig> {
-    input: Array<string>;
-    arguments: CommandValues<T>;
-    environment: RunnableDevEnvironment;
-}
-export interface Command<T extends ParseArgsOptionsConfig = ParseArgsOptionsConfig> {
-    description?: string;
-    arguments?: T;
-    run: (scope: Scope, context: CommandContext<T>) => Awaitable<void>;
-}
 export type SourceFormat = "object" | "named";
 export interface Source {
     from: Array<string>;
@@ -101,7 +78,6 @@ export interface ModuleDefinition<TName extends string, TConfig = Record<string,
     modules?: TDependencies;
     setup: (config: Config & Record<TName, TConfig> & InferModuleConfigs<TDependencies>) => Awaitable<ModuleSetupResult<TName, TConfig, TDependencies>>;
 }
-export declare function defineCommand<const T extends ParseArgsOptionsConfig>(command: Command<T>): Command<T>;
 export declare function defineModule<const TName extends string, TConfig = Record<string, never>, const TDependencies extends ReadonlyArray<Module> = []>(definition: ModuleDefinition<TName, TConfig, TDependencies>): Module<TName, TConfig, TDependencies>;
 export declare function addVirtual(config: Config, name: string, virtual: Template): void;
 export declare function addTemplate(config: Config, name: string, template: Template): void;

package/dist/module/index.js

@@ -3,7 +3,7 @@ import { mergeObjects, toExportNames } from "../shared/index.js";
 import package_default from "../package.js";
 import { findPackageJSON } from "node:module";
 import { spawnSync } from "child_process";
-import { copyFileSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
 import { createRequire } from "module";
 import { globSync } from "node:fs";
 import { pathToFileURL } from "node:url";
@@ -11,9 +11,6 @@ import { dirname, extname, isAbsolute, join, posix, relative, resolve, win32 } f
 import { fileURLToPath } from "url";
 import "vite";
 //#region src/module/index.ts
-function defineCommand(command) {
-	return command;
-}
 function defineModule(definition) {
 	return definition;
 }
@@ -359,7 +356,7 @@ async function revojs(inputConfig) {
 				builder: {
 					sharedConfigBuild: true,
 					async buildApp(builder) {
-						for (const environment of Object.values(builder.environments)) if (environment.config.consumer === "client") await builder.build(environment);
+						for (const environment of Object.values(builder.environments)) if (environment.config.consumer === "client" && (environment.config.build.rolldownOptions.input !== void 0 || existsSync(resolve(environment.config.root, "index.html")))) await builder.build(environment);
 						for (const environment of Object.values(builder.environments)) if (environment.config.consumer === "server") await builder.build(environment);
 					}
 				}
@@ -400,4 +397,4 @@ async function revojs(inputConfig) {
 }
 var PACKAGE_CACHE = /* @__PURE__ */ new Map();
 //#endregion
-export { addTemplate, addTypes, addVirtual, core, createConfig, defineCommand, defineModule, matchesConsumer, module, posixPath, resolveFrameworkPackages, resolvePaths, resolvePattern, resolveSource, revojs, useModule };
+export { addTemplate, addTypes, addVirtual, core, createConfig, defineModule, matchesConsumer, module, posixPath, resolveFrameworkPackages, resolvePaths, resolvePattern, resolveSource, revojs, useModule };

package/dist/package.js

@@ -1,11 +1,11 @@
 //#region package.json
 var name = "revojs";
-var version = "0.2.43";
+var version = "0.2.45";
 var repository = {
 	"type": "git",
 	"url": "git+https://github.com/tellua/revojs.git"
 };
-var bin = { "revojs": "dist/commands/index.js" };
+var bin = { "revojs": "dist/bin/index.js" };
 var files = ["dist", "src/types"];
 var type = "module";
 var main = "./dist/index.js";
@@ -16,6 +16,10 @@ var exports = {
 		"types": "./dist/index.d.ts",
 		"import": "./dist/index.js"
 	},
+	"./commands": {
+		"types": "./dist/commands/index.d.ts",
+		"import": "./dist/commands/index.js"
+	},
 	"./module": {
 		"types": "./dist/module/index.d.ts",
 		"import": "./dist/module/index.js"

package/dist/types/index.d.ts

@@ -21,7 +21,7 @@ declare module "#hooks" {
 
 declare module "#commands" {
     import type { Source } from "revojs";
-    import type { Command } from "revojs/module";
+    import type { Command } from "revojs/commands";
 
     const entries: Source<Command>;
     export default entries;

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "revojs",
-    "version": "0.2.43",
+    "version": "0.2.45",
     "license": "MIT",
     "repository": {
         "type": "git",
         "url": "git+https://github.com/tellua/revojs.git"
     },
     "bin": {
-        "revojs": "dist/commands/index.js"
+        "revojs": "dist/bin/index.js"
     },
     "files": [
         "dist",
@@ -23,6 +23,10 @@
             "types": "./dist/index.d.ts",
             "import": "./dist/index.js"
         },
+        "./commands": {
+            "types": "./dist/commands/index.d.ts",
+            "import": "./dist/commands/index.js"
+        },
         "./module": {
             "types": "./dist/module/index.d.ts",
             "import": "./dist/module/index.js"

package/src/types/index.d.ts

@@ -21,7 +21,7 @@ declare module "#hooks" {
 
 declare module "#commands" {
     import type { Source } from "revojs";
-    import type { Command } from "revojs/module";
+    import type { Command } from "revojs/commands";
 
     const entries: Source<Command>;
     export default entries;