@openfairygui/cli 0.2.0-alpha.8 → 0.2.0

package/src/commands/publish.ts

@@ -0,0 +1,67 @@
+import type { Command } from 'commander';
+import { NodeIO } from '@openfairygui/core/node';
+import { resolvePublishOptions } from '@openfairygui/functions';
+import { publishNode } from '@openfairygui/functions/node';
+import path from 'node:path';
+import { resolveFairyPath } from '../utils/project-input.js';
+import { parseProjectType } from '../utils/project-type.js';
+
+type PublishCommandOptions = {
+	output?: string;
+	compressed?: boolean;
+	packages?: string;
+	branch?: string;
+	projectType?: string;
+};
+
+export function registerPublishCommand(program: Command): void {
+	program
+		.command('publish')
+		.description('Publish project to binary outputs and configured generated code')
+		.argument('<project-dir>', 'Project root directory or .fairy file')
+		.option('-o, --output <dir>', 'Override project or package publish output directory')
+		.option('-c, --compressed', 'Compress binary data (overrides project setting)')
+		.option('-p, --packages <a,b,c>', 'Only publish specific packages (comma-separated)')
+		.option('-b, --branch <name>', 'Active branch used by "主干合并活跃分支"; omit for main branch')
+		.option(
+			'-t, --project-type <name|id>',
+			'Override project type (for example: unity, layabox, cocoscreator, 0, 4, 3)',
+		)
+		.action(async (projectDir: string, options: PublishCommandOptions) => {
+			const fairyPath = await resolveFairyPath(projectDir);
+			const projectRootDir = path.dirname(fairyPath);
+			const outputDir = options.output ? path.resolve(options.output) : undefined;
+
+			console.log(`Reading project: ${fairyPath}`);
+			const io = new NodeIO();
+			const doc = await io.readProject(fairyPath);
+			const projectType = parseProjectType(options.projectType);
+			if (projectType !== undefined) {
+				doc.getRoot().setProjectType(projectType);
+			}
+
+			const pkgFilter = options.packages?.split(',').map((value) => value.trim());
+			const resolved = resolvePublishOptions(doc, {
+				compressed: options.compressed,
+				packages: pkgFilter,
+			});
+
+			console.log(`Settings: ext=${resolved.fileExtension}, compressed=${resolved.compressed}`);
+			if (options.branch) {
+				console.log(`Active branch: ${options.branch}`);
+			}
+
+			await publishNode({
+				document: doc,
+				output: outputDir,
+				compressed: resolved.compressed,
+				fileExtension: resolved.fileExtension,
+				packages: resolved.packages,
+				assetsPath: path.join(projectRootDir, 'assets'),
+				atlas: resolved.atlas,
+				branch: options.branch,
+			});
+
+			console.log(`\nDone!${outputDir ? ` Output override: ${outputDir}` : ''}`);
+		});
+}

package/src/commands/restore.ts

@@ -0,0 +1,49 @@
+import path from 'node:path';
+import { restoreNode } from '@openfairygui/functions/node';
+import type { Command } from 'commander';
+import { parseProjectType } from '../utils/project-type.js';
+
+type RestoreCommandOptions = {
+	output: string;
+	packages?: string;
+	force?: boolean;
+	projectType?: string;
+};
+
+export function registerRestoreCommand(program: Command): void {
+	program
+		.command('restore')
+		.description('Recover a project directory from trusted local published artifacts')
+		.argument('<release-dir>', 'Published release directory')
+		.requiredOption('-o, --output <dir>', 'Output project directory')
+		.option('-p, --packages <a,b,c>', 'Only restore specific packages (comma-separated)')
+		.option('-f, --force', 'Replace a non-empty output directory only after a complete staged restore')
+		.option('-t, --project-type <name|id>', 'Override restored project type; default is unity')
+		.action(async (releaseDir: string, options: RestoreCommandOptions) => {
+			const inputDir = path.resolve(releaseDir);
+			const outputDir = path.resolve(options.output);
+			const pkgFilter = options.packages
+				? options.packages
+						.split(',')
+						.map((value) => value.trim())
+						.filter(Boolean)
+				: undefined;
+			const projectType = parseProjectType(options.projectType);
+
+			console.log(`Restoring published FairyGUI project: ${inputDir}`);
+			const result = await restoreNode({
+				inputDir,
+				output: outputDir,
+				packages: pkgFilter,
+				force: options.force,
+				projectType,
+			});
+
+			const packages = result.document.getRoot().listPackages();
+			console.log(`\nDone! Output: ${result.projectPath}`);
+			console.log(`Packages: ${packages.map((pkg) => pkg.getName()).join(', ')}`);
+			for (const warning of result.warnings) {
+				console.warn(`Warning: ${warning}`);
+			}
+		});
+}

package/src/utils/package-version.ts

@@ -0,0 +1,23 @@
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+declare const __OPENFAIRYGUI_PACKAGE_VERSION__: string | undefined;
+
+function getInjectedPackageVersion(): string | null {
+	const version = typeof __OPENFAIRYGUI_PACKAGE_VERSION__ === 'string' ? __OPENFAIRYGUI_PACKAGE_VERSION__ : null;
+	return typeof version === 'string' && version.length > 0 ? version : null;
+}
+
+export function readPackageVersion(): string {
+	const injectedVersion = getInjectedPackageVersion();
+	if (injectedVersion) return injectedVersion;
+	try {
+		const pkg = require('../../package.json') as { version?: unknown };
+		if (typeof pkg.version === 'string' && pkg.version.length > 0) {
+			return pkg.version;
+		}
+	} catch {
+		// Keep the CLI usable when executed from a bundled artifact missing package.json.
+	}
+	return '0.0.0-dev';
+}

package/src/utils/project-input.ts

@@ -0,0 +1,26 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+/** Resolve input to a .fairy file path. Accepts a directory or a .fairy file. */
+export async function resolveFairyPath(input: string): Promise<string> {
+	const resolved = path.resolve(input);
+	const stat = await fs.stat(resolved);
+
+	if (stat.isFile() && resolved.endsWith('.fairy')) {
+		return resolved;
+	}
+
+	if (stat.isDirectory()) {
+		const entries = await fs.readdir(resolved);
+		const fairyFiles = entries.filter((entry) => entry.endsWith('.fairy'));
+		if (fairyFiles.length === 1) {
+			return path.join(resolved, fairyFiles[0]);
+		}
+		if (fairyFiles.length > 1) {
+			throw new Error(`Multiple .fairy files found in ${resolved}: ${fairyFiles.join(', ')}. Please specify one.`);
+		}
+		throw new Error(`No .fairy file found in ${resolved}`);
+	}
+
+	throw new Error(`Input is not a .fairy file or directory: ${resolved}`);
+}

package/src/utils/project-type.ts

@@ -0,0 +1,31 @@
+import { ProjectType } from '@openfairygui/core';
+
+export function parseProjectType(value: string | undefined): number | undefined {
+	if (!value) return undefined;
+	const trimmed = value.trim();
+	if (trimmed === '') return undefined;
+	if (/^\d+$/u.test(trimmed)) return Number(trimmed);
+	const normalized = trimmed.toLowerCase();
+	const map: Record<string, number> = {
+		unity: ProjectType.Unity,
+		flash: ProjectType.Flash,
+		starling: ProjectType.Starling,
+		cocoscreator: ProjectType.CocosCreator,
+		cocos: ProjectType.CocosCreator,
+		layabox: ProjectType.LayaBox,
+		laya: ProjectType.LayaBox,
+		egret: ProjectType.Egret,
+		haxe: ProjectType.Haxe,
+		pixi: ProjectType.Pixi,
+		libgdx: ProjectType.LibGDX,
+		unreal: ProjectType.Unreal,
+		cryengine: ProjectType.CryEngine,
+		monogame: ProjectType.MonoGame,
+		vision: ProjectType.Vision,
+	};
+	const resolved = map[normalized];
+	if (resolved === undefined) {
+		throw new Error(`Unknown project type: ${value}. Use a numeric id or one of: ${Object.keys(map).join(', ')}`);
+	}
+	return resolved;
+}