@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/fonts/embeddedFonts.js

@@ -0,0 +1,112 @@
+import { parseRelationships, resolveRelativePath } from "../docx/relsParser.js";
+import { unzipDocx } from "../docx/unzip.js";
+import { deobfuscateFont, isValidFontKey } from "./fontDeobfuscation.js";
+import { parseEmbeddedFontTable } from "./embeddedFontTable.js";
+//#region src/fonts/embeddedFonts.ts
+/**
+* Embedded-font extraction.
+*
+* Turns the obfuscated `word/fonts/*.odttf` binaries a `.docx` carries into
+* de-obfuscated OpenType/TrueType faces the renderer can register as
+* `@font-face`s, so documents whose fonts are embedded (rather than installed)
+* render in their authored fonts instead of a fallback.
+*
+* The core is pure and framework-free: {@link getEmbeddedFontFaces} works over
+* already-unzipped package parts; {@link extractEmbeddedFonts} is the buffer
+* convenience that unzips first. Neither touches the DOM. Round-trip
+* preservation is unaffected: the serializer copies `word/fonts/*` and
+* `fontTable.xml` from the original ZIP untouched, so this is a read-only view.
+*
+* Ported from eigenpal/docx-editor (see NOTICE.md).
+*/
+/** Pairs each embed field with the CSS weight/style it renders as. */
+const EMBED_KINDS = [
+	{
+		ref: "embedRegular",
+		weight: 400,
+		style: "normal"
+	},
+	{
+		ref: "embedBold",
+		weight: 700,
+		style: "normal"
+	},
+	{
+		ref: "embedItalic",
+		weight: 400,
+		style: "italic"
+	},
+	{
+		ref: "embedBoldItalic",
+		weight: 700,
+		style: "italic"
+	}
+];
+const FONTTABLE_RELS_BASE_PATH = "word/_rels/fontTable.xml.rels";
+const FONTTABLE_RELS_PATH = "word/_rels/fonttable.xml.rels";
+/** Normalize a package path for comparison: drop leading slashes, lowercase. */
+function normalizePackagePath(path) {
+	return path.replace(/^\/+/u, "").toLowerCase();
+}
+/**
+* Find the font binary for an already-resolved package path (e.g.
+* `word/fonts/font1.odttf`) in the unzipped font map, matched case- and
+* leading-slash-insensitively (ZIP entry casing/prefixes vary across producers).
+*/
+function lookupFontData(resolvedPath, fonts) {
+	const wanted = normalizePackagePath(resolvedPath);
+	for (const [path, data] of fonts) if (normalizePackagePath(path) === wanted) return data;
+}
+function resolveFace(family, ref, kind, fonts, rels) {
+	const target = rels.get(ref.relId)?.target;
+	if (!target) return null;
+	const raw = lookupFontData(resolveRelativePath(FONTTABLE_RELS_BASE_PATH, target), fonts);
+	if (!raw) return null;
+	const bytes = new Uint8Array(raw);
+	const data = ref.fontKey && isValidFontKey(ref.fontKey) ? deobfuscateFont(bytes, ref.fontKey) : bytes;
+	return {
+		family,
+		style: kind.style,
+		weight: kind.weight,
+		bytes: data,
+		subsetted: ref.subsetted ?? false
+	};
+}
+/**
+* Resolve and de-obfuscate every embedded font face declared in a font table.
+* Pure and DOM-free. Faces whose relationship or binary is missing are skipped,
+* so the result only contains faces that produced usable bytes.
+*/
+function getEmbeddedFontFaces(parts) {
+	const entries = parseEmbeddedFontTable(parts.fontTableXml);
+	if (entries.length === 0) return [];
+	if (!parts.fontTableRelsXml || parts.fonts.size === 0) return [];
+	const rels = parseRelationships(parts.fontTableRelsXml);
+	const faces = [];
+	for (const entry of entries) for (const kind of EMBED_KINDS) {
+		const ref = entry[kind.ref];
+		if (!ref) continue;
+		const face = resolveFace(entry.name, ref, kind, parts.fonts, rels);
+		if (face) faces.push(face);
+	}
+	return faces;
+}
+function findFontTableRels(allXml) {
+	for (const [path, xml] of allXml) if (normalizePackagePath(path) === FONTTABLE_RELS_PATH) return xml;
+}
+/**
+* Extract every embedded font face from a raw `.docx` buffer. Unzips the
+* package, then resolves + de-obfuscates the faces via
+* {@link getEmbeddedFontFaces}. Returns an empty list for documents with no
+* embedded fonts.
+*/
+async function extractEmbeddedFonts(buffer) {
+	const raw = await unzipDocx(buffer);
+	return getEmbeddedFontFaces({
+		fontTableXml: raw.fontTableXml,
+		fontTableRelsXml: findFontTableRels(raw.allXml),
+		fonts: raw.fonts
+	});
+}
+//#endregion
+export { extractEmbeddedFonts, getEmbeddedFontFaces };

package/dist/fonts/fontDeobfuscation.d.ts

@@ -0,0 +1,30 @@
+//#region src/fonts/fontDeobfuscation.d.ts
+/**
+ * Embedded-font de-obfuscation (ECMA-376 Part 4 §2.8.1, "Font Embedding").
+ *
+ * Word ships embedded fonts as obfuscated OpenType (`.odttf`): the first 32
+ * bytes of the font binary are XOR-scrambled with a 16-byte key; the rest of
+ * the file is untouched. The key is the font's `w:fontKey` GUID with its byte
+ * order reversed, applied to bytes 0-15 and again to bytes 16-31.
+ *
+ * Example (from the spec): GUID `001B70DC-AA60-4AD5-90EC-18A0948E1EAE` yields
+ * key bytes `AE 1E 8E 94 A0 18 EC 90 D5 4A 60 AA DC 70 1B 00`. The scheme is a
+ * pure XOR, so the same operation obfuscates and de-obfuscates.
+ *
+ * Ported from eigenpal/docx-editor (see NOTICE.md). The ODTTF scheme is an
+ * OOXML interop format, so the algorithm is reproduced faithfully.
+ */
+/**
+ * Whether a string is a usable embedded-font obfuscation key: a 128-bit GUID,
+ * with or without braces and hyphens.
+ */
+declare function isValidFontKey(fontKey: string | undefined | null): boolean;
+/**
+ * De-obfuscate an embedded `.odttf` font into a usable OpenType/TrueType binary
+ * by XOR-ing its first 32 bytes with the reversed `w:fontKey` GUID. Returns a
+ * new array; the input is not mutated. Throws when `fontKey` is not a valid
+ * 128-bit GUID (guard with {@link isValidFontKey} first).
+ */
+declare function deobfuscateFont(data: Uint8Array, fontKey: string): Uint8Array<ArrayBuffer>;
+//#endregion
+export { deobfuscateFont, isValidFontKey };

package/dist/fonts/fontDeobfuscation.js

@@ -0,0 +1,57 @@
+//#region src/fonts/fontDeobfuscation.ts
+/**
+* Embedded-font de-obfuscation (ECMA-376 Part 4 §2.8.1, "Font Embedding").
+*
+* Word ships embedded fonts as obfuscated OpenType (`.odttf`): the first 32
+* bytes of the font binary are XOR-scrambled with a 16-byte key; the rest of
+* the file is untouched. The key is the font's `w:fontKey` GUID with its byte
+* order reversed, applied to bytes 0-15 and again to bytes 16-31.
+*
+* Example (from the spec): GUID `001B70DC-AA60-4AD5-90EC-18A0948E1EAE` yields
+* key bytes `AE 1E 8E 94 A0 18 EC 90 D5 4A 60 AA DC 70 1B 00`. The scheme is a
+* pure XOR, so the same operation obfuscates and de-obfuscates.
+*
+* Ported from eigenpal/docx-editor (see NOTICE.md). The ODTTF scheme is an
+* OOXML interop format, so the algorithm is reproduced faithfully.
+*/
+const HEADER_LENGTH = 32;
+const KEY_LENGTH = 16;
+/**
+* Strip a `w:fontKey` GUID down to its 16 key bytes, in the reversed order the
+* obfuscation applies. Returns null when the value is not a 32-hex-digit GUID.
+*/
+function fontKeyToReversedBytes(fontKey) {
+	const hex = fontKey.replace(/[^0-9a-fA-F]/gu, "");
+	if (hex.length !== KEY_LENGTH * 2) return null;
+	const reversed = new Uint8Array(KEY_LENGTH);
+	for (let i = 0; i < KEY_LENGTH; i++) {
+		const byte = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+		if (Number.isNaN(byte)) return null;
+		reversed[KEY_LENGTH - 1 - i] = byte;
+	}
+	return reversed;
+}
+/**
+* Whether a string is a usable embedded-font obfuscation key: a 128-bit GUID,
+* with or without braces and hyphens.
+*/
+function isValidFontKey(fontKey) {
+	if (!fontKey) return false;
+	return fontKeyToReversedBytes(fontKey) !== null;
+}
+/**
+* De-obfuscate an embedded `.odttf` font into a usable OpenType/TrueType binary
+* by XOR-ing its first 32 bytes with the reversed `w:fontKey` GUID. Returns a
+* new array; the input is not mutated. Throws when `fontKey` is not a valid
+* 128-bit GUID (guard with {@link isValidFontKey} first).
+*/
+function deobfuscateFont(data, fontKey) {
+	const key = fontKeyToReversedBytes(fontKey);
+	if (!key) throw new Error(`Invalid embedded-font key: "${fontKey}"`);
+	const out = new Uint8Array(data);
+	const end = Math.min(HEADER_LENGTH, out.length);
+	for (let i = 0; i < end; i++) out[i] = (out[i] ?? 0) ^ (key[i % KEY_LENGTH] ?? 0);
+	return out;
+}
+//#endregion
+export { deobfuscateFont, isValidFontKey };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { FolioAIBlock, FolioAIBlockAnchor, FolioAIBlockKind, FolioAIBlockPreviewRun, FolioAIComment, FolioAIEditAppliedOperation, FolioAIEditApplyMode, FolioAIEditApplyResult, FolioAIEditOperation, FolioAIEditReviewMeta, FolioAIEditSeverity, FolioAIEditSkipReason, FolioAIEditSkippedOperation, FolioAIEditSnapshot, FolioAISignatureParty } from "./ai-edits/types.js";
+import { applyFolioAIEditOperations } from "./ai-edits/apply.js";
+import { document_d_exports } from "./types/document.js";
+import { createFolioAIEditSnapshot, hashFolioAIBlockText, normalizeFolioAIBlockText } from "./ai-edits/snapshot.js";
+import { DeriveBlockIdInput, FolioBlockId, deriveBlockId, getFolioParaIdFromBlockId, isFolioBlockId, isSequentialFolioBlockId } from "./types/block-id.js";
+import { WordDiffSegment, diffWordSegments } from "./ai-edits/word-diff.js";
+import { AIBarStatus, AIChatMode, AICitation, AICitationSource, AIGenerateInput, AISuggestion, AISuggestionApplyMode, AISuggestionPreset, AISuggestionSeverity, AISuggestionStatus, DEFAULT_AI_SUGGESTION_PRESETS } from "./ai-suggestions/types.js";
+import { ApplyResult, applySuggestions } from "./ai-suggestions/apply.js";
+import { ResolvedAnchor, isSuggestionStale, resolveSuggestionAnchor } from "./ai-suggestions/conflict.js";
+import { PositionalText, buildPositionalText } from "./ai-suggestions/text-positions.js";
+import { TemplatePreviewSpan, TemplatePreviewValue, TemplatePreviewValues, setTemplatePreviewValues } from "./prosemirror/plugins/templatePreviewValues.js";
+import { DocxCompatibility } from "./docx/compatibility.js";
+import { createDocx } from "./docx/rezip.js";
+import { EmbeddedFont, EmbeddedFontParts, extractEmbeddedFonts, getEmbeddedFontFaces } from "./fonts/embeddedFonts.js";
+import { CreateEmptyDocumentOptions, createEmptyDocument } from "./utils/createDocument.js";
+import { setAISuggestionsMeta, setFocusedSuggestionMeta } from "./prosemirror/plugins/aiSuggestionDecorations.js";
+import { scrollFolioPositionIntoView } from "./paged-layout/scrollToPmPosition.js";
+import { getFolioCaretViewportRect, getFolioSelectionViewportRect } from "./paged-layout/selectionViewportRect.js";
+import { AICitationRange, createAICitationDecorationsPlugin, setAICitationsMeta, setActiveCitationMeta } from "./prosemirror/plugins/aiCitationDecorations.js";
+import { AnonymizationMatch, AnonymizationTerm, anonymizationDecorationsKey, getAnonymizationMatches, setAnonymizationTermsMeta } from "./prosemirror/plugins/anonymizationDecorations.js";
+import { DirectiveKind, DirectiveRange, getTemplateDirectives, scanDirectives } from "./prosemirror/plugins/templateDirectives.js";
+import { TemplateSlashMenuKeyAction, TemplateSlashMenuState, clearTemplateSlashMenu, consumeTemplateSlashQuery, getTemplateSlashMenu, resetTemplateSlashQuery, templateSlashMenuKey } from "./prosemirror/plugins/templateSlashMenu.js";
+import { AcceptAutocompleteResult, AutocompleteSuggestionPluginOptions, AutocompleteSuggestionState, AutocompleteSuggestionStatus, AutocompleteTriggerCheck, AutocompleteTriggerOptions, AutocompleteTriggerSkipReason, DEFAULT_AUTOCOMPLETE_DEAD_ZONE_NODES, acceptAutocompleteSuggestion, acceptAutocompleteWord, appendAutocompleteToken, autocompleteSuggestionKey, autocompleteSuggestionPlugin, clearAutocompleteSuggestion, finishAutocompleteSuggestion, getAutocompleteSuggestion, shouldTriggerAutocomplete, startAutocompleteSuggestion } from "./prosemirror/plugins/autocompleteSuggestion.js";
+import { ImageMeta, ImageRef, MarkdownOptions, MarkdownResult } from "./markdown/types.js";
+import { fromMarkdown } from "./markdown/fromMarkdown.js";
+import { toMarkdown, toMarkdownResult } from "./markdown/index.js";
+type Document = document_d_exports.Document;
+export { type AIBarStatus, type AIChatMode, type AICitation, type AICitationRange, type AICitationSource, type AIGenerateInput, type AISuggestion, type AISuggestionApplyMode, type AISuggestionPreset, type AISuggestionSeverity, type AISuggestionStatus, type AcceptAutocompleteResult, type AnonymizationMatch, type AnonymizationTerm, type ApplyResult, type AutocompleteSuggestionPluginOptions, type AutocompleteSuggestionState, type AutocompleteSuggestionStatus, type AutocompleteTriggerCheck, type AutocompleteTriggerOptions, type AutocompleteTriggerSkipReason, type CreateEmptyDocumentOptions, DEFAULT_AI_SUGGESTION_PRESETS, DEFAULT_AUTOCOMPLETE_DEAD_ZONE_NODES, type DeriveBlockIdInput, type DirectiveKind, type DirectiveRange, type Document, type DocxCompatibility, type EmbeddedFont, type EmbeddedFontParts, type FolioAIBlock, type FolioAIBlockAnchor, type FolioAIBlockKind, type FolioAIBlockPreviewRun, type FolioAIComment, type FolioAIEditAppliedOperation, type FolioAIEditApplyMode, type FolioAIEditApplyResult, type FolioAIEditOperation, type FolioAIEditReviewMeta, type FolioAIEditSeverity, type FolioAIEditSkipReason, type FolioAIEditSkippedOperation, type FolioAIEditSnapshot, type FolioAISignatureParty, type FolioBlockId, type ImageMeta, type ImageRef, type MarkdownOptions, type MarkdownResult, type PositionalText, type ResolvedAnchor, type TemplatePreviewSpan, type TemplatePreviewValue, type TemplatePreviewValues, type TemplateSlashMenuKeyAction, type TemplateSlashMenuState, type WordDiffSegment, acceptAutocompleteSuggestion, acceptAutocompleteWord, anonymizationDecorationsKey, appendAutocompleteToken, applyFolioAIEditOperations, applySuggestions, autocompleteSuggestionKey, autocompleteSuggestionPlugin, buildPositionalText, clearAutocompleteSuggestion, clearTemplateSlashMenu, consumeTemplateSlashQuery, createAICitationDecorationsPlugin, createDocx, createEmptyDocument, createFolioAIEditSnapshot, deriveBlockId, diffWordSegments, extractEmbeddedFonts, finishAutocompleteSuggestion, fromMarkdown, getAnonymizationMatches, getAutocompleteSuggestion, getEmbeddedFontFaces, getFolioCaretViewportRect, getFolioParaIdFromBlockId, getFolioSelectionViewportRect, getTemplateDirectives, getTemplateSlashMenu, hashFolioAIBlockText, isFolioBlockId, isSequentialFolioBlockId, isSuggestionStale, normalizeFolioAIBlockText, resetTemplateSlashQuery, resolveSuggestionAnchor, scanDirectives, scrollFolioPositionIntoView, setAICitationsMeta, setAISuggestionsMeta, setActiveCitationMeta, setAnonymizationTermsMeta, setFocusedSuggestionMeta, setTemplatePreviewValues, shouldTriggerAutocomplete, startAutocompleteSuggestion, templateSlashMenuKey, toMarkdown, toMarkdownResult };

package/dist/index.js

@@ -0,0 +1,23 @@
+import { createEmptyDocument } from "./utils/createDocument.js";
+import { createDocx } from "./docx/rezip.js";
+import { deriveBlockId, getFolioParaIdFromBlockId, isFolioBlockId, isSequentialFolioBlockId } from "./types/block-id.js";
+import { DEFAULT_AI_SUGGESTION_PRESETS } from "./ai-suggestions/types.js";
+import { buildPositionalText } from "./ai-suggestions/text-positions.js";
+import { isSuggestionStale, resolveSuggestionAnchor } from "./ai-suggestions/conflict.js";
+import { applySuggestions } from "./ai-suggestions/apply.js";
+import { createFolioAIEditSnapshot, hashFolioAIBlockText, normalizeFolioAIBlockText } from "./ai-edits/snapshot.js";
+import { diffWordSegments } from "./ai-edits/word-diff.js";
+import { applyFolioAIEditOperations } from "./ai-edits/apply.js";
+import { setAISuggestionsMeta, setFocusedSuggestionMeta } from "./prosemirror/plugins/aiSuggestionDecorations.js";
+import { scrollFolioPositionIntoView } from "./paged-layout/scrollToPmPosition.js";
+import { getFolioCaretViewportRect, getFolioSelectionViewportRect } from "./paged-layout/selectionViewportRect.js";
+import { createAICitationDecorationsPlugin, setAICitationsMeta, setActiveCitationMeta } from "./prosemirror/plugins/aiCitationDecorations.js";
+import { anonymizationDecorationsKey, getAnonymizationMatches, setAnonymizationTermsMeta } from "./prosemirror/plugins/anonymizationDecorations.js";
+import { getTemplateDirectives, scanDirectives } from "./prosemirror/plugins/templateDirectives.js";
+import { setTemplatePreviewValues } from "./prosemirror/plugins/templatePreviewValues.js";
+import { clearTemplateSlashMenu, consumeTemplateSlashQuery, getTemplateSlashMenu, resetTemplateSlashQuery, templateSlashMenuKey } from "./prosemirror/plugins/templateSlashMenu.js";
+import { DEFAULT_AUTOCOMPLETE_DEAD_ZONE_NODES, acceptAutocompleteSuggestion, acceptAutocompleteWord, appendAutocompleteToken, autocompleteSuggestionKey, autocompleteSuggestionPlugin, clearAutocompleteSuggestion, finishAutocompleteSuggestion, getAutocompleteSuggestion, shouldTriggerAutocomplete, startAutocompleteSuggestion } from "./prosemirror/plugins/autocompleteSuggestion.js";
+import { fromMarkdown } from "./markdown/fromMarkdown.js";
+import { toMarkdown, toMarkdownResult } from "./markdown/index.js";
+import { extractEmbeddedFonts, getEmbeddedFontFaces } from "./fonts/embeddedFonts.js";
+export { DEFAULT_AI_SUGGESTION_PRESETS, DEFAULT_AUTOCOMPLETE_DEAD_ZONE_NODES, acceptAutocompleteSuggestion, acceptAutocompleteWord, anonymizationDecorationsKey, appendAutocompleteToken, applyFolioAIEditOperations, applySuggestions, autocompleteSuggestionKey, autocompleteSuggestionPlugin, buildPositionalText, clearAutocompleteSuggestion, clearTemplateSlashMenu, consumeTemplateSlashQuery, createAICitationDecorationsPlugin, createDocx, createEmptyDocument, createFolioAIEditSnapshot, deriveBlockId, diffWordSegments, extractEmbeddedFonts, finishAutocompleteSuggestion, fromMarkdown, getAnonymizationMatches, getAutocompleteSuggestion, getEmbeddedFontFaces, getFolioCaretViewportRect, getFolioParaIdFromBlockId, getFolioSelectionViewportRect, getTemplateDirectives, getTemplateSlashMenu, hashFolioAIBlockText, isFolioBlockId, isSequentialFolioBlockId, isSuggestionStale, normalizeFolioAIBlockText, resetTemplateSlashQuery, resolveSuggestionAnchor, scanDirectives, scrollFolioPositionIntoView, setAICitationsMeta, setAISuggestionsMeta, setActiveCitationMeta, setAnonymizationTermsMeta, setFocusedSuggestionMeta, setTemplatePreviewValues, shouldTriggerAutocomplete, startAutocompleteSuggestion, templateSlashMenuKey, toMarkdown, toMarkdownResult };

package/dist/layout-bridge/convert/footnoteLayout.d.ts

@@ -0,0 +1,57 @@
+import { document_d_exports } from "../../types/document.js";
+import { FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, FlowBlock, FootnoteContent, Measure, Page } from "../../layout-engine/types.js";
+
+//#region src/layout-bridge/convert/footnoteLayout.d.ts
+type MeasureBlocksFn = (blocks: FlowBlock[], contentWidth: number) => Measure[];
+type ConvertFootnoteOptions = {
+  styles?: document_d_exports.StyleDefinitions | null;
+  theme?: document_d_exports.Theme | null;
+  measureBlocks?: MeasureBlocksFn; /** Document-wide `w:defaultTabStop` in twips — forwarded to toFlowBlocks. */
+  defaultTabStopTwips?: number;
+};
+/**
+ * Scan FlowBlocks for runs with footnoteRefId set.
+ * Returns a list of { footnoteId, pmPos } in document order.
+ *
+ * Recurses into table cells and text-box content so footnote references
+ * nested in tables (incl. tables-within-cells) and text boxes still reach
+ * the page-assignment step. Without this walk, inline footnote markers
+ * render inside the body but never get an entry in the per-page footnote
+ * area.
+ */
+declare function collectFootnoteRefs(blocks: FlowBlock[]): {
+  footnoteId: number;
+  pmPos: number;
+}[];
+/**
+ * After layout, determine which footnotes appear on which pages.
+ * Checks each page's fragments to see if any footnoteRef PM positions fall within.
+ *
+ * Returns Map<pageNumber, footnoteId[]> in document order.
+ */
+declare function mapFootnotesToPages(pages: Page[], footnoteRefs: {
+  footnoteId: number;
+  pmPos: number;
+}[]): Map<number, number[]>;
+/**
+ * Convert a Footnote's content paragraphs to FlowBlocks suitable for rendering.
+ * Prepends the display number to the first run of the first paragraph.
+ */
+declare function convertFootnoteToContent(footnote: document_d_exports.Footnote, displayNumber: number, contentWidth: number, options?: ConvertFootnoteOptions): FootnoteContent;
+declare function applyFootnotePresentation(blocks: FlowBlock[], displayNumber: number): FlowBlock[];
+/**
+ * Build footnote content for all footnotes referenced in the document.
+ * Returns a Map<footnoteId, FootnoteContent>.
+ */
+declare function buildFootnoteContentMap(footnotes: document_d_exports.Footnote[], footnoteRefs: {
+  footnoteId: number;
+}[], contentWidth: number, options?: ConvertFootnoteOptions): Map<number, FootnoteContent>;
+/**
+ * Calculate per-page footnote reserved heights.
+ * Returns Map<pageNumber, reservedHeight>.
+ */
+declare function calculateFootnoteReservedHeights(pageFootnoteMap: Map<number, number[]>, footnoteContentMap: Map<number, {
+  height: number;
+}>): Map<number, number>;
+//#endregion
+export { ConvertFootnoteOptions, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, MeasureBlocksFn, applyFootnotePresentation, buildFootnoteContentMap, calculateFootnoteReservedHeights, collectFootnoteRefs, convertFootnoteToContent, mapFootnotesToPages };

package/dist/layout-bridge/convert/footnoteLayout.js

@@ -0,0 +1,316 @@
+import { DEFAULT_TEXTBOX_MARGINS, FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT } from "../../layout-engine/types.js";
+import { measureParagraph } from "../../layout-engine/measure/measureParagraph.js";
+import { toFlowBlocks } from "./toFlowBlocks.js";
+import { footnoteToProseDoc } from "../../prosemirror/conversion/toProseDoc.js";
+//#region src/layout-bridge/convert/footnoteLayout.ts
+/** Default footnote font size in points */
+const FOOTNOTE_FONT_SIZE = 8;
+/**
+* Scan FlowBlocks for runs with footnoteRefId set.
+* Returns a list of { footnoteId, pmPos } in document order.
+*
+* Recurses into table cells and text-box content so footnote references
+* nested in tables (incl. tables-within-cells) and text boxes still reach
+* the page-assignment step. Without this walk, inline footnote markers
+* render inside the body but never get an entry in the per-page footnote
+* area.
+*/
+function collectFootnoteRefs(blocks) {
+	const refs = [];
+	const walk = (containerBlocks) => {
+		for (const block of containerBlocks) if (block.kind === "paragraph") {
+			for (const run of block.runs) if (run.kind === "text" && run.footnoteRefId !== void 0) refs.push({
+				footnoteId: run.footnoteRefId,
+				pmPos: run.pmStart ?? 0
+			});
+		} else if (block.kind === "table") for (const row of block.rows) for (const cell of row.cells) walk(cell.blocks);
+		else if (block.kind === "textBox") walk(block.content);
+	};
+	walk(blocks);
+	return refs;
+}
+/**
+* After layout, determine which footnotes appear on which pages.
+* Checks each page's fragments to see if any footnoteRef PM positions fall within.
+*
+* Returns Map<pageNumber, footnoteId[]> in document order.
+*/
+function mapFootnotesToPages(pages, footnoteRefs) {
+	const pageFootnotes = /* @__PURE__ */ new Map();
+	if (footnoteRefs.length === 0) return pageFootnotes;
+	for (const ref of footnoteRefs) for (const page of pages) {
+		let found = false;
+		for (const fragment of page.fragments) {
+			const pmStart = fragment.pmStart ?? -1;
+			const pmEnd = fragment.pmEnd ?? -1;
+			if (pmStart >= 0 && pmEnd >= 0 && ref.pmPos >= pmStart && ref.pmPos < pmEnd) {
+				const existing = pageFootnotes.get(page.number) ?? [];
+				if (!existing.includes(ref.footnoteId)) existing.push(ref.footnoteId);
+				pageFootnotes.set(page.number, existing);
+				found = true;
+				break;
+			}
+		}
+		if (found) break;
+	}
+	return pageFootnotes;
+}
+/**
+* Convert a Footnote's content paragraphs to FlowBlocks suitable for rendering.
+* Prepends the display number to the first run of the first paragraph.
+*/
+function convertFootnoteToContent(footnote, displayNumber, contentWidth, options = {}) {
+	const proseOptions = {};
+	if (options.styles) proseOptions.styles = options.styles;
+	if (options.theme !== void 0) proseOptions.theme = options.theme;
+	const pmDoc = footnoteToProseDoc(footnote.content, proseOptions);
+	const flowOptions = {};
+	if (options.theme !== void 0) flowOptions.theme = options.theme;
+	if (options.defaultTabStopTwips !== void 0) flowOptions.defaultTabStopTwips = options.defaultTabStopTwips;
+	const blocks = applyFootnotePresentation(toFlowBlocks(pmDoc, flowOptions), displayNumber);
+	const measures = options.measureBlocks ? options.measureBlocks(blocks, contentWidth) : measureFootnoteBlocks(blocks, contentWidth);
+	let totalHeight = 0;
+	for (const measure of measures) if (measure.kind === "paragraph") totalHeight += measure.totalHeight;
+	else if (measure.kind === "table") totalHeight += measure.totalHeight;
+	else if (measure.kind === "image" || measure.kind === "textBox") totalHeight += measure.height;
+	return {
+		id: footnote.id,
+		displayNumber,
+		blocks,
+		measures,
+		height: totalHeight
+	};
+}
+function measureFootnoteBlocks(blocks, contentWidth) {
+	return blocks.map((block) => measureFootnoteBlock(block, contentWidth));
+}
+function measureFootnoteBlock(block, contentWidth) {
+	switch (block.kind) {
+		case "paragraph": return measureParagraph(block, contentWidth);
+		case "table": return measureFootnoteTable(block, contentWidth);
+		case "image": return {
+			kind: "image",
+			width: block.width,
+			height: block.height
+		};
+		case "textBox": {
+			const margins = block.margins ?? DEFAULT_TEXTBOX_MARGINS;
+			const width = block.width;
+			const innerWidth = Math.max(1, width - margins.left - margins.right);
+			const innerMeasures = block.content.map((paragraph) => measureParagraph(paragraph, innerWidth));
+			let contentHeight = 0;
+			for (const measure of innerMeasures) contentHeight += measure.totalHeight;
+			return {
+				kind: "textBox",
+				width,
+				height: block.height ?? contentHeight + margins.top + margins.bottom,
+				innerMeasures
+			};
+		}
+		case "pageBreak": return { kind: "pageBreak" };
+		case "columnBreak": return { kind: "columnBreak" };
+		case "sectionBreak": return { kind: "sectionBreak" };
+		default: return block;
+	}
+}
+function resolveFootnoteTableWidth(width, widthType, contentWidth) {
+	if (!width) return;
+	if (widthType === "pct") return contentWidth * width / 5e3;
+	if (widthType === "dxa" || !widthType || widthType === "auto") return width / 1440 * 96;
+}
+function measureFootnoteTable(tableBlock, contentWidth) {
+	let columnWidths = tableBlock.columnWidths ?? [];
+	const explicitWidth = resolveFootnoteTableWidth(tableBlock.width, tableBlock.widthType, contentWidth);
+	if (columnWidths.length === 0) {
+		const firstRow = tableBlock.rows.at(0);
+		let colCount = 0;
+		for (const cell of firstRow?.cells ?? []) colCount += cell.colSpan ?? 1;
+		const equalWidth = (explicitWidth ?? contentWidth) / Math.max(1, colCount);
+		columnWidths = Array.from({ length: Math.max(1, colCount) }, () => equalWidth);
+	} else if (explicitWidth) {
+		const totalWidth = sumColumnWidths(columnWidths);
+		if (totalWidth > 0 && Math.abs(totalWidth - explicitWidth) > 1) {
+			const scale = explicitWidth / totalWidth;
+			columnWidths = columnWidths.map((width) => width * scale);
+		}
+	}
+	const rowSpanEnds = [];
+	const rows = tableBlock.rows.map((row, rowIndex) => {
+		let columnIndex = 0;
+		const cells = row.cells.map((cell) => {
+			while ((rowSpanEnds[columnIndex] ?? 0) > rowIndex) columnIndex++;
+			const colSpan = cell.colSpan ?? 1;
+			let cellWidth = 0;
+			for (let offset = 0; offset < colSpan && columnIndex + offset < columnWidths.length; offset++) cellWidth += columnWidths[columnIndex + offset] ?? 0;
+			if (cellWidth === 0) cellWidth = cell.width ?? 100;
+			columnIndex += colSpan;
+			const padding = cell.padding ?? {
+				top: 0,
+				right: 7,
+				bottom: 0,
+				left: 7
+			};
+			const innerWidth = Math.max(1, cellWidth - padding.left - padding.right);
+			const blocks = measureFootnoteBlocks(cell.blocks, innerWidth);
+			let height = padding.top + padding.bottom;
+			for (const measure of blocks) height += getMeasureHeight(measure);
+			const cellMeasure = {
+				blocks,
+				width: cellWidth,
+				height
+			};
+			if (cell.colSpan !== void 0) cellMeasure.colSpan = cell.colSpan;
+			if (cell.rowSpan !== void 0) cellMeasure.rowSpan = cell.rowSpan;
+			if ((cell.rowSpan ?? 1) > 1) {
+				const rowSpanEnd = rowIndex + (cell.rowSpan ?? 1);
+				for (let offset = 0; offset < colSpan; offset++) rowSpanEnds[columnIndex - colSpan + offset] = rowSpanEnd;
+			}
+			return cellMeasure;
+		});
+		let contentHeight = 0;
+		for (const cell of cells) contentHeight = Math.max(contentHeight, cell.height);
+		const explicitHeight = row.height;
+		let height = contentHeight;
+		if (explicitHeight !== void 0 && row.heightRule === "exact") height = explicitHeight;
+		else if (explicitHeight !== void 0) height = Math.max(contentHeight, explicitHeight);
+		return {
+			cells,
+			height
+		};
+	});
+	let totalHeight = 0;
+	for (const row of rows) totalHeight += row.height;
+	return {
+		kind: "table",
+		rows,
+		columnWidths,
+		totalWidth: sumColumnWidths(columnWidths) || explicitWidth || contentWidth,
+		totalHeight
+	};
+}
+function sumColumnWidths(columnWidths) {
+	let total = 0;
+	for (const width of columnWidths) total += width;
+	return total;
+}
+function getMeasureHeight(measure) {
+	if (measure.kind === "paragraph" || measure.kind === "table") return measure.totalHeight;
+	if (measure.kind === "image" || measure.kind === "textBox") return measure.height;
+	return 0;
+}
+function applyFootnotePresentation(blocks, displayNumber) {
+	if (blocks.length === 0) return [{
+		kind: "paragraph",
+		id: `fn-empty-${displayNumber}`,
+		runs: [{
+			kind: "text",
+			text: `${displayNumber}  `,
+			fontSize: FOOTNOTE_FONT_SIZE,
+			superscript: true
+		}]
+	}];
+	const output = blocks.map(applyFootnoteBlockPresentation);
+	const first = output[0];
+	if (first?.kind === "paragraph") output[0] = {
+		...first,
+		runs: [createFootnoteNumberRun(displayNumber, first), ...first.runs]
+	};
+	else output.unshift({
+		kind: "paragraph",
+		id: `fn-number-${displayNumber}`,
+		runs: [{
+			kind: "text",
+			text: `${displayNumber}  `,
+			fontSize: FOOTNOTE_FONT_SIZE,
+			superscript: true
+		}]
+	});
+	return output;
+}
+function createFootnoteNumberRun(displayNumber, paragraph) {
+	const firstTextRun = paragraph.runs.find((run) => run.kind === "text");
+	const firstFormattedRun = paragraph.runs.find((run) => run.kind === "text" || run.kind === "tab" || run.kind === "field");
+	const numberRun = {
+		kind: "text",
+		text: firstTextRun?.text.match(/^\s/u) ? `${displayNumber}` : `${displayNumber} `,
+		fontSize: firstFormattedRun?.fontSize ?? paragraph.attrs?.defaultFontSize ?? FOOTNOTE_FONT_SIZE,
+		superscript: true
+	};
+	const fontFamily = firstFormattedRun?.fontFamily ?? paragraph.attrs?.defaultFontFamily;
+	if (fontFamily) numberRun.fontFamily = fontFamily;
+	return numberRun;
+}
+function applyFootnoteBlockPresentation(block) {
+	if (block.kind === "paragraph") return applyFootnoteParagraphPresentation(block);
+	if (block.kind === "table") return {
+		...block,
+		rows: block.rows.map((row) => ({
+			...row,
+			cells: row.cells.map((cell) => ({
+				...cell,
+				blocks: cell.blocks.map(applyFootnoteBlockPresentation)
+			}))
+		}))
+	};
+	if (block.kind === "textBox") return {
+		...block,
+		content: block.content.map(applyFootnoteParagraphPresentation)
+	};
+	return block;
+}
+function applyFootnoteParagraphPresentation(block) {
+	return {
+		...block,
+		runs: block.runs.map(applyFootnoteRunPresentation)
+	};
+}
+function applyFootnoteRunPresentation(run) {
+	if ((run.kind === "text" || run.kind === "tab" || run.kind === "field") && run.fontSize === void 0) return {
+		...run,
+		fontSize: FOOTNOTE_FONT_SIZE
+	};
+	return run;
+}
+/**
+* Build footnote content for all footnotes referenced in the document.
+* Returns a Map<footnoteId, FootnoteContent>.
+*/
+function buildFootnoteContentMap(footnotes, footnoteRefs, contentWidth, options = {}) {
+	const contentMap = /* @__PURE__ */ new Map();
+	const footnoteById = /* @__PURE__ */ new Map();
+	for (const fn of footnotes) if (fn.noteType === "normal") footnoteById.set(fn.id, fn);
+	let displayNumber = 1;
+	const seen = /* @__PURE__ */ new Set();
+	for (const ref of footnoteRefs) {
+		if (seen.has(ref.footnoteId)) continue;
+		seen.add(ref.footnoteId);
+		const footnote = footnoteById.get(ref.footnoteId);
+		if (!footnote) continue;
+		const content = convertFootnoteToContent(footnote, displayNumber, contentWidth, options);
+		contentMap.set(ref.footnoteId, content);
+		displayNumber++;
+	}
+	return contentMap;
+}
+/**
+* Calculate per-page footnote reserved heights.
+* Returns Map<pageNumber, reservedHeight>.
+*/
+function calculateFootnoteReservedHeights(pageFootnoteMap, footnoteContentMap) {
+	const reserved = /* @__PURE__ */ new Map();
+	for (const [pageNumber, footnoteIds] of pageFootnoteMap) {
+		let totalHeight = 0;
+		for (const fnId of footnoteIds) {
+			const content = footnoteContentMap.get(fnId);
+			if (content) totalHeight += content.height;
+		}
+		if (totalHeight > 0) {
+			totalHeight += 12;
+			totalHeight += footnoteIds.length * 0;
+			reserved.set(pageNumber, totalHeight);
+		}
+	}
+	return reserved;
+}
+//#endregion
+export { FOOTNOTE_ENTRY_MARGIN_BOTTOM, FOOTNOTE_FALLBACK_LINE_HEIGHT, FOOTNOTE_SEPARATOR_HEIGHT, applyFootnotePresentation, buildFootnoteContentMap, calculateFootnoteReservedHeights, collectFootnoteRefs, convertFootnoteToContent, mapFootnotesToPages };