oasis-editor 0.0.84 → 0.0.86

package/dist/core/endnotes.d.ts

@@ -1,10 +1,5 @@
 import { EditorBlockNode, EditorDocument, EditorEndnote, EditorEndnotes, EditorParagraphNode, EditorTextRun } from './model.js';
 
-/**
- * Iterate every paragraph in document order (endnote bodies excluded), yielding
- * each endnote reference run with its owning paragraph. Order matches reading
- * order, which is what numbering depends on.
- */
 export declare function iterateEndnoteReferenceRuns(document: EditorDocument): Generator<{
     paragraph: EditorParagraphNode;
     run: EditorTextRun;

package/dist/core/footnotes.d.ts

@@ -1,10 +1,5 @@
 import { EditorBlockNode, EditorDocument, EditorFootnote, EditorFootnoteNumberFormat, EditorFootnotes, EditorParagraphNode, EditorTextRun } from './model.js';
 
-/**
- * Iterate every paragraph in document order (sections + footnotes excluded),
- * yielding each footnote reference run along with the owning paragraph. Order
- * matches reading order, which is what numbering depends on.
- */
 export declare function iterateFootnoteReferenceRuns(document: EditorDocument): Generator<{
     paragraph: EditorParagraphNode;
     run: EditorTextRun;

package/dist/core/noteTraversal.d.ts

@@ -0,0 +1,77 @@
+import { EditorBlockNode, EditorDocument, EditorFootnoteNumberFormat, EditorParagraphNode, EditorSection, EditorTextRun } from './model.js';
+
+/** Discriminant of a note reference run. */
+export type NoteReferenceRunKind = "footnoteReference" | "endnoteReference";
+/** Neutral view of a note reference run's data (id + optional custom mark). */
+export interface NoteRef {
+    id: string;
+    customMark?: string;
+}
+/** Minimal shape of a note body shared by footnotes and endnotes. */
+interface NoteBody {
+    blocks: EditorBlockNode[];
+}
+/** Minimal shape of a note collection (footnotes/endnotes registry). */
+interface NoteCollection<TNote extends NoteBody> {
+    items: Record<string, TNote>;
+    settings?: {
+        numberFormat?: EditorFootnoteNumberFormat;
+        startAt?: number;
+    };
+}
+/**
+ * Describes one note family so the shared algorithm can operate on either.
+ */
+export interface NoteTraversal {
+    /** Reference run discriminant for this family. */
+    runKind: NoteReferenceRunKind;
+    /** Read neutral reference data from a run, or undefined if not this kind. */
+    getRef(run: EditorTextRun): NoteRef | undefined;
+    /** Map a one-based index + format to display marker text. */
+    formatMarker(oneBasedIndex: number, format: EditorFootnoteNumberFormat): string;
+}
+/**
+ * Iterate every paragraph in document order (note bodies excluded), yielding
+ * each reference run of `runKind` with its owning paragraph. Order matches
+ * reading order, which is what numbering depends on.
+ */
+export declare function iterateNoteReferenceRuns(document: EditorDocument, runKind: NoteReferenceRunKind): Generator<{
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+}, void, void>;
+export declare function collectNoteReferences(document: EditorDocument, runKind: NoteReferenceRunKind): Array<{
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+}>;
+/** Find the note body that contains the given paragraph id (neutral id). */
+export declare function findNoteBodyByParagraphId<TNote extends NoteBody>(items: Record<string, TNote> | undefined, paragraphId: string): {
+    id: string;
+    body: TNote;
+} | null;
+/** Find the first reference run for a given note id. */
+export declare function findNoteReference(document: EditorDocument, traversal: NoteTraversal, noteId: string): {
+    paragraph: EditorParagraphNode;
+    run: EditorTextRun;
+} | null;
+/** Neutral per-reference info (id + custom mark + computed reading-order index). */
+export interface NoteReferenceInfo {
+    id: string;
+    customMark?: string;
+    index: number;
+}
+export declare function listReferencedNotes(document: EditorDocument, traversal: NoteTraversal): NoteReferenceInfo[];
+/** Result of {@link computeNoteRenumber}: rewritten sections + pruned items. */
+export interface NoteRenumberResult<TNote extends NoteBody> {
+    sections: EditorSection[];
+    sectionsChanged: boolean;
+    nextItems: Record<string, TNote>;
+    itemsChanged: boolean;
+}
+/**
+ * Compute the renumbering of a note family: assign a marker per referenced note
+ * in reading order, rewrite reference run text where it differs, and prune note
+ * bodies that are no longer referenced. Pure — the caller assembles the new
+ * document with the correct collection field.
+ */
+export declare function computeNoteRenumber<TNote extends NoteBody>(document: EditorDocument, collection: NoteCollection<TNote>, traversal: NoteTraversal): NoteRenumberResult<TNote>;
+export {};