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

package/dist/prosemirror/extensions/marks/markUtils.js

@@ -0,0 +1,233 @@
+import { applyRunFormattingOverrideMark, buildRunFormattingOverrideAttrs } from "./RunFormattingOverrideExtension.js";
+//#region src/prosemirror/extensions/marks/markUtils.ts
+function marksToTextFormatting(marks) {
+	const formatting = {};
+	for (const mark of marks) switch (mark.type.name) {
+		case "bold":
+			formatting.bold = true;
+			break;
+		case "italic":
+			formatting.italic = true;
+			break;
+		case "underline":
+			formatting.underline = { style: typeof mark.attrs["style"] === "string" ? mark.attrs["style"] : "single" };
+			break;
+		case "strike":
+			formatting.strike = true;
+			break;
+		case "textColor": {
+			const colorRgb = mark.attrs["rgb"] !== null && mark.attrs["rgb"] !== void 0 ? String(mark.attrs["rgb"]) : void 0;
+			const colorTheme = mark.attrs["themeColor"] !== null && mark.attrs["themeColor"] !== void 0 ? String(mark.attrs["themeColor"]) : void 0;
+			const colorTint = mark.attrs["themeTint"] !== null && mark.attrs["themeTint"] !== void 0 ? String(mark.attrs["themeTint"]) : void 0;
+			const colorShade = mark.attrs["themeShade"] !== null && mark.attrs["themeShade"] !== void 0 ? String(mark.attrs["themeShade"]) : void 0;
+			formatting.color = {
+				...colorRgb !== void 0 ? { rgb: colorRgb } : {},
+				...colorTheme !== void 0 ? { themeColor: colorTheme } : {},
+				...colorTint !== void 0 ? { themeTint: colorTint } : {},
+				...colorShade !== void 0 ? { themeShade: colorShade } : {}
+			};
+			break;
+		}
+		case "highlight":
+			formatting.highlight = String(mark.attrs["color"]);
+			break;
+		case "fontSize":
+			formatting.fontSize = Number(mark.attrs["size"]);
+			break;
+		case "fontFamily": {
+			const ascii = mark.attrs["ascii"] !== null && mark.attrs["ascii"] !== void 0 ? String(mark.attrs["ascii"]) : void 0;
+			const hAnsi = mark.attrs["hAnsi"] !== null && mark.attrs["hAnsi"] !== void 0 ? String(mark.attrs["hAnsi"]) : void 0;
+			formatting.fontFamily = {
+				...ascii !== void 0 ? { ascii } : {},
+				...hAnsi !== void 0 ? { hAnsi } : {}
+			};
+			break;
+		}
+		case "superscript":
+			formatting.vertAlign = "superscript";
+			break;
+		case "subscript":
+			formatting.vertAlign = "subscript";
+			break;
+		case "rtl":
+			formatting.rtl = true;
+			break;
+		case "runFormattingOverride":
+			applyRunFormattingOverrideMark(formatting, mark);
+			break;
+		default: break;
+	}
+	return formatting;
+}
+function saveStoredMarksToParagraph(state, tr, marks) {
+	const { $from } = state.selection;
+	const paragraph = $from.parent;
+	if (paragraph.type.name !== "paragraph") return tr;
+	if (paragraph.textContent.length > 0) return tr;
+	if (marks.length === 0) return tr.setNodeMarkup($from.before(), void 0, {
+		...paragraph.attrs,
+		defaultTextFormatting: null
+	});
+	const defaultTextFormatting = marksToTextFormatting(marks);
+	return tr.setNodeMarkup($from.before(), void 0, {
+		...paragraph.attrs,
+		defaultTextFormatting
+	});
+}
+function dispatchStoredMarks(state, dispatch, marks) {
+	let tr = state.tr;
+	tr = saveStoredMarksToParagraph(state, tr, marks);
+	tr.setStoredMarks(marks);
+	dispatch(tr);
+}
+function setMark(markType, attrs) {
+	return (state, dispatch) => {
+		const { from, to, empty } = state.selection;
+		const mark = markType.create(attrs);
+		if (empty) {
+			if (dispatch) {
+				const current = state.storedMarks ?? state.selection.$from.marks();
+				dispatchStoredMarks(state, dispatch, [...markType.isInSet(current) ? current.filter((m) => m.type !== markType) : current, mark]);
+			}
+			return true;
+		}
+		if (dispatch) dispatch(state.tr.addMark(from, to, mark).scrollIntoView());
+		return true;
+	};
+}
+function removeMark(markType) {
+	return (state, dispatch) => {
+		const { from, to, empty } = state.selection;
+		if (empty) {
+			if (dispatch) dispatchStoredMarks(state, dispatch, (state.storedMarks ?? state.selection.$from.marks()).filter((m) => m.type !== markType));
+			return true;
+		}
+		if (dispatch) dispatch(state.tr.removeMark(from, to, markType).scrollIntoView());
+		return true;
+	};
+}
+/**
+* Check if a mark is active in the current selection
+*/
+function isMarkActive(state, markType, attrs) {
+	const { from, to, empty } = state.selection;
+	if (empty) return (state.storedMarks ?? state.selection.$from.marks()).some((mark) => {
+		if (mark.type !== markType) return false;
+		if (!attrs) return true;
+		return Object.entries(attrs).every(([key, value]) => mark.attrs[key] === value);
+	});
+	let hasMark = false;
+	state.doc.nodesBetween(from, to, (node) => {
+		if (node.isText) {
+			const mark = markType.isInSet(node.marks);
+			if (mark) {
+				if (!attrs) {
+					hasMark = true;
+					return false;
+				}
+				if (Object.entries(attrs).every(([key, value]) => mark.attrs[key] === value)) {
+					hasMark = true;
+					return false;
+				}
+			}
+		}
+		return true;
+	});
+	return hasMark;
+}
+/**
+* Get the current value of a mark attribute
+*/
+function getMarkAttr(state, markType, attr) {
+	const { empty, $from, from, to } = state.selection;
+	if (empty) {
+		const marks = state.storedMarks ?? $from.marks();
+		for (const mark of marks) if (mark.type === markType) return mark.attrs[attr];
+		return null;
+	}
+	let value = null;
+	state.doc.nodesBetween(from, to, (node) => {
+		if (node.isText && value === null) {
+			const mark = markType.isInSet(node.marks);
+			if (mark) {
+				value = mark.attrs[attr];
+				return false;
+			}
+		}
+		return true;
+	});
+	return value;
+}
+/**
+* Convert TextFormatting to marks array (used to restore formatting on empty paragraphs)
+*/
+function textFormattingToMarks(formatting, schema) {
+	const marks = [];
+	const overrideAttrs = buildRunFormattingOverrideAttrs(formatting);
+	if (overrideAttrs && schema.marks["runFormattingOverride"]) marks.push(schema.marks["runFormattingOverride"].create(overrideAttrs));
+	if (formatting.bold && schema.marks["bold"]) marks.push(schema.marks["bold"].create());
+	if (formatting.italic && schema.marks["italic"]) marks.push(schema.marks["italic"].create());
+	if (formatting.underline && schema.marks["underline"]) marks.push(schema.marks["underline"].create({
+		style: formatting.underline.style,
+		color: formatting.underline.color
+	}));
+	if (formatting.strike && schema.marks["strike"]) marks.push(schema.marks["strike"].create());
+	if (formatting.doubleStrike && schema.marks["strike"]) marks.push(schema.marks["strike"].create({ double: true }));
+	if (formatting.color && schema.marks["textColor"]) marks.push(schema.marks["textColor"].create({
+		rgb: formatting.color.rgb,
+		themeColor: formatting.color.themeColor,
+		themeTint: formatting.color.themeTint,
+		themeShade: formatting.color.themeShade
+	}));
+	if (formatting.highlight && schema.marks["highlight"]) marks.push(schema.marks["highlight"].create({ color: formatting.highlight }));
+	if (formatting.fontSize !== void 0 && schema.marks["fontSize"]) marks.push(schema.marks["fontSize"].create({ size: formatting.fontSize }));
+	if (formatting.fontFamily && schema.marks["fontFamily"]) marks.push(schema.marks["fontFamily"].create({
+		ascii: formatting.fontFamily.ascii,
+		hAnsi: formatting.fontFamily.hAnsi,
+		asciiTheme: formatting.fontFamily.asciiTheme
+	}));
+	if (formatting.vertAlign === "superscript" && schema.marks["superscript"]) marks.push(schema.marks["superscript"].create());
+	if (formatting.vertAlign === "subscript" && schema.marks["subscript"]) marks.push(schema.marks["subscript"].create());
+	if (formatting.rtl && schema.marks["rtl"]) marks.push(schema.marks["rtl"].create());
+	return marks;
+}
+/**
+* Clear all text formatting (remove all marks)
+*/
+const clearFormatting = (state, dispatch) => {
+	const { from, to, empty } = state.selection;
+	if (empty) {
+		if (dispatch) {
+			const tr = saveStoredMarksToParagraph(state, state.tr, []);
+			tr.setStoredMarks([]);
+			dispatch(tr);
+		}
+		return true;
+	}
+	if (dispatch) {
+		let tr = state.tr;
+		state.doc.nodesBetween(from, to, (node, pos) => {
+			if (node.isText && node.marks.length > 0) {
+				const start = Math.max(from, pos);
+				const end = Math.min(to, pos + node.nodeSize);
+				for (const mark of node.marks) tr = tr.removeMark(start, end, mark.type);
+			}
+		});
+		dispatch(tr.scrollIntoView());
+	}
+	return true;
+};
+/**
+* Create a command that sets a mark on the selection
+*/
+function createSetMarkCommand(markType, attrs) {
+	return setMark(markType, attrs ?? {});
+}
+/**
+* Create a command that removes a mark from the selection
+*/
+function createRemoveMarkCommand(markType) {
+	return removeMark(markType);
+}
+//#endregion
+export { clearFormatting, createRemoveMarkCommand, createSetMarkCommand, getMarkAttr, isMarkActive, removeMark, setMark, textFormattingToMarks };

package/dist/prosemirror/extensions/nodes/BlockSdtExtension.d.ts

@@ -0,0 +1,22 @@
+import { NodeExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/nodes/BlockSdtExtension.d.ts
+/**
+ * BlockSdt Extension — block-level content control node.
+ *
+ * Mirrors OOXML's block `w:sdt` wrapping paragraphs/tables. `isolating: true`
+ * keeps user edits scoped to the control (a backspace at the start of an
+ * inner paragraph cannot merge through the boundary into a sibling), and
+ * `defining: true` preserves the wrapper across split/lift.
+ *
+ * Attributes:
+ * - `sdtType` / `alias` / `tag` / `lock` / `placeholder` /
+ *   `showingPlaceholder` / `dateFormat` / `listItems` / `checked` — modeled
+ *   projection of `w:sdtPr`; drives addressing and widget UX.
+ * - `rawPropertiesXml` / `rawEndPropertiesXml` — verbatim original strings
+ *   so unmodeled OOXML features (`w:dataBinding`, `w15:repeatingSection`,
+ *   etc.) round-trip without being enumerated here.
+ */
+declare const BlockSdtExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { BlockSdtExtension };

package/dist/prosemirror/extensions/nodes/BlockSdtExtension.js

@@ -0,0 +1,122 @@
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/nodes/BlockSdtExtension.ts
+/**
+* BlockSdt Extension — block-level content control node.
+*
+* Mirrors OOXML's block `w:sdt` wrapping paragraphs/tables. `isolating: true`
+* keeps user edits scoped to the control (a backspace at the start of an
+* inner paragraph cannot merge through the boundary into a sibling), and
+* `defining: true` preserves the wrapper across split/lift.
+*
+* Attributes:
+* - `sdtType` / `alias` / `tag` / `lock` / `placeholder` /
+*   `showingPlaceholder` / `dateFormat` / `listItems` / `checked` — modeled
+*   projection of `w:sdtPr`; drives addressing and widget UX.
+* - `rawPropertiesXml` / `rawEndPropertiesXml` — verbatim original strings
+*   so unmodeled OOXML features (`w:dataBinding`, `w15:repeatingSection`,
+*   etc.) round-trip without being enumerated here.
+*/
+const BlockSdtExtension = createNodeExtension({
+	name: "blockSdt",
+	schemaNodeName: "blockSdt",
+	nodeSpec: {
+		group: "block",
+		content: "block+",
+		isolating: true,
+		defining: true,
+		attrs: {
+			sdtType: { default: "richText" },
+			alias: { default: null },
+			tag: { default: null },
+			id: { default: null },
+			lock: { default: null },
+			placeholder: { default: null },
+			showingPlaceholder: { default: false },
+			dateFormat: { default: null },
+			/** ISO 8601 bound date value (`w:date@w:fullDate`). */
+			dateValueISO: { default: null },
+			listItems: { default: null },
+			/**
+			* Selected dropdown / comboBox value (`w:dropDownList@w:lastValue`).
+			* Persisted independently of body display text so duplicate-label
+			* items round-trip to the right OOXML value on save.
+			*/
+			dropdownLastValue: { default: null },
+			checked: { default: null },
+			/**
+			* True when the source `<w:sdtContent/>` was empty. PM `block+`
+			* requires at least one child so `toProseDoc` inserts a synthetic
+			* filler paragraph; on save, `fromProseDoc` reads this flag to
+			* drop the filler when the body still matches the synthetic shape.
+			* Without the explicit marker we'd silently drop authored
+			* `<w:sdtContent><w:p/></w:sdtContent>` empty-paragraph content too.
+			*/
+			_originallyEmpty: { default: false },
+			rawPropertiesXml: { default: null },
+			rawEndPropertiesXml: { default: null },
+			/**
+			* Verbatim XML for direct sdt siblings of sdtContent (range markers
+			* per MS-OE376 §2.5.2.30). Two slots so position is preserved.
+			*/
+			rawSdtChildrenBeforeContent: { default: null },
+			rawSdtChildrenAfterContent: { default: null }
+		},
+		parseDOM: [{
+			tag: "div.docx-block-sdt",
+			getAttrs(dom) {
+				if (!(dom instanceof HTMLElement)) return false;
+				const checkedRaw = dom.dataset["checked"];
+				let checked = null;
+				if (checkedRaw === "true") checked = true;
+				else if (checkedRaw === "false") checked = false;
+				const idRaw = dom.dataset["sdtId"];
+				const id = idRaw ? Number.parseInt(idRaw, 10) : null;
+				return {
+					sdtType: dom.dataset["sdtType"] ?? "richText",
+					alias: dom.dataset["alias"] ?? null,
+					tag: dom.dataset["tag"] ?? null,
+					id: id !== null && !Number.isNaN(id) ? id : null,
+					lock: dom.dataset["lock"] ?? null,
+					placeholder: dom.dataset["placeholder"] ?? null,
+					showingPlaceholder: dom.dataset["showingPlaceholder"] === "true",
+					dateFormat: dom.dataset["dateFormat"] ?? null,
+					dateValueISO: dom.dataset["dateValueIso"] ?? null,
+					listItems: dom.dataset["listItems"] ?? null,
+					dropdownLastValue: dom.dataset["dropdownLastValue"] ?? null,
+					checked,
+					_originallyEmpty: dom.dataset["originallyEmpty"] === "true",
+					rawPropertiesXml: null,
+					rawEndPropertiesXml: null,
+					rawSdtChildrenBeforeContent: null,
+					rawSdtChildrenAfterContent: null
+				};
+			}
+		}],
+		toDOM(node) {
+			const attrs = node.attrs;
+			const data = {
+				class: `docx-block-sdt docx-block-sdt-${String(attrs["sdtType"])}`,
+				"data-sdt-type": String(attrs["sdtType"])
+			};
+			if (attrs["alias"]) data["data-alias"] = String(attrs["alias"]);
+			if (attrs["tag"]) data["data-tag"] = String(attrs["tag"]);
+			if (attrs["id"] !== null && attrs["id"] !== void 0) data["data-sdt-id"] = String(attrs["id"]);
+			if (attrs["lock"]) data["data-lock"] = String(attrs["lock"]);
+			if (attrs["placeholder"]) data["data-placeholder"] = String(attrs["placeholder"]);
+			if (attrs["showingPlaceholder"]) data["data-showing-placeholder"] = "true";
+			if (attrs["dateFormat"]) data["data-date-format"] = String(attrs["dateFormat"]);
+			if (attrs["dateValueISO"]) data["data-date-value-iso"] = String(attrs["dateValueISO"]);
+			if (attrs["listItems"]) data["data-list-items"] = String(attrs["listItems"]);
+			if (attrs["dropdownLastValue"]) data["data-dropdown-last-value"] = String(attrs["dropdownLastValue"]);
+			if (attrs["checked"] !== null && attrs["checked"] !== void 0) data["data-checked"] = String(attrs["checked"]);
+			if (attrs["_originallyEmpty"]) data["data-originally-empty"] = "true";
+			return [
+				"div",
+				data,
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { BlockSdtExtension };

package/dist/prosemirror/extensions/nodes/FieldExtension.d.ts

@@ -0,0 +1,12 @@
+import { NodeExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/nodes/FieldExtension.d.ts
+/**
+ * Field Extension — inline field node (PAGE, NUMPAGES, DATE, MERGEFIELD, etc.)
+ *
+ * Represents OOXML simple and complex fields as an atomic inline node.
+ * At render time, field values are substituted (e.g., PAGE → actual page number).
+ */
+declare const FieldExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { FieldExtension };

package/dist/prosemirror/extensions/nodes/FieldExtension.js

@@ -0,0 +1,87 @@
+import { parseFieldInstruction } from "../../../docx/fieldParser.js";
+import { expectFieldAttrs } from "../../attrs/index.js";
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/nodes/FieldExtension.ts
+/**
+* Field Extension — inline field node (PAGE, NUMPAGES, DATE, MERGEFIELD, etc.)
+*
+* Represents OOXML simple and complex fields as an atomic inline node.
+* At render time, field values are substituted (e.g., PAGE → actual page number).
+*/
+const FieldExtension = createNodeExtension({
+	name: "field",
+	schemaNodeName: "field",
+	nodeSpec: {
+		inline: true,
+		group: "inline",
+		atom: true,
+		selectable: true,
+		attrs: {
+			/** Field type: PAGE, NUMPAGES, DATE, MERGEFIELD, etc. */
+			fieldType: { default: "UNKNOWN" },
+			/** Full field instruction (e.g., "PAGE \\* MERGEFORMAT") */
+			instruction: { default: "" },
+			/** Display text (the current/cached field value) */
+			displayText: { default: "" },
+			/** Whether this is a simple or complex field */
+			fieldKind: { default: "simple" },
+			/** Field is locked */
+			fldLock: { default: false },
+			/** Field is dirty (needs update) */
+			dirty: { default: false }
+		},
+		parseDOM: [{
+			tag: "span.docx-field",
+			getAttrs(dom) {
+				return {
+					fieldType: dom.dataset["fieldType"] ?? "UNKNOWN",
+					instruction: dom.dataset["instruction"] ?? "",
+					displayText: dom.textContent,
+					fieldKind: dom.dataset["fieldKind"] ?? "simple",
+					fldLock: dom.dataset["fldLock"] === "true",
+					dirty: dom.dataset["dirty"] === "true"
+				};
+			}
+		}],
+		toDOM(node) {
+			const { fieldType, instruction, displayText, fieldKind, fldLock, dirty } = expectFieldAttrs(node);
+			let text = displayText || "";
+			if (!text) switch (fieldType) {
+				case "PAGE":
+					text = "{page}";
+					break;
+				case "NUMPAGES":
+					text = "{pages}";
+					break;
+				case "DATE":
+				case "TIME":
+				case "CREATEDATE":
+				case "SAVEDATE":
+					text = (/* @__PURE__ */ new Date()).toLocaleDateString();
+					break;
+				case "MERGEFIELD":
+					text = `«${getMergeFieldName(instruction)}»`;
+					break;
+				default: text = `{${fieldType}}`;
+			}
+			return [
+				"span",
+				{
+					class: `docx-field docx-field-${fieldType.toLowerCase()}`,
+					"data-field-type": fieldType,
+					"data-instruction": instruction,
+					"data-field-kind": fieldKind,
+					...fldLock ? { "data-fld-lock": "true" } : {},
+					...dirty ? { "data-dirty": "true" } : {},
+					style: "outline: 1px solid var(--doc-field-outline, rgba(200,200,200,0.4)); padding: 0 1px; border-radius: 2px;"
+				},
+				text
+			];
+		}
+	}
+});
+function getMergeFieldName(instruction) {
+	return parseFieldInstruction(instruction).argument ?? "";
+}
+//#endregion
+export { FieldExtension };

package/dist/prosemirror/extensions/nodes/HardBreakExtension.d.ts

@@ -0,0 +1,9 @@
+import { NodeExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/nodes/HardBreakExtension.d.ts
+/**
+ * Hard Break Extension — Shift+Enter line break
+ */
+declare const HardBreakExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { HardBreakExtension };

package/dist/prosemirror/extensions/nodes/HardBreakExtension.js

@@ -0,0 +1,38 @@
+import { createNodeExtension } from "../create.js";
+import { panic } from "better-result";
+//#region src/prosemirror/extensions/nodes/HardBreakExtension.ts
+/**
+* Hard Break Extension — Shift+Enter line break
+*/
+const HardBreakExtension = createNodeExtension({
+	name: "hardBreak",
+	schemaNodeName: "hardBreak",
+	nodeSpec: {
+		inline: true,
+		group: "inline",
+		attrs: { breakType: { default: null } },
+		selectable: false,
+		parseDOM: [{
+			tag: "br",
+			getAttrs(node) {
+				if (!(node instanceof HTMLElement)) return null;
+				const breakType = node.dataset["docxBreakType"];
+				return breakType === "column" ? { breakType } : null;
+			}
+		}],
+		toDOM(node) {
+			if (node.attrs["breakType"] === "column") return ["br", { "data-docx-break-type": "column" }];
+			return ["br"];
+		}
+	},
+	onSchemaReady(ctx) {
+		const hardBreakType = ctx.schema.nodes["hardBreak"];
+		if (!hardBreakType) panic("Missing node type: hardBreak");
+		return { keyboardShortcuts: { "Shift-Enter": (state, dispatch) => {
+			if (dispatch) dispatch(state.tr.replaceSelectionWith(hardBreakType.create()).scrollIntoView());
+			return true;
+		} } };
+	}
+});
+//#endregion
+export { HardBreakExtension };

package/dist/prosemirror/extensions/nodes/HorizontalRuleExtension.d.ts

@@ -0,0 +1,9 @@
+import { NodeExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/nodes/HorizontalRuleExtension.d.ts
+/**
+ * Horizontal Rule Extension
+ */
+declare const HorizontalRuleExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { HorizontalRuleExtension };

package/dist/prosemirror/extensions/nodes/HorizontalRuleExtension.js

@@ -0,0 +1,18 @@
+import { createNodeExtension } from "../create.js";
+//#region src/prosemirror/extensions/nodes/HorizontalRuleExtension.ts
+/**
+* Horizontal Rule Extension
+*/
+const HorizontalRuleExtension = createNodeExtension({
+	name: "horizontalRule",
+	schemaNodeName: "horizontalRule",
+	nodeSpec: {
+		group: "block",
+		parseDOM: [{ tag: "hr" }],
+		toDOM() {
+			return ["hr"];
+		}
+	}
+});
+//#endregion
+export { HorizontalRuleExtension };

package/dist/prosemirror/extensions/nodes/ImageExtension.d.ts

@@ -0,0 +1,9 @@
+import { NodeExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/nodes/ImageExtension.d.ts
+/**
+ * Image Extension — inline/floating image node
+ */
+declare const ImageExtension: (options?: Partial<Record<string, unknown>> | undefined) => NodeExtension;
+//#endregion
+export { ImageExtension };