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

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

@@ -0,0 +1,188 @@
+import { createExtension } from "../create.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+import { AddMarkStep, AddNodeMarkStep, RemoveMarkStep, RemoveNodeMarkStep } from "prosemirror-transform";
+//#region src/prosemirror/extensions/features/ParagraphChangeTrackerExtension.ts
+/**
+* Paragraph Change Tracker Extension
+*
+* Watches ProseMirror transactions and records which paragraph IDs (paraId)
+* were modified. Also detects structural changes (paragraphs added/deleted).
+* Used by the selective save system to patch only changed paragraphs in document.xml.
+*/
+const paragraphChangeTrackerKey = new PluginKey("paragraphChangeTracker");
+const CLEAR_META = "clear";
+const IGNORE_META = "ignore";
+/**
+* Count paragraph nodes in a ProseMirror document
+*/
+function countParagraphs(doc) {
+	let count = 0;
+	doc.descendants((node) => {
+		if (node.type.name === "paragraph") count++;
+	});
+	return count;
+}
+/**
+* Collect paraIds of all paragraphs that overlap with the given range
+*/
+function collectAffectedParaIds(doc, from, to) {
+	const ids = /* @__PURE__ */ new Set();
+	let hasUntracked = false;
+	doc.nodesBetween(from, to, (node) => {
+		if (node.type.name === "paragraph") {
+			const paraId = node.attrs["paraId"];
+			if (paraId) ids.add(paraId);
+			else hasUntracked = true;
+		}
+	});
+	return {
+		ids,
+		hasUntracked
+	};
+}
+/**
+* AddMarkStep / RemoveMarkStep inherit Step.getMap() → StepMap.empty, so we use
+* their from/to to find affected paragraphs.
+* Node mark steps use a single position before the target node.
+*/
+function collectAffectedParaIdsFromMarkLikeStep(doc, from, to) {
+	const lo = Math.min(from, to);
+	const hi = Math.max(from, to);
+	const primary = collectAffectedParaIds(doc, lo, hi > lo ? hi : lo + 1);
+	if (primary.ids.size > 0 || primary.hasUntracked) return primary;
+	try {
+		const $p = doc.resolve(lo);
+		for (let d = $p.depth; d >= 0; d--) {
+			const n = $p.node(d);
+			if (n.type.name === "paragraph") {
+				const paraId = n.attrs["paraId"];
+				if (paraId) return {
+					ids: /* @__PURE__ */ new Set([paraId]),
+					hasUntracked: false
+				};
+				return {
+					ids: /* @__PURE__ */ new Set(),
+					hasUntracked: true
+				};
+			}
+		}
+	} catch {}
+	return {
+		ids: /* @__PURE__ */ new Set(),
+		hasUntracked: false
+	};
+}
+function mapStepPosition(remap, pos, assoc) {
+	return remap.map(pos, assoc);
+}
+function createParagraphChangeTrackerPlugin() {
+	return new Plugin({
+		key: paragraphChangeTrackerKey,
+		state: {
+			init(_config, state) {
+				return {
+					changedParaIds: /* @__PURE__ */ new Set(),
+					structuralChange: false,
+					hasUntrackedChanges: false,
+					paragraphCount: countParagraphs(state.doc)
+				};
+			},
+			apply(tr, prevState) {
+				const meta = tr.getMeta(paragraphChangeTrackerKey);
+				if (meta === CLEAR_META) return {
+					changedParaIds: /* @__PURE__ */ new Set(),
+					structuralChange: false,
+					hasUntrackedChanges: false,
+					paragraphCount: prevState.paragraphCount
+				};
+				if (meta === IGNORE_META) return {
+					...prevState,
+					paragraphCount: tr.docChanged ? countParagraphs(tr.doc) : prevState.paragraphCount
+				};
+				if (!tr.docChanged) return prevState;
+				const newCount = countParagraphs(tr.doc);
+				const newState = {
+					changedParaIds: new Set(prevState.changedParaIds),
+					structuralChange: prevState.structuralChange,
+					hasUntrackedChanges: prevState.hasUntrackedChanges,
+					paragraphCount: newCount
+				};
+				if (prevState.paragraphCount !== newCount) newState.structuralChange = true;
+				for (let stepIndex = 0; stepIndex < tr.steps.length; stepIndex++) {
+					const step = tr.steps[stepIndex];
+					const remap = tr.mapping.slice(stepIndex + 1);
+					if (step instanceof AddMarkStep || step instanceof RemoveMarkStep) {
+						const from = mapStepPosition(remap, step.from, 1);
+						const to = mapStepPosition(remap, step.to, -1);
+						if (to <= from) continue;
+						const { ids, hasUntracked } = collectAffectedParaIdsFromMarkLikeStep(tr.doc, from, to);
+						for (const id of ids) newState.changedParaIds.add(id);
+						if (hasUntracked) newState.hasUntrackedChanges = true;
+						continue;
+					}
+					if (step instanceof AddNodeMarkStep || step instanceof RemoveNodeMarkStep) {
+						const pos = mapStepPosition(remap, step.pos, 1);
+						const node = tr.doc.nodeAt(pos);
+						if (!node) continue;
+						const end = pos + node.nodeSize;
+						const { ids, hasUntracked } = collectAffectedParaIds(tr.doc, pos, end);
+						for (const id of ids) newState.changedParaIds.add(id);
+						if (hasUntracked) newState.hasUntrackedChanges = true;
+						continue;
+					}
+					step.getMap().forEach((_oldStart, _oldEnd, newStart, newEnd) => {
+						const from = mapStepPosition(remap, newStart, 1);
+						const to = mapStepPosition(remap, newEnd, -1);
+						if (to < from) return;
+						const { ids, hasUntracked } = collectAffectedParaIds(tr.doc, from, to);
+						for (const id of ids) newState.changedParaIds.add(id);
+						if (hasUntracked) newState.hasUntrackedChanges = true;
+					});
+				}
+				return newState;
+			}
+		}
+	});
+}
+/**
+* Get the change tracker state from an EditorState
+*/
+function getChangeTrackerState(state) {
+	return paragraphChangeTrackerKey.getState(state);
+}
+/**
+* Get the set of changed paragraph IDs from an EditorState
+*/
+function getChangedParagraphIds(state) {
+	return getChangeTrackerState(state)?.changedParaIds ?? /* @__PURE__ */ new Set();
+}
+/**
+* Check if structural changes (paragraph add/delete) occurred
+*/
+function hasStructuralChanges(state) {
+	return getChangeTrackerState(state)?.structuralChange ?? false;
+}
+/**
+* Check if any changes affected paragraphs without paraId
+*/
+function hasUntrackedChanges(state) {
+	return getChangeTrackerState(state)?.hasUntrackedChanges ?? false;
+}
+/**
+* Create a transaction that clears the change tracker
+*/
+function clearTrackedChanges(state) {
+	return state.tr.setMeta(paragraphChangeTrackerKey, CLEAR_META);
+}
+function ignoreTrackedChanges(tr) {
+	return tr.setMeta(paragraphChangeTrackerKey, IGNORE_META);
+}
+const ParagraphChangeTrackerExtension = createExtension({
+	name: "paragraphChangeTracker",
+	defaultOptions: {},
+	onSchemaReady() {
+		return { plugins: [createParagraphChangeTrackerPlugin()] };
+	}
+});
+//#endregion
+export { ParagraphChangeTrackerExtension, clearTrackedChanges, getChangeTrackerState, getChangedParagraphIds, hasStructuralChanges, hasUntrackedChanges, ignoreTrackedChanges, paragraphChangeTrackerKey };

package/dist/prosemirror/extensions/features/PasteCleanupExtension.d.ts

@@ -0,0 +1,20 @@
+import { Extension } from "../types.js";
+
+//#region src/prosemirror/extensions/features/PasteCleanupExtension.d.ts
+/**
+ * Paste Cleanup Extension
+ *
+ * Wires two paste-handling behaviors into the editor:
+ *
+ * 1. `transformPastedHTML` — strips Office/web producer cruft from pasted HTML
+ *    (see {@link cleanPastedHtml}) before the schema parser reads it. Runs at
+ *    `Highest` priority so the cleanup happens before the style inliner and the
+ *    default clipboard parser; ProseMirror chains every plugin's
+ *    `transformPastedHTML`, so this cooperates with the inliner rather than
+ *    replacing it, and `<style>` blocks are left intact for it to resolve.
+ * 2. `Mod-Alt-v` — "paste without formatting", inserting clipboard text with
+ *    the source formatting stripped (see {@link pasteWithoutFormatting}).
+ */
+declare const PasteCleanupExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion
+export { PasteCleanupExtension };

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

@@ -0,0 +1,34 @@
+import { Priority } from "../types.js";
+import { createExtension } from "../create.js";
+import { pasteWithoutFormatting } from "../../commands/pastePlainText.js";
+import { cleanPastedHtml } from "./pasteCleanup.js";
+import { Plugin } from "prosemirror-state";
+//#region src/prosemirror/extensions/features/PasteCleanupExtension.ts
+/**
+* Paste Cleanup Extension
+*
+* Wires two paste-handling behaviors into the editor:
+*
+* 1. `transformPastedHTML` — strips Office/web producer cruft from pasted HTML
+*    (see {@link cleanPastedHtml}) before the schema parser reads it. Runs at
+*    `Highest` priority so the cleanup happens before the style inliner and the
+*    default clipboard parser; ProseMirror chains every plugin's
+*    `transformPastedHTML`, so this cooperates with the inliner rather than
+*    replacing it, and `<style>` blocks are left intact for it to resolve.
+* 2. `Mod-Alt-v` — "paste without formatting", inserting clipboard text with
+*    the source formatting stripped (see {@link pasteWithoutFormatting}).
+*/
+const PasteCleanupExtension = createExtension({
+	name: "pasteCleanup",
+	priority: Priority.Highest,
+	onSchemaReady() {
+		return {
+			plugins: [new Plugin({ props: { transformPastedHTML(html) {
+				return cleanPastedHtml(html);
+			} } })],
+			keyboardShortcuts: { "Mod-Alt-v": pasteWithoutFormatting }
+		};
+	}
+});
+//#endregion
+export { PasteCleanupExtension };

package/dist/prosemirror/extensions/features/PasteStyleInlinerExtension.d.ts

@@ -0,0 +1,20 @@
+import { Extension } from "../types.js";
+
+//#region src/prosemirror/extensions/features/PasteStyleInlinerExtension.d.ts
+/**
+ * Paste Style Inliner Extension
+ *
+ * When pasting from apps like Google Docs that use class-based CSS
+ * (e.g. `<style>.c5 { margin-top: 12pt }</style>`) instead of inline styles,
+ * ProseMirror's parseDOM can't read the styles because elements aren't attached
+ * to the live document during parsing.
+ *
+ * This extension provides a `transformPastedHTML` hook that:
+ * 1. Parses the pasted HTML string
+ * 2. Extracts all `<style>` rules
+ * 3. Inlines them onto matching elements
+ * 4. Returns the modified HTML so parseDOM can read inline styles
+ */
+declare const PasteStyleInlinerExtension: (options?: Partial<Record<string, unknown>> | undefined) => Extension;
+//#endregion
+export { PasteStyleInlinerExtension };

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

@@ -0,0 +1,145 @@
+import { Priority } from "../types.js";
+import { createExtension } from "../create.js";
+import { Plugin } from "prosemirror-state";
+//#region src/prosemirror/extensions/features/PasteStyleInlinerExtension.ts
+/**
+* Paste Style Inliner Extension
+*
+* When pasting from apps like Google Docs that use class-based CSS
+* (e.g. `<style>.c5 { margin-top: 12pt }</style>`) instead of inline styles,
+* ProseMirror's parseDOM can't read the styles because elements aren't attached
+* to the live document during parsing.
+*
+* This extension provides a `transformPastedHTML` hook that:
+* 1. Parses the pasted HTML string
+* 2. Extracts all `<style>` rules
+* 3. Inlines them onto matching elements
+* 4. Returns the modified HTML so parseDOM can read inline styles
+*/
+/**
+* Parse a CSS rule's style declarations into a Record<property, value>.
+*/
+function parseStyleDeclarations(cssText) {
+	const result = {};
+	const declarations = cssText.split(";");
+	for (const decl of declarations) {
+		const trimmed = decl.trim();
+		if (!trimmed) continue;
+		const colonIdx = trimmed.indexOf(":");
+		if (colonIdx === -1) continue;
+		const prop = trimmed.slice(0, colonIdx).trim();
+		const value = trimmed.slice(colonIdx + 1).trim();
+		if (prop && value) result[prop] = value;
+	}
+	return result;
+}
+/**
+* Merge style declarations onto an element's existing inline style.
+* Existing inline styles take precedence (they were explicitly set by the app).
+*/
+function mergeStylesOntoElement(element, declarations) {
+	const existingDeclarations = parseStyleDeclarations(element.getAttribute("style") || "");
+	for (const [prop, value] of Object.entries(declarations)) if (!(prop in existingDeclarations)) element.style.setProperty(prop, value);
+}
+/**
+* Extract CSS rules from `<style>` elements and inline them onto matching elements.
+*
+* Uses the browser's CSSStyleSheet API to properly parse CSS rules,
+* handling complex selectors, specificity, etc.
+*/
+function inlineStylesFromStyleBlocks(doc) {
+	const styleElements = doc.querySelectorAll("style");
+	if (styleElements.length === 0) return;
+	const rulesWithSelectors = [];
+	for (const styleEl of styleElements) {
+		const cssText = styleEl.textContent || "";
+		if (!cssText.trim()) continue;
+		try {
+			const tempStyle = doc.createElement("style");
+			tempStyle.textContent = cssText;
+			doc.head.append(tempStyle);
+			const sheet = tempStyle.sheet;
+			if (sheet) {
+				for (const rule of sheet.cssRules) if (rule instanceof CSSStyleRule) {
+					const declarations = {};
+					const style = rule.style;
+					for (const prop of style) declarations[prop] = style.getPropertyValue(prop);
+					if (Object.keys(declarations).length > 0) rulesWithSelectors.push({
+						selector: rule.selectorText,
+						declarations
+					});
+				}
+			}
+			tempStyle.remove();
+		} catch {
+			let searchFrom = 0;
+			while (searchFrom < cssText.length) {
+				const open = cssText.indexOf("{", searchFrom);
+				if (open === -1) break;
+				const close = cssText.indexOf("}", open + 1);
+				if (close === -1) break;
+				const selector = cssText.slice(searchFrom, open).trim();
+				const declarations = parseStyleDeclarations(cssText.slice(open + 1, close));
+				if (Object.keys(declarations).length > 0) rulesWithSelectors.push({
+					selector,
+					declarations
+				});
+				searchFrom = close + 1;
+			}
+		}
+	}
+	if (rulesWithSelectors.length === 0) return;
+	for (const { selector, declarations } of rulesWithSelectors) try {
+		const matchingElements = doc.body.querySelectorAll(selector);
+		for (const el of matchingElements) if (el instanceof HTMLElement) mergeStylesOntoElement(el, declarations);
+	} catch {}
+}
+/**
+* Google Docs wraps ALL clipboard content in a structural <b> tag:
+*   <b id="docs-internal-guid-XXXXX" style="font-weight:normal;">...content...</b>
+*
+* This is NOT a bold formatting tag — it is a container for Google Docs' internal
+* tracking GUID. The actual bold status is on <span> elements via font-weight CSS.
+*
+* This function detects such wrappers and replaces them with their child nodes,
+* preventing ProseMirror's BoldExtension parseDOM from applying bold to all content.
+*/
+function unwrapGoogleDocsStructuralB(doc) {
+	const structuralBs = doc.body.querySelectorAll("b[id^=\"docs-internal-guid-\"]");
+	for (const b of structuralBs) {
+		if (!b.parentNode) continue;
+		while (b.firstChild) b.before(b.firstChild);
+		b.remove();
+	}
+}
+/**
+* Transform pasted HTML by inlining class-based CSS and unwrapping Google Docs wrappers.
+*/
+function transformPastedHTML(html) {
+	const hasStyleBlock = html.includes("<style");
+	const hasGoogleDocsWrapper = html.includes("docs-internal-guid-");
+	if (!hasStyleBlock && !hasGoogleDocsWrapper) return html;
+	try {
+		const doc = new DOMParser().parseFromString(html, "text/html");
+		if (hasStyleBlock) {
+			inlineStylesFromStyleBlocks(doc);
+			const styleElements = doc.querySelectorAll("style");
+			for (const el of styleElements) el.remove();
+		}
+		if (hasGoogleDocsWrapper) unwrapGoogleDocsStructuralB(doc);
+		return doc.body.innerHTML;
+	} catch {
+		return html;
+	}
+}
+const PasteStyleInlinerExtension = createExtension({
+	name: "pasteStyleInliner",
+	priority: Priority.High,
+	onSchemaReady() {
+		return { plugins: [new Plugin({ props: { transformPastedHTML(html) {
+			return transformPastedHTML(html);
+		} } })] };
+	}
+});
+//#endregion
+export { PasteStyleInlinerExtension };

package/dist/prosemirror/extensions/features/SelectionTrackerExtension.d.ts

@@ -0,0 +1,10 @@
+import { Extension } from "../types.js";
+import { SelectionChangeCallback } from "../../plugins/selectionTracker.js";
+
+//#region src/prosemirror/extensions/features/SelectionTrackerExtension.d.ts
+type SelectionTrackerOptions = {
+  onSelectionChange?: SelectionChangeCallback;
+};
+declare const SelectionTrackerExtension: (options?: Partial<SelectionTrackerOptions> | undefined) => Extension;
+//#endregion
+export { SelectionTrackerExtension };

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

@@ -0,0 +1,17 @@
+import { createExtension } from "../create.js";
+import { createSelectionTrackerPlugin, extractSelectionContext } from "../../plugins/selectionTracker.js";
+const SelectionTrackerExtension = createExtension({
+	name: "selectionTracker",
+	defaultOptions: {},
+	onSchemaReady(_ctx, options) {
+		return {
+			plugins: [createSelectionTrackerPlugin(options.onSelectionChange)],
+			commands: { extractSelectionContext: () => (state, _dispatch) => {
+				extractSelectionContext(state);
+				return true;
+			} }
+		};
+	}
+});
+//#endregion
+export { SelectionTrackerExtension };

package/dist/prosemirror/extensions/features/bidiShortcutController.d.ts

@@ -0,0 +1,31 @@
+//#region src/prosemirror/extensions/features/bidiShortcutController.d.ts
+/**
+ * Bidi shortcut controller — framework-agnostic state machine for the
+ * Ctrl/Cmd+Shift direction shortcut, split out from the plugin wiring (which
+ * reaches the singleton schema) so it can be imported and unit-tested without
+ * triggering schema initialization.
+ *
+ * The direction change is armed on the Shift keydown (while Ctrl/Cmd is held)
+ * but only applied on the Shift keyup, and is cancelled if any other key is
+ * pressed in between. That deferral is what keeps the shortcut from hijacking
+ * longer chords that also start with Ctrl/Cmd+Shift — most importantly the redo
+ * chord Ctrl/Cmd+Shift+Z: firing the direction change on the Shift keydown would
+ * record a paragraph-attribute transaction that wipes the editor's redo stack
+ * before the "Z" ever arrives, so redo would silently restore nothing.
+ */
+/** Paragraph base-direction a bidi shortcut applies. */
+type BidiDirection = "ltr" | "rtl";
+/** Minimal keyboard-event shape the bidi controller reads. */
+type BidiKeyEvent = {
+  key: string;
+  code: string;
+  metaKey: boolean;
+  ctrlKey: boolean;
+};
+type BidiShortcutController = {
+  /** Track a keydown: arm on Ctrl/Cmd+Shift, cancel on any other key. */handleKeyDown: (event: BidiKeyEvent) => void; /** On Shift keyup, return the armed direction (and disarm), else null. */
+  handleKeyUp: (event: BidiKeyEvent) => BidiDirection | null;
+};
+declare const createBidiShortcutController: () => BidiShortcutController;
+//#endregion
+export { BidiDirection, BidiKeyEvent, BidiShortcutController, createBidiShortcutController };

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

@@ -0,0 +1,27 @@
+//#region src/prosemirror/extensions/features/bidiShortcutController.ts
+const createBidiShortcutController = () => {
+	let armed = null;
+	return {
+		handleKeyDown(event) {
+			if (event.key !== "Shift") {
+				armed = null;
+				return;
+			}
+			if (!(event.metaKey || event.ctrlKey)) {
+				armed = null;
+				return;
+			}
+			if (event.code === "ShiftLeft") armed = "ltr";
+			else if (event.code === "ShiftRight") armed = "rtl";
+			else armed = null;
+		},
+		handleKeyUp(event) {
+			if (event.key !== "Shift") return null;
+			const direction = armed;
+			armed = null;
+			return direction;
+		}
+	};
+};
+//#endregion
+export { createBidiShortcutController };

package/dist/prosemirror/extensions/features/pasteCleanup.d.ts

@@ -0,0 +1,31 @@
+//#region src/prosemirror/extensions/features/pasteCleanup.d.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).
+ */
+/**
+ * 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.
+ */
+declare function cleanPastedHtml(html: string): string;
+//#endregion
+export { cleanPastedHtml };