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

package/dist/prosemirror/extensions/features/pasteCleanup.js

@@ -0,0 +1,159 @@
+//#region src/prosemirror/extensions/features/pasteCleanup.ts
+/**
+* Office / web paste cleanup
+*
+* Content pasted from word processors and web pages arrives wrapped in a large
+* amount of producer-specific cruft: conditional comments, XML processing
+* instructions, namespaced markup (`<o:p>`, `<w:sdt>`, smart tags), `mso-*`
+* style declarations, and empty spans. None of it maps to the editor schema,
+* and some of it confuses the browser HTML parser that ProseMirror's clipboard
+* pipeline relies on. Producer class names (`MsoNormal`, ...) are deliberately
+* kept so the downstream style inliner can match `<style>` rules against them.
+*
+* `cleanPastedHtml` normalizes the raw clipboard HTML string into something the
+* schema's `parseDOM` rules can read cleanly. It is a pure string transform so
+* it runs in the editor and in tests without a DOM, and it is deliberately
+* conservative: it strips producer metadata but never rewrites visible text
+* (curly quotes, non-Latin scripts, and whitespace between words are left
+* untouched, since this editor targets an international, typography-sensitive
+* audience).
+*/
+/**
+* Remove every HTML comment, including downlevel conditional comments
+* (`<!--[if gte mso 9]> ... <![endif]-->`) that carry the Office `<xml>` island,
+* while leaving the contents of `<style>` elements untouched.
+*
+* The `<style>` carve-out matters because legacy pasted HTML hides stylesheet
+* CSS inside comment delimiters (`<style><!-- .c { ... } --></style>`, the old
+* CDATA-hiding trick). This cleanup runs before the style inliner and must hand
+* it an intact stylesheet, so a blanket comment strip would drop class rules
+* that used to be inlined. Style blocks are copied through verbatim.
+*
+* A single linear scan rather than a regex: clipboard HTML is untrusted, and a
+* lazy `<!--[\s\S]*?-->` against the multi-character `-->` terminator backtracks
+* polynomially on hostile input. The scan also drops an unterminated comment
+* through end-of-string so no stray `<!--` can survive.
+*/
+function stripHtmlComments(html) {
+	const lower = html.toLowerCase();
+	let result = "";
+	let cursor = 0;
+	while (cursor < html.length) {
+		const commentStart = html.indexOf("<!--", cursor);
+		if (commentStart === -1) {
+			result += html.slice(cursor);
+			break;
+		}
+		const styleStart = lower.indexOf("<style", cursor);
+		if (styleStart !== -1 && styleStart < commentStart) {
+			const openTagEnd = html.indexOf(">", styleStart);
+			const closeStart = openTagEnd === -1 ? -1 : lower.indexOf("</style", openTagEnd + 1);
+			const closeTagEnd = closeStart === -1 ? -1 : html.indexOf(">", closeStart);
+			if (closeTagEnd === -1) {
+				result += html.slice(cursor);
+				break;
+			}
+			result += html.slice(cursor, closeTagEnd + 1);
+			cursor = closeTagEnd + 1;
+			continue;
+		}
+		result += html.slice(cursor, commentStart);
+		const commentEnd = html.indexOf("-->", commentStart + 4);
+		if (commentEnd === -1) break;
+		cursor = commentEnd + 3;
+	}
+	return result;
+}
+/**
+* Drop `mso-*` declarations from every inline `style` attribute while keeping
+* legitimate CSS. Operates per attribute (bounded `[^"]*` / `[^']*` inside the
+* quotes) so it can never run past the attribute into unrelated markup. An
+* attribute left with no non-`mso-*` declarations is removed entirely.
+*/
+function stripMsoStyles(html) {
+	return html.replace(/(\s+)style=(?:"([^"]*)"|'([^']*)')/gi, (_match, ws, dq, sq) => {
+		const raw = dq ?? sq ?? "";
+		const quote = dq === void 0 ? "'" : "\"";
+		const kept = splitStyleDeclarations(raw).map((declaration) => declaration.trim()).filter((declaration) => declaration.length > 0 && !/^mso-/i.test(declaration)).join("; ");
+		return kept ? `${ws}style=${quote}${kept}${quote}` : "";
+	});
+}
+/**
+* Split a CSS `style` value into declarations on top-level `;` only.
+*
+* A naive `split(";")` corrupts values that legitimately contain a semicolon
+* inside a function or a quoted string (e.g. `background:url("data:...;base64,...")`).
+* This scan ignores `;` while inside parentheses or a quoted string, so such
+* declarations stay intact.
+*/
+function splitStyleDeclarations(value) {
+	const declarations = [];
+	let current = "";
+	let parenDepth = 0;
+	let quote = null;
+	for (const char of value) {
+		if (quote !== null) {
+			current += char;
+			if (char === quote) quote = null;
+			continue;
+		}
+		if (char === "\"" || char === "'") quote = char;
+		else if (char === "(") parenDepth++;
+		else if (char === ")") parenDepth = Math.max(0, parenDepth - 1);
+		else if (char === ";" && parenDepth === 0) {
+			declarations.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current) declarations.push(current);
+	return declarations;
+}
+const TAG_TAIL = `(?:"[^"]*"|'[^']*'|[^>"'])*`;
+const NAMESPACED_TAG = new RegExp(`<\\/?(?:[owvm]|st\\d+):${TAG_TAIL}>`, "gi");
+const XML_PROCESSING_INSTRUCTION = new RegExp(`<\\?xml${TAG_TAIL}>`, "gi");
+const STRAY_XML_TAG = new RegExp(`<\\/?xml${TAG_TAIL}>`, "gi");
+const NOISE_TAG = new RegExp(`<\\/?(?:font|meta|link)${TAG_TAIL}>`, "gi");
+const EMPTY_SPAN = new RegExp(`<span(?:\\s${TAG_TAIL})?><\\/span>`, "gi");
+const MAX_EMPTY_SPAN_PASSES = 5;
+/**
+* Remove empty spans left behind after stripping `mso-*` styles. Only truly
+* empty spans are removed (whitespace-only spans are kept so word-separating
+* spacer runs never collapse two words together). Repeated a bounded number of
+* times to unwrap nested empties (`<span><span></span></span>`).
+*/
+function stripEmptySpans(html) {
+	let current = html;
+	for (let pass = 0; pass < MAX_EMPTY_SPAN_PASSES; pass++) {
+		const next = current.replace(EMPTY_SPAN, "");
+		if (next === current) break;
+		current = next;
+	}
+	return current;
+}
+/**
+* Strip Office/web producer cruft from a raw clipboard HTML string.
+*
+* Best-effort and non-throwing: any unexpected failure returns the original
+* markup so a paste degrades to the browser default rather than losing content.
+* `<style>` blocks are intentionally left in place for the downstream style
+* inliner, which resolves class-based CSS before the schema parser runs.
+*/
+function cleanPastedHtml(html) {
+	if (!html) return html;
+	try {
+		let cleaned = stripHtmlComments(html);
+		cleaned = cleaned.replace(XML_PROCESSING_INSTRUCTION, "");
+		cleaned = cleaned.replace(NAMESPACED_TAG, "");
+		cleaned = cleaned.replace(STRAY_XML_TAG, "");
+		cleaned = cleaned.replace(NOISE_TAG, "");
+		cleaned = stripMsoStyles(cleaned);
+		cleaned = stripEmptySpans(cleaned);
+		return cleaned.trim();
+	} catch {
+		return html;
+	}
+}
+//#endregion
+export { cleanPastedHtml };

package/dist/prosemirror/extensions/marks/AllCapsExtension.d.ts

@@ -0,0 +1,9 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/AllCapsExtension.d.ts
+/**
+ * All Caps Mark Extension (w:caps)
+ */
+declare const AllCapsExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { AllCapsExtension };

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

@@ -0,0 +1,24 @@
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/AllCapsExtension.ts
+/**
+* All Caps Mark Extension (w:caps)
+*/
+const AllCapsExtension = createMarkExtension({
+	name: "allCaps",
+	schemaMarkName: "allCaps",
+	markSpec: {
+		parseDOM: [{
+			style: "text-transform",
+			getAttrs: (value) => value === "uppercase" ? {} : false
+		}],
+		toDOM() {
+			return [
+				"span",
+				{ style: "text-transform: uppercase" },
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { AllCapsExtension };

package/dist/prosemirror/extensions/marks/BoldExtension.d.ts

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

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

@@ -0,0 +1,41 @@
+import { createMarkExtension } from "../create.js";
+import { panic } from "better-result";
+import { toggleMark } from "prosemirror-commands";
+//#region src/prosemirror/extensions/marks/BoldExtension.ts
+/**
+* Bold Mark Extension
+*/
+const BoldExtension = createMarkExtension({
+	name: "bold",
+	schemaMarkName: "bold",
+	markSpec: {
+		parseDOM: [
+			{ tag: "strong" },
+			{
+				tag: "b",
+				getAttrs(dom) {
+					const fw = dom.style.fontWeight;
+					if (fw === "normal" || fw === "400") return false;
+					return null;
+				}
+			},
+			{
+				style: "font-weight",
+				getAttrs: (value) => /^(?:bold(?:er)?|[5-9]\d{2})$/u.test(value) ? null : false
+			}
+		],
+		toDOM() {
+			return ["strong", 0];
+		}
+	},
+	onSchemaReady(ctx) {
+		const boldType = ctx.schema.marks["bold"];
+		if (!boldType) panic("Missing mark type: bold");
+		return {
+			commands: { toggleBold: () => toggleMark(boldType) },
+			keyboardShortcuts: { "Mod-b": toggleMark(boldType) }
+		};
+	}
+});
+//#endregion
+export { BoldExtension };

package/dist/prosemirror/extensions/marks/CharacterSpacingExtension.d.ts

@@ -0,0 +1,14 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/CharacterSpacingExtension.d.ts
+/**
+ * Character Spacing Mark Extension
+ *
+ * Handles: character spacing (w:spacing), position/raise-lower (w:position),
+ * horizontal scale (w:w), and kerning (w:kern).
+ *
+ * Single mark with multiple attributes to avoid mark explosion.
+ */
+declare const CharacterSpacingExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { CharacterSpacingExtension };

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

@@ -0,0 +1,64 @@
+import { formatPx, twipsToPixels } from "../../../utils/units.js";
+import { expectCharacterSpacingMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/CharacterSpacingExtension.ts
+/**
+* Character Spacing Mark Extension
+*
+* Handles: character spacing (w:spacing), position/raise-lower (w:position),
+* horizontal scale (w:w), and kerning (w:kern).
+*
+* Single mark with multiple attributes to avoid mark explosion.
+*/
+function halfPointsToPixels(halfPoints) {
+	return halfPoints / 2 * (96 / 72);
+}
+const CharacterSpacingExtension = createMarkExtension({
+	name: "characterSpacing",
+	schemaMarkName: "characterSpacing",
+	markSpec: {
+		attrs: {
+			spacing: { default: null },
+			position: { default: null },
+			scale: { default: null },
+			kerning: { default: null }
+		},
+		parseDOM: [{
+			tag: "span.docx-char-spacing",
+			getAttrs: (dom) => ({
+				spacing: dom.dataset["spacing"] ? Number(dom.dataset["spacing"]) : null,
+				position: dom.dataset["position"] ? Number(dom.dataset["position"]) : null,
+				scale: dom.dataset["scale"] ? Number(dom.dataset["scale"]) : null,
+				kerning: dom.dataset["kerning"] ? Number(dom.dataset["kerning"]) : null
+			})
+		}],
+		toDOM(mark) {
+			const { spacing, position, scale, kerning } = expectCharacterSpacingMarkAttrs(mark);
+			const styles = [];
+			const dataAttrs = { class: "docx-char-spacing" };
+			if (spacing !== void 0 && spacing !== 0) {
+				styles.push(`letter-spacing: ${formatPx(twipsToPixels(spacing))}`);
+				dataAttrs["data-spacing"] = String(spacing);
+			}
+			if (position !== void 0 && position !== 0) {
+				const px = halfPointsToPixels(position);
+				styles.push(`vertical-align: ${formatPx(px)}`);
+				dataAttrs["data-position"] = String(position);
+			}
+			if (scale !== void 0 && scale !== 100) {
+				styles.push(`transform: scaleX(${scale / 100})`);
+				styles.push("display: inline-block");
+				dataAttrs["data-scale"] = String(scale);
+			}
+			if (kerning !== void 0) dataAttrs["data-kerning"] = String(kerning);
+			if (styles.length > 0) dataAttrs["style"] = styles.join("; ");
+			return [
+				"span",
+				dataAttrs,
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { CharacterSpacingExtension };

package/dist/prosemirror/extensions/marks/CharacterStyleExtension.d.ts

@@ -0,0 +1,23 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/CharacterStyleExtension.d.ts
+/**
+ * Character Style Mark Extension (w:rStyle)
+ *
+ * Carries a run's character style reference through ProseMirror so semantic
+ * styles (e.g. a house "DefinedTerm" style) survive the load → edit → save
+ * round-trip. The style's resolved formatting is flattened into the regular
+ * marks at load for rendering; this mark only preserves the reference plus a
+ * private snapshot of the style's own run properties (`_styleRPr`) that the
+ * serializer uses to avoid re-emitting style-provided values as direct
+ * formatting.
+ *
+ * The mark renders as an unstyled span with a `data-character-style`
+ * attribute. parseDOM restores the styleId (so copy/paste inside the editor
+ * keeps the reference) but not the snapshot — pasted content then serializes
+ * with the reference plus explicit formatting, which renders identically and
+ * degrades gracefully.
+ */
+declare const CharacterStyleExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { CharacterStyleExtension };

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

@@ -0,0 +1,47 @@
+import { expectCharacterStyleMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/CharacterStyleExtension.ts
+/**
+* Character Style Mark Extension (w:rStyle)
+*
+* Carries a run's character style reference through ProseMirror so semantic
+* styles (e.g. a house "DefinedTerm" style) survive the load → edit → save
+* round-trip. The style's resolved formatting is flattened into the regular
+* marks at load for rendering; this mark only preserves the reference plus a
+* private snapshot of the style's own run properties (`_styleRPr`) that the
+* serializer uses to avoid re-emitting style-provided values as direct
+* formatting.
+*
+* The mark renders as an unstyled span with a `data-character-style`
+* attribute. parseDOM restores the styleId (so copy/paste inside the editor
+* keeps the reference) but not the snapshot — pasted content then serializes
+* with the reference plus explicit formatting, which renders identically and
+* degrades gracefully.
+*/
+const CharacterStyleExtension = createMarkExtension({
+	name: "characterStyle",
+	schemaMarkName: "characterStyle",
+	markSpec: {
+		attrs: {
+			styleId: { default: "" },
+			_styleRPr: { default: null }
+		},
+		parseDOM: [{
+			tag: "span[data-character-style]",
+			getAttrs: (dom) => {
+				const styleId = dom.getAttribute("data-character-style");
+				return styleId ? { styleId } : false;
+			}
+		}],
+		toDOM(mark) {
+			const { styleId } = expectCharacterStyleMarkAttrs(mark);
+			return [
+				"span",
+				{ "data-character-style": styleId },
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { CharacterStyleExtension };

package/dist/prosemirror/extensions/marks/CommentExtension.d.ts

@@ -0,0 +1,12 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/CommentExtension.d.ts
+/**
+ * Comment Mark Extension — highlights text that has comments
+ *
+ * Applied to text ranges between commentRangeStart and commentRangeEnd.
+ * The comment ID links to the Comment object in the document model.
+ */
+declare const CommentExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { CommentExtension };

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

@@ -0,0 +1,38 @@
+import { expectCommentMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+//#region src/prosemirror/extensions/marks/CommentExtension.ts
+/**
+* Comment Mark Extension — highlights text that has comments
+*
+* Applied to text ranges between commentRangeStart and commentRangeEnd.
+* The comment ID links to the Comment object in the document model.
+*/
+const CommentExtension = createMarkExtension({
+	name: "comment",
+	schemaMarkName: "comment",
+	markSpec: {
+		attrs: { 
+		/** Comment ID (matches Comment.id) */
+commentId: { default: 0 } },
+		inclusive: false,
+		parseDOM: [{
+			tag: "span.docx-comment",
+			getAttrs(dom) {
+				return { commentId: Number.parseInt(dom.dataset["commentId"] ?? "0", 10) };
+			}
+		}],
+		toDOM(mark) {
+			const { commentId } = expectCommentMarkAttrs(mark);
+			return [
+				"span",
+				{
+					class: "docx-comment",
+					"data-comment-id": String(commentId)
+				},
+				0
+			];
+		}
+	}
+});
+//#endregion
+export { CommentExtension };

package/dist/prosemirror/extensions/marks/FontFamilyExtension.d.ts

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

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

@@ -0,0 +1,55 @@
+import { expectFontFamilyMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+import { removeMark, setMark } from "./markUtils.js";
+import { panic } from "better-result";
+//#region src/prosemirror/extensions/marks/FontFamilyExtension.ts
+/**
+* Font Family Mark Extension
+*/
+const FontFamilyExtension = createMarkExtension({
+	name: "fontFamily",
+	schemaMarkName: "fontFamily",
+	markSpec: {
+		attrs: {
+			ascii: { default: null },
+			hAnsi: { default: null },
+			eastAsia: { default: null },
+			cs: { default: null },
+			asciiTheme: { default: null },
+			hAnsiTheme: { default: null },
+			eastAsiaTheme: { default: null },
+			csTheme: { default: null }
+		},
+		parseDOM: [{
+			style: "font-family",
+			getAttrs: (value) => {
+				const firstFont = (value.split(",")[0] ?? "").trim().replace(/['"]/gu, "");
+				if (firstFont) return { ascii: firstFont };
+				return false;
+			}
+		}],
+		toDOM(mark) {
+			const { ascii, hAnsi } = expectFontFamilyMarkAttrs(mark);
+			const fontName = ascii ?? hAnsi;
+			if (!fontName) return ["span", 0];
+			return [
+				"span",
+				{ style: `font-family: ${fontName.includes(" ") ? `"${fontName}"` : fontName}, "Noto Sans Arabic", sans-serif` },
+				0
+			];
+		}
+	},
+	onSchemaReady(ctx) {
+		const fontFamilyType = ctx.schema.marks["fontFamily"];
+		if (!fontFamilyType) panic("Missing mark type: fontFamily");
+		return { commands: {
+			setFontFamily: (fontName) => setMark(fontFamilyType, {
+				ascii: fontName,
+				hAnsi: fontName
+			}),
+			clearFontFamily: () => removeMark(fontFamilyType)
+		} };
+	}
+});
+//#endregion
+export { FontFamilyExtension };

package/dist/prosemirror/extensions/marks/FontSizeExtension.d.ts

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

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

@@ -0,0 +1,47 @@
+import { expectFontSizeMarkAttrs } from "../../attrs/index.js";
+import { createMarkExtension } from "../create.js";
+import { removeMark, setMark } from "./markUtils.js";
+import { panic } from "better-result";
+//#region src/prosemirror/extensions/marks/FontSizeExtension.ts
+/**
+* Font Size Mark Extension
+*/
+const FontSizeExtension = createMarkExtension({
+	name: "fontSize",
+	schemaMarkName: "fontSize",
+	markSpec: {
+		attrs: { size: { default: 24 } },
+		parseDOM: [{
+			style: "font-size",
+			getAttrs: (value) => {
+				const pxMatch = /^(?<value>[\d.]+)px$/u.exec(value);
+				if (pxMatch) {
+					const pt = Number.parseFloat(pxMatch.groups?.["value"] ?? "0") * .75;
+					return { size: Math.round(pt * 2) };
+				}
+				const ptMatch = /^(?<value>[\d.]+)pt$/u.exec(value);
+				if (ptMatch) return { size: Math.round(Number.parseFloat(ptMatch.groups?.["value"] ?? "0") * 2) };
+				return false;
+			}
+		}],
+		toDOM(mark) {
+			const { size } = expectFontSizeMarkAttrs(mark);
+			const pt = size / 2;
+			return [
+				"span",
+				{ style: `font-size: ${pt}pt; line-height: ${(pt * 1.15).toFixed(2)}pt` },
+				0
+			];
+		}
+	},
+	onSchemaReady(ctx) {
+		const fontSizeType = ctx.schema.marks["fontSize"];
+		if (!fontSizeType) panic("Missing mark type: fontSize");
+		return { commands: {
+			setFontSize: (size) => setMark(fontSizeType, { size }),
+			clearFontSize: () => removeMark(fontSizeType)
+		} };
+	}
+});
+//#endregion
+export { FontSizeExtension };

package/dist/prosemirror/extensions/marks/FootnoteRefExtension.d.ts

@@ -0,0 +1,11 @@
+import { MarkExtension } from "../types.js";
+
+//#region src/prosemirror/extensions/marks/FootnoteRefExtension.d.ts
+/**
+ * Footnote Reference Mark Extension
+ *
+ * Provides footnoteRef mark + insert/delete commands for footnotes and endnotes.
+ */
+declare const FootnoteRefExtension: (options?: Partial<Record<string, unknown>> | undefined) => MarkExtension;
+//#endregion
+export { FootnoteRefExtension };