@stll/folio-core 0.15.10 → 0.15.12

package/dist/docx/rezip.js

@@ -11,7 +11,7 @@ import { ensureThreadedCommentParaIds, serializeComments, serializeCommentsExten
 import { serializeDocument } from "./serializer/documentSerializer.js";
 import { serializeFontTableXml } from "./serializer/fontTableSerializer.js";
 import { serializeHeaderFooter } from "./serializer/headerFooterSerializer.js";
-import { serializeEndnotes, serializeFootnotes } from "./serializer/noteSerializer.js";
+import { serializeEndnotes, serializeFootnotes, serializeNewEndnotesPart, serializeNewFootnotesPart } from "./serializer/noteSerializer.js";
 import { serializeNumberingXml } from "./serializer/numberingSerializer.js";
 import { serializeSettingsXml } from "./serializer/settingsSerializer.js";
 import { serializeStylesXml } from "./serializer/stylesSerializer.js";
@@ -978,9 +978,50 @@ function serializeHeadersFootersToZip(doc, zip, compressionLevel) {
 */
 async function serializeNotesToZip(doc, originalZip, newZip, compressionLevel) {
 	const footnotes = doc.package.footnotes ?? [];
-	if (footnotes.length > 0) await patchNotePartIntoZip("word/footnotes.xml", serializeFootnotes(footnotes), (xml) => serializeFootnotes(parseFootnotes(xml).getNormalFootnotes()), originalZip, newZip, compressionLevel);
+	if (footnotes.length > 0) if (findNotePartEntry(originalZip, "word/footnotes.xml")) await patchNotePartIntoZip("word/footnotes.xml", serializeFootnotes(footnotes), (xml) => serializeFootnotes(parseFootnotes(xml).getNormalFootnotes()), originalZip, newZip, compressionLevel);
+	else await materializeNewNotePart({
+		contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
+		newZip,
+		partPath: "word/footnotes.xml",
+		relationshipType: RELATIONSHIP_TYPES.footnotes,
+		serializedPart: serializeNewFootnotesPart(footnotes),
+		compressionLevel
+	});
 	const endnotes = doc.package.endnotes ?? [];
-	if (endnotes.length > 0) await patchNotePartIntoZip("word/endnotes.xml", serializeEndnotes(endnotes), (xml) => serializeEndnotes(parseEndnotes(xml).getNormalEndnotes()), originalZip, newZip, compressionLevel);
+	if (endnotes.length > 0) if (findNotePartEntry(originalZip, "word/endnotes.xml")) await patchNotePartIntoZip("word/endnotes.xml", serializeEndnotes(endnotes), (xml) => serializeEndnotes(parseEndnotes(xml).getNormalEndnotes()), originalZip, newZip, compressionLevel);
+	else await materializeNewNotePart({
+		contentType: "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml",
+		newZip,
+		partPath: "word/endnotes.xml",
+		relationshipType: RELATIONSHIP_TYPES.endnotes,
+		serializedPart: serializeNewEndnotesPart(endnotes),
+		compressionLevel
+	});
+}
+async function materializeNewNotePart({ contentType, newZip, partPath, relationshipType, serializedPart, compressionLevel }) {
+	const contentTypesFile = findNotePartEntry(newZip, "[content_types].xml");
+	const relationshipsFile = findNotePartEntry(newZip, "word/_rels/document.xml.rels");
+	if (!contentTypesFile || !relationshipsFile) throw new DocxPackageFidelityError(`Cannot create ${partPath}: the DOCX package is missing content types or document relationships`);
+	const compressionOptions = { level: compressionLevel };
+	const contentTypesXml = await contentTypesFile.async("text");
+	const partName = `/${partPath}`;
+	if (!contentTypesXml.toLowerCase().includes(partName.toLowerCase())) newZip.file(contentTypesFile.name, contentTypesXml.replace("</Types>", () => `<Override PartName="${partName}" ContentType="${contentType}"/></Types>`), {
+		compression: "DEFLATE",
+		compressionOptions
+	});
+	const relationshipsXml = await relationshipsFile.async("text");
+	if (!relationshipsXml.includes(relationshipType)) {
+		const relationshipId = `rId${findMaxRId(relationshipsXml) + 1}`;
+		const target = partPath.slice(5);
+		newZip.file(relationshipsFile.name, relationshipsXml.replace("</Relationships>", () => `<Relationship Id="${relationshipId}" Type="${relationshipType}" Target="${target}"/></Relationships>`), {
+			compression: "DEFLATE",
+			compressionOptions
+		});
+	}
+	newZip.file(partPath, serializedPart, {
+		compression: "DEFLATE",
+		compressionOptions
+	});
 }
 const numberingBaselines = /* @__PURE__ */ new WeakMap();
 async function serializeNumberingIntoZip(doc, originalZip, newZip, compressionLevel) {

package/dist/docx/serializer/noteSerializer.d.ts

@@ -14,5 +14,11 @@ declare function serializeFootnotes(footnotes: readonly document_d_exports.Footn
  * @returns Complete endnotes.xml string.
  */
 declare function serializeEndnotes(endnotes: readonly document_d_exports.Endnote[]): string;
+/** Serialize a brand-new footnote part, including Word's required separators
+ * and the automatic reference mark at the start of every normal note. */
+declare function serializeNewFootnotesPart(footnotes: readonly document_d_exports.Footnote[]): string;
+/** Serialize a brand-new endnote part, including Word's required separators
+ * and the automatic reference mark at the start of every normal note. */
+declare function serializeNewEndnotesPart(endnotes: readonly document_d_exports.Endnote[]): string;
 //#endregion
-export { serializeEndnotes, serializeFootnotes };
+export { serializeEndnotes, serializeFootnotes, serializeNewEndnotesPart, serializeNewFootnotesPart };

package/dist/docx/serializer/noteSerializer.js

@@ -48,6 +48,25 @@ function serializeNote(elementName, note) {
 	const body = note.content.map((block) => serializeBlock(block)).join("");
 	return `<w:${elementName} ${attrs.join(" ")}>${body}</w:${elementName}>`;
 }
+const NOTE_SEPARATOR_BODY = "<w:p><w:pPr><w:spacing w:after=\"0\" w:line=\"240\" w:lineRule=\"auto\"/></w:pPr>";
+function serializeRequiredNoteSeparators(elementName) {
+	return `<w:${elementName} w:type="separator" w:id="-1">${NOTE_SEPARATOR_BODY}<w:r><w:separator/></w:r></w:p></w:${elementName}><w:${elementName} w:type="continuationSeparator" w:id="0">${NOTE_SEPARATOR_BODY}<w:r><w:continuationSeparator/></w:r></w:p></w:${elementName}>`;
+}
+function insertNoteReferenceMark(xml, elementName) {
+	const paragraphOpen = /<w:p(?=[\s>])[^>]*>/u.exec(xml);
+	if (!paragraphOpen) return `${`<w:p><w:r><w:rPr><w:rStyle w:val="${elementName === "footnote" ? "FootnoteReference" : "EndnoteReference"}"/></w:rPr><w:${elementName}Ref/></w:r></w:p>`}${xml}`;
+	const paragraphStart = paragraphOpen.index + paragraphOpen[0].length;
+	const paragraphEnd = xml.indexOf("</w:p>", paragraphStart);
+	const propertiesEnd = xml.indexOf("</w:pPr>", paragraphStart);
+	const insertAt = propertiesEnd !== -1 && propertiesEnd < paragraphEnd ? propertiesEnd + 8 : paragraphStart;
+	const referenceRun = `<w:r><w:rPr><w:rStyle w:val="${elementName === "footnote" ? "FootnoteReference" : "EndnoteReference"}"/></w:rPr><w:${elementName}Ref/></w:r>`;
+	return `${xml.slice(0, insertAt)}${referenceRun}${xml.slice(insertAt)}`;
+}
+function serializeNewNotePart(elementName, notes) {
+	const nsDecl = buildNamespaceDeclarations();
+	const serializedNotes = notes.map((note) => insertNoteReferenceMark(serializeNote(elementName, note), elementName)).join("");
+	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:${elementName}s ${nsDecl} mc:Ignorable="w14 w15 wp14">` + serializeRequiredNoteSeparators(elementName) + serializedNotes + `</w:${elementName}s>`;
+}
 /**
 * Serialize footnotes to a complete word/footnotes.xml string.
 *
@@ -66,5 +85,15 @@ function serializeFootnotes(footnotes) {
 function serializeEndnotes(endnotes) {
 	return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\n<w:endnotes ${buildNamespaceDeclarations()} mc:Ignorable="w14 w15 wp14">${endnotes.map((en) => serializeNote("endnote", en)).join("")}</w:endnotes>`;
 }
+/** Serialize a brand-new footnote part, including Word's required separators
+* and the automatic reference mark at the start of every normal note. */
+function serializeNewFootnotesPart(footnotes) {
+	return serializeNewNotePart("footnote", footnotes);
+}
+/** Serialize a brand-new endnote part, including Word's required separators
+* and the automatic reference mark at the start of every normal note. */
+function serializeNewEndnotesPart(endnotes) {
+	return serializeNewNotePart("endnote", endnotes);
+}
 //#endregion
-export { serializeEndnotes, serializeFootnotes };
+export { serializeEndnotes, serializeFootnotes, serializeNewEndnotesPart, serializeNewFootnotesPart };

package/dist/layout-bridge/dom/clickToPositionDom.d.ts

@@ -61,6 +61,21 @@ type DomCaretPosition = {
   height: number;
   pageIndex: number;
 };
+type CollapsedLineEdgeCaretGeometry = {
+  left: number;
+  top: number;
+  /** Viewport height of the visual anchor. Full-line caret painters retain
+   * their own line-height policy instead of using this glyph-box height. */
+  height: number;
+};
+/**
+ * Resolve viewport geometry for a line-edge space span that the painter keeps
+ * addressable but collapses to zero font size. Browser ranges inside those
+ * spans report their zero-height baseline as `top`, which makes a caret appear
+ * below the line until visible text is typed. Anchor the caret to the nearest
+ * painted sibling instead; an all-whitespace line falls back to its line box.
+ */
+declare function getCollapsedLineEdgeCaretGeometry(spanEl: HTMLElement): CollapsedLineEdgeCaretGeometry | null;
 declare function getCaretPositionFromDom(container: HTMLElement, pmPos: number, overlayRect: DOMRect): DomCaretPosition | null;
 //#endregion
-export { DomCaretPosition, DomSelectionRect, clickToPositionDom, findPositionInSpan, getCaretPositionFromDom, getSelectionRectsFromDom };
+export { CollapsedLineEdgeCaretGeometry, DomCaretPosition, DomSelectionRect, clickToPositionDom, findPositionInSpan, getCaretPositionFromDom, getCollapsedLineEdgeCaretGeometry, getSelectionRectsFromDom };

package/dist/layout-bridge/dom/clickToPositionDom.js

@@ -225,6 +225,29 @@ function getSelectionRectsFromDom(container, from, to, overlayRect) {
 	}
 	return rects;
 }
+/**
+* Resolve viewport geometry for a line-edge space span that the painter keeps
+* addressable but collapses to zero font size. Browser ranges inside those
+* spans report their zero-height baseline as `top`, which makes a caret appear
+* below the line until visible text is typed. Anchor the caret to the nearest
+* painted sibling instead; an all-whitespace line falls back to its line box.
+*/
+function getCollapsedLineEdgeCaretGeometry(spanEl) {
+	const isLeading = spanEl.dataset["collapsedLeadingSpaces"] === "true";
+	const isTrailing = spanEl.dataset["collapsedTrailingSpaces"] === "true";
+	if (!isLeading && !isTrailing) return null;
+	let sibling = isTrailing ? spanEl.previousElementSibling : spanEl.nextElementSibling;
+	while (sibling && (sibling.getAttribute("data-collapsed-leading-spaces") === "true" || sibling.getAttribute("data-collapsed-trailing-spaces") === "true")) sibling = isTrailing ? sibling.previousElementSibling : sibling.nextElementSibling;
+	const spanRect = spanEl.getBoundingClientRect();
+	const line = closestHtmlElement(spanEl, ".layout-line");
+	const anchorRect = sibling?.getBoundingClientRect() ?? line?.getBoundingClientRect() ?? spanRect;
+	const lineRect = line?.getBoundingClientRect();
+	return {
+		left: spanRect.left,
+		top: anchorRect.top,
+		height: anchorRect.height || lineRect?.height || 16
+	};
+}
 function getCaretPositionFromDom(container, pmPos, overlayRect) {
 	const spans = htmlQueryAll(container, ".layout-page-content span[data-pm-start][data-pm-end]");
 	for (const spanEl of spans) {
@@ -247,6 +270,17 @@ function getCaretPositionFromDom(container, pmPos, overlayRect) {
 			continue;
 		}
 		if (pmPos >= pmStart && pmPos <= pmEnd) {
+			const collapsedGeometry = getCollapsedLineEdgeCaretGeometry(spanEl);
+			if (collapsedGeometry) {
+				const pageEl = closestHtmlElement(spanEl, ".layout-page");
+				const pageIndex = pageEl ? Number(pageEl.dataset["pageNumber"] || 1) - 1 : 0;
+				return {
+					x: collapsedGeometry.left - overlayRect.left,
+					y: collapsedGeometry.top - overlayRect.top,
+					height: collapsedGeometry.height,
+					pageIndex
+				};
+			}
 			const textNode = spanEl.firstChild;
 			if (!textNode || textNode.nodeType !== Node.TEXT_NODE) {
 				const spanRect = spanEl.getBoundingClientRect();
@@ -301,4 +335,4 @@ function getCaretPositionFromDom(container, pmPos, overlayRect) {
 	return null;
 }
 //#endregion
-export { clickToPositionDom, findPositionInSpan, getCaretPositionFromDom, getSelectionRectsFromDom };
+export { clickToPositionDom, findPositionInSpan, getCaretPositionFromDom, getCollapsedLineEdgeCaretGeometry, getSelectionRectsFromDom };

package/dist/layout-bridge/dom/imeCaretAnchor.d.ts

@@ -0,0 +1,42 @@
+//#region src/layout-bridge/dom/imeCaretAnchor.d.ts
+type ImeCaretHost = {
+  style: {
+    transform: string;
+  };
+};
+type ImeCaretEditorView = {
+  readonly composing: boolean;
+  readonly dom?: HTMLElement;
+  readonly state: {
+    readonly selection: {
+      readonly empty: boolean;
+      readonly head: number;
+    };
+  };
+  hasFocus: () => boolean;
+  coordsAtPos: (position: number) => {
+    left: number;
+    top: number;
+  };
+};
+type VisibleCaretViewportRect = {
+  left: number;
+  top: number;
+};
+type SyncImeCaretAnchorOptions = {
+  hiddenHost: ImeCaretHost | null | undefined;
+  editorView: ImeCaretEditorView | null | undefined;
+  visibleCaret: VisibleCaretViewportRect | null | undefined;
+};
+/**
+ * Align the real off-screen ProseMirror caret with the painted document caret.
+ *
+ * Native IME candidate windows follow the focused contenteditable selection,
+ * not folio's visual caret overlay. Translating the hidden input host preserves
+ * split rendering while anchoring CJK candidate UI at the visible insertion
+ * point.
+ */
+declare const syncImeCaretAnchor: ({ hiddenHost, editorView, visibleCaret }: SyncImeCaretAnchorOptions) => boolean;
+declare const resetImeCaretAnchor: (hiddenHost: ImeCaretHost | null | undefined) => void;
+//#endregion
+export { resetImeCaretAnchor, syncImeCaretAnchor };

package/dist/layout-bridge/dom/imeCaretAnchor.js

@@ -0,0 +1,59 @@
+//#region src/layout-bridge/dom/imeCaretAnchor.ts
+const resetHostTransform = (hiddenHost) => {
+	if (hiddenHost) hiddenHost.style.transform = "";
+};
+const getNativeSelectionCaret = (editorView) => {
+	const editorDom = editorView.dom;
+	const selection = editorDom?.ownerDocument.getSelection();
+	if (!editorDom || !selection || selection.rangeCount === 0) return null;
+	const range = selection.getRangeAt(0);
+	if (!editorDom.contains(range.startContainer)) return null;
+	const rect = range.getBoundingClientRect();
+	if (range.getClientRects().length === 0 || rect.left === 0 && rect.top === 0 && rect.width === 0 && rect.height === 0) return null;
+	return {
+		left: rect.left,
+		top: rect.top
+	};
+};
+/**
+* Align the real off-screen ProseMirror caret with the painted document caret.
+*
+* Native IME candidate windows follow the focused contenteditable selection,
+* not folio's visual caret overlay. Translating the hidden input host preserves
+* split rendering while anchoring CJK candidate UI at the visible insertion
+* point.
+*/
+const syncImeCaretAnchor = ({ hiddenHost, editorView, visibleCaret }) => {
+	if (!hiddenHost) return false;
+	if (!editorView) {
+		resetHostTransform(hiddenHost);
+		return false;
+	}
+	if (editorView.composing) return false;
+	if (!visibleCaret || !editorView.hasFocus() || !editorView.state.selection.empty) {
+		resetHostTransform(hiddenHost);
+		return false;
+	}
+	const previousTransform = hiddenHost.style.transform;
+	hiddenHost.style.transform = "";
+	let hiddenCaret;
+	try {
+		hiddenCaret = getNativeSelectionCaret(editorView) ?? editorView.coordsAtPos(editorView.state.selection.head);
+	} catch {
+		hiddenHost.style.transform = previousTransform;
+		return false;
+	}
+	if (!Number.isFinite(hiddenCaret.left) || !Number.isFinite(hiddenCaret.top) || !Number.isFinite(visibleCaret.left) || !Number.isFinite(visibleCaret.top)) {
+		resetHostTransform(hiddenHost);
+		return false;
+	}
+	const dx = Math.round(visibleCaret.left - hiddenCaret.left);
+	const dy = Math.round(visibleCaret.top - hiddenCaret.top);
+	hiddenHost.style.transform = `translate3d(${dx}px, ${dy}px, 0)`;
+	return true;
+};
+const resetImeCaretAnchor = (hiddenHost) => {
+	resetHostTransform(hiddenHost);
+};
+//#endregion
+export { resetImeCaretAnchor, syncImeCaretAnchor };

package/dist/layout-bridge/headerFooterLayout.js

@@ -1,3 +1,4 @@
+import { getCollapsedLineEdgeCaretGeometry } from "./dom/clickToPositionDom.js";
 //#region src/layout-bridge/headerFooterLayout.ts
 const hfDomCache = {
 	header: null,
@@ -68,6 +69,12 @@ function computeHfCaretRectFromView(view, section, doc = globalThis.document) {
 		const end = Number(span.dataset["pmEnd"]);
 		if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
 		if (pmPos >= start && pmPos <= end) {
+			const collapsedGeometry = getCollapsedLineEdgeCaretGeometry(span);
+			if (collapsedGeometry) return {
+				top: collapsedGeometry.top,
+				left: collapsedGeometry.left,
+				height: collapsedGeometry.height
+			};
 			const range = host.ownerDocument.createRange();
 			const walker = host.ownerDocument.createTreeWalker(span, NodeFilter.SHOW_TEXT);
 			let remaining = pmPos - start;

package/dist/render-dom/RenderedDomContext.js

@@ -1,3 +1,4 @@
+import { getCollapsedLineEdgeCaretGeometry } from "../layout-bridge/dom/clickToPositionDom.js";
 import { findBodyEmptyRuns, findBodyPmSpans } from "../layout-bridge/dom/findBodyPmSpans.js";
 import { closestHtmlElement } from "../utils/domGuards.js";
 //#region src/render-dom/RenderedDomContext.ts
@@ -36,6 +37,12 @@ var RenderedDomContextImpl = class {
 				y: (spanRect.top - containerRect.top) / this.#zoom,
 				height: lineHeightFor(span, this.#zoom)
 			};
+			const collapsedGeometry = getCollapsedLineEdgeCaretGeometry(span);
+			if (collapsedGeometry) return {
+				x: (collapsedGeometry.left - containerRect.left) / this.#zoom,
+				y: (collapsedGeometry.top - containerRect.top) / this.#zoom,
+				height: lineHeightFor(span, this.#zoom)
+			};
 			const textNode = textNodeForSpan(span);
 			if (!textNode) return {
 				x: (spanRect.left - containerRect.left) / this.#zoom,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/folio-core",
-  "version": "0.15.10",
+  "version": "0.15.12",
   "description": "Headless, framework-neutral core of folio: the OOXML (.docx) parser, document model, ProseMirror integration, and page-layout engine. No React.",
   "keywords": [
     "document-model",