@openfairygui/functions 0.2.0-alpha.1 → 0.2.0-alpha.12

package/dist/web.js

@@ -0,0 +1,271 @@
+import { t as publish } from "./publish-Bl-GK9kt.js";
+import { ProjectType } from "@openfairygui/core";
+//#region src/adapters/web/publish.ts
+function getBrowserContext(canvas) {
+	const context = canvas.getContext("2d");
+	if (!context) throw new Error("publishBrowser: a 2D canvas context is unavailable.");
+	return context;
+}
+function createBrowserCanvas(width, height) {
+	if (typeof OffscreenCanvas !== "undefined") return new OffscreenCanvas(width, height);
+	if (typeof globalThis.document === "undefined") throw new Error("publishBrowser: OffscreenCanvas or a DOM canvas is required for atlas PNG generation.");
+	const canvas = globalThis.document.createElement("canvas");
+	canvas.width = width;
+	canvas.height = height;
+	return canvas;
+}
+function assertBrowserImageSupport() {
+	if (typeof createImageBitmap !== "function") throw new Error("publishBrowser: createImageBitmap is required for atlas PNG generation.");
+	if (typeof OffscreenCanvas === "undefined" && typeof globalThis.document === "undefined") throw new Error("publishBrowser: OffscreenCanvas or a DOM canvas is required for atlas PNG generation.");
+}
+function createRaster(width, height, background) {
+	const canvas = createBrowserCanvas(width, height);
+	const context = getBrowserContext(canvas);
+	context.clearRect(0, 0, width, height);
+	if (background && background.alpha > 0) {
+		context.fillStyle = `rgba(${background.r}, ${background.g}, ${background.b}, ${background.alpha})`;
+		context.fillRect(0, 0, width, height);
+	}
+	return {
+		canvas,
+		width,
+		height
+	};
+}
+function imageMimeType(path) {
+	if (/\.svg$/iu.test(path)) return "image/svg+xml";
+	if (/\.jpe?g$/iu.test(path)) return "image/jpeg";
+	if (/\.webp$/iu.test(path)) return "image/webp";
+	if (/\.gif$/iu.test(path)) return "image/gif";
+	return "image/png";
+}
+function imageMimeTypeFromBytes(bytes) {
+	if (bytes[0] === 255 && bytes[1] === 216) return "image/jpeg";
+	if (bytes[0] === 71 && bytes[1] === 73 && bytes[2] === 70) return "image/gif";
+	if (bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70) return "image/webp";
+	return "image/png";
+}
+async function canvasToPng(canvas) {
+	let blob;
+	if ("convertToBlob" in canvas && typeof canvas.convertToBlob === "function") blob = await canvas.convertToBlob({ type: "image/png" });
+	else blob = await new Promise((resolve, reject) => {
+		canvas.toBlob((value) => {
+			if (value) resolve(value);
+			else reject(/* @__PURE__ */ new Error("publishBrowser: canvas PNG encoding failed."));
+		}, "image/png");
+	});
+	return new Uint8Array(await blob.arrayBuffer());
+}
+async function decodeRaster(bytes, mimeType) {
+	if (typeof createImageBitmap !== "function") throw new Error("publishBrowser: createImageBitmap is required for atlas PNG generation.");
+	const copy = bytes.slice();
+	const bitmap = await createImageBitmap(new Blob([copy.buffer], { type: mimeType }));
+	try {
+		const raster = createRaster(bitmap.width, bitmap.height);
+		getBrowserContext(raster.canvas).drawImage(bitmap, 0, 0);
+		return raster;
+	} finally {
+		bitmap.close();
+	}
+}
+var BrowserImagePipeline = class {
+	rawOutput = false;
+	constructor(raster, decode, write) {
+		this.raster = raster;
+		this.decode = decode;
+		this.write = write;
+	}
+	ensureAlpha() {
+		return this;
+	}
+	resize(options) {
+		this.raster = this.raster.then((source) => {
+			const target = createRaster(options.width, options.height);
+			getBrowserContext(target.canvas).drawImage(source.canvas, 0, 0, options.width, options.height);
+			return target;
+		});
+		return this;
+	}
+	raw() {
+		this.rawOutput = true;
+		return this;
+	}
+	extract(options) {
+		this.raster = this.raster.then((source) => {
+			const target = createRaster(options.width, options.height);
+			getBrowserContext(target.canvas).drawImage(source.canvas, options.left, options.top, options.width, options.height, 0, 0, options.width, options.height);
+			return target;
+		});
+		return this;
+	}
+	png() {
+		this.rawOutput = false;
+		return this;
+	}
+	rotate(angle) {
+		this.raster = this.raster.then((source) => {
+			if (angle % 180 === 0) return source;
+			const target = createRaster(source.height, source.width);
+			const context = getBrowserContext(target.canvas);
+			context.save();
+			if (angle === 270 || angle === -90) {
+				context.translate(0, source.width);
+				context.rotate(-Math.PI / 2);
+			} else {
+				context.translate(source.height, 0);
+				context.rotate(Math.PI / 2);
+			}
+			context.drawImage(source.canvas, 0, 0);
+			context.restore();
+			return target;
+		});
+		return this;
+	}
+	composite(inputs) {
+		this.raster = this.raster.then(async (target) => {
+			const context = getBrowserContext(target.canvas);
+			for (const input of inputs) {
+				const source = await this.decode(input.input);
+				context.drawImage(source.canvas, input.left, input.top);
+			}
+			return target;
+		});
+		return this;
+	}
+	async metadata() {
+		const raster = await this.raster;
+		return {
+			width: raster.width,
+			height: raster.height,
+			channels: 4,
+			hasAlpha: true
+		};
+	}
+	async toBuffer(options) {
+		const raster = await this.raster;
+		if (options?.resolveWithObject) {
+			const data = getBrowserContext(raster.canvas).getImageData(0, 0, raster.width, raster.height).data;
+			return {
+				data: new Uint8Array(data),
+				info: {
+					width: raster.width,
+					height: raster.height,
+					channels: 4
+				}
+			};
+		}
+		if (this.rawOutput) return new Uint8Array(getBrowserContext(raster.canvas).getImageData(0, 0, raster.width, raster.height).data);
+		return canvasToPng(raster.canvas);
+	}
+	async toFile(path) {
+		const raster = await this.raster;
+		await this.write(path, await canvasToPng(raster.canvas));
+	}
+};
+function createBrowserImageEncoder(sourceFileSystem, outputFileSystem) {
+	const decode = (bytes) => decodeRaster(bytes, imageMimeTypeFromBytes(bytes));
+	return (input) => {
+		return new BrowserImagePipeline(typeof input === "string" ? sourceFileSystem.readFileRaw(input).then((bytes) => decodeRaster(bytes, imageMimeType(input))) : input instanceof Uint8Array ? decode(input) : Promise.resolve(createRaster(input.create.width, input.create.height, input.create.background)), decode, outputFileSystem.writeFileRaw);
+	};
+}
+function createTrackingFileSystem(fileSystem, files) {
+	return {
+		join: (...paths) => fileSystem.join(...paths),
+		mkdir: (path) => fileSystem.mkdir(path),
+		writeFileRaw: async (path, data) => {
+			await fileSystem.writeFileRaw(path, data);
+			files.set(path, data.byteLength);
+		}
+	};
+}
+function createDiagnosticLogger(logger, diagnostics) {
+	return {
+		debug(message) {
+			diagnostics.push({
+				level: "debug",
+				message
+			});
+			logger.debug(message);
+		},
+		info(message) {
+			diagnostics.push({
+				level: "info",
+				message
+			});
+			logger.info(message);
+		},
+		warn(message) {
+			diagnostics.push({
+				level: "warning",
+				message
+			});
+			logger.warn(message);
+		},
+		error(message) {
+			diagnostics.push({
+				level: "error",
+				message
+			});
+			logger.error(message);
+		}
+	};
+}
+function toResult(success, files, diagnostics) {
+	return {
+		success,
+		files: [...files].map(([path, size]) => ({
+			path,
+			size
+		})),
+		diagnostics
+	};
+}
+/**
+* Publish a loaded FairyGUI project to browser-provided storage.
+*
+* The adapter uses browser Canvas APIs for atlas composition, writes only through
+* the supplied output filesystem, and intentionally skips Node publish plugins.
+*/
+async function publishBrowser(options) {
+	const files = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	const root = options.document.getRoot();
+	const previousProjectType = root.getProjectType();
+	const previousLogger = options.document.getLogger();
+	options.document.setLogger(createDiagnosticLogger(previousLogger, diagnostics));
+	try {
+		if (options.projectType !== "layabox") throw new Error(`publishBrowser: unsupported project type "${String(options.projectType)}".`);
+		assertBrowserImageSupport();
+		root.setProjectType(ProjectType.LayaBox);
+		const outputFileSystem = createTrackingFileSystem(options.outputFileSystem, files);
+		const sourceAssetsPath = options.sourceFileSystem.join(options.document.getProjectDir(), "assets");
+		await options.document.transform(publish({
+			output: options.output,
+			compressed: options.compressed,
+			fileExtension: "fui",
+			packages: options.packages,
+			branch: options.branch,
+			basePath: sourceAssetsPath,
+			encoder: createBrowserImageEncoder(options.sourceFileSystem, outputFileSystem),
+			atlas: {
+				...options.atlas,
+				readFileRaw: (path) => options.sourceFileSystem.readFileRaw(path)
+			},
+			fs: outputFileSystem,
+			plugins: [],
+			codeGeneration: false
+		}));
+		return toResult(true, files, diagnostics);
+	} catch (error) {
+		diagnostics.push({
+			level: "error",
+			message: error instanceof Error ? error.message : String(error)
+		});
+		return toResult(false, files, diagnostics);
+	} finally {
+		root.setProjectType(previousProjectType);
+		options.document.setLogger(previousLogger);
+	}
+}
+//#endregion
+export { publishBrowser };

package/package.json

@@ -1,54 +1,87 @@
 {
-	"name": "@openfairygui/functions",
-	"version": "0.2.0-alpha.1",
-	"description": "FairyGUI Headless Authoring SDK — composable transform functions.",
-	"author": "OpenFairyGUI Contributors",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/OpenFairyGUI/OpenFairyGUI.git",
-		"directory": "packages/functions"
-	},
-	"homepage": "https://github.com/OpenFairyGUI/OpenFairyGUI#readme",
-	"bugs": {
-		"url": "https://github.com/OpenFairyGUI/OpenFairyGUI/issues"
-	},
-	"type": "module",
-	"sideEffects": false,
-	"main": "./dist/index.cjs",
-	"module": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"exports": {
-		"require": {
-			"types": "./dist/index.d.cts",
-			"default": "./dist/index.cjs"
-		},
-		"default": {
-			"types": "./dist/index.d.ts",
-			"default": "./dist/index.js"
-		}
-	},
-	"scripts": {
-		"build": "tsdown --format esm,cjs --platform neutral --env.PACKAGE_VERSION=$npm_package_version",
-		"build:watch": "tsdown --watch --format esm,cjs --platform neutral --env.PACKAGE_VERSION=$npm_package_version"
-	},
-	"files": [
-		"dist/",
-		"src/"
-	],
-	"keywords": [
-		"fairygui",
-		"ui",
-		"headless",
-		"authoring",
-		"transform",
-		"publish"
-	],
-	"dependencies": {
-		"@openfairygui/core": "workspace:*"
-	},
-	"devDependencies": {
-		"ava": "^7.0.0",
-		"tsx": "^4.0.0"
-	}
-}
+  "name": "@openfairygui/functions",
+  "version": "0.2.0-alpha.12",
+  "description": "FairyGUI Headless Authoring SDK — composable transform functions.",
+  "author": "OpenFairyGUI Contributors",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OpenFairyGUI/OpenFairyGUI.git",
+    "directory": "packages/functions"
+  },
+  "homepage": "https://github.com/OpenFairyGUI/OpenFairyGUI#readme",
+  "bugs": {
+    "url": "https://github.com/OpenFairyGUI/OpenFairyGUI/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./uam": {
+      "require": {
+        "types": "./dist/uam-transaction.d.cts",
+        "default": "./dist/uam-transaction.cjs"
+      },
+      "default": {
+        "types": "./dist/uam-transaction.d.ts",
+        "default": "./dist/uam-transaction.js"
+      }
+    },
+    "./node": {
+      "require": {
+        "types": "./dist/node.d.cts",
+        "default": "./dist/node.cjs"
+      },
+      "default": {
+        "types": "./dist/node.d.ts",
+        "default": "./dist/node.js"
+      }
+    },
+    "./web": {
+      "require": {
+        "types": "./dist/web.d.cts",
+        "default": "./dist/web.cjs"
+      },
+      "default": {
+        "types": "./dist/web.d.ts",
+        "default": "./dist/web.js"
+      }
+    }
+  },
+  "files": [
+    "dist/",
+    "src/"
+  ],
+  "keywords": [
+    "fairygui",
+    "ui",
+    "headless",
+    "authoring",
+    "transform",
+    "publish"
+  ],
+  "dependencies": {
+    "jiti": "^2.6.1",
+    "@openfairygui/core": "0.2.0-alpha.11"
+  },
+  "devDependencies": {
+    "ava": "^7.0.0",
+    "tsx": "^4.0.0"
+  },
+  "scripts": {
+    "build": "tsdown src/index.ts src/uam-transaction.ts src/node.ts src/web.ts --format esm,cjs --platform neutral --env.PACKAGE_VERSION=$npm_package_version",
+    "build:watch": "tsdown src/index.ts src/uam-transaction.ts src/node.ts src/web.ts --watch --format esm,cjs --platform neutral --env.PACKAGE_VERSION=$npm_package_version"
+  }
+}

package/src/adapters/node/plugins.ts

@@ -0,0 +1,82 @@
+import type { Document } from '@openfairygui/core';
+import {
+	formatPluginError,
+	type LoadedPlugin,
+	type Plugin,
+	type PluginManifest,
+	type PluginModule,
+} from '../../plugins/types.js';
+
+interface PluginPackageJson extends Partial<PluginManifest> {
+	name?: string;
+	main?: string;
+}
+
+// Keep Node builtins out of the neutral bundle resolver while still loading plugins in Node.
+const importNative = new Function('id', 'return import(id)') as <T>(id: string) => Promise<T>;
+
+export async function loadPlugins(doc: Document, pluginsDir: string): Promise<LoadedPlugin[]> {
+	if (!pluginsDir) return [];
+
+	const fs = await importNative<typeof import('node:fs/promises')>('node:fs/promises');
+	const path = await importNative<typeof import('node:path')>('node:path');
+	let entries: Array<{ name: string; isDirectory(): boolean }>;
+	try {
+		entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+	} catch {
+		return [];
+	}
+
+	const plugins: LoadedPlugin[] = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const pluginDir = path.join(pluginsDir, entry.name);
+		try {
+			const manifest = await readPluginManifest(fs, path, pluginDir);
+			if (!manifest) continue;
+
+			const mainPath = resolvePluginMain(path, pluginDir, manifest);
+			const plugin = await loadPlugin(mainPath);
+			plugins.push({ name: manifest.name, plugin });
+		} catch (error) {
+			doc.getLogger().warn(`publish: Plugin "${entry.name}" was skipped: ${formatPluginError(error)}`);
+		}
+	}
+
+	return plugins;
+}
+
+async function readPluginManifest(
+	fs: typeof import('node:fs/promises'),
+	path: typeof import('node:path'),
+	pluginDir: string,
+): Promise<PluginPackageJson | null> {
+	const manifestPath = path.join(pluginDir, 'package.json');
+	const content = await fs.readFile(manifestPath, 'utf-8');
+	const manifest = JSON.parse(content) as PluginPackageJson;
+	if (!manifest.name) throw new Error(`Codegen plugin at ${pluginDir} is missing package.json name.`);
+	if (!manifest.main) throw new Error(`Codegen plugin "${manifest.name}" is missing package.json main.`);
+	return manifest;
+}
+
+function resolvePluginMain(path: typeof import('node:path'), pluginDir: string, manifest: PluginPackageJson): string {
+	const mainPath = path.resolve(pluginDir, manifest.main!);
+	const relative = path.relative(pluginDir, mainPath);
+	if (relative.startsWith('..') || path.isAbsolute(relative)) {
+		throw new Error(`Codegen plugin "${manifest.name}" main must resolve inside its plugin directory.`);
+	}
+	return mainPath;
+}
+
+async function loadPlugin(mainPath: string): Promise<Plugin> {
+	const { createJiti } = await importNative<typeof import('jiti')>('jiti');
+	const jiti = createJiti(import.meta.url);
+	const mod = await jiti.import<PluginModule>(mainPath);
+	const defaultExport = mod.default;
+	const plugin = isObject(defaultExport) ? defaultExport : mod;
+	return plugin as Plugin;
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === 'object';
+}

package/src/adapters/node/publish.ts

@@ -0,0 +1,129 @@
+import type { Document } from '@openfairygui/core';
+import { resolveProjectBasePath } from '../../codegen.js';
+import { publish, type PublishOptions } from '../../publish.js';
+import type { AtlasRasterBackend, PublishFileSystem } from '../../publish/contracts.js';
+import type { LoadedPlugin } from '../../plugins/types.js';
+import { loadPlugins } from './plugins.js';
+
+const importNative = new Function('id', 'return import(id)') as <T>(id: string) => Promise<T>;
+
+interface NodePublishFileSystem extends PublishFileSystem {
+	readFileRaw(path: string): Promise<Uint8Array>;
+}
+
+export interface PublishNodeOptions extends Omit<PublishOptions, 'atlas' | 'basePath' | 'encoder' | 'fs' | 'plugins'> {
+	document: Document;
+	/**
+	 * Assets directory. Defaults to `<document project dir>/assets` when available.
+	 */
+	assetsPath?: string;
+	/**
+	 * Override the standard Sharp raster backend.
+	 */
+	encoder?: AtlasRasterBackend;
+	/**
+	 * Supply already-loaded hooks. Pass an empty array to skip project plugin discovery.
+	 */
+	plugins?: LoadedPlugin[];
+	atlas?: Omit<NonNullable<PublishOptions['atlas']>, 'readFileRaw'>;
+}
+
+async function createNodePublishFileSystem(): Promise<NodePublishFileSystem> {
+	const [fs, path] = await Promise.all([
+		importNative<typeof import('node:fs/promises')>('node:fs/promises'),
+		importNative<typeof import('node:path')>('node:path'),
+	]);
+
+	return {
+		async readFileRaw(filePath: string): Promise<Uint8Array> {
+			const data = await fs.readFile(filePath);
+			return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+		},
+		async writeFileRaw(filePath: string, data: Uint8Array): Promise<void> {
+			await fs.mkdir(path.dirname(filePath), { recursive: true });
+			await fs.writeFile(filePath, data);
+		},
+		async mkdir(dirPath: string): Promise<void> {
+			await fs.mkdir(dirPath, { recursive: true });
+		},
+		async readdir(dirPath: string): Promise<string[]> {
+			return fs.readdir(dirPath);
+		},
+		async deleteFile(filePath: string): Promise<void> {
+			await fs.rm(filePath, { force: true });
+		},
+		join(...paths: string[]): string {
+			return path.join(...paths);
+		},
+	};
+}
+
+async function resolveNodeAssetsPath(document: Document, assetsPath: string | undefined): Promise<string | undefined> {
+	if (assetsPath) return assetsPath;
+	const projectDir = document.getProjectDir?.() ?? '';
+	if (!projectDir) return undefined;
+	const path = await importNative<typeof import('node:path')>('node:path');
+	return path.join(projectDir, 'assets');
+}
+
+async function loadSharpBackend(): Promise<AtlasRasterBackend | undefined> {
+	try {
+		const sharp = await importNative<typeof import('sharp')>('sharp');
+		return (sharp.default ?? sharp) as unknown as AtlasRasterBackend;
+	} catch {
+		return undefined;
+	}
+}
+
+async function loadNodePublishPlugins(document: Document, assetsPath: string | undefined): Promise<LoadedPlugin[]> {
+	const projectDir = document.getProjectDir?.() || (assetsPath ? resolveProjectBasePath(assetsPath) : '');
+	if (!projectDir) return [];
+	const path = await importNative<typeof import('node:path')>('node:path');
+	return loadPlugins(document, path.join(projectDir, 'plugins'));
+}
+
+/**
+ * Publish a FairyGUI project through the standard Node host adapter.
+ *
+ * The adapter owns Node filesystem, Sharp, and project plugin discovery.
+ * For custom environments, use the lower-level `publish()` core with explicit
+ * capabilities instead.
+ */
+export async function publishNode(options: PublishNodeOptions): Promise<void> {
+	const {
+		document,
+		assetsPath: configuredAssetsPath,
+		atlas,
+		encoder: configuredEncoder,
+		plugins: configuredPlugins,
+		...publishOptions
+	} = options;
+	const [fileSystem, assetsPath] = await Promise.all([
+		createNodePublishFileSystem(),
+		resolveNodeAssetsPath(document, configuredAssetsPath),
+	]);
+	const [encoder, plugins] = await Promise.all([
+		configuredEncoder === undefined ? loadSharpBackend() : Promise.resolve(configuredEncoder),
+		configuredPlugins === undefined
+			? loadNodePublishPlugins(document, assetsPath)
+			: Promise.resolve(configuredPlugins),
+	]);
+
+	if (!encoder) {
+		document.getLogger().warn('publish: Sharp is unavailable; atlas layout will be generated without PNG output.');
+	}
+
+	await document.transform(
+		publish({
+			...publishOptions,
+			basePath: assetsPath,
+			encoder,
+			atlas: {
+				...atlas,
+				readFileRaw: fileSystem.readFileRaw,
+			},
+			fs: fileSystem,
+			plugins,
+		}),
+	);
+}