@public-tauri/raycast-convert 1.0.1 → 1.1.0

package/dist/src-Re0YIJP-.mjs

@@ -0,0 +1,729 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import fs$1 from "node:fs";
+import { fileURLToPath } from "node:url";
+//#region src/build.ts
+const installCommand = "pnpm";
+const installArgs = [
+	"install",
+	"--ignore-scripts",
+	"--frozen-lockfile=false"
+];
+const runInstall = (cwd, label) => {
+	console.log(`Installing ${label} dependencies...`);
+	const result = spawnSync(installCommand, installArgs, {
+		cwd,
+		stdio: "inherit"
+	});
+	if (result.status !== 0) throw new Error(`${label} dependency install failed with exit code ${result.status}`);
+};
+const installOutputDependencies = (options) => {
+	runInstall(options.outputDir, "converted plugin");
+};
+const getBuildCommand = (options) => {
+	return {
+		command: "pnpm",
+		args: [
+			"exec",
+			"tsdown",
+			"--config",
+			path.join(options.outputDir, "tsdown.config.ts")
+		],
+		cwd: options.outputDir
+	};
+};
+const buildConvertedPlugin = (options) => {
+	const { command, args: buildArgs, cwd } = getBuildCommand(options);
+	const result = spawnSync(command, buildArgs, {
+		cwd,
+		stdio: "inherit"
+	});
+	if (result.status !== 0) throw new Error(`Build failed with exit code ${result.status}`);
+};
+const installAndBuild = (options) => {
+	installOutputDependencies(options);
+	buildConvertedPlugin(options);
+};
+//#endregion
+//#region src/files.ts
+const readJson = async (filePath) => JSON.parse(await fs.readFile(filePath, "utf8"));
+const writeJson = async (filePath, value) => {
+	await fs.mkdir(path.dirname(filePath), { recursive: true });
+	await fs.writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+};
+const exists = async (filePath) => {
+	try {
+		await fs.access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+/** Names skipped when mirroring the Raycast plugin into outDir (see README). */
+const PLUGIN_COPY_SKIP_NAMES = new Set([
+	"package.json",
+	"node_modules",
+	"pnpm-lock.yaml",
+	"package-lock.json",
+	"yarn.lock"
+]);
+/**
+* Recursively copy the Raycast plugin directory into `outputDir`, except entries in `skipNames`.
+* Source `package.json` is never copied; generated `package.json` is written separately.
+*/
+const copyPluginSourceToOutput = async (inputDir, outputDir, skipNames = PLUGIN_COPY_SKIP_NAMES) => {
+	await fs.mkdir(outputDir, { recursive: true });
+	const entries = await fs.readdir(inputDir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (skipNames.has(entry.name)) continue;
+		const from = path.join(inputDir, entry.name);
+		const to = path.join(outputDir, entry.name);
+		await fs.cp(from, to, { recursive: true });
+	}
+};
+//#endregion
+//#region src/commands.ts
+const findCommandEntry = async (inputDir, command) => {
+	const candidates = [
+		path.join(inputDir, "src", `${command.name}.tsx`),
+		path.join(inputDir, "src", `${command.name}.ts`),
+		path.join(inputDir, "src", `${command.name}.jsx`),
+		path.join(inputDir, "src", `${command.name}.js`),
+		path.join(inputDir, "src", command.name, "index.tsx"),
+		path.join(inputDir, "src", command.name, "index.ts"),
+		path.join(inputDir, "src", command.name, "index.jsx"),
+		path.join(inputDir, "src", command.name, "index.js")
+	];
+	for (const candidate of candidates) if (await exists(candidate)) return candidate;
+	return null;
+};
+const SUPPORTED_COMMAND_MODES = new Set(["no-view", "view"]);
+const SUPPORTED_COMMAND_ARGUMENT_TYPES = new Set([
+	"text",
+	"password",
+	"dropdown"
+]);
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const validateCommandArguments = (command) => {
+	const args = command.arguments;
+	if (!args) return null;
+	if (!Array.isArray(args)) return "arguments must be an array";
+	if (args.length > 3) return "arguments length exceeds Raycast limit (3)";
+	for (const item of args) {
+		const arg = item;
+		if (!isObject(arg)) return "argument item must be an object";
+		if (!arg.name || typeof arg.name !== "string") return "argument.name is required";
+		if (!arg.type || typeof arg.type !== "string" || !SUPPORTED_COMMAND_ARGUMENT_TYPES.has(arg.type)) return `argument "${arg.name}" has unsupported type: ${String(arg.type)}`;
+		if (arg.required !== void 0 && typeof arg.required !== "boolean") return `argument "${arg.name}" has invalid required field`;
+		if (arg.placeholder !== void 0 && typeof arg.placeholder !== "string") return `argument "${arg.name}" has invalid placeholder field`;
+		if (arg.type === "dropdown") {
+			if (!Array.isArray(arg.data) || arg.data.length === 0) return `dropdown argument "${arg.name}" requires non-empty data`;
+			for (const option of arg.data) if (!isObject(option) || typeof option.value !== "string") return `dropdown argument "${arg.name}" has invalid option value`;
+		}
+	}
+	return null;
+};
+const resolveSupportedCommands = async (inputDir, sourceCommands) => {
+	const convertedCommands = [];
+	const skippedCommands = [];
+	for (const command of sourceCommands) {
+		const mode = command.mode || "view";
+		if (!SUPPORTED_COMMAND_MODES.has(mode)) {
+			skippedCommands.push({
+				name: command.name,
+				reason: `Unsupported mode: ${command.mode || "<empty>"}`
+			});
+			continue;
+		}
+		const argumentErr = validateCommandArguments(command);
+		if (argumentErr) {
+			skippedCommands.push({
+				name: command.name,
+				reason: `Invalid arguments: ${argumentErr}`
+			});
+			continue;
+		}
+		const entry = await findCommandEntry(inputDir, command);
+		if (!entry) {
+			skippedCommands.push({
+				name: command.name,
+				reason: "Command entry not found under src/"
+			});
+			continue;
+		}
+		convertedCommands.push({
+			...command,
+			mode,
+			entry
+		});
+	}
+	if (!convertedCommands.length) throw new Error("No supported Raycast commands were converted");
+	return {
+		convertedCommands,
+		skippedCommands
+	};
+};
+//#endregion
+//#region src/generate/copy-templates.ts
+const templateDir = path.join(path.dirname(fileURLToPath(import.meta.url)), "../../templates");
+const workerViewRelPaths = [
+	"json-patch.ts",
+	"raycast-view-protocol.ts",
+	"raycast-worker-runtime.ts",
+	"host-instance.ts",
+	"virtual-serialize.ts"
+];
+function copyTemplateFile(relativePath, buildDir) {
+	const dest = path.join(buildDir, relativePath);
+	fs$1.mkdirSync(path.dirname(dest), { recursive: true });
+	fs$1.copyFileSync(path.join(templateDir, relativePath), dest);
+}
+/** 自 startDir 向上查找 monorepo 根（与 options.ts 一致） */
+function findPublicTauriRepoRoot$1(startDir) {
+	let dir = path.resolve(startDir);
+	const { root } = path.parse(dir);
+	while (dir !== root) {
+		const ws = path.join(dir, "pnpm-workspace.yaml");
+		const apiPkg = path.join(dir, "packages", "api", "package.json");
+		if (fs$1.existsSync(ws) && fs$1.existsSync(apiPkg)) return dir;
+		dir = path.dirname(dir);
+	}
+	return null;
+}
+function getTemplateRaycastViewDistDir(repoRoot) {
+	return path.join(repoRoot, "packages/template/dist");
+}
+/** 若尚未 build，则在 repo 根执行 `pnpm --filter @public-tauri/template build` */
+function ensureRaycastViewTemplateBuilt(repoRoot) {
+	const marker = path.join(getTemplateRaycastViewDistDir(repoRoot), "raycast.html");
+	if (fs$1.existsSync(marker)) return;
+	if (spawnSync("pnpm", [
+		"--filter",
+		"@public-tauri/template",
+		"run",
+		"build"
+	], {
+		cwd: repoRoot,
+		stdio: "inherit",
+		shell: process.platform === "win32"
+	}).status !== 0) throw new Error("Building @public-tauri/template failed. From the repo root run: pnpm --filter @public-tauri/template build");
+}
+/**
+* 将 `packages/template` 的 Vite 应用产物复制到插件 `dist/view/`（与 `dist/server.js` 并列）。
+* wujie `publicPlugin.html` 指向 `./dist/view/raycast.html`。
+*/
+function copyRaycastViewTemplateAppDist(repoRoot, pluginDistDir) {
+	const srcDir = getTemplateRaycastViewDistDir(repoRoot);
+	const marker = path.join(srcDir, "raycast.html");
+	if (!fs$1.existsSync(marker)) throw new Error(`Missing ${marker}; build @public-tauri/template first.`);
+	const destDir = path.join(pluginDistDir, "view");
+	fs$1.rmSync(destDir, {
+		recursive: true,
+		force: true
+	});
+	fs$1.cpSync(srcDir, destDir, { recursive: true });
+}
+/** 将 Worker 侧 view 模板（reconciler + 宿主类型 + 序列化 + 组件）复制到 `.raycast-build` */
+function copyRaycastWorkerViewBundle(buildDir) {
+	for (const rel of workerViewRelPaths) copyTemplateFile(rel, buildDir);
+}
+//#endregion
+//#region src/generate/public-main.ts
+const generatePublicMain = () => `export default function createPlugin() {
+  const getApi = () => window.$wujie?.props;
+  return {
+  async onAction(command, action, query, options) {
+    const api = getApi();
+    try {
+      await api.channel.invoke('raycast:run', {
+        commandName: command.name,
+        query,
+        action,
+        options,
+        preferences: api.getPreferences?.() || {},
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await api.dialog.showToast(message);
+      throw error;
+    }
+  },
+  };
+}
+`;
+//#endregion
+//#region src/generate/server-module.ts
+const commandEntryImportSpecifier = (inputDir, outputDir, buildDir, entry) => {
+	const outputEntry = path.join(outputDir, path.relative(path.resolve(inputDir), path.resolve(entry)));
+	let rel = path.relative(path.resolve(buildDir), outputEntry);
+	rel = rel.split(path.sep).join("/");
+	if (rel && !rel.startsWith(".") && !rel.startsWith("/")) return `./${rel}`;
+	return rel;
+};
+const generateServerModule = (commands, packageName, publicCommands, layout) => {
+	const nvLoaders = commands.noView.map((command) => `  ${JSON.stringify(command.name)}: () => import(${JSON.stringify(commandEntryImportSpecifier(layout.inputDir, layout.outputDir, layout.buildDir, command.entry))}),`).join("\n");
+	const vvLoaders = commands.view.map((command) => `  ${JSON.stringify(command.name)}: () => import(${JSON.stringify(commandEntryImportSpecifier(layout.inputDir, layout.outputDir, layout.buildDir, command.entry))}),`).join("\n");
+	const commandManifests = JSON.stringify(publicCommands, null, 2);
+	const viewRuntimeImport = commands.view.length ? "import { createRaycastViewSession, __setRaycastViewContext } from './raycast-worker-runtime';" : "";
+	const raycastRunHandler = commands.noView.length ? `channel.handle('raycast:run', async (payload = {}) => {
+  const commandName = String(payload.commandName || '');
+  const loadCommandModule = commandModuleLoaders[commandName];
+  if (!loadCommandModule) {
+    throw new Error(\`Unknown Raycast command: \${commandName}\`);
+  }
+  const launchPayload = payload.options?.payload || {};
+  __setRaycastContext({
+    pluginName: ${JSON.stringify(packageName)},
+    commandName,
+    commandMode: 'no-view',
+    commands: commandManifests,
+    launchType: launchPayload.launchType,
+    preferences: payload.preferences || {},
+    supportPath: path.join(pluginRoot, '.raycast-compat'),
+    assetsPath: path.join(pluginRoot, 'assets'),
+  });
+  const commandModule = await loadCommandModule();
+  const run = commandModule.default;
+  if (typeof run !== 'function') {
+    throw new Error(\`Raycast command \${commandName} has no default function export\`);
+  }
+  return await run({
+    arguments: launchPayload.arguments || {},
+    fallbackText: launchPayload.fallbackText ?? payload.query ?? '',
+    launchContext: launchPayload.context ?? payload,
+    launchType: launchPayload.launchType || 'userInitiated',
+  });
+});
+` : "";
+	const viewHandlers = commands.view.length ? `const viewSessions = new Map();
+
+channel.handle('raycast:view:mount', async (payload = {}) => {
+  const commandName = String(payload.commandName || '');
+  const existingSession = viewSessions.get(commandName);
+  if (existingSession) {
+    existingSession.unmount();
+    viewSessions.delete(commandName);
+  }
+  const loadViewCommandModule = viewCommandModuleLoaders[commandName];
+  if (!loadViewCommandModule) {
+    throw new Error(\`Unknown Raycast view command: \${commandName}\`);
+  }
+  __setRaycastViewContext({
+    pluginName: ${JSON.stringify(packageName)},
+    commandName,
+    preferences: payload.preferences || {},
+    supportPath: path.join(pluginRoot, '.raycast-compat'),
+    assetsPath: path.join(pluginRoot, 'assets'),
+    launchProps: {
+      arguments: payload.options?.payload?.arguments || {},
+      fallbackText: payload.options?.payload?.fallbackText ?? payload.query ?? '',
+      launchContext: payload.options?.payload?.context ?? payload,
+      launchType: payload.options?.payload?.launchType || 'userInitiated',
+    },
+  });
+  const commandModule = await loadViewCommandModule();
+  const Command = commandModule.default;
+  if (typeof Command !== 'function') {
+    throw new Error(\`Raycast view command \${commandName} has no default function export\`);
+  }
+
+  const session = createRaycastViewSession({
+    emitSnapshot: (snapshot) => channel.emit('raycast:view:snapshot', snapshot),
+    emitPatch: (patches) => channel.emit('raycast:view:patch', patches),
+  });
+  viewSessions.set(commandName, session);
+  await session.mount(Command);
+  return true;
+});
+
+channel.handle('raycast:view:run-action', async (payload = {}) => {
+  const session = viewSessions.get(String(payload.commandName || ''));
+  if (!session) throw new Error(\`No Raycast view session for \${String(payload.commandName || '')}\`);
+  const rawArgs = payload.args;
+  const args = Array.isArray(rawArgs) ? rawArgs : [];
+  await session.dispatchHostEvent(String(payload.hostId || ''), String(payload.event || 'onAction'), args);
+  return true;
+});
+
+channel.handle('raycast:view:unmount', async (payload = {}) => {
+  const commandName = String(payload.commandName || '');
+  const session = viewSessions.get(commandName);
+  if (session) {
+    session.unmount();
+    viewSessions.delete(commandName);
+  }
+  // 无活跃 view 会话时退出 Worker，配合宿主按需加载下次再拉起线程
+  if (viewSessions.size === 0) {
+    queueMicrotask(() => process.exit(0));
+  }
+  return true;
+});
+` : "";
+	return `import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { channel } from '@public-tauri/api/node';
+import { __setRaycastContext } from '@public-tauri/api/raycast';
+${viewRuntimeImport}
+
+${commands.noView.length ? `const commandModuleLoaders: Record<string, () => Promise<any>> = {
+${nvLoaders}
+};
+` : "const commandModuleLoaders: Record<string, () => Promise<any>> = {};"}
+${commands.view.length ? `const viewCommandModuleLoaders: Record<string, () => Promise<any>> = {
+${vvLoaders}
+};
+` : "const viewCommandModuleLoaders: Record<string, () => Promise<any>> = {};"}
+
+const distDir = path.dirname(fileURLToPath(import.meta.url));
+const pluginRoot = path.dirname(distDir);
+const commandManifests = ${commandManifests};
+
+${raycastRunHandler}
+${viewHandlers}
+`;
+};
+//#endregion
+//#region src/generate/tsdown-config.ts
+const formatAlias = (aliases) => Object.entries(aliases).map(([key, value]) => `      ${JSON.stringify(key)}: ${JSON.stringify(value)},`).join("\n");
+const formatAliasProperty = (aliases) => {
+	const entries = formatAlias(aliases);
+	return entries ? `    alias: {\n${entries}\n    },` : "    alias: {},";
+};
+/** Server 入口：`@raycast/api` → `@public-tauri/api/raycast` 源码；view 与 no-view 一致。 */
+const getServerAliases = (outputDir) => {
+	const apiSrc = path.join(outputDir, "node_modules", "@public-tauri", "api", "src");
+	return {
+		"@raycast/api": path.join(apiSrc, "raycast.ts"),
+		"@public-tauri/api/node": path.join(apiSrc, "node.ts")
+	};
+};
+const generateTsdownConfig = (options, flags) => {
+	const entries = [];
+	if (flags.hasPublicMain) entries.push(`  {
+    entry: ${JSON.stringify(path.join(options.buildDir, "public-main.ts"))},
+    format: 'esm',
+    platform: 'browser',
+    target: 'es2022',
+    outDir: ${JSON.stringify(options.distDir)},
+    outExtensions: () => ({ js: '.js' }),
+    deps: {
+      alwaysBundle: () => true,
+    },
+${formatAliasProperty({})}
+  },`);
+	entries.push(`  {
+    entry: ${JSON.stringify(path.join(options.buildDir, "server.ts"))},
+    format: 'esm',
+    platform: 'node',
+    target: 'es2022',
+    outDir: ${JSON.stringify(options.distDir)},
+    outExtensions: () => ({ js: '.js' }),
+    deps: {
+      alwaysBundle: () => true,
+    },
+${formatAliasProperty(getServerAliases(options.outputDir))}
+  },`);
+	return `export default [
+${entries.join("\n")}
+];
+`;
+};
+//#endregion
+//#region src/icons.ts
+const isUrlLike = (value) => /^(?:https?:|data:|asset:|public-icon:)/.test(value);
+const hasPathSegment = (value) => value.includes("/") || value.includes("\\");
+const normalizeRaycastIcon = (icon) => {
+	if (!icon) return void 0;
+	if (isUrlLike(icon)) return icon;
+	if (icon.startsWith("./") || icon.startsWith("../") || icon.startsWith("/")) return icon;
+	if (hasPathSegment(icon)) return `./${icon}`;
+	return `./assets/${icon}`;
+};
+//#endregion
+//#region src/options.ts
+const resolveMode = (mode) => mode || "development";
+/**
+* 自 startDir 向上查找 monorepo 根（pnpm-workspace.yaml + packages/api），避免依赖 process.cwd()
+*（例如从 src-node、src-node/src 启动 Node 时 cwd 并非仓库根）。
+*/
+const findPublicTauriRepoRoot = (startDir) => {
+	let dir = path.resolve(startDir);
+	const { root } = path.parse(dir);
+	while (dir !== root) {
+		const ws = path.join(dir, "pnpm-workspace.yaml");
+		const apiPkg = path.join(dir, "packages", "api", "package.json");
+		if (fs$1.existsSync(ws) && fs$1.existsSync(apiPkg)) return dir;
+		dir = path.dirname(dir);
+	}
+};
+const resolveInvocationDir = (options) => {
+	if (options.invocationDir) return path.resolve(options.invocationDir);
+	if (resolveMode(options.mode) !== "development") return path.resolve(process.cwd());
+	const fromRoot = findPublicTauriRepoRoot(process.cwd());
+	if (fromRoot) return fromRoot;
+	throw new Error("development 模式需要定位 monorepo 根目录（含 pnpm-workspace.yaml 与 packages/api）。请在仓库内执行、设置 invocationDir，或改用 production 模式。");
+};
+const resolveConvertOptions = (options) => {
+	const inputDir = path.resolve(options.inputDir);
+	const outputDir = path.resolve(options.outputDir || `${inputDir}-public`);
+	const invocationDir = resolveInvocationDir(options);
+	const mode = resolveMode(options.mode);
+	return {
+		inputDir,
+		outputDir,
+		build: Boolean(options.build),
+		mode,
+		invocationDir,
+		publicApiDependency: mode === "development" ? `file:${path.join(invocationDir, "packages", "api")}` : "latest",
+		buildDir: path.join(outputDir, ".raycast-build"),
+		distDir: path.join(outputDir, "dist")
+	};
+};
+//#endregion
+//#region src/package-json.ts
+const rewriteDependencyMap = (dependencies) => {
+	const rewritten = { ...dependencies || {} };
+	const replacedRaycastApi = "@raycast/api" in rewritten;
+	if (replacedRaycastApi) delete rewritten["@raycast/api"];
+	return {
+		dependencies: rewritten,
+		replacedRaycastApi
+	};
+};
+const createConvertedPackage = (sourcePackage, publicPlugin, options) => {
+	const dependenciesResult = rewriteDependencyMap(sourcePackage.dependencies);
+	const devDependenciesResult = rewriteDependencyMap(sourcePackage.devDependencies);
+	if (dependenciesResult.replacedRaycastApi || devDependenciesResult.replacedRaycastApi) options.warnings.push({
+		type: "dependency",
+		message: "Replaced @raycast/api with @public-tauri/api (see tsdown alias); @raycast/utils is left as declared"
+	});
+	return {
+		...sourcePackage,
+		name: options.convertedPackageName,
+		version: sourcePackage.version || "1.0.0",
+		type: "module",
+		private: true,
+		publicPlugin,
+		scripts: {
+			...sourcePackage.scripts || {},
+			build: "tsdown --config tsdown.config.ts"
+		},
+		dependencies: {
+			...dependenciesResult.dependencies,
+			"@public-tauri/api": dependenciesResult.dependencies["@public-tauri/api"] || options.publicApiDependency,
+			...options.hasViewCommands ? {
+				react: dependenciesResult.dependencies.react || "^19.0.0",
+				"react-reconciler": dependenciesResult.dependencies["react-reconciler"] || "^0.31.0"
+			} : {}
+		},
+		devDependencies: {
+			...devDependenciesResult.dependencies,
+			tsdown: devDependenciesResult.dependencies.tsdown || "^0.21.7",
+			...options.hasViewCommands ? { "@types/react": devDependenciesResult.dependencies["@types/react"] || "^19.0.0" } : {}
+		}
+	};
+};
+//#endregion
+//#region src/package-name.ts
+const RAYCAST_CONVERTED_SCOPE = "@public-tauri-raycast";
+/** npm 包名片段：与 npm 命名惯例对齐的小写、符号规整 */
+const sanitizeSlug = (raw) => {
+	let segment = raw.trim().toLowerCase().replace(/[^a-z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+	if (!segment || /^[._]/.test(segment)) segment = `plugin-${segment || "unnamed"}`.replace(/^-+/, "");
+	return segment || "raycast-plugin";
+};
+/**
+* 未 scope 的 Raycast 官方插件：一般为单段名字 → `@public-tauri-raycast/<slug>`。
+* 若将来出现 scoped：`@my-scope/xxx` → `@public-tauri-raycast/my-scope_xxx`。
+*/
+const resolveRaycastSlug = (sourcePackage, inputDir) => {
+	const raw = typeof sourcePackage.name === "string" ? sourcePackage.name.trim() : "";
+	if (raw.startsWith("@")) {
+		const slash = raw.indexOf("/");
+		if (slash !== -1) {
+			const scope = raw.slice(1, slash);
+			const pkg = raw.slice(slash + 1);
+			return `${sanitizeSlug(scope)}_${sanitizeSlug(pkg)}`;
+		}
+		return sanitizeSlug(raw.slice(1));
+	}
+	if (raw) return sanitizeSlug(raw);
+	return sanitizeSlug(path.basename(path.resolve(inputDir)));
+};
+const resolveConvertedPackageName = (sourcePackage, inputDir) => `${RAYCAST_CONVERTED_SCOPE}/${resolveRaycastSlug(sourcePackage, inputDir)}`;
+//#endregion
+//#region src/preferences.ts
+const mapPreferenceType = (type, warnings) => {
+	switch (type) {
+		case "password": return "password";
+		case "textarea": return "textarea";
+		case "dropdown": return "select";
+		case "checkbox": return "select";
+		case "textfield":
+		case "appPicker":
+		case void 0: return "text";
+		default:
+			warnings.push({
+				type: "preference",
+				message: `Unsupported preference type "${type}", converted to text`
+			});
+			return "text";
+	}
+};
+const convertPreference = (preference, warnings) => {
+	const type = mapPreferenceType(preference.type, warnings);
+	const options = preference.type === "checkbox" ? [{
+		label: "Yes",
+		value: true
+	}, {
+		label: "No",
+		value: false
+	}] : preference.data?.map((item) => ({
+		label: item.title || item.label || String(item.value),
+		value: item.value
+	}));
+	return {
+		name: preference.name,
+		title: preference.title || preference.label || preference.name,
+		description: preference.description,
+		type,
+		required: Boolean(preference.required),
+		placeholder: preference.placeholder,
+		defaultValue: preference.defaultValue ?? preference.default,
+		...options?.length ? { options } : {}
+	};
+};
+const mergePreferences = (pluginPreferences, commandPreferences, warnings) => {
+	const preferenceNames = /* @__PURE__ */ new Set();
+	return [...pluginPreferences, ...commandPreferences].map((preference) => convertPreference(preference, warnings)).filter((preference) => {
+		if (preferenceNames.has(preference.name)) {
+			warnings.push({
+				type: "preference",
+				message: `Duplicate preference "${preference.name}" was skipped`
+			});
+			return false;
+		}
+		preferenceNames.add(preference.name);
+		return true;
+	});
+};
+//#endregion
+//#region src/index.ts
+/**
+* `development` 模式下 view 插件的 wujie 入口：指向 `@public-tauri/template` 的 Vite 默认端口下的 `raycast.html`，
+* 便于先 `pnpm --filter @public-tauri/template dev` 再转换插件即可调试 UI，无需模板 `build`/拷贝 `dist/view`。
+* `production` 模式使用 `./dist/view/raycast.html`。
+*/
+const RAYCAST_VIEW_TEMPLATE_DEV_ENTRY = "http://localhost:5173/raycast.html";
+const createPublicCommands = (commands, icon) => commands.map((command) => {
+	const raycastArguments = (command.arguments || []).map((arg) => ({
+		name: arg.name,
+		type: arg.type,
+		placeholder: arg.placeholder,
+		required: Boolean(arg.required),
+		data: arg.type === "dropdown" ? (arg.data || []).map((item) => ({
+			title: item.title || item.value,
+			value: item.value
+		})) : void 0
+	}));
+	return {
+		name: command.name,
+		title: command.title || command.name,
+		subtitle: command.subtitle || command.description,
+		description: command.description,
+		icon: normalizeRaycastIcon(command.icon) || icon,
+		mode: command.mode === "no-view" && raycastArguments.length === 0 ? "none" : "view",
+		raycastTargetMode: command.mode,
+		raycastArguments,
+		matches: [{
+			type: "text",
+			keywords: command.keywords?.length ? command.keywords : [command.title || command.name]
+		}]
+	};
+});
+const convertRaycastPlugin = async (rawOptions) => {
+	const options = resolveConvertOptions(rawOptions);
+	const warnings = [];
+	const sourcePackage = await readJson(path.join(options.inputDir, "package.json"));
+	const convertedPackageName = resolveConvertedPackageName(sourcePackage, options.inputDir);
+	const sourceCommands = sourcePackage.commands || [];
+	const { convertedCommands, skippedCommands } = await resolveSupportedCommands(options.inputDir, sourceCommands);
+	const noViewCommands = convertedCommands.filter((command) => command.mode === "no-view");
+	const viewCommands = convertedCommands.filter((command) => command.mode === "view");
+	const hasViewCommands = viewCommands.length > 0;
+	const viewHtmlUsesDevServer = hasViewCommands && options.mode === "development";
+	await fs.rm(options.outputDir, {
+		recursive: true,
+		force: true
+	});
+	await copyPluginSourceToOutput(options.inputDir, options.outputDir);
+	await fs.mkdir(options.buildDir, { recursive: true });
+	await fs.mkdir(options.distDir, { recursive: true });
+	const icon = normalizeRaycastIcon(sourcePackage.icon || convertedCommands[0]?.icon) || "extension";
+	const commandPreferences = convertedCommands.flatMap((command) => command.preferences || []);
+	const preferences = mergePreferences(sourcePackage.preferences || [], commandPreferences, warnings);
+	const publicCommands = createPublicCommands(convertedCommands, icon);
+	const publicPlugin = {
+		title: sourcePackage.title || sourcePackage.name || convertedPackageName,
+		subtitle: sourcePackage.description || sourcePackage.name || convertedPackageName,
+		description: sourcePackage.description,
+		icon,
+		...noViewCommands.length ? { main: "./dist/public-main.js" } : {},
+		server: "./dist/server.js",
+		...viewCommands.length ? { html: viewHtmlUsesDevServer ? RAYCAST_VIEW_TEMPLATE_DEV_ENTRY : "./dist/view/raycast.html" } : {},
+		...preferences.length ? { preferences } : {},
+		commands: publicCommands
+	};
+	await writeJson(path.join(options.outputDir, "package.json"), createConvertedPackage(sourcePackage, publicPlugin, {
+		convertedPackageName,
+		publicApiDependency: options.publicApiDependency,
+		warnings,
+		hasViewCommands
+	}));
+	if (noViewCommands.length) await fs.writeFile(path.join(options.buildDir, "public-main.ts"), generatePublicMain(), "utf8");
+	await fs.writeFile(path.join(options.buildDir, "server.ts"), generateServerModule({
+		noView: noViewCommands,
+		view: viewCommands
+	}, convertedPackageName, publicCommands, {
+		inputDir: options.inputDir,
+		outputDir: options.outputDir,
+		buildDir: options.buildDir
+	}), "utf8");
+	let raycastViewRepoRoot = null;
+	if (hasViewCommands) {
+		copyRaycastWorkerViewBundle(options.buildDir);
+		if (viewHtmlUsesDevServer) raycastViewRepoRoot = null;
+		else {
+			raycastViewRepoRoot = findPublicTauriRepoRoot$1(options.invocationDir) ?? findPublicTauriRepoRoot$1(process.cwd());
+			if (!raycastViewRepoRoot) throw new Error("Could not locate Public Tauri repo root (pnpm-workspace.yaml + packages/api). Run raycast-convert from the monorepo, set invocationDir, or copy packages/template dist into dist/view manually.");
+			ensureRaycastViewTemplateBuilt(raycastViewRepoRoot);
+			if (!options.build) copyRaycastViewTemplateAppDist(raycastViewRepoRoot, options.distDir);
+		}
+	}
+	await fs.writeFile(path.join(options.outputDir, "tsdown.config.ts"), generateTsdownConfig(options, { hasPublicMain: noViewCommands.length > 0 }), "utf8");
+	const report = {
+		source: options.inputDir,
+		output: options.outputDir,
+		sourcePackageName: typeof sourcePackage.name === "string" ? sourcePackage.name : void 0,
+		convertedPackageName,
+		convertedCommands: convertedCommands.map((command) => {
+			const outputEntry = path.join(options.outputDir, path.relative(path.resolve(options.inputDir), path.resolve(command.entry)));
+			const entry = path.relative(options.outputDir, outputEntry).split(path.sep).join("/") || ".";
+			return {
+				name: command.name,
+				entry
+			};
+		}),
+		skippedCommands,
+		warnings
+	};
+	await writeJson(path.join(options.outputDir, "raycast-conversion-report.json"), report);
+	if (options.build) {
+		installAndBuild(options);
+		if (hasViewCommands && raycastViewRepoRoot) copyRaycastViewTemplateAppDist(raycastViewRepoRoot, options.distDir);
+	}
+	return report;
+};
+//#endregion
+export { resolveRaycastSlug as a, resolveConvertedPackageName as i, convertRaycastPlugin as n, sanitizeSlug as o, RAYCAST_CONVERTED_SCOPE as r, RAYCAST_VIEW_TEMPLATE_DEV_ENTRY as t };