@stll/folio-core 0.1.3 → 0.3.0

package/dist/managers/AutoSaveManager.js

@@ -0,0 +1,279 @@
+import { Subscribable } from "./Subscribable.js";
+//#region src/managers/AutoSaveManager.ts
+const DEFAULT_STORAGE_KEY = "docx-editor-autosave";
+const DEFAULT_INTERVAL = 3e4;
+const DEFAULT_MAX_AGE = 1440 * 60 * 1e3;
+const DEFAULT_DEBOUNCE_DELAY = 2e3;
+const SAVE_VERSION = 1;
+function isLocalStorageAvailable() {
+	try {
+		const testKey = "__docx_editor_test__";
+		localStorage.setItem(testKey, "test");
+		localStorage.removeItem(testKey);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function serializeForStorage(document) {
+	return JSON.stringify({
+		...document,
+		originalBuffer: null
+	});
+}
+function isDocumentLike(value) {
+	return typeof value === "object" && value !== null && "package" in value;
+}
+function parseSavedData(json) {
+	let parsed;
+	try {
+		parsed = JSON.parse(json);
+	} catch {
+		return null;
+	}
+	if (typeof parsed !== "object" || parsed === null) return null;
+	if (!("document" in parsed) || !("savedAt" in parsed) || !("version" in parsed)) return null;
+	const { document, savedAt, version } = parsed;
+	if (typeof savedAt !== "string" || typeof version !== "number") return null;
+	if (!isDocumentLike(document)) return null;
+	return {
+		document,
+		savedAt,
+		version
+	};
+}
+function isStale(savedAt, maxAge) {
+	const savedTime = new Date(savedAt).getTime();
+	return Date.now() - savedTime > maxAge;
+}
+var AutoSaveManager = class extends Subscribable {
+	storageKey;
+	interval;
+	maxAge;
+	saveOnChange;
+	debounceDelay;
+	onSaveCallback;
+	onErrorCallback;
+	onRecoveryAvailableCallback;
+	storageAvailable;
+	currentDocument = null;
+	lastSavedJson = null;
+	intervalTimer = null;
+	debounceTimer = null;
+	status = "idle";
+	lastSaveTime = null;
+	hasRecoveryData = false;
+	isEnabled;
+	constructor(options = {}) {
+		super({
+			status: "idle",
+			lastSaveTime: null,
+			hasRecoveryData: false,
+			isEnabled: true
+		});
+		this.storageKey = options.storageKey ?? DEFAULT_STORAGE_KEY;
+		this.interval = options.interval ?? DEFAULT_INTERVAL;
+		this.maxAge = options.maxAge ?? DEFAULT_MAX_AGE;
+		this.saveOnChange = options.saveOnChange ?? true;
+		this.debounceDelay = options.debounceDelay ?? DEFAULT_DEBOUNCE_DELAY;
+		this.onSaveCallback = options.onSave;
+		this.onErrorCallback = options.onError;
+		this.onRecoveryAvailableCallback = options.onRecoveryAvailable;
+		this.isEnabled = true;
+		this.storageAvailable = isLocalStorageAvailable();
+		this.checkRecoveryData();
+	}
+	/** Update the current document. Triggers a debounced save if enabled. */
+	onDocumentChanged(document) {
+		this.currentDocument = document;
+		if (this.isEnabled && this.saveOnChange && document && this.storageAvailable) this.debounceSave();
+	}
+	/** Manually trigger a save. */
+	save() {
+		if (!this.storageAvailable) {
+			this.onErrorCallback?.(/* @__PURE__ */ new Error("localStorage is not available"));
+			return false;
+		}
+		const doc = this.currentDocument;
+		if (!doc) return false;
+		this.updateStatus("saving");
+		try {
+			const serialized = serializeForStorage(doc);
+			if (serialized === this.lastSavedJson) {
+				this.updateStatus("saved");
+				return true;
+			}
+			this.persistToStorage(doc);
+			this.lastSavedJson = serialized;
+			const saveTime = /* @__PURE__ */ new Date();
+			this.lastSaveTime = saveTime;
+			this.updateStatus("saved");
+			this.onSaveCallback?.(saveTime);
+			return true;
+		} catch (error) {
+			this.updateStatus("error");
+			this.onErrorCallback?.(error instanceof Error ? error : new Error(String(error)));
+			return false;
+		}
+	}
+	/** Clear auto-saved data from storage. */
+	clear() {
+		if (!this.storageAvailable) return;
+		try {
+			localStorage.removeItem(this.storageKey);
+			this.hasRecoveryData = false;
+			this.lastSavedJson = null;
+			this.emitSnapshot();
+		} catch (error) {
+			this.onErrorCallback?.(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	/** Get recovery data from storage. */
+	getRecoveryData() {
+		if (!this.storageAvailable) return null;
+		const savedJson = localStorage.getItem(this.storageKey);
+		if (!savedJson) return null;
+		const savedData = parseSavedData(savedJson);
+		if (!savedData) return null;
+		if (isStale(savedData.savedAt, this.maxAge)) {
+			this.clear();
+			return null;
+		}
+		return savedData;
+	}
+	/** Accept recovery and return the document. */
+	acceptRecovery() {
+		const data = this.getRecoveryData();
+		if (!data) return null;
+		this.hasRecoveryData = false;
+		this.emitSnapshot();
+		return data.document;
+	}
+	/** Dismiss recovery and clear saved data. */
+	dismissRecovery() {
+		this.clear();
+		this.hasRecoveryData = false;
+		this.emitSnapshot();
+	}
+	/** Enable auto-save and start the interval timer. */
+	enable() {
+		this.isEnabled = true;
+		this.startInterval();
+		this.emitSnapshot();
+	}
+	/** Disable auto-save and stop all timers. */
+	disable() {
+		this.isEnabled = false;
+		this.stopTimers();
+		this.emitSnapshot();
+	}
+	/** Start the interval timer. Call after enabling or on init. */
+	startInterval() {
+		this.stopTimers();
+		if (!this.isEnabled || !this.storageAvailable) return;
+		this.intervalTimer = setInterval(() => {
+			this.save();
+		}, this.interval);
+	}
+	/** Save synchronously on destroy (best-effort). */
+	destroy() {
+		this.stopTimers();
+		if (this.isEnabled && this.currentDocument && this.storageAvailable) try {
+			this.persistToStorage(this.currentDocument);
+		} catch (error) {
+			this.onErrorCallback?.(error instanceof Error ? error : new Error(String(error)));
+		}
+	}
+	checkRecoveryData() {
+		if (!this.storageAvailable) return;
+		const data = this.getRecoveryData();
+		if (data) {
+			this.hasRecoveryData = true;
+			this.emitSnapshot();
+			this.onRecoveryAvailableCallback?.(data);
+		}
+	}
+	persistToStorage(document) {
+		const dataToSave = {
+			document: {
+				...document,
+				originalBuffer: null
+			},
+			savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			version: SAVE_VERSION
+		};
+		localStorage.setItem(this.storageKey, JSON.stringify(dataToSave));
+	}
+	debounceSave() {
+		if (this.debounceTimer) clearTimeout(this.debounceTimer);
+		this.debounceTimer = setTimeout(() => {
+			this.save();
+		}, this.debounceDelay);
+	}
+	stopTimers() {
+		if (this.intervalTimer) {
+			clearInterval(this.intervalTimer);
+			this.intervalTimer = null;
+		}
+		if (this.debounceTimer) {
+			clearTimeout(this.debounceTimer);
+			this.debounceTimer = null;
+		}
+	}
+	updateStatus(status) {
+		this.status = status;
+		this.emitSnapshot();
+	}
+	emitSnapshot() {
+		this.setSnapshot({
+			status: this.status,
+			lastSaveTime: this.lastSaveTime,
+			hasRecoveryData: this.hasRecoveryData,
+			isEnabled: this.isEnabled
+		});
+	}
+};
+/** Format last save time for display. */
+function formatLastSaveTime(date) {
+	if (!date) return "Never";
+	const diffMs = (/* @__PURE__ */ new Date()).getTime() - date.getTime();
+	const diffSec = Math.floor(diffMs / 1e3);
+	const diffMin = Math.floor(diffSec / 60);
+	const diffHour = Math.floor(diffMin / 60);
+	if (diffSec < 10) return "Just now";
+	if (diffSec < 60) return `${diffSec} seconds ago`;
+	if (diffMin < 60) return `${diffMin} minute${diffMin === 1 ? "" : "s"} ago`;
+	if (diffHour < 24) return `${diffHour} hour${diffHour === 1 ? "" : "s"} ago`;
+	return date.toLocaleDateString();
+}
+/** Get auto-save status label. */
+function getAutoSaveStatusLabel(status) {
+	return {
+		idle: "Ready",
+		saving: "Saving...",
+		saved: "Saved",
+		error: "Save failed"
+	}[status];
+}
+/** Get storage size used by auto-save (bytes). */
+function getAutoSaveStorageSize(storageKey = DEFAULT_STORAGE_KEY) {
+	try {
+		const data = localStorage.getItem(storageKey);
+		if (!data) return 0;
+		return new Blob([data]).size;
+	} catch {
+		return 0;
+	}
+}
+/** Format storage size for display. */
+function formatStorageSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+/** Check whether auto-save is supported. */
+function isAutoSaveSupported() {
+	return isLocalStorageAvailable();
+}
+//#endregion
+export { AutoSaveManager, formatLastSaveTime, formatStorageSize, getAutoSaveStatusLabel, getAutoSaveStorageSize, isAutoSaveSupported };

package/dist/managers/ClipboardManager.d.ts

@@ -0,0 +1,31 @@
+import { document_d_exports } from "../types/document.js";
+
+//#region src/managers/ClipboardManager.d.ts
+/** Selection data for clipboard operations. */
+type ClipboardSelection = {
+  text: string;
+  runs: document_d_exports.Run[];
+  startParagraphIndex: number;
+  startRunIndex: number;
+  startOffset: number;
+  endParagraphIndex: number;
+  endRunIndex: number;
+  endOffset: number;
+  isMultiParagraph: boolean;
+};
+/**
+ * Convert a CSS color string (rgb/rgba/hex) to a 6-char uppercase hex string.
+ *
+ * NOTE: This parses CSS color *strings*, unlike a numeric-component
+ * `rgbToHex(r, g, b)` helper.
+ */
+declare function cssColorToHex(color: string): string | null;
+/** Extract formatting from an HTML element's computed styles. */
+declare function extractFormattingFromElement(element: HTMLElement): document_d_exports.TextFormatting | undefined;
+/** Get selected runs from the current DOM selection. */
+declare function getSelectionRuns(): document_d_exports.Run[];
+/** Create a ClipboardSelection from the current DOM selection. */
+declare function createSelectionFromDOM(): ClipboardSelection | null;
+declare const rgbToHex: typeof cssColorToHex;
+//#endregion
+export { ClipboardSelection, createSelectionFromDOM, cssColorToHex, extractFormattingFromElement, getSelectionRuns, rgbToHex };

package/dist/managers/ClipboardManager.js

@@ -0,0 +1,147 @@
+//#region src/managers/ClipboardManager.ts
+/**
+* Convert a CSS color string (rgb/rgba/hex) to a 6-char uppercase hex string.
+*
+* NOTE: This parses CSS color *strings*, unlike a numeric-component
+* `rgbToHex(r, g, b)` helper.
+*/
+function cssColorToHex(color) {
+	if (!color || color === "transparent" || color === "inherit") return null;
+	if (color.startsWith("#")) return color.slice(1).toUpperCase();
+	const rgbMatch = /rgba?\((?<r>\d+),\s*(?<g>\d+),\s*(?<b>\d+)/u.exec(color);
+	if (rgbMatch?.groups) {
+		const { r, g, b } = rgbMatch.groups;
+		if (r === void 0 || g === void 0 || b === void 0) return null;
+		const rHex = Number.parseInt(r, 10).toString(16).padStart(2, "0");
+		const gHex = Number.parseInt(g, 10).toString(16).padStart(2, "0");
+		const bHex = Number.parseInt(b, 10).toString(16).padStart(2, "0");
+		return (rHex + gHex + bHex).toUpperCase();
+	}
+	return null;
+}
+/** Extract formatting from an HTML element's computed styles. */
+function extractFormattingFromElement(element) {
+	const style = window.getComputedStyle(element);
+	const formatting = {};
+	if (style.fontWeight === "bold" || Number.parseInt(style.fontWeight, 10) >= 700) formatting.bold = true;
+	if (style.fontStyle === "italic") formatting.italic = true;
+	const textDecoration = style.textDecoration || style.textDecorationLine || "";
+	if (textDecoration.includes("underline")) formatting.underline = { style: "single" };
+	if (textDecoration.includes("line-through")) formatting.strike = true;
+	const fontSize = Number.parseFloat(style.fontSize);
+	if (!Number.isNaN(fontSize) && fontSize > 0) formatting.fontSize = Math.round(fontSize / 1.333 * 2);
+	const fontFamily = style.fontFamily.replace(/["']/gu, "").split(",")[0]?.trim();
+	if (fontFamily) formatting.fontFamily = { ascii: fontFamily };
+	const color = style.color;
+	if (color && color !== "rgb(0, 0, 0)") {
+		const hex = cssColorToHex(color);
+		if (hex) formatting.color = { rgb: hex };
+	}
+	const bgColor = style.backgroundColor;
+	if (bgColor && bgColor !== "transparent" && bgColor !== "rgba(0, 0, 0, 0)") {
+		const hex = cssColorToHex(bgColor);
+		if (hex) formatting.shading = { fill: { rgb: hex } };
+	}
+	return Object.keys(formatting).length > 0 ? formatting : void 0;
+}
+/** Get selected text from a run element, considering partial selection. */
+function getSelectedTextFromRun(runEl, range) {
+	const runRange = document.createRange();
+	runRange.selectNodeContents(runEl);
+	const startInRun = range.compareBoundaryPoints(Range.START_TO_START, runRange) >= 0 && range.compareBoundaryPoints(Range.START_TO_END, runRange) <= 0;
+	const endInRun = range.compareBoundaryPoints(Range.END_TO_START, runRange) >= 0 && range.compareBoundaryPoints(Range.END_TO_END, runRange) <= 0;
+	if (startInRun && endInRun) return range.toString();
+	if (startInRun) {
+		const tempRange = document.createRange();
+		tempRange.setStart(range.startContainer, range.startOffset);
+		tempRange.setEnd(runRange.endContainer, runRange.endOffset);
+		return tempRange.toString();
+	}
+	if (endInRun) {
+		const tempRange = document.createRange();
+		tempRange.setStart(runRange.startContainer, runRange.startOffset);
+		tempRange.setEnd(range.endContainer, range.endOffset);
+		return tempRange.toString();
+	}
+	if (range.intersectsNode(runEl)) return runEl.textContent ?? "";
+	return "";
+}
+/** Find the paragraph element containing a node. */
+function findParagraphElement(node) {
+	let current = node;
+	while (current) {
+		if (current instanceof HTMLElement && current.hasAttribute("data-paragraph-index")) return current;
+		current = current.parentNode;
+	}
+	return null;
+}
+/** Get selected runs from the current DOM selection. */
+function getSelectionRuns() {
+	const selection = window.getSelection();
+	if (!selection || selection.isCollapsed) return [];
+	const runs = [];
+	const range = selection.getRangeAt(0);
+	const container = range.commonAncestorContainer;
+	const containerElement = container instanceof HTMLElement ? container : container.parentElement;
+	if (!containerElement) return runs;
+	const runElements = containerElement.querySelectorAll(".docx-run");
+	for (const runEl of runElements) {
+		if (!(runEl instanceof HTMLElement) || !range.intersectsNode(runEl)) continue;
+		const text = getSelectedTextFromRun(runEl, range);
+		if (!text) continue;
+		const formatting = extractFormattingFromElement(runEl);
+		const run = formatting ? {
+			type: "run",
+			formatting,
+			content: [{
+				type: "text",
+				text
+			}]
+		} : {
+			type: "run",
+			content: [{
+				type: "text",
+				text
+			}]
+		};
+		runs.push(run);
+	}
+	if (runs.length === 0) {
+		const selectedText = selection.toString();
+		if (selectedText) runs.push({
+			type: "run",
+			content: [{
+				type: "text",
+				text: selectedText
+			}]
+		});
+	}
+	return runs;
+}
+/** Create a ClipboardSelection from the current DOM selection. */
+function createSelectionFromDOM() {
+	const selection = window.getSelection();
+	if (!selection || selection.isCollapsed) return null;
+	const runs = getSelectionRuns();
+	if (runs.length === 0) return null;
+	const text = selection.toString();
+	const range = selection.getRangeAt(0);
+	const startPara = findParagraphElement(range.startContainer);
+	const endPara = findParagraphElement(range.endContainer);
+	const startParagraphIndex = startPara ? Number.parseInt(startPara.getAttribute("data-paragraph-index") ?? "0", 10) : 0;
+	const endParagraphIndex = endPara ? Number.parseInt(endPara.getAttribute("data-paragraph-index") ?? "0", 10) : 0;
+	return {
+		text,
+		runs,
+		startParagraphIndex,
+		startRunIndex: 0,
+		startOffset: range.startOffset,
+		endParagraphIndex,
+		endRunIndex: 0,
+		endOffset: range.endOffset,
+		isMultiParagraph: startParagraphIndex !== endParagraphIndex
+	};
+}
+const rgbToHex = cssColorToHex;
+//#endregion
+export { createSelectionFromDOM, cssColorToHex, extractFormattingFromElement, getSelectionRuns, rgbToHex };

package/dist/paged-layout/rangeProjection.d.ts

@@ -25,6 +25,28 @@ type RangeProjectionContext = {
  * left margin is fixed, so this value holds steady as text is edited.
  */
 declare const measureContentLeft: (pagesContainer: HTMLElement, zoom: number) => number | null;
+/**
+ * One page's body-content vertical extent in container space. `.layout-page-content`
+ * is inset by the page margins, so its box excludes the header/footer and the
+ * inter-page gap — exactly the region a gutter rail is allowed to paint over.
+ */
+type PageContentBand = {
+  /** 0-based page index (from `data-page-number` minus one). */pageIndex: number; /** Top of the body content area, container space. */
+  top: number; /** Bottom of the body content area, container space. */
+  bottom: number;
+};
+/**
+ * Left-margin geometry the block-directive rails need in one measurement pass:
+ * the text-column left edge (rail anchor), the usable left-margin width (gutter
+ * budget), and each page's body-content band (so a rail can be clipped per page
+ * instead of running across page breaks). Measured O(pages), never per-range.
+ */
+type DirectiveGutterGeometry = {
+  /** Text-column left edge, container space. Rails anchor here. */contentLeft: number; /** Usable left-margin width: `contentLeft - pageLeftEdge`. Drives the budget. */
+  marginWidth: number; /** Per-page body-content vertical bands, in document order. */
+  pageBands: PageContentBand[];
+};
+declare const measureDirectiveGutter: (pagesContainer: HTMLElement, zoom: number) => DirectiveGutterGeometry | null;
 /**
  * Computed text style of the painted run at a PM position. Overlays
  * that paint substituted text over the pages (template fill preview,
@@ -48,4 +70,4 @@ type ProjectedRunFont = {
 declare const collectRunFontsAtPmPositions: (pagesContainer: HTMLElement, positions: readonly number[]) => Map<number, ProjectedRunFont>;
 declare const projectRangesToRects: <T extends ProjectableRange>(ranges: readonly T[], ctx: RangeProjectionContext) => Promise<ProjectedRange<T>[]>;
 //#endregion
-export { ProjectableRange, ProjectedRange, ProjectedRunFont, RangeProjectionContext, collectRunFontsAtPmPositions, measureContentLeft, projectRangesToRects };
+export { DirectiveGutterGeometry, PageContentBand, ProjectableRange, ProjectedRange, ProjectedRunFont, RangeProjectionContext, collectRunFontsAtPmPositions, measureContentLeft, measureDirectiveGutter, projectRangesToRects };

package/dist/paged-layout/rangeProjection.js

@@ -77,6 +77,39 @@ const measureContentLeft = (pagesContainer, zoom) => {
 	}
 	return Number.isFinite(min) ? (min - overlayLeft) / zoom : null;
 };
+const measureDirectiveGutter = (pagesContainer, zoom) => {
+	if (zoom <= 0) return null;
+	const overlay = pagesContainer.parentElement?.querySelector("[data-testid=\"selection-overlay\"]");
+	const pages = pagesContainer.querySelectorAll(".layout-page");
+	if (!overlay || pages.length === 0) return null;
+	const overlayRect = overlay.getBoundingClientRect();
+	const pageBands = [];
+	let contentLeft = null;
+	let marginWidth = null;
+	for (const [domIndex, page] of pages.entries()) {
+		const contentEl = page.querySelector(".layout-page-content");
+		if (!contentEl) continue;
+		const pageNumberRaw = page.dataset["pageNumber"];
+		const pageIndex = pageNumberRaw ? Number(pageNumberRaw) - 1 : domIndex;
+		const contentRect = contentEl.getBoundingClientRect();
+		pageBands.push({
+			pageIndex,
+			top: (contentRect.top - overlayRect.top) / zoom,
+			bottom: (contentRect.bottom - overlayRect.top) / zoom
+		});
+		if (contentLeft === null) {
+			const pageRect = page.getBoundingClientRect();
+			contentLeft = (contentRect.left - overlayRect.left) / zoom;
+			marginWidth = Math.max(0, (contentRect.left - pageRect.left) / zoom);
+		}
+	}
+	if (contentLeft === null || marginWidth === null) return null;
+	return {
+		contentLeft,
+		marginWidth,
+		pageBands
+	};
+};
 /**
 * Sample the painted-run text style at each position in a single walk
 * over the rendered run spans. Positions outside the rendered buffer
@@ -150,4 +183,4 @@ const projectRangesToRects = async (ranges, ctx) => {
 	return result;
 };
 //#endregion
-export { collectRunFontsAtPmPositions, measureContentLeft, projectRangesToRects };
+export { collectRunFontsAtPmPositions, measureContentLeft, measureDirectiveGutter, projectRangesToRects };

package/dist/prosemirror/cellDragSelection.d.ts

@@ -0,0 +1,34 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/cellDragSelection.d.ts
+/**
+ * @deprecated No longer used. The tracker ignores pointer overflow so same-cell
+ * drags stay text selections. Kept only for backward-compatible imports; will be
+ * removed in a future major.
+ */
+declare const CELL_SELECT_OVERFLOW_PX = 5;
+/**
+ * Walk up from a PM position to the enclosing `tableCell`/`tableHeader` and
+ * return its `before(d)` position (what `CellSelection` resolves against), or
+ * null when the position isn't inside a table cell.
+ */
+declare function findCellPosFromPmPos(view: EditorView, pmPos: number): number | null;
+/** Dispatch a `CellSelection` spanning the two cell positions. */
+declare function applyCellSelection(view: EditorView, anchorCellPos: number, headCellPos: number): boolean;
+/**
+ * Per-gesture state machine for cell-drag selection. Create one per pointer
+ * handler; drive it from mousedown/mousemove/mouseup.
+ */
+type CellDragTracker = {
+  /** mousedown: record the cell under the press (or null when outside a table). */begin(cellPos: number | null): void;
+  /**
+   * mousemove: returns true when it applied a `CellSelection` and the caller
+   * should NOT also run its text-drag selection for this move.
+   */
+  update(view: EditorView, pmPos: number, clientX: number): boolean; /** mouseup / gesture end: clear the transient drag flags. */
+  end(): void; /** True while a cell drag is actively producing CellSelections. */
+  readonly isCellDragging: boolean;
+};
+declare function createCellDragTracker(): CellDragTracker;
+//#endregion
+export { CELL_SELECT_OVERFLOW_PX, CellDragTracker, applyCellSelection, createCellDragTracker, findCellPosFromPmPos };

package/dist/prosemirror/cellDragSelection.js

@@ -0,0 +1,69 @@
+import { CellSelection } from "prosemirror-tables";
+//#region src/prosemirror/cellDragSelection.ts
+/**
+* @deprecated No longer used. The tracker ignores pointer overflow so same-cell
+* drags stay text selections. Kept only for backward-compatible imports; will be
+* removed in a future major.
+*/
+const CELL_SELECT_OVERFLOW_PX = 5;
+/**
+* Walk up from a PM position to the enclosing `tableCell`/`tableHeader` and
+* return its `before(d)` position (what `CellSelection` resolves against), or
+* null when the position isn't inside a table cell.
+*/
+function findCellPosFromPmPos(view, pmPos) {
+	try {
+		const $pos = view.state.doc.resolve(pmPos);
+		for (let d = $pos.depth; d > 0; d--) {
+			const node = $pos.node(d);
+			if (node.type.name === "tableCell" || node.type.name === "tableHeader") return $pos.before(d);
+		}
+	} catch {}
+	return null;
+}
+/** Dispatch a `CellSelection` spanning the two cell positions. */
+function applyCellSelection(view, anchorCellPos, headCellPos) {
+	try {
+		const $a = view.state.doc.resolve(anchorCellPos);
+		const $h = view.state.doc.resolve(headCellPos);
+		view.dispatch(view.state.tr.setSelection(new CellSelection($a, $h)));
+		return true;
+	} catch {
+		return false;
+	}
+}
+function createCellDragTracker() {
+	let anchorCellPos = null;
+	let cellDragging = false;
+	return {
+		begin(cellPos) {
+			anchorCellPos = cellPos;
+			cellDragging = false;
+		},
+		update(view, pmPos, _clientX) {
+			if (anchorCellPos === null) return false;
+			if (cellDragging) {
+				const cur = findCellPosFromPmPos(view, pmPos);
+				if (cur !== null) {
+					applyCellSelection(view, anchorCellPos, cur);
+					return true;
+				}
+			}
+			const cur = findCellPosFromPmPos(view, pmPos);
+			if (cur !== null && cur !== anchorCellPos) {
+				cellDragging = true;
+				applyCellSelection(view, anchorCellPos, cur);
+				return true;
+			}
+			return false;
+		},
+		end() {
+			cellDragging = false;
+		},
+		get isCellDragging() {
+			return cellDragging;
+		}
+	};
+}
+//#endregion
+export { CELL_SELECT_OVERFLOW_PX, applyCellSelection, createCellDragTracker, findCellPosFromPmPos };

package/dist/prosemirror/commands/sectionBreak.d.ts

@@ -0,0 +1,15 @@
+import { Command } from "prosemirror-state";
+
+//#region src/prosemirror/commands/sectionBreak.d.ts
+/**
+ * Insert a "next page" section break at the cursor — starts a new section on a
+ * new page.
+ */
+declare const insertSectionBreakNextPage: Command;
+/**
+ * Insert a "continuous" section break at the cursor — starts a new section on
+ * the same page.
+ */
+declare const insertSectionBreakContinuous: Command;
+//#endregion
+export { insertSectionBreakContinuous, insertSectionBreakNextPage };