fabricjs-document-engine 1.0.2 → 1.2.0

package/dist/engine/create-document-engine.js

@@ -1,6 +1,7 @@
 import { buildAssetManifest } from "../assets/asset-manifest.js";
+import { documentObjects, pickPageFields } from "../fabric/page-state.js";
 import { DocumentEngineError, isDocumentEngineError } from "./errors.js";
-import { secureDocument } from "../security/content-limits.js";
+import { canvasSizeProblem, isSafeImageUrl, secureDocument } from "../security/content-limits.js";
 import { isSameUrl } from "../assets/image-check.js";
 import { inspectAssets, prepareAssetsForLoad, prepareAssetsForSave } from "../assets/asset-pipeline.js";
 import { resolveExportArea } from "../export/export-area.js";
@@ -9,6 +10,8 @@ import { readObjectId, writeObjectId } from "../fabric/object-ids.js";
 import { collectSerializedTypes, walkObjects } from "../fabric/walk-objects.js";
 import { preflightExport } from "../export/preflight-export.js";
 import { mimeTypes, renderRaster, renderSvg, withExportView } from "../export/render-export.js";
+import { embedSvgAssets } from "../export/svg/embed-assets.js";
+import { readSvg } from "../import/svg-import.js";
 import "../document/document-format.js";
 import { createId } from "../document/ids.js";
 import { createDocumentInfo } from "../document/create-document.js";
@@ -36,11 +39,21 @@ function createDocumentEngine(options) {
 	const registry = createObjectRegistry(options.customObjects);
 	const events = createEventEmitter();
 	const objectsById = /* @__PURE__ */ new Map();
-	const assetOptions = options.assets ?? {};
+	const assetOptions = {
+		...options.assets,
+		maxImagePixels: options.limits?.maxImagePixels ?? 67108864
+	};
 	const uploadedUrls = /* @__PURE__ */ new Map();
 	let documentInfo = createDocumentInfo(options.document);
 	let activeLoad = null;
 	let destroyed = false;
+	let mutations = 0;
+	let session = 0;
+	/** Throws when async work started under `startedIn` would now change another document. */
+	function ensureSameSession(startedIn, what) {
+		ensureUsable();
+		if (session !== startedIn) throw new DocumentEngineError("DOCUMENT_CHANGED", `${what} was dropped because another document was opened while it ran`);
+	}
 	function ensureUsable() {
 		if (destroyed) throw new DocumentEngineError("ENGINE_DESTROYED", "This document engine was destroyed");
 	}
@@ -65,21 +78,41 @@ function createDocumentEngine(options) {
 		objectsById.clear();
 		canvas.getObjects().forEach(indexObjectTree);
 	}
-	const handleObjectAdded = ({ target }) => indexObjectTree(target);
-	const handleObjectRemoved = ({ target }) => removeObjectTreeFromIndex(target);
+	const handleObjectAdded = ({ target }) => {
+		mutations += 1;
+		indexObjectTree(target);
+	};
+	const handleObjectRemoved = ({ target }) => {
+		mutations += 1;
+		removeObjectTreeFromIndex(target);
+	};
+	const countMutation = () => {
+		mutations += 1;
+	};
 	canvas.on("object:added", handleObjectAdded);
 	canvas.on("object:removed", handleObjectRemoved);
+	canvas.on("object:modified", countMutation);
+	canvas.on("text:changed", countMutation);
 	rebuildIndex();
 	const history = createHistory({
 		canvas,
 		limit: options.history?.limit,
 		maxBytes: options.history?.maxBytes,
-		serializeObjects: () => {
+		serializeState: () => {
 			rebuildIndex();
-			return serializeCanvas(canvas, registry.propertiesToInclude()).objects;
+			const serialized = serializeCanvas(canvas, registry.propertiesToInclude());
+			return {
+				objects: serialized.objects,
+				page: {
+					width: canvas.getWidth(),
+					height: canvas.getHeight(),
+					...pickPageFields(serialized)
+				}
+			};
 		},
 		onChange: (state) => events.emit("history:change", state),
-		onContentChange: () => noteContentChange()
+		onContentChange: () => noteContentChange(),
+		onLiveChange: () => noteContentChange()
 	});
 	const saving = createSaveController({
 		getStorage: () => requireStorage(),
@@ -114,6 +147,7 @@ function createDocumentEngine(options) {
 		}
 	}) : void 0;
 	function noteContentChange() {
+		mutations += 1;
 		saving.noteContentChange();
 		recovery?.schedule();
 	}
@@ -136,15 +170,21 @@ function createDocumentEngine(options) {
 				height: canvas.getHeight()
 			},
 			objects: serialized.objects,
-			assets: buildAssetManifest(serialized.objects),
+			assets: buildAssetManifest(documentObjects({
+				objects: serialized.objects,
+				canvas: serialized
+			})),
 			metadata: { ...documentInfo.metadata }
 		};
 		if (serialized.version !== void 0) document.fabricVersion = serialized.version;
-		if (serialized.background !== void 0) document.canvas.background = serialized.background;
+		Object.assign(document.canvas, pickPageFields(serialized));
 		return document;
 	}
-	function toLoadError(error, signal) {
-		if (signal.aborted) return new DocumentEngineError("LOAD_ABORTED", "Loading stopped because a newer load started", { cause: error });
+	function toLoadError(error, controller) {
+		if (controller.signal.aborted) {
+			const reason = cancelledByCaller.has(controller) ? "Loading was cancelled" : destroyed ? "Loading stopped because the engine was destroyed" : "Loading stopped because a newer load started";
+			return new DocumentEngineError("LOAD_ABORTED", reason, { cause: error });
+		}
 		if (isDocumentEngineError(error)) return error;
 		const reason = error instanceof Error ? error.message : String(error);
 		return new DocumentEngineError("LOAD_FAILED", `Fabric could not load the document: ${reason}`, { cause: error });
@@ -156,7 +196,7 @@ function createDocumentEngine(options) {
 			throw new DocumentEngineError(issues[0].code, `The document is not valid: ${summary}`, { issues });
 		}
 		const document = input;
-		const unknownTypes = registry.findUnknownTypes(collectSerializedTypes(document.objects));
+		const unknownTypes = registry.findUnknownTypes(collectSerializedTypes(documentObjects(document)));
 		if (unknownTypes.length > 0) throw new DocumentEngineError("UNKNOWN_OBJECT_TYPE", `The document uses object types that are not registered: ${unknownTypes.join(", ")}. Register them with customObjects or engine.registerObject before loading.`, { unknownTypes });
 		return document;
 	}
@@ -167,19 +207,50 @@ function createDocumentEngine(options) {
 		if (!storage || discardUnsavedChanges || !saving.state().isDirty) return;
 		throw new DocumentEngineError("UNSAVED_CHANGES", "The current document has unsaved changes. Save first, or pass { discardUnsavedChanges: true } to replace it anyway.");
 	}
-	function startLoad() {
+	const cancelledByCaller = /* @__PURE__ */ new WeakSet();
+	const unlinkCallerSignal = /* @__PURE__ */ new WeakMap();
+	function startLoad(callerSignal) {
 		activeLoad?.abort();
 		const controller = new AbortController();
 		activeLoad = controller;
+		if (callerSignal) {
+			const cancel = () => {
+				cancelledByCaller.add(controller);
+				controller.abort();
+			};
+			if (callerSignal.aborted) cancel();
+			else {
+				callerSignal.addEventListener("abort", cancel, { once: true });
+				unlinkCallerSignal.set(controller, () => callerSignal.removeEventListener("abort", cancel));
+			}
+		}
 		return controller;
 	}
+	function finishLoad(controller) {
+		unlinkCallerSignal.get(controller)?.();
+		unlinkCallerSignal.delete(controller);
+	}
 	async function loadMigratedDocument(input, loadOptions, importDetails, startedLoad) {
 		ensureUsable();
 		protectUnsavedChanges(loadOptions.discardUnsavedChanges);
-		const controller = startedLoad ?? startLoad();
+		const controller = startedLoad ?? startLoad(loadOptions.signal);
+		const mutationsAtStart = mutations;
 		const documentId = describeDocumentId(input);
+		const report = (stage, done, total) => {
+			if (controller.signal.aborted) return;
+			const progress = {
+				documentId,
+				stage,
+				done,
+				total
+			};
+			loadOptions.onProgress?.(progress);
+			events.emit("load:progress", progress);
+		};
 		events.emit("load:start", { documentId });
 		try {
+			if (controller.signal.aborted) throw new Error("aborted");
+			report("prepare", 0, 1);
 			await recovery?.markLoadStarted(documentId);
 			if (controller.signal.aborted) throw new Error("aborted");
 			const { document: migrated, migratedFrom } = migrateDocument(secureDocument(input, options.limits), {
@@ -188,13 +259,21 @@ function createDocumentEngine(options) {
 				...importDetails
 			});
 			const checked = checkDocument(migrated);
-			const { document, warnings } = await prepareAssetsForLoad(checked, assetOptions, controller.signal, options.limits?.isAllowedUrl);
+			report("prepare", 1, 1);
+			const { document, warnings } = await prepareAssetsForLoad(checked, assetOptions, controller.signal, options.limits?.isAllowedUrl, (done, total) => report("images", done, total));
 			if (controller.signal.aborted) throw new Error("aborted");
 			await history.withoutRecording(() => loadIntoCanvas(canvas, {
 				version: document.fabricVersion,
-				background: document.canvas.background,
+				...pickPageFields(document.canvas),
 				objects: document.objects
-			}, controller.signal));
+			}, {
+				signal: controller.signal,
+				onObjects: (done, total) => report("objects", done, total),
+				beforeSwap: () => {
+					if (mutations !== mutationsAtStart && !loadOptions.discardUnsavedChanges) throw new DocumentEngineError("LOAD_CONFLICT", "The canvas was edited while the document loaded, so the load was stopped to keep the edits. Pass { discardUnsavedChanges: true } to replace them.");
+					session += 1;
+				}
+			}));
 			if (controller.signal.aborted) throw new Error("aborted");
 			if (loadOptions.restoreCanvasSize ?? true) canvas.setDimensions({
 				width: document.canvas.width,
@@ -211,6 +290,7 @@ function createDocumentEngine(options) {
 			recovery?.cancel();
 			saving.startSession(document.revision ?? 0);
 			canvas.requestRenderAll();
+			report("done", 1, 1);
 			if (warnings.length > 0) events.emit("assets:warning", { warnings });
 			events.emit("document:change", { documentId: document.id });
 			events.emit("load:success", {
@@ -220,10 +300,11 @@ function createDocumentEngine(options) {
 			});
 			return document;
 		} catch (error) {
-			const engineError = toLoadError(error, controller.signal);
+			const engineError = toLoadError(error, controller);
 			events.emit("load:error", { error: engineError });
 			throw engineError;
 		} finally {
+			finishLoad(controller);
 			if (activeLoad === controller) {
 				activeLoad = null;
 				await recovery?.markLoadFinished();
@@ -244,6 +325,43 @@ function createDocumentEngine(options) {
 			metadata
 		});
 	}
+	function setPage(changes, label = "Change page") {
+		ensureUsable();
+		const problem = canvasSizeProblem(changes.width ?? canvas.getWidth(), changes.height ?? canvas.getHeight(), options.limits);
+		if (problem) throw new DocumentEngineError("UNSAFE_DOCUMENT", `The page was not resized: it would be ${problem}`);
+		history.transaction(label, () => {
+			const width = changes.width ?? canvas.getWidth();
+			const height = changes.height ?? canvas.getHeight();
+			if (width !== canvas.getWidth() || height !== canvas.getHeight()) canvas.setDimensions({
+				width,
+				height
+			});
+			const live = {};
+			if (changes.background !== void 0) live.backgroundColor = changes.background ?? "";
+			if (changes.backgroundImage !== void 0) live.backgroundImage = changes.backgroundImage ?? void 0;
+			if (changes.overlay !== void 0) live.overlayColor = changes.overlay ?? "";
+			if (changes.overlayImage !== void 0) live.overlayImage = changes.overlayImage ?? void 0;
+			if (changes.clipPath !== void 0) live.clipPath = changes.clipPath ?? void 0;
+			canvas.set(live);
+		});
+		canvas.requestRenderAll();
+	}
+	async function importSvg(svg, importOptions = {}) {
+		ensureUsable();
+		const startedIn = session;
+		const result = await readSvg(svg, importOptions, options.limits);
+		try {
+			ensureSameSession(startedIn, "The SVG import");
+		} catch (error) {
+			result.objects.forEach((object) => object.dispose?.());
+			throw error;
+		}
+		if (result.objects.length > 0) {
+			history.transaction("Import SVG", () => canvas.add(...result.objects));
+			canvas.requestRenderAll();
+		}
+		return result;
+	}
 	let savesSinceAutomaticVersion = 0;
 	let lastVersionTime = 0;
 	function nextVersionTimestamp() {
@@ -322,15 +440,17 @@ function createDocumentEngine(options) {
 		ensureUsable();
 		const source = requireStorage();
 		protectUnsavedChanges(loadOptions?.discardUnsavedChanges);
-		const controller = startLoad();
+		const controller = startLoad(loadOptions?.signal);
 		let stored;
 		try {
+			if (controller.signal.aborted) throw new Error("aborted");
 			stored = await source.loadDocument(documentId);
 			if (controller.signal.aborted) throw new Error("aborted");
 		} catch (error) {
+			finishLoad(controller);
 			if (activeLoad === controller) activeLoad = null;
 			if (controller.signal.aborted) {
-				const aborted = toLoadError(error, controller.signal);
+				const aborted = toLoadError(error, controller);
 				events.emit("load:error", { error: aborted });
 				throw aborted;
 			}
@@ -355,6 +475,7 @@ function createDocumentEngine(options) {
 		protectUnsavedChanges(newOptions.discardUnsavedChanges);
 		activeLoad?.abort();
 		history.withoutRecording(() => canvas.clear());
+		session += 1;
 		objectsById.clear();
 		documentInfo = createDocumentInfo(newOptions);
 		uploadedUrls.clear();
@@ -381,10 +502,12 @@ function createDocumentEngine(options) {
 			if (isReplaceableImage(object) && isSameUrl(object.getSrc(), oldUrl)) images.push(object);
 		});
 		if (images.length === 0) return 0;
+		const startedIn = session;
 		await history.transaction("Replace image", () => Promise.all(images.map(async (image) => {
 			const displayedWidth = image.width * image.scaleX;
 			const displayedHeight = image.height * image.scaleY;
 			await image.setSrc(newUrl, { crossOrigin: image.crossOrigin ?? null });
+			ensureSameSession(startedIn, "Replacing the image");
 			image.set({
 				scaleX: displayedWidth / image.width,
 				scaleY: displayedHeight / image.height
@@ -400,8 +523,8 @@ function createDocumentEngine(options) {
 	}
 	async function checkBeforeExport(exportOptions) {
 		ensureUsable();
-		const { format } = normalizeExportOptions(exportOptions);
-		return preflightExport(canvas, format, format === "json" ? [] : fontsOnCanvas(), assetOptions);
+		const { format, svg } = normalizeExportOptions(exportOptions);
+		return preflightExport(canvas, format, format === "json" ? [] : fontsOnCanvas(), assetOptions, svg);
 	}
 	function describeProblems(check) {
 		return check.problems.map((problem) => problem.message).join("; ");
@@ -430,24 +553,58 @@ function createDocumentEngine(options) {
 		if (!check.ok) throw new DocumentEngineError("EXPORT_BLOCKED", `The export cannot run: ${describeProblems(check)}`, { problems: check.problems });
 		const format = settings.format;
 		try {
+			const warnings = [...check.warnings];
 			const rendered = withExportView(canvas, settings.background, format, () => {
 				const area = resolveExportArea(canvas, settings.area, settings.padding);
+				if (format !== "svg") {
+					const problem = canvasSizeProblem(area.width * settings.scale, area.height * settings.scale, options.limits);
+					if (problem) {
+						const message = `The export would be ${problem}. Lower the scale or export a smaller area.`;
+						throw new DocumentEngineError("EXPORT_BLOCKED", message, { problems: [{
+							code: "TOO_LARGE",
+							message,
+							objectIds: []
+						}] });
+					}
+				}
 				return {
 					area,
-					content: format === "svg" ? Promise.resolve(new Blob([renderSvg(canvas, area, settings.scale)], { type: mimeTypes.svg })) : renderRaster(canvas, area, format, settings.scale, settings.quality)
+					content: format === "svg" ? Promise.resolve(renderSvg(canvas, area, settings.scale, settings.svg, options.limits)) : renderRaster(canvas, area, format, settings.scale, settings.quality)
 				};
 			});
-			const blob = await rendered.content;
+			let blob;
+			if (format === "svg") {
+				const { svg, rasterizedObjectIds } = await rendered.content;
+				if (rasterizedObjectIds.length > 0) warnings.push({
+					code: "CLIP_PATH_RASTERIZED",
+					message: "Objects whose clip path has a clip path of its own were drawn as pictures: Fabric cannot write nested clip paths as SVG.",
+					objectIds: rasterizedObjectIds
+				});
+				const embedded = await embedSvgAssets(svg, canvas, settings.svg, settings.signal, options.limits?.isAllowedUrl ?? isSafeImageUrl);
+				stopIfCancelled();
+				if (settings.svg.embedImages === "require" && embedded.problems.length > 0) {
+					const problems = embedded.warnings.filter((warning) => warning.code === "IMAGE_NOT_EMBEDDED").map((warning) => ({
+						code: "IMAGE_NOT_EMBEDDED",
+						message: warning.message,
+						url: warning.url,
+						objectIds: warning.objectIds
+					}));
+					throw new DocumentEngineError("EXPORT_BLOCKED", `The export cannot run: ${embedded.problems.join("; ")}`, { problems });
+				}
+				warnings.push(...embedded.warnings);
+				blob = new Blob([embedded.svg], { type: mimeTypes.svg });
+			} else blob = await rendered.content;
 			return {
 				format,
 				mimeType: blob.type || mimeTypes[format],
 				blob,
 				width: Math.round(rendered.area.width * settings.scale),
 				height: Math.round(rendered.area.height * settings.scale),
-				warnings: check.warnings
+				warnings
 			};
 		} catch (error) {
 			if (isDocumentEngineError(error)) throw error;
+			if (settings.signal?.aborted) throw new DocumentEngineError("EXPORT_ABORTED", "The export was cancelled", { cause: error });
 			if (error?.name === "SecurityError") {
 				const problem = {
 					code: "CROSS_ORIGIN_IMAGE",
@@ -485,12 +642,14 @@ function createDocumentEngine(options) {
 		if (!recovery) throw new DocumentEngineError("RECOVERY_MISSING", "Pass recovery: { store } to createDocumentEngine to use recovery");
 		return recovery;
 	}
-	async function restoreRecovery(documentId, loadOptions) {
+	async function restoreRecovery(documentId, restoreOptions = {}) {
 		const source = requireRecovery();
 		const id = documentId ?? documentInfo.id;
-		const record = await source.read(id);
+		const { sessionId: branch, ...loadOptions } = restoreOptions;
+		const record = await source.read(id, branch);
 		if (!record) throw new DocumentEngineError("RECOVERY_NOT_FOUND", `There is no recovery copy for document "${id}"`);
 		const loaded = await loadDocument(await restoreRecordedFiles(record), loadOptions);
+		source.adopt(loaded.id, record.sessionId);
 		noteContentChange();
 		events.emit("recovery:restored", { document: loaded });
 		return loaded;
@@ -511,12 +670,15 @@ function createDocumentEngine(options) {
 		const { disposed } = canvas;
 		if (recovery && saving.state().isDirty && !disposed) recovery.writeNow();
 		destroyed = true;
+		session += 1;
 		activeLoad?.abort();
 		history.destroy();
 		saving.destroy();
 		recovery?.destroy();
 		canvas.off("object:added", handleObjectAdded);
 		canvas.off("object:removed", handleObjectRemoved);
+		canvas.off("object:modified", countMutation);
+		canvas.off("text:changed", countMutation);
 		objectsById.clear();
 		events.clear();
 	}
@@ -524,7 +686,8 @@ function createDocumentEngine(options) {
 		canvas,
 		getDocumentInfo: () => ({
 			...documentInfo,
-			metadata: { ...documentInfo.metadata }
+			metadata: { ...documentInfo.metadata },
+			session
 		}),
 		updateMetadata(changes) {
 			ensureUsable();
@@ -542,6 +705,7 @@ function createDocumentEngine(options) {
 		loadDocument,
 		load,
 		importFabricJson,
+		importSvg,
 		createVersion: (name) => storeVersion(name ?? `Version ${(/* @__PURE__ */ new Date()).toLocaleString()}`, "named"),
 		listVersions: async (documentId) => requireVersions().listVersions(documentId ?? documentInfo.id),
 		restoreVersion,
@@ -564,14 +728,15 @@ function createDocumentEngine(options) {
 		preflightExport: checkBeforeExport,
 		flushRecovery: async () => requireRecovery().flush(),
 		getRecoverableDocuments: async () => requireRecovery().list(),
-		getRecovery: async (documentId) => requireRecovery().read(documentId ?? documentInfo.id),
+		getRecovery: async (documentId, sessionId) => requireRecovery().read(documentId ?? documentInfo.id, sessionId),
 		restoreRecovery,
-		discardRecovery: async (documentId) => requireRecovery().remove(documentId ?? documentInfo.id),
+		discardRecovery: async (documentId, sessionId) => requireRecovery().discard(documentId ?? documentInfo.id, sessionId),
 		getInterruptedLoad: async () => requireRecovery().interruptedLoad(),
-		transaction(label, work) {
+		transaction(label, work, transactionOptions) {
 			ensureUsable();
-			return history.transaction(label, work);
+			return history.transaction(label, work, transactionOptions);
 		},
+		setPage,
 		commit(label = "Edit") {
 			ensureUsable();
 			return history.commit(label);

package/dist/engine/errors.d.cts

@@ -1,7 +1,7 @@
 import { FontAsset, ImageAsset } from "../assets/asset-manifest.cjs";
 import { ExportProblem } from "../export/preflight-export.cjs";
 //#region src/engine/errors.d.ts
-export type DocumentErrorCode = "INVALID_DOCUMENT" | "UNSAFE_DOCUMENT" | "UNSUPPORTED_SCHEMA" | "UNKNOWN_OBJECT_TYPE" | "INVALID_CUSTOM_OBJECT" | "LOAD_ABORTED" | "LOAD_FAILED" | "MISSING_ASSETS" | "MISSING_FONTS" | "ASSET_UPLOAD_FAILED" | "STORAGE_MISSING" | "UNSAVED_CHANGES" | "SAVE_FAILED" | "SAVE_CONFLICT" | "SAVE_CANCELLED" | "DOCUMENT_NOT_FOUND" | "HISTORY_FAILED" | "RECOVERY_MISSING" | "RECOVERY_NOT_FOUND" | "RECOVERY_FAILED" | "MIGRATION_FAILED" | "VERSIONS_UNSUPPORTED" | "VERSION_NOT_FOUND" | "VERSION_FAILED" | "INVALID_EXPORT_OPTIONS" | "EXPORT_BLOCKED" | "EXPORT_FAILED" | "EXPORT_ABORTED" | "ENGINE_DESTROYED";
+export type DocumentErrorCode = "INVALID_DOCUMENT" | "UNSAFE_DOCUMENT" | "UNSUPPORTED_SCHEMA" | "UNKNOWN_OBJECT_TYPE" | "INVALID_CUSTOM_OBJECT" | "LOAD_ABORTED" | "LOAD_FAILED" | "MISSING_ASSETS" | "MISSING_FONTS" | "ASSET_UPLOAD_FAILED" | "STORAGE_MISSING" | "UNSAVED_CHANGES" | "SAVE_FAILED" | "SAVE_CONFLICT" | "SAVE_CANCELLED" | "DOCUMENT_NOT_FOUND" | "HISTORY_FAILED" | "RECOVERY_MISSING" | "RECOVERY_NOT_FOUND" | "RECOVERY_FAILED" | "MIGRATION_FAILED" | "VERSIONS_UNSUPPORTED" | "VERSION_NOT_FOUND" | "VERSION_FAILED" | "INVALID_EXPORT_OPTIONS" | "EXPORT_BLOCKED" | "EXPORT_FAILED" | "EXPORT_ABORTED" | "SVG_IMPORT_FAILED" | "LOAD_CONFLICT" | "DOCUMENT_CHANGED" | "PDF_UNAVAILABLE" | "PDF_FAILED" | "ENGINE_DESTROYED";
 export interface DocumentIssue {
   code: DocumentErrorCode;
   path: string;

package/dist/engine/errors.d.ts

@@ -1,7 +1,7 @@
 import { FontAsset, ImageAsset } from "../assets/asset-manifest.js";
 import { ExportProblem } from "../export/preflight-export.js";
 //#region src/engine/errors.d.ts
-export type DocumentErrorCode = "INVALID_DOCUMENT" | "UNSAFE_DOCUMENT" | "UNSUPPORTED_SCHEMA" | "UNKNOWN_OBJECT_TYPE" | "INVALID_CUSTOM_OBJECT" | "LOAD_ABORTED" | "LOAD_FAILED" | "MISSING_ASSETS" | "MISSING_FONTS" | "ASSET_UPLOAD_FAILED" | "STORAGE_MISSING" | "UNSAVED_CHANGES" | "SAVE_FAILED" | "SAVE_CONFLICT" | "SAVE_CANCELLED" | "DOCUMENT_NOT_FOUND" | "HISTORY_FAILED" | "RECOVERY_MISSING" | "RECOVERY_NOT_FOUND" | "RECOVERY_FAILED" | "MIGRATION_FAILED" | "VERSIONS_UNSUPPORTED" | "VERSION_NOT_FOUND" | "VERSION_FAILED" | "INVALID_EXPORT_OPTIONS" | "EXPORT_BLOCKED" | "EXPORT_FAILED" | "EXPORT_ABORTED" | "ENGINE_DESTROYED";
+export type DocumentErrorCode = "INVALID_DOCUMENT" | "UNSAFE_DOCUMENT" | "UNSUPPORTED_SCHEMA" | "UNKNOWN_OBJECT_TYPE" | "INVALID_CUSTOM_OBJECT" | "LOAD_ABORTED" | "LOAD_FAILED" | "MISSING_ASSETS" | "MISSING_FONTS" | "ASSET_UPLOAD_FAILED" | "STORAGE_MISSING" | "UNSAVED_CHANGES" | "SAVE_FAILED" | "SAVE_CONFLICT" | "SAVE_CANCELLED" | "DOCUMENT_NOT_FOUND" | "HISTORY_FAILED" | "RECOVERY_MISSING" | "RECOVERY_NOT_FOUND" | "RECOVERY_FAILED" | "MIGRATION_FAILED" | "VERSIONS_UNSUPPORTED" | "VERSION_NOT_FOUND" | "VERSION_FAILED" | "INVALID_EXPORT_OPTIONS" | "EXPORT_BLOCKED" | "EXPORT_FAILED" | "EXPORT_ABORTED" | "SVG_IMPORT_FAILED" | "LOAD_CONFLICT" | "DOCUMENT_CHANGED" | "PDF_UNAVAILABLE" | "PDF_FAILED" | "ENGINE_DESTROYED";
 export interface DocumentIssue {
   code: DocumentErrorCode;
   path: string;

package/dist/export/batch-render.cjs

@@ -0,0 +1,172 @@
+const require_errors = require("../engine/errors.cjs");
+const require_walk_objects = require("../fabric/walk-objects.cjs");
+const require_create_document_engine = require("../engine/create-document-engine.cjs");
+let fabric = require("fabric");
+//#region src/export/batch-render.ts
+/**
+* Releases a canvas's pixels now. Fabric's `dispose` drops its references,
+* but in browsers the memory behind a canvas comes back only much later,
+* when the garbage collector gets to it.
+*/
+function releaseCanvas(value) {
+	if (typeof HTMLCanvasElement !== "undefined" && value instanceof HTMLCanvasElement) {
+		value.width = 0;
+		value.height = 0;
+	}
+}
+function disposeObject(object) {
+	const owned = object;
+	for (const key of [
+		"_cacheCanvas",
+		"_filteredEl",
+		"_element",
+		"_originalElement"
+	]) releaseCanvas(owned[key]);
+	object.dispose?.();
+}
+/** Frees the objects on a canvas: their cache canvases and image elements. */
+function disposeObjects(canvas) {
+	const objects = canvas.getObjects();
+	canvas.remove(...objects);
+	require_walk_objects.walkObjects(objects, (object) => {
+		disposeObject(object);
+		if (object.clipPath) disposeObject(object.clipPath);
+	});
+	for (const key of ["backgroundImage", "overlayImage"]) {
+		const image = canvas[key];
+		if (image) {
+			disposeObject(image);
+			canvas[key] = void 0;
+		}
+	}
+}
+function createSlot(options) {
+	if (typeof document === "undefined") throw new require_errors.DocumentEngineError("EXPORT_FAILED", "Rendering documents needs a browser DOM");
+	const element = document.createElement("canvas");
+	const canvas = new fabric.StaticCanvas(element, {
+		renderOnAddRemove: false,
+		enableRetinaScaling: false
+	});
+	return {
+		element,
+		canvas,
+		engine: require_create_document_engine.createDocumentEngine({
+			canvas,
+			customObjects: options.customObjects,
+			assets: options.assets,
+			limits: options.limits,
+			history: { limit: 1 }
+		})
+	};
+}
+async function releaseSlot(slot) {
+	disposeObjects(slot.canvas);
+	slot.engine.destroy();
+	await slot.canvas.dispose();
+	slot.element.width = 0;
+	slot.element.height = 0;
+}
+function toEngineError(error) {
+	if (require_errors.isDocumentEngineError(error)) return error;
+	const reason = error instanceof Error ? error.message : String(error);
+	return new require_errors.DocumentEngineError("EXPORT_FAILED", `The document could not be rendered: ${reason}`, { cause: error });
+}
+function documentIdOf(value) {
+	const id = value?.id;
+	return typeof id === "string" ? id : void 0;
+}
+async function renderOne(slot, input, options, signal) {
+	const { concurrency: _concurrency, onProgress: _onProgress, customObjects: _custom, assets: _assets, limits: _limits, ...exportOptions } = options;
+	try {
+		await slot.engine.loadDocument(input, {
+			signal,
+			discardUnsavedChanges: true
+		});
+		return await slot.engine.export({
+			...exportOptions,
+			signal
+		});
+	} finally {
+		disposeObjects(slot.canvas);
+		slot.engine.clearHistory();
+	}
+}
+/**
+* Renders each document and yields the results as they finish, so they can
+* be uploaded or saved one by one instead of all being held in memory.
+* Documents can be `FabricDocument`s or plain Fabric JSON, and can come from
+* an async iterable, such as pages of a database query.
+*/
+async function* renderDocuments(documents, options) {
+	const concurrency = Math.max(1, Math.floor(options.concurrency ?? 2));
+	const total = Array.isArray(documents) ? documents.length : void 0;
+	const controller = new AbortController();
+	const stop = () => controller.abort();
+	options.signal?.addEventListener("abort", stop, { once: true });
+	if (options.signal?.aborted) stop();
+	const iterator = Symbol.asyncIterator in documents ? documents[Symbol.asyncIterator]() : documents[Symbol.iterator]();
+	const slots = [];
+	const idle = [];
+	const running = /* @__PURE__ */ new Map();
+	let nextIndex = 0;
+	let exhausted = false;
+	let done = 0;
+	async function take() {
+		if (exhausted) return void 0;
+		const next = await iterator.next();
+		if (next.done) {
+			exhausted = true;
+			return;
+		}
+		return {
+			index: nextIndex++,
+			value: next.value
+		};
+	}
+	function start(slot, job) {
+		const task = renderOne(slot, job.value, options, controller.signal).then((result) => ({
+			index: job.index,
+			documentId: documentIdOf(job.value),
+			result
+		}), (error) => ({
+			index: job.index,
+			documentId: documentIdOf(job.value),
+			error: toEngineError(error)
+		}));
+		running.set(job.index, task.finally(() => idle.push(slot)));
+	}
+	try {
+		while (true) {
+			if (controller.signal.aborted) throw new require_errors.DocumentEngineError("EXPORT_ABORTED", "Rendering was cancelled");
+			while (running.size < concurrency && !exhausted) {
+				const job = await take();
+				if (!job) break;
+				let slot = idle.pop();
+				if (!slot) {
+					slot = createSlot(options);
+					slots.push(slot);
+				}
+				start(slot, job);
+			}
+			if (running.size === 0) break;
+			const finished = await Promise.race(running.values());
+			running.delete(finished.index);
+			done += 1;
+			options.onProgress?.({
+				done,
+				total
+			});
+			if (controller.signal.aborted) throw new require_errors.DocumentEngineError("EXPORT_ABORTED", "Rendering was cancelled");
+			yield finished;
+		}
+	} finally {
+		controller.abort();
+		options.signal?.removeEventListener("abort", stop);
+		await Promise.allSettled(running.values());
+		await Promise.all(slots.map(releaseSlot));
+		if (!exhausted) await iterator.return?.();
+	}
+}
+//#endregion
+exports.disposeObjects = disposeObjects;
+exports.renderDocuments = renderDocuments;