@stll/folio-core 0.1.3 → 0.2.0

package/dist/prosemirror/imageCommit.js

@@ -0,0 +1,118 @@
+//#region src/prosemirror/imageCommit.ts
+const MIN_IMAGE_PX = 20;
+const MAX_IMAGE_PX = 2e3;
+/**
+* New image dimensions for a resize drag, shared by the React and Vue overlays
+* (issue #266). Corner handles drive both axes (aspect-locked unless
+* `lockAspect` is false, e.g. Shift held); edge handles drive one axis and
+* never lock. The non-driven axis is returned unchanged. Driven axes are
+* clamped to a sane pixel range.
+*/
+function calculateResizedImageDimensions(handle, deltaX, deltaY, startWidth, startHeight, lockAspect) {
+	const drivesWidth = handle.includes("w") || handle.includes("e");
+	const drivesHeight = handle.includes("n") || handle.includes("s");
+	const isCorner = drivesWidth && drivesHeight;
+	const signX = handle.includes("w") ? -1 : 1;
+	const signY = handle.includes("n") ? -1 : 1;
+	let newWidth = drivesWidth ? startWidth + deltaX * signX : startWidth;
+	let newHeight = drivesHeight ? startHeight + deltaY * signY : startHeight;
+	if (isCorner && lockAspect) {
+		const scale = Math.max(newWidth / startWidth, newHeight / startHeight);
+		newWidth = startWidth * scale;
+		newHeight = startHeight * scale;
+	}
+	const clamp = (n) => Math.max(MIN_IMAGE_PX, Math.min(MAX_IMAGE_PX, n));
+	return {
+		width: drivesWidth ? clamp(newWidth) : startWidth,
+		height: drivesHeight ? clamp(newHeight) : startHeight
+	};
+}
+/** True when the image is floating (anchored) rather than inline. */
+function isFloatingImage(node) {
+	const wrapType = node.attrs["wrapType"];
+	return node.attrs["displayMode"] === "float" || (wrapType ? [
+		"square",
+		"tight",
+		"through"
+	].includes(wrapType) : false);
+}
+/** Resolve the image node at `pmPos`, or null if it isn't an image. */
+function imageNodeAt(view, pmPos) {
+	const node = view.state.doc.nodeAt(pmPos);
+	if (!node || node.type.name !== "image") return null;
+	return node;
+}
+/**
+* Resize commit: set the image node's `width`/`height`. Returns `pmPos` to
+* re-select, or null if the position no longer holds an image.
+*/
+function commitImageResize(view, pmPos, newWidth, newHeight) {
+	try {
+		const node = imageNodeAt(view, pmPos);
+		if (!node) return null;
+		view.dispatch(view.state.tr.setNodeMarkup(pmPos, void 0, {
+			...node.attrs,
+			width: newWidth,
+			height: newHeight
+		}));
+		return pmPos;
+	} catch {
+		return null;
+	}
+}
+/**
+* Floating drag commit: rewrite the anchor's margin-relative `position`
+* offsets (in EMU) so the image lands at the drop point while staying
+* floating. Returns `pmPos` to re-select, or null on no-op / failure.
+*/
+function commitImageFloatMove(view, pmPos, hOffsetEmu, vOffsetEmu) {
+	try {
+		const node = imageNodeAt(view, pmPos);
+		if (!node) return null;
+		const newPosition = {
+			horizontal: {
+				posOffset: hOffsetEmu,
+				relativeTo: "margin"
+			},
+			vertical: {
+				posOffset: vOffsetEmu,
+				relativeTo: "margin"
+			}
+		};
+		view.dispatch(view.state.tr.setNodeMarkup(pmPos, void 0, {
+			...node.attrs,
+			position: newPosition
+		}));
+		return pmPos;
+	} catch {
+		return null;
+	}
+}
+/**
+* Inline drag commit: move the image node to `dropPos` via a delete + insert
+* pair. Returns the PM position to re-select, or null when the drop is a
+* no-op (same slot) or fails.
+*/
+function commitImageInlineMove(view, pmPos, dropPos) {
+	try {
+		const node = imageNodeAt(view, pmPos);
+		if (!node) return null;
+		if (dropPos === pmPos || dropPos === pmPos + 1) return null;
+		let tr = view.state.tr;
+		if (dropPos <= pmPos) {
+			tr = tr.delete(pmPos, pmPos + node.nodeSize);
+			tr = tr.insert(dropPos, node);
+			view.dispatch(tr);
+			return dropPos;
+		}
+		tr = tr.delete(pmPos, pmPos + node.nodeSize);
+		const adjusted = Math.min(dropPos - node.nodeSize, tr.doc.content.size);
+		tr = tr.insert(adjusted, node);
+		view.dispatch(tr);
+		return Math.min(adjusted, view.state.doc.content.size - 1);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+export { calculateResizedImageDimensions, commitImageFloatMove, commitImageInlineMove, commitImageResize, isFloatingImage };

package/dist/prosemirror/paraText.d.ts

@@ -0,0 +1,26 @@
+import { Node } from "prosemirror-model";
+
+//#region src/prosemirror/paraText.d.ts
+/** Text of a single PM node (typically a paragraph), vanilla view. */
+declare function getVanillaNodeText(node: Node): string;
+/** Text between two doc positions, vanilla view. */
+declare function getVanillaTextBetween(doc: Node, from: number, to: number): string;
+/**
+ * Find `searchText` within a PM paragraph range and return its position.
+ *
+ * Returns null if:
+ *   - searchText is empty
+ *   - searchText is not found
+ *   - searchText appears more than once (ambiguous; caller disambiguates)
+ *
+ * The fullText is built from PM text nodes only and matches the vanilla
+ * view the agent reads via `read_document`: tracked insertions are
+ * excluded (not in the doc yet), tracked deletions are included (still
+ * in the doc until accepted), and comment markers are stripped.
+ */
+declare function findTextInPmParagraph(doc: Node, paragraphFrom: number, paragraphTo: number, searchText: string): {
+  from: number;
+  to: number;
+} | null;
+//#endregion
+export { findTextInPmParagraph, getVanillaNodeText, getVanillaTextBetween };

package/dist/prosemirror/paraText.js

@@ -0,0 +1,73 @@
+//#region src/prosemirror/paraText.ts
+/** Text of a single PM node (typically a paragraph), vanilla view. */
+function getVanillaNodeText(node) {
+	const parts = [];
+	node.descendants((child) => {
+		if (!child.isText || !child.text) return true;
+		if (child.marks.some((m) => m.type.name === "insertion")) return false;
+		parts.push(child.text);
+		return true;
+	});
+	return parts.join("");
+}
+/** Text between two doc positions, vanilla view. */
+function getVanillaTextBetween(doc, from, to) {
+	if (from >= to) return "";
+	const parts = [];
+	doc.nodesBetween(from, to, (child, pos) => {
+		if (!child.isText || !child.text) return;
+		if (child.marks.some((m) => m.type.name === "insertion")) return;
+		const start = Math.max(from, pos);
+		const end = Math.min(to, pos + child.text.length);
+		if (start < end) parts.push(child.text.slice(start - pos, end - pos));
+	});
+	return parts.join("");
+}
+/**
+* Find `searchText` within a PM paragraph range and return its position.
+*
+* Returns null if:
+*   - searchText is empty
+*   - searchText is not found
+*   - searchText appears more than once (ambiguous; caller disambiguates)
+*
+* The fullText is built from PM text nodes only and matches the vanilla
+* view the agent reads via `read_document`: tracked insertions are
+* excluded (not in the doc yet), tracked deletions are included (still
+* in the doc until accepted), and comment markers are stripped.
+*/
+function findTextInPmParagraph(doc, paragraphFrom, paragraphTo, searchText) {
+	if (!searchText) return null;
+	let fullText = "";
+	const textPositions = [];
+	doc.nodesBetween(paragraphFrom, paragraphTo, (node, pos) => {
+		if (!node.isText || !node.text) return;
+		if (node.marks.some((m) => m.type.name === "insertion")) return;
+		textPositions.push({
+			pos,
+			len: node.text.length
+		});
+		fullText += node.text;
+	});
+	const firstMatch = fullText.indexOf(searchText);
+	if (firstMatch === -1) return null;
+	if (fullText.indexOf(searchText, firstMatch + 1) !== -1) return null;
+	let charOffset = 0;
+	let fromPos = paragraphFrom;
+	let toPos = paragraphFrom;
+	for (const tp of textPositions) {
+		const segEnd = charOffset + tp.len;
+		if (charOffset <= firstMatch && firstMatch < segEnd) fromPos = tp.pos + (firstMatch - charOffset);
+		if (charOffset <= firstMatch + searchText.length && firstMatch + searchText.length <= segEnd) {
+			toPos = tp.pos + (firstMatch + searchText.length - charOffset);
+			break;
+		}
+		charOffset = segEnd;
+	}
+	return {
+		from: fromPos,
+		to: toPos
+	};
+}
+//#endregion
+export { findTextInPmParagraph, getVanillaNodeText, getVanillaTextBetween };

package/dist/prosemirror/plugins/templateDirectives.d.ts

@@ -12,6 +12,26 @@ type DirectiveRange = {
   clauseVersion?: string; /** True for block directives that occupy their own paragraph. */
   block: boolean;
 };
+/**
+ * Nesting depth (0-based) of every block-directive opener, derived purely from
+ * the scanned ranges by containment: walk the block openers/closers in document
+ * order with a kind-aware stack, and record each opener's depth as the stack size
+ * before it is pushed. Only `block:true` if/each pairs participate (inline markers
+ * resolve within a paragraph and get no rail).
+ *
+ * Matching is kind-aware so a mid-edit / unbalanced template stays sane: a closer
+ * pops the nearest opener of the *same family* ({{/if}} ⇒ {{#if}}, {{/each}} ⇒
+ * {{#each}}), dropping any still-open openers nested above it; a closer with no
+ * matching opener is ignored (never decrements a foreign block's depth). A blind
+ * open/close counter would mis-count here: e.g. a stray {{/each}} between {{#if}}
+ * and a nested {{#each}} would wrongly pull the inner {{#each}} back to depth 0.
+ *
+ * Keyed by the opener's `from` PM position, which is unique per marker, so the
+ * overlay can look a band's depth up from its opener range. This is a pure
+ * function of the ranges (no layout), hence unit-testable in isolation; the
+ * overlay caps the *visual* indentation separately.
+ */
+declare const computeBlockDepths: (ranges: readonly DirectiveRange[]) => Map<number, number>;
 declare const scanDirectives: (doc: Node) => DirectiveRange[];
 declare const templateDirectivesKey: PluginKey<DocScanState<undefined, DirectiveRange>>;
 type TemplateDirectivesPluginOptions = {
@@ -22,4 +42,4 @@ declare const createTemplateDirectivesPlugin: ({
 }?: TemplateDirectivesPluginOptions) => import("prosemirror-state").Plugin<DocScanState<undefined, DirectiveRange>>;
 declare const getTemplateDirectives: (state: EditorState) => readonly DirectiveRange[];
 //#endregion
-export { type DirectiveKind, DirectiveRange, TemplateDirectivesPluginOptions, createTemplateDirectivesPlugin, getTemplateDirectives, scanDirectives, templateDirectivesKey };
+export { type DirectiveKind, DirectiveRange, TemplateDirectivesPluginOptions, computeBlockDepths, createTemplateDirectivesPlugin, getTemplateDirectives, scanDirectives, templateDirectivesKey };

package/dist/prosemirror/plugins/templateDirectives.js

@@ -21,6 +21,45 @@ const directiveExpr = (meta) => {
 		default: return assertNever(meta);
 	}
 };
+/** Block-directive openers ({{#if}}, {{#each}}) that start a gutter-rail band. */
+const BLOCK_OPENER_KINDS = /* @__PURE__ */ new Set(["if", "each"]);
+/** Block-directive closers ({{/if}}, {{/each}}) that end a gutter-rail band. */
+const BLOCK_CLOSER_KINDS = /* @__PURE__ */ new Set(["endif", "endeach"]);
+/**
+* Nesting depth (0-based) of every block-directive opener, derived purely from
+* the scanned ranges by containment: walk the block openers/closers in document
+* order with a kind-aware stack, and record each opener's depth as the stack size
+* before it is pushed. Only `block:true` if/each pairs participate (inline markers
+* resolve within a paragraph and get no rail).
+*
+* Matching is kind-aware so a mid-edit / unbalanced template stays sane: a closer
+* pops the nearest opener of the *same family* ({{/if}} ⇒ {{#if}}, {{/each}} ⇒
+* {{#each}}), dropping any still-open openers nested above it; a closer with no
+* matching opener is ignored (never decrements a foreign block's depth). A blind
+* open/close counter would mis-count here: e.g. a stray {{/each}} between {{#if}}
+* and a nested {{#each}} would wrongly pull the inner {{#each}} back to depth 0.
+*
+* Keyed by the opener's `from` PM position, which is unique per marker, so the
+* overlay can look a band's depth up from its opener range. This is a pure
+* function of the ranges (no layout), hence unit-testable in isolation; the
+* overlay caps the *visual* indentation separately.
+*/
+const computeBlockDepths = (ranges) => {
+	const depths = /* @__PURE__ */ new Map();
+	const stack = [];
+	const ordered = ranges.filter((r) => r.block && (BLOCK_OPENER_KINDS.has(r.kind) || BLOCK_CLOSER_KINDS.has(r.kind))).slice().sort((a, b) => a.from - b.from);
+	for (const range of ordered) {
+		if (BLOCK_OPENER_KINDS.has(range.kind)) {
+			depths.set(range.from, stack.length);
+			stack.push(range.kind);
+			continue;
+		}
+		const wantOpener = range.kind === "endif" ? "if" : "each";
+		const matchIdx = stack.lastIndexOf(wantOpener);
+		if (matchIdx !== -1) stack.length = matchIdx;
+	}
+	return depths;
+};
 const scanDirectives = (doc) => {
 	const ranges = [];
 	for (const chunks of collectBlockChunks(doc)) {
@@ -64,4 +103,4 @@ const createTemplateDirectivesPlugin = ({ onRangesChange } = {}) => createDocSca
 });
 const getTemplateDirectives = (state) => getDocScanRanges(templateDirectivesKey, state);
 //#endregion
-export { createTemplateDirectivesPlugin, getTemplateDirectives, scanDirectives, templateDirectivesKey };
+export { computeBlockDepths, createTemplateDirectivesPlugin, getTemplateDirectives, scanDirectives, templateDirectivesKey };

package/dist/prosemirror/queries.d.ts

@@ -0,0 +1,46 @@
+import { Node } from "prosemirror-model";
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/queries.d.ts
+/** A resolved PM position range — half-open `[from, to)` in PM coordinates. */
+type PmRange = {
+  from: number;
+  to: number;
+};
+/**
+ * Clamp a caller-supplied `[from, to]` range to a valid in-document span, or
+ * return `null` when it cannot be made valid: non-integer, negative, reversed
+ * (`to < from`), or a `from` past the document end. `to` is clamped to the
+ * document size so an out-of-range end never makes `doc.resolve()` throw a
+ * `RangeError`. Both adapters' `highlightRange` route raw caller positions
+ * through this so the no-op contract holds identically.
+ */
+declare function clampRangeToDoc(doc: Node, from: number, to: number): PmRange | null;
+/**
+ * Resolve a `commentId` to the PM position range its `comment` mark
+ * spans. Walks every inline node carrying a `comment` mark with the
+ * matching id and returns the union range (earliest start → latest end),
+ * so a comment whose range is interrupted by un-marked inline atoms still
+ * resolves to a single span. Returns `null` when the id is no longer
+ * present (the comment was deleted, or the marked text was removed) — the
+ * caller distinguishes "scrolled" from "stale" on that signal.
+ *
+ * Pure read over `view.state`; no dispatch.
+ */
+declare function findCommentRange(view: EditorView | null, commentId: number): PmRange | null;
+/**
+ * Resolve a tracked-change `revisionId` to the PM position range of its
+ * first site. Delegates to {@link extractTrackedChanges} so a coalesced
+ * revision (sites scattered across paragraphs, replace pairs, Enter
+ * chains) resolves to the same entry the sidebar shows. Matches on the
+ * entry's primary `revisionId`, its `insertionRevisionId`, or any
+ * `coalescedRevisionIds` member. Returns `null` when no entry carries the
+ * id (the change was accepted/rejected/deleted) — the caller uses this to
+ * show a "location no longer exists" affordance instead of a silent
+ * no-op.
+ *
+ * Pure read over `view.state`; no dispatch.
+ */
+declare function findChangeRange(view: EditorView | null, revisionId: number): PmRange | null;
+//#endregion
+export { PmRange, clampRangeToDoc, findChangeRange, findCommentRange };

package/dist/prosemirror/queries.js

@@ -0,0 +1,74 @@
+import { extractTrackedChanges } from "./utils/extractTrackedChanges.js";
+//#region src/prosemirror/queries.ts
+/**
+* Clamp a caller-supplied `[from, to]` range to a valid in-document span, or
+* return `null` when it cannot be made valid: non-integer, negative, reversed
+* (`to < from`), or a `from` past the document end. `to` is clamped to the
+* document size so an out-of-range end never makes `doc.resolve()` throw a
+* `RangeError`. Both adapters' `highlightRange` route raw caller positions
+* through this so the no-op contract holds identically.
+*/
+function clampRangeToDoc(doc, from, to) {
+	if (!Number.isInteger(from) || !Number.isInteger(to) || from < 0 || to < from) return null;
+	const max = doc.content.size;
+	if (from > max) return null;
+	return {
+		from,
+		to: Math.min(to, max)
+	};
+}
+/**
+* Resolve a `commentId` to the PM position range its `comment` mark
+* spans. Walks every inline node carrying a `comment` mark with the
+* matching id and returns the union range (earliest start → latest end),
+* so a comment whose range is interrupted by un-marked inline atoms still
+* resolves to a single span. Returns `null` when the id is no longer
+* present (the comment was deleted, or the marked text was removed) — the
+* caller distinguishes "scrolled" from "stale" on that signal.
+*
+* Pure read over `view.state`; no dispatch.
+*/
+function findCommentRange(view, commentId) {
+	if (!view) return null;
+	const commentType = view.state.schema.marks["comment"];
+	if (!commentType) return null;
+	let from = Infinity;
+	let to = -Infinity;
+	view.state.doc.descendants((node, pos) => {
+		if (!node.isInline) return;
+		for (const mark of node.marks) if (mark.type === commentType && mark.attrs["commentId"] === commentId) {
+			from = Math.min(from, pos);
+			to = Math.max(to, pos + node.nodeSize);
+		}
+	});
+	if (to < 0) return null;
+	return {
+		from,
+		to
+	};
+}
+/**
+* Resolve a tracked-change `revisionId` to the PM position range of its
+* first site. Delegates to {@link extractTrackedChanges} so a coalesced
+* revision (sites scattered across paragraphs, replace pairs, Enter
+* chains) resolves to the same entry the sidebar shows. Matches on the
+* entry's primary `revisionId`, its `insertionRevisionId`, or any
+* `coalescedRevisionIds` member. Returns `null` when no entry carries the
+* id (the change was accepted/rejected/deleted) — the caller uses this to
+* show a "location no longer exists" affordance instead of a silent
+* no-op.
+*
+* Pure read over `view.state`; no dispatch.
+*/
+function findChangeRange(view, revisionId) {
+	if (!view) return null;
+	const { entries } = extractTrackedChanges(view.state);
+	const entry = entries.find((e) => e.revisionId === revisionId || e.insertionRevisionId === revisionId || e.coalescedRevisionIds?.includes(revisionId));
+	if (!entry) return null;
+	return {
+		from: entry.from,
+		to: entry.to
+	};
+}
+//#endregion
+export { clampRangeToDoc, findChangeRange, findCommentRange };

package/dist/prosemirror/styles/styleResolver.d.ts

@@ -8,6 +8,22 @@ type ResolvedParagraphStyle = {
   /** Paragraph formatting (alignment, spacing, indentation, etc.) */paragraphFormatting?: document_d_exports.ParagraphFormatting; /** Default run formatting from the style */
   runFormatting?: document_d_exports.TextFormatting;
 };
+/**
+ * Paragraph-spacing fields sourced from the table style enclosing a cell
+ * paragraph: the table style's own `w:pPr`, then the applicable
+ * `w:tblStylePr` conditional region's `w:pPr` layered on top (already merged
+ * by the caller — see `resolveTableBaseStyle`/`resolveTableStyleConditional`
+ * in toProseDoc.ts).
+ *
+ * Deliberately narrower than the full {@link ParagraphFormatting}: this is
+ * the layer-2 overlay described on {@link StyleResolver.resolveParagraphStyleInTable}
+ * and is scoped to the spacing fields responsible for folio's table-row
+ * height bug (table styles like Word's `TableGrid` zero these out relative
+ * to `docDefaults`). Alignment, indentation, borders, etc. are out of scope
+ * here — applying the whole `pPr` would risk regressing unrelated cell
+ * layout that isn't part of this fix.
+ */
+type TableCellParagraphSpacingOverlay = Pick<document_d_exports.ParagraphFormatting, "spaceBefore" | "spaceAfter" | "lineSpacing" | "lineSpacingRule" | "contextualSpacing">;
 /**
  * StyleResolver provides efficient access to resolved style properties
  */
@@ -33,6 +49,32 @@ declare class StyleResolver {
    * @returns Resolved paragraph and run formatting
    */
   resolveParagraphStyle(styleId: string | undefined | null): ResolvedParagraphStyle;
+  /**
+   * Resolve paragraph style properties for a paragraph inside a table cell,
+   * layering the enclosing table style's paragraph-spacing fields into the
+   * cascade between docDefaults and the paragraph's own style chain.
+   *
+   * Per ECMA-376 §17.7.2, a cell paragraph's properties resolve in this
+   * order (later wins):
+   *   1. docDefaults (`w:pPrDefault`)
+   *   2. the enclosing table style's `w:pPr` (`tableParagraphOverlay`, here)
+   *   3. the paragraph's own style chain (`w:pStyle` + `basedOn` ancestors)
+   *   4. direct formatting on the paragraph (`w:pPr`)
+   *
+   * Layer 4 is applied by the caller (`paragraphFormattingToAttrs`), which
+   * already prefers the paragraph's direct formatting over this method's
+   * result. Layer 3 is applied below, after the overlay, so an explicit
+   * paragraph style still wins over the table for any field it sets.
+   *
+   * @param styleId - The paragraph's style ID (e.g., 'Heading1', 'Normal')
+   * @param tableParagraphOverlay - Paragraph-spacing fields from the
+   *   enclosing table style (base `pPr` merged with the applicable
+   *   conditional region), or `undefined` when the paragraph isn't in a
+   *   table cell, the table has no style, or the style sets no spacing.
+   * @returns Resolved paragraph and run formatting
+   */
+  resolveParagraphStyleInTable(styleId: string | undefined | null, tableParagraphOverlay: TableCellParagraphSpacingOverlay | undefined): ResolvedParagraphStyle;
+  private resolveParagraphStyleCascade;
   /**
    * Resolve the style applied to the paragraph that follows one styled with
    * `styleId` when the user presses Enter (OOXML `w:next`, §17.7.4.10).
@@ -91,4 +133,4 @@ declare class StyleResolver {
  */
 declare function createStyleResolver(styleDefinitions: document_d_exports.StyleDefinitions | undefined): StyleResolver;
 //#endregion
-export { ResolvedParagraphStyle, StyleResolver, createStyleResolver };
+export { ResolvedParagraphStyle, StyleResolver, TableCellParagraphSpacingOverlay, createStyleResolver };

package/dist/prosemirror/styles/styleResolver.js

@@ -70,9 +70,43 @@ var StyleResolver = class {
 	* @returns Resolved paragraph and run formatting
 	*/
 	resolveParagraphStyle(styleId) {
+		return this.resolveParagraphStyleCascade(styleId, void 0);
+	}
+	/**
+	* Resolve paragraph style properties for a paragraph inside a table cell,
+	* layering the enclosing table style's paragraph-spacing fields into the
+	* cascade between docDefaults and the paragraph's own style chain.
+	*
+	* Per ECMA-376 §17.7.2, a cell paragraph's properties resolve in this
+	* order (later wins):
+	*   1. docDefaults (`w:pPrDefault`)
+	*   2. the enclosing table style's `w:pPr` (`tableParagraphOverlay`, here)
+	*   3. the paragraph's own style chain (`w:pStyle` + `basedOn` ancestors)
+	*   4. direct formatting on the paragraph (`w:pPr`)
+	*
+	* Layer 4 is applied by the caller (`paragraphFormattingToAttrs`), which
+	* already prefers the paragraph's direct formatting over this method's
+	* result. Layer 3 is applied below, after the overlay, so an explicit
+	* paragraph style still wins over the table for any field it sets.
+	*
+	* @param styleId - The paragraph's style ID (e.g., 'Heading1', 'Normal')
+	* @param tableParagraphOverlay - Paragraph-spacing fields from the
+	*   enclosing table style (base `pPr` merged with the applicable
+	*   conditional region), or `undefined` when the paragraph isn't in a
+	*   table cell, the table has no style, or the style sets no spacing.
+	* @returns Resolved paragraph and run formatting
+	*/
+	resolveParagraphStyleInTable(styleId, tableParagraphOverlay) {
+		return this.resolveParagraphStyleCascade(styleId, tableParagraphOverlay);
+	}
+	resolveParagraphStyleCascade(styleId, tableParagraphOverlay) {
 		const result = {};
 		if (this.docDefaults?.pPr) result.paragraphFormatting = { ...this.docDefaults.pPr };
 		if (this.docDefaults?.rPr) result.runFormatting = { ...this.docDefaults.rPr };
+		if (tableParagraphOverlay) {
+			const merged = mergeParagraphFormatting(result.paragraphFormatting, tableParagraphOverlay);
+			if (merged !== void 0) result.paragraphFormatting = merged;
+		}
 		if (!styleId) {
 			if (this.defaultParagraphStyle) this.mergeStyleIntoResult(result, this.defaultParagraphStyle);
 			return result;

package/dist/prosemirror/tableResize.d.ts

@@ -0,0 +1,49 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/tableResize.d.ts
+/** 1px ≈ 15 twips at 96dpi (20 twips/pt × 72pt/in ÷ 96px/in). */
+declare const TWIPS_PER_PIXEL = 15;
+/** Minimum column width (~0.2"). */
+declare const MIN_CELL_WIDTH_TWIPS = 300;
+/** Minimum row height (~0.14"). */
+declare const MIN_ROW_HEIGHT_TWIPS = 200;
+/** Read the [left, right] column widths at `colIndex` in the table starting at `pmStart`. */
+declare function readColumnWidths(view: EditorView, pmStart: number, colIndex: number): {
+  left: number;
+  right: number;
+} | null;
+/**
+ * Read the row height (in twips) for `rowIndex` in the table starting at
+ * `pmStart`. Returns null if the row has no explicit height — the caller
+ * can fall back to measuring the rendered DOM cell.
+ */
+declare function readRowHeight(view: EditorView, pmStart: number, rowIndex: number): number | null;
+/** Read the last-column width (the one being resized from the table's right edge). */
+declare function readColumnWidthAt(view: EditorView, pmStart: number, colIndex: number): number | null;
+/**
+ * Bake a column-resize into the PM doc: update the table's `columnWidths`
+ * attr and every cell at `colIdx` / `colIdx + 1` in every row.
+ */
+declare function commitColumnResize(view: EditorView, opts: {
+  pmStart: number;
+  colIdx: number;
+  newLeft: number;
+  newRight: number;
+}): void;
+/** Bake a row-resize into the PM doc: update the target row's `height` + `heightRule`. */
+declare function commitRowResize(view: EditorView, opts: {
+  pmStart: number;
+  rowIdx: number;
+  newHeight: number;
+}): void;
+/**
+ * Bake a right-edge resize into the PM doc: grow only the last column.
+ * Updates `columnWidths[colIdx]` and the cell at `colIdx` in every row.
+ */
+declare function commitRightEdgeResize(view: EditorView, opts: {
+  pmStart: number;
+  colIdx: number;
+  newWidth: number;
+}): void;
+//#endregion
+export { MIN_CELL_WIDTH_TWIPS, MIN_ROW_HEIGHT_TWIPS, TWIPS_PER_PIXEL, commitColumnResize, commitRightEdgeResize, commitRowResize, readColumnWidthAt, readColumnWidths, readRowHeight };