@stll/folio-core 0.10.0 → 0.12.0

package/dist/ai-edits/table-cell-mutations.js

@@ -0,0 +1,237 @@
+import { expectTableCellAttrs } from "../prosemirror/attrs/index.js";
+import { standaloneTableCellFromProseMirror } from "../prosemirror/conversion/fromProseDoc.js";
+import { markStructuralChange } from "../prosemirror/extensions/features/ParagraphChangeTrackerExtension.js";
+import { standaloneTableCellToProseMirror } from "../prosemirror/conversion/toProseDoc.js";
+import { tableRectanglesEqual } from "./table-mutation-plan.js";
+import { tableRectangleCutsMergedCell } from "./table-targets.js";
+import { Result } from "better-result";
+import { TableMap } from "prosemirror-tables";
+import { Fragment } from "prosemirror-model";
+//#region src/ai-edits/table-cell-mutations.ts
+const mergeTableRectangle = ({ tr, tablePosition, table, rectangle }) => {
+	const map = TableMap.get(table);
+	if (rectangle.left < 0 || rectangle.top < 0 || rectangle.right > map.width || rectangle.bottom > map.height || rectangle.left >= rectangle.right || rectangle.top >= rectangle.bottom || rectangle.right - rectangle.left === 1 && rectangle.bottom - rectangle.top === 1 || tableRectangleCutsMergedCell(map, rectangle)) return null;
+	const tableStart = tablePosition + 1;
+	const seen = /* @__PURE__ */ new Set();
+	const cells = [];
+	let appendedContent = Fragment.empty;
+	for (let row = rectangle.top; row < rectangle.bottom; row++) for (let column = rectangle.left; column < rectangle.right; column++) {
+		const cellPosition = map.map[row * map.width + column];
+		if (cellPosition === void 0 || seen.has(cellPosition)) continue;
+		const cell = table.nodeAt(cellPosition);
+		if (!cell) return null;
+		seen.add(cellPosition);
+		cells.push({
+			position: cellPosition,
+			cell
+		});
+		if (cells.length > 1 && !isEmptyTableCell(cell)) appendedContent = appendedContent.append(cell.content);
+	}
+	const merged = cells.at(0);
+	if (!merged || cells.length < 2) return null;
+	const colspan = merged.cell.attrs["colspan"];
+	const rowspan = merged.cell.attrs["rowspan"];
+	const colwidth = merged.cell.attrs["colwidth"];
+	if (typeof colspan !== "number" || !Number.isInteger(colspan) || colspan < 1 || typeof rowspan !== "number" || !Number.isInteger(rowspan) || rowspan < 1 || colwidth !== null && colwidth !== void 0 && (!Array.isArray(colwidth) || colwidth.length !== colspan || !colwidth.every((width) => typeof width === "number"))) return null;
+	const mergedColspan = rectangle.right - rectangle.left;
+	const nextColwidth = Array.isArray(colwidth) ? [...colwidth] : null;
+	while (nextColwidth && nextColwidth.length < mergedColspan) nextColwidth.push(0);
+	const mapFrom = tr.mapping.maps.length;
+	for (const { position: cellPosition, cell } of cells.slice(1)) {
+		const position = tr.mapping.slice(mapFrom).map(tableStart + cellPosition);
+		tr = tr.delete(position, position + cell.nodeSize);
+	}
+	const absoluteMergedPosition = tableStart + merged.position;
+	tr = tr.setNodeMarkup(absoluteMergedPosition, void 0, {
+		...merged.cell.attrs,
+		colspan: mergedColspan,
+		rowspan: rectangle.bottom - rectangle.top,
+		colwidth: nextColwidth
+	});
+	if (appendedContent.size > 0) {
+		const contentEnd = absoluteMergedPosition + 1 + merged.cell.content.size;
+		const contentStart = isEmptyTableCell(merged.cell) ? absoluteMergedPosition + 1 : contentEnd;
+		tr = tr.replaceWith(contentStart, contentEnd, appendedContent);
+	}
+	return tr;
+};
+const mergeTrackedVerticalTableCells = ({ tr, tablePosition, table, rectangle, revisionId, author, date }) => {
+	const map = TableMap.get(table);
+	if (rectangle.right - rectangle.left !== 1 || rectangle.bottom - rectangle.top < 2 || rectangle.left < 0 || rectangle.top < 0 || rectangle.right > map.width || rectangle.bottom > map.height || tableRectangleCutsMergedCell(map, rectangle)) return null;
+	const cells = [];
+	for (let row = rectangle.top; row < rectangle.bottom; row++) {
+		const position = map.map[row * map.width + rectangle.left];
+		if (position === void 0) return null;
+		const cell = table.nodeAt(position);
+		if (!cell || !tableRectanglesEqual(map.findCell(position), {
+			left: rectangle.left,
+			top: row,
+			right: rectangle.right,
+			bottom: row + 1
+		})) return null;
+		const attrs = expectTableCellAttrs(cell);
+		if (attrs.colspan !== 1 || attrs.rowspan !== 1 || attrs.cellMarker !== void 0 || attrs._docxVMergeContinuationCells !== void 0 || attrs._preserveVMergeRestart === true || attrs._originalFormatting?.vMerge !== void 0) return null;
+		cells.push({
+			position,
+			cell
+		});
+	}
+	const origin = cells.at(0);
+	if (!origin || cells.length !== rectangle.bottom - rectangle.top || cells.some(({ cell }) => cell.type !== origin.cell.type) || cells.slice(1).some(({ cell }) => !isEmptyTableCell(cell))) return null;
+	const continuationCells = [];
+	for (const { cell } of cells.slice(1)) {
+		const continuation = standaloneTableCellFromProseMirror(cell);
+		continuation.formatting = {
+			...continuation.formatting,
+			vMerge: "continue"
+		};
+		continuation.structuralChange = {
+			type: "tableCellMerge",
+			info: {
+				id: revisionId,
+				author,
+				date
+			},
+			verticalMerge: "continue",
+			verticalMergeOriginal: "rest"
+		};
+		continuationCells.push(continuation);
+	}
+	const nextTr = mergeTableRectangle({
+		tr,
+		tablePosition,
+		table,
+		rectangle
+	});
+	if (!nextTr) return null;
+	nextTr.setNodeAttribute(tablePosition + 1 + origin.position, "_docxVMergeContinuationCells", continuationCells);
+	markStructuralChange(nextTr);
+	return nextTr;
+};
+const splitTableRectangle = ({ tr, tablePosition, table, rectangle }) => {
+	const map = TableMap.get(table);
+	if (rectangle.left < 0 || rectangle.top < 0 || rectangle.right > map.width || rectangle.bottom > map.height || rectangle.left >= rectangle.right || rectangle.top >= rectangle.bottom || rectangle.right - rectangle.left === 1 && rectangle.bottom - rectangle.top === 1) return null;
+	const cellPosition = map.map[rectangle.top * map.width + rectangle.left];
+	if (cellPosition === void 0) return null;
+	if (!tableRectanglesEqual(map.findCell(cellPosition), rectangle)) return null;
+	const cell = table.nodeAt(cellPosition);
+	if (!cell) return null;
+	const colspan = cell.attrs["colspan"];
+	const rowspan = cell.attrs["rowspan"];
+	const colwidth = cell.attrs["colwidth"];
+	if (typeof colspan !== "number" || !Number.isInteger(colspan) || colspan !== rectangle.right - rectangle.left || typeof rowspan !== "number" || !Number.isInteger(rowspan) || rowspan !== rectangle.bottom - rectangle.top || colwidth !== null && colwidth !== void 0 && (!Array.isArray(colwidth) || colwidth.length !== colspan || !colwidth.every((width) => typeof width === "number"))) return null;
+	const baseAttrs = {
+		...cell.attrs,
+		colspan: 1,
+		rowspan: 1,
+		_preserveVMergeRestart: null,
+		_docxVMergeContinuationCells: null
+	};
+	const attrsByColumn = Array.from({ length: colspan }, (_, index) => ({
+		...baseAttrs,
+		colwidth: Array.isArray(colwidth) && typeof colwidth[index] === "number" && colwidth[index] > 0 ? [colwidth[index]] : null
+	}));
+	const tableStart = tablePosition + 1;
+	const insertions = [];
+	for (let row = rectangle.top; row < rectangle.bottom; row++) {
+		let position = map.positionAt(row, rectangle.left, table);
+		if (row === rectangle.top) position += cell.nodeSize;
+		for (let column = rectangle.left; column < rectangle.right; column++) {
+			if (row === rectangle.top && column === rectangle.left) continue;
+			const attrs = attrsByColumn[column - rectangle.left];
+			const nextCell = attrs ? cell.type.createAndFill(attrs) : null;
+			if (!nextCell) return null;
+			insertions.push({
+				position: tableStart + position,
+				cell: nextCell
+			});
+		}
+	}
+	const mapFrom = tr.mapping.maps.length;
+	for (const insertion of insertions) tr = tr.insert(tr.mapping.slice(mapFrom).map(insertion.position, 1), insertion.cell);
+	return tr.setNodeMarkup(tableStart + cellPosition, void 0, attrsByColumn[0]);
+};
+const splitTrackedVerticalTableCell = ({ tr, tablePosition, table, rectangle, revisionId, author, date }) => {
+	const map = TableMap.get(table);
+	if (rectangle.right - rectangle.left !== 1 || rectangle.bottom - rectangle.top < 2 || rectangle.left < 0 || rectangle.top < 0 || rectangle.right > map.width || rectangle.bottom > map.height) return null;
+	const relativeCellPosition = map.map[rectangle.top * map.width + rectangle.left];
+	if (relativeCellPosition === void 0) return null;
+	if (!tableRectanglesEqual(map.findCell(relativeCellPosition), rectangle)) return null;
+	const cell = table.nodeAt(relativeCellPosition);
+	if (!cell) return null;
+	const attrs = expectTableCellAttrs(cell);
+	if (attrs.colspan !== 1 || attrs.rowspan !== rectangle.bottom - rectangle.top || attrs.cellMarker !== void 0) return null;
+	const continuationCells = attrs._docxVMergeContinuationCells;
+	if (continuationCells !== void 0 && continuationCells.length !== rectangle.bottom - rectangle.top - 1) return null;
+	const marker = {
+		kind: "merge",
+		info: {
+			revisionId,
+			author,
+			date
+		},
+		verticalMergeOriginal: "continue"
+	};
+	const insertedCells = [];
+	for (let index = 0; index < rectangle.bottom - rectangle.top - 1; index++) {
+		const source = continuationCells?.[index];
+		if (source?.structuralChange !== void 0) return null;
+		const insertedCell = source ? trackedSplitCellFromStoredSource({
+			origin: cell,
+			source,
+			marker
+		}) : cell.type.createAndFill({
+			...cell.attrs,
+			rowspan: 1,
+			cellMarker: marker,
+			_originalFormatting: formattingWithoutVerticalMerge(attrs._originalFormatting),
+			_preserveVMergeRestart: null,
+			_docxVMergeContinuationCells: null
+		});
+		if (!insertedCell) return null;
+		insertedCells.push(insertedCell);
+	}
+	const tableStart = tablePosition + 1;
+	const mapFrom = tr.mapping.maps.length;
+	for (const [index, insertedCell] of insertedCells.entries()) {
+		const row = rectangle.top + index + 1;
+		const position = tableStart + map.positionAt(row, rectangle.left, table);
+		tr = tr.insert(tr.mapping.slice(mapFrom).map(position, 1), insertedCell);
+	}
+	tr = tr.setNodeMarkup(tableStart + relativeCellPosition, void 0, {
+		...cell.attrs,
+		rowspan: 1,
+		_originalFormatting: formattingWithoutVerticalMerge(attrs._originalFormatting),
+		_preserveVMergeRestart: null,
+		_docxVMergeContinuationCells: null
+	});
+	markStructuralChange(tr);
+	return tr;
+};
+const isEmptyTableCell = (cell) => cell.childCount === 1 && cell.firstChild?.isTextblock === true && cell.firstChild.childCount === 0;
+const trackedSplitCellFromStoredSource = ({ origin, source, marker }) => {
+	const formatting = formattingWithoutVerticalMerge(source.formatting);
+	const converted = standaloneTableCellToProseMirror({
+		type: "tableCell",
+		...formatting ? { formatting } : {},
+		...source.propertyChanges ? { propertyChanges: source.propertyChanges } : {},
+		content: source.content
+	}, origin.type.name === "tableHeader" ? "tableHeader" : "tableCell");
+	const compatible = Result.try(() => origin.type.schema.nodeFromJSON(converted.toJSON())).unwrapOr(null);
+	if (!compatible) return null;
+	return compatible.type.create({
+		...compatible.attrs,
+		rowspan: 1,
+		cellMarker: marker,
+		_preserveVMergeRestart: null,
+		_docxVMergeContinuationCells: null
+	}, compatible.content);
+};
+const formattingWithoutVerticalMerge = (formatting) => {
+	if (!formatting) return;
+	const next = { ...formatting };
+	delete next.vMerge;
+	return next;
+};
+//#endregion
+export { mergeTableRectangle, mergeTrackedVerticalTableCells, splitTableRectangle, splitTrackedVerticalTableCell };

package/dist/ai-edits/table-mutation-plan.d.ts

@@ -0,0 +1,38 @@
+//#region src/ai-edits/table-mutation-plan.d.ts
+type TableRectangle = {
+  left: number;
+  top: number;
+  right: number;
+  bottom: number;
+};
+type TableMutationPlanTarget = {
+  type: "none";
+} | {
+  type: "tableStructure";
+  tablePosition: number;
+} | {
+  type: "mergeCells";
+  tablePosition: number;
+  rectangle: TableRectangle;
+} | {
+  type: "splitCell";
+  tablePosition: number;
+  rectangle: TableRectangle;
+};
+type TableMutationPlanCandidate<T> = {
+  item: T;
+  operationId: string;
+  target: TableMutationPlanTarget;
+};
+type TableMutationPlanSkip = {
+  id: string;
+  reason: "noopOperation" | "unsupportedBlock";
+};
+type TableMutationPlan<T> = {
+  executable: T[];
+  skipped: TableMutationPlanSkip[];
+};
+declare const planTableMutations: <T>(candidates: readonly TableMutationPlanCandidate<T>[]) => TableMutationPlan<T>;
+declare const tableRectanglesEqual: (left: TableRectangle, right: TableRectangle) => boolean;
+//#endregion
+export { TableMutationPlanTarget, TableRectangle, planTableMutations, tableRectanglesEqual };

package/dist/ai-edits/table-mutation-plan.js

@@ -0,0 +1,90 @@
+//#region src/ai-edits/table-mutation-plan.ts
+const planTableMutations = (candidates) => {
+	const tableStructureMutations = /* @__PURE__ */ new Set();
+	const mergeTables = /* @__PURE__ */ new Set();
+	const splitTables = /* @__PURE__ */ new Set();
+	for (const { target } of candidates) switch (target.type) {
+		case "tableStructure":
+			tableStructureMutations.add(target.tablePosition);
+			break;
+		case "mergeCells":
+			mergeTables.add(target.tablePosition);
+			break;
+		case "splitCell":
+			splitTables.add(target.tablePosition);
+			break;
+		case "none": break;
+	}
+	const mergeRectanglesByTable = /* @__PURE__ */ new Map();
+	const splitRectanglesByTable = /* @__PURE__ */ new Map();
+	const executable = [];
+	const skipped = [];
+	for (const candidate of candidates) {
+		const { target } = candidate;
+		if (target.type === "mergeCells") {
+			if (tableStructureMutations.has(target.tablePosition) || splitTables.has(target.tablePosition)) {
+				skipped.push({
+					id: candidate.operationId,
+					reason: "unsupportedBlock"
+				});
+				continue;
+			}
+			const claimedRectangles = mergeRectanglesByTable.get(target.tablePosition) ?? [];
+			if (claimedRectangles.some((rectangle) => tableRectanglesEqual(rectangle, target.rectangle))) {
+				skipped.push({
+					id: candidate.operationId,
+					reason: "noopOperation"
+				});
+				continue;
+			}
+			if (claimedRectangles.some((rectangle) => tableRectanglesOverlap(rectangle, target.rectangle))) {
+				skipped.push({
+					id: candidate.operationId,
+					reason: "unsupportedBlock"
+				});
+				continue;
+			}
+			claimedRectangles.push(target.rectangle);
+			mergeRectanglesByTable.set(target.tablePosition, claimedRectangles);
+			executable.push(candidate.item);
+			continue;
+		}
+		if (target.type === "splitCell") {
+			if (tableStructureMutations.has(target.tablePosition) || mergeTables.has(target.tablePosition)) {
+				skipped.push({
+					id: candidate.operationId,
+					reason: "unsupportedBlock"
+				});
+				continue;
+			}
+			const claimedRectangles = splitRectanglesByTable.get(target.tablePosition) ?? [];
+			if (claimedRectangles.some((rectangle) => tableRectanglesEqual(rectangle, target.rectangle))) {
+				skipped.push({
+					id: candidate.operationId,
+					reason: "noopOperation"
+				});
+				continue;
+			}
+			if (claimedRectangles.some((rectangle) => tableRectanglesOverlap(rectangle, target.rectangle))) {
+				skipped.push({
+					id: candidate.operationId,
+					reason: "unsupportedBlock"
+				});
+				continue;
+			}
+			claimedRectangles.push(target.rectangle);
+			splitRectanglesByTable.set(target.tablePosition, claimedRectangles);
+			executable.push(candidate.item);
+			continue;
+		}
+		executable.push(candidate.item);
+	}
+	return {
+		executable,
+		skipped
+	};
+};
+const tableRectanglesOverlap = (left, right) => left.left < right.right && right.left < left.right && left.top < right.bottom && right.top < left.bottom;
+const tableRectanglesEqual = (left, right) => left.left === right.left && left.top === right.top && left.right === right.right && left.bottom === right.bottom;
+//#endregion
+export { planTableMutations, tableRectanglesEqual };

package/dist/ai-edits/table-row-column-mutations.d.ts

@@ -0,0 +1,100 @@
+import { TableRowTarget } from "./table-targets.js";
+import { Transaction } from "prosemirror-state";
+import { Node } from "prosemirror-model";
+
+//#region src/ai-edits/table-row-column-mutations.d.ts
+type TableRowInsertion = {
+  tableStart: number;
+  rowPosition: number;
+  rowType: Node["type"];
+  cells: readonly Node[];
+  rowspanUpdates: readonly number[];
+};
+type TableRowDeletion = Omit<TableRowTarget, "table">;
+type TableColumnInsertion = {
+  tablePosition: number;
+  columnIndex: number;
+};
+type TableColumnDeletion = TableColumnInsertion;
+type TableStructureRevision = {
+  revisionId: number;
+  author: string;
+  date: string;
+};
+type TableRowColumnMutationResult = {
+  type: "applied";
+  transaction: Transaction;
+  revisionId: number | null;
+} | {
+  type: "unsupported";
+};
+declare const getTableColumnCoordinateKey: ({
+  tablePosition,
+  columnIndex
+}: TableColumnInsertion) => string;
+type FindTableColumnInsertionOptions = {
+  doc: Node;
+  blockFrom: number;
+  position: "after" | "before";
+};
+declare const findTableColumnInsertion: ({
+  doc,
+  blockFrom,
+  position
+}: FindTableColumnInsertionOptions) => (TableColumnInsertion & {
+  boundaryPosition: number;
+}) | null;
+type FindTableRowInsertionOptions = FindTableColumnInsertionOptions;
+declare const findTableRowInsertion: ({
+  doc,
+  blockFrom,
+  position
+}: FindTableRowInsertionOptions) => TableRowInsertion | null;
+type ApplyTableRowInsertionOptions = {
+  tr: Transaction;
+  insertion: TableRowInsertion;
+  cellTexts: readonly string[] | undefined;
+  revision: TableStructureRevision | null;
+};
+declare const applyTableRowInsertion: ({
+  tr,
+  insertion,
+  cellTexts,
+  revision
+}: ApplyTableRowInsertionOptions) => TableRowColumnMutationResult;
+type ApplyTableColumnInsertionOptions = {
+  tr: Transaction;
+  insertion: TableColumnInsertion;
+  cellTexts: readonly string[] | undefined;
+  revision: TableStructureRevision | null;
+};
+declare const applyTableColumnInsertion: ({
+  tr,
+  insertion,
+  cellTexts,
+  revision
+}: ApplyTableColumnInsertionOptions) => TableRowColumnMutationResult;
+type ApplyTableColumnDeletionOptions = {
+  tr: Transaction;
+  deletion: TableColumnDeletion;
+  insertedColumnCount: number;
+  revision: TableStructureRevision | null;
+};
+declare const applyTableColumnDeletion: ({
+  tr,
+  deletion,
+  insertedColumnCount,
+  revision
+}: ApplyTableColumnDeletionOptions) => TableRowColumnMutationResult;
+type ApplyTableRowDeletionOptions = {
+  tr: Transaction;
+  deletion: TableRowDeletion;
+  revision: TableStructureRevision | null;
+};
+declare const applyTableRowDeletion: ({
+  tr,
+  deletion,
+  revision
+}: ApplyTableRowDeletionOptions) => TableRowColumnMutationResult;
+//#endregion
+export { TableColumnDeletion, TableColumnInsertion, TableRowDeletion, TableRowInsertion, TableStructureRevision, applyTableColumnDeletion, applyTableColumnInsertion, applyTableRowDeletion, applyTableRowInsertion, findTableColumnInsertion, findTableRowInsertion, getTableColumnCoordinateKey };