@stll/folio-core 0.52.0 → 0.54.0

package/dist/prosemirror/attrs/index.js

@@ -374,6 +374,7 @@ const readPreservedBlockAttrs = (node) => {
 	const issues = [];
 	expectNodeType(node, "preservedBlock", issues);
 	requiredString(attrs, "xml", "preservedBlock.attrs.xml", issues);
+	optionalString(attrs, "readerText", "preservedBlock.attrs.readerText", issues);
 	return attrsResult(attrs, issues);
 };
 const expectPreservedBlockAttrs = (node) => expectCachedNodeAttrs(node, preservedBlockAttrsCache, readPreservedBlockAttrs, "preservedBlock attrs");
@@ -402,6 +403,7 @@ const readTableAttrsUncached = (node) => {
 	optionalRecord(attrs, "_originalFormatting", "table.attrs._originalFormatting", issues);
 	optionalPositionedBookmarks(attrs, "table.attrs._bookmarks", issues);
 	optionalTablePreservedMarkup(attrs, "_preserved", "table.attrs._preserved", issues);
+	optionalTableContentCarriers(attrs, "carrierStack", "table.attrs.carrierStack", issues);
 	return attrsResult(attrs, issues);
 };
 const readTableAttrs = memoizeNodeAttrsReader(readTableAttrsUncached);
@@ -426,6 +428,7 @@ const readTableRowAttrsUncached = (node) => {
 	optionalPreservedAttributes(attrs, "_preservedAttributes", "tableRow.attrs._preservedAttributes", issues);
 	optionalPositionedBookmarks(attrs, "tableRow.attrs._bookmarks", issues);
 	optionalContentControls(attrs, "tableRow.attrs.contentControls", issues);
+	optionalTableContentCarriers(attrs, "carrierStack", "tableRow.attrs.carrierStack", issues);
 	optionalTablePreservedMarkup(attrs, "_preserved", "tableRow.attrs._preserved", issues);
 	return attrsResult(attrs, issues);
 };
@@ -461,6 +464,7 @@ const readTableCellAttrs = (node) => {
 	optionalRecord(attrs, "_originalFormatting", "tableCell.attrs._originalFormatting", issues);
 	optionalTableCellRevision(attrs, issues);
 	optionalContentControls(attrs, "tableCell.attrs.contentControls", issues);
+	optionalTableContentCarriers(attrs, "carrierStack", "tableCell.attrs.carrierStack", issues);
 	optionalBoolean(attrs, "_preserveVMergeRestart", "tableCell.attrs._preserveVMergeRestart", issues);
 	return attrsResult(attrs, issues);
 };
@@ -529,6 +533,81 @@ const readImageAttrs = (node) => {
 	return attrsResult(attrs, issues);
 };
 const expectImageAttrs = (node) => expectCachedNodeAttrs(node, imageAttrsCache, readImageAttrs, "image attrs");
+const validateEmptyFieldResultRuns = (value, issues) => {
+	if (!Array.isArray(value) || value.length === 0) {
+		issues.push({
+			path: "field.attrs._docxEmptyResultRuns",
+			message: "Expected a nonempty array of empty runs."
+		});
+		return;
+	}
+	for (const [index, run] of value.entries()) {
+		const path = `field.attrs._docxEmptyResultRuns[${index}]`;
+		if (!isRecord(run) || run["type"] !== "run") {
+			issues.push({
+				path,
+				message: "Expected a run."
+			});
+			continue;
+		}
+		const content = run["content"];
+		if (!Array.isArray(content) || !content.every((item) => isRecord(item) && item["type"] === "text" && item["text"] === "")) issues.push({
+			path: `${path}.content`,
+			message: "Expected only empty text."
+		});
+		const formatting = run["formatting"];
+		if (formatting !== void 0) if (!isRecord(formatting)) issues.push({
+			path: `${path}.formatting`,
+			message: "Expected formatting object."
+		});
+		else validateTextFormatting(formatting, `${path}.formatting`, issues);
+		optionalPropertyChanges(run, "propertyChanges", `${path}.propertyChanges`, issues, ["runPropertyChange"]);
+		optionalPreservedAttributes(run, "preservedAttributes", `${path}.preservedAttributes`, issues);
+	}
+};
+const isValidEmptyFieldResultRuns = (value) => {
+	const issues = [];
+	validateEmptyFieldResultRuns(value, issues);
+	return issues.length === 0;
+};
+const isFieldCodeContent = (value) => {
+	if (!isRecord(value)) return false;
+	switch (value["type"]) {
+		case "text":
+		case "instrText": return typeof value["text"] === "string";
+		case "fieldChar": return value["charType"] === "begin" || value["charType"] === "separate" || value["charType"] === "end";
+		case "preservedXml": return typeof value["xml"] === "string" && isSafePreservedChildXml(value["xml"]) && typeof value["text"] === "string";
+		case "symbol": return typeof value["font"] === "string" && typeof value["char"] === "string";
+		case "footnoteRef":
+		case "endnoteRef": return typeof value["id"] === "number";
+		case "drawing": return isRecord(value["image"]);
+		case "shape": return isRecord(value["shape"]);
+		case "tab":
+		case "break":
+		case "softHyphen":
+		case "noBreakHyphen":
+		case "renderedPageBreak": return true;
+		default: return false;
+	}
+};
+const isValidFieldCode = (value) => {
+	if (!isRecord(value) || typeof value["instruction"] !== "string") return false;
+	const runs = value["runs"];
+	if (!Array.isArray(runs) || runs.length === 0) return false;
+	const issues = [];
+	for (const [index, run] of runs.entries()) {
+		if (!isRecord(run) || run["type"] !== "run" || !Array.isArray(run["content"])) return false;
+		if (!run["content"].every(isFieldCodeContent)) return false;
+		const path = `field.attrs._docxFieldCode.runs[${index}]`;
+		if (run["formatting"] !== void 0) {
+			if (!isRecord(run["formatting"])) return false;
+			validateTextFormatting(run["formatting"], `${path}.formatting`, issues);
+		}
+		optionalPropertyChanges(run, "propertyChanges", `${path}.propertyChanges`, issues, ["runPropertyChange"]);
+		optionalPreservedAttributes(run, "preservedAttributes", `${path}.preservedAttributes`, issues);
+	}
+	return issues.length === 0;
+};
 const readFieldAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -541,6 +620,34 @@ const readFieldAttrs = (node) => {
 	optionalBoolean(attrs, "fldLock", "field.attrs.fldLock", issues);
 	optionalBoolean(attrs, "dirty", "field.attrs.dirty", issues);
 	optionalBoolean(attrs, "fieldResultIsFallback", "field.attrs.fieldResultIsFallback", issues);
+	optionalString(attrs, "formFieldDataXml", "field.attrs.formFieldDataXml", issues);
+	if (attrs["fieldKind"] === "simple") {
+		if (attrs["fieldResultIsFallback"] !== void 0 && attrs["fieldResultIsFallback"] !== null) issues.push({
+			path: "field.attrs.fieldResultIsFallback",
+			message: "Simple fields cannot have a synthesized complex-field result."
+		});
+		if (attrs["formFieldDataXml"] !== void 0 && attrs["formFieldDataXml"] !== null) issues.push({
+			path: "field.attrs.formFieldDataXml",
+			message: "Simple fields cannot carry complex-field form data."
+		});
+	}
+	const emptyResultRuns = attrs["_docxEmptyResultRuns"];
+	if (emptyResultRuns !== void 0 && emptyResultRuns !== null) validateEmptyFieldResultRuns(emptyResultRuns, issues);
+	const fieldCode = attrs["_docxFieldCode"];
+	if (fieldCode !== void 0 && fieldCode !== null && !isValidFieldCode(fieldCode)) issues.push({
+		path: "field.attrs._docxFieldCode",
+		message: "Expected source field code runs."
+	});
+	if (attrs["fieldKind"] === "simple") {
+		if (fieldCode !== void 0 && fieldCode !== null) issues.push({
+			path: "field.attrs._docxFieldCode",
+			message: "Simple fields cannot carry complex-field code runs."
+		});
+		if (attrs["fieldResultIsFallback"] !== void 0 && attrs["fieldResultIsFallback"] !== null) issues.push({
+			path: "field.attrs.fieldResultIsFallback",
+			message: "Simple fields cannot have a synthesized complex-field result."
+		});
+	}
 	return attrsResult(attrs, issues);
 };
 const expectFieldAttrs = (node) => expectCachedNodeAttrs(node, fieldAttrsCache, readFieldAttrs, "field attrs");
@@ -563,6 +670,17 @@ const readSdtAttrs = (node) => {
 };
 const expectSdtAttrs = (node) => expectCachedNodeAttrs(node, sdtAttrsCache, readSdtAttrs, "sdt attrs");
 const blockSdtAttrsCache = /* @__PURE__ */ new WeakMap();
+const blockCustomXmlAttrsCache = /* @__PURE__ */ new WeakMap();
+const readBlockCustomXmlAttrs = (node) => {
+	const attrs = attrsRecord(node.attrs);
+	const issues = [];
+	expectNodeType(node, "blockCustomXml", issues);
+	requiredString(attrs, "openingXml", "blockCustomXml.attrs.openingXml", issues);
+	requiredString(attrs, "closingXml", "blockCustomXml.attrs.closingXml", issues);
+	optionalBoolean(attrs, "_originallyEmpty", "blockCustomXml.attrs._originallyEmpty", issues);
+	return attrsResult(attrs, issues);
+};
+const expectBlockCustomXmlAttrs = (node) => expectCachedNodeAttrs(node, blockCustomXmlAttrsCache, readBlockCustomXmlAttrs, "blockCustomXml attrs");
 const readBlockSdtAttrs = (node) => {
 	const attrs = attrsRecord(node.attrs);
 	const issues = [];
@@ -1724,6 +1842,57 @@ const optionalContentControls = (attrs, path, issues) => {
 		requiredString(entry, "sdtType", `${entryPath}.sdtType`, issues);
 	}
 };
+const optionalTableContentCarriers = (attrs, key, path, issues) => {
+	const value = attrs[key];
+	if (value === void 0 || value === null) return;
+	if (!Array.isArray(value)) {
+		issues.push({
+			path,
+			message: "Expected an array."
+		});
+		return;
+	}
+	for (const [index, carrier] of value.entries()) {
+		const carrierPath = `${path}[${index}]`;
+		if (!isRecord(carrier)) {
+			issues.push({
+				path: carrierPath,
+				message: "Expected an object."
+			});
+			continue;
+		}
+		if (carrier["type"] === "customXml") {
+			const wrapper = carrier["wrapper"];
+			if (!isRecord(wrapper)) {
+				issues.push({
+					path: `${carrierPath}.wrapper`,
+					message: "Expected an object."
+				});
+				continue;
+			}
+			requiredNumber(wrapper, "id", `${carrierPath}.wrapper.id`, issues);
+			requiredString(wrapper, "openingXml", `${carrierPath}.wrapper.openingXml`, issues);
+			requiredString(wrapper, "closingXml", `${carrierPath}.wrapper.closingXml`, issues);
+			continue;
+		}
+		if (carrier["type"] === "sdt") {
+			const properties = carrier["properties"];
+			if (!isRecord(properties)) {
+				issues.push({
+					path: `${carrierPath}.properties`,
+					message: "Expected an object."
+				});
+				continue;
+			}
+			requiredString(properties, "sdtType", `${carrierPath}.properties.sdtType`, issues);
+			continue;
+		}
+		issues.push({
+			path: `${carrierPath}.type`,
+			message: "Expected \"customXml\" or \"sdt\"."
+		});
+	}
+};
 /** A table sink entry may itself sit inside a row- or cell-level control. */
 const optionalTablePreservedMarkup = (attrs, key, path, issues) => {
 	optionalPreservedMarkup(attrs, key, path, issues);
@@ -1821,6 +1990,7 @@ const optionalPreservedMarkup = (attrs, key, path, issues) => {
 		}
 		requiredNumber(entry, "index", `${entryPath}.index`, issues);
 		requiredString(entry, "xml", `${entryPath}.xml`, issues);
+		optionalTableContentCarriers(entry, "carrierStack", `${entryPath}.carrierStack`, issues);
 		const xml = entry["xml"];
 		if (typeof xml === "string" && !isSafePreservedChildXml(xml)) issues.push({
 			path: `${entryPath}.xml`,
@@ -1855,6 +2025,7 @@ const optionalPositionedBookmarks = (attrs, path, issues) => {
 			continue;
 		}
 		validateNonNegativeSafeInteger(entry["index"], `${entryPath}.index`, issues);
+		optionalTableContentCarriers(entry, "carrierStack", `${entryPath}.carrierStack`, issues);
 		const marker = entry["marker"];
 		if (!isRecord(marker)) {
 			issues.push({
@@ -2839,4 +3010,4 @@ const optionalEmptyHyperlinkArray = (value, issues) => {
 	}
 };
 //#endregion
-export { expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };
+export { expectBlockCustomXmlAttrs, expectBlockSdtAttrs, expectCharacterSpacingMarkAttrs, expectCharacterStyleMarkAttrs, expectCommentMarkAttrs, expectEmphasisMarkAttrs, expectFieldAttrs, expectFontFamilyMarkAttrs, expectFontSizeMarkAttrs, expectFootnoteRefMarkAttrs, expectHardBreakAttrs, expectHighlightMarkAttrs, expectHyperlinkMarkAttrs, expectImageAttrs, expectInlineWrapperMarkAttrs, expectLanguageMarkAttrs, expectMathAttrs, expectPageBreakRunAttrs, expectParagraphAttrs, expectPreservedBlockAttrs, expectPreservedXmlAttrs, expectRunFormattingOverrideMarkAttrs, expectRunIdentityMarkAttrs, expectRunPropertyChangeMarkAttrs, expectRunShadingMarkAttrs, expectSdtAttrs, expectShapeAttrs, expectStrikeMarkAttrs, expectSymbolAttrs, expectTabAttrs, expectTableAttrs, expectTableCellAttrs, expectTableRowAttrs, expectTextBoxAttrs, expectTextColorMarkAttrs, expectTextEffectMarkAttrs, expectTrackedChangeMarkAttrs, expectUnderlineMarkAttrs, isTrackedRevisionAncestorArray, isValidEmptyFieldResultRuns, isValidFieldCode, mergeImageAttrs, mergeParagraphAttrs, mergeTableAttrs, mergeTableCellAttrs, mergeTableRowAttrs, readBlockCustomXmlAttrs, readBlockSdtAttrs, readCharacterSpacingMarkAttrs, readCharacterStyleMarkAttrs, readCommentMarkAttrs, readEmphasisMarkAttrs, readFieldAttrs, readFontFamilyMarkAttrs, readFontSizeMarkAttrs, readFootnoteRefMarkAttrs, readHardBreakAttrs, readHighlightMarkAttrs, readHyperlinkMarkAttrs, readImageAttrs, readInlineWrapperMarkAttrs, readInlineWrapperStack, readLanguageMarkAttrs, readMathAttrs, readPageBreakRunAttrs, readParagraphAttrs, readPreservedBlockAttrs, readPreservedXmlAttrs, readRunFormattingOverrideMarkAttrs, readRunIdentityMarkAttrs, readRunPropertyChangeMarkAttrs, readRunShadingMarkAttrs, readSdtAttrs, readShapeAttrs, readStrikeMarkAttrs, readSymbolAttrs, readTabAttrs, readTableAttrs, readTableCellAttrs, readTableRowAttrs, readTextBoxAttrs, readTextColorMarkAttrs, readTextEffectMarkAttrs, readTrackedChangeMarkAttrs, readUnderlineMarkAttrs };

package/dist/prosemirror/clearRunColor.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "prosemirror-state";
+//#region src/prosemirror/clearRunColor.d.ts
+/** Clearing direct color reveals the run's character/paragraph style color. */
+declare const clearRunColor: () => Command;
+//#endregion
+export { clearRunColor };

package/dist/prosemirror/clearRunColor.js

@@ -0,0 +1,46 @@
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+import { applyMarksToRunFormattingRepresentation, selectRunFormattingCarrierRepresentations } from "./runFormattingInlineCarriers.js";
+import { readAuthoredRunFormatting, reconcileRunFormattingMarks } from "./runFormattingReconciliation.js";
+import { paragraphRunStyleContextAt } from "./runStyleFormatting.js";
+//#region src/prosemirror/clearRunColor.ts
+/** Clearing direct color reveals the run's character/paragraph style color. */
+const clearRunColor = () => (state, dispatch) => {
+	if (!dispatch) return true;
+	const styleResolver = getDocumentStyleResolver(state);
+	const tr = state.tr;
+	const { from, to, empty } = state.selection;
+	const clearedMarks = (node, position) => {
+		const context = paragraphRunStyleContextAt({
+			doc: state.doc,
+			pos: position,
+			styleResolver
+		});
+		const { color: _color, ...authoredFormatting } = readAuthoredRunFormatting({
+			context,
+			marks: node.marks,
+			styleResolver
+		});
+		return reconcileRunFormattingMarks({
+			authoredFormatting,
+			context,
+			node,
+			styleResolver
+		});
+	};
+	if (empty) {
+		const node = state.schema.text(" ", state.storedMarks ?? state.selection.$from.marks());
+		tr.setStoredMarks(clearedMarks(node, from));
+	} else for (const representation of selectRunFormattingCarrierRepresentations({
+		doc: state.doc,
+		from,
+		to
+	})) applyMarksToRunFormattingRepresentation({
+		tr,
+		representation,
+		marks: clearedMarks(representation.node, representation.position)
+	});
+	dispatch(tr.scrollIntoView());
+	return true;
+};
+//#endregion
+export { clearRunColor };

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

@@ -32,7 +32,8 @@ declare function acceptChange(from: number, to: number): Command;
  */
 declare function rejectChange(from: number, to: number): Command;
 /**
- * Accept all tracked changes in the document.
+ * Accept all tracked changes in the document. Returns `false` while pending
+ * suggestions are present because this command cannot restage them.
  */
 declare function acceptAllChanges(): Command;
 /**
@@ -42,15 +43,11 @@ declare function rejectAllChanges(): Command;
 /**
  * Resolve a complete state synchronously for a headless reader or writer.
  *
- * @internal The replacement transaction is consumed here and never exposed:
- * it is deliberately not an editor command and must not be transported or
- * mapped through concurrent edits.
+ * Uses the same single-step resolver as the interactive editor command.
  */
 declare function resolveAllChangesInHeadlessState(state: EditorState, mode: ResolveMode): EditorState;
 /**
- * Resolve through the editor command path when a caller must map a position in
- * the reviewed document back to the tracked source. The bulk resolver is
- * faster, but deliberately replaces inline content without retaining mapping.
+ * Resolve a story and retain its position map for callers addressing the tracked source.
  */
 declare const resolveAllChangesInHeadlessStateWithMapping: (state: EditorState, mode: ResolveMode) => {
   state: EditorState;
@@ -109,6 +106,8 @@ type FolioSuggestion = {
  * accepting it applies (tracked vs direct).
  */
 declare function getSuggestions(state: EditorState): FolioSuggestion[];
+/** The suggestion a revision belongs to, or `null` for an ordinary tracked change. */
+declare function suggestionIdOfRevision(state: EditorState, revisionId: number): string | null;
 /**
  * The document range covering every mark belonging to `suggestionId`, plus the
  * revision ids those marks carry. Returns null when the suggestion is absent
@@ -184,4 +183,4 @@ declare function findNextChange(state: EditorState, startPos: number): ChangeRan
  */
 declare function findPreviousChange(state: EditorState, startPos: number): ChangeRange | null;
 //#endregion
-export { AcceptSuggestionOptions, FolioSuggestion, ParagraphBoundaryChange, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState, resolveAllChangesInHeadlessStateWithMapping };
+export { AcceptSuggestionOptions, FolioSuggestion, ParagraphBoundaryChange, SuggestionAppliedAs, SuggestionKind, acceptAIEditRevision, acceptAllChanges, acceptAllSuggestions, acceptChange, acceptSuggestion, addCommentMark, findAIEditRevisionRange, findChangeAtPosition, findNextChange, findParagraphBoundaryChangeAtPosition, findPreviousChange, findSuggestionRange, getSuggestions, rejectAIEditRevision, rejectAllChanges, rejectAllSuggestions, rejectChange, rejectSuggestion, removeCommentMark, resolveAllChangesInHeadlessState, resolveAllChangesInHeadlessStateWithMapping, suggestionIdOfRevision };