@fumadocs/cli 1.3.2 → 1.3.4

package/dist/installer-BWoLnsXE.js

@@ -0,0 +1,673 @@
+import { a as transformSpecifiers, i as toImportSpecifier, n as encodeImport, o as typescriptExtensions, r as collectMacroBindings, t as decodeImport } from "./import-CSbSteB3.js";
+import { r as createCache, t as HttpRegistryClient } from "./client-C2A4Jf2w.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { x } from "tinyexec";
+import { Visitor, parse } from "oxc-parser";
+import { detect } from "package-manager-detector";
+import MagicString from "magic-string";
+//#region src/registry/installer/dep-manager.ts
+async function createDeps(cwd, dependencies, devDependencies) {
+	const packageJsonPath = path.join(cwd, "package.json");
+	return new DependencyManager(cwd, await fs.readFile(packageJsonPath).then((res) => JSON.parse(res.toString())).catch(() => null), dependencies, devDependencies);
+}
+var DependencyManager = class {
+	constructor(cwd, packageJson, dependencies, devDependencies) {
+		this.cwd = cwd;
+		this.packageJson = packageJson;
+		const installedDeps = {
+			...packageJson?.dependencies,
+			...packageJson?.devDependencies
+		};
+		this.dependencies = Object.entries(dependencies).filter(([k]) => !(k in installedDeps)).map(([k, v]) => encodeDep(k, v));
+		this.devDependencies = Object.entries(devDependencies).filter(([k]) => !(k in installedDeps)).map(([k, v]) => encodeDep(k, v));
+	}
+	hasRequired() {
+		return this.dependencies.length > 0 || this.devDependencies.length > 0;
+	}
+	async writeRequired(packageJsonPath = path.resolve(this.cwd, "package.json")) {
+		if (this.packageJson === null) return false;
+		for (const dep of this.dependencies) {
+			const { name, version } = decodeDep(dep);
+			this.packageJson.dependencies ??= {};
+			this.packageJson.dependencies[name] ??= version;
+		}
+		for (const dep of this.devDependencies) {
+			const { name, version } = decodeDep(dep);
+			this.packageJson.devDependencies ??= {};
+			this.packageJson.devDependencies[name] ??= version;
+		}
+		await fs.writeFile(packageJsonPath, JSON.stringify(this.packageJson, null, 2));
+	}
+	async installRequired(packageManager) {
+		packageManager ??= (await detect())?.name ?? "npm";
+		if (this.dependencies.length > 0) await x(packageManager, ["install", ...this.dependencies]);
+		if (this.devDependencies.length > 0) await x(packageManager, [
+			"install",
+			...this.devDependencies,
+			"-D"
+		]);
+	}
+};
+function encodeDep(name, version) {
+	return version === null || version.length === 0 ? name : `${name}@${version}`;
+}
+function decodeDep(dep) {
+	const idx = dep.indexOf("@", 1);
+	if (idx === -1) return {
+		name: dep,
+		version: "latest"
+	};
+	else return {
+		name: dep.slice(0, idx),
+		version: dep.slice(idx + 1)
+	};
+}
+//#endregion
+//#region src/utils/format.ts
+function indent(code, tab = 1) {
+	const prefix = "  ".repeat(tab);
+	return code.split("\n").map((v) => v.length === 0 ? v : prefix + v).join("\n");
+}
+function dedent(code) {
+	const lines = code.split("\n");
+	const minIndent = lines.reduce((min, line) => {
+		const match = line.match(/^(\s*)\S/);
+		return match ? Math.min(min, match[1].length) : min;
+	}, Infinity);
+	return minIndent === Infinity ? lines.join("\n") : lines.map((l) => l.slice(minIndent)).join("\n");
+}
+//#endregion
+//#region src/registry/macros/route-handler.build.ts
+const reactRouterLoaderMethods = new Set([
+	"GET",
+	"HEAD",
+	"OPTIONS"
+]);
+const reactRouterActionMethods = new Set([
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+]);
+function collectRouteHandlerCalls(program, locals) {
+	const calls = [];
+	new Visitor({ CallExpression(node) {
+		if (node.callee.type !== "Identifier") return;
+		if (!locals.has(node.callee.name)) return;
+		calls.push(node);
+	} }).visit(program);
+	return calls;
+}
+function isSameCall(init, call) {
+	if (!init || init.type !== "CallExpression") return false;
+	return init.start === call.start && init.end === call.end;
+}
+function findStatementSpanForCall(program, call) {
+	for (const stmt of program.body) {
+		const span = statementSpanIfContainsCall(stmt, call);
+		if (span) return span;
+	}
+	return null;
+}
+function statementSpanIfContainsCall(stmt, call) {
+	if (stmt.type === "ExportNamedDeclaration" && stmt.declaration?.type === "VariableDeclaration") {
+		for (const d of stmt.declaration.declarations) if (isSameCall(d.init, call)) return {
+			start: stmt.start,
+			end: stmt.end
+		};
+	}
+	if (stmt.type === "VariableDeclaration") {
+		for (const d of stmt.declarations) if (isSameCall(d.init, call)) return {
+			start: stmt.start,
+			end: stmt.end
+		};
+	}
+	return null;
+}
+function objectPropertyKeyName(key) {
+	if (key.type !== "Property") return null;
+	const k = key.key;
+	if (k.type === "Identifier") return k.name;
+	if (k.type === "Literal" && typeof k.value === "string") return k.value;
+	return null;
+}
+/**
+* Read `methods`, `params`, and optional `catchAll` from the `$routeHandler` info object literal (AST).
+*/
+function parseRouteInfoFromAst(info) {
+	let methods;
+	let params;
+	let catchAll;
+	for (const prop of info.properties) {
+		if (prop.type !== "Property") continue;
+		const name = objectPropertyKeyName(prop);
+		if (name === "methods") {
+			if (prop.value.type !== "ArrayExpression") throw new Error("route-handler.build: `methods` in $routeHandler info must be an array literal");
+			const out = [];
+			for (const el of prop.value.elements) {
+				if (el == null) continue;
+				if (el.type === "Literal" && typeof el.value === "string") {
+					out.push(el.value);
+					continue;
+				}
+				throw new Error("route-handler.build: `methods` must be string literals (e.g. methods: [\"GET\", \"POST\"])");
+			}
+			methods = out;
+		}
+		if (name === "params") {
+			if (prop.value.type !== "ArrayExpression") throw new Error("route-handler.build: `params` must be an array literal");
+			const out = [];
+			for (const el of prop.value.elements) {
+				if (el == null) continue;
+				if (el.type === "Literal" && typeof el.value === "string") {
+					out.push(el.value);
+					continue;
+				}
+				throw new Error("route-handler.build: `params` must be string literals");
+			}
+			params = out;
+		}
+		if (name === "catchAll") {
+			if (prop.value.type === "Literal" && typeof prop.value.value === "string") {
+				catchAll = prop.value.value;
+				continue;
+			}
+			throw new Error("route-handler.build: `catchAll` must be a string literal");
+		}
+	}
+	if (!methods?.length) throw new Error("route-handler.build: $routeHandler info must include a non-empty `methods` array");
+	if (!params) throw new Error("route-handler.build: $routeHandler info must include a `params` array literal");
+	return {
+		methods,
+		params,
+		catchAll
+	};
+}
+function needsRouteParams(info) {
+	return info.params.length > 0 || Boolean(info.catchAll);
+}
+function encodeKey(key) {
+	if (key.includes("-")) return JSON.stringify(key);
+	return key;
+}
+function bindingNameFromParam(p) {
+	if (p.type === "Identifier") return p.name;
+	return null;
+}
+function parseHandlerFromAst(s, expr) {
+	const isFn = expr.type === "FunctionExpression";
+	const isArrow = expr.type === "ArrowFunctionExpression";
+	if (!isFn && !isArrow) throw new Error("route-handler.build: second argument to $routeHandler must be a function or async arrow function");
+	const fn = expr;
+	if (!fn.async) throw new Error("route-handler.build: route handler must be async");
+	if (isFn && (!fn.body || fn.body.type !== "BlockStatement")) throw new Error("route-handler.build: function handler must use a block body");
+	const p0 = fn.params[0];
+	const p1 = fn.params[1];
+	if (fn.params.length > 2) throw new Error("route-handler.build: route handler must have at most two parameters");
+	const requestName = p0 && bindingNameFromParam(p0) || "request";
+	const paramsName = p1 ? bindingNameFromParam(p1) : null;
+	if (p1 && !paramsName) throw new Error("route-handler.build: unsupported parameter pattern; use a simple identifier for (request, params)");
+	const body = fn.body;
+	let bodyText;
+	if (body == null) throw new Error("route-handler.build: handler has no body");
+	else if (body.type === "BlockStatement") bodyText = s.original.slice(body.start + 1, body.end - 1).replace(/^\s*?\n/, "").replace(/\n\s*?$/, "");
+	else if (fn.type === "ArrowFunctionExpression") bodyText = `return ${s.original.slice(body.start, body.end)};`;
+	else throw new Error("route-handler.build: could not extract handler body");
+	return {
+		requestName,
+		paramsName,
+		bodyText
+	};
+}
+function generateRequestDeclaration(framework, binding) {
+	if (framework === "tanstack-start") {
+		if (binding === "ctx") throw new Error("route-handler.build: name the request parameter something other than `ctx` for TanStack file routes");
+		return `const ${binding} = ctx.request;\n`;
+	}
+	if (framework === "react-router") {
+		if (binding === "args") throw new Error("route-handler.build: name the request parameter something other than `args` for React Router resource routes");
+		return `const ${binding} = args.request;\n`;
+	}
+	return "";
+}
+function generateParamsDeclaration(framework, info, paramsBinding) {
+	let paramsIdentifier;
+	let paramsCatchAllIdentifier;
+	switch (framework) {
+		case "next": return `const ${paramsBinding} = await ctx.params;\n`;
+		case "waku": return `const ${paramsBinding} = context.params;\n`;
+		case "react-router":
+			paramsIdentifier = "args.params";
+			paramsCatchAllIdentifier = "args.params['*']";
+			break;
+		case "tanstack-start":
+			paramsIdentifier = "ctx.params";
+			paramsCatchAllIdentifier = "ctx.params._splat";
+			break;
+	}
+	const parts = [];
+	for (const k of info.params) parts.push(`${encodeKey(k)}: ${paramsIdentifier}.${k}`);
+	if (info.catchAll) parts.push(`${encodeKey(info.catchAll)}: ${paramsCatchAllIdentifier}`);
+	return `const ${paramsBinding} = {\n${indent(parts.join(",\n"))}\n};\n`;
+}
+function resolveParamsBindingName(info, userSecond) {
+	if (!needsRouteParams(info)) return null;
+	return userSecond ?? "params";
+}
+function registryRouteToTanStackCreateFileRoutePath(route) {
+	const segments = route.split("/");
+	const parts = [];
+	for (const seg of segments) {
+		if (/^\[\[\.\.\.[^/\]]+\]\]$/.test(seg) || /^\[\.\.\.[^/\]]+\]$/.test(seg)) {
+			parts.push("$");
+			continue;
+		}
+		const m = /^\[([^/\]]+)\]$/.exec(seg);
+		if (m) parts.push(`$${m[1]}`);
+		else parts.push(seg);
+	}
+	return `/${parts.join("/")}`;
+}
+/** URL path for `RouteContext` / `ApiContext` string literals (leading slash, App Router–style segments). */
+function registryRouteToUrlPath(route) {
+	const t = route.replace(/^\/+/, "").replace(/\/+$/, "");
+	return t ? `/${t}` : "/";
+}
+/**
+* React Router typegen: `./+types/<segments>` relative to the route file (see `+types` next to `routes/`).
+*/
+function computeReactRouterTypesSpecifier(routeFilePath) {
+	return `./+types/${path.basename(routeFilePath, path.extname(routeFilePath))}`;
+}
+function generateImports(framework, routeFilePath) {
+	const lines = [];
+	if (framework === "tanstack-start") lines.push(`import { createFileRoute } from '@tanstack/react-router';`);
+	if (framework === "waku") lines.push(`import type { ApiContext } from 'waku/router';`);
+	if (framework === "react-router") lines.push(`import type { Route } from '${computeReactRouterTypesSpecifier(routeFilePath)}';`);
+	return lines.length ? `${lines.join("\n")}\n` : "";
+}
+function generateDeclaration(framework, route, parsedInfo, handler) {
+	const paramsBinding = resolveParamsBindingName(parsedInfo, handler.paramsName);
+	let inner = dedent(handler.bodyText);
+	if (paramsBinding) inner = generateParamsDeclaration(framework, parsedInfo, paramsBinding) + inner;
+	inner = generateRequestDeclaration(framework, handler.requestName) + inner;
+	const urlPath = registryRouteToUrlPath(route);
+	const urlPathLiteral = JSON.stringify(urlPath);
+	switch (framework) {
+		case "next": {
+			/** `RouteContext` is provided by Next.js typed routes / `next typegen` (global). */
+			const ctxType = `RouteContext<${urlPathLiteral}>`;
+			return parsedInfo.methods.map((m) => `export async function ${m}(${handler.requestName}: Request, ctx: ${ctxType}) {\n${indent(inner)}\n}`).join("\n\n");
+		}
+		case "waku": {
+			const ctxType = `ApiContext<${urlPathLiteral}>`;
+			return parsedInfo.methods.map((m) => `export async function ${m}(${handler.requestName}: Request, context: ${ctxType}) {\n${indent(inner)}\n}`).join("\n\n");
+		}
+		case "tanstack-start": return `export const Route = createFileRoute(${JSON.stringify(registryRouteToTanStackCreateFileRoutePath(route))})({\n  server: {\n    handlers: {\n${parsedInfo.methods.map((m) => `      ${m}: async (ctx) => {\n${indent(inner, 4)}\n      },`).join("\n")}\n    },\n  },\n});\n`;
+		case "react-router": {
+			const includeLoader = parsedInfo.methods.some((x) => reactRouterLoaderMethods.has(x));
+			const includeAction = parsedInfo.methods.some((x) => reactRouterActionMethods.has(x));
+			if (!includeLoader && !includeAction) throw new Error("route-handler.build: react-router needs at least one method mapped to loader (GET/HEAD/OPTIONS) or action (POST/PUT/PATCH/DELETE)");
+			const parts = [];
+			if (includeLoader) parts.push(`export async function loader(args: Route.LoaderArgs) {\n${indent(inner)}\n}`);
+			if (includeAction) parts.push(`export async function action(args: Route.ActionArgs) {\n${indent(inner)}\n}`);
+			return `${parts.join("\n\n")}\n`;
+		}
+	}
+}
+function removeMacroImport(s, importDecl) {
+	const start = importDecl.start;
+	let end = importDecl.end;
+	if (s.original[end] === "\n") end += 1;
+	s.remove(start, end);
+}
+/**
+* Rewrites a module that calls `$routeHandler` into framework-native route code.
+*
+* Output does not import `@fumadocs/cli`.
+*
+* Uses framework typegen where applicable: global `RouteContext` (Next typed routes), `ApiContext` (Waku),
+* inferred handler `ctx` (TanStack `createFileRoute`), `Route.LoaderArgs` / `Route.ActionArgs` (React Router `+types`).
+*/
+function transformRouteHandler(route, routeFilePath, framework, program, s) {
+	const macro = collectMacroBindings(program, "$routeHandler");
+	if (!macro) return;
+	const calls = collectRouteHandlerCalls(program, macro.locals);
+	if (calls.length === 0) return;
+	if (calls.length > 1) throw new Error("route-handler.build: expected exactly one $routeHandler(...) call per file");
+	const call = calls[0];
+	if (call.arguments.length !== 2) throw new Error("route-handler.build: $routeHandler must be called with (info, handler)");
+	const arg0 = call.arguments[0];
+	const arg1 = call.arguments[1];
+	if (arg0.type !== "ObjectExpression") throw new Error("route-handler.build: first argument to $routeHandler must be an object literal");
+	const parsedInfo = parseRouteInfoFromAst(arg0);
+	const handler = parseHandlerFromAst(s, arg1);
+	const stmtSpan = findStatementSpanForCall(program, call);
+	if (!stmtSpan) throw new Error("route-handler.build: $routeHandler(...) must be the initializer of a const (optionally exported)");
+	for (const decl of macro.importDecls) removeMacroImport(s, decl);
+	const extraImports = generateImports(framework, routeFilePath);
+	if (extraImports) {
+		const insertPos = findInsertPositionForNewImports(program);
+		if (insertPos === 0) s.prepend(extraImports);
+		else s.appendLeft(insertPos, `\n${extraImports}`);
+	}
+	s.overwrite(stmtSpan.start, stmtSpan.end, generateDeclaration(framework, route, parsedInfo, handler));
+	s.trim();
+}
+function findInsertPositionForNewImports(program) {
+	const last = program.body.findLast((stmt) => stmt.type === "ImportDeclaration");
+	if (last) return last.end;
+	return 0;
+}
+//#endregion
+//#region src/utils/framework.ts
+/**
+* Resolves the route file path (relative to the CLI `baseDir`) from an App Router–style route string.
+*
+* @param route - The route path, e.g., "api/auth/[[...slug]]".
+* @param framework - Value of `framework` in CLI config.
+* @param extension - Optional file extension, default is "ts".
+* @returns Relative path incl. framework route root, e.g. "app/api/foo/route.ts" (next), "routes/api.foo.$.ts" (tanstack-start), or "routes/api/foo/$.ts" (react-router).
+*/
+function resolveRouteFilePath(route, framework, extension = "ts") {
+	route = route.replace(/^\/+/, "").replace(/\/+$/, "");
+	switch (framework) {
+		case "next": return `app/${route}/route.${extension}`;
+		case "tanstack-start": {
+			let flat = route.replace(/\[\[\.\.\.[^/\]]+\]\]/g, "$").replace(/\[\.\.\.[^/\]]+\]/g, "$").replace(/\[([^/\]]+)\]/g, (_, p1) => `$${p1}`);
+			flat = flat.replaceAll("/", ".");
+			return `routes/${flat}.${extension}`;
+		}
+		case "react-router": return `app/routes/${route.replace(/\[\[\.\.\.[^/\]]+\]\]/g, "all").replace(/\[\.\.\.[^/\]]+\]/g, "all").replace(/\[([^/\]]+)\]/g, (_, v) => `$${v}`)}.${extension}`;
+		case "waku": return `pages/_api/${route.replace(/\[\[\.\.\.([^\]]+)\]\]/g, "[...$1]").replace(/\[\.\.\.([^\]]+)\]/g, "[...$1]")}.${extension}`;
+		default: return framework;
+	}
+}
+function resolveReactRouterRoute(route) {
+	return route.replace(/\[\[\.\.\.[^/\]]+\]\]/g, "*").replace(/\[\.\.\.[^/\]]+\]/g, "*").replace(/\[([^/\]]+)\]/g, (_, v) => `:${v}`);
+}
+function tsSingleQuotedLiteral(value) {
+	return `'${value.replaceAll("\\", "\\\\").replaceAll("'", "\\'")}'`;
+}
+function unwrapExportDefaultToArrayExpression(decl) {
+	if (decl.type === "FunctionDeclaration" || decl.type === "ClassDeclaration") return null;
+	let expr = decl;
+	while (expr) {
+		if (expr.type === "ArrayExpression") return expr;
+		if (expr.type === "TSSatisfiesExpression" || expr.type === "TSAsExpression") {
+			expr = expr.expression;
+			continue;
+		}
+		return null;
+	}
+	return null;
+}
+function parseStringArgument(expr) {
+	if (!expr) return null;
+	if (expr.type === "Literal" && typeof expr.value === "string") return expr.value;
+	return null;
+}
+function parseReactRouterRoutesItem(item) {
+	if (!item || item.type !== "CallExpression") return;
+	const callee = item.callee;
+	if (callee.type !== "Identifier") return;
+	if (callee.name === "route") {
+		const path = parseStringArgument(item.arguments[0]);
+		const module = parseStringArgument(item.arguments[1]);
+		if (path === null || module === null) return;
+		return {
+			type: "route",
+			path,
+			module,
+			expression: item
+		};
+	}
+	if (callee.name === "index") {
+		const module = parseStringArgument(item.arguments[0]);
+		if (module === null) return;
+		return {
+			type: "index",
+			module,
+			expression: item
+		};
+	}
+}
+function findReactRouterRoutesArray(program) {
+	for (const stmt of program.body) {
+		if (stmt.type !== "ExportDefaultDeclaration") continue;
+		if (stmt.declaration == null) continue;
+		return unwrapExportDefaultToArrayExpression(stmt.declaration);
+	}
+	return null;
+}
+/**
+* Inserts a `route(...)` or `index(...)` entry into a React Router `routes.ts` config
+* (`export default [ ... ] satisfies RouteConfig`), writing the file in place.
+*
+* New `route` entries are placed before the first `route('*', ...)` splat (if any) so the
+* catch-all remains last.
+*/
+async function addReactRouterRouteToFile(routesFilePath, content, spec, write = true) {
+	const parsed = await parse(routesFilePath, content, {
+		lang: routesFilePath.endsWith(".tsx") ? "tsx" : "ts",
+		astType: "ts"
+	});
+	if (parsed.errors.length > 0) throw new Error(`addReactRouterRouteToFile: failed to parse ${routesFilePath}:\n${parsed.errors.map((e) => e.message).join("\n")}`);
+	const array = findReactRouterRoutesArray(parsed.program);
+	if (!array) throw new Error(`addReactRouterRouteToFile: no export default array found in ${routesFilePath}`);
+	const elements = [];
+	for (const v of array.elements) if (v && v.type !== "SpreadElement") {
+		const parsed = parseReactRouterRoutesItem(v);
+		if (parsed) elements.push(parsed);
+	}
+	if (spec.kind === "index") {
+		if (elements.some((element) => element.type === "index")) return {
+			added: false,
+			content
+		};
+	} else if (elements.some((element) => element.type === "route" && element.path === spec.path)) return {
+		added: false,
+		content
+	};
+	const line = spec.kind === "index" ? `index(${tsSingleQuotedLiteral(spec.module)})` : `route(${tsSingleQuotedLiteral(spec.path)}, ${tsSingleQuotedLiteral(spec.module)})`;
+	const s = new MagicString(content);
+	const insertAt = elements.findLast((element) => element.type !== "route" || !element.path.endsWith("*"));
+	if (!insertAt) s.appendRight(array.start + 1, `\n  ${line},\n`);
+	else s.appendRight(insertAt.expression.end, `,\n  ${line}`);
+	const out = s.toString();
+	if (write) await fs.writeFile(routesFilePath, out, "utf8");
+	return {
+		added: true,
+		content: out
+	};
+}
+//#endregion
+//#region src/registry/installer/index.ts
+var ComponentInstaller = class {
+	constructor(rootClient, options = {}) {
+		this.rootClient = rootClient;
+		this.installedFiles = /* @__PURE__ */ new Set();
+		this.downloadCache = createCache();
+		this.dependencies = {};
+		this.devDependencies = {};
+		this.cwd = options.cwd ?? process.cwd();
+		this.plugins = options.plugins ?? [];
+	}
+	async installComponent(comp, ctx) {
+		if (ctx.stack.indexOf(comp) !== ctx.stack.length - 1) return;
+		const pluginCtx = {
+			installer: this,
+			...ctx
+		};
+		for (const plugin of this.plugins) comp = await plugin.beforeInstall?.(comp, pluginCtx) ?? comp;
+		Object.assign(this.dependencies, comp.dependencies);
+		Object.assign(this.devDependencies, comp.devDependencies);
+		for (const file of comp.files) {
+			const outPath = this.resolveOutputPath(file);
+			if (this.installedFiles.has(outPath)) continue;
+			this.installedFiles.add(outPath);
+			const output = typescriptExtensions.includes(path.extname(outPath)) ? await this.transform(file, comp, ctx) : file.content;
+			const status = await fs.readFile(outPath).then((res) => {
+				if (res.toString().trim() === output.trim()) return "ignore";
+				return "need-update";
+			}).catch(() => "write");
+			if (status === "ignore") continue;
+			if (status === "need-update") {
+				if (!await ctx.io.confirmFileOverride({ path: outPath })) continue;
+			}
+			await fs.mkdir(path.dirname(outPath), { recursive: true });
+			await fs.writeFile(outPath, output);
+			ctx.io.onFileDownloaded({
+				path: outPath,
+				file,
+				component: comp
+			});
+		}
+		for (const child of comp.$subComponents) {
+			const stack = [...ctx.stack, child];
+			const variables = { ...ctx.$variables };
+			if (child.$registry.registryId !== comp.$registry.registryId) {
+				const info = await child.$registry.fetchRegistryInfo();
+				Object.assign(variables, info.variables);
+			}
+			Object.assign(variables, child.variables);
+			await this.installComponent(child, {
+				...ctx,
+				stack,
+				$variables: variables
+			});
+		}
+	}
+	async install(name, io) {
+		let downloaded;
+		const registry = (await this.rootClient.fetchRegistryInfo()).registries?.find((registry) => name.startsWith(`${registry}/`));
+		if (registry) downloaded = await this.download(name.slice(registry.length + 1), this.rootClient.createLinkedRegistryClient(registry));
+		else downloaded = await this.download(name, this.rootClient);
+		const allComponents = /* @__PURE__ */ new Set();
+		function scan(comp) {
+			if (allComponents.has(comp)) return;
+			allComponents.add(comp);
+			for (const child of comp.$subComponents) scan(child);
+		}
+		scan(downloaded);
+		const importLookup = /* @__PURE__ */ new Map();
+		for (const comp of allComponents) for (const file of comp.files) importLookup.set(encodeImport(file), file);
+		const info = await downloaded.$registry.fetchRegistryInfo();
+		await this.installComponent(downloaded, {
+			importLookup,
+			io,
+			$variables: {
+				...info.env,
+				...downloaded.variables
+			},
+			stack: [downloaded]
+		});
+	}
+	deps() {
+		return createDeps(this.cwd, this.dependencies, this.devDependencies);
+	}
+	async onEnd() {
+		const config = this.rootClient.config;
+		if (config.commands.format) await x(config.commands.format);
+	}
+	/**
+	* download component & its sub components
+	*/
+	async download(name, client) {
+		return this.downloadCache.cached(JSON.stringify([client.registryId, name]), async (presolve) => {
+			for (const plugin of this.plugins) await plugin.beforeDownload?.({
+				installer: this,
+				name
+			});
+			const comp = await client.fetchComponent(name);
+			const result = {
+				...comp,
+				$registry: client,
+				$subComponents: []
+			};
+			presolve(result);
+			result.$subComponents = await Promise.all(comp.subComponents.map((sub) => {
+				if (typeof sub === "string") return this.download(sub, client);
+				let subClient;
+				if (this.rootClient instanceof HttpRegistryClient) {
+					const baseUrl = new URL(sub.baseUrl, `${this.rootClient.baseUrl}/`).href;
+					subClient = client instanceof HttpRegistryClient && client.baseUrl === baseUrl ? client : new HttpRegistryClient(baseUrl, client.config);
+				} else subClient = new HttpRegistryClient(sub.baseUrl, client.config);
+				return this.download(sub.component, subClient);
+			}));
+			for (const plugin of this.plugins) await plugin.afterDownload?.({
+				installer: this,
+				name,
+				result
+			});
+			return result;
+		});
+	}
+	async transform(file, component, ctx) {
+		const filePath = this.resolveOutputPath(file);
+		const transformCtx = {
+			installer: this,
+			file,
+			filePath,
+			component,
+			...ctx
+		};
+		let transformed = await this.defaultTransform(file.content, transformCtx);
+		for (const plugin of this.plugins) {
+			if (!plugin.transform) continue;
+			transformed = await plugin.transform(transformed, transformCtx);
+		}
+		return transformed;
+	}
+	async defaultTransform(content, ctx) {
+		const { file, importLookup, filePath, $variables, io } = ctx;
+		const config = this.rootClient.config;
+		const parsed = await parse(filePath, content);
+		const s = new MagicString(content);
+		transformSpecifiers(parsed.program, s, (specifier) => {
+			for (const plugin of this.plugins) if (plugin.transformImport) specifier = plugin.transformImport(specifier, ctx);
+			if (importLookup.has(specifier)) {
+				let outputPath = this.resolveOutputPath(importLookup.get(specifier));
+				for (const [k, v] of Object.entries($variables)) if (typeof v === "string") outputPath = outputPath.replaceAll(`<${k}>`, v);
+				return toImportSpecifier(filePath, outputPath);
+			}
+			const decoded = decodeImport(specifier);
+			if ("raw" in decoded) return decoded.raw;
+			io.onWarn(`cannot find the referenced file of ${specifier}`);
+			return specifier;
+		});
+		if (file.type === "route-handler") {
+			transformRouteHandler(file.route, filePath, config.framework, parsed.program, s);
+			if (config.framework === "react-router") {
+				const routesFile = path.join(this.cwd, "app/routes.ts");
+				const content = await fs.readFile(routesFile, "utf-8").then((res) => res.toString()).catch(() => null);
+				if (content) await addReactRouterRouteToFile(routesFile, content, {
+					path: resolveReactRouterRoute(file.route),
+					module: path.relative(path.dirname(routesFile), filePath)
+				});
+			}
+		}
+		return s.toString();
+	}
+	resolveOutputPath(file) {
+		const config = this.rootClient.config;
+		if (file.type === "route-handler") {
+			const rel = resolveRouteFilePath(file.route, config.framework, "ts");
+			return path.resolve(this.cwd, config.baseDir, rel);
+		}
+		const dir = {
+			components: config.aliases.componentsDir,
+			ui: config.aliases.uiDir,
+			css: config.aliases.cssDir,
+			lib: config.aliases.libDir,
+			layout: config.aliases.layoutDir
+		}[file.type];
+		if (file.target) return path.resolve(this.cwd, config.baseDir, file.target.replace("<dir>", dir));
+		return path.resolve(this.cwd, config.baseDir, dir, path.basename(file.path));
+	}
+};
+//#endregion
+export { ComponentInstaller as t };
+
+//# sourceMappingURL=installer-BWoLnsXE.js.map