@stll/folio-core 0.53.0 → 0.54.0

package/dist/prosemirror/listNumbering.d.ts

@@ -1,5 +1,5 @@
 import { ListKind, ListLevelFormat } from "../docx/listNumberingInstances.js";
-import { ParagraphAttrs, ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
+import { ParagraphAttrs } from "./schema/nodes.js";
 import { NumberingMap } from "../docx/numberingParser.js";
 import { Node, ResolvedPos } from "prosemirror-model";
 import { Command, EditorState, Transaction } from "prosemirror-state";
@@ -15,24 +15,6 @@ type ListRequest = {
   /** The value a new list's first item shows. */
   start?: number | undefined;
 };
-type PreviousFormatting = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
-/**
- * The list rendering a paragraph takes when a `w:pPrChange` is rejected. A
- * reject restores the recorded numbering, but the rendering attrs sit outside
- * the scope it restores wholesale, so a record that does not state them (one
- * written by an operation, or read from a file) would leave the rendering of
- * the numbering it undoes: a paragraph restored to no numbering still showed
- * the marker it was given. When the reject changes the numbering, the
- * rendering is recomputed from the restored numbering; otherwise it stays.
- */
-type RejectedListRenderingOptions = {
-  /** The paragraph's attrs before the reject. */
-  current: Pick<ParagraphAttrs, "numPr">;
-  /** The previous state the rejected record restores. */
-  previousFormatting: PreviousFormatting | null | undefined;
-  numbering: NumberingMap | null;
-};
-declare const rejectedListRenderingPatch: ({ current, previousFormatting, numbering }: RejectedListRenderingOptions) => Record<string, unknown>;
 /** Where the paragraphs a command numbers go. */
 type ListTarget = {
   numId: number;
@@ -56,7 +38,7 @@ type ResolveListTargetOptions = {
  */
 declare const resolveListTarget: ({ numbering, $from, $to, requests }: ResolveListTargetOptions) => ListTarget | null;
 /** A paragraph's attrs as an item of `numId` at `ilvl`, resolved in `numbering`. */
-declare const listItemAttrs: (attrs: Record<string, unknown>, { numId, ilvl }: {
+declare const listItemAttrs: (attrs: Readonly<ParagraphAttrs>, { numId, ilvl }: {
   numId: number;
   ilvl: number;
 }, numbering: NumberingMap) => Record<string, unknown>;
@@ -107,4 +89,4 @@ declare const NO_LIST_NUMBERING_MENU: {
  */
 declare const listNumberingMenuState: (state: EditorState) => ListNumberingMenuState;
 //#endregion
-export { ListNumberingMenuState, ListRequest, NO_LIST_NUMBERING_MENU, RejectedListRenderingOptions, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, rejectedListRenderingPatch, resolveListTarget, restartNumbering, setNumberingValue };
+export { ListNumberingMenuState, ListRequest, NO_LIST_NUMBERING_MENU, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, resolveListTarget, restartNumbering, setNumberingValue };

package/dist/prosemirror/listNumbering.js

@@ -1,13 +1,14 @@
 import { mintListInstance, restartListInstance } from "../docx/listNumberingInstances.js";
 import { createNumberingMap, isBulletLevel } from "../docx/numberingParser.js";
-import { paragraphNumberingLevel, paragraphNumberingReferenceId, sameStatedParagraphNumbering } from "../docx/numberingReference.js";
+import { paragraphNumberingLevel, paragraphNumberingReferenceId } from "../docx/numberingReference.js";
 import { expectParagraphAttrs } from "./attrs/index.js";
 import { paragraphPropertiesSnapshot } from "./commands/propertyChangeScope.js";
-import { CLEARED_LIST_RENDERING_ATTRS } from "./listMarker.js";
+import { listRenderingFor, recordsListRendering } from "./listRendering.js";
 import { LIST_RENDERING_ATTR_KEYS } from "./listRenderingAttrs.js";
+import { directParagraphIndentation } from "./paragraphIndentation.js";
 import { getDocumentNumbering } from "./plugins/documentNumbering.js";
 import { SUGGESTION_META, makeRevisionInfo } from "./plugins/suggestionMode.js";
-import { listAttrsFromNumbering } from "./styles/resolvedStyleAttrs.js";
+import { listAttrsFromNumbering, listLevelIndentAttrPatch } from "./styles/resolvedStyleAttrs.js";
 //#region src/prosemirror/listNumbering.ts
 const PARAGRAPH_NODE = "paragraph";
 /**
@@ -38,26 +39,6 @@ const originalListFormatting = (record, numbering) => {
 	original["numPr"] = record.numPr ?? null;
 	return original;
 };
-/** Whether a `w:pPrChange` record states the list rendering it had (a list command's does). */
-const recordsListRendering = (record) => LIST_RENDERING_ATTR_KEYS.some((key) => Object.hasOwn(record, key));
-/** Every list-rendering attr for `numPr`: its level's, or all cleared when it numbers nothing. */
-const listRenderingFor = (numPr, numbering) => {
-	const numId = paragraphNumberingReferenceId(numPr ?? void 0);
-	const rendering = numId === void 0 ? CLEARED_LIST_RENDERING_ATTRS : listAttrsFromNumbering({
-		numId,
-		ilvl: paragraphNumberingLevel(numPr ?? void 0) ?? 0
-	}, numbering);
-	const attrs = {};
-	for (const key of LIST_RENDERING_ATTR_KEYS) attrs[key] = rendering[key] ?? null;
-	return attrs;
-};
-const rejectedListRenderingPatch = ({ current, previousFormatting, numbering }) => {
-	const record = previousFormatting ?? {};
-	if (recordsListRendering(record)) return {};
-	const restored = record.numPr ?? void 0;
-	if (sameStatedParagraphNumbering(restored, current.numPr ?? void 0)) return {};
-	return listRenderingFor(restored, numbering);
-};
 const canonicalJson = (value) => JSON.stringify(value, (_key, nested) => nested !== null && typeof nested === "object" && !Array.isArray(nested) ? Object.fromEntries(Object.entries(nested).filter(([, entry]) => entry !== null && entry !== void 0).toSorted(([left], [right]) => left.localeCompare(right))) : nested);
 /**
 * `next` with the list change recorded as a tracked paragraph-property change.
@@ -203,6 +184,10 @@ const listItemAttrs = (attrs, { numId, ilvl }, numbering) => ({
 		numId,
 		ilvl
 	}, numbering),
+	...listLevelIndentAttrPatch(directParagraphIndentation(attrs), {
+		numId,
+		ilvl
+	}, numbering),
 	listImplicitChildLevelAdvances: attrs["listImplicitChildLevelAdvances"] ?? null,
 	listMarkerSecondSlotOffsetTwips: attrs["listMarkerSecondSlotOffsetTwips"] ?? null
 });
@@ -261,7 +246,7 @@ const moveItems = ({ state, items, numId, numbering }) => {
 		updates: items.map(({ pos, node, membership }) => ({
 			pos,
 			node,
-			next: listItemAttrs(node.attrs, {
+			next: listItemAttrs(expectParagraphAttrs(node), {
 				numId,
 				ilvl: membership.ilvl
 			}, numbering)
@@ -342,4 +327,4 @@ const listNumberingMenuState = (state) => restartNumbering(state) ? {
 	canContinue: continueNumbering(state)
 } : NO_LIST_NUMBERING_MENU;
 //#endregion
-export { NO_LIST_NUMBERING_MENU, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, rejectedListRenderingPatch, resolveListTarget, restartNumbering, setNumberingValue };
+export { NO_LIST_NUMBERING_MENU, applyParagraphUpdates, continueNumbering, listItemAttrs, listNumberingMenuState, resolveListTarget, restartNumbering, setNumberingValue };

package/dist/prosemirror/listRendering.d.ts

@@ -0,0 +1,27 @@
+import { ParagraphAttrs, ParagraphPropertyChangeAttrs } from "./schema/nodes.js";
+import { NumberingMap } from "../docx/numberingParser.js";
+//#region src/prosemirror/listRendering.d.ts
+type PreviousFormatting = NonNullable<ParagraphPropertyChangeAttrs["previousFormatting"]>;
+/** Whether a `w:pPrChange` record states the list rendering it had (a list command's does). */
+declare const recordsListRendering: (record: PreviousFormatting) => boolean;
+/** Every list-rendering attr for `numPr`: its level's, or all cleared when it numbers nothing. */
+declare const listRenderingFor: (numPr: PreviousFormatting["numPr"], numbering: NumberingMap | null) => Record<string, unknown>;
+/**
+ * The list rendering a paragraph takes when a `w:pPrChange` is rejected. A
+ * reject restores the recorded numbering, but the rendering attrs sit outside
+ * the scope it restores wholesale, so a record that does not state them (one
+ * written by an operation, or read from a file) would leave the rendering of
+ * the numbering it undoes: a paragraph restored to no numbering still showed
+ * the marker it was given. When the reject changes the numbering, the
+ * rendering is recomputed from the restored numbering; otherwise it stays.
+ */
+type RejectedListRenderingOptions = {
+  /** The paragraph's attrs before the reject. */
+  current: Pick<ParagraphAttrs, "numPr">;
+  /** The previous state the rejected record restores. */
+  previousFormatting: PreviousFormatting | null | undefined;
+  numbering: NumberingMap | null;
+};
+declare const rejectedListRenderingPatch: ({ current, previousFormatting, numbering }: RejectedListRenderingOptions) => Record<string, unknown>;
+//#endregion
+export { RejectedListRenderingOptions, listRenderingFor, recordsListRendering, rejectedListRenderingPatch };

package/dist/prosemirror/listRendering.js

@@ -0,0 +1,27 @@
+import { paragraphNumberingLevel, paragraphNumberingReferenceId, sameStatedParagraphNumbering } from "../docx/numberingReference.js";
+import { CLEARED_LIST_RENDERING_ATTRS } from "./listMarker.js";
+import { LIST_RENDERING_ATTR_KEYS } from "./listRenderingAttrs.js";
+import { listAttrsFromNumbering } from "./styles/resolvedStyleAttrs.js";
+//#region src/prosemirror/listRendering.ts
+/** Whether a `w:pPrChange` record states the list rendering it had (a list command's does). */
+const recordsListRendering = (record) => LIST_RENDERING_ATTR_KEYS.some((key) => Object.hasOwn(record, key));
+/** Every list-rendering attr for `numPr`: its level's, or all cleared when it numbers nothing. */
+const listRenderingFor = (numPr, numbering) => {
+	const numId = paragraphNumberingReferenceId(numPr ?? void 0);
+	const rendering = numId === void 0 ? CLEARED_LIST_RENDERING_ATTRS : listAttrsFromNumbering({
+		numId,
+		ilvl: paragraphNumberingLevel(numPr ?? void 0) ?? 0
+	}, numbering);
+	const attrs = {};
+	for (const key of LIST_RENDERING_ATTR_KEYS) attrs[key] = rendering[key] ?? null;
+	return attrs;
+};
+const rejectedListRenderingPatch = ({ current, previousFormatting, numbering }) => {
+	const record = previousFormatting ?? {};
+	if (recordsListRendering(record)) return {};
+	const restored = record.numPr ?? void 0;
+	if (sameStatedParagraphNumbering(restored, current.numPr ?? void 0)) return {};
+	return listRenderingFor(restored, numbering);
+};
+//#endregion
+export { listRenderingFor, recordsListRendering, rejectedListRenderingPatch };

package/dist/prosemirror/markupViewNotes.d.ts

@@ -0,0 +1,8 @@
+import { document_d_exports } from "../types/document.js";
+import { DisplayMode } from "../managers/EditorModeManager.js";
+import { EditorState } from "prosemirror-state";
+//#region src/prosemirror/markupViewNotes.d.ts
+/** The footnotes or endnotes as `view` shows them. */
+declare const markupViewNotes: <TNote extends document_d_exports.Footnote | document_d_exports.Endnote>(notes: TNote[] | undefined, view: DisplayMode, state: EditorState, document: document_d_exports.Document | null) => TNote[] | undefined;
+//#endregion
+export { markupViewNotes };

package/dist/prosemirror/markupViewNotes.js

@@ -0,0 +1,49 @@
+import { resolveWholeStory } from "../internal/wholeStoryRevisionResolution.js";
+import { proseDocToBlocks } from "./conversion/fromProseDoc.js";
+import { footnoteToProseDoc } from "./conversion/toProseDoc.js";
+import { markupViewResolutionMode } from "./markupViewProjection.js";
+import { getDocumentNumbering } from "./plugins/documentNumbering.js";
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
+//#region src/prosemirror/markupViewNotes.ts
+const resolvedNotes = /* @__PURE__ */ new WeakMap();
+const resolvedNote = (note, mode, state, document) => {
+	const styleResolver = getDocumentStyleResolver(state);
+	const cached = resolvedNotes.get(note)?.get(mode);
+	if (cached?.styleResolver === styleResolver) return cached.note;
+	const { styles, theme } = document.package;
+	const doc = footnoteToProseDoc(note.content, {
+		...styles !== void 0 && { styles },
+		...theme !== void 0 && { theme }
+	});
+	const result = resolveWholeStory({
+		doc,
+		mode,
+		styleResolver,
+		numbering: getDocumentNumbering(state)
+	});
+	const resolved = result.failed || result.resolved.eq(doc) ? note : {
+		...note,
+		content: proseDocToBlocks(result.resolved, note.content, styles)
+	};
+	const byMode = resolvedNotes.get(note) ?? /* @__PURE__ */ new Map();
+	byMode.set(mode, {
+		styleResolver,
+		note: resolved
+	});
+	resolvedNotes.set(note, byMode);
+	return resolved;
+};
+/** The footnotes or endnotes as `view` shows them. */
+const markupViewNotes = (notes, view, state, document) => {
+	const mode = markupViewResolutionMode(view);
+	if (!notes || !mode || !document) return notes;
+	let changed = false;
+	const shown = notes.map((note) => {
+		const resolved = resolvedNote(note, mode, state, document);
+		changed ||= resolved !== note;
+		return resolved;
+	});
+	return changed ? shown : notes;
+};
+//#endregion
+export { markupViewNotes };

package/dist/prosemirror/markupViewProjection.d.ts

@@ -82,6 +82,8 @@ type MarkupViewProjection =
  * Cached per editor state: the resolver also reads its styles and numbering
  * plugins, which may change while the document node stays the same.
  */
+/** How a view resolves the revisions it reads, or null when it shows them inline. */
+declare const markupViewResolutionMode: (view: DisplayMode) => RevisionResolutionMode | null;
 declare const projectMarkupView: (state: EditorState, view: DisplayMode) => MarkupViewProjection;
 /**
  * Where a caret at editor `position` is painted in a view. A position the view
@@ -92,4 +94,4 @@ declare const projectMarkupView: (state: EditorState, view: DisplayMode) => Mark
  */
 declare const visibleCaretPosition: (projection: MarkupViewProjection, position: number) => number;
 //#endregion
-export { MarkupViewProjection, projectMarkupView, resolveStateStory, visibleCaretPosition };
+export { MarkupViewProjection, markupViewResolutionMode, projectMarkupView, resolveStateStory, visibleCaretPosition };

package/dist/prosemirror/markupViewProjection.js

@@ -2,7 +2,7 @@ import { indexedPositionMap } from "../internal/indexedPositionMap.js";
 import { finalRevisionParagraphRanges } from "../internal/revisionResolutionTracking.js";
 import { resolveWholeStory } from "../internal/wholeStoryRevisionResolution.js";
 import { getDocumentNumbering } from "./plugins/documentNumbering.js";
-import { getDocumentStyleResolver } from "./plugins/documentStyles.js";
+import { getDocumentStyleResolver } from "./plugins/documentStyleState.js";
 import { Selection } from "prosemirror-state";
 //#region src/prosemirror/markupViewProjection.ts
 /** Resolve every revision in the state's story with the state's own styles and numbering. */
@@ -41,6 +41,11 @@ const projectionCache = /* @__PURE__ */ new WeakMap();
 * Cached per editor state: the resolver also reads its styles and numbering
 * plugins, which may change while the document node stays the same.
 */
+/** How a view resolves the revisions it reads, or null when it shows them inline. */
+const markupViewResolutionMode = (view) => {
+	const resolution = MARKUP_VIEW_RESOLUTIONS[view];
+	return resolution.type === "resolved" ? resolution.mode : null;
+};
 const projectMarkupView = (state, view) => {
 	const resolution = MARKUP_VIEW_RESOLUTIONS[view];
 	if (resolution.type === "authored") return AUTHORED;
@@ -80,4 +85,4 @@ const visibleCaretPosition = (projection, position) => {
 	return projection.toEditor(near.head, -1);
 };
 //#endregion
-export { projectMarkupView, resolveStateStory, visibleCaretPosition };
+export { markupViewResolutionMode, projectMarkupView, resolveStateStory, visibleCaretPosition };

package/dist/prosemirror/noteReferenceReview.d.ts

@@ -0,0 +1,77 @@
+import { document_d_exports } from "../types/document.js";
+import { Mark, Node } from "prosemirror-model";
+import { Transform } from "prosemirror-transform";
+//#region src/prosemirror/noteReferenceReview.d.ts
+type NoteKind = "footnote" | "endnote";
+/** `footnote:<id>` or `endnote:<id>`. */
+type NoteKey = `${NoteKind}:${number}`;
+/**
+ * The notes a story's text refers to, and whether each reference is pending
+ * deletion: a reference is deleted when every character of it is.
+ */
+declare const noteReferenceStates: (doc: Node) => Map<NoteKey, "live" | "deleted">;
+/** The notes whose reference a change took from pending deletion back to live. */
+declare const noteReferencesRestored: (before: Node, after: Node) => NoteKey[];
+/**
+ * The revisions that deleted a note along with its reference: its text and
+ * its paragraph marks, deleted by the reference deletion's author at its
+ * date. A deletion in the note made some other time is a change of its own,
+ * which resolving the reference leaves alone.
+ */
+declare const noteDeletionRevisions: (doc: Node, reference: Mark) => number[];
+/**
+ * The document with the named notes' deletions that went with their
+ * reference rejected: the notes whose reference's deletion was rejected get
+ * their text back. `before` is the body that still had those deletions.
+ */
+declare const restoreNotes: (document: document_d_exports.Document, keys: Iterable<NoteKey>, before: Node) => document_d_exports.Document;
+/** The deletion each pending-deleted note reference carries. */
+declare const referenceDeletions: (doc: Node) => Map<NoteKey, Mark>;
+/**
+ * Delete a note's text and its paragraph marks along with its reference: by
+ * the reference deletion's author at its date, so resolving the reference
+ * resolves them too (see {@link noteDeletionRevisions}).
+ */
+declare const deleteNoteWithReference: <T extends Transform>(transform: T, reference: Mark) => T;
+/**
+ * Keeps an editor's notes following their references across body edits. The
+ * editor reports the body as it was before the edits it has not yet written
+ * back, and reconciles the document it writes back:
+ *
+ * - a reference whose deletion is rejected gives its note back its text;
+ * - a reference deleted again, as undoing that reject does, takes the note's
+ *   text with it: the note returns to what it was, or, when the note changed
+ *   since, its text is deleted along with the reference.
+ */
+type NoteReferenceFollower = {
+  /** The body before the edits the next {@link reconcile} writes back. */
+  noteBase: (before: Node) => void;
+  /** The document to write back, its notes following the body's references. */
+  reconcile: (document: document_d_exports.Document, body: Node) => document_d_exports.Document;
+  /**
+   * `document` with the note changes an earlier {@link reconcile} wrote back
+   * and the editor's document has not taken in yet: a save reads the editor
+   * right after a write-back, before the host hands the result back.
+   */
+  withPending: (document: document_d_exports.Document) => document_d_exports.Document;
+  /** Forget the pending base and what earlier restores replaced (a new document). */
+  reset: () => void;
+};
+declare const createNoteReferenceFollower: () => NoteReferenceFollower;
+/** The notes model content refers to, live or pending deletion. */
+declare const noteKeysReferencedIn: (content: unknown) => Set<NoteKey>;
+/**
+ * The notes anything refers to, live or pending deletion: the main story, and
+ * the stories the body does not hold (headers, footers, comments, notes).
+ * References inside the `skipped` notes do not count: those notes are going.
+ */
+declare const referencedNotes: (document: document_d_exports.Document, skipped?: ReadonlySet<string>) => Set<NoteKey>;
+/**
+ * The document without the notes nothing refers to any more: a note goes
+ * with its reference, so accepting the reference's deletion leaves a note no
+ * reader can reach, and saving drops it, with the comments anchored only in
+ * it. Separators stay.
+ */
+declare const withoutUnreferencedNotes: (document: document_d_exports.Document) => document_d_exports.Document;
+//#endregion
+export { NoteKey, NoteReferenceFollower, createNoteReferenceFollower, deleteNoteWithReference, noteDeletionRevisions, noteKeysReferencedIn, noteReferenceStates, noteReferencesRestored, referenceDeletions, referencedNotes, restoreNotes, withoutUnreferencedNotes };