@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/extensions/core/ParagraphExtension.js

@@ -1,5 +1,6 @@
 import { BUILT_IN_STYLE_NAME } from "../../../docx/builtInStyles.js";
 import { PROSE_PARAGRAPH_SOURCE_TOKEN_ATTR } from "../../../docx/paragraphPropertySource.js";
+import { isStyleSourcedParagraphNumbering } from "../../../internal/paragraphFormattingSerialization.js";
 import { PARAGRAPH_ALIGNMENT_VALUES } from "../../../types/documentEnumValues.js";
 import { paragraphToStyle } from "../../../utils/formatToStyle.js";
 import { collectHeadings } from "../../../utils/headingCollector.js";
@@ -7,12 +8,16 @@ import { tableOfContentsStyleLevel } from "../../../utils/tableOfContentsStyle.j
 import { expectParagraphAttrs } from "../../attrs/index.js";
 import { autospacingMatchesBase } from "../../autospacingBase.js";
 import { removeSectionBreakAtSelection, setSectionBreakType } from "../../commands/sectionBreak.js";
+import { CLEARED_LIST_RENDERING_ATTRS } from "../../listMarker.js";
 import { directParagraphAlignment } from "../../paragraphAlignment.js";
 import { directionIsRtl } from "../../paragraphDirection.js";
-import { withDirectParagraphSpacing } from "../../paragraphSpacing.js";
-import { getDocumentBuiltInStyles } from "../../plugins/documentStyles.js";
+import { directParagraphIndentation } from "../../paragraphIndentation.js";
+import { directParagraphSpacing, withDirectParagraphSpacing } from "../../paragraphSpacing.js";
+import { getDocumentNumbering } from "../../plugins/documentNumbering.js";
+import { getDocumentBuiltInStyles, getDocumentStyleResolver } from "../../plugins/documentStyleState.js";
+import { rebaseParagraphRuns } from "../../rebaseParagraphRuns.js";
 import { mintSectionProperties, parseSectionBreakType, sectionBreakTypeOf } from "../../sectionCarrier.js";
-import { listAttrsFromResolvedStyle, paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs.js";
+import { listAttrsFromResolvedStyle, listLevelIndentAttrPatch, paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs.js";
 import { createNodeExtension } from "../create.js";
 import { headingOutlineLevel, paragraphNumberingLevel, paragraphNumberingReferenceId } from "@stll/docx-core/model";
 import { Fragment } from "prosemirror-model";
@@ -213,6 +218,7 @@ const paragraphNodeSpec = {
 		indentFirstLine: { default: null },
 		hangingIndent: { default: false },
 		numPr: { default: null },
+		_pastedHtmlList: { default: void 0 },
 		numPrFromStyle: { default: null },
 		listNumFmt: { default: null },
 		listIsBullet: { default: null },
@@ -273,11 +279,22 @@ const paragraphNodeSpec = {
 			const styleId = element.dataset["styleId"];
 			const tableOfContentsLevel = Number(element.dataset["tableOfContentsLevel"]);
 			const sectionBreakType = parseSectionBreakType(element.dataset["sectionBreak"]);
+			const pastedListGroup = Number(element.dataset["folioListGroup"]);
+			const pastedListLevel = Number(element.dataset["folioListLevel"]);
+			const pastedListKind = element.dataset["folioListKind"];
+			const pastedListStart = Number(element.dataset["folioListStart"]);
+			const pastedHtmlList = Number.isSafeInteger(pastedListGroup) && pastedListGroup > 0 && Number.isSafeInteger(pastedListLevel) && pastedListLevel >= 0 && pastedListLevel <= 8 && (pastedListKind === "bullet" || pastedListKind === "numbered") ? {
+				group: pastedListGroup,
+				level: pastedListLevel,
+				kind: pastedListKind,
+				...Number.isSafeInteger(pastedListStart) && pastedListStart > 0 ? { start: pastedListStart } : {}
+			} : void 0;
 			const attrs = {
 				...paraId ? { paraId } : {},
 				...alignment ? { alignment } : {},
 				...alignmentFromStyle ? { alignmentFromStyle } : {},
 				...styleId ? { styleId } : {},
+				...pastedHtmlList ? { _pastedHtmlList: pastedHtmlList } : {},
 				...Number.isSafeInteger(tableOfContentsLevel) && tableOfContentsLevel > 0 ? { _tableOfContentsLevel: tableOfContentsLevel } : {},
 				...sectionBreakType ? { _sectionProperties: mintSectionProperties(sectionBreakType) } : {}
 			};
@@ -387,6 +404,51 @@ function setParagraphSpacingAttr(side, twips) {
 		return true;
 	};
 }
+const DIRECT_PARAGRAPH_TOGGLES = [
+	"outlineLevel",
+	"borders",
+	"shading",
+	"tabs",
+	"keepNext",
+	"keepLines",
+	"widowControl",
+	"pageBreakBefore",
+	"contextualSpacing"
+];
+/** The attrs a paragraph states itself, over whatever style it reads. */
+function directParagraphAttrs(attrs) {
+	const direct = {};
+	const alignment = directParagraphAlignment(attrs);
+	if (alignment !== void 0) direct["alignment"] = alignment;
+	const spacing = directParagraphSpacing(attrs);
+	for (const key of [
+		"spaceBefore",
+		"spaceAfter",
+		"lineSpacing",
+		"lineSpacingRule"
+	]) if (spacing?.[key] !== void 0) direct[key] = spacing[key];
+	const indentation = directParagraphIndentation(attrs);
+	if (indentation?.indentLeft !== void 0) direct["indentLeft"] = indentation.indentLeft;
+	if (indentation?.indentRight !== void 0) direct["indentRight"] = indentation.indentRight;
+	if (indentation?.indentFirstLine !== void 0) {
+		direct["indentFirstLine"] = Math.abs(indentation.indentFirstLine);
+		direct["hangingIndent"] = indentation.hangingIndent === true;
+	}
+	const original = attrs._originalFormatting;
+	for (const key of DIRECT_PARAGRAPH_TOGGLES) if (original?.[key] !== void 0) direct[key] = attrs[key];
+	return direct;
+}
+/**
+* The indentation a restyled paragraph still states itself: a field its
+* source stated that the new style's attrs keep a value for. Every other
+* field now reads the style's value, which a save leaves to the style.
+*/
+function restyledIndentation(styleAttrs, originalFormatting) {
+	const stated = {};
+	if (originalFormatting?.indentLeft !== void 0 && typeof styleAttrs.indentLeft === "number") stated.indentLeft = styleAttrs.indentLeft;
+	if (originalFormatting?.indentFirstLine !== void 0 && typeof styleAttrs.indentFirstLine === "number") stated.indentFirstLine = styleAttrs.indentFirstLine;
+	return stated;
+}
 function setParagraphAttrsCmd(attrs) {
 	return (state, dispatch) => {
 		const { $from, $to } = state.selection;
@@ -467,9 +529,10 @@ function makeDecreaseIndent(amount = 720) {
 				seen.add(pos);
 				const currentIndent = node.attrs["indentLeft"] || 0;
 				const newIndent = Math.max(0, currentIndent - amount);
+				const numbered = paragraphNumberingReferenceId(expectParagraphAttrs(node).numPr ?? void 0) !== void 0;
 				tr = tr.setNodeMarkup(pos, void 0, {
 					...node.attrs,
-					indentLeft: newIndent > 0 ? newIndent : null
+					indentLeft: newIndent > 0 || numbered ? newIndent : null
 				});
 			}
 		});
@@ -477,79 +540,61 @@ function makeDecreaseIndent(amount = 720) {
 		return true;
 	};
 }
-function makeApplyStyle(schema) {
+function makeApplyStyle() {
 	return (styleId, resolvedAttrs) => (state, dispatch) => {
 		const { $from, $to } = state.selection;
 		if (!dispatch) return true;
 		let tr = state.tr;
 		const seen = /* @__PURE__ */ new Set();
-		const styleMarks = [];
-		if (resolvedAttrs?.runFormatting) {
-			const rpr = resolvedAttrs.runFormatting;
-			if (rpr.bold && schema.marks["bold"]) styleMarks.push(schema.marks["bold"].create());
-			if (rpr.italic && schema.marks["italic"]) styleMarks.push(schema.marks["italic"].create());
-			if (rpr.fontSize && schema.marks["fontSize"]) styleMarks.push(schema.marks["fontSize"].create({ size: rpr.fontSize }));
-			if (rpr.fontFamily && schema.marks["fontFamily"]) styleMarks.push(schema.marks["fontFamily"].create({
-				ascii: rpr.fontFamily.ascii,
-				hAnsi: rpr.fontFamily.hAnsi,
-				asciiTheme: rpr.fontFamily.asciiTheme
-			}));
-			if (rpr.color && !rpr.color.auto && schema.marks["textColor"]) styleMarks.push(schema.marks["textColor"].create({
-				rgb: rpr.color.rgb,
-				themeColor: rpr.color.themeColor,
-				themeTint: rpr.color.themeTint,
-				themeShade: rpr.color.themeShade
-			}));
-			if (rpr.underline && rpr.underline.style !== "none" && schema.marks["underline"]) styleMarks.push(schema.marks["underline"].create({
-				style: rpr.underline.style,
-				color: rpr.underline.color
-			}));
-			if ((rpr.strike || rpr.doubleStrike) && schema.marks["strike"]) styleMarks.push(schema.marks["strike"].create({ double: rpr.doubleStrike || false }));
-		}
-		const styleControlledMarks = [
-			schema.marks["bold"],
-			schema.marks["italic"],
-			schema.marks["fontSize"],
-			schema.marks["fontFamily"],
-			schema.marks["textColor"],
-			schema.marks["underline"],
-			schema.marks["strike"]
-		].filter(Boolean);
 		state.doc.nodesBetween($from.pos, $to.pos, (node, pos) => {
 			if (node.type.name === "paragraph" && !seen.has(pos)) {
 				seen.add(pos);
 				const newAttrs = {
 					...node.attrs,
 					styleId,
-					_tableOfContentsLevel: tableOfContentsStyleLevel({ styleId }) ?? null
+					_tableOfContentsLevel: styleId ? tableOfContentsStyleLevel({ styleId }) ?? null : null
 				};
 				if (resolvedAttrs) {
-					Object.assign(newAttrs, paragraphAttrsFromResolvedStyle(resolvedAttrs, {
-						styleId,
+					const current = expectParagraphAttrs(node);
+					const styleAttrs = paragraphAttrsFromResolvedStyle(resolvedAttrs, {
+						styleId: styleId ?? "",
 						...resolvedAttrs.styleName ? { styleName: resolvedAttrs.styleName } : {}
-					}));
-					const originalFormatting = {
-						...expectParagraphAttrs(node)._originalFormatting,
-						styleId
-					};
-					Reflect.deleteProperty(originalFormatting, "alignment");
-					newAttrs["_originalFormatting"] = withDirectParagraphSpacing(originalFormatting, void 0);
-					newAttrs["spacingExplicit"] = null;
+					});
+					Object.assign(newAttrs, styleAttrs);
+					if (!styleId) newAttrs["_tableOfContentsLevel"] = null;
+					const originalFormatting = { ...current._originalFormatting };
+					if (styleId) originalFormatting.styleId = styleId;
+					else Reflect.deleteProperty(originalFormatting, "styleId");
+					let restyledOriginal = originalFormatting;
+					if (styleId) {
+						Reflect.deleteProperty(originalFormatting, "alignment");
+						Reflect.deleteProperty(originalFormatting, "outlineLevel");
+						restyledOriginal = withDirectParagraphSpacing(originalFormatting, void 0);
+						newAttrs["spacingExplicit"] = null;
+					} else Object.assign(newAttrs, directParagraphAttrs(current));
+					newAttrs["_originalFormatting"] = restyledOriginal ?? null;
 					const listAttrs = listAttrsFromResolvedStyle(resolvedAttrs, resolvedAttrs.numbering);
+					const directNumId = current.numPrFromStyle == null ? paragraphNumberingReferenceId(current.numPr ?? void 0) : void 0;
 					if (listAttrs) Object.assign(newAttrs, listAttrs);
+					else if (isStyleSourcedParagraphNumbering(current.numPr, current.numPrFromStyle)) Object.assign(newAttrs, CLEARED_LIST_RENDERING_ATTRS, {
+						numPr: null,
+						numPrFromStyle: null
+					});
+					else if (directNumId !== void 0) Object.assign(newAttrs, listLevelIndentAttrPatch(restyledIndentation(styleAttrs, restyledOriginal), {
+						numId: directNumId,
+						ilvl: paragraphNumberingLevel(current.numPr ?? void 0) ?? 0
+					}, resolvedAttrs.numbering ?? getDocumentNumbering(state)));
 				}
 				tr = tr.setNodeMarkup(pos, void 0, newAttrs);
-				if (resolvedAttrs) {
-					const paragraphStart = pos + 1;
-					const paragraphEnd = pos + node.nodeSize - 1;
-					if (paragraphEnd > paragraphStart) {
-						for (const markType of styleControlledMarks) tr = tr.removeMark(paragraphStart, paragraphEnd, markType);
-						for (const mark of styleMarks) tr = tr.addMark(paragraphStart, paragraphEnd, mark);
-					}
-				}
+				rebaseParagraphRuns({
+					tr,
+					position: pos,
+					previous: node,
+					styleResolver: getDocumentStyleResolver(state),
+					storedMarks: state.storedMarks ?? state.selection.$from.marks()
+				});
 			}
 		});
-		if (styleMarks.length > 0) tr = tr.setStoredMarks(styleMarks);
 		dispatch(tr.scrollIntoView());
 		return true;
 	};
@@ -582,8 +627,8 @@ const ParagraphExtension = createNodeExtension({
 	name: "paragraph",
 	schemaNodeName: "paragraph",
 	nodeSpec: paragraphNodeSpec,
-	onSchemaReady(ctx) {
-		const applyStyleFn = makeApplyStyle(ctx.schema);
+	onSchemaReady() {
+		const applyStyleFn = makeApplyStyle();
 		return { commands: {
 			setAlignment: (alignment) => makeSetAlignment(alignment),
 			alignLeft: () => makeSetAlignment("left"),
@@ -605,10 +650,18 @@ const ParagraphExtension = createNodeExtension({
 				hangingIndent: hanging ?? false
 			}),
 			applyStyle: (styleId, resolvedAttrs) => applyStyleFn(styleId, resolvedAttrs),
-			clearStyle: () => setParagraphAttrsCmd({
-				styleId: null,
-				_tableOfContentsLevel: null
-			}),
+			clearStyle: () => (state, dispatch) => {
+				const resolver = getDocumentStyleResolver(state);
+				if (!resolver) return applyStyleFn(null)(state, dispatch);
+				const resolved = resolver.resolveParagraphStyle(null);
+				const styleName = resolver.getDefaultParagraphStyle()?.name;
+				return applyStyleFn(null, {
+					...resolved.paragraphFormatting && { paragraphFormatting: resolved.paragraphFormatting },
+					...resolved.runFormatting && { runFormatting: resolved.runFormatting },
+					...styleName && { styleName },
+					numbering: getDocumentNumbering(state)
+				})(state, dispatch);
+			},
 			insertSectionBreak: (breakType) => setSectionBreakType(breakType),
 			removeSectionBreak: () => removeSectionBreakAtSelection,
 			generateTOC: ({ title }) => (state, dispatch) => {

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

@@ -1,7 +1,7 @@
 import { mergeTextFormatting } from "../../../utils/textFormattingMerge.js";
 import { expectCharacterStyleMarkAttrs, expectRunFormattingOverrideMarkAttrs } from "../../attrs/index.js";
 import { keepSectionBreaksOnSurvivingMarks } from "../../commands/sectionBreak.js";
-import { getDocumentStyleResolver } from "../../plugins/documentStyles.js";
+import { getDocumentStyleResolver } from "../../plugins/documentStyleState.js";
 import { RUN_FORMATTING_MARK_NAMES } from "../../runFormattingMarkNames.js";
 import { authoredRunFormattingFromAttrs } from "../../runFormattingProvenance.js";
 import { paragraphAttrsFromResolvedStyle } from "../../styles/resolvedStyleAttrs.js";
@@ -63,6 +63,9 @@ const INHERITED_PARA_ATTRS = [
 	"snapToGrid",
 	"spaceAfter",
 	"spaceBefore",
+	"spacingExplicit",
+	"spacingFromDocDefaults",
+	"spacingFromImplicitDefaultStyle",
 	"contextualSpacing"
 ];
 /** Style formatting needed when the caret has no marks of its own. */

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

@@ -2,6 +2,26 @@ import { createExtension } from "../create.js";
 import { textFormattingToMarks } from "../marks/markUtils.js";
 import { Plugin, PluginKey } from "prosemirror-state";
 //#region src/prosemirror/extensions/features/EmptyParagraphFormatExtension.ts
+/**
+* EmptyParagraphFormat — re-establishes stored marks for an empty styled
+* paragraph so typed text inherits the style's run formatting (bold, color,
+* size, font).
+*
+* Why this exists:
+* An empty paragraph carries its run defaults in the `defaultTextFormatting`
+* attr (set at load by `toProseDoc`, and when a style is applied via
+* `applyStyle`). The visible painter only derives font/size from that attr,
+* so an empty heading renders a correctly sized caret — but typed text only
+* becomes bold/colored if it carries real marks. Those marks live in
+* `storedMarks`, which ProseMirror clears on the next selection change
+* (e.g. when the style picker dropdown returns focus to the editor).
+*
+* This plugin watches for the caret sitting in an empty paragraph with no
+* stored marks and re-derives them from `defaultTextFormatting`, but only
+* when the defaults carry formatting the painter can't reproduce on its own
+* (bold/italic/color/…). Plain body paragraphs (font + size only) are left
+* untouched so ordinary typed text stays mark-free and serializes cleanly.
+*/
 const emptyParagraphFormatKey = new PluginKey("emptyParagraphFormat");
 /**
 * Run-formatting properties the painter does NOT reproduce from
@@ -15,7 +35,7 @@ const FONT_ONLY_DEFAULTS = /* @__PURE__ */ new Set(["fontFamily", "fontSize"]);
 function hasNonFontDefaults(dtf) {
 	return Object.entries(dtf).some(([property, value]) => value !== void 0 && !FONT_ONLY_DEFAULTS.has(property));
 }
-function createEmptyParagraphFormatPlugin(schema) {
+function createEmptyParagraphFormatPlugin() {
 	return new Plugin({
 		key: emptyParagraphFormatKey,
 		appendTransaction(transactions, _oldState, newState) {
@@ -27,6 +47,7 @@ function createEmptyParagraphFormatPlugin(schema) {
 			if (para.type.name !== "paragraph" || para.content.size !== 0) return null;
 			const dtf = para.attrs["defaultTextFormatting"];
 			if (!dtf || !hasNonFontDefaults(dtf)) return null;
+			const { schema } = newState;
 			const marks = textFormattingToMarks(dtf, schema);
 			if (dtf.styleId) marks.push(schema.mark("characterStyle", { styleId: dtf.styleId }));
 			if (marks.length === 0) return null;
@@ -38,8 +59,8 @@ function createEmptyParagraphFormatPlugin(schema) {
 }
 const EmptyParagraphFormatExtension = createExtension({
 	name: "emptyParagraphFormat",
-	onSchemaReady(ctx) {
-		return { plugins: [createEmptyParagraphFormatPlugin(ctx.schema)] };
+	onSchemaReady() {
+		return { plugins: [createEmptyParagraphFormatPlugin()] };
 	}
 });
 //#endregion

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

@@ -0,0 +1,20 @@
+import { Extension } from "../types.js";
+//#region src/prosemirror/extensions/features/JoinedRunStyleExtension.d.ts
+/**
+ * Runs that a join moves into another paragraph take that paragraph's style.
+ *
+ * Deleting across a paragraph break (Backspace or Delete at the break, a
+ * deletion or typing over a selection that spans paragraphs) runs the later
+ * paragraph's remaining text on into the earlier one. A run's direct
+ * formatting is its own and stays; what the later paragraph's style lent it
+ * does not travel, and it reads in the style of the paragraph it now belongs
+ * to. The document styles plugin re-reads those runs after an ordinary edit.
+ *
+ * A transaction that re-reads the runs it moves itself (resolving a tracked
+ * change, an operation that merges paragraphs) says so with
+ * {@link JOINED_RUNS_RESTYLED_META}, and is left as it is.
+ */
+declare const JOINED_RUNS_RESTYLED_META = "joinedRunsRestyled";
+declare const JoinedRunStyleExtension: (options?: Partial<{}> | undefined) => Extension;
+//#endregion
+export { JOINED_RUNS_RESTYLED_META, JoinedRunStyleExtension };

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

@@ -0,0 +1,43 @@
+import { createExtension } from "../create.js";
+import { Plugin, PluginKey } from "prosemirror-state";
+//#region src/prosemirror/extensions/features/JoinedRunStyleExtension.ts
+/**
+* Runs that a join moves into another paragraph take that paragraph's style.
+*
+* Deleting across a paragraph break (Backspace or Delete at the break, a
+* deletion or typing over a selection that spans paragraphs) runs the later
+* paragraph's remaining text on into the earlier one. A run's direct
+* formatting is its own and stays; what the later paragraph's style lent it
+* does not travel, and it reads in the style of the paragraph it now belongs
+* to. The document styles plugin re-reads those runs after an ordinary edit.
+*
+* A transaction that re-reads the runs it moves itself (resolving a tracked
+* change, an operation that merges paragraphs) says so with
+* {@link JOINED_RUNS_RESTYLED_META}, and is left as it is.
+*/
+const JOINED_RUNS_RESTYLED_META = "joinedRunsRestyled";
+const pastedTableEndKey = new PluginKey("pastedTableEnd");
+/**
+* A table pasted over a story's last paragraph leaves that paragraph, emptied,
+* after it: a story ends with a paragraph, and the paste replaced the words,
+* not the break that ends the story. ProseMirror's paste replaces the whole
+* paragraph, so the empty one is put back.
+*/
+const createPastedTableEndPlugin = () => new Plugin({
+	key: pastedTableEndKey,
+	appendTransaction(transactions, oldState, newState) {
+		if (!transactions.some((transaction) => transaction.docChanged && transaction.getMeta("uiEvent") === "paste")) return null;
+		if (newState.doc.lastChild?.type.spec["tableRole"] !== "table" || oldState.doc.lastChild?.type.name !== "paragraph") return null;
+		const paragraph = newState.schema.nodes["paragraph"]?.createAndFill();
+		return paragraph ? newState.tr.insert(newState.doc.content.size, paragraph) : null;
+	}
+});
+const JoinedRunStyleExtension = createExtension({
+	name: "joinedRunStyle",
+	defaultOptions: {},
+	onSchemaReady() {
+		return { plugins: [createPastedTableEndPlugin()] };
+	}
+});
+//#endregion
+export { JOINED_RUNS_RESTYLED_META, JoinedRunStyleExtension };