@stll/folio-core 0.60.0 → 0.62.0

package/dist/prosemirror/runFormattingReconciliation.js

@@ -1,8 +1,9 @@
 import { mergeTextFormatting } from "../utils/textFormattingMerge.js";
-import { expectCharacterStyleMarkAttrs } from "./attrs/index.js";
+import { expectCharacterStyleMarkAttrs, expectRunIdentityMarkAttrs } from "./attrs/index.js";
 import { textFormattingToMarks } from "./extensions/marks/markUtils.js";
 import { marksToTextFormatting } from "./runFormattingFromMarks.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
+import { RUN_IDENTITY_MARK_NAME } from "./runIdentity.js";
 import { getParagraphMarkSuppressionOverrides, hasDirectRunFormatting, isParagraphMarkSuppressionEligible, paragraphFormattingForRun, resolveEffectiveRunStyleFormatting } from "./runStyleFormatting.js";
 import { Mark } from "prosemirror-model";
 //#region src/prosemirror/runFormattingReconciliation.ts
@@ -14,6 +15,13 @@ const readAuthoredRunFormatting = ({ context, marks, styleResolver }) => marksTo
 	paragraphMarkPrecedesStyle: context.paragraphMarkPrecedesStyle,
 	...styleResolver !== void 0 ? { styleResolver } : {}
 });
+/** Preserve the authored distinction between an absent and empty property set in revisions. */
+const readAuthoredRunPropertySnapshot = (options) => {
+	const formatting = readAuthoredRunFormatting(options);
+	if (Object.keys(formatting).length > 0) return formatting;
+	const identity = options.marks.find(({ type }) => type.name === RUN_IDENTITY_MARK_NAME);
+	return identity && expectRunIdentityMarkAttrs(identity).emptyFormatting ? formatting : void 0;
+};
 /**
 * Rebuild a run's physical formatting marks from its authored properties and
 * current style context. This is the inverse of {@link readAuthoredRunFormatting}:
@@ -54,4 +62,4 @@ const reconcileRunFormattingMarks = ({ authoredFormatting, context, node, styleR
 	]);
 };
 //#endregion
-export { readAuthoredRunFormatting, reconcileRunFormattingMarks };
+export { readAuthoredRunFormatting, readAuthoredRunPropertySnapshot, reconcileRunFormattingMarks };

package/dist/prosemirror/runIdentityAcrossRevisions.d.ts

@@ -1,10 +1,8 @@
 import { Node } from "prosemirror-model";
 //#region src/prosemirror/runIdentityAcrossRevisions.d.ts
-/**
- * `nodes`, one inline container's content, with each run a revision cut given
- * the identity of the run it was cut from. A control is a container of its
- * own. `nodes` itself comes back when nothing changes.
- */
-declare const continueRunIdentitiesAcrossRevisions: (nodes: readonly Node[]) => readonly Node[];
+/** The continuation policy covers every declared source-carrier mark. */
+declare const SOURCE_CARRIER_MARK_NAMES: ("hyperlink" | "runIdentity")[];
+/** Every source-carrier family uses the same revision-boundary continuation policy. */
+declare const continueSourceCarrierIdentitiesAcrossRevisions: (nodes: readonly Node[]) => readonly Node[];
 //#endregion
-export { continueRunIdentitiesAcrossRevisions };
+export { SOURCE_CARRIER_MARK_NAMES, continueSourceCarrierIdentitiesAcrossRevisions };

package/dist/prosemirror/runIdentityAcrossRevisions.js

@@ -1,52 +1,73 @@
-import { expectRunIdentityMarkAttrs } from "./attrs/index.js";
+import { expectHyperlinkMarkAttrs, expectRunIdentityMarkAttrs } from "./attrs/index.js";
 import "./extensions/nodes/SdtExtension.js";
 import { RUN_IDENTITY_MARK_NAME } from "./runIdentity.js";
 import { Fragment, Mark } from "prosemirror-model";
 //#region src/prosemirror/runIdentityAcrossRevisions.ts
 /**
-* One run identity for the pieces of a `w:r` a tracked change cut.
-*
-* A revision inside a run splits it: `<w:r a>Sel</w:r><w:del><w:r a>ler</w:r></w:del>`,
-* `<w:r a>Sel</w:r><w:ins>…</w:ins><w:r a>ler</w:r>`, or a `w:rPrChange` on
-* one piece of the run only. Read back, each
-* `w:r` is its own authored run, so resolving the revision would leave two
-* runs where the source had one. The package cannot say whether the two were
-* one run, but runs that carry the same attributes and that only revised
-* content holds apart are what such a cut writes, so the later piece takes the
-* earlier one's identity. The pieces stay separate runs while the revision
-* holds them apart, and become one run once it is resolved and they state the
-* same properties again (a run joins its owner only then, see `fromProseDoc`).
-*
-* Runs the package writes side by side under the same revision state keep
-* their own identities.
+* One source identity for matching runs and hyperlinks a revision cut apart.
+* Serialized fragments mint separate identities on reopen. Matching fragments
+* across a revision boundary or revised-only bridge take the earlier identity,
+* so resolution can rejoin them. Every non-identity attribute must match.
+* Adjacent carriers under the same revision state keep their source identities.
 */
 const REVISION_MARK_NAMES = /* @__PURE__ */ new Set([
 	"insertion",
 	"deletion",
 	"runPropertyChange"
 ]);
-const identityOf = (node) => node.marks.find((mark) => mark.type.name === RUN_IDENTITY_MARK_NAME);
+const CARRIER_OWNERS = [{
+	markName: RUN_IDENTITY_MARK_NAME,
+	read: (mark) => {
+		const attrs = expectRunIdentityMarkAttrs(mark);
+		return {
+			id: attrs.id,
+			payloadKey: JSON.stringify({
+				...attrs,
+				id: 0
+			})
+		};
+	}
+}, {
+	markName: "hyperlink",
+	read: (mark) => {
+		const attrs = expectHyperlinkMarkAttrs(mark);
+		if (typeof attrs._docxHyperlinkIndex !== "number") return void 0;
+		return {
+			id: attrs._docxHyperlinkIndex,
+			payloadKey: JSON.stringify({
+				...attrs,
+				_docxHyperlinkIndex: 0
+			})
+		};
+	}
+}];
+/** The continuation policy covers every declared source-carrier mark. */
+const SOURCE_CARRIER_MARK_NAMES = CARRIER_OWNERS.map(({ markName }) => markName);
+const identityOf = (node, owner) => {
+	const mark = node.marks.find((candidate) => candidate.type.name === owner.markName);
+	if (!mark) return void 0;
+	const identity = owner.read(mark);
+	return identity === void 0 ? void 0 : {
+		mark,
+		...identity
+	};
+};
 const revisionMarksOf = (node) => node.marks.filter((mark) => REVISION_MARK_NAMES.has(mark.type.name));
-/** The identity's attrs without the id: what the run carries. */
-const payloadKey = (identity) => JSON.stringify({
-	...expectRunIdentityMarkAttrs(identity),
-	id: 0
-});
 /** Whether `right` continues `left`'s run across a revision boundary. */
-const continuesRun = ({ left, right, bridged }) => {
-	const leftIdentity = identityOf(left);
-	const rightIdentity = identityOf(right);
-	if (!leftIdentity || !rightIdentity || leftIdentity.eq(rightIdentity)) return false;
-	return (bridged || !Mark.sameSet(revisionMarksOf(left), revisionMarksOf(right))) && payloadKey(leftIdentity) === payloadKey(rightIdentity);
+const continuesCarrier = ({ left, right, bridged, owner }) => {
+	const leftIdentity = identityOf(left, owner);
+	const rightIdentity = identityOf(right, owner);
+	if (!leftIdentity || !rightIdentity || leftIdentity.mark.eq(rightIdentity.mark)) return false;
+	return (bridged || !Mark.sameSet(revisionMarksOf(left), revisionMarksOf(right))) && leftIdentity.payloadKey === rightIdentity.payloadKey;
 };
 /**
-* `nodes`, one inline container's content, with each run a revision cut given
-* the identity of the run it was cut from. A control is a container of its
+* `nodes`, one inline container's content, with each revision fragment given
+* the identity of its matching source carrier. A control is a container of its
 * own. `nodes` itself comes back when nothing changes.
 */
-const continueRunIdentitiesAcrossRevisions = (nodes) => {
+const continueIdentities = (nodes, owner) => {
 	const renamed = /* @__PURE__ */ new Map();
-	/** The last run with an identity, while only revised content follows it. */
+	/** The last carrier with an identity, while only revised content follows it. */
 	let anchor;
 	let bridged = false;
 	let changed = false;
@@ -57,25 +78,26 @@ const continueRunIdentitiesAcrossRevisions = (nodes) => {
 			node.forEach((child) => {
 				children.push(child);
 			});
-			const continued = continueRunIdentitiesAcrossRevisions(children);
+			const continued = continueIdentities(children, owner);
 			if (continued === children) return node;
 			changed = true;
 			return node.copy(Fragment.fromArray([...continued]));
 		}
-		const identity = identityOf(node);
+		const identity = identityOf(node, owner);
 		if (!identity) {
 			if (anchor && revisionMarksOf(node).length > 0) bridged = true;
 			else anchor = void 0;
 			return node;
 		}
-		const id = expectRunIdentityMarkAttrs(identity).id;
+		const id = identity.id;
 		let replacement = renamed.get(id);
-		if (!replacement && anchor && continuesRun({
+		if (!replacement && anchor && continuesCarrier({
 			left: anchor,
 			right: node,
-			bridged
+			bridged,
+			owner
 		})) {
-			replacement = identityOf(anchor);
+			replacement = identityOf(anchor, owner)?.mark;
 			if (replacement) renamed.set(id, replacement);
 		}
 		const next = replacement ? node.mark(replacement.addToSet(node.marks)) : node;
@@ -86,5 +108,11 @@ const continueRunIdentitiesAcrossRevisions = (nodes) => {
 	});
 	return changed ? result : nodes;
 };
+/** Every source-carrier family uses the same revision-boundary continuation policy. */
+const continueSourceCarrierIdentitiesAcrossRevisions = (nodes) => {
+	let continued = nodes;
+	for (const owner of CARRIER_OWNERS) continued = continueIdentities(continued, owner);
+	return continued;
+};
 //#endregion
-export { continueRunIdentitiesAcrossRevisions };
+export { SOURCE_CARRIER_MARK_NAMES, continueSourceCarrierIdentitiesAcrossRevisions };

package/dist/prosemirror/runPropertyChangeResolution.js

@@ -1,6 +1,8 @@
+import { expectRunIdentityMarkAttrs } from "./attrs/index.js";
 import { runFormattingInlineAtomDisposition } from "./runFormattingInlineCarriers.js";
 import { RUN_FORMATTING_MARK_NAMES } from "./runFormattingMarkNames.js";
 import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { RUN_IDENTITY_MARK_NAME, runIdentityAttrs } from "./runIdentity.js";
 //#region src/prosemirror/runPropertyChangeResolution.ts
 /**
 * Rebuild the pre-change run marks against the paragraph's live style cascade.
@@ -8,12 +10,22 @@ import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFor
 * owner so their reject semantics cannot diverge at the bulk threshold.
 */
 const reconstructRejectedRunFormattingMarks = ({ node, paragraphContext, previousFormatting, styleResolver }) => {
-	return reconcileRunFormattingMarks({
+	const formatting = reconcileRunFormattingMarks({
 		authoredFormatting: previousFormatting ?? {},
 		context: paragraphContext,
 		node,
 		...styleResolver !== void 0 ? { styleResolver } : {}
 	}).filter(({ type }) => RUN_FORMATTING_MARK_NAMES.has(type.name));
+	if (previousFormatting === void 0 || Object.keys(previousFormatting).length > 0) return formatting;
+	const identityType = node.type.schema.marks[RUN_IDENTITY_MARK_NAME];
+	if (!identityType) return formatting;
+	const identity = node.marks.find(({ type }) => type === identityType);
+	const attrs = identity ? expectRunIdentityMarkAttrs(identity) : void 0;
+	return [...formatting, identityType.create(runIdentityAttrs(attrs?.id ?? 0, {
+		preservedAttributes: attrs?.preservedAttributes ?? void 0,
+		preserved: attrs?.preserved ?? void 0,
+		emptyFormatting: true
+	}))];
 };
 /** Restored deletions inherit the live paragraph cascade without authoring their historical visuals. */
 const restoreHistoricalRunFormatting = ({ node, paragraphContext, styleResolver }) => {

package/dist/prosemirror/trackedRunInlineAtoms.d.ts

@@ -21,7 +21,7 @@ declare const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS: Readonly<{
   readonly pageBreakRun: "page-break-carrier";
   readonly preservedXml: "carry";
   readonly rangeAnchor: "transparent";
-  readonly renderedPageBreak: "transparent";
+  readonly renderedPageBreak: "carry";
   readonly shape: "carry";
   readonly structuredField: "carry";
   readonly symbol: "carry";

package/dist/prosemirror/trackedRunInlineAtoms.js

@@ -20,7 +20,7 @@ const TRACKED_RUN_INLINE_ATOM_DISPOSITIONS = Object.freeze({
 	pageBreakRun: "page-break-carrier",
 	preservedXml: "carry",
 	rangeAnchor: "transparent",
-	renderedPageBreak: "transparent",
+	renderedPageBreak: "carry",
 	shape: "carry",
 	structuredField: "carry",
 	symbol: "carry",

package/dist/utils/base64.d.ts

@@ -1,35 +1,5 @@
+import { bytesToBase64, encodeBase64Portable } from "@stll/utf8-boundaries";
 //#region src/utils/base64.d.ts
-/**
- * The package's one bytes-to-base64 encoder.
- *
- * Every call site that spelled this itself got a different answer to the same
- * two questions, and one of them got the first question wrong:
- *
- * - `btoa(new TextDecoder("latin1").decode(bytes))` is not a binary string.
- *   The Encoding standard maps the `latin1` label to windows-1252, so bytes
- *   0x80-0x9F decode to characters outside Latin-1 and `btoa` throws
- *   `InvalidCharacterError` on them. Ordinary image bytes contain those values,
- *   so the browser path of that spelling fails on real input.
- * - `String.fromCharCode(...chunk)` is correct but spreads a chunk's worth of
- *   arguments per call, and the intermediate binary string is as large as the
- *   input.
- *
- * Neither question has to be asked per call site, so it is asked here once.
- * The runtime's own encoder answers it when the runtime has one, and the
- * portable encoder below answers it when not; both produce canonical base64,
- * so the choice is invisible in the output.
- */
-/**
- * Encode into exactly one intermediate buffer: ASCII codes are written into a
- * single array and decoded once, so a megabyte-scale input leaves the output
- * string and nothing else.
- *
- * Exported because the runtimes the tests run on all carry a native encoder,
- * and the fallback is the branch the browsers that lack one take.
- */
-declare const encodeBase64Portable: (bytes: Uint8Array) => string;
-/** Encode bytes as canonical, padded, standard-alphabet base64. */
-declare const bytesToBase64: (bytes: Uint8Array) => string;
 /** Encode bytes as a `data:` URL with the given media type. */
 declare const bytesToDataUrl: (bytes: Uint8Array, mimeType: string) => string;
 //#endregion

package/dist/utils/base64.js

@@ -1,40 +1,26 @@
+import { bytesToBase64, bytesToBase64 as bytesToBase64$1, encodeBase64Portable } from "@stll/utf8-boundaries";
 //#region src/utils/base64.ts
-const BASE64_CODES = Uint8Array.from("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", (character) => character.charCodeAt(0));
-const BASE64_PAD = 61;
 /**
-* Encode into exactly one intermediate buffer: ASCII codes are written into a
-* single array and decoded once, so a megabyte-scale input leaves the output
-* string and nothing else.
+* The package's one bytes-to-base64 encoder.
 *
-* Exported because the runtimes the tests run on all carry a native encoder,
-* and the fallback is the branch the browsers that lack one take.
+* Every call site that spelled this itself got a different answer to the same
+* two questions, and one of them got the first question wrong:
+*
+* - `btoa(new TextDecoder("latin1").decode(bytes))` is not a binary string.
+*   The Encoding standard maps the `latin1` label to windows-1252, so bytes
+*   0x80-0x9F decode to characters outside Latin-1 and `btoa` throws
+*   `InvalidCharacterError` on them. Ordinary image bytes contain those values,
+*   so the browser path of that spelling fails on real input.
+* - `String.fromCharCode(...chunk)` is correct but spreads a chunk's worth of
+*   arguments per call, and the intermediate binary string is as large as the
+*   input.
+*
+* Neither question has to be asked per call site, so it is asked here once.
+* The runtime's own encoder answers it when the runtime has one, and the
+* portable encoder in the shared owner answers it when not; both produce canonical base64,
+* so the choice is invisible in the output.
 */
-const encodeBase64Portable = (bytes) => {
-	const groups = Math.ceil(bytes.length / 3);
-	const encoded = new Uint8Array(groups * 4);
-	let read = 0;
-	let write = 0;
-	for (; read + 2 < bytes.length; read += 3) {
-		const triple = bytes[read] << 16 | bytes[read + 1] << 8 | bytes[read + 2];
-		encoded[write] = BASE64_CODES[triple >> 18 & 63];
-		encoded[write + 1] = BASE64_CODES[triple >> 12 & 63];
-		encoded[write + 2] = BASE64_CODES[triple >> 6 & 63];
-		encoded[write + 3] = BASE64_CODES[triple & 63];
-		write += 4;
-	}
-	const remaining = bytes.length - read;
-	if (remaining > 0) {
-		const tail = bytes[read] << 16 | (remaining === 2 ? bytes[read + 1] << 8 : 0);
-		encoded[write] = BASE64_CODES[tail >> 18 & 63];
-		encoded[write + 1] = BASE64_CODES[tail >> 12 & 63];
-		encoded[write + 2] = remaining === 2 ? BASE64_CODES[tail >> 6 & 63] : BASE64_PAD;
-		encoded[write + 3] = BASE64_PAD;
-	}
-	return new TextDecoder().decode(encoded);
-};
-/** Encode bytes as canonical, padded, standard-alphabet base64. */
-const bytesToBase64 = ("toBase64" in Uint8Array.prototype ? (bytes) => bytes.toBase64() : void 0) ?? encodeBase64Portable;
 /** Encode bytes as a `data:` URL with the given media type. */
-const bytesToDataUrl = (bytes, mimeType) => `data:${mimeType};base64,${bytesToBase64(bytes)}`;
+const bytesToDataUrl = (bytes, mimeType) => `data:${mimeType};base64,${bytesToBase64$1(bytes)}`;
 //#endregion
 export { bytesToBase64, bytesToDataUrl, encodeBase64Portable };

package/dist/utils/clipboard.js

@@ -1,5 +1,6 @@
 import { htmlCommentEnd } from "./htmlComments.js";
 import { stripXmlDeclarations } from "./stripXmlDeclarations.js";
+import { encodeUtf8, readBlobText } from "./textEncoding.js";
 import { sanitizeXmlCharacters } from "@stll/docx-core";
 import createDOMPurify from "dompurify";
 //#region src/utils/clipboard.ts
@@ -171,8 +172,8 @@ function paragraphsToClipboardContent(paragraphs, includeFormatting = true) {
 async function writeToClipboard(content) {
 	try {
 		const items = [new ClipboardItem({
-			[CLIPBOARD_TYPES.PLAIN]: new Blob([content.plainText], { type: CLIPBOARD_TYPES.PLAIN }),
-			[CLIPBOARD_TYPES.HTML]: new Blob([content.html], { type: CLIPBOARD_TYPES.HTML })
+			[CLIPBOARD_TYPES.PLAIN]: new Blob([encodeUtf8(content.plainText)], { type: CLIPBOARD_TYPES.PLAIN }),
+			[CLIPBOARD_TYPES.HTML]: new Blob([encodeUtf8(content.html)], { type: CLIPBOARD_TYPES.HTML })
 		})];
 		await navigator.clipboard.write(items);
 		return true;
@@ -222,8 +223,8 @@ async function parseClipboardItems(items, cleanWordFormatting) {
 	let html = "";
 	let plainText = "";
 	for (const item of items) {
-		if (item.types.includes(CLIPBOARD_TYPES.HTML)) html = await (await item.getType(CLIPBOARD_TYPES.HTML)).text();
-		if (item.types.includes(CLIPBOARD_TYPES.PLAIN)) plainText = await (await item.getType(CLIPBOARD_TYPES.PLAIN)).text();
+		if (item.types.includes(CLIPBOARD_TYPES.HTML)) html = await readBlobText(await item.getType(CLIPBOARD_TYPES.HTML));
+		if (item.types.includes(CLIPBOARD_TYPES.PLAIN)) plainText = await readBlobText(await item.getType(CLIPBOARD_TYPES.PLAIN));
 	}
 	return parseClipboardHtml(html, plainText, cleanWordFormatting);
 }

package/dist/utils/colorResolver.js

@@ -1,3 +1,4 @@
+import { sliceText } from "./sliceText.js";
 import { THEME_COLOR_BY_SCHEME_COLOR_VALUE, isSchemeColorValue, isThemeColor, themeColorSlot } from "@stll/docx-core/model";
 //#region src/utils/colorResolver.ts
 /**
@@ -109,7 +110,11 @@ function parseModifierValue(hexValue) {
 * @returns RGB object with r, g, b values 0-255
 */
 function hexToRgb(hex) {
-	const normalized = hex.padStart(6, "0").slice(0, 6);
+	const normalized = sliceText({
+		text: hex.padStart(6, "0"),
+		units: "codeUnits",
+		end: 6
+	});
 	const r = Number.parseInt(normalized.slice(0, 2), 16);
 	const g = Number.parseInt(normalized.slice(2, 4), 16);
 	const b = Number.parseInt(normalized.slice(4, 6), 16);
@@ -293,7 +298,11 @@ function parseColorString(colorString) {
 	const hex = normalized.replace(/^#/u, "").toUpperCase();
 	if (/^[0-9A-F]{6}$/iu.test(hex)) return { rgb: hex };
 	if (/^[0-9A-F]{3}$/iu.test(hex)) return { rgb: hex.split("").map((c) => c + c).join("") };
-	return { rgb: hex.padStart(6, "0").slice(0, 6) };
+	return { rgb: sliceText({
+		text: hex.padStart(6, "0"),
+		units: "codeUnits",
+		end: 6
+	}) };
 }
 /**
 * Create a ColorValue from theme color reference

package/dist/utils/findMatchView.d.ts

@@ -0,0 +1,32 @@
+import { document_d_exports } from "../types/document.js";
+import { Layout } from "../layout-engine/types.js";
+import { FindMatch } from "./findReplace.js";
+import { FindMatchRange } from "../prosemirror/findReplaceSelection.js";
+import { Node } from "prosemirror-model";
+import { OpStory } from "@stll/docx-core/ops";
+//#region src/utils/findMatchView.d.ts
+/** The same page variant selection used by the painter, including unmounted pages. */
+declare const getRenderedSearchStories: (layout: Layout | null) => OpStory[];
+type ResolvedMatch = FindMatchRange & {
+  index: number;
+  story: OpStory;
+};
+type FindMatchViewOptions = {
+  container: HTMLElement;
+  document: document_d_exports.Document;
+  bodyDoc?: Node | undefined;
+  matches: readonly FindMatch[];
+  commentRoot?: HTMLElement | undefined;
+  layout?: Layout | null | undefined;
+};
+/** Resolve each story once; box positions are local to their parent story. */
+declare const resolveDocumentFindRanges: ({ document, bodyDoc, matches }: Omit<FindMatchViewOptions, "container" | "commentRoot" | "layout">) => ResolvedMatch[];
+/** Paint search geometry over the existing page DOM, without changing editor state. */
+declare const createFindMatchView: (options: FindMatchViewOptions) => {
+  paint: (index: number) => void;
+  reveal: (index: number) => boolean;
+  navigate: (index: number, activateComment?: (commentId: number) => void) => void;
+  destroy: () => void;
+};
+//#endregion
+export { createFindMatchView, getRenderedSearchStories, resolveDocumentFindRanges };