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

package/dist/uam-transaction.cjs

@@ -0,0 +1,79 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _openfairygui_core_uam = require("@openfairygui/core/uam");
+//#region src/uam-transaction.ts
+function mapTransactionErrorStage(error) {
+	switch (error.code) {
+		case "transaction_unsupported": return "preflight";
+		case "invalid_uam": return "preflight";
+		case "execution_failure": return error.opIndex === void 0 && error.issues !== void 0 ? "postflight" : "execution";
+		case "selector_ambiguity": return error.opIndex === void 0 ? "preflight" : "execution";
+	}
+}
+function compactDiagnostic(diagnostic) {
+	return Object.fromEntries(Object.entries(diagnostic).filter(([, value]) => value !== void 0));
+}
+function isTransactionSupportIssue(issue) {
+	return "code" in issue;
+}
+function mapTransactionDiagnostics(error) {
+	if (error.issues?.length) return error.issues.map((issue) => {
+		if (isTransactionSupportIssue(issue)) return compactDiagnostic({
+			code: issue.code,
+			message: issue.message,
+			severity: "error",
+			path: issue.path,
+			nodeKind: issue.nodeKind,
+			resourceKind: issue.resourceKind,
+			gearKind: issue.gearKind,
+			field: issue.field,
+			operationKind: issue.operationKind ?? error.opKind,
+			opIndex: error.opIndex,
+			opId: error.opId
+		});
+		return compactDiagnostic({
+			code: error.code,
+			message: issue.message,
+			severity: "error",
+			path: issue.path,
+			operationKind: error.opKind,
+			opIndex: error.opIndex,
+			opId: error.opId
+		});
+	});
+	return [compactDiagnostic({
+		code: error.code,
+		message: error.message,
+		severity: "error",
+		path: error.opIndex === void 0 ? void 0 : `operations[${error.opIndex}]`,
+		operationKind: error.opKind,
+		opIndex: error.opIndex,
+		opId: error.opId
+	})];
+}
+function applyUamTransactionApp(input) {
+	try {
+		return {
+			ok: true,
+			project: (0, _openfairygui_core_uam.applyUamTransaction)(input.project, input.operations)
+		};
+	} catch (error) {
+		if (error instanceof _openfairygui_core_uam.UamTransactionError) return {
+			ok: false,
+			error: {
+				code: error.code,
+				stage: mapTransactionErrorStage(error),
+				message: error.message,
+				opIndex: error.opIndex,
+				opId: error.opId,
+				opKind: error.opKind,
+				operationKind: error.opKind,
+				selector: error.selector,
+				issues: error.issues,
+				diagnostics: mapTransactionDiagnostics(error)
+			}
+		};
+		throw error;
+	}
+}
+//#endregion
+exports.applyUamTransactionApp = applyUamTransactionApp;

package/dist/uam-transaction.d.cts

@@ -0,0 +1,42 @@
+import { UamProject, UamTransactionErrorCode, UamTransactionOperation, UamTransactionSupportIssue, UamValidationIssue } from "@openfairygui/core/uam";
+
+//#region src/uam-transaction.d.ts
+interface ApplyUamTransactionAppInput {
+  project: UamProject;
+  operations: UamTransactionOperation[];
+}
+interface ApplyUamTransactionAppError {
+  code: UamTransactionErrorCode;
+  stage: 'preflight' | 'execution' | 'postflight';
+  message: string;
+  opIndex?: number;
+  opId?: string;
+  opKind?: UamTransactionOperation['kind'];
+  operationKind?: UamTransactionOperation['kind'];
+  selector?: Record<string, unknown>;
+  issues?: UamValidationIssue[] | UamTransactionSupportIssue[];
+  diagnostics: ApplyUamTransactionAppDiagnostic[];
+}
+type ApplyUamTransactionAppResult = {
+  ok: true;
+  project: UamProject;
+} | {
+  ok: false;
+  error: ApplyUamTransactionAppError;
+};
+interface ApplyUamTransactionAppDiagnostic {
+  code: string;
+  message: string;
+  severity: 'error';
+  path?: string;
+  nodeKind?: string;
+  resourceKind?: string;
+  gearKind?: string;
+  field?: string;
+  operationKind?: UamTransactionOperation['kind'];
+  opIndex?: number;
+  opId?: string;
+}
+declare function applyUamTransactionApp(input: ApplyUamTransactionAppInput): ApplyUamTransactionAppResult;
+//#endregion
+export { ApplyUamTransactionAppDiagnostic, ApplyUamTransactionAppError, ApplyUamTransactionAppInput, ApplyUamTransactionAppResult, applyUamTransactionApp };

package/dist/uam-transaction.d.ts

@@ -0,0 +1,42 @@
+import { UamProject, UamTransactionErrorCode, UamTransactionOperation, UamTransactionSupportIssue, UamValidationIssue } from "@openfairygui/core/uam";
+
+//#region src/uam-transaction.d.ts
+interface ApplyUamTransactionAppInput {
+  project: UamProject;
+  operations: UamTransactionOperation[];
+}
+interface ApplyUamTransactionAppError {
+  code: UamTransactionErrorCode;
+  stage: 'preflight' | 'execution' | 'postflight';
+  message: string;
+  opIndex?: number;
+  opId?: string;
+  opKind?: UamTransactionOperation['kind'];
+  operationKind?: UamTransactionOperation['kind'];
+  selector?: Record<string, unknown>;
+  issues?: UamValidationIssue[] | UamTransactionSupportIssue[];
+  diagnostics: ApplyUamTransactionAppDiagnostic[];
+}
+type ApplyUamTransactionAppResult = {
+  ok: true;
+  project: UamProject;
+} | {
+  ok: false;
+  error: ApplyUamTransactionAppError;
+};
+interface ApplyUamTransactionAppDiagnostic {
+  code: string;
+  message: string;
+  severity: 'error';
+  path?: string;
+  nodeKind?: string;
+  resourceKind?: string;
+  gearKind?: string;
+  field?: string;
+  operationKind?: UamTransactionOperation['kind'];
+  opIndex?: number;
+  opId?: string;
+}
+declare function applyUamTransactionApp(input: ApplyUamTransactionAppInput): ApplyUamTransactionAppResult;
+//#endregion
+export { ApplyUamTransactionAppDiagnostic, ApplyUamTransactionAppError, ApplyUamTransactionAppInput, ApplyUamTransactionAppResult, applyUamTransactionApp };

package/dist/uam-transaction.js

@@ -0,0 +1,78 @@
+import { UamTransactionError, applyUamTransaction } from "@openfairygui/core/uam";
+//#region src/uam-transaction.ts
+function mapTransactionErrorStage(error) {
+	switch (error.code) {
+		case "transaction_unsupported": return "preflight";
+		case "invalid_uam": return "preflight";
+		case "execution_failure": return error.opIndex === void 0 && error.issues !== void 0 ? "postflight" : "execution";
+		case "selector_ambiguity": return error.opIndex === void 0 ? "preflight" : "execution";
+	}
+}
+function compactDiagnostic(diagnostic) {
+	return Object.fromEntries(Object.entries(diagnostic).filter(([, value]) => value !== void 0));
+}
+function isTransactionSupportIssue(issue) {
+	return "code" in issue;
+}
+function mapTransactionDiagnostics(error) {
+	if (error.issues?.length) return error.issues.map((issue) => {
+		if (isTransactionSupportIssue(issue)) return compactDiagnostic({
+			code: issue.code,
+			message: issue.message,
+			severity: "error",
+			path: issue.path,
+			nodeKind: issue.nodeKind,
+			resourceKind: issue.resourceKind,
+			gearKind: issue.gearKind,
+			field: issue.field,
+			operationKind: issue.operationKind ?? error.opKind,
+			opIndex: error.opIndex,
+			opId: error.opId
+		});
+		return compactDiagnostic({
+			code: error.code,
+			message: issue.message,
+			severity: "error",
+			path: issue.path,
+			operationKind: error.opKind,
+			opIndex: error.opIndex,
+			opId: error.opId
+		});
+	});
+	return [compactDiagnostic({
+		code: error.code,
+		message: error.message,
+		severity: "error",
+		path: error.opIndex === void 0 ? void 0 : `operations[${error.opIndex}]`,
+		operationKind: error.opKind,
+		opIndex: error.opIndex,
+		opId: error.opId
+	})];
+}
+function applyUamTransactionApp(input) {
+	try {
+		return {
+			ok: true,
+			project: applyUamTransaction(input.project, input.operations)
+		};
+	} catch (error) {
+		if (error instanceof UamTransactionError) return {
+			ok: false,
+			error: {
+				code: error.code,
+				stage: mapTransactionErrorStage(error),
+				message: error.message,
+				opIndex: error.opIndex,
+				opId: error.opId,
+				opKind: error.opKind,
+				operationKind: error.opKind,
+				selector: error.selector,
+				issues: error.issues,
+				diagnostics: mapTransactionDiagnostics(error)
+			}
+		};
+		throw error;
+	}
+}
+//#endregion
+export { applyUamTransactionApp };

package/dist/web.cjs

@@ -0,0 +1,272 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_publish = require("./publish-CtCXsMdj.cjs");
+let _openfairygui_core = require("@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(_openfairygui_core.ProjectType.LayaBox);
+		const outputFileSystem = createTrackingFileSystem(options.outputFileSystem, files);
+		const sourceAssetsPath = options.sourceFileSystem.join(options.document.getProjectDir(), "assets");
+		await options.document.transform(require_publish.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
+exports.publishBrowser = publishBrowser;

package/dist/web.d.cts

@@ -0,0 +1,41 @@
+import { d as PublishSourceFileSystem, t as AtlasOptions, u as PublishOutputFileSystem } from "./atlas-CHsu2Y8i.cjs";
+import { Document } from "@openfairygui/core";
+
+//#region src/adapters/web/publish.d.ts
+type BrowserPublishProjectType = 'layabox';
+type BrowserPublishAtlasOptions = Pick<AtlasOptions, 'maxSize' | 'fast' | 'allowRotation' | 'padding' | 'powerOfTwo' | 'square' | 'multiPage' | 'trimImage' | 'extractAlpha'>;
+type BrowserPublishSourceFileSystem = PublishSourceFileSystem;
+type BrowserPublishOutputFileSystem = PublishOutputFileSystem;
+interface BrowserPublishOptions {
+  document: Document;
+  sourceFileSystem: BrowserPublishSourceFileSystem;
+  outputFileSystem: BrowserPublishOutputFileSystem;
+  projectType: BrowserPublishProjectType;
+  output: string;
+  compressed?: boolean;
+  packages?: string[];
+  branch?: string;
+  atlas?: BrowserPublishAtlasOptions;
+}
+interface BrowserPublishDiagnostic {
+  level: 'debug' | 'info' | 'warning' | 'error';
+  message: string;
+}
+interface BrowserPublishedFile {
+  path: string;
+  size: number;
+}
+interface BrowserPublishResult {
+  success: boolean;
+  files: BrowserPublishedFile[];
+  diagnostics: BrowserPublishDiagnostic[];
+}
+/**
+ * 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.
+ */
+declare function publishBrowser(options: BrowserPublishOptions): Promise<BrowserPublishResult>;
+//#endregion
+export { type BrowserPublishAtlasOptions, type BrowserPublishDiagnostic, type BrowserPublishOptions, type BrowserPublishOutputFileSystem, type BrowserPublishProjectType, type BrowserPublishResult, type BrowserPublishSourceFileSystem, type BrowserPublishedFile, publishBrowser };

package/dist/web.d.ts

@@ -0,0 +1,41 @@
+import { d as PublishSourceFileSystem, t as AtlasOptions, u as PublishOutputFileSystem } from "./atlas-CDn6TirX.js";
+import { Document } from "@openfairygui/core";
+
+//#region src/adapters/web/publish.d.ts
+type BrowserPublishProjectType = 'layabox';
+type BrowserPublishAtlasOptions = Pick<AtlasOptions, 'maxSize' | 'fast' | 'allowRotation' | 'padding' | 'powerOfTwo' | 'square' | 'multiPage' | 'trimImage' | 'extractAlpha'>;
+type BrowserPublishSourceFileSystem = PublishSourceFileSystem;
+type BrowserPublishOutputFileSystem = PublishOutputFileSystem;
+interface BrowserPublishOptions {
+  document: Document;
+  sourceFileSystem: BrowserPublishSourceFileSystem;
+  outputFileSystem: BrowserPublishOutputFileSystem;
+  projectType: BrowserPublishProjectType;
+  output: string;
+  compressed?: boolean;
+  packages?: string[];
+  branch?: string;
+  atlas?: BrowserPublishAtlasOptions;
+}
+interface BrowserPublishDiagnostic {
+  level: 'debug' | 'info' | 'warning' | 'error';
+  message: string;
+}
+interface BrowserPublishedFile {
+  path: string;
+  size: number;
+}
+interface BrowserPublishResult {
+  success: boolean;
+  files: BrowserPublishedFile[];
+  diagnostics: BrowserPublishDiagnostic[];
+}
+/**
+ * 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.
+ */
+declare function publishBrowser(options: BrowserPublishOptions): Promise<BrowserPublishResult>;
+//#endregion
+export { type BrowserPublishAtlasOptions, type BrowserPublishDiagnostic, type BrowserPublishOptions, type BrowserPublishOutputFileSystem, type BrowserPublishProjectType, type BrowserPublishResult, type BrowserPublishSourceFileSystem, type BrowserPublishedFile, publishBrowser };