fabricjs-document-engine 0.0.0

package/dist/engine/create-document-engine.d.cts

@@ -0,0 +1,56 @@
+import { DocumentInfo, FabricDocument } from "../document/document-format.cjs";
+import { NewDocumentOptions } from "../document/create-document.cjs";
+import { CustomObjectDefinition } from "../fabric/object-registry.cjs";
+import { DocumentEngineError } from "./errors.cjs";
+import { Unsubscribe } from "./event-emitter.cjs";
+import { FabricObject, StaticCanvas } from "fabric";
+//#region src/engine/create-document-engine.d.ts
+export interface DocumentStorage {
+  loadDocument(id: string): Promise<unknown>;
+  saveDocument(document: FabricDocument): Promise<void>;
+}
+export interface DocumentEngineOptions {
+  canvas: StaticCanvas;
+  storage?: DocumentStorage;
+  customObjects?: CustomObjectDefinition[];
+  document?: NewDocumentOptions;
+}
+export interface LoadOptions {
+  restoreCanvasSize?: boolean;
+}
+export interface DocumentEngineEvents {
+  "load:start": {
+    documentId: string | undefined;
+  };
+  "load:success": {
+    document: FabricDocument;
+  };
+  "load:error": {
+    error: DocumentEngineError;
+  };
+  "save:start": {
+    document: FabricDocument;
+  };
+  "save:success": {
+    document: FabricDocument;
+  };
+  "save:error": {
+    error: DocumentEngineError;
+  };
+}
+export interface DocumentEngine {
+  readonly canvas: StaticCanvas;
+  getDocumentInfo(): DocumentInfo;
+  updateMetadata(changes: Record<string, unknown>): void;
+  newDocument(options?: NewDocumentOptions): void;
+  toDocument(): FabricDocument;
+  loadDocument(document: unknown, options?: LoadOptions): Promise<FabricDocument>;
+  load(documentId: string, options?: LoadOptions): Promise<FabricDocument>;
+  save(): Promise<FabricDocument>;
+  registerObject(definition: CustomObjectDefinition): void;
+  getObjectById(id: string): FabricObject | undefined;
+  on<Name extends keyof DocumentEngineEvents>(name: Name, handler: (payload: DocumentEngineEvents[Name]) => void): Unsubscribe;
+  destroy(): void;
+}
+export declare function createDocumentEngine(options: DocumentEngineOptions): DocumentEngine;
+//#endregion

package/dist/engine/create-document-engine.d.ts

@@ -0,0 +1,56 @@
+import { DocumentInfo, FabricDocument } from "../document/document-format.js";
+import { NewDocumentOptions } from "../document/create-document.js";
+import { CustomObjectDefinition } from "../fabric/object-registry.js";
+import { DocumentEngineError } from "./errors.js";
+import { Unsubscribe } from "./event-emitter.js";
+import { FabricObject, StaticCanvas } from "fabric";
+//#region src/engine/create-document-engine.d.ts
+export interface DocumentStorage {
+  loadDocument(id: string): Promise<unknown>;
+  saveDocument(document: FabricDocument): Promise<void>;
+}
+export interface DocumentEngineOptions {
+  canvas: StaticCanvas;
+  storage?: DocumentStorage;
+  customObjects?: CustomObjectDefinition[];
+  document?: NewDocumentOptions;
+}
+export interface LoadOptions {
+  restoreCanvasSize?: boolean;
+}
+export interface DocumentEngineEvents {
+  "load:start": {
+    documentId: string | undefined;
+  };
+  "load:success": {
+    document: FabricDocument;
+  };
+  "load:error": {
+    error: DocumentEngineError;
+  };
+  "save:start": {
+    document: FabricDocument;
+  };
+  "save:success": {
+    document: FabricDocument;
+  };
+  "save:error": {
+    error: DocumentEngineError;
+  };
+}
+export interface DocumentEngine {
+  readonly canvas: StaticCanvas;
+  getDocumentInfo(): DocumentInfo;
+  updateMetadata(changes: Record<string, unknown>): void;
+  newDocument(options?: NewDocumentOptions): void;
+  toDocument(): FabricDocument;
+  loadDocument(document: unknown, options?: LoadOptions): Promise<FabricDocument>;
+  load(documentId: string, options?: LoadOptions): Promise<FabricDocument>;
+  save(): Promise<FabricDocument>;
+  registerObject(definition: CustomObjectDefinition): void;
+  getObjectById(id: string): FabricObject | undefined;
+  on<Name extends keyof DocumentEngineEvents>(name: Name, handler: (payload: DocumentEngineEvents[Name]) => void): Unsubscribe;
+  destroy(): void;
+}
+export declare function createDocumentEngine(options: DocumentEngineOptions): DocumentEngine;
+//#endregion

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

@@ -0,0 +1,218 @@
+import "../document/document-format.js";
+import { createId } from "../document/ids.js";
+import { createDocumentInfo } from "../document/create-document.js";
+import { validateDocument } from "../document/validate-document.js";
+import { collectSerializedTypes, walkObjects } from "../fabric/walk-objects.js";
+import { loadIntoCanvas, serializeCanvas } from "../fabric/fabric-adapter.js";
+import { readObjectId, writeObjectId } from "../fabric/object-ids.js";
+import { DocumentEngineError, isDocumentEngineError } from "./errors.js";
+import { createObjectRegistry } from "../fabric/object-registry.js";
+import { createEventEmitter } from "./event-emitter.js";
+//#region src/engine/create-document-engine.ts
+function describeDocumentId(value) {
+	const id = value?.id;
+	return typeof id === "string" ? id : void 0;
+}
+function createDocumentEngine(options) {
+	const { canvas, storage } = options;
+	const registry = createObjectRegistry(options.customObjects);
+	const events = createEventEmitter();
+	const objectsById = /* @__PURE__ */ new Map();
+	let documentInfo = createDocumentInfo(options.document);
+	let activeLoad = null;
+	let destroyed = false;
+	function ensureUsable() {
+		if (destroyed) throw new DocumentEngineError("ENGINE_DESTROYED", "This document engine was destroyed");
+	}
+	function indexObjectTree(root) {
+		walkObjects([root], (object) => {
+			let id = readObjectId(object);
+			const owner = id === void 0 ? void 0 : objectsById.get(id);
+			if (id === void 0 || owner !== void 0 && owner !== object) {
+				id = createId();
+				writeObjectId(object, id);
+			}
+			objectsById.set(id, object);
+		});
+	}
+	function removeObjectTreeFromIndex(root) {
+		walkObjects([root], (object) => {
+			const id = readObjectId(object);
+			if (id !== void 0 && objectsById.get(id) === object) objectsById.delete(id);
+		});
+	}
+	function rebuildIndex() {
+		objectsById.clear();
+		canvas.getObjects().forEach(indexObjectTree);
+	}
+	const handleObjectAdded = ({ target }) => indexObjectTree(target);
+	const handleObjectRemoved = ({ target }) => removeObjectTreeFromIndex(target);
+	canvas.on("object:added", handleObjectAdded);
+	canvas.on("object:removed", handleObjectRemoved);
+	rebuildIndex();
+	function toDocument() {
+		ensureUsable();
+		rebuildIndex();
+		const serialized = serializeCanvas(canvas, registry.propertiesToInclude());
+		documentInfo = {
+			...documentInfo,
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		const document = {
+			schemaVersion: 1,
+			id: documentInfo.id,
+			createdAt: documentInfo.createdAt,
+			updatedAt: documentInfo.updatedAt,
+			canvas: {
+				width: canvas.getWidth(),
+				height: canvas.getHeight()
+			},
+			objects: serialized.objects,
+			metadata: { ...documentInfo.metadata }
+		};
+		if (serialized.version !== void 0) document.fabricVersion = serialized.version;
+		if (serialized.background !== void 0) document.canvas.background = serialized.background;
+		return document;
+	}
+	function toLoadError(error, signal) {
+		if (isDocumentEngineError(error)) return error;
+		if (signal.aborted) return new DocumentEngineError("LOAD_ABORTED", "Loading stopped because a newer load started", { cause: error });
+		const reason = error instanceof Error ? error.message : String(error);
+		return new DocumentEngineError("LOAD_FAILED", `Fabric could not load the document: ${reason}`, { cause: error });
+	}
+	function checkDocument(input) {
+		const issues = validateDocument(input);
+		if (issues.length > 0) {
+			const summary = issues.map((issue) => `${issue.path || "document"} ${issue.message}`).join("; ");
+			throw new DocumentEngineError(issues[0].code, `The document is not valid: ${summary}`, { issues });
+		}
+		const document = input;
+		const unknownTypes = registry.findUnknownTypes(collectSerializedTypes(document.objects));
+		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;
+	}
+	async function loadDocument(input, loadOptions = {}) {
+		ensureUsable();
+		activeLoad?.abort();
+		const controller = new AbortController();
+		activeLoad = controller;
+		events.emit("load:start", { documentId: describeDocumentId(input) });
+		try {
+			const document = checkDocument(input);
+			await loadIntoCanvas(canvas, {
+				version: document.fabricVersion,
+				background: document.canvas.background,
+				objects: document.objects
+			}, controller.signal);
+			if (controller.signal.aborted) throw new Error("aborted");
+			if (loadOptions.restoreCanvasSize ?? true) canvas.setDimensions({
+				width: document.canvas.width,
+				height: document.canvas.height
+			});
+			documentInfo = {
+				id: document.id,
+				createdAt: document.createdAt,
+				updatedAt: document.updatedAt,
+				metadata: { ...document.metadata }
+			};
+			rebuildIndex();
+			canvas.requestRenderAll();
+			events.emit("load:success", { document });
+			return document;
+		} catch (error) {
+			const engineError = toLoadError(error, controller.signal);
+			events.emit("load:error", { error: engineError });
+			throw engineError;
+		} finally {
+			if (activeLoad === controller) activeLoad = null;
+		}
+	}
+	function requireStorage() {
+		if (!storage) throw new DocumentEngineError("STORAGE_MISSING", "Pass a storage adapter to createDocumentEngine to use load and save");
+		return storage;
+	}
+	async function load(documentId, loadOptions) {
+		ensureUsable();
+		const source = requireStorage();
+		let stored;
+		try {
+			stored = await source.loadDocument(documentId);
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			const engineError = new DocumentEngineError("LOAD_FAILED", `Storage could not load "${documentId}": ${reason}`, { cause: error });
+			events.emit("load:error", { error: engineError });
+			throw engineError;
+		}
+		return loadDocument(stored, loadOptions);
+	}
+	async function save() {
+		ensureUsable();
+		const target = requireStorage();
+		const document = toDocument();
+		events.emit("save:start", { document });
+		try {
+			await target.saveDocument(document);
+		} catch (error) {
+			const reason = error instanceof Error ? error.message : String(error);
+			const engineError = new DocumentEngineError("SAVE_FAILED", `Storage could not save the document: ${reason}`, { cause: error });
+			events.emit("save:error", { error: engineError });
+			throw engineError;
+		}
+		events.emit("save:success", { document });
+		return document;
+	}
+	function newDocument(newOptions) {
+		ensureUsable();
+		activeLoad?.abort();
+		canvas.clear();
+		objectsById.clear();
+		documentInfo = createDocumentInfo(newOptions);
+	}
+	function getObjectById(id) {
+		ensureUsable();
+		const indexed = objectsById.get(id);
+		if (indexed !== void 0) return indexed;
+		rebuildIndex();
+		return objectsById.get(id);
+	}
+	function destroy() {
+		if (destroyed) return;
+		destroyed = true;
+		activeLoad?.abort();
+		canvas.off("object:added", handleObjectAdded);
+		canvas.off("object:removed", handleObjectRemoved);
+		objectsById.clear();
+		events.clear();
+	}
+	return {
+		canvas,
+		getDocumentInfo: () => ({
+			...documentInfo,
+			metadata: { ...documentInfo.metadata }
+		}),
+		updateMetadata(changes) {
+			ensureUsable();
+			documentInfo = {
+				...documentInfo,
+				metadata: {
+					...documentInfo.metadata,
+					...changes
+				}
+			};
+		},
+		newDocument,
+		toDocument,
+		loadDocument,
+		load,
+		save,
+		registerObject(definition) {
+			ensureUsable();
+			registry.register(definition);
+		},
+		getObjectById,
+		on: (name, handler) => events.on(name, handler),
+		destroy
+	};
+}
+//#endregion
+export { createDocumentEngine };

package/dist/engine/errors.cjs

@@ -0,0 +1,17 @@
+//#region src/engine/errors.ts
+var DocumentEngineError = class extends Error {
+	constructor(code, message, details = {}) {
+		super(message);
+		this.name = "DocumentEngineError";
+		this.code = code;
+		this.issues = details.issues ?? [];
+		this.unknownTypes = details.unknownTypes ?? [];
+		this.cause = details.cause;
+	}
+};
+function isDocumentEngineError(value) {
+	return value instanceof DocumentEngineError;
+}
+//#endregion
+exports.DocumentEngineError = DocumentEngineError;
+exports.isDocumentEngineError = isDocumentEngineError;

package/dist/engine/errors.d.cts

@@ -0,0 +1,21 @@
+//#region src/engine/errors.d.ts
+export type DocumentErrorCode = "INVALID_DOCUMENT" | "UNSUPPORTED_SCHEMA" | "UNKNOWN_OBJECT_TYPE" | "INVALID_CUSTOM_OBJECT" | "LOAD_ABORTED" | "LOAD_FAILED" | "STORAGE_MISSING" | "SAVE_FAILED" | "ENGINE_DESTROYED";
+export interface DocumentIssue {
+  code: DocumentErrorCode;
+  path: string;
+  message: string;
+}
+export interface DocumentEngineErrorDetails {
+  issues?: DocumentIssue[];
+  unknownTypes?: string[];
+  cause?: unknown;
+}
+export declare class DocumentEngineError extends Error {
+  readonly code: DocumentErrorCode;
+  readonly issues: DocumentIssue[];
+  readonly unknownTypes: string[];
+  readonly cause: unknown;
+  constructor(code: DocumentErrorCode, message: string, details?: DocumentEngineErrorDetails);
+}
+export declare function isDocumentEngineError(value: unknown): value is DocumentEngineError;
+//#endregion

package/dist/engine/errors.d.ts

@@ -0,0 +1,21 @@
+//#region src/engine/errors.d.ts
+export type DocumentErrorCode = "INVALID_DOCUMENT" | "UNSUPPORTED_SCHEMA" | "UNKNOWN_OBJECT_TYPE" | "INVALID_CUSTOM_OBJECT" | "LOAD_ABORTED" | "LOAD_FAILED" | "STORAGE_MISSING" | "SAVE_FAILED" | "ENGINE_DESTROYED";
+export interface DocumentIssue {
+  code: DocumentErrorCode;
+  path: string;
+  message: string;
+}
+export interface DocumentEngineErrorDetails {
+  issues?: DocumentIssue[];
+  unknownTypes?: string[];
+  cause?: unknown;
+}
+export declare class DocumentEngineError extends Error {
+  readonly code: DocumentErrorCode;
+  readonly issues: DocumentIssue[];
+  readonly unknownTypes: string[];
+  readonly cause: unknown;
+  constructor(code: DocumentErrorCode, message: string, details?: DocumentEngineErrorDetails);
+}
+export declare function isDocumentEngineError(value: unknown): value is DocumentEngineError;
+//#endregion

package/dist/engine/errors.js

@@ -0,0 +1,16 @@
+//#region src/engine/errors.ts
+var DocumentEngineError = class extends Error {
+	constructor(code, message, details = {}) {
+		super(message);
+		this.name = "DocumentEngineError";
+		this.code = code;
+		this.issues = details.issues ?? [];
+		this.unknownTypes = details.unknownTypes ?? [];
+		this.cause = details.cause;
+	}
+};
+function isDocumentEngineError(value) {
+	return value instanceof DocumentEngineError;
+}
+//#endregion
+export { DocumentEngineError, isDocumentEngineError };

package/dist/engine/event-emitter.cjs

@@ -0,0 +1,24 @@
+//#region src/engine/event-emitter.ts
+function createEventEmitter() {
+	const handlersByName = /* @__PURE__ */ new Map();
+	return {
+		on(name, handler) {
+			const handlers = handlersByName.get(name) ?? /* @__PURE__ */ new Set();
+			handlers.add(handler);
+			handlersByName.set(name, handlers);
+			return () => {
+				handlers.delete(handler);
+			};
+		},
+		emit(name, payload) {
+			const handlers = handlersByName.get(name);
+			if (!handlers) return;
+			for (const handler of [...handlers]) handler(payload);
+		},
+		clear() {
+			handlersByName.clear();
+		}
+	};
+}
+//#endregion
+exports.createEventEmitter = createEventEmitter;

package/dist/engine/event-emitter.d.cts

@@ -0,0 +1,3 @@
+//#region src/engine/event-emitter.d.ts
+export type Unsubscribe = () => void;
+//#endregion

package/dist/engine/event-emitter.d.ts

@@ -0,0 +1,3 @@
+//#region src/engine/event-emitter.d.ts
+export type Unsubscribe = () => void;
+//#endregion

package/dist/engine/event-emitter.js

@@ -0,0 +1,24 @@
+//#region src/engine/event-emitter.ts
+function createEventEmitter() {
+	const handlersByName = /* @__PURE__ */ new Map();
+	return {
+		on(name, handler) {
+			const handlers = handlersByName.get(name) ?? /* @__PURE__ */ new Set();
+			handlers.add(handler);
+			handlersByName.set(name, handlers);
+			return () => {
+				handlers.delete(handler);
+			};
+		},
+		emit(name, payload) {
+			const handlers = handlersByName.get(name);
+			if (!handlers) return;
+			for (const handler of [...handlers]) handler(payload);
+		},
+		clear() {
+			handlersByName.clear();
+		}
+	};
+}
+//#endregion
+export { createEventEmitter };

package/dist/fabric/fabric-adapter.cjs

@@ -0,0 +1,68 @@
+const require_walk_objects = require("./walk-objects.cjs");
+//#region src/fabric/fabric-adapter.ts
+function keepOriginExplicit(liveObjects, serializedObjects) {
+	const pending = [];
+	serializedObjects.forEach((serialized, index) => {
+		const live = liveObjects[index];
+		if (live) pending.push([live, serialized]);
+	});
+	while (pending.length > 0) {
+		const [live, serialized] = pending.pop();
+		serialized.originX ?? (serialized.originX = live.originX);
+		serialized.originY ?? (serialized.originY = live.originY);
+		const liveChildren = require_walk_objects.childrenOf(live);
+		serialized.objects?.forEach((child, index) => {
+			const liveChild = liveChildren[index];
+			if (liveChild) pending.push([liveChild, child]);
+		});
+	}
+}
+function serializeCanvas(canvas, propertiesToInclude) {
+	const serialized = canvas.toObject(propertiesToInclude);
+	const objects = serialized.objects ?? [];
+	keepOriginExplicit(canvas.getObjects(), objects);
+	return {
+		version: serialized.version,
+		background: serialized.background,
+		objects
+	};
+}
+function countSerializedTree(root) {
+	let count = 0;
+	const pending = [root];
+	while (pending.length > 0) {
+		const object = pending.pop();
+		count += 1;
+		if (object.objects) pending.push(...object.objects);
+	}
+	return count;
+}
+function countLiveTree(root) {
+	let count = 0;
+	require_walk_objects.walkObjects([root], () => {
+		count += 1;
+	});
+	return count;
+}
+function describeObject(serialized) {
+	return serialized.id ? `"${serialized.type}" object ${serialized.id}` : `"${serialized.type}" object`;
+}
+function refuseMissingObjects(serialized, created, error) {
+	if (error !== void 0 || created === void 0) {
+		const reason = error instanceof Error ? error.message : String(error ?? "unknown reason");
+		throw new Error(`The ${describeObject(serialized)} could not be created: ${reason}`);
+	}
+	const expected = countSerializedTree(serialized);
+	const actual = countLiveTree(created);
+	if (actual !== expected) throw new Error(`Only ${actual} of ${expected} objects inside the ${describeObject(serialized)} could be created`);
+}
+async function loadIntoCanvas(canvas, content, signal) {
+	const json = { objects: content.objects };
+	if (content.version !== void 0) json.version = content.version;
+	if (content.background !== void 0) json.background = content.background;
+	const reviver = refuseMissingObjects;
+	await canvas.loadFromJSON(json, reviver, { signal });
+}
+//#endregion
+exports.loadIntoCanvas = loadIntoCanvas;
+exports.serializeCanvas = serializeCanvas;

package/dist/fabric/fabric-adapter.js

@@ -0,0 +1,67 @@
+import { childrenOf, walkObjects } from "./walk-objects.js";
+//#region src/fabric/fabric-adapter.ts
+function keepOriginExplicit(liveObjects, serializedObjects) {
+	const pending = [];
+	serializedObjects.forEach((serialized, index) => {
+		const live = liveObjects[index];
+		if (live) pending.push([live, serialized]);
+	});
+	while (pending.length > 0) {
+		const [live, serialized] = pending.pop();
+		serialized.originX ?? (serialized.originX = live.originX);
+		serialized.originY ?? (serialized.originY = live.originY);
+		const liveChildren = childrenOf(live);
+		serialized.objects?.forEach((child, index) => {
+			const liveChild = liveChildren[index];
+			if (liveChild) pending.push([liveChild, child]);
+		});
+	}
+}
+function serializeCanvas(canvas, propertiesToInclude) {
+	const serialized = canvas.toObject(propertiesToInclude);
+	const objects = serialized.objects ?? [];
+	keepOriginExplicit(canvas.getObjects(), objects);
+	return {
+		version: serialized.version,
+		background: serialized.background,
+		objects
+	};
+}
+function countSerializedTree(root) {
+	let count = 0;
+	const pending = [root];
+	while (pending.length > 0) {
+		const object = pending.pop();
+		count += 1;
+		if (object.objects) pending.push(...object.objects);
+	}
+	return count;
+}
+function countLiveTree(root) {
+	let count = 0;
+	walkObjects([root], () => {
+		count += 1;
+	});
+	return count;
+}
+function describeObject(serialized) {
+	return serialized.id ? `"${serialized.type}" object ${serialized.id}` : `"${serialized.type}" object`;
+}
+function refuseMissingObjects(serialized, created, error) {
+	if (error !== void 0 || created === void 0) {
+		const reason = error instanceof Error ? error.message : String(error ?? "unknown reason");
+		throw new Error(`The ${describeObject(serialized)} could not be created: ${reason}`);
+	}
+	const expected = countSerializedTree(serialized);
+	const actual = countLiveTree(created);
+	if (actual !== expected) throw new Error(`Only ${actual} of ${expected} objects inside the ${describeObject(serialized)} could be created`);
+}
+async function loadIntoCanvas(canvas, content, signal) {
+	const json = { objects: content.objects };
+	if (content.version !== void 0) json.version = content.version;
+	if (content.background !== void 0) json.background = content.background;
+	const reviver = refuseMissingObjects;
+	await canvas.loadFromJSON(json, reviver, { signal });
+}
+//#endregion
+export { loadIntoCanvas, serializeCanvas };

package/dist/fabric/object-ids.cjs

@@ -0,0 +1,11 @@
+//#region src/fabric/object-ids.ts
+function readObjectId(object) {
+	const id = object.id;
+	return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function writeObjectId(object, id) {
+	object.id = id;
+}
+//#endregion
+exports.readObjectId = readObjectId;
+exports.writeObjectId = writeObjectId;

package/dist/fabric/object-ids.js

@@ -0,0 +1,10 @@
+//#region src/fabric/object-ids.ts
+function readObjectId(object) {
+	const id = object.id;
+	return typeof id === "string" && id.length > 0 ? id : void 0;
+}
+function writeObjectId(object, id) {
+	object.id = id;
+}
+//#endregion
+export { readObjectId, writeObjectId };

package/dist/fabric/object-registry.cjs

@@ -0,0 +1,21 @@
+const require_errors = require("../engine/errors.cjs");
+let fabric = require("fabric");
+//#region src/fabric/object-registry.ts
+function createObjectRegistry(initialDefinitions = []) {
+	const extraProperties = /* @__PURE__ */ new Set(["id"]);
+	function register(definition) {
+		const { fabricClass } = definition;
+		if (typeof fabricClass?.type !== "string" || fabricClass.type.length === 0) throw new require_errors.DocumentEngineError("INVALID_CUSTOM_OBJECT", "A custom object class needs a static \"type\" string, for example: static type = \"Sticker\"");
+		if (typeof fabricClass.fromObject !== "function") throw new require_errors.DocumentEngineError("INVALID_CUSTOM_OBJECT", `Custom object "${fabricClass.type}" must extend a Fabric class so it has a static fromObject method`);
+		fabric.classRegistry.setClass(fabricClass);
+		for (const property of definition.properties ?? []) extraProperties.add(property);
+	}
+	initialDefinitions.forEach(register);
+	return {
+		register,
+		propertiesToInclude: () => [...extraProperties],
+		findUnknownTypes: (types) => [...types].filter((type) => !fabric.classRegistry.has(type))
+	};
+}
+//#endregion
+exports.createObjectRegistry = createObjectRegistry;

package/dist/fabric/object-registry.d.cts

@@ -0,0 +1,9 @@
+//#region src/fabric/object-registry.d.ts
+export interface CustomObjectDefinition {
+  fabricClass: {
+    type: string;
+    fromObject?: unknown;
+  };
+  properties?: string[];
+}
+//#endregion

package/dist/fabric/object-registry.d.ts

@@ -0,0 +1,9 @@
+//#region src/fabric/object-registry.d.ts
+export interface CustomObjectDefinition {
+  fabricClass: {
+    type: string;
+    fromObject?: unknown;
+  };
+  properties?: string[];
+}
+//#endregion