@stll/folio-core 0.0.1-placeholder.0 → 0.1.0

package/dist/prosemirror/commands/contentControls.js

@@ -0,0 +1,294 @@
+import { formatDate } from "../../docx/fieldParser.js";
+import { expectBlockSdtAttrs } from "../attrs/index.js";
+import { ContentControlBoundError, ContentControlLockedError, ContentControlTypeError } from "../../content-controls/errors.js";
+import { SUGGESTION_BYPASS_META } from "../plugins/suggestionMode.js";
+//#region src/prosemirror/commands/contentControls.ts
+function nodeMatchesFilter(node, pos, filter) {
+	if (node.type.name !== "blockSdt") return false;
+	if (filter.pmPos !== void 0 && pos !== filter.pmPos) return false;
+	const attrs = node.attrs;
+	if (filter.tag !== void 0 && attrs["tag"] !== filter.tag) return false;
+	if (filter.alias !== void 0 && attrs["alias"] !== filter.alias) return false;
+	if (filter.id !== void 0 && attrs["id"] !== filter.id) return false;
+	if (filter.sdtType !== void 0 && attrs["sdtType"] !== filter.sdtType) return false;
+	return true;
+}
+/** All blockSdt nodes in `doc` matching `filter`. Outer→inner traversal. */
+function findBlockSdtMatches(doc, filter = {}) {
+	const matches = [];
+	doc.descendants((node, pos, _parent, index) => {
+		if (node.type.name !== "blockSdt") return true;
+		if (nodeMatchesFilter(node, pos, filter)) matches.push({
+			node,
+			pos,
+			path: [...resolvePath(doc, pos), index]
+		});
+		return true;
+	});
+	return matches;
+}
+/** First match or null — convenience for editor-ref callers. */
+function findBlockSdtMatch(doc, filter) {
+	for (const match of findBlockSdtMatches(doc, filter)) return match;
+	return null;
+}
+function resolvePath(doc, pos) {
+	const $pos = doc.resolve(pos);
+	const path = [];
+	for (let depth = 1; depth <= $pos.depth; depth += 1) path.push($pos.index(depth - 1));
+	return path;
+}
+/**
+* Project a `blockSdt` PM node's attrs onto the full modeled `SdtProperties`
+* shape so the editor-ref `getContentControls` and lock-error messages
+* surface every field downstream tooling expects (lock, placeholder,
+* dateFormat, listItems, checked, etc.). Raw XML payloads are not exposed —
+* those are for serializer replay, not for callers.
+*/
+function blockSdtAttrsToSdtProperties(node) {
+	const attrs = expectBlockSdtAttrs(node);
+	const props = { sdtType: attrs.sdtType };
+	if (attrs.alias !== void 0) props.alias = attrs.alias;
+	if (attrs.tag !== void 0) props.tag = attrs.tag;
+	if (typeof attrs.id === "number") props.id = attrs.id;
+	if (attrs.lock !== void 0) props.lock = attrs.lock;
+	if (attrs.placeholder !== void 0) props.placeholder = attrs.placeholder;
+	if (attrs.showingPlaceholder !== void 0) props.showingPlaceholder = attrs.showingPlaceholder;
+	if (attrs.dateFormat !== void 0) props.dateFormat = attrs.dateFormat;
+	if (attrs.dateValueISO !== void 0) props.dateValueISO = attrs.dateValueISO;
+	if (attrs.listItems) {
+		const parsed = parseListItemsAttr(attrs.listItems);
+		if (parsed) props.listItems = parsed;
+	}
+	if (typeof attrs.dropdownLastValue === "string") props.dropdownLastValue = attrs.dropdownLastValue;
+	if (typeof attrs.checked === "boolean") props.checked = attrs.checked;
+	return props;
+}
+function parseListItemsAttr(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		if (!Array.isArray(parsed)) return null;
+		const items = [];
+		for (const entry of parsed) if (entry !== null && typeof entry === "object" && "displayText" in entry && "value" in entry && typeof entry.displayText === "string" && typeof entry.value === "string") items.push(entry);
+		return items.length > 0 ? items : null;
+	} catch {
+		return null;
+	}
+}
+function attrsToProperties(node) {
+	const attrs = node.attrs;
+	const props = { sdtType: String(attrs["sdtType"] ?? "richText") };
+	if (attrs["alias"]) props.alias = String(attrs["alias"]);
+	if (attrs["tag"]) props.tag = String(attrs["tag"]);
+	if (typeof attrs["id"] === "number") props.id = attrs["id"];
+	return props;
+}
+function throwLockedNode(node, lock) {
+	const props = attrsToProperties(node);
+	throw new ContentControlLockedError({
+		message: `Control "${props.tag ?? props.alias ?? "(unnamed)"}" has w:lock=${lock}.`,
+		lock,
+		...props.tag !== void 0 ? { tag: props.tag } : {},
+		...props.alias !== void 0 ? { alias: props.alias } : {}
+	});
+}
+/**
+* Per OOXML §17.5.2.16: `contentLocked` and `sdtContentLocked` block
+* content edits; `sdtLocked` does NOT (it only forbids container
+* removal). Mirrors the headless `ensureContentNotLocked` helper.
+*/
+function ensureContentNotLocked(node, options) {
+	if (options.force) return;
+	const lock = node.attrs["lock"];
+	if (lock === "contentLocked" || lock === "sdtContentLocked") throwLockedNode(node, lock);
+}
+/**
+* Per OOXML §17.5.2.16: `sdtLocked` and `sdtContentLocked` block container
+* removal; `contentLocked` does NOT (it only forbids content edits).
+*/
+function ensureSdtNotLocked(node, options) {
+	if (options.force) return;
+	const lock = node.attrs["lock"];
+	if (lock === "sdtLocked" || lock === "sdtContentLocked") throwLockedNode(node, lock);
+}
+const DATA_BINDING_RE = /<\w+:dataBinding\b(?<attrs>[^>]*)\/?>/iu;
+/**
+* Refuse content mutations on bound SDTs unless force; on force, return
+* the stripped rawPropertiesXml so the caller can persist it on the new
+* node attrs. Mirrors the headless `ensureContentNotBound` helper.
+*/
+function ensureContentNotBound(node, options) {
+	const raw = node.attrs["rawPropertiesXml"];
+	if (typeof raw !== "string") return { strippedRawPropertiesXml: void 0 };
+	const match = DATA_BINDING_RE.exec(raw);
+	if (!match) return { strippedRawPropertiesXml: void 0 };
+	if (!options.force) {
+		const attrs = match.groups?.["attrs"] ?? "";
+		const xpathMatch = /\bxpath="(?<xpath>[^"]*)"/iu.exec(attrs);
+		const storeMatch = /\bstoreItemID="(?<storeItemID>[^"]*)"/iu.exec(attrs);
+		const props = attrsToProperties(node);
+		throw new ContentControlBoundError({
+			message: `Control "${props.tag ?? props.alias ?? "(unnamed)"}" is bound to ${xpathMatch?.groups?.["xpath"] ?? "(unknown xpath)"}. Word regenerates the body from the bound XML on open; pass { force: true } to strip the binding inline, or remove it explicitly before writing.`,
+			xpath: xpathMatch?.groups?.["xpath"] ?? "",
+			...storeMatch?.groups?.["storeItemID"] !== void 0 ? { storeItemID: storeMatch.groups["storeItemID"] } : {},
+			...props.tag !== void 0 ? { tag: props.tag } : {},
+			...props.alias !== void 0 ? { alias: props.alias } : {}
+		});
+	}
+	return { strippedRawPropertiesXml: raw.replaceAll(/<\w+:dataBinding\b[^>]*\/?>(?:[\s\S]*?<\/\w+:dataBinding>)?/giu, "") };
+}
+function paragraphFromText(schema, text) {
+	if (text.length === 0) return schema.node("paragraph", {}, []);
+	return schema.node("paragraph", {}, [schema.text(text)]);
+}
+function replaceBlockSdtChildren(state, match, children, propertyOverrides = {}) {
+	const next = state.schema.node("blockSdt", {
+		...match.node.attrs,
+		showingPlaceholder: false,
+		...propertyOverrides
+	}, children.length === 0 ? [paragraphFromText(state.schema, "")] : children);
+	return state.tr.replaceWith(match.pos, match.pos + match.node.nodeSize, next).setMeta(SUGGESTION_BYPASS_META, true);
+}
+/**
+* Replace a control's children with plain text (one paragraph) or
+* pre-built PM blocks. Returns null when no match is present.
+*/
+function setContentControlContentTr(state, filter, input, options = {}) {
+	const match = findBlockSdtMatch(state.doc, filter);
+	if (!match) return null;
+	ensureContentNotLocked(match.node, options);
+	const { strippedRawPropertiesXml } = ensureContentNotBound(match.node, options);
+	if (typeof input !== "string") throw new ContentControlTypeError({
+		message: "Block-content fill must go through `setContentControlContentBlocksTr` (avoids a schema/plugin import cycle); pass a string here.",
+		sdtType: match.node.attrs["sdtType"] ?? "richText",
+		reason: "PM-direct path takes string input only"
+	});
+	return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, input)], strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {});
+}
+/**
+* Internal helper for the block-content fill variant. Lives in this module
+* so callers reuse the same lock-check and `replaceWith` shape; the
+* conversion-aware `setContentControlContentBlocksTr` in
+* `./contentControlsBlockFill.ts` wraps it.
+*/
+function replaceBlockSdtChildrenForFill(state, filter, children, options = {}) {
+	const match = findBlockSdtMatch(state.doc, filter);
+	if (!match) return null;
+	ensureContentNotLocked(match.node, options);
+	const { strippedRawPropertiesXml } = ensureContentNotBound(match.node, options);
+	return replaceBlockSdtChildren(state, match, children, strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {});
+}
+function setContentControlValueTr(state, filter, input, options = {}) {
+	const match = findBlockSdtMatch(state.doc, filter);
+	if (!match) return null;
+	ensureContentNotLocked(match.node, options);
+	const { strippedRawPropertiesXml } = ensureContentNotBound(match.node, options);
+	const bindingOverride = strippedRawPropertiesXml !== void 0 ? { rawPropertiesXml: strippedRawPropertiesXml } : {};
+	const sdtType = match.node.attrs["sdtType"];
+	if (input.kind === "dropdown") {
+		if (sdtType !== "dropdown" && sdtType !== "comboBox") throw new ContentControlTypeError({
+			message: `Cannot set dropdown value on a ${sdtType} control.`,
+			sdtType,
+			reason: "kind=dropdown requires sdtType=dropdown|comboBox"
+		});
+		const listItemsAttr = match.node.attrs["listItems"];
+		let display = input.value;
+		if (typeof listItemsAttr === "string" && listItemsAttr) {
+			let items = null;
+			try {
+				const parsed = JSON.parse(listItemsAttr);
+				if (Array.isArray(parsed)) items = parsed;
+			} catch {
+				items = null;
+			}
+			const item = items?.find((i) => i.value === input.value);
+			if (!item && !options.force && items !== null) throw new ContentControlTypeError({
+				message: `Value "${input.value}" not in the control's list items.`,
+				sdtType,
+				reason: "value not in listItems"
+			});
+			if (item) display = item.displayText;
+		}
+		return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, display)], {
+			dropdownLastValue: input.value,
+			...bindingOverride
+		});
+	}
+	if (input.kind === "checkbox") {
+		if (sdtType !== "checkbox") throw new ContentControlTypeError({
+			message: `Cannot toggle checkbox on a ${sdtType} control.`,
+			sdtType,
+			reason: "kind=checkbox requires sdtType=checkbox"
+		});
+		const glyph = input.checked ? "☒" : "☐";
+		return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, glyph)], {
+			checked: input.checked,
+			...bindingOverride
+		});
+	}
+	if (sdtType !== "date") throw new ContentControlTypeError({
+		message: `Cannot set date on a ${sdtType} control.`,
+		sdtType,
+		reason: "kind=date requires sdtType=date"
+	});
+	const dateFormatAttr = match.node.attrs["dateFormat"];
+	const display = formatDateForBody(input.date, typeof dateFormatAttr === "string" ? dateFormatAttr : void 0);
+	return replaceBlockSdtChildren(state, match, [paragraphFromText(state.schema, display)], {
+		dateValueISO: input.date,
+		...bindingOverride
+	});
+}
+function formatDateForBody(isoDate, dateFormat) {
+	if (!dateFormat) return isoDate;
+	const parsed = parseSdtDate(isoDate);
+	if (!parsed) return isoDate;
+	return formatDate(parsed, dateFormat);
+}
+/**
+* See `formatDateForSdtBody` in the headless helpers for the rationale.
+* Supports date-only (`YYYY-MM-DD`) and date+time
+* (`YYYY-MM-DDTHH:mm[:ss]`) inputs, building a local-time Date so
+* `formatDate`'s accessors return the picked wall-clock components
+* regardless of TZ.
+*/
+const SDT_DATE_RE = /^(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})(?:[Tt](?<hours>\d{2}):(?<minutes>\d{2})(?::(?<seconds>\d{2})(?:\.\d+)?)?)?(?:[Zz]|[+-]\d{2}:?\d{2})?$/u;
+function parseSdtDate(iso) {
+	const match = SDT_DATE_RE.exec(iso);
+	if (match) {
+		const groups = match.groups;
+		const year = Number(groups["year"]);
+		const month = Number(groups["month"]);
+		const day = Number(groups["day"]);
+		const hours = groups["hours"] ? Number(groups["hours"]) : 0;
+		const minutes = groups["minutes"] ? Number(groups["minutes"]) : 0;
+		const seconds = groups["seconds"] ? Number(groups["seconds"]) : 0;
+		const candidate = new Date(year, month - 1, day, hours, minutes, seconds);
+		if (candidate.getFullYear() !== year || candidate.getMonth() !== month - 1 || candidate.getDate() !== day || candidate.getHours() !== hours || candidate.getMinutes() !== minutes || candidate.getSeconds() !== seconds) return null;
+		return candidate;
+	}
+	const parsed = new Date(iso);
+	return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function isRepeatingSection(node) {
+	const raw = node.attrs["rawPropertiesXml"];
+	return typeof raw === "string" && /<\w+:repeatingSection\b/u.test(raw);
+}
+function removeContentControlTr(state, filter, options = {}) {
+	const match = findBlockSdtMatch(state.doc, filter);
+	if (!match) return null;
+	ensureSdtNotLocked(match.node, options);
+	if (options.keepContent) {
+		if (isRepeatingSection(match.node) && !options.force) throw new ContentControlTypeError({
+			message: "Refusing to unwrap a w15:repeatingSection — would orphan its w15 row items.",
+			sdtType: match.node.attrs["sdtType"] ?? "richText",
+			reason: "repeatingSection unwrap orphans items"
+		});
+		const children = [];
+		for (let i = 0; i < match.node.childCount; i += 1) children.push(match.node.child(i));
+		return state.tr.replaceWith(match.pos, match.pos + match.node.nodeSize, children).setMeta(SUGGESTION_BYPASS_META, true);
+	}
+	if (state.doc.resolve(match.pos).parent.childCount === 1) return state.tr.replaceWith(match.pos, match.pos + match.node.nodeSize, paragraphFromText(state.schema, "")).setMeta(SUGGESTION_BYPASS_META, true);
+	return state.tr.delete(match.pos, match.pos + match.node.nodeSize).setMeta(SUGGESTION_BYPASS_META, true);
+}
+//#endregion
+export { blockSdtAttrsToSdtProperties, findBlockSdtMatch, findBlockSdtMatches, removeContentControlTr, replaceBlockSdtChildrenForFill, setContentControlContentTr, setContentControlValueTr };

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

@@ -0,0 +1,15 @@
+import { document_d_exports } from "../../types/document.js";
+import { ContentControlFilter } from "../../content-controls/findContentControls.js";
+import { EditorState, Transaction } from "prosemirror-state";
+
+//#region src/prosemirror/commands/contentControlsBlockFill.d.ts
+/**
+ * Replace the children of the content control matching `filter` with the
+ * PM-converted form of `blocks`. Locked controls throw
+ * `ContentControlLockedError` unless `{ force: true }` is passed.
+ */
+declare function setContentControlContentBlocksTr(state: EditorState, filter: ContentControlFilter, blocks: document_d_exports.BlockContent[], options?: {
+  force?: boolean;
+}): Transaction | null;
+//#endregion
+export { setContentControlContentBlocksTr };

package/dist/prosemirror/commands/contentControlsBlockFill.js

@@ -0,0 +1,19 @@
+import { replaceBlockSdtChildrenForFill } from "./contentControls.js";
+import { headerFooterToProseDoc } from "../conversion/toProseDoc.js";
+//#region src/prosemirror/commands/contentControlsBlockFill.ts
+function blockContentToPMChildren(blocks) {
+	const pmDoc = headerFooterToProseDoc(blocks);
+	const out = [];
+	for (let i = 0; i < pmDoc.childCount; i += 1) out.push(pmDoc.child(i));
+	return out;
+}
+/**
+* Replace the children of the content control matching `filter` with the
+* PM-converted form of `blocks`. Locked controls throw
+* `ContentControlLockedError` unless `{ force: true }` is passed.
+*/
+function setContentControlContentBlocksTr(state, filter, blocks, options = {}) {
+	return replaceBlockSdtChildrenForFill(state, filter, blockContentToPMChildren(blocks), options);
+}
+//#endregion
+export { setContentControlContentBlocksTr };

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

@@ -0,0 +1,31 @@
+import { Command, EditorState } from "prosemirror-state";
+import { Mark } from "prosemirror-model";
+
+//#region src/prosemirror/commands/formatPainter.d.ts
+/**
+ * Character-formatting marks the painter copies. Structural marks — comments,
+ * hyperlinks, tracked changes (insertion/deletion), footnote references — are
+ * deliberately excluded so painting never moves an anchor, link, or revision.
+ * `rtl` (run direction) and `hidden` are excluded too: painting them could flip
+ * text direction or hide content, which is surprising for a formatting brush.
+ */
+declare const PAINTABLE_MARK_NAMES: ReadonlySet<string>;
+/**
+ * Capture the paintable character marks active over the current selection.
+ * Returns the marks (with their attrs) to hand to `applyFormatMarks`. An empty
+ * selection reads the stored/insertion marks; a range reads its leading run.
+ * Returns an empty array when the source carries no direct character formatting.
+ */
+declare function captureFormatMarks(state: EditorState): Mark[];
+/**
+ * Apply captured marks onto the current selection's range: clear every paintable
+ * mark type first (replace, not merge — so painting Georgia-12-bold onto
+ * Arial-10 leaves only Georgia-12-bold), then lay down the captured marks.
+ *
+ * Best-effort: a collapsed selection or an empty capture is a no-op (returns
+ * false so a keymap binding stays unclaimed and the keystroke passes through).
+ * Never throws.
+ */
+declare function applyFormatMarks(marks: readonly Mark[]): Command;
+//#endregion
+export { PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks };

package/dist/prosemirror/commands/formatPainter.js

@@ -0,0 +1,130 @@
+//#region src/prosemirror/commands/formatPainter.ts
+/**
+* Character-formatting marks the painter copies. Structural marks — comments,
+* hyperlinks, tracked changes (insertion/deletion), footnote references — are
+* deliberately excluded so painting never moves an anchor, link, or revision.
+* `rtl` (run direction) and `hidden` are excluded too: painting them could flip
+* text direction or hide content, which is surprising for a formatting brush.
+*/
+const PAINTABLE_MARK_NAMES = /* @__PURE__ */ new Set([
+	"bold",
+	"italic",
+	"underline",
+	"strike",
+	"textColor",
+	"highlight",
+	"fontSize",
+	"fontFamily",
+	"superscript",
+	"subscript",
+	"allCaps",
+	"smallCaps",
+	"characterSpacing",
+	"runShading",
+	"runFormattingOverride",
+	"emboss",
+	"imprint",
+	"textShadow",
+	"emphasisMark",
+	"textOutline",
+	"textEffect",
+	"characterStyle"
+]);
+/**
+* Formatting that must never be painted — whether it arrives as its own mark or
+* is smuggled in as a `runFormattingOverride` attr (e.g. `rtl: false`,
+* `hidden: false`). Single source of truth: it gates both the mark-type
+* exclusion and the override-attr filtering below, so an exclusion can't leak
+* back in through the override mark as new override attrs are added.
+*/
+const NON_PAINTABLE_FORMATS = /* @__PURE__ */ new Set(["rtl", "hidden"]);
+/** A mark is paintable when it is in the allowlist and not a hard exclusion. */
+function isPaintableMark(mark) {
+	const name = mark.type.name;
+	return PAINTABLE_MARK_NAMES.has(name) && !NON_PAINTABLE_FORMATS.has(name);
+}
+/**
+* Strip excluded overrides (`rtl`/`hidden`) from a `runFormattingOverride` mark
+* so they cannot be re-smuggled past the mark-type exclusion. Returns the mark
+* unchanged when it carries no excluded attr, a trimmed mark when it carries a
+* mix, or null when only excluded overrides remain (nothing paintable left).
+*/
+function sanitizeOverrideMark(mark) {
+	const kept = {};
+	let removedExcluded = false;
+	for (const [key, value] of Object.entries(mark.attrs)) {
+		if (value === null || value === void 0) continue;
+		if (NON_PAINTABLE_FORMATS.has(key)) {
+			removedExcluded = true;
+			continue;
+		}
+		kept[key] = value;
+	}
+	if (!removedExcluded) return mark;
+	if (Object.keys(kept).length === 0) return null;
+	return mark.type.create(kept);
+}
+/**
+* Marks of the first text node inside [from, to). A word processor's format
+* brush copies from the start of the source selection, so a mixed selection
+* yields the formatting of its leading run.
+*/
+function firstTextMarks(state, from, to) {
+	let marks = null;
+	state.doc.nodesBetween(from, to, (node) => {
+		if (marks) return false;
+		if (node.isText) {
+			marks = node.marks;
+			return false;
+		}
+		return true;
+	});
+	return marks ?? [];
+}
+/**
+* Capture the paintable character marks active over the current selection.
+* Returns the marks (with their attrs) to hand to `applyFormatMarks`. An empty
+* selection reads the stored/insertion marks; a range reads its leading run.
+* Returns an empty array when the source carries no direct character formatting.
+*/
+function captureFormatMarks(state) {
+	const { empty, $from, from, to } = state.selection;
+	const source = empty ? state.storedMarks ?? $from.marks() : firstTextMarks(state, from, to);
+	const captured = [];
+	for (const mark of source) {
+		if (!isPaintableMark(mark)) continue;
+		if (mark.type.name === "runFormattingOverride") {
+			const sanitized = sanitizeOverrideMark(mark);
+			if (sanitized) captured.push(sanitized);
+			continue;
+		}
+		captured.push(mark);
+	}
+	return captured;
+}
+/**
+* Apply captured marks onto the current selection's range: clear every paintable
+* mark type first (replace, not merge — so painting Georgia-12-bold onto
+* Arial-10 leaves only Georgia-12-bold), then lay down the captured marks.
+*
+* Best-effort: a collapsed selection or an empty capture is a no-op (returns
+* false so a keymap binding stays unclaimed and the keystroke passes through).
+* Never throws.
+*/
+function applyFormatMarks(marks) {
+	return (state, dispatch) => {
+		const { from, to, empty } = state.selection;
+		if (empty || marks.length === 0) return false;
+		if (!dispatch) return true;
+		let tr = state.tr;
+		for (const name of PAINTABLE_MARK_NAMES) {
+			const markType = state.schema.marks[name];
+			if (markType) tr = tr.removeMark(from, to, markType);
+		}
+		for (const mark of marks) tr = tr.addMark(from, to, mark);
+		dispatch(tr.scrollIntoView());
+		return true;
+	};
+}
+//#endregion
+export { PAINTABLE_MARK_NAMES, applyFormatMarks, captureFormatMarks };

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

@@ -0,0 +1,32 @@
+import { document_d_exports } from "../../types/document.js";
+import { TextColorAttrs } from "../schema/marks.js";
+import { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive } from "../extensions/marks/markUtils.js";
+import { getHyperlinkAttrs, getSelectedText, isHyperlinkActive } from "../extensions/marks/HyperlinkExtension.js";
+import { Command } from "prosemirror-state";
+import { Mark } from "prosemirror-model";
+
+//#region src/prosemirror/commands/formatting.d.ts
+/**
+ * textFormattingToMarks — wraps markUtils version to use singleton schema
+ */
+declare function textFormattingToMarks(formatting: document_d_exports.TextFormatting): Mark[];
+declare const toggleBold: Command;
+declare const toggleItalic: Command;
+declare const toggleUnderline: Command;
+declare const toggleStrike: Command;
+declare const toggleSuperscript: Command;
+declare const toggleSubscript: Command;
+declare function setTextColor(attrs: TextColorAttrs): Command;
+declare const clearTextColor: Command;
+declare function setHighlight(color: string): Command;
+declare const clearHighlight: Command;
+declare function setFontSize(size: number): Command;
+declare const clearFontSize: Command;
+declare function setFontFamily(fontName: string): Command;
+declare const clearFontFamily: Command;
+declare function setUnderlineStyle(style: string, color?: TextColorAttrs): Command;
+declare function setHyperlink(href: string, tooltip?: string): Command;
+declare const removeHyperlink: Command;
+declare function insertHyperlink(text: string, href: string, tooltip?: string): Command;
+//#endregion
+export { clearFontFamily, clearFontSize, clearFormatting, clearHighlight, clearTextColor, createRemoveMarkCommand, createSetMarkCommand, getHyperlinkAttrs, getMarkAttr, getSelectedText, insertHyperlink, isHyperlinkActive, isMarkActive, removeHyperlink, setFontFamily, setFontSize, setHighlight, setHyperlink, setTextColor, setUnderlineStyle, textFormattingToMarks, toggleBold, toggleItalic, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline };

package/dist/prosemirror/commands/formatting.js

@@ -0,0 +1,45 @@
+import { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, textFormattingToMarks as textFormattingToMarks$1 } from "../extensions/marks/markUtils.js";
+import { getHyperlinkAttrs, getSelectedText, isHyperlinkActive } from "../extensions/marks/HyperlinkExtension.js";
+import { schema, singletonManager } from "../schema/index.js";
+//#region src/prosemirror/commands/formatting.ts
+/**
+* textFormattingToMarks — wraps markUtils version to use singleton schema
+*/
+function textFormattingToMarks(formatting) {
+	return textFormattingToMarks$1(formatting, schema);
+}
+const cmds = singletonManager.getCommands();
+const toggleBold = cmds["toggleBold"]();
+const toggleItalic = cmds["toggleItalic"]();
+const toggleUnderline = cmds["toggleUnderline"]();
+const toggleStrike = cmds["toggleStrike"]();
+const toggleSuperscript = cmds["toggleSuperscript"]();
+const toggleSubscript = cmds["toggleSubscript"]();
+function setTextColor(attrs) {
+	return cmds["setTextColor"](attrs);
+}
+const clearTextColor = cmds["clearTextColor"]();
+function setHighlight(color) {
+	return cmds["setHighlight"](color);
+}
+const clearHighlight = cmds["clearHighlight"]();
+function setFontSize(size) {
+	return cmds["setFontSize"](size);
+}
+const clearFontSize = cmds["clearFontSize"]();
+function setFontFamily(fontName) {
+	return cmds["setFontFamily"](fontName);
+}
+const clearFontFamily = cmds["clearFontFamily"]();
+function setUnderlineStyle(style, color) {
+	return cmds["setUnderlineStyle"](style, color);
+}
+function setHyperlink(href, tooltip) {
+	return cmds["setHyperlink"](href, tooltip);
+}
+const removeHyperlink = cmds["removeHyperlink"]();
+function insertHyperlink(text, href, tooltip) {
+	return cmds["insertHyperlink"](text, href, tooltip);
+}
+//#endregion
+export { clearFontFamily, clearFontSize, clearFormatting, clearHighlight, clearTextColor, createRemoveMarkCommand, createSetMarkCommand, getHyperlinkAttrs, getMarkAttr, getSelectedText, insertHyperlink, isHyperlinkActive, isMarkActive, removeHyperlink, setFontFamily, setFontSize, setHighlight, setHyperlink, setTextColor, setUnderlineStyle, textFormattingToMarks, toggleBold, toggleItalic, toggleStrike, toggleSubscript, toggleSuperscript, toggleUnderline };

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

@@ -0,0 +1,31 @@
+import { EditorView } from "prosemirror-view";
+
+//#region src/prosemirror/commands/hyperlink.d.ts
+type EditHyperlinkInput = {
+  displayText: string;
+  href: string;
+};
+/**
+ * Replace the text and href of the hyperlink at the cursor.
+ *
+ * Returns whether the adapter should close the popup and refocus the editor:
+ * true after a successful edit and when the schema has no hyperlink behaviour
+ * to act on at the cursor; false only when a hyperlink mark is present but no
+ * contiguous range contains the cursor (the original's silent bail).
+ */
+declare const editHyperlinkAtCursor: (view: EditorView, {
+  displayText,
+  href
+}: EditHyperlinkInput) => boolean;
+type RemoveHyperlinkInput = {
+  /** href from the popup, used as a fallback when the cursor reports no mark. */popupHref: string | undefined;
+};
+/**
+ * Remove the hyperlink mark from the contiguous run at the cursor. Returns
+ * whether a link was actually removed (so the adapter can toast + refocus).
+ */
+declare const removeHyperlinkAtCursor: (view: EditorView, {
+  popupHref
+}: RemoveHyperlinkInput) => boolean;
+//#endregion
+export { EditHyperlinkInput, RemoveHyperlinkInput, editHyperlinkAtCursor, removeHyperlinkAtCursor };