@stll/folio-core 0.11.0 → 0.12.0

package/dist/ai-edits/table-row-column-mutations.js

@@ -0,0 +1,300 @@
+import { stripBlockIdentityAttrs } from "./block-identity.js";
+import { markStructuralChange } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
+import { findEnclosingTableCell, findEnclosingTableRow } from "./table-targets.js";
+import { TableMap, columnIsHeader, removeColumn, removeRow, rowIsHeader, tableNodeTypes } from "prosemirror-tables";
+//#region src/ai-edits/table-row-column-mutations.ts
+const getTableColumnCoordinateKey = ({ tablePosition, columnIndex }) => `${tablePosition}:${columnIndex}`;
+const findTableColumnInsertion = ({ doc, blockFrom, position }) => {
+	const target = findEnclosingTableCell(doc, blockFrom);
+	if (!target) return null;
+	return {
+		tablePosition: target.tablePosition,
+		columnIndex: position === "before" ? target.leftColumnIndex : target.rightColumnIndex,
+		boundaryPosition: position === "before" ? target.cellPosition : target.cellEndPosition
+	};
+};
+const findTableRowInsertion = ({ doc, blockFrom, position }) => {
+	const target = findEnclosingTableRow(doc, blockFrom);
+	if (!target) return null;
+	const map = TableMap.get(target.table);
+	const rowIndex = position === "before" ? target.rowIndex : target.rowIndex + 1;
+	return buildTableRowInsertion({
+		map,
+		table: target.table,
+		tableStart: target.tableStart,
+		rowIndex
+	});
+};
+const applyTableRowInsertion = ({ tr, insertion, cellTexts, revision }) => {
+	if (revision && insertion.rowspanUpdates.length > 0) return { type: "unsupported" };
+	const liveRowspanUpdates = [];
+	for (const updatePosition of insertion.rowspanUpdates) {
+		const cellPosition = insertion.tableStart + updatePosition;
+		const liveCell = tr.doc.nodeAt(cellPosition);
+		const rowspan = liveCell?.attrs["rowspan"];
+		if (!liveCell || typeof rowspan !== "number") return { type: "unsupported" };
+		liveRowspanUpdates.push({
+			position: cellPosition,
+			cell: liveCell,
+			rowspan
+		});
+	}
+	for (const update of liveRowspanUpdates) tr.setNodeMarkup(update.position, void 0, {
+		...update.cell.attrs,
+		rowspan: update.rowspan + 1
+	});
+	const rowAttrs = revision ? { trIns: revision } : null;
+	const row = insertion.rowType.create(rowAttrs, insertion.cells);
+	tr.insert(insertion.rowPosition, populateTableRow(row, cellTexts));
+	return applied(tr, revision);
+};
+const applyTableColumnInsertion = ({ tr, insertion, cellTexts, revision }) => {
+	const tablePosition = tr.mapping.map(insertion.tablePosition, 1);
+	const table = tr.doc.nodeAt(tablePosition);
+	if (!table || table.type.spec["tableRole"] !== "table") return { type: "unsupported" };
+	const actions = buildTableColumnInsertionActions({
+		map: TableMap.get(table),
+		table,
+		columnIndex: insertion.columnIndex,
+		cellTexts
+	});
+	if (!actions || revision && actions.some(({ type }) => type === "setColspan")) return { type: "unsupported" };
+	const mapFrom = tr.mapping.maps.length;
+	for (const action of actions) {
+		const position = tr.mapping.slice(mapFrom).map(tablePosition + 1 + action.position);
+		if (action.type === "setColspan") {
+			tr.setNodeMarkup(position, void 0, action.attrs);
+			continue;
+		}
+		const cell = revision ? action.cell.type.create({
+			...action.cell.attrs,
+			cellMarker: {
+				kind: "ins",
+				info: revision
+			}
+		}, action.cell.content) : action.cell;
+		tr.insert(position, cell);
+	}
+	return applied(tr, revision);
+};
+const applyTableColumnDeletion = ({ tr, deletion, insertedColumnCount, revision }) => {
+	const tablePosition = tr.mapping.map(deletion.tablePosition, 1);
+	const table = tr.doc.nodeAt(tablePosition);
+	if (!table || table.type.spec["tableRole"] !== "table") return { type: "unsupported" };
+	const map = TableMap.get(table);
+	const columnIndex = deletion.columnIndex + insertedColumnCount;
+	if (columnIndex < 0 || columnIndex >= map.width) return { type: "unsupported" };
+	if (revision) {
+		const cellPositions = getTableColumnDeletionCellPositions({
+			map,
+			table,
+			columnIndex
+		});
+		if (!cellPositions) return { type: "unsupported" };
+		for (const cellPosition of cellPositions) tr.setNodeAttribute(tablePosition + 1 + cellPosition, "cellMarker", {
+			kind: "del",
+			info: revision
+		});
+		markStructuralChange(tr);
+		return applied(tr, revision);
+	}
+	if (map.width === 1) {
+		const transaction = deleteTableNode({
+			tr,
+			tablePosition,
+			table
+		});
+		return transaction ? applied(transaction, null) : { type: "unsupported" };
+	}
+	removeColumn(tr, {
+		map,
+		table,
+		tableStart: tablePosition + 1,
+		left: columnIndex,
+		top: 0,
+		right: columnIndex + 1,
+		bottom: map.height
+	}, columnIndex);
+	return applied(tr, null);
+};
+const applyTableRowDeletion = ({ tr, deletion, revision }) => {
+	if (revision) {
+		const rowPosition = tr.mapping.map(deletion.rowPosition);
+		const row = tr.doc.nodeAt(rowPosition);
+		if (!row || row.type.spec["tableRole"] !== "row" || row.attrs["trIns"] != null || row.attrs["trDel"] != null) return { type: "unsupported" };
+		tr.setNodeAttribute(rowPosition, "trDel", revision);
+		markStructuralChange(tr);
+		return applied(tr, revision);
+	}
+	const table = tr.doc.nodeAt(deletion.tablePosition);
+	if (!table || table.type.spec["tableRole"] !== "table" || deletion.rowIndex >= table.childCount) return { type: "unsupported" };
+	if (table.childCount === 1) {
+		const transaction = deleteTableNode({
+			tr,
+			tablePosition: deletion.tablePosition,
+			table
+		});
+		return transaction ? applied(transaction, null) : { type: "unsupported" };
+	}
+	const map = TableMap.get(table);
+	removeRow(tr, {
+		map,
+		table,
+		tableStart: deletion.tableStart,
+		left: 0,
+		top: deletion.rowIndex,
+		right: map.width,
+		bottom: deletion.rowIndex + 1
+	}, deletion.rowIndex);
+	return applied(tr, null);
+};
+const applied = (transaction, revision) => ({
+	type: "applied",
+	transaction,
+	revisionId: revision?.revisionId ?? null
+});
+const deleteTableNode = ({ tr, tablePosition, table }) => {
+	const tableEnd = tablePosition + table.nodeSize;
+	const resolved = tr.doc.resolve(tablePosition);
+	const parent = resolved.parent;
+	const tableIndex = resolved.index();
+	if (parent.canReplace(tableIndex, tableIndex + 1)) return tr.delete(tablePosition, tableEnd);
+	const emptyParagraph = tr.doc.type.schema.nodes["paragraph"]?.createAndFill();
+	if (!emptyParagraph || !parent.canReplaceWith(tableIndex, tableIndex + 1, emptyParagraph.type, emptyParagraph.marks)) return null;
+	return tr.replaceWith(tablePosition, tableEnd, emptyParagraph);
+};
+const buildTableRowInsertion = ({ map, table, tableStart, rowIndex }) => {
+	const cells = [];
+	const rowspanUpdates = [];
+	let referenceRow = rowIndex > 0 ? -1 : 0;
+	if (rowIsHeader(map, table, rowIndex + referenceRow)) referenceRow = rowIndex === 0 || rowIndex === map.height ? null : 0;
+	for (let col = 0, index = map.width * rowIndex; col < map.width; col++, index++) {
+		if (rowIndex > 0 && rowIndex < map.height && map.map[index] === map.map[index - map.width]) {
+			const cellPosition = map.map[index];
+			if (cellPosition === void 0) return null;
+			const cell = table.nodeAt(cellPosition);
+			if (!cell) return null;
+			const colspan = cell.attrs["colspan"];
+			if (typeof colspan !== "number" || colspan < 1) return null;
+			rowspanUpdates.push(cellPosition);
+			col += colspan - 1;
+			index += colspan - 1;
+			continue;
+		}
+		const referencePosition = referenceRow === null ? void 0 : map.map[index + referenceRow * map.width];
+		const cell = (referencePosition === void 0 ? tableNodeTypes(table.type.schema).cell : table.nodeAt(referencePosition)?.type)?.createAndFill();
+		if (!cell) return null;
+		cells.push(cell);
+	}
+	if (cells.length === 0) return null;
+	let rowPosition = tableStart;
+	for (let index = 0; index < rowIndex; index++) rowPosition += table.child(index).nodeSize;
+	return {
+		tableStart,
+		rowPosition,
+		rowType: tableNodeTypes(table.type.schema).row,
+		cells,
+		rowspanUpdates
+	};
+};
+const populateTableRow = (row, cellTexts) => {
+	if (cellTexts === void 0) return row;
+	const cells = [];
+	row.forEach((cell, _offset, index) => {
+		const paragraph = cell.firstChild;
+		if (!paragraph?.isTextblock) {
+			cells.push(cell);
+			return;
+		}
+		const text = cellTexts[index] ?? "";
+		const content = text.length > 0 ? row.type.schema.text(text) : null;
+		const nextParagraph = paragraph.type.create(stripBlockIdentityAttrs(paragraph.attrs), content);
+		cells.push(cell.type.create(cell.attrs, nextParagraph));
+	});
+	return row.type.create(row.attrs, cells);
+};
+const getInsertedPhysicalColumnRows = (map, columnIndex) => {
+	const rows = [];
+	for (let row = 0; row < map.height; row++) {
+		const index = row * map.width + columnIndex;
+		if (!(columnIndex > 0 && columnIndex < map.width && map.map[index - 1] === map.map[index])) rows.push(row);
+	}
+	return rows;
+};
+const expandTableCellColspan = (cell, colspanOffset) => {
+	const colspan = cell.attrs["colspan"];
+	const rowspan = cell.attrs["rowspan"];
+	const colwidth = cell.attrs["colwidth"];
+	if (typeof colspan !== "number" || !Number.isInteger(colspan) || colspan < 1 || typeof rowspan !== "number" || !Number.isInteger(rowspan) || rowspan < 1 || !Number.isInteger(colspanOffset) || colspanOffset < 0 || colspanOffset > colspan) return null;
+	if (colwidth !== null && !Array.isArray(colwidth)) return null;
+	if (Array.isArray(colwidth) && !colwidth.every((width) => typeof width === "number")) return null;
+	const nextColwidth = Array.isArray(colwidth) ? [...colwidth] : null;
+	nextColwidth?.splice(colspanOffset, 0, 0);
+	return {
+		...cell.attrs,
+		colspan: colspan + 1,
+		colwidth: nextColwidth
+	};
+};
+const populateTableCell = (cell, text) => {
+	const paragraph = cell.firstChild;
+	if (!paragraph?.isTextblock) return null;
+	const content = text.length > 0 ? cell.type.schema.text(text) : null;
+	const nextParagraph = paragraph.type.create(stripBlockIdentityAttrs(paragraph.attrs), content);
+	return cell.type.create(cell.attrs, nextParagraph);
+};
+const buildTableColumnInsertionActions = ({ map, table, columnIndex, cellTexts }) => {
+	if (columnIndex < 0 || columnIndex > map.width) return null;
+	const physicalRows = getInsertedPhysicalColumnRows(map, columnIndex);
+	if ((cellTexts?.length ?? 0) > physicalRows.length) return null;
+	let referenceColumn = columnIndex > 0 ? -1 : 0;
+	if (columnIsHeader(map, table, columnIndex + referenceColumn)) referenceColumn = columnIndex === 0 || columnIndex === map.width ? null : 0;
+	const actions = [];
+	let physicalCellIndex = 0;
+	for (let row = 0; row < map.height; row++) {
+		const index = row * map.width + columnIndex;
+		if (columnIndex > 0 && columnIndex < map.width && map.map[index - 1] === map.map[index]) {
+			const position = map.map[index];
+			if (position === void 0) return null;
+			const cell = table.nodeAt(position);
+			if (!cell) return null;
+			const colspanOffset = columnIndex - map.colCount(position);
+			const attrs = expandTableCellColspan(cell, colspanOffset);
+			if (!attrs) return null;
+			actions.push({
+				type: "setColspan",
+				position,
+				attrs
+			});
+			row += Number(cell.attrs["rowspan"]) - 1;
+			continue;
+		}
+		const referencePosition = referenceColumn === null ? void 0 : map.map[index + referenceColumn];
+		const cell = (referencePosition === void 0 ? tableNodeTypes(table.type.schema).cell : table.nodeAt(referencePosition)?.type)?.createAndFill();
+		if (!cell) return null;
+		const populatedCell = populateTableCell(cell, cellTexts?.[physicalCellIndex] ?? "");
+		if (!populatedCell) return null;
+		actions.push({
+			type: "insertCell",
+			position: map.positionAt(row, columnIndex, table),
+			cell: populatedCell
+		});
+		physicalCellIndex++;
+	}
+	return actions;
+};
+const getTableColumnDeletionCellPositions = ({ map, table, columnIndex }) => {
+	if (columnIndex < 0 || columnIndex >= map.width) return null;
+	const positions = /* @__PURE__ */ new Set();
+	for (let row = 0; row < map.height; row++) {
+		const position = map.map[row * map.width + columnIndex];
+		if (position === void 0) return null;
+		const cell = table.nodeAt(position);
+		const tableRole = cell?.type.spec["tableRole"];
+		if (!cell || tableRole !== "cell" && tableRole !== "header_cell" || cell.attrs["colspan"] !== 1 || cell.attrs["cellMarker"] != null) return null;
+		positions.add(position);
+	}
+	return [...positions];
+};
+//#endregion
+export { applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey };

package/dist/ai-edits/table-targets.d.ts

@@ -0,0 +1,32 @@
+import { TableRectangle } from "./table-mutation-plan.js";
+import { Node } from "prosemirror-model";
+import { TableMap } from "prosemirror-tables";
+
+//#region src/ai-edits/table-targets.d.ts
+type TableBoundary = {
+  before: number;
+  after: number;
+};
+type TableRowTarget = {
+  table: Node;
+  tableStart: number;
+  tablePosition: number;
+  rowIndex: number;
+  rowPosition: number;
+};
+type TableCellTarget = {
+  tablePosition: number;
+  cellPosition: number;
+  cellEndPosition: number;
+  leftColumnIndex: number;
+  rightColumnIndex: number;
+  topRowIndex: number;
+  bottomRowIndex: number;
+};
+/** Resolve the nearest enclosing table boundary for block-adjacent insertions. */
+declare const findEnclosingTableBoundary: (doc: Node, blockFrom: number) => TableBoundary | null;
+declare const findEnclosingTableRow: (doc: Node, blockFrom: number) => TableRowTarget | null;
+declare const findEnclosingTableCell: (doc: Node, blockFrom: number) => TableCellTarget | null;
+declare const tableRectangleCutsMergedCell: (map: TableMap, rectangle: TableRectangle) => boolean;
+//#endregion
+export { TableBoundary, TableCellTarget, TableRowTarget, findEnclosingTableBoundary, findEnclosingTableCell, findEnclosingTableRow, tableRectangleCutsMergedCell };

package/dist/ai-edits/table-targets.js

@@ -0,0 +1,70 @@
+import { TableMap } from "prosemirror-tables";
+//#region src/ai-edits/table-targets.ts
+/** Resolve the nearest enclosing table boundary for block-adjacent insertions. */
+const findEnclosingTableBoundary = (doc, blockFrom) => {
+	const resolved = doc.resolve(blockFrom);
+	for (let depth = resolved.depth; depth > 0; depth--) if (resolved.node(depth).type.name === "table") return {
+		before: resolved.before(depth),
+		after: resolved.after(depth)
+	};
+	return null;
+};
+const findEnclosingTableRow = (doc, blockFrom) => {
+	const resolved = doc.resolve(blockFrom);
+	for (let rowDepth = resolved.depth; rowDepth > 0; rowDepth--) {
+		if (resolved.node(rowDepth).type.spec["tableRole"] !== "row") continue;
+		const tableDepth = rowDepth - 1;
+		const table = resolved.node(tableDepth);
+		if (table.type.spec["tableRole"] !== "table") return null;
+		return {
+			table,
+			tableStart: resolved.start(tableDepth),
+			tablePosition: resolved.before(tableDepth),
+			rowIndex: resolved.index(tableDepth),
+			rowPosition: resolved.before(rowDepth)
+		};
+	}
+	return null;
+};
+const findEnclosingTableCell = (doc, blockFrom) => {
+	const resolved = doc.resolve(blockFrom);
+	for (let cellDepth = resolved.depth; cellDepth > 0; cellDepth--) {
+		const cell = resolved.node(cellDepth);
+		const tableRole = cell.type.spec["tableRole"];
+		if (tableRole !== "cell" && tableRole !== "header_cell") continue;
+		const rowDepth = cellDepth - 1;
+		const tableDepth = rowDepth - 1;
+		if (tableDepth < 0) return null;
+		if (resolved.node(rowDepth).type.spec["tableRole"] !== "row" || resolved.node(tableDepth).type.spec["tableRole"] !== "table") return null;
+		const table = resolved.node(tableDepth);
+		const tableStart = resolved.start(tableDepth);
+		const cellPosition = resolved.before(cellDepth);
+		const cellRectangle = TableMap.get(table).findCell(cellPosition - tableStart);
+		return {
+			tablePosition: resolved.before(tableDepth),
+			cellPosition,
+			cellEndPosition: cellPosition + cell.nodeSize,
+			leftColumnIndex: cellRectangle.left,
+			rightColumnIndex: cellRectangle.right,
+			topRowIndex: cellRectangle.top,
+			bottomRowIndex: cellRectangle.bottom
+		};
+	}
+	return null;
+};
+const tableRectangleCutsMergedCell = (map, rectangle) => {
+	if (rectangle.left < 0 || rectangle.top < 0 || rectangle.right > map.width || rectangle.bottom > map.height) return false;
+	for (let row = rectangle.top; row < rectangle.bottom; row++) {
+		const leftIndex = row * map.width + rectangle.left;
+		const rightIndex = row * map.width + rectangle.right - 1;
+		if (rectangle.left > 0 && map.map[leftIndex] === map.map[leftIndex - 1] || rectangle.right < map.width && map.map[rightIndex] === map.map[rightIndex + 1]) return true;
+	}
+	for (let column = rectangle.left; column < rectangle.right; column++) {
+		const topIndex = rectangle.top * map.width + column;
+		const bottomIndex = (rectangle.bottom - 1) * map.width + column;
+		if (rectangle.top > 0 && map.map[topIndex] === map.map[topIndex - map.width] || rectangle.bottom < map.height && map.map[bottomIndex] === map.map[bottomIndex + map.width]) return true;
+	}
+	return false;
+};
+//#endregion
+export { findEnclosingTableBoundary, findEnclosingTableCell, findEnclosingTableRow, tableRectangleCutsMergedCell };

package/dist/ai-edits/types.d.ts

@@ -196,6 +196,40 @@ type FolioAIEditOperation = FolioAIEditReviewMeta & {
   position?: "after" | "before";
   parties: FolioAISignatureParty[];
   comment?: FolioAIComment;
+} | {
+  id: string;
+  type: "insertTableRow"; /** Stable paragraph anchor inside the row that receives the new sibling. */
+  blockId: string;
+  position?: "after" | "before"; /** Initial text for each physical cell in source order; omitted cells stay empty. */
+  cellTexts?: string[];
+} | {
+  id: string;
+  type: "deleteTableRow"; /** Stable paragraph anchor inside the row to delete. */
+  blockId: string;
+} | {
+  id: string;
+  type: "insertTableColumn"; /** Stable paragraph anchor inside the cell that receives the new sibling column. */
+  blockId: string;
+  position?: "after" | "before"; /** Initial text for newly created physical cells in row order. */
+  cellTexts?: string[];
+} | {
+  id: string;
+  type: "deleteTableColumn"; /** Stable paragraph anchor inside the column to delete. */
+  blockId: string;
+} | ({
+  id: string;
+  type: "mergeTableCells"; /** Stable paragraph anchor inside the first cell. */
+  blockId: string;
+} & ({
+  /** Stable paragraph anchor inside the opposite corner cell. */endBlockId: string;
+  rowCount?: never;
+} | {
+  /** Number of grid rows to merge downward from the anchored cell. */rowCount: number;
+  endBlockId?: never;
+})) | {
+  id: string;
+  type: "splitTableCell"; /** Stable paragraph anchor inside the cell to split. */
+  blockId: string;
 });
 type FolioAIEditApplyMode = "direct" | "tracked-changes";
 type FolioAIEditSkipReason = "missingBlock" | "changedBlock" | "ambiguousFind" | "missingFind" | "unsupportedBlock" | "unsupportedMode" | "atomicBatchRejected" | "preconditionFailed" | "staleRange" | "emptyOperation"

package/dist/compat/eigenpal.js

@@ -1,5 +1,6 @@
 import { deriveBlockId, getFolioParaIdFromBlockId, isFolioBlockId, isSequentialFolioBlockId } from "../types/block-id.js";
 import { createFolioAIEditSnapshot, hashFolioAIBlockText, normalizeFolioAIBlockText } from "../ai-edits/snapshot.js";
+import { getGoogleFontsEnabled, setGoogleFontsEnabled } from "../utils/fontResolver.js";
 import { diffWordSegments } from "../ai-edits/word-diff.js";
 import { applyFolioAIEditOperations } from "../ai-edits/apply.js";
 import { FOLIO_DOCUMENT_OPERATION_BATCH_MODES, FOLIO_DOCUMENT_OPERATION_CONTRACT_VERSION, FOLIO_DOCUMENT_OPERATION_MODES, FOLIO_DOCUMENT_OPERATION_MODES_BY_TYPE, FOLIO_DOCUMENT_OPERATION_PRECONDITIONS, FOLIO_DOCUMENT_OPERATION_STORIES, FOLIO_DOCUMENT_OPERATION_TYPES, InvalidFolioDocumentOperationBatchError, UnsupportedFolioDocumentOperationVersionError, applyFolioDocumentOperations, assertSupportedFolioDocumentOperationVersion, getFolioDocumentOperationCapabilities, getFolioDocumentOperationIssues, getFolioDocumentOperationReceipts, isFolioDocumentOperationModeSupported, isSupportedFolioDocumentOperationVersion, parseFolioDocumentOperationBatch } from "../document-operations.js";
@@ -13,7 +14,6 @@ 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 { getGoogleFontsEnabled, setGoogleFontsEnabled } from "../utils/fontResolver.js";
 import { setAISuggestionsMeta, setFocusedSuggestionMeta } from "../prosemirror/plugins/aiSuggestionDecorations.js";
 import { scrollFolioPositionIntoView } from "../paged-layout/scrollToPmPosition.js";
 import { getFolioCaretViewportRect, getFolioSelectionViewportRect } from "../paged-layout/selectionViewportRect.js";

package/dist/content-controls/mutateContentControls.js

@@ -1,5 +1,5 @@
-import { formatDate } from "../docx/fieldParser.js";
 import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "./errors.js";
+import { formatDate } from "../docx/fieldParser.js";
 //#region src/content-controls/mutateContentControls.ts
 /**
 * Pure (immutable) write helpers for block-level content controls.

package/dist/controller/activeEditorStory.d.ts

@@ -0,0 +1,36 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/controller/activeEditorStory.d.ts
+type ActiveEditorStoryTarget = {
+  type: "note";
+  view: EditorView;
+} | {
+  type: "headerFooter";
+  view: EditorView;
+} | {
+  type: "body";
+  view: EditorView;
+} | {
+  type: "none";
+  view: null;
+};
+type ActiveEditorStoryCandidates = {
+  bodyView: EditorView | null;
+  headerFooterView: EditorView | null;
+  noteView: EditorView | null;
+};
+/**
+ * Resolve the single command target across editable document stories.
+ *
+ * A visible note panel takes precedence over header/footer mode, which takes
+ * precedence over the body. Keeping this order in core prevents framework
+ * adapters from sending formatting, focus, or history commands to a story
+ * hidden behind another active editor surface during an async UI transition.
+ */
+declare const resolveActiveEditorStory: ({
+  bodyView,
+  headerFooterView,
+  noteView
+}: ActiveEditorStoryCandidates) => ActiveEditorStoryTarget;
+//#endregion
+export { ActiveEditorStoryCandidates, ActiveEditorStoryTarget, resolveActiveEditorStory };

package/dist/controller/activeEditorStory.js

@@ -0,0 +1,30 @@
+//#region src/controller/activeEditorStory.ts
+const NO_ACTIVE_STORY = {
+	type: "none",
+	view: null
+};
+/**
+* Resolve the single command target across editable document stories.
+*
+* A visible note panel takes precedence over header/footer mode, which takes
+* precedence over the body. Keeping this order in core prevents framework
+* adapters from sending formatting, focus, or history commands to a story
+* hidden behind another active editor surface during an async UI transition.
+*/
+const resolveActiveEditorStory = ({ bodyView, headerFooterView, noteView }) => {
+	if (noteView) return {
+		type: "note",
+		view: noteView
+	};
+	if (headerFooterView) return {
+		type: "headerFooter",
+		view: headerFooterView
+	};
+	if (bodyView) return {
+		type: "body",
+		view: bodyView
+	};
+	return NO_ACTIVE_STORY;
+};
+//#endregion
+export { resolveActiveEditorStory };

package/dist/controller/contentControlWidgetController.d.ts

@@ -0,0 +1,55 @@
+import { ContentControlWidgetEvent } from "../prosemirror/plugins/contentControlWidgets.js";
+import { Subscribable } from "../managers/Subscribable.js";
+import { EditorView } from "prosemirror-view";
+
+//#region src/controller/contentControlWidgetController.d.ts
+type ContentControlListItem = {
+  displayText: string;
+  value: string;
+};
+type ContentControlPickerPosition = {
+  x: number;
+  y: number;
+};
+type ContentControlWidgetSnapshot = {
+  status: "closed";
+} | {
+  status: "dropdown";
+  items: readonly ContentControlListItem[];
+  pmPos: number;
+  position: ContentControlPickerPosition;
+} | {
+  status: "date";
+  currentValue: string | null;
+  pmPos: number;
+  position: ContentControlPickerPosition;
+};
+type ContentControlWidgetControllerOptions = {
+  onRefused?: ((event: Extract<ContentControlWidgetEvent, {
+    kind: "refused";
+  }>) => void) | undefined;
+};
+declare const parseContentControlListItems: (raw: string | undefined) => ContentControlListItem[];
+declare class ContentControlWidgetController extends Subscribable<ContentControlWidgetSnapshot> {
+  private readonly options;
+  private view;
+  private viewDom;
+  private eventRoot;
+  private ownerWindow;
+  constructor(options?: ContentControlWidgetControllerOptions);
+  bind(view: EditorView | null, eventRoot?: HTMLElement | null): void;
+  handleWidgetEvent(event: ContentControlWidgetEvent): void;
+  pickDropdown(value: string): boolean;
+  pickDate(value: string): boolean;
+  close(): void;
+  destroy(): void;
+  private readonly onDomEvent;
+  private readonly onPaintedClick;
+  private readonly onKeyDown;
+  private readonly onScroll;
+  private open;
+  private removeDismissListeners;
+  private unbindView;
+}
+//#endregion
+export { ContentControlListItem, ContentControlPickerPosition, ContentControlWidgetController, ContentControlWidgetControllerOptions, ContentControlWidgetSnapshot, parseContentControlListItems };