@embedpdf/plugin-stamp 3.0.0-next.12 → 3.0.0-next.13

package/dist/index.js

@@ -1,9 +1,10 @@
-import { a as assetIdFor, c as stampKey, d as stampPieceInfo, i as STAMP_PIECEINFO_VERSION, l as stampKindToPdfName, n as STAMP_LIBRARY_PIECEINFO_APP, o as customStampName, r as STAMP_PIECEINFO_APP, s as parseStampKey, t as StampToken, u as stampLibraryPieceInfo } from "./contract-BFCBVNRX.js";
+import { a as STAMP_PIECEINFO_VERSION, c as libraryKindFromPdfName, d as stampKey, f as stampKindToPdfName, i as STAMP_PIECEINFO_APP, l as libraryKindToPdfName, m as stampPieceInfo, n as DEFAULT_LIBRARY_KIND, o as assetIdFor, p as stampLibraryPieceInfo, r as STAMP_LIBRARY_PIECEINFO_APP, s as customStampName, t as StampToken, u as parseStampKey } from "./contract-B79Onij2.js";
 import { createEventHook, definePlugin } from "@embedpdf/core";
 import { EngineError, EngineErrorCode, resolveBinarySource, sniffBinaryMetadata } from "@embedpdf/engine-core/runtime";
 import { javaScriptProgramFromActionTree } from "@embedpdf/core-acrojs";
 import { ActionsToken } from "@embedpdf/plugin-actions/contract/host";
 import { AnnotationToken } from "@embedpdf/plugin-annotation/contract";
+import { AnnotationToken as AnnotationToken$1 } from "@embedpdf/plugin-annotation/contract/host";
 import { createFormScriptingController } from "@embedpdf/plugin-form/scripting";
 //#region src/blank-library.ts
 /**
@@ -37,6 +38,51 @@ function blankLibraryPdf() {
 //#endregion
 //#region src/capability.ts
 const DEFAULT_PREVIEW_WIDTH = 256;
+/** `#rrggbb` → the engine's sRGB triplet. */
+const hexColor = (hex) => {
+	const m = /^#?([0-9a-f]{6})$/i.exec(hex.trim());
+	if (!m) throw new EngineError(EngineErrorCode.InvalidArg, `[stamp] mark color must be #rrggbb, got '${hex}'`);
+	const n = parseInt(m[1], 16);
+	return {
+		r: n >> 16 & 255,
+		g: n >> 8 & 255,
+		b: n & 255
+	};
+};
+/** An exact ArrayBuffer over a view (the engine's binary idiom). */
+const toArrayBuffer = (bytes) => {
+	const out = new ArrayBuffer(bytes.byteLength);
+	new Uint8Array(out).set(bytes);
+	return out;
+};
+/** The rect an ink mark occupies, padded by its stroke. */
+const inkBounds = (strokes, strokeWidth) => {
+	let left = Infinity;
+	let bottom = Infinity;
+	let right = -Infinity;
+	let top = -Infinity;
+	for (const stroke of strokes) for (const { x, y } of stroke) {
+		if (x < left) left = x;
+		if (x > right) right = x;
+		if (y < bottom) bottom = y;
+		if (y > top) top = y;
+	}
+	if (!Number.isFinite(left)) throw new EngineError(EngineErrorCode.InvalidArg, "[stamp] an ink mark needs at least one point");
+	const pad = strokeWidth;
+	return {
+		left: left - pad,
+		bottom: bottom - pad,
+		right: right + pad,
+		top: top + pad
+	};
+};
+/** A generous box for typed text; the export crops to the glyphs. */
+const textBounds = (text, fontSize) => ({
+	left: 0,
+	bottom: 0,
+	right: Math.max(1, text.length) * fontSize * .75 + fontSize,
+	top: fontSize * 1.6
+});
 /** Session-unique ids. Assets are session-scoped for now (no persistence),
 *  so a timestamp + counter is enough — durable ids come with the store port. */
 let seq = 0;
@@ -128,6 +174,7 @@ function createStampCapability(ctx, config = {}) {
 		format: "png"
 	}));
 	const createLibrary = async (name, opts) => {
+		const kind = opts?.kind ?? "stamps";
 		const taken = new Set(Object.keys(ctx.getState().libraries));
 		const id = allocateId(opts?.id, "stamp-lib", taken);
 		const doc = await openAssetDocument(blankLibraryPdf());
@@ -135,7 +182,10 @@ function createStampCapability(ctx, config = {}) {
 		try {
 			requireCanonicalServices(doc);
 			await doc.metadata.update({ title: name });
-			await doc.pieceInfo.update(STAMP_LIBRARY_PIECEINFO_APP, stampLibraryPieceInfo(id, { categories: opts?.categories }));
+			await doc.pieceInfo.update(STAMP_LIBRARY_PIECEINFO_APP, stampLibraryPieceInfo(id, {
+				kind,
+				categories: opts?.categories
+			}));
 			bytes = await doc.download();
 		} finally {
 			await doc.close();
@@ -146,6 +196,7 @@ function createStampCapability(ctx, config = {}) {
 			library: {
 				id,
 				name,
+				kind,
 				assetIds: [],
 				...opts?.categories ? { categories: opts.categories } : {}
 			}
@@ -179,6 +230,7 @@ function createStampCapability(ctx, config = {}) {
 			if (!docMeta.title) await doc.metadata.update({ title: libraryName });
 			const libraryCategories = opts?.categories ?? entryStringArray(catalogEntries, "Categories");
 			const libraryLocale = entryString(catalogEntries, "Locale");
+			const libraryKind = opts?.libraryKind ?? libraryKindFromPdfName(entryName(catalogEntries, "Kind"));
 			const registry = (layout.namedPages ?? []).filter((entry) => entry.target.kind === "page");
 			const hidden = (layout.namedPages ?? []).filter((entry) => entry.target.kind !== "page");
 			if (hidden.length > 0) globalThis.console?.warn(`[stamp] library '${libraryName}' carries ${hidden.length} hidden-template or dangling registration(s); they are not stamps and were ignored`);
@@ -219,6 +271,7 @@ function createStampCapability(ctx, config = {}) {
 				});
 			}
 			await doc.pieceInfo.update(STAMP_LIBRARY_PIECEINFO_APP, stampLibraryPieceInfo(libraryId, {
+				kind: libraryKind,
 				categories: libraryCategories,
 				locale: libraryLocale
 			}));
@@ -260,6 +313,7 @@ function createStampCapability(ctx, config = {}) {
 				library: {
 					id: libraryId,
 					name: libraryName,
+					kind: libraryKind,
 					...libraryLocale ? { locale: libraryLocale } : {},
 					categories: libraryCategories,
 					assetIds: []
@@ -291,9 +345,76 @@ function createStampCapability(ctx, config = {}) {
 		});
 		return imported.library.id;
 	};
+	/**
+	* A drawn or typed mark rendered to a one-page PDF: the annotation is
+	* authored on a scratch page and exported the way "stamp from selection"
+	* exports — a fresh page the size of the mark, paths kept as paths, the
+	* font subset-embedded. Self-contained and Acrobat-readable.
+	*/
+	const renderMark = async (mark) => {
+		const doc = await openAssetDocument(blankLibraryPdf());
+		try {
+			const scratch = (await doc.pages.list()).pages[0];
+			if (!scratch) throw new EngineError(EngineErrorCode.Unknown, "[stamp] no scratch page");
+			const page = doc.page(scratch.pageObjectNumber);
+			if (!page.annotations.exportAppearance) throw new EngineError(EngineErrorCode.NotImplemented, "[stamp] authoring a mark needs an asset engine that can export annotation appearances");
+			const color = hexColor(mark.color ?? "#1d2b53");
+			const created = mark.kind === "ink" ? await page.annotations.create({
+				subtype: "ink",
+				inkList: mark.strokes.map((stroke) => stroke.map(({ x, y }) => ({
+					x,
+					y
+				}))),
+				rect: inkBounds(mark.strokes, mark.strokeWidth ?? 2),
+				color,
+				strokeWidth: mark.strokeWidth ?? 2
+			}) : await page.annotations.create({
+				subtype: "free-text",
+				intent: "free-text",
+				contents: mark.text,
+				fontFamily: mark.fontFamily,
+				fontSize: mark.fontSize ?? 36,
+				textAlign: "left",
+				rect: textBounds(mark.text, mark.fontSize ?? 36),
+				fontColor: color,
+				strokeWidth: 0
+			});
+			return new Uint8Array(await page.annotations.exportAppearance([created.created.ref]));
+		} finally {
+			await doc.close();
+		}
+	};
+	/** One page of a PDF as a single-page PDF (a `pdf` mark with `pageIndex`). */
+	const extractPage = async (bytes, pageIndex) => {
+		const doc = await openAssetDocument(bytes);
+		try {
+			const layout = await doc.pages.list();
+			const page = layout.pages[pageIndex];
+			if (!page) throw new EngineError(EngineErrorCode.InvalidArg, `[stamp] the PDF has no page ${pageIndex} (${layout.pageCount} pages)`);
+			return await doc.pages.extract([page.pageObjectNumber]);
+		} finally {
+			await doc.close();
+		}
+	};
+	/** The bytes an asset is made from: the caller's `source`, or its `mark` authored into one. */
+	const resolveAssetSource = async (input) => {
+		if (input.source === void 0 === (input.mark === void 0)) throw new EngineError(EngineErrorCode.InvalidArg, "[stamp] addAsset takes exactly one of `source` / `mark`");
+		if (input.source !== void 0) return resolveBinarySource(input.source);
+		const mark = input.mark;
+		switch (mark.kind) {
+			case "image": return resolveBinarySource(mark.source);
+			case "pdf": {
+				const resolved = await resolveBinarySource(mark.source);
+				if (mark.pageIndex === void 0) return resolved;
+				return { bytes: toArrayBuffer(await extractPage(new Uint8Array(resolved.bytes), mark.pageIndex)) };
+			}
+			case "ink":
+			case "text": return { bytes: toArrayBuffer(await renderMark(mark)) };
+		}
+	};
 	const addAsset = async (input) => {
 		if (input.libraryId && !ctx.getState().libraries[input.libraryId]) throw new EngineError(EngineErrorCode.NotFound, `[stamp] unknown library '${input.libraryId}'`);
-		const resolved = await resolveBinarySource(input.source);
+		const resolved = await resolveAssetSource(input);
 		const meta = sniffBinaryMetadata(resolved.bytes);
 		if (!meta) throw new EngineError(EngineErrorCode.InvalidArg, "[stamp] asset source must be PNG, JPEG, or single-page PDF bytes");
 		const isPdf = meta.mimeType === "application/pdf";
@@ -502,6 +623,43 @@ function createStampCapability(ctx, config = {}) {
 			});
 		});
 	};
+	const updateLibrary = async (id, patch) => {
+		if (!ctx.getState().libraries[id]) throw new EngineError(EngineErrorCode.NotFound, `[stamp] unknown library '${id}'`);
+		return mutateLibrary(id, async () => {
+			const library = ctx.getState().libraries[id];
+			if (!library) throw new EngineError(EngineErrorCode.NotFound, `[stamp] unknown library '${id}'`);
+			const canonicalBytes = libraryBinaries.get(id);
+			if (!canonicalBytes) throw new EngineError(EngineErrorCode.Unknown, `[stamp] canonical bytes are missing for library '${id}'`);
+			const next = {
+				...library,
+				...patch.name !== void 0 ? { name: patch.name } : {},
+				...patch.categories !== void 0 ? { categories: patch.categories } : {}
+			};
+			const doc = await openAssetDocument(canonicalBytes);
+			let rewritten;
+			try {
+				requireCanonicalServices(doc);
+				if (next.name !== library.name) await doc.metadata.update({ title: next.name });
+				await doc.pieceInfo.update(STAMP_LIBRARY_PIECEINFO_APP, stampLibraryPieceInfo(id, {
+					kind: next.kind,
+					categories: next.categories,
+					locale: next.locale
+				}));
+				rewritten = await doc.download();
+			} finally {
+				await doc.close();
+			}
+			libraryBinaries.set(id, rewritten);
+			ctx.dispatch({
+				type: "LIBRARY_UPDATED",
+				library: next
+			});
+			libraryChanged.emit({
+				libraryId: id,
+				reason: "updated"
+			});
+		});
+	};
 	/**
 	* Form-backed stamps are executable templates only until placement. Work
 	* on an isolated copy so neither the canonical library nor its reusable
@@ -581,6 +739,20 @@ function createStampCapability(ctx, config = {}) {
 			...stampPayload(asset, placement, placement !== bin),
 			targetWidth: opts?.targetWidth
 		});
+		armedByDocument.set(documentId, assetId);
+	};
+	/** Which asset this plugin armed per document. The annotation plugin owns
+	*  the arm itself (a tool switch disarms it), so the answer is checked
+	*  against it and forgotten once it no longer holds one. */
+	const armedByDocument = /* @__PURE__ */ new Map();
+	const armedAsset = (documentId) => {
+		const assetId = armedByDocument.get(documentId);
+		if (assetId === void 0) return null;
+		if (!ctx.tryForDocument(AnnotationToken$1, documentId)?.hasArmedStamp()) {
+			armedByDocument.delete(documentId);
+			return null;
+		}
+		return ctx.getState().assets[assetId] ?? null;
 	};
 	/**
 	* Ghost renders, one per size bucket per asset, rendered lazily on the
@@ -651,9 +823,10 @@ function createStampCapability(ctx, config = {}) {
 		if (ownedAssetEngine) Promise.resolve(ownedAssetEngine).then((engine) => engine.destroy()).catch(() => {});
 	});
 	return {
-		libraries: () => {
+		libraries: (query) => {
 			const s = ctx.getState();
-			return s.libraryOrder.map((id) => s.libraries[id]).filter((l) => l != null);
+			const kinds = query?.kind === void 0 ? null : new Set(typeof query.kind === "string" ? [query.kind] : query.kind);
+			return s.libraryOrder.map((id) => s.libraries[id]).filter((l) => l != null && (kinds === null || kinds.has(l.kind)));
 		},
 		library: (id) => ctx.getState().libraries[id] ?? null,
 		assets: (libraryId) => {
@@ -670,6 +843,7 @@ function createStampCapability(ctx, config = {}) {
 		exportLibrary: (id) => libraryBinaries.get(id) ?? null,
 		onLibraryChanged: libraryChanged.on,
 		createLibrary,
+		updateLibrary,
 		importLibraryPdf,
 		addAsset,
 		addAssetFromAnnotations,
@@ -678,7 +852,11 @@ function createStampCapability(ctx, config = {}) {
 		removeLibrary,
 		armAsset,
 		placeAsset,
-		disarm: (documentId) => ctx.forDocument(AnnotationToken, documentId).disarmStamp()
+		disarm: (documentId) => {
+			armedByDocument.delete(documentId);
+			ctx.forDocument(AnnotationToken, documentId).disarmStamp();
+		},
+		armedAsset
 	};
 }
 //#endregion
@@ -700,6 +878,13 @@ const stampReducer = (state, action) => {
 			},
 			libraryOrder: [...state.libraryOrder, action.library.id]
 		};
+		case "LIBRARY_UPDATED": return state.libraries[action.library.id] ? {
+			...state,
+			libraries: {
+				...state.libraries,
+				[action.library.id]: action.library
+			}
+		} : state;
 		case "LIBRARY_REMOVED": {
 			const library = state.libraries[action.libraryId];
 			if (!library) return state;
@@ -850,6 +1035,6 @@ function persistStampLibraries(stamp, store, opts = {}) {
 	};
 }
 //#endregion
-export { STAMP_LIBRARY_PIECEINFO_APP, STAMP_PIECEINFO_APP, STAMP_PIECEINFO_VERSION, StampToken, assetIdFor, customStampName, memoryStampStore, parseStampKey, persistStampLibraries, restoreStampLibraries, stampKey, stampKindToPdfName, stampLibraryPieceInfo, stampPieceInfo, stampPlugin };
+export { DEFAULT_LIBRARY_KIND, STAMP_LIBRARY_PIECEINFO_APP, STAMP_PIECEINFO_APP, STAMP_PIECEINFO_VERSION, StampToken, assetIdFor, customStampName, libraryKindFromPdfName, libraryKindToPdfName, memoryStampStore, parseStampKey, persistStampLibraries, restoreStampLibraries, stampKey, stampKindToPdfName, stampLibraryPieceInfo, stampPieceInfo, stampPlugin };
 
 //# sourceMappingURL=index.js.map