fabricjs-document-engine 0.2.0 → 0.4.0

package/README.md

@@ -10,6 +10,8 @@ Fabric already draws objects, handles interaction and serializes to JSON. This p
 - **Custom objects.** Register your own Fabric classes and the extra properties they need to keep.
 - **Safe saving.** It tracks unsaved changes and can autosave. Only one save runs at a time, so a slow older save can never overwrite newer work. Revision checks catch another tab or device saving the same document, and failed saves are retried with backoff.
 - **Your storage.** Plug in any backend with two functions, or use the built-in memory and localStorage adapters. No hosted service is needed.
+- **Assets and fonts.** Documents record the images and fonts they need. When a document is opened, every image and font is checked first. You get the exact list of what is missing, can offer replacements, and tab-only images are uploaded when you save.
+- **Recovery.** Unsaved work is copied to IndexedDB while the user edits, and again at the moment the tab is closed or refreshed. After a crash or refresh you can offer to restore it, including images that only existed in the old tab.
 - **Reliable undo and redo.** One user action is one undo step. Transactions group several code changes into one labelled step, and ids survive undo and redo.
 - **Fabric 6 and 7.** Every release is tested against both.
 
@@ -121,6 +123,87 @@ import { bindUnsavedChangesWarning } from 'fabricjs-document-engine';
 const unbind = bindUnsavedChangesWarning(engine);
 ```
 
+## Assets and fonts
+
+Every saved document carries an `assets` manifest that lists each image URL and font variant, together with the ids of the objects that use them. Images embedded as `data:` URLs are left out of the manifest because they need no fetching.
+
+```ts
+const engine = createDocumentEngine({
+  canvas,
+  storage,
+  assets: {
+    resolveUrl: (url) => url.replace('asset://', 'https://cdn.example.com/'),
+    replaceMissingImage: (image) => '/placeholder.png',
+    upload: async ({ blob }) => uploadToYourBucket(blob),
+    loadFont: async ({ family, weight, style }) => {
+      const face = new FontFace(family, `url(/fonts/${family}-${weight}.woff2)`, { weight, style });
+      document.fonts.add(await face.load());
+    },
+    requireFonts: false,
+  },
+});
+
+engine.on('assets:warning', ({ warnings }) => warnings.forEach((warning) => console.warn(warning.message)));
+```
+
+### When a document is opened
+
+1. `resolveUrl` can rewrite each stored URL, for example to sign it or to map asset ids to a CDN.
+2. `loadFont` runs for each font variant. Then the engine checks that the font really renders, rather than silently falling back to a default.
+3. Every image loads in parallel. If any are missing, `replaceMissingImage` can supply a replacement URL for each one. Return `null` to leave it missing.
+4. If images are still missing, loading fails with `MISSING_ASSETS`, and `error.missingAssets` lists each `{ url, objectIds }`. The canvas is not touched.
+
+Fonts that are not available produce a `FONT_UNAVAILABLE` warning and the text uses a fallback font. Set `requireFonts: true` to fail with `MISSING_FONTS` instead. Warnings are also delivered with `load:success` as `{ document, warnings }`.
+
+### When a document is saved
+
+Images that exist only in this tab (`blob:` URLs) and embedded `data:` images are passed to `upload` once, and the document stores the returned URL. Without an `upload` handler, `blob:` images produce an `ASSET_NOT_PORTABLE` warning, because another device cannot open them.
+
+### Cross-origin images
+
+An image from another site without `crossOrigin: 'anonymous'` taints the canvas, and exporting it will fail. The engine warns with `IMAGE_CROSS_ORIGIN` so you can fix it before the user tries to export.
+
+### Checking and replacing at any time
+
+```ts
+const report = await engine.checkAssets();
+report.missingImages;
+report.unavailableFonts;
+report.warnings;
+
+await engine.replaceImage('/old-logo.png', '/new-logo.png');
+```
+
+`replaceImage` swaps every image that uses a URL. Each image keeps its size on the page, and the change is one undo step. `engine.getAssetManifest()` returns the manifest for the current canvas.
+
+## Recovery
+
+```ts
+import { createIndexedDbRecovery } from 'fabricjs-document-engine/recovery';
+
+const engine = createDocumentEngine({
+  canvas,
+  storage,
+  recovery: { store: createIndexedDbRecovery(), interval: 2000 },
+});
+
+const [latest] = await engine.getRecoverableDocuments();
+if (latest && confirm(`Restore unsaved work from ${new Date(latest.savedAt).toLocaleString()}?`)) {
+  await engine.restoreRecovery(latest.documentId);
+} else if (latest) {
+  await engine.discardRecovery(latest.documentId);
+}
+```
+
+- **Checkpoints.** While there are unsaved changes, a copy is written at most once every `interval` ms (default 2000). Nothing is written while the document is saved.
+- **Closing or refreshing.** Browsers do not let IndexedDB finish writing while a page unloads. So when the tab is hidden or closed, the engine also writes an immediate copy to localStorage. The newest copy wins when you read it back.
+- **Tab-only images.** Images with `blob:` URLs vanish on refresh. Checkpoints keep the image data, and restoring creates fresh URLs for it.
+- **After a save.** When a save covers every change, the copy is removed. If the tab closes during a save, the copy stays, so work is never lost between the edit and the server.
+- **Restoring.** The restored document is marked as unsaved and keeps the revision it was based on. If the server moved on meanwhile, the next save reports `SAVE_CONFLICT` instead of overwriting newer work.
+- **Interrupted loads.** A marker is kept while a document loads. If the tab crashes during loading, `engine.getInterruptedLoad()` returns `{ documentId, startedAt }` on the next start, so you can skip or discard that document instead of crashing again.
+- `engine.flushRecovery()` writes a copy right now. `engine.getRecovery(id?)` reads one.
+- `createMemoryRecovery()` keeps copies in memory, which is useful for tests. To use your own storage, implement `{ get, set, delete, keys }`, plus an optional synchronous `setNow` for the moment the page closes.
+
 ## Custom objects
 
 ```ts
@@ -199,6 +282,10 @@ interface FabricDocument {
   fabricVersion?: string;
   canvas: { width: number; height: number; background?: unknown };
   objects: SerializedFabricObject[];
+  assets?: {
+    images: Array<{ url: string; objectIds: string[] }>;
+    fonts: Array<{ family: string; weight: string; style: string; objectIds: string[] }>;
+  };
   metadata: Record<string, unknown>;
 }
 ```
@@ -221,6 +308,13 @@ Keep project data such as titles, owners and tags in `metadata` with `engine.upd
 | `engine.updateMetadata(changes)` | Merges changes into the document metadata. |
 | `engine.getObjectById(id)` | Finds any object by id, including objects inside groups. |
 | `engine.registerObject({ fabricClass, properties })` | Registers a custom class after the engine is created. |
+| `engine.getAssetManifest()` | Lists the images and fonts used on the canvas. |
+| `engine.checkAssets()` | Resolves to `{ manifest, missingImages, unavailableFonts, warnings }` for the current canvas. |
+| `engine.replaceImage(oldUrl, newUrl)` | Replaces every image with that URL as one undo step. Resolves to the number of images replaced. |
+| `engine.getRecoverableDocuments()` | Lists recovery copies, newest first. |
+| `engine.restoreRecovery(id?)` / `engine.discardRecovery(id?)` | Loads or deletes a recovery copy. The default is the current document. |
+| `engine.getRecovery(id?)` / `engine.flushRecovery()` | Reads a copy, or writes one now. |
+| `engine.getInterruptedLoad()` | Returns the load that was running when the tab last crashed, if any. |
 | `engine.transaction(label, work)` | Runs `work` and records everything it changed as one undo step. Returns what `work` returns. |
 | `engine.commit(label?)` | Records changes made since the last step. Returns `false` when nothing changed. |
 | `engine.undo()` / `engine.redo()` | Resolves to `true` when a step was applied. Calls run one after another. |
@@ -228,7 +322,7 @@ Keep project data such as titles, owners and tags in `metadata` with `engine.upd
 | `engine.getHistory()` | Returns `{ undo, redo }` label lists, newest first. |
 | `engine.clearHistory()` | Forgets all steps. Loading a document or starting a new one also does this. |
 | `bindKeyboardShortcuts(engine, { target? })` | Adds the undo and redo shortcuts. Returns an unbind function. |
-| `engine.on(event, handler)` | Listens to `load:start`, `load:success`, `load:error`, `save:start`, `save:success`, `save:error`, `save:retry`, `save:status`, `history:change` or `history:error`. Returns an unsubscribe function. |
+| `engine.on(event, handler)` | Listens to `load:start`, `load:success`, `load:error`, `save:start`, `save:success`, `save:error`, `save:retry`, `save:status`, `assets:warning`, `recovery:checkpoint`, `recovery:restored`, `recovery:error`, `history:change` or `history:error`. Returns an unsubscribe function. |
 | `engine.destroy()` | Stops listening to the canvas and cancels a running load. |
 | `validateDocument(value)` | Returns a list of issues with the exact path of each problem. |
 
@@ -243,11 +337,17 @@ Every failure is a `DocumentEngineError` with a `code` you can switch on:
 | `UNKNOWN_OBJECT_TYPE` | A type is not registered. `error.unknownTypes` lists them. |
 | `LOAD_FAILED` | Fabric or your storage could not load the document, for example because an image is missing. `error.cause` holds the original error. |
 | `LOAD_ABORTED` | A newer load started before this one finished. |
+| `MISSING_ASSETS` | Images could not be loaded and had no replacement. `error.missingAssets` lists each `{ url, objectIds }`. |
+| `MISSING_FONTS` | Fonts are not available and `requireFonts` is on. `error.missingFonts` lists them. |
+| `ASSET_UPLOAD_FAILED` | Your `upload` handler failed while saving. |
 | `SAVE_FAILED` | Your storage adapter rejected the save after all retries. `error.retryable` tells you whether trying again could help. |
 | `SAVE_CONFLICT` | Another tab or device saved this document first. |
 | `SAVE_CANCELLED` | A queued save was dropped because another document was opened. |
 | `DOCUMENT_NOT_FOUND` | The built-in adapters have no document with that id. |
 | `HISTORY_FAILED` | Undo or redo could not rebuild an object, for example because an image is gone. The step is kept and the canvas is unchanged. |
+| `RECOVERY_MISSING` | A recovery method was called without `recovery: { store }`. |
+| `RECOVERY_NOT_FOUND` | There is no recovery copy for that document. |
+| `RECOVERY_FAILED` | Writing a recovery copy failed, for example because storage is full. It is delivered as a `recovery:error` event and never interrupts editing. |
 | `STORAGE_MISSING` | `load` or `save` was called without a storage adapter. |
 | `INVALID_CUSTOM_OBJECT` | A registered class has no static `type`, or it does not extend a Fabric class. |
 | `ENGINE_DESTROYED` | The engine was used after `destroy()`. |
@@ -256,18 +356,18 @@ A failed load never clears or half-fills your canvas.
 
 ## Roadmap
 
-| Version | Focus |
-| --- | --- |
-| 0.1 ✓ | Document foundation: ids, save and load, validation, custom objects |
-| 0.2 ✓ | Undo and redo with transactions |
-| 0.3 ✓ | Safe saving: dirty state, autosave, stale-response protection |
-| 0.4 | Assets and fonts |
-| 0.5 | Recovery after a refresh or crash |
-| 0.6 | PNG, JPEG, SVG and JSON export with preflight checks |
-| 0.7 | Named versions and schema migrations |
-| 0.8 | React adapter and examples |
-| 0.9 | Hardening and benchmarks |
-| 1.0 | Stable API |
+| Stage | Focus | Released in |
+| --- | --- | --- |
+| 1 | Document foundation: ids, save and load, validation, custom objects | 0.0.0 |
+| 2 | Undo and redo with transactions | 0.1.0 |
+| 3 | Safe saving: dirty state, autosave, stale-response protection | 0.2.0 |
+| 4 | Assets and fonts | 0.3.0 |
+| 5 | Recovery after a refresh or crash | 0.4.0 |
+| 6 | PNG, JPEG, SVG and JSON export with preflight checks | |
+| 7 | Named versions and schema migrations | |
+| 8 | React adapter and examples | |
+| 9 | Hardening and benchmarks | |
+| 10 | Stable API | 1.0.0 |
 
 ## License
 

package/dist/assets/asset-manifest.cjs

@@ -0,0 +1,43 @@
+const require_asset_references = require("./asset-references.cjs");
+//#region src/assets/asset-manifest.ts
+function isEmbeddedUrl(url) {
+	return url.startsWith("data:");
+}
+function fontKey(font) {
+	return `${font.style}|${font.weight}|${font.family}`;
+}
+function addObjectId(objectIds, objectId) {
+	if (objectId !== void 0 && !objectIds.includes(objectId)) objectIds.push(objectId);
+}
+function buildAssetManifest(objects) {
+	const imagesByUrl = /* @__PURE__ */ new Map();
+	for (const reference of require_asset_references.findImageReferences(objects)) {
+		if (isEmbeddedUrl(reference.url)) continue;
+		const image = imagesByUrl.get(reference.url) ?? {
+			url: reference.url,
+			objectIds: []
+		};
+		addObjectId(image.objectIds, reference.objectId);
+		imagesByUrl.set(reference.url, image);
+	}
+	const fontsByKey = /* @__PURE__ */ new Map();
+	for (const reference of require_asset_references.findFontReferences(objects)) {
+		const key = fontKey(reference);
+		const font = fontsByKey.get(key) ?? {
+			family: reference.family,
+			weight: reference.weight,
+			style: reference.style,
+			objectIds: []
+		};
+		addObjectId(font.objectIds, reference.objectId);
+		fontsByKey.set(key, font);
+	}
+	return {
+		images: [...imagesByUrl.values()],
+		fonts: [...fontsByKey.values()]
+	};
+}
+//#endregion
+exports.buildAssetManifest = buildAssetManifest;
+exports.fontKey = fontKey;
+exports.isEmbeddedUrl = isEmbeddedUrl;

package/dist/assets/asset-manifest.d.cts

@@ -0,0 +1,16 @@
+//#region src/assets/asset-manifest.d.ts
+export interface ImageAsset {
+  url: string;
+  objectIds: string[];
+}
+export interface FontAsset {
+  family: string;
+  weight: string;
+  style: string;
+  objectIds: string[];
+}
+export interface AssetManifest {
+  images: ImageAsset[];
+  fonts: FontAsset[];
+}
+//#endregion

package/dist/assets/asset-manifest.d.ts

@@ -0,0 +1,16 @@
+//#region src/assets/asset-manifest.d.ts
+export interface ImageAsset {
+  url: string;
+  objectIds: string[];
+}
+export interface FontAsset {
+  family: string;
+  weight: string;
+  style: string;
+  objectIds: string[];
+}
+export interface AssetManifest {
+  images: ImageAsset[];
+  fonts: FontAsset[];
+}
+//#endregion

package/dist/assets/asset-manifest.js

@@ -0,0 +1,41 @@
+import { findFontReferences, findImageReferences } from "./asset-references.js";
+//#region src/assets/asset-manifest.ts
+function isEmbeddedUrl(url) {
+	return url.startsWith("data:");
+}
+function fontKey(font) {
+	return `${font.style}|${font.weight}|${font.family}`;
+}
+function addObjectId(objectIds, objectId) {
+	if (objectId !== void 0 && !objectIds.includes(objectId)) objectIds.push(objectId);
+}
+function buildAssetManifest(objects) {
+	const imagesByUrl = /* @__PURE__ */ new Map();
+	for (const reference of findImageReferences(objects)) {
+		if (isEmbeddedUrl(reference.url)) continue;
+		const image = imagesByUrl.get(reference.url) ?? {
+			url: reference.url,
+			objectIds: []
+		};
+		addObjectId(image.objectIds, reference.objectId);
+		imagesByUrl.set(reference.url, image);
+	}
+	const fontsByKey = /* @__PURE__ */ new Map();
+	for (const reference of findFontReferences(objects)) {
+		const key = fontKey(reference);
+		const font = fontsByKey.get(key) ?? {
+			family: reference.family,
+			weight: reference.weight,
+			style: reference.style,
+			objectIds: []
+		};
+		addObjectId(font.objectIds, reference.objectId);
+		fontsByKey.set(key, font);
+	}
+	return {
+		images: [...imagesByUrl.values()],
+		fonts: [...fontsByKey.values()]
+	};
+}
+//#endregion
+export { buildAssetManifest, fontKey, isEmbeddedUrl };

package/dist/assets/asset-pipeline.cjs

@@ -0,0 +1,175 @@
+const require_asset_references = require("./asset-references.cjs");
+const require_asset_manifest = require("./asset-manifest.cjs");
+const require_errors = require("../engine/errors.cjs");
+const require_font_check = require("./font-check.cjs");
+const require_image_check = require("./image-check.cjs");
+//#region src/assets/asset-pipeline.ts
+function cloneDocument(document) {
+	return JSON.parse(JSON.stringify(document));
+}
+function groupByUrl(references) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const reference of references) {
+		const group = groups.get(reference.url) ?? [];
+		group.push(reference);
+		groups.set(reference.url, group);
+	}
+	return groups;
+}
+function objectIdsOf(references) {
+	return [...new Set(references.map((reference) => reference.objectId).filter((id) => id !== void 0))];
+}
+function pointTo(references, url) {
+	for (const reference of references) {
+		reference.holder[reference.key] = url;
+		reference.url = url;
+	}
+}
+async function rewriteUrls(document, rewrite) {
+	const groups = groupByUrl(require_asset_references.findImageReferences(document.objects));
+	await Promise.all([...groups].map(async ([url, references]) => {
+		const next = await rewrite(url, references);
+		if (next !== url) pointTo(references, next);
+	}));
+}
+function crossOriginWarnings(document) {
+	const warnings = [];
+	for (const [url, references] of groupByUrl(require_asset_references.findImageReferences(document.objects))) {
+		if (!require_image_check.isCrossOriginUrl(url) || references.every((reference) => reference.crossOrigin)) continue;
+		warnings.push({
+			code: "IMAGE_CROSS_ORIGIN",
+			message: `The image ${url} comes from another site without crossOrigin set, so exporting the canvas will fail`,
+			url,
+			objectIds: objectIdsOf(references)
+		});
+	}
+	return warnings;
+}
+function fontWarnings(fonts) {
+	return fonts.map((font) => ({
+		code: "FONT_UNAVAILABLE",
+		message: `The font "${font.family}" (${font.weight}, ${font.style}) is not available, text will use a fallback font`,
+		family: font.family,
+		objectIds: font.objectIds
+	}));
+}
+async function inspectAssets(document, options, signal) {
+	const manifest = require_asset_manifest.buildAssetManifest(document.objects);
+	const uniqueImages = [...groupByUrl(require_asset_references.findImageReferences(document.objects).filter((reference) => !require_asset_manifest.isEmbeddedUrl(reference.url)))].map(([url, references]) => ({
+		url,
+		crossOrigin: references[0].crossOrigin
+	}));
+	const [missingUrls, unavailableFonts] = await Promise.all([options.checkImages === false ? Promise.resolve([]) : require_image_check.findMissingImages(uniqueImages, signal), require_font_check.findUnavailableFonts(manifest.fonts, options.loadFont)]);
+	const missing = new Set(missingUrls);
+	return {
+		manifest,
+		missingImages: manifest.images.filter((image) => missing.has(image.url)),
+		unavailableFonts,
+		warnings: [...crossOriginWarnings(document), ...fontWarnings(unavailableFonts)]
+	};
+}
+async function replaceMissingImages(document, missingImages, options, signal) {
+	const replace = options.replaceMissingImage;
+	if (!replace || missingImages.length === 0) return {
+		stillMissing: [...missingImages],
+		warnings: []
+	};
+	const replacements = /* @__PURE__ */ new Map();
+	for (const image of missingImages) {
+		const replacement = await replace(image);
+		if (typeof replacement === "string" && replacement.length > 0) replacements.set(image.url, replacement);
+	}
+	const brokenReplacements = new Set(await require_image_check.findMissingImages([...replacements.values()].map((url) => ({
+		url,
+		crossOrigin: null
+	})), signal));
+	const stillMissing = [];
+	const warnings = [];
+	const groups = groupByUrl(require_asset_references.findImageReferences(document.objects));
+	for (const image of missingImages) {
+		const replacement = replacements.get(image.url);
+		if (replacement === void 0 || brokenReplacements.has(replacement)) {
+			stillMissing.push(image);
+			continue;
+		}
+		pointTo(groups.get(image.url) ?? [], replacement);
+		warnings.push({
+			code: "IMAGE_REPLACED",
+			message: `The missing image ${image.url} was replaced with ${replacement}`,
+			url: image.url,
+			objectIds: image.objectIds
+		});
+	}
+	return {
+		stillMissing,
+		warnings
+	};
+}
+async function prepareAssetsForLoad(input, options, signal) {
+	const document = cloneDocument(input);
+	const { resolveUrl } = options;
+	if (resolveUrl) await rewriteUrls(document, async (url) => resolveUrl(url));
+	const report = await inspectAssets(document, options, signal);
+	if (options.requireFonts && report.unavailableFonts.length > 0) {
+		const families = report.unavailableFonts.map((font) => font.family).join(", ");
+		throw new require_errors.DocumentEngineError("MISSING_FONTS", `These fonts are not available: ${families}`, { missingFonts: report.unavailableFonts });
+	}
+	const { stillMissing, warnings } = await replaceMissingImages(document, report.missingImages, options, signal);
+	if (stillMissing.length > 0) {
+		const urls = stillMissing.map((image) => image.url).join(", ");
+		throw new require_errors.DocumentEngineError("MISSING_ASSETS", `These images could not be loaded: ${urls}`, { missingAssets: stillMissing });
+	}
+	return {
+		document,
+		warnings: [...report.warnings, ...warnings]
+	};
+}
+async function uploadOnce(url, references, upload) {
+	try {
+		return await upload({
+			url,
+			blob: await (await fetch(url)).blob(),
+			objectIds: objectIdsOf(references)
+		});
+	} catch (error) {
+		if (require_errors.isDocumentEngineError(error)) throw error;
+		const reason = error instanceof Error ? error.message : String(error);
+		throw new require_errors.DocumentEngineError("ASSET_UPLOAD_FAILED", `Could not upload the image ${url.slice(0, 60)}: ${reason}`, {
+			cause: error,
+			retryable: true
+		});
+	}
+}
+async function prepareAssetsForSave(document, options, uploadedUrls) {
+	const { upload } = options;
+	const warnings = [];
+	await rewriteUrls(document, async (url, references) => {
+		if (!(url.startsWith("blob:") || url.startsWith("data:"))) return url;
+		if (!upload) {
+			if (!require_image_check.isPortableUrl(url)) warnings.push({
+				code: "ASSET_NOT_PORTABLE",
+				message: `The image ${url} only exists in this browser tab. Pass assets.upload to store it before saving.`,
+				url,
+				objectIds: objectIdsOf(references)
+			});
+			return url;
+		}
+		let uploading = uploadedUrls.get(url);
+		if (!uploading) {
+			uploading = uploadOnce(url, references, upload);
+			uploadedUrls.set(url, uploading);
+			uploading.catch(() => uploadedUrls.delete(url));
+		}
+		return uploading;
+	});
+	document.assets = require_asset_manifest.buildAssetManifest(document.objects);
+	return {
+		document,
+		warnings
+	};
+}
+//#endregion
+exports.inspectAssets = inspectAssets;
+exports.prepareAssetsForLoad = prepareAssetsForLoad;
+exports.prepareAssetsForSave = prepareAssetsForSave;
+exports.rewriteUrls = rewriteUrls;

package/dist/assets/asset-pipeline.d.cts

@@ -0,0 +1,31 @@
+import { AssetManifest, FontAsset, ImageAsset } from "./asset-manifest.cjs";
+import { FontLoader } from "./font-check.cjs";
+//#region src/assets/asset-pipeline.d.ts
+export type AssetWarningCode = "IMAGE_CROSS_ORIGIN" | "FONT_UNAVAILABLE" | "ASSET_NOT_PORTABLE" | "IMAGE_REPLACED";
+export interface AssetWarning {
+  code: AssetWarningCode;
+  message: string;
+  url?: string;
+  family?: string;
+  objectIds: string[];
+}
+export interface UploadRequest {
+  url: string;
+  blob: Blob;
+  objectIds: string[];
+}
+export interface AssetOptions {
+  resolveUrl?: (url: string) => string | Promise<string>;
+  replaceMissingImage?: (image: ImageAsset) => string | null | undefined | Promise<string | null | undefined>;
+  upload?: (request: UploadRequest) => Promise<string>;
+  loadFont?: FontLoader;
+  checkImages?: boolean;
+  requireFonts?: boolean;
+}
+export interface AssetReport {
+  manifest: AssetManifest;
+  missingImages: ImageAsset[];
+  unavailableFonts: FontAsset[];
+  warnings: AssetWarning[];
+}
+//#endregion

package/dist/assets/asset-pipeline.d.ts

@@ -0,0 +1,31 @@
+import { AssetManifest, FontAsset, ImageAsset } from "./asset-manifest.js";
+import { FontLoader } from "./font-check.js";
+//#region src/assets/asset-pipeline.d.ts
+export type AssetWarningCode = "IMAGE_CROSS_ORIGIN" | "FONT_UNAVAILABLE" | "ASSET_NOT_PORTABLE" | "IMAGE_REPLACED";
+export interface AssetWarning {
+  code: AssetWarningCode;
+  message: string;
+  url?: string;
+  family?: string;
+  objectIds: string[];
+}
+export interface UploadRequest {
+  url: string;
+  blob: Blob;
+  objectIds: string[];
+}
+export interface AssetOptions {
+  resolveUrl?: (url: string) => string | Promise<string>;
+  replaceMissingImage?: (image: ImageAsset) => string | null | undefined | Promise<string | null | undefined>;
+  upload?: (request: UploadRequest) => Promise<string>;
+  loadFont?: FontLoader;
+  checkImages?: boolean;
+  requireFonts?: boolean;
+}
+export interface AssetReport {
+  manifest: AssetManifest;
+  missingImages: ImageAsset[];
+  unavailableFonts: FontAsset[];
+  warnings: AssetWarning[];
+}
+//#endregion