dsh-figmark 1.2.1 → 1.2.2

package/lib/client.pdf.js

@@ -1189,6 +1189,9 @@ window.__ModuleLoader__.load({
 				cancel: (0, react.useCallback)(() => {
 					autosave.cancel();
 				}, [autosave]),
+				drained: (0, react.useCallback)(async () => {
+					await autosave.drained();
+				}, [autosave]),
 				markWritten: (0, react.useCallback)((input) => {
 					writtenSignature.current = signature(input);
 				}, [signature]),
@@ -25086,20 +25089,21 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
 			return ordinals(allMarks(marks));
 		}
 		/**
-		* Drop one mark from wherever in the document it was drawn.
+		* Drop several marks from wherever in the document they were drawn.
 		*
-		* The list shows the whole file, so its delete button can name a mark on a page the
-		* surface is not holding: the owner is the only one that knows every page.
+		* A hand-off removes exactly the marks it carried. Doing that by repeatedly dropping
+		* one mark would visit every page once per delivered mark, which matters on a large
+		* document; this keeps it to one visit per page.
 		*
 		* @param marks - every page's marks.
-		* @param id - the mark to remove.
-		* @returns the new map, or the same one when no page carried that mark.
+		* @param ids - the marks that were delivered.
+		* @returns the new map, or the same one when no page carried any of them.
 		*/
-		function withoutMark(marks, id) {
+		function withoutMarks(marks, ids) {
 			let changed = false;
 			const next = new Map(marks);
 			for (const [page, pageMarks] of marks) {
-				const kept = pageMarks.filter((mark) => mark.id !== id);
+				const kept = pageMarks.filter((mark) => !ids.has(mark.id));
 				if (kept.length !== pageMarks.length) {
 					changed = true;
 					next.set(page, kept);
@@ -25167,6 +25171,7 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
 		*/
 		async function discardDocument(context) {
 			context.autosave.cancel();
+			await context.autosave.drained();
 			context.autosave.forget();
 			try {
 				await context.seat.discard(context.address);
@@ -25185,60 +25190,98 @@ fn fs_main(in : VertexOutput) -> @location(0) vec4<f32> {
 		* which they cannot see from the pill they pressed.
 		*
 		* @param context - the document being saved.
-		* @param target - who receives the annotation.
 		* @param only - the single mark being sent, or undefined to send the document.
+		* @returns the ready snapshot, or why there is none.
 		*/
-		async function saveAndDeliver(context, target, only) {
+		function prepareDelivery(context, only) {
 			const collected = context.collect();
-			if (collected === null) {
-				context.fail(context.copy.notReady);
-				return;
-			}
+			if (collected === null) return { kind: "not-ready" };
 			const input = only === void 0 ? collected : {
 				...collected,
 				marks: collected.marks.filter((mark) => mark.id === only.id)
 			};
-			const { pdf, bytes } = context;
-			if (input.marks.length === 0) {
-				context.fail(context.copy.nothingToSend);
-				return;
-			}
+			if (input.marks.length === 0) return { kind: "nothing" };
 			/* v8 ignore start -- a collected document always carries both, for the reason above. */
-			if (pdf === null || bytes === void 0) {
-				context.fail(context.copy.notReady);
-				return;
-			}
+			const { pdf, bytes } = context;
+			if (pdf === null || bytes === void 0) return { kind: "not-ready" };
 			/* v8 ignore stop */
-			context.setBusy(true);
-			context.say(target === "agent" ? context.copy.sending : context.copy.composing);
-			try {
-				const pages = markedPages(groupByPage(input.marks));
-				const annotatedPdf = await context.annotate(bytes, pdf, pages, context.figureUnit);
-				const saved = await context.seat.save(context.address, input, annotatedPdf);
-				context.autosave.cancel();
-				context.autosave.markWritten(input);
-				context.setCreatedAt(input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString());
-				context.setStale(false);
-				const pageImages = await context.review(pdf, pages);
-				if (target === "composer") {
-					await context.seat.compose(input, saved, pageImages, annotatedPdf);
-					context.say(only === void 0 ? context.copy.composed : context.copy.composedOne);
-				} else {
-					const warnings = await context.seat.send(input, saved, pageImages, annotatedPdf);
-					const delivered = only === void 0 ? context.copy.sent : context.copy.sentOne;
-					context.say(`${delivered}${warnings.length === 0 ? "" : ` ${warnings.join(" ")}`}`);
+			return {
+				kind: "ready",
+				value: {
+					input,
+					whole: only === void 0,
+					pdf,
+					bytes
 				}
-				if (only === void 0) {
-					await discardDocument(context);
-					return;
+			};
+		}
+		/**
+		* Write and hand off one prepared snapshot.
+		*
+		* Failures are thrown rather than painted here: the caller owns the send card, and
+		* that card can only show its retry button when the same task rejects.
+		*/
+		async function saveAndDeliver(context, target, prepared) {
+			context.setBusy(true);
+			const outcome = await writePrepared(context, target, prepared).then((value) => ({
+				ok: true,
+				value
+			}), (cause) => ({
+				ok: false,
+				cause
+			}));
+			context.setBusy(false);
+			if (!outcome.ok) throw new Error(`${context.copy.saveFailed}${messageOf(outcome.cause)}`);
+			return outcome.value;
+		}
+		/**
+		* Write one prepared snapshot and update the document afterwards.
+		*
+		* Kept apart from the busy flag so a rejection has one unwind point: the
+		* public function turns the promise into either its warnings or the sentence
+		* the retryable toast card shows.
+		*/
+		async function writePrepared(context, target, prepared) {
+			const { input, whole, pdf, bytes } = prepared;
+			const pages = markedPages(groupByPage(input.marks));
+			const annotatedPdf = await context.annotate(bytes, pdf, pages, context.figureUnit);
+			const saved = await context.seat.save(context.address, input, annotatedPdf);
+			context.autosave.cancel();
+			context.autosave.markWritten(input);
+			context.setCreatedAt(input.createdAt ?? (/* @__PURE__ */ new Date()).toISOString());
+			context.setStale(false);
+			const pageImages = await context.review(pdf, pages);
+			if (target === "composer") await context.seat.compose(input, saved, pageImages);
+			else {
+				const warnings = await context.seat.send(input, saved, pageImages);
+				if (whole) {
+					const sentIds = new Set(input.marks.map((mark) => mark.id));
+					const sentSummary = input.summary;
+					context.autosave.cancel();
+					await context.autosave.drained();
+					try {
+						await context.seat.discard(context.address);
+					} catch (cause) {
+						context.fail(`${context.copy.clearFailed}${messageOf(cause)}`);
+					}
+					context.delivered(sentIds, sentSummary, true);
+					return warnings;
 				}
-				context.autosave.forget();
-				context.dropped(only.id);
+				context.autosave.cancel();
+				await context.autosave.drained();
+				context.delivered(new Set(input.marks.map((mark) => mark.id)), input.summary, false);
+				return warnings;
+			}
+			const ids = new Set(input.marks.map((mark) => mark.id));
+			context.autosave.cancel();
+			await context.autosave.drained();
+			if (whole) try {
+				await context.seat.discard(context.address);
 			} catch (cause) {
-				context.fail(`${context.copy.saveFailed}${messageOf(cause)}`);
-			} finally {
-				context.setBusy(false);
+				context.fail(`${context.copy.clearFailed}${messageOf(cause)}`);
 			}
+			context.delivered(ids, input.summary, whole);
+			return [];
 		}
 		//#endregion
 		//#region node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js
@@ -50953,7 +50996,8 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 		* @returns the document's toolbar and the page on screen, or why it is not there yet.
 		*/
 		function PdfBody(props) {
-			const { AnnotatorBody, seat, t } = props;
+			const { AnnotatorBody, seat, t, toasts, ToastStack } = props;
+			const { note, notify } = toasts;
 			const address = props.resourceAddress ?? "";
 			const { createAutosave, annotationSignature, autosaveDelayMs, figureUnit, markOrdinals } = props;
 			const bytes = props.content?.kind === "bytes" ? props.content.data : void 0;
@@ -50999,7 +51043,23 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 			*/
 			const [zoom, setZoom] = (0, react.useState)("fit");
 			const [busy, setBusy] = (0, react.useState)(false);
-			const [status, setStatus] = (0, react.useState)(null);
+			/**
+			* The latest values a late delivery callback has to see.
+			*
+			* A send closes over the context that started it. Marks and notes added while the
+			* session answers render into newer contexts; keeping the current values in a ref
+			* lets the first context remove only its own snapshot without losing the newer work.
+			*/
+			const latest = (0, react.useRef)({
+				marks,
+				summary,
+				createdAt
+			});
+			latest.current = {
+				marks,
+				summary,
+				createdAt
+			};
 			const zoomFactor = zoom === "fit" ? 1 : zoom;
 			const renderWidth = renderWidthFor(pane.width, zoomFactor);
 			/**
@@ -51021,11 +51081,11 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 					setCreatedAt(saved.createdAt);
 				}, []),
 				fail: (0, react.useCallback)((cause) => {
-					setStatus({
+					note({
 						tone: "error",
 						text: `${translateRef.current("readError")}${messageOf(cause)}`
 					});
-				}, [])
+				}, [note])
 			});
 			(0, react.useEffect)(() => {
 				if (pdf === null || renderWidth < 120) return;
@@ -51075,6 +51135,7 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 			const revealMark = (0, react.useCallback)((mark) => {
 				setSelectedId(mark.id);
 				if (mark.page !== void 0) paging.goTo(mark.page);
+				setOpenPanel(null);
 			}, [paging]);
 			/** Everything one save persists, or null while the document is still unknown. */
 			const collect = (0, react.useCallback)(() => collectInput(figure, pageCount, address, marks, summary, createdAt), [
@@ -51103,35 +51164,23 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 					annotationSignature,
 					autosaveDelayMs,
 					onError: (0, react.useCallback)((cause) => {
-						setStatus({
+						note({
 							tone: "error",
 							text: `${translateRef.current("saveError")}${messageOf(cause)}`
 						});
-					}, [])
+					}, [note])
 				}),
-				say: (0, react.useCallback)((text) => {
-					setStatus({
-						tone: "info",
-						text
-					});
-				}, []),
 				fail: (0, react.useCallback)((text) => {
-					setStatus({
+					note({
 						tone: "error",
 						text
 					});
-				}, []),
+				}, [note]),
 				setBusy,
 				copy: {
 					saveFailed: t("saveError"),
 					notReady: t("notReady"),
 					nothingToSend: t("sendNothingToSend"),
-					sending: t("sending"),
-					composing: t("composing"),
-					composed: t("composed"),
-					composedOne: t("composedOne"),
-					sent: t("sent"),
-					sentOne: t("sentOne"),
 					clearFailed: t("clearError")
 				},
 				cleared: (0, react.useCallback)(() => {
@@ -51141,20 +51190,49 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 					setStale(false);
 					setGeneration((current) => current + 1);
 				}, []),
-				dropped: (0, react.useCallback)((id) => {
-					setMarks((current) => withoutMark(current, id));
+				delivered: (0, react.useCallback)((ids, sentSummary, summaryDelivered) => {
+					const current = latest.current;
+					const next = withoutMarks(current.marks, ids);
+					const keptSummary = summaryDelivered && current.summary === sentSummary ? "" : current.summary;
+					const remains = allMarks(next).length > 0 || keptSummary.trim() !== "";
+					setMarks(next);
+					setSummary(keptSummary);
+					setCreatedAt(remains ? current.createdAt : null);
+					setGeneration((current) => current + 1);
 				}, []),
 				setCreatedAt,
 				setStale
 			};
 			const contextRef = (0, react.useRef)(saveContext);
 			contextRef.current = saveContext;
-			const run = (0, react.useCallback)((target) => {
-				saveAndDeliver(contextRef.current, target);
-			}, []);
+			const run = (0, react.useCallback)((target, only) => {
+				const context = contextRef.current;
+				const prepared = prepareDelivery(context, only);
+				if (prepared.kind === "not-ready") {
+					note({
+						tone: "info",
+						text: context.copy.notReady
+					});
+					return;
+				}
+				if (prepared.kind === "nothing") {
+					notify("annotate.none");
+					return;
+				}
+				const event = target === "agent" ? "annotate.send.agent" : only === void 0 ? "annotate.save.all" : "annotate.save.one";
+				let warnings = [];
+				notify(event, async () => {
+					warnings = await saveAndDeliver(context, target, prepared.value);
+				}).then((outcome) => {
+					if (outcome === "ok" && warnings.length > 0) note({
+						tone: "info",
+						text: warnings.join(" ")
+					});
+				});
+			}, [note, notify]);
 			const runOne = (0, react.useCallback)((mark, target) => {
-				saveAndDeliver(contextRef.current, target, mark);
-			}, []);
+				run(target, mark);
+			}, [run]);
 			const clearDocument = (0, react.useCallback)(() => {
 				discardDocument(contextRef.current);
 			}, []);
@@ -51210,10 +51288,10 @@ while (prev === _win[++scan] && prev === _win[++scan] && prev === _win[++scan] &
 						"data-tone": "error",
 						children: t("stale")
 					}) : null,
-					status === null ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
-						className: "da-status",
-						"data-tone": status.tone === "info" ? void 0 : status.tone,
-						children: status.text
+					/* @__PURE__ */ (0, react_jsx_runtime.jsx)(ToastStack, {
+						view: toasts,
+						label: t("close"),
+						resendLabel: t("toastResend")
 					}),
 					error !== null ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("p", {
 						className: "da-hint",