@public-tauri/raycast-convert 1.0.1 → 1.1.0

package/dist/src-DPoXoCnp.mjs

@@ -1,414 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-//#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;
-	}
-};
-const copyAssetsDir = async (inputDir, assetsDir) => {
-	const source = path.join(inputDir, "assets");
-	if (!await exists(source)) return;
-	await fs.cp(source, assetsDir, { 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 resolveNoViewCommands = async (inputDir, sourceCommands) => {
-	const convertedCommands = [];
-	const skippedCommands = [];
-	for (const command of sourceCommands) {
-		if (command.mode !== "no-view") {
-			skippedCommands.push({
-				name: command.name,
-				reason: `Unsupported mode: ${command.mode || "<empty>"}`
-			});
-			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,
-			entry
-		});
-	}
-	if (!convertedCommands.length) throw new Error("No Raycast no-view commands were converted");
-	return {
-		convertedCommands,
-		skippedCommands
-	};
-};
-//#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 toImportName = (index) => `command${index}`;
-const generateServerModule = (commands, packageName, publicCommands) => {
-	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';
-
-${commands.map((command, index) => `import * as ${toImportName(index)} from ${JSON.stringify(command.entry)};`).join("\n")}
-
-const commandModules: Record<string, any> = {
-${commands.map((command, index) => `  ${JSON.stringify(command.name)}: ${toImportName(index)},`).join("\n")}
-};
-
-const distDir = path.dirname(fileURLToPath(import.meta.url));
-const pluginRoot = path.dirname(distDir);
-const commandManifests = ${JSON.stringify(publicCommands, null, 2)};
-
-channel.handle('raycast:run', async (payload = {}) => {
-  const commandName = String(payload.commandName || '');
-  const commandModule = commandModules[commandName];
-  if (!commandModule) {
-    throw new Error(\`Unknown Raycast command: \${commandName}\`);
-  }
-  const run = commandModule.default;
-  if (typeof run !== 'function') {
-    throw new Error(\`Raycast command \${commandName} has no default function export\`);
-  }
-  const launchPayload = payload.options?.payload || {};
-  __setRaycastContext({
-    pluginName: ${JSON.stringify(packageName)},
-    commandName,
-    commands: commandManifests,
-    launchType: launchPayload.launchType,
-    preferences: payload.preferences || {},
-    supportPath: path.join(pluginRoot, '.raycast-compat'),
-    assetsPath: path.join(pluginRoot, 'assets'),
-  });
-  return await run({
-    arguments: launchPayload.arguments || {},
-    fallbackText: launchPayload.fallbackText ?? payload.query ?? '',
-    launchContext: launchPayload.context ?? payload,
-    launchType: launchPayload.launchType || 'userInitiated',
-  });
-});
-`;
-};
-//#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: {},";
-};
-const getServerAliases = () => ({
-	"@raycast/api": "@public-tauri/api/raycast",
-	"@raycast/utils": "@public-tauri/api/raycast/utils"
-});
-const generateTsdownConfig = (options) => `export default [
-  {
-    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({})}
-  },
-  {
-    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())}
-  },
-];
-`;
-//#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";
-const resolveConvertOptions = (options) => {
-	const inputDir = path.resolve(options.inputDir);
-	const outputDir = path.resolve(options.outputDir || `${inputDir}-public`);
-	const invocationDir = path.resolve(options.invocationDir || process.cwd());
-	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"),
-		assetsDir: path.join(outputDir, "assets")
-	};
-};
-//#endregion
-//#region src/package-json.ts
-const raycastApiPackages = new Set(["@raycast/api", "@raycast/utils"]);
-const rewriteDependencyMap = (dependencies) => {
-	const rewritten = { ...dependencies || {} };
-	let replacedRaycastApi = false;
-	for (const packageName of raycastApiPackages) if (packageName in rewritten) {
-		delete rewritten[packageName];
-		replacedRaycastApi = true;
-	}
-	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 and/or @raycast/utils with @public-tauri/api"
-	});
-	return {
-		...sourcePackage,
-		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
-		},
-		devDependencies: {
-			...devDependenciesResult.dependencies,
-			tsdown: devDependenciesResult.dependencies.tsdown || "^0.21.7"
-		}
-	};
-};
-//#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
-const createPublicCommands = (commands, icon) => commands.map((command) => ({
-	name: command.name,
-	title: command.title || command.name,
-	subtitle: command.subtitle || command.description,
-	description: command.description,
-	icon: normalizeRaycastIcon(command.icon) || icon,
-	mode: "none",
-	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 sourceCommands = sourcePackage.commands || [];
-	const { convertedCommands, skippedCommands } = await resolveNoViewCommands(options.inputDir, sourceCommands);
-	await fs.rm(options.outputDir, {
-		recursive: true,
-		force: true
-	});
-	await fs.mkdir(options.buildDir, { recursive: true });
-	await fs.mkdir(options.distDir, { recursive: true });
-	await copyAssetsDir(options.inputDir, options.assetsDir);
-	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,
-		subtitle: sourcePackage.description || sourcePackage.name,
-		description: sourcePackage.description,
-		icon,
-		main: "./dist/public-main.js",
-		server: "./dist/server.js",
-		...preferences.length ? { preferences } : {},
-		commands: publicCommands
-	};
-	await writeJson(path.join(options.outputDir, "package.json"), createConvertedPackage(sourcePackage, publicPlugin, {
-		publicApiDependency: options.publicApiDependency,
-		warnings
-	}));
-	await fs.writeFile(path.join(options.buildDir, "public-main.ts"), generatePublicMain(), "utf8");
-	await fs.writeFile(path.join(options.buildDir, "server.ts"), generateServerModule(convertedCommands, sourcePackage.name, publicCommands), "utf8");
-	await fs.writeFile(path.join(options.outputDir, "tsdown.config.ts"), generateTsdownConfig(options), "utf8");
-	const report = {
-		source: options.inputDir,
-		output: options.outputDir,
-		convertedCommands: convertedCommands.map((command) => ({
-			name: command.name,
-			entry: command.entry
-		})),
-		skippedCommands,
-		warnings
-	};
-	await writeJson(path.join(options.outputDir, "raycast-conversion-report.json"), report);
-	if (options.build) installAndBuild(options);
-	return report;
-};
-//#endregion
-export { convertRaycastPlugin as t };