@embedpdf/plugin-page-edit 3.0.0-next.14 → 3.0.0-next.16

package/dist/index.js

@@ -1,117 +1,316 @@
-import { t as PageEditToken } from "./contract-BsNelyd8.js";
-import { definePlugin } from "@embedpdf/core";
-//#region src/capability.ts
-/**
-* Authorization for structural page edits. Maps to PDF bit 11 (ASSEMBLE =
-* insert/rotate/delete pages). The engine ALSO enforces this — every
-* page-structure verb throws `PermissionDenied` without it, identically on
-* local and cloud — so `canEdit()` is the UI mirror of a real guard, not the
-* guard itself. Typed as `DocCapability` so a typo is a compile error.
-*/
-const ASSEMBLE_CAPABILITY = "doc.pages.assemble";
+import { t as PageEditToken } from "./contract-CYWYR5Pd.js";
+import { DocumentsToken, PluginError, definePlugin, defineState, memo, toPluginError } from "@embedpdf/core";
+//#region src/model.ts
+const initialPageEditState = () => ({ selected: [] });
+/** The selection becomes `refs`, each page once. */
+function selected(state, refs) {
+	const numbers = refs.map((ref) => ref.objectNumber);
+	const unique = refs.filter((_ref, i) => numbers.indexOf(numbers[i]) === i);
+	return unique.length === state.selected.length && unique.every((ref, i) => ref.objectNumber === state.selected[i].objectNumber) ? state : {
+		...state,
+		selected: unique
+	};
+}
+//#endregion
+//#region src/controller.ts
 /**
-* Forwards structural edits to the document's engine handle, addressed by PON.
-* The handle (`ctx.doc`) and the page registry (`ctx.document()`, kept in sync
-* by the kernel's event→registry bridge) are both already on the plugin
-* context — this capability is the thin layer that turns the relative rotate
-* gesture into the engine's absolute wire.
+* The page-edit controller: page edits that take refs or indexes, and the
+* page selection. Turning a page relative to its own rotation, and fixing a
+* position's page, live here once instead of in every app's click handler.
+*
+* A verb refuses before anything starts (permission, pages, position), then
+* stages its edit as one change on the document's queue (`ctx.changes`): one
+* step of the history, sent after everything staged before it. The page list
+* shows it once the engine answers; nothing predicts pages yet.
 */
-function createPageEditCapability(ctx) {
-	const requireDoc = () => {
-		const doc = ctx.doc;
-		if (!doc) throw new Error("[page-edit] no document bound");
-		return doc;
+/** Inserting, rotating and deleting pages (PDF permission bit 4 or 11). The engine enforces it too. */
+const ASSEMBLE = "doc.pages.assemble";
+/** Copying pages out of a document is a partial download. The engine enforces it too. */
+const DOWNLOAD = "doc.download";
+/** The size of a blank page when the document has no page to match: Letter, in points. */
+const LETTER_SIZE = {
+	width: 612,
+	height: 792
+};
+const NO_PAGES = Object.freeze([]);
+const NO_LAYOUTS = Object.freeze([]);
+function createPageEditController(ctx) {
+	/** Engine calls outside the guarded `ctx.doc` (another document, a scratch document) map their errors here. */
+	const mapErrors = async (work) => {
+		try {
+			return await work();
+		} catch (error) {
+			throw toPluginError("page-edit", error);
+		}
 	};
-	/** Current absolute rotation of a page from the registry; 0 if unknown. */
-	const rotationOf = (pon) => {
-		return (ctx.document()?.pages.find((p) => p.pageObjectNumber === pon))?.rotation ?? 0;
+	const registry = () => ctx.document()?.pages ?? NO_LAYOUTS;
+	const noPages = () => new PluginError("invalid-input", "page-edit", "no pages given");
+	/**
+	* A verb's pages as refs, checked when it is called: an index names the
+	* page at that position now, which is the page the user clicked.
+	*/
+	const refsOf = (pages) => {
+		if (pages.length === 0) throw noPages();
+		return pages.map((page) => ctx.pageOf(page).ref);
+	};
+	/** A position, its page checked when the verb is called, like the verb's own pages. Default `'end'`. */
+	const positionOf = (position) => {
+		if (!position || position === "start" || position === "end") return position ?? "end";
+		if ("after" in position) return { after: ctx.pageOf(position.after).ref };
+		return { before: ctx.pageOf(position.before).ref };
 	};
 	/**
-	* Resolve a placement to the engine's index wire, from the registry at
-	* call time — the PON anchors are why "add after this thumbnail" survives
-	* a concurrent reorder. Returns the anchor page too, so `addBlank` can
-	* default its size without a second lookup.
+	* Default blank-page size: the page the position names, else the page the
+	* new ones go next to (the first or the last), else Letter.
 	*/
-	const resolvePlacement = (placement) => {
-		if (!placement) return {
-			destIndex: void 0,
-			anchor: void 0
-		};
-		if ("index" in placement) return {
-			destIndex: placement.index,
-			anchor: void 0
-		};
-		const pon = "after" in placement ? placement.after : placement.before;
-		const anchor = ctx.document()?.pages.find((p) => p.pageObjectNumber === pon);
-		if (!anchor) throw new Error(`[page-edit] placement page not found: ${pon}`);
-		return {
-			destIndex: "after" in placement ? anchor.index + 1 : anchor.index,
-			anchor
-		};
+	const sizeAt = (position) => {
+		if (typeof position === "object") return ctx.pageOf("after" in position ? position.after : position.before).size;
+		const pages = registry();
+		if (pages.length === 0) return LETTER_SIZE;
+		return (position === "start" ? pages[0] : pages[pages.length - 1]).size;
+	};
+	const getSelected = memo(() => [registry(), ctx.state.get().selected], (pages, refs) => {
+		if (refs.length === 0) return NO_PAGES;
+		const present = new Set(pages.map((page) => page.ref.objectNumber));
+		return refs.filter((ref) => present.has(ref.objectNumber));
+	});
+	const select = (pages) => {
+		const refs = pages.flatMap((page) => {
+			const found = ctx.getPage(page);
+			return found ? [found.ref] : [];
+		});
+		ctx.state.update(selected, refs);
+	};
+	/** Refuse before anything starts: without the right, or once the caller cancelled. */
+	const refuse = (permission, operation, options) => {
+		ctx.assertAllowed(permission, operation);
+		if (options?.signal?.aborted) throw new PluginError("operation-cancelled", "page-edit", `${operation} was cancelled`);
 	};
 	/**
-	* Default blank-page size: the insertion point's predecessor (the page
-	* the new one will follow), else the first page, else — only reachable
-	* with an empty registry, which an open document never has — US Letter.
+	* Stage one user action: one change, one step of the history. Its label
+	* counts the pages it acts on, when the verb knows how many.
 	*/
-	const neighbourSize = (destIndex) => {
-		const pages = ctx.document()?.pages ?? [];
-		if (pages.length === 0) return {
-			width: 612,
-			height: 792
+	const stageChange = (verb, count, ops, undo) => {
+		const label = count === null ? { key: `pages.${verb}` } : {
+			key: `pages.${verb}`,
+			count
 		};
-		if (destIndex === void 0) return pages[pages.length - 1].size;
-		return pages[Math.max(0, Math.min(destIndex - 1, pages.length - 1))].size;
+		return ctx.changes.stage({
+			label,
+			ops,
+			...undo ? { undo } : {}
+		});
+	};
+	/** The engine's answer to a staged change: its first item. */
+	const answer = async (change, options) => {
+		try {
+			return (await ctx.cancellable(options?.signal, change.result)).items[0];
+		} catch (error) {
+			throw toPluginError("page-edit", error);
+		}
+	};
+	/** What an insert's answer names: the new pages. */
+	const inserted = async (change, options) => {
+		const item = await answer(change, options);
+		return { pages: "insertedPages" in item ? item.insertedPages : NO_PAGES };
 	};
-	return {
-		canEdit() {
-			return ctx.doc?.security.allows(ASSEMBLE_CAPABILITY) ?? false;
+	/**
+	* A page's rotation once this session's changes on their way apply: the
+	* last rotation one of them gives it, else the page's own. What a turn
+	* starts from, so two quick quarter turns are a half turn.
+	*/
+	const rotationOf = (ref) => {
+		let rotation = ctx.pageOf(ref).rotation;
+		for (const change of ctx.changes.pending()) for (const op of change.shows) {
+			if (op.type !== "pages.rotate") continue;
+			if (op.pages.some((page) => page.objectNumber === ref.objectNumber)) rotation = op.rotation;
+		}
+		return rotation;
+	};
+	/**
+	* Rotate pages as one change: one op per rotation they end up with. What
+	* undoing it looks like is each page turned back, so a turn right after an
+	* undo starts from where the undo leaves the page.
+	*/
+	const rotate = (refs, rotationAfter) => {
+		const after = /* @__PURE__ */ new Map();
+		const before = /* @__PURE__ */ new Map();
+		for (const ref of refs) {
+			const add = (groups, rotation) => groups.set(rotation, [...groups.get(rotation) ?? [], ref]);
+			add(before, rotationOf(ref));
+			add(after, rotationAfter(ref));
+		}
+		const opsOf = (groups) => [...groups].map(([rotation, pages]) => ({
+			type: "pages.rotate",
+			pages,
+			rotation
+		}));
+		return stageChange("rotate", refs.length, opsOf(after), opsOf(before));
+	};
+	/**
+	* The pages as they show: every change on its way sent and answered first,
+	* so a copy holds the edits made before it.
+	*/
+	const settled = async (options) => {
+		ctx.changes.sendHolds();
+		await ctx.cancellable(options?.signal, ctx.changes.whenSettled());
+	};
+	/** Copy pages of this document out, as they show. */
+	const extractShown = async (refs, options) => {
+		await settled(options);
+		return ctx.cancellable(options?.signal, ctx.doc.pages.extract([...refs]));
+	};
+	/** Stage the insert of a PDF's pages; resolves the new pages. */
+	const insertBytes = (verb, count, bytes, position, options) => {
+		const source = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+		const change = stageChange(verb, count, [{
+			type: "pages.insert",
+			source,
+			position
+		}]);
+		return inserted(change, options);
+	};
+	/** Some pages of a PDF: open the bytes beside the document and extract them. */
+	const pagesOfBytes = async (bytes, pageIndexes, signal) => {
+		const source = await mapErrors(() => ctx.engine.open({
+			kind: "bytes",
+			id: `page-edit-source-${Date.now().toString(36)}`,
+			bytes: new Uint8Array(bytes)
+		}, { scope: ["*"] }));
+		try {
+			const layout = await mapErrors(() => ctx.cancellable(signal, source.pages.list()));
+			const refs = pageIndexes.map((index) => {
+				const page = layout.pages[index];
+				if (!page) throw new PluginError("not-found", "page-edit", `the PDF has no page ${index}`);
+				return page.ref;
+			});
+			return await mapErrors(() => ctx.cancellable(signal, source.pages.extract(refs)));
+		} finally {
+			await source.close();
+		}
+	};
+	return { api: {
+		canEdit: () => ctx.allows(ASSEMBLE),
+		canExtract: () => ctx.allows(DOWNLOAD),
+		getSelected,
+		select,
+		rotateBy: async (pages, delta, options) => {
+			refuse(ASSEMBLE, "pageEdit.rotateBy", options);
+			const refs = refsOf(pages);
+			const change = rotate(refs, (ref) => ((rotationOf(ref) + delta) % 360 + 360) % 360);
+			await answer(change, options);
+		},
+		setRotation: async (pages, rotation, options) => {
+			refuse(ASSEMBLE, "pageEdit.setRotation", options);
+			const change = rotate(refsOf(pages), () => rotation);
+			await answer(change, options);
 		},
-		rotateBy(pon, delta) {
-			const next = ((rotationOf(pon) + delta) % 360 + 360) % 360;
-			return requireDoc().pages.rotate([pon], next);
+		reorder: async (pages, position, options) => {
+			refuse(ASSEMBLE, "pageEdit.reorder", options);
+			const refs = refsOf(pages);
+			const change = stageChange("reorder", refs.length, [{
+				type: "pages.reorder",
+				pages: refs,
+				position: positionOf(position)
+			}]);
+			await answer(change, options);
 		},
-		setRotation(pons, rotation) {
-			return requireDoc().pages.rotate(pons, rotation);
+		delete: async (pages, options) => {
+			refuse(ASSEMBLE, "pageEdit.delete", options);
+			const refs = refsOf(pages);
+			const deleting = new Set(refs.map((ref) => ref.objectNumber));
+			if (registry().every((page) => deleting.has(page.ref.objectNumber))) throw new PluginError("invalid-input", "page-edit", "a document keeps at least one page");
+			const change = stageChange("delete", refs.length, [{
+				type: "pages.delete",
+				pages: refs
+			}]);
+			await answer(change, options);
 		},
-		move(pons, destIndex) {
-			return requireDoc().pages.move(pons, destIndex);
+		insertBlank: async (options = {}) => {
+			refuse(ASSEMBLE, "pageEdit.insertBlank", options);
+			const position = positionOf(options.position);
+			const count = options.count ?? 1;
+			const size = options.size ?? sizeAt(position);
+			const change = stageChange("insertBlank", count, [{
+				type: "pages.insertBlank",
+				spec: {
+					size,
+					count
+				},
+				position
+			}]);
+			return inserted(change, options);
 		},
-		delete(pons) {
-			return requireDoc().pages.delete(pons);
+		insertFromBytes: async (bytes, options = {}) => {
+			refuse(ASSEMBLE, "pageEdit.insertFromBytes", options);
+			const position = positionOf(options.position);
+			const { pageIndexes, signal } = options;
+			if (pageIndexes?.length === 0) throw noPages();
+			const source = pageIndexes ? await pagesOfBytes(bytes, pageIndexes, signal) : bytes;
+			return insertBytes("insert", pageIndexes?.length ?? null, source, position, options);
 		},
-		addBlank(opts = {}) {
-			const doc = requireDoc();
-			const { destIndex, anchor } = resolvePlacement(opts.placement);
-			const size = opts.size ?? anchor?.size ?? neighbourSize(destIndex);
-			return doc.pages.insertBlank({
-				size,
-				count: opts.count
-			}, destIndex);
+		insertFromDocument: async (documentId, pages, options = {}) => {
+			refuse(ASSEMBLE, "pageEdit.insertFromDocument", options);
+			if (pages.length === 0) throw noPages();
+			const other = ctx.documentHandle(documentId);
+			if (!other) throw new PluginError("not-found", "page-edit", `document '${documentId}' is not open`);
+			const otherPages = ctx.get(DocumentsToken).listPages(documentId);
+			const refs = pages.map((page) => {
+				const found = typeof page === "number" ? otherPages[page] : otherPages.find((candidate) => candidate.ref.objectNumber === page.objectNumber);
+				if (!found) throw new PluginError("not-found", "page-edit", `document '${documentId}' has no such page`);
+				return found.ref;
+			});
+			const position = positionOf(options.position);
+			const bytes = await mapErrors(() => ctx.cancellable(options.signal, other.pages.extract(refs)));
+			return insertBytes("insert", refs.length, bytes, position, options);
 		},
-		insert(bytes, opts = {}) {
-			const doc = requireDoc();
-			const { destIndex } = resolvePlacement(opts.placement);
-			return doc.pages.insert(bytes, destIndex);
+		duplicate: async (pages, options = {}) => {
+			refuse(ASSEMBLE, "pageEdit.duplicate", options);
+			ctx.assertAllowed(DOWNLOAD, "pageEdit.duplicate");
+			const refs = refsOf(pages);
+			const position = options.position ? positionOf(options.position) : { after: refs[refs.length - 1] };
+			const bytes = await extractShown(refs, options);
+			return insertBytes("duplicate", refs.length, bytes, position, options);
+		},
+		extract: async (pages, options) => {
+			refuse(DOWNLOAD, "pageEdit.extract", options);
+			return extractShown(refsOf(pages), options);
 		}
-	};
+	} };
 }
 //#endregion
 //#region src/page-edit.plugin.ts
 /**
-* Document-scoped, stateless: turns the engine handle's page service into a
-* PON-addressed edit capability. The relative→absolute rotation lives in the
-* capability so the four framework adapters never re-derive it, and this is the
-* home for client-side edit state (pending/optimistic/undo) when it lands —
-* adapters keep their thin hook over `PageEditToken` unchanged.
+* Document-scoped: the document's page edits, each one change of its
+* history, and which of its pages are selected. Turning a page relative to
+* its own rotation lives in the controller, so no app re-derives it.
 */
 const pageEditPlugin = () => definePlugin({
 	id: "page-edit",
 	scope: "document",
 	token: PageEditToken,
-	capability: createPageEditCapability
+	state: initialPageEditState,
+	create: createPageEditController
+});
+//#endregion
+//#region src/state.ts
+/**
+* The pages page's State table as code: what `usePageEditState()` returns,
+* and the same fields in every other framework.
+*/
+const pageEditState = defineState(PageEditToken, {
+	read: (pageEdit) => ({
+		selected: pageEdit.getSelected(),
+		canEdit: pageEdit.canEdit(),
+		canExtract: pageEdit.canExtract()
+	}),
+	empty: {
+		selected: [],
+		canEdit: false,
+		canExtract: false
+	}
 });
 //#endregion
-export { PageEditToken, pageEditPlugin };
+export { PageEditToken, pageEditPlugin, pageEditState };
 
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../src/capability.ts","../src/page-edit.plugin.ts"],"sourcesContent":["import type {\n  PluginContext,\n  PageObjectNumber,\n  PageRotation,\n  DocCapability,\n  PdfSize,\n} from '@embedpdf/core';\nimport type { PageEditCapability, PagePlacement } from './types';\n\n/**\n * Authorization for structural page edits. Maps to PDF bit 11 (ASSEMBLE =\n * insert/rotate/delete pages). The engine ALSO enforces this — every\n * page-structure verb throws `PermissionDenied` without it, identically on\n * local and cloud — so `canEdit()` is the UI mirror of a real guard, not the\n * guard itself. Typed as `DocCapability` so a typo is a compile error.\n */\nconst ASSEMBLE_CAPABILITY: DocCapability = 'doc.pages.assemble';\n\n/**\n * Forwards structural edits to the document's engine handle, addressed by PON.\n * The handle (`ctx.doc`) and the page registry (`ctx.document()`, kept in sync\n * by the kernel's event→registry bridge) are both already on the plugin\n * context — this capability is the thin layer that turns the relative rotate\n * gesture into the engine's absolute wire.\n */\nexport function createPageEditCapability(ctx: PluginContext<unknown>): PageEditCapability {\n  const requireDoc = () => {\n    const doc = ctx.doc;\n    if (!doc) throw new Error('[page-edit] no document bound');\n    return doc;\n  };\n\n  /** Current absolute rotation of a page from the registry; 0 if unknown. */\n  const rotationOf = (pon: PageObjectNumber): PageRotation => {\n    const page = ctx.document()?.pages.find((p) => p.pageObjectNumber === pon);\n    return page?.rotation ?? 0;\n  };\n\n  /**\n   * Resolve a placement to the engine's index wire, from the registry at\n   * call time — the PON anchors are why \"add after this thumbnail\" survives\n   * a concurrent reorder. Returns the anchor page too, so `addBlank` can\n   * default its size without a second lookup.\n   */\n  const resolvePlacement = (placement?: PagePlacement) => {\n    if (!placement) return { destIndex: undefined, anchor: undefined };\n    if ('index' in placement) return { destIndex: placement.index, anchor: undefined };\n    const pon = 'after' in placement ? placement.after : placement.before;\n    const anchor = ctx.document()?.pages.find((p) => p.pageObjectNumber === pon);\n    if (!anchor) throw new Error(`[page-edit] placement page not found: ${pon}`);\n    return { destIndex: 'after' in placement ? anchor.index + 1 : anchor.index, anchor };\n  };\n\n  /**\n   * Default blank-page size: the insertion point's predecessor (the page\n   * the new one will follow), else the first page, else — only reachable\n   * with an empty registry, which an open document never has — US Letter.\n   */\n  const neighbourSize = (destIndex: number | undefined): PdfSize => {\n    const pages = ctx.document()?.pages ?? [];\n    if (pages.length === 0) return { width: 612, height: 792 };\n    if (destIndex === undefined) return pages[pages.length - 1].size;\n    return pages[Math.max(0, Math.min(destIndex - 1, pages.length - 1))].size;\n  };\n\n  return {\n    canEdit() {\n      // Wildcard-aware predicate (mirrors the engine's own enforcement),\n      // identical on both engines. NOT `effectiveScope.includes(...)` — that\n      // enumeration drops the `*` admin grant, so it would hide the UI on a\n      // default admin open even though the engine allows the edit.\n      return ctx.doc?.security.allows(ASSEMBLE_CAPABILITY) ?? false;\n    },\n\n    rotateBy(pon, delta) {\n      // Wrap to [0, 360) — the double-mod keeps -90 from current 0 landing on 270.\n      const next = ((((rotationOf(pon) + delta) % 360) + 360) % 360) as PageRotation;\n      return requireDoc().pages.rotate([pon], next);\n    },\n\n    setRotation(pons, rotation) {\n      return requireDoc().pages.rotate(pons, rotation);\n    },\n\n    move(pons, destIndex) {\n      return requireDoc().pages.move(pons, destIndex);\n    },\n\n    delete(pons) {\n      return requireDoc().pages.delete(pons);\n    },\n\n    addBlank(opts = {}) {\n      const doc = requireDoc();\n      const { destIndex, anchor } = resolvePlacement(opts.placement);\n      // PON placements match the anchor the user is looking at; everything\n      // else matches the neighbour the new page will follow.\n      const size = opts.size ?? anchor?.size ?? neighbourSize(destIndex);\n      return doc.pages.insertBlank({ size, count: opts.count }, destIndex);\n    },\n\n    insert(bytes, opts = {}) {\n      const doc = requireDoc();\n      const { destIndex } = resolvePlacement(opts.placement);\n      return doc.pages.insert(bytes, destIndex);\n    },\n  };\n}\n","import { definePlugin } from '@embedpdf/core';\nimport { createPageEditCapability } from './capability';\nimport { PageEditToken } from './types';\n\n/**\n * Document-scoped, stateless: turns the engine handle's page service into a\n * PON-addressed edit capability. The relative→absolute rotation lives in the\n * capability so the four framework adapters never re-derive it, and this is the\n * home for client-side edit state (pending/optimistic/undo) when it lands —\n * adapters keep their thin hook over `PageEditToken` unchanged.\n */\nexport const pageEditPlugin = () =>\n  definePlugin({\n    id: 'page-edit',\n    scope: 'document',\n    token: PageEditToken,\n    capability: createPageEditCapability,\n  });\n"],"mappings":";;;;;;;;;;AAgBA,MAAM,sBAAqC;;;;;;;;AAS3C,SAAgB,yBAAyB,KAAiD;CACxF,MAAM,mBAAmB;EACvB,MAAM,MAAM,IAAI;EAChB,IAAI,CAAC,KAAK,MAAM,IAAI,MAAM,+BAA+B;EACzD,OAAO;CACT;;CAGA,MAAM,cAAc,QAAwC;EAE1D,QADa,IAAI,SAAS,CAAC,EAAE,MAAM,MAAM,MAAM,EAAE,qBAAqB,GAAG,EAAA,EAC5D,YAAY;CAC3B;;;;;;;CAQA,MAAM,oBAAoB,cAA8B;EACtD,IAAI,CAAC,WAAW,OAAO;GAAE,WAAW,KAAA;GAAW,QAAQ,KAAA;EAAU;EACjE,IAAI,WAAW,WAAW,OAAO;GAAE,WAAW,UAAU;GAAO,QAAQ,KAAA;EAAU;EACjF,MAAM,MAAM,WAAW,YAAY,UAAU,QAAQ,UAAU;EAC/D,MAAM,SAAS,IAAI,SAAS,CAAC,EAAE,MAAM,MAAM,MAAM,EAAE,qBAAqB,GAAG;EAC3E,IAAI,CAAC,QAAQ,MAAM,IAAI,MAAM,yCAAyC,KAAK;EAC3E,OAAO;GAAE,WAAW,WAAW,YAAY,OAAO,QAAQ,IAAI,OAAO;GAAO;EAAO;CACrF;;;;;;CAOA,MAAM,iBAAiB,cAA2C;EAChE,MAAM,QAAQ,IAAI,SAAS,CAAC,EAAE,SAAS,CAAC;EACxC,IAAI,MAAM,WAAW,GAAG,OAAO;GAAE,OAAO;GAAK,QAAQ;EAAI;EACzD,IAAI,cAAc,KAAA,GAAW,OAAO,MAAM,MAAM,SAAS,EAAE,CAAC;EAC5D,OAAO,MAAM,KAAK,IAAI,GAAG,KAAK,IAAI,YAAY,GAAG,MAAM,SAAS,CAAC,CAAC,EAAE,CAAC;CACvE;CAEA,OAAO;EACL,UAAU;GAKR,OAAO,IAAI,KAAK,SAAS,OAAO,mBAAmB,KAAK;EAC1D;EAEA,SAAS,KAAK,OAAO;GAEnB,MAAM,SAAW,WAAW,GAAG,IAAI,SAAS,MAAO,OAAO;GAC1D,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,CAAC,GAAG,GAAG,IAAI;EAC9C;EAEA,YAAY,MAAM,UAAU;GAC1B,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,MAAM,QAAQ;EACjD;EAEA,KAAK,MAAM,WAAW;GACpB,OAAO,WAAW,CAAC,CAAC,MAAM,KAAK,MAAM,SAAS;EAChD;EAEA,OAAO,MAAM;GACX,OAAO,WAAW,CAAC,CAAC,MAAM,OAAO,IAAI;EACvC;EAEA,SAAS,OAAO,CAAC,GAAG;GAClB,MAAM,MAAM,WAAW;GACvB,MAAM,EAAE,WAAW,WAAW,iBAAiB,KAAK,SAAS;GAG7D,MAAM,OAAO,KAAK,QAAQ,QAAQ,QAAQ,cAAc,SAAS;GACjE,OAAO,IAAI,MAAM,YAAY;IAAE;IAAM,OAAO,KAAK;GAAM,GAAG,SAAS;EACrE;EAEA,OAAO,OAAO,OAAO,CAAC,GAAG;GACvB,MAAM,MAAM,WAAW;GACvB,MAAM,EAAE,cAAc,iBAAiB,KAAK,SAAS;GACrD,OAAO,IAAI,MAAM,OAAO,OAAO,SAAS;EAC1C;CACF;AACF;;;;;;;;;;AChGA,MAAa,uBACX,aAAa;CACX,IAAI;CACJ,OAAO;CACP,OAAO;CACP,YAAY;AACd,CAAC"}
+{"version":3,"file":"index.js","names":[],"sources":["../src/model.ts","../src/controller.ts","../src/page-edit.plugin.ts","../src/state.ts"],"sourcesContent":["/**\n * The page-edit session state: which pages are selected. A plain list of\n * refs, changed only by the transitions here; the controller reads it over the\n * document's pages, so a page that went leaves the selection.\n */\nimport type { PageRef } from '@embedpdf/core';\n\nexport interface PageEditState {\n  /** The selected pages, in the order they were selected. */\n  readonly selected: readonly PageRef[];\n}\n\nexport const initialPageEditState = (): PageEditState => ({ selected: [] });\n\n/** The selection becomes `refs`, each page once. */\nexport function selected(state: PageEditState, refs: readonly PageRef[]): PageEditState {\n  const numbers = refs.map((ref) => ref.objectNumber);\n  const unique = refs.filter((_ref, i) => numbers.indexOf(numbers[i]!) === i);\n  const same =\n    unique.length === state.selected.length &&\n    unique.every((ref, i) => ref.objectNumber === state.selected[i]!.objectNumber);\n  return same ? state : { ...state, selected: unique };\n}\n","/**\n * The page-edit controller: page edits that take refs or indexes, and the\n * page selection. Turning a page relative to its own rotation, and fixing a\n * position's page, live here once instead of in every app's click handler.\n *\n * A verb refuses before anything starts (permission, pages, position), then\n * stages its edit as one change on the document's queue (`ctx.changes`): one\n * step of the history, sent after everything staged before it. The page list\n * shows it once the engine answers; nothing predicts pages yet.\n */\nimport { memo, PluginError, toPluginError, DocumentsToken } from '@embedpdf/core';\nimport type {\n  ChangeLabel,\n  DocCapability,\n  OperationOptions,\n  PageLayout,\n  PagePosition,\n  PageRef,\n  PdfRotation,\n  PdfSize,\n  PendingChange,\n  PluginContext,\n  PredictedOp,\n} from '@embedpdf/core';\n\nimport type { PageEditCapability, PageEditInsertResult } from './contract';\nimport { selected, type PageEditState } from './model';\n\n/** Inserting, rotating and deleting pages (PDF permission bit 4 or 11). The engine enforces it too. */\nconst ASSEMBLE: DocCapability = 'doc.pages.assemble';\n/** Copying pages out of a document is a partial download. The engine enforces it too. */\nconst DOWNLOAD: DocCapability = 'doc.download';\n\n/** The size of a blank page when the document has no page to match: Letter, in points. */\nconst LETTER_SIZE: PdfSize = { width: 612, height: 792 };\n\nconst NO_PAGES: readonly PageRef[] = Object.freeze([]);\nconst NO_LAYOUTS: readonly PageLayout[] = Object.freeze([]);\n\n/** A page op, as a verb stages it. */\ntype PageOp = Extract<PredictedOp, { type: `pages.${string}` }>;\n\n/** What a change is called in history and refusals. */\ntype PageVerb = 'rotate' | 'reorder' | 'delete' | 'insertBlank' | 'insert' | 'duplicate';\n\nexport function createPageEditController(ctx: PluginContext<PageEditState>) {\n  /** Engine calls outside the guarded `ctx.doc` (another document, a scratch document) map their errors here. */\n  const mapErrors = async <T>(work: () => Promise<T>): Promise<T> => {\n    try {\n      return await work();\n    } catch (error) {\n      throw toPluginError('page-edit', error);\n    }\n  };\n  const registry = (): readonly PageLayout[] => ctx.document()?.pages ?? NO_LAYOUTS;\n  const noPages = () => new PluginError('invalid-input', 'page-edit', 'no pages given');\n\n  /**\n   * A verb's pages as refs, checked when it is called: an index names the\n   * page at that position now, which is the page the user clicked.\n   */\n  const refsOf = (pages: readonly (PageRef | number)[]): PageRef[] => {\n    if (pages.length === 0) throw noPages();\n    return pages.map((page) => ctx.pageOf(page).ref);\n  };\n\n  /** A position, its page checked when the verb is called, like the verb's own pages. Default `'end'`. */\n  const positionOf = (position: PagePosition | undefined): PagePosition => {\n    if (!position || position === 'start' || position === 'end') return position ?? 'end';\n    if ('after' in position) return { after: ctx.pageOf(position.after).ref };\n    return { before: ctx.pageOf(position.before).ref };\n  };\n  /**\n   * Default blank-page size: the page the position names, else the page the\n   * new ones go next to (the first or the last), else Letter.\n   */\n  const sizeAt = (position: PagePosition): PdfSize => {\n    if (typeof position === 'object') {\n      return ctx.pageOf('after' in position ? position.after : position.before).size;\n    }\n    const pages = registry();\n    if (pages.length === 0) return LETTER_SIZE;\n    return (position === 'start' ? pages[0] : pages[pages.length - 1]).size;\n  };\n\n  /* ── the selection ─────────────────────────────────────────────────────── */\n\n  const getSelected = memo(\n    () => [registry(), ctx.state.get().selected] as const,\n    (pages, refs) => {\n      if (refs.length === 0) return NO_PAGES;\n      const present = new Set(pages.map((page) => page.ref.objectNumber));\n      return refs.filter((ref) => present.has(ref.objectNumber));\n    },\n  );\n  const select = (pages: readonly (PageRef | number)[]): void => {\n    const refs = pages.flatMap((page) => {\n      const found = ctx.getPage(page);\n      return found ? [found.ref] : [];\n    });\n    ctx.state.update(selected, refs);\n  };\n\n  /* ── writes ────────────────────────────────────────────────────────────── */\n\n  /** Refuse before anything starts: without the right, or once the caller cancelled. */\n  const refuse = (\n    permission: DocCapability,\n    operation: string,\n    options: OperationOptions | undefined,\n  ): void => {\n    ctx.assertAllowed(permission, operation);\n    if (options?.signal?.aborted) {\n      throw new PluginError('operation-cancelled', 'page-edit', `${operation} was cancelled`);\n    }\n  };\n\n  /**\n   * Stage one user action: one change, one step of the history. Its label\n   * counts the pages it acts on, when the verb knows how many.\n   */\n  const stageChange = (\n    verb: PageVerb,\n    count: number | null,\n    ops: readonly PageOp[],\n    undo?: readonly PageOp[],\n  ): PendingChange => {\n    const label: ChangeLabel =\n      count === null ? { key: `pages.${verb}` } : { key: `pages.${verb}`, count };\n    return ctx.changes.stage({ label, ops, ...(undo ? { undo } : {}) });\n  };\n\n  /** The engine's answer to a staged change: its first item. */\n  const answer = async (change: PendingChange, options: OperationOptions | undefined) => {\n    try {\n      const result = await ctx.cancellable(options?.signal, change.result);\n      return result.items[0]!;\n    } catch (error) {\n      throw toPluginError('page-edit', error);\n    }\n  };\n\n  /** What an insert's answer names: the new pages. */\n  const inserted = async (\n    change: PendingChange,\n    options: OperationOptions | undefined,\n  ): Promise<PageEditInsertResult> => {\n    const item = await answer(change, options);\n    return { pages: 'insertedPages' in item ? item.insertedPages : NO_PAGES };\n  };\n\n  /**\n   * A page's rotation once this session's changes on their way apply: the\n   * last rotation one of them gives it, else the page's own. What a turn\n   * starts from, so two quick quarter turns are a half turn.\n   */\n  const rotationOf = (ref: PageRef): PdfRotation => {\n    let rotation = ctx.pageOf(ref).rotation;\n    for (const change of ctx.changes.pending()) {\n      for (const op of change.shows) {\n        if (op.type !== 'pages.rotate') continue;\n        if (op.pages.some((page) => page.objectNumber === ref.objectNumber)) {\n          rotation = op.rotation;\n        }\n      }\n    }\n    return rotation;\n  };\n\n  /**\n   * Rotate pages as one change: one op per rotation they end up with. What\n   * undoing it looks like is each page turned back, so a turn right after an\n   * undo starts from where the undo leaves the page.\n   */\n  const rotate = (refs: readonly PageRef[], rotationAfter: (ref: PageRef) => PdfRotation) => {\n    const after = new Map<PdfRotation, PageRef[]>();\n    const before = new Map<PdfRotation, PageRef[]>();\n    for (const ref of refs) {\n      const add = (groups: Map<PdfRotation, PageRef[]>, rotation: PdfRotation) =>\n        groups.set(rotation, [...(groups.get(rotation) ?? []), ref]);\n      add(before, rotationOf(ref));\n      add(after, rotationAfter(ref));\n    }\n    const opsOf = (groups: Map<PdfRotation, PageRef[]>): PageOp[] =>\n      [...groups].map(([rotation, pages]) => ({ type: 'pages.rotate', pages, rotation }));\n    return stageChange('rotate', refs.length, opsOf(after), opsOf(before));\n  };\n\n  /**\n   * The pages as they show: every change on its way sent and answered first,\n   * so a copy holds the edits made before it.\n   */\n  const settled = async (options: OperationOptions | undefined): Promise<void> => {\n    ctx.changes.sendHolds();\n    await ctx.cancellable(options?.signal, ctx.changes.whenSettled());\n  };\n\n  /** Copy pages of this document out, as they show. */\n  const extractShown = async (\n    refs: readonly PageRef[],\n    options: OperationOptions | undefined,\n  ): Promise<Uint8Array> => {\n    await settled(options);\n    return ctx.cancellable(options?.signal, ctx.doc.pages.extract([...refs]));\n  };\n\n  /** Stage the insert of a PDF's pages; resolves the new pages. */\n  const insertBytes = (\n    verb: 'insert' | 'duplicate',\n    count: number | null,\n    bytes: Uint8Array | ArrayBuffer,\n    position: PagePosition,\n    options: OperationOptions | undefined,\n  ): Promise<PageEditInsertResult> => {\n    const source = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);\n    const change = stageChange(verb, count, [{ type: 'pages.insert', source, position }]);\n    return inserted(change, options);\n  };\n\n  /** Some pages of a PDF: open the bytes beside the document and extract them. */\n  const pagesOfBytes = async (\n    bytes: Uint8Array | ArrayBuffer,\n    pageIndexes: readonly number[],\n    signal: AbortSignal | undefined,\n  ): Promise<Uint8Array> => {\n    const source = await mapErrors(() =>\n      ctx.engine.open(\n        {\n          kind: 'bytes',\n          id: `page-edit-source-${Date.now().toString(36)}`,\n          bytes: new Uint8Array(bytes),\n        },\n        { scope: ['*'] },\n      ),\n    );\n    try {\n      const layout = await mapErrors(() => ctx.cancellable(signal, source.pages.list()));\n      const refs = pageIndexes.map((index) => {\n        const page = layout.pages[index];\n        if (!page) {\n          throw new PluginError('not-found', 'page-edit', `the PDF has no page ${index}`);\n        }\n        return page.ref;\n      });\n      return await mapErrors(() => ctx.cancellable(signal, source.pages.extract(refs)));\n    } finally {\n      await source.close();\n    }\n  };\n\n  const api: PageEditCapability = {\n    canEdit: () => ctx.allows(ASSEMBLE),\n    canExtract: () => ctx.allows(DOWNLOAD),\n\n    getSelected,\n    select,\n\n    rotateBy: async (pages, delta, options) => {\n      refuse(ASSEMBLE, 'pageEdit.rotateBy', options);\n      const refs = refsOf(pages);\n      // The double modulo keeps -90 from 0 at 270.\n      const change = rotate(\n        refs,\n        (ref) => ((((rotationOf(ref) + delta) % 360) + 360) % 360) as PdfRotation,\n      );\n      await answer(change, options);\n    },\n\n    setRotation: async (pages, rotation, options) => {\n      refuse(ASSEMBLE, 'pageEdit.setRotation', options);\n      const change = rotate(refsOf(pages), () => rotation);\n      await answer(change, options);\n    },\n\n    reorder: async (pages, position, options) => {\n      refuse(ASSEMBLE, 'pageEdit.reorder', options);\n      const refs = refsOf(pages);\n      const change = stageChange('reorder', refs.length, [\n        { type: 'pages.reorder', pages: refs, position: positionOf(position) },\n      ]);\n      await answer(change, options);\n    },\n\n    delete: async (pages, options) => {\n      refuse(ASSEMBLE, 'pageEdit.delete', options);\n      const refs = refsOf(pages);\n      const deleting = new Set(refs.map((ref) => ref.objectNumber));\n      if (registry().every((page) => deleting.has(page.ref.objectNumber))) {\n        throw new PluginError('invalid-input', 'page-edit', 'a document keeps at least one page');\n      }\n      const change = stageChange('delete', refs.length, [{ type: 'pages.delete', pages: refs }]);\n      await answer(change, options);\n    },\n\n    insertBlank: async (options = {}) => {\n      refuse(ASSEMBLE, 'pageEdit.insertBlank', options);\n      const position = positionOf(options.position);\n      const count = options.count ?? 1;\n      const size = options.size ?? sizeAt(position);\n      const change = stageChange('insertBlank', count, [\n        { type: 'pages.insertBlank', spec: { size, count }, position },\n      ]);\n      return inserted(change, options);\n    },\n\n    insertFromBytes: async (bytes, options = {}) => {\n      refuse(ASSEMBLE, 'pageEdit.insertFromBytes', options);\n      const position = positionOf(options.position);\n      const { pageIndexes, signal } = options;\n      if (pageIndexes?.length === 0) throw noPages();\n      const source = pageIndexes ? await pagesOfBytes(bytes, pageIndexes, signal) : bytes;\n      return insertBytes('insert', pageIndexes?.length ?? null, source, position, options);\n    },\n\n    insertFromDocument: async (documentId, pages, options = {}) => {\n      refuse(ASSEMBLE, 'pageEdit.insertFromDocument', options);\n      if (pages.length === 0) throw noPages();\n      const other = ctx.documentHandle(documentId);\n      if (!other) {\n        throw new PluginError('not-found', 'page-edit', `document '${documentId}' is not open`);\n      }\n      // The pages are the other document's, so its page list resolves them.\n      const otherPages = ctx.get(DocumentsToken).listPages(documentId);\n      const refs = pages.map((page) => {\n        const found =\n          typeof page === 'number'\n            ? otherPages[page]\n            : otherPages.find((candidate) => candidate.ref.objectNumber === page.objectNumber);\n        if (!found) {\n          throw new PluginError(\n            'not-found',\n            'page-edit',\n            `document '${documentId}' has no such page`,\n          );\n        }\n        return found.ref;\n      });\n      const position = positionOf(options.position);\n      // The other document's session decides whether its pages may be copied\n      // out: the engine refuses `doc.download` there with the permission named.\n      const bytes = await mapErrors(() =>\n        ctx.cancellable(options.signal, other.pages.extract(refs)),\n      );\n      return insertBytes('insert', refs.length, bytes, position, options);\n    },\n\n    duplicate: async (pages, options = {}) => {\n      refuse(ASSEMBLE, 'pageEdit.duplicate', options);\n      ctx.assertAllowed(DOWNLOAD, 'pageEdit.duplicate');\n      const refs = refsOf(pages);\n      const position = options.position\n        ? positionOf(options.position)\n        : { after: refs[refs.length - 1]! };\n      const bytes = await extractShown(refs, options);\n      return insertBytes('duplicate', refs.length, bytes, position, options);\n    },\n\n    extract: async (pages, options) => {\n      refuse(DOWNLOAD, 'pageEdit.extract', options);\n      return extractShown(refsOf(pages), options);\n    },\n  };\n  return { api };\n}\n","import { definePlugin } from '@embedpdf/core';\n\nimport { PageEditToken } from './contract';\nimport { createPageEditController } from './controller';\nimport { initialPageEditState } from './model';\n\n/**\n * Document-scoped: the document's page edits, each one change of its\n * history, and which of its pages are selected. Turning a page relative to\n * its own rotation lives in the controller, so no app re-derives it.\n */\nexport const pageEditPlugin = () =>\n  definePlugin({\n    id: 'page-edit',\n    scope: 'document',\n    token: PageEditToken,\n    state: initialPageEditState,\n    create: createPageEditController,\n  });\n","/**\n * The pages page's State table as code: what `usePageEditState()` returns,\n * and the same fields in every other framework.\n */\nimport { defineState } from '@embedpdf/core';\n\nimport { PageEditToken } from './contract';\n\nexport const pageEditState = defineState(PageEditToken, {\n  read: (pageEdit) => ({\n    selected: pageEdit.getSelected(),\n    canEdit: pageEdit.canEdit(),\n    canExtract: pageEdit.canExtract(),\n  }),\n  empty: {\n    selected: [],\n    canEdit: false,\n    canExtract: false,\n  },\n});\n"],"mappings":"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"}

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@embedpdf/plugin-page-edit",
-  "version": "3.0.0-next.14",
+  "version": "3.0.0-next.16",
   "private": false,
-  "description": "Document-scoped page-edit capability: PON-addressed rotate/move/delete over the engine DocumentHandle. Owns relative→absolute rotation so framework adapters never re-derive it; the home for pending/undo/gating state.",
+  "description": "Document-scoped page-edit capability: ref-addressed rotate/move/delete/insert over the engine DocumentHandle, each one change of the history, and the page selection. Owns relative→absolute rotation and position resolution so framework adapters never re-derive them.",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -22,11 +22,14 @@
     "dist"
   ],
   "dependencies": {
-    "@embedpdf/core": "3.0.0-next.14"
+    "@embedpdf/core": "3.0.0-next.16"
   },
   "devDependencies": {
     "typescript": "^5.0.0",
     "vitest": "^2.1.9",
+    "@embedpdf/engine": "3.0.0-next.16",
+    "@embedpdf/engine-core": "3.0.0-next.16",
+    "@embedpdf/plugin-history": "3.0.0-next.16",
     "@embedpdf/tooling-build": "0.0.0"
   },
   "license": "Apache-2.0",

package/dist/contract-BnXi11KD.d.cts

@@ -1,82 +0,0 @@
-import { AbortablePromise, PageDeleteResult, PageInsertResult, PageMoveResult, PageObjectNumber, PageRotateResult, PageRotation, PdfSize } from "@embedpdf/core";
-//#region src/types.d.ts
-/**
- * Where added pages land. The PON anchors are the thumbnail gestures ("+
- * after this page") and stay correct across a concurrent reorder between
- * click and call — a raw index does not; `index` remains for absolute
- * positions ("at the start"). Omitted → append. Resolved to the engine's
- * index wire by the capability at call time, from the registry.
- */
-type PagePlacement = {
-  after: PageObjectNumber;
-} | {
-  before: PageObjectNumber;
-} | {
-  index: number;
-};
-/**
- * Structural page edits, addressed by durable PON (never display index — an
- * index shifts the moment a sibling is moved or deleted). Mirrors the engine's
- * `DocumentPagesService` 1:1, with one addition the engine can't have: the
- * relative `rotateBy` gesture. The engine wire is always ABSOLUTE; turning a
- * "+90° on this thumbnail" click into an absolute value needs the page's
- * current rotation, so that read+arithmetic lives HERE — once — instead of
- * being re-derived in every framework adapter's click handler.
- *
- * Document-scoped: rotation is shared document metadata, so editing through the
- * sidebar lens and seeing it in the main lens is automatic (both read the same
- * registry, which the kernel keeps in sync from the engine's event stream).
- */
-interface PageEditCapability {
-  /**
-   * Whether this caller is authorized to perform structural page edits —
-   * `effectiveScope` includes `doc.pages.assemble` (PDF bit 11). UIs gate
-   * ALL their edit affordances on this, the add verbs included (rotate,
-   * move, delete, addBlank, and insert share the one capability); the
-   * engine independently enforces the same capability and throws
-   * `PermissionDenied` if a call slips through.
-   */
-  canEdit(): boolean;
-  /**
-   * Rotate a SINGLE page by a relative quarter-turn — the per-thumbnail button
-   * gesture. Reads the page's current rotation from the registry and forwards
-   * the resulting absolute rotation to the engine.
-   */
-  rotateBy(pon: PageObjectNumber, delta: 90 | -90): AbortablePromise<PageRotateResult>;
-  /**
-   * Set the ABSOLUTE rotation of one or more pages to a single shared value —
-   * the multi-select gesture. Maps 1:1 to the engine.
-   */
-  setRotation(pons: PageObjectNumber[], rotation: PageRotation): AbortablePromise<PageRotateResult>;
-  /** Reorder pages (by PON) as a contiguous block starting at `destIndex`. */
-  move(pons: PageObjectNumber[], destIndex: number): AbortablePromise<PageMoveResult>;
-  /** Delete pages by PON. The engine rejects deleting every page. */
-  delete(pons: PageObjectNumber[]): AbortablePromise<PageDeleteResult>;
-  /**
-   * Create blank pages — gate the affordance on `canEdit()`, like every
-   * other structure verb (the add verbs share the `doc.pages.assemble`
-   * capability and are mandatory on the engine contract). `size` defaults
-   * to the page the new pages sit beside — the anchor for PON placements,
-   * else the insertion point's predecessor, else the last page — so "add
-   * page" matches the document without an A4-vs-Letter guess. That default
-   * is a registry read, which is why it lives HERE and the engine wire
-   * stays explicit (the `rotateBy` law). `count` defaults to 1.
-   */
-  addBlank(opts?: {
-    size?: PdfSize;
-    count?: number;
-    placement?: PagePlacement;
-  }): AbortablePromise<PageInsertResult>;
-  /**
-   * Copy every page of a standalone PDF (`bytes`) in at the placement —
-   * the merge/import gesture. Forwards to `pages.insert`; the inserted
-   * copies get fresh PONs, returned in insertion order.
-   */
-  insert(bytes: Uint8Array | ArrayBuffer, opts?: {
-    placement?: PagePlacement;
-  }): AbortablePromise<PageInsertResult>;
-}
-declare const PageEditToken: import("@embedpdf/core").CapabilityToken<PageEditCapability>;
-//#endregion
-export { PageEditToken as n, PageEditCapability as t };
-//# sourceMappingURL=contract-BnXi11KD.d.cts.map