@pixerate/editor 0.23.0 → 0.25.0

package/dist/{track-changes-BSF58RK0.d.cts → track-changes-D_VAPELi.d.cts}

@@ -5,6 +5,7 @@ import { MentionOptions as MentionOptions$1 } from '@tiptap/extension-mention';
 import { SuggestionOptions } from '@tiptap/suggestion';
 import { EditorState, PluginKey } from '@tiptap/pm/state';
 import { Node } from '@tiptap/pm/model';
+import { R as ReviewAuthor } from './comment-store-BEMgVlAA.cjs';
 
 interface MentionEntity {
     id: string;
@@ -27,144 +28,30 @@ interface MentionOptions extends Partial<MentionOptions$1> {
  * Creates atomic inline <span data-type="mention"> nodes with full suggestion support.
  */
 declare const Mention: _tiptap_core.Node<MentionOptions$1<any, _tiptap_extension_mention.MentionNodeAttrs>, any>;
-/**
- * Helper to configure the Mention extension with preset defaults.
- */
-declare function createMentionExtension(options?: Partial<MentionOptions>): _tiptap_core.Node<MentionOptions$1<any, _tiptap_extension_mention.MentionNodeAttrs>, any>;
-
-/**
- * Who made a comment, reply or tracked change.
- */
-interface ReviewAuthor {
+/** Mention nodes in a document, with their positions (for role pickers). */
+interface MentionNodeInfo {
+    pos: number;
     id: string;
-    name: string;
-    color?: string;
-    avatarUrl?: string;
-}
-/**
- * Where a comment thread is attached in the document. `from`/`to` are
- * ProseMirror positions and `quote` is the commented text at the time the
- * anchor was last synced. Positions are only meaningful for the current
- * document; the `comment` mark in the document is the source of truth.
- */
-interface CommentAnchor {
-    from: number;
-    to: number;
-    quote: string;
-}
-interface CommentReply {
-    id: string;
-    author: ReviewAuthor;
-    body: string;
-    createdAt: number;
-    editedAt?: number;
-}
-interface CommentThread {
-    id: string;
-    /** `null` while the thread has no text in the document (see `orphaned`). */
-    anchor: CommentAnchor | null;
-    author: ReviewAuthor;
-    createdAt: number;
-    /** An empty body marks a draft that has not been posted yet. */
-    body: string;
-    editedAt?: number;
-    replies: CommentReply[];
-    resolved: boolean;
-    resolvedAt?: number;
-    resolvedBy?: ReviewAuthor;
-    /**
-     * True when the commented text was deleted from the document. Undoing the
-     * deletion re-attaches the thread.
-     */
-    orphaned: boolean;
-    /** The quote the thread had before it was orphaned. */
-    lastQuote?: string;
-}
-interface CommentStoreSnapshot {
-    /** Threads in document order (anchored first), then orphaned threads. */
-    threads: readonly CommentThread[];
-    activeThreadId: string | null;
-}
-/** JSON shape produced by `CommentStore.toJSON()`. */
-interface SerializedComments {
-    version: 1;
-    threads: CommentThread[];
-}
-interface CommentStoreOptions {
-    threads?: CommentThread[] | SerializedComments;
-    generateId?: () => string;
-    now?: () => number;
-}
-interface CreateThreadInput {
-    id?: string;
-    body: string;
-    author: ReviewAuthor;
-    anchor?: CommentAnchor | null;
-    createdAt?: number;
+    label: string;
+    type?: string;
+    role?: string;
 }
-type CommentStoreListener = (snapshot: CommentStoreSnapshot) => void;
-/**
- * Generates a reasonably unique id without depending on `crypto`.
- */
-declare function createReviewId(prefix?: string): string;
+/** Every mention node of an editor's document, in document order. */
+declare function getMentionNodes(editor: {
+    state: {
+        doc: any;
+    };
+}): MentionNodeInfo[];
 /**
- * Headless, framework-agnostic store of comment threads.
- *
- * The store never talks to a server: persist `toJSON()` yourself and pass it
- * back via `new CommentStore({ threads })` or `load()`. Snapshots are
- * immutable and only replaced when something changes, so `getSnapshot` is safe
- * to use with React's `useSyncExternalStore`. `subscribe` calls the listener
- * immediately (Svelte store contract).
+ * Sets (or with `null` clears) the role of the mention node at `pos`, as one
+ * undoable step. Returns `false` when there is no mention at `pos` or the role
+ * name is invalid.
  */
-declare class CommentStore {
-    private threads;
-    private activeThreadId;
-    private snapshot;
-    private listeners;
-    /** Deleted threads, kept so undoing a "Delete Comment" can restore them. */
-    private deleted;
-    private generateId;
-    private now;
-    constructor(options?: CommentStoreOptions);
-    /** Parses `toJSON()` output (or a plain thread array). */
-    static parse(json: string | CommentThread[] | SerializedComments): CommentThread[];
-    subscribe: (listener: CommentStoreListener) => (() => void);
-    getSnapshot: () => CommentStoreSnapshot;
-    getThread(id: string): CommentThread | undefined;
-    createThread(input: CreateThreadInput): CommentThread;
-    /** Edits the thread's body, or one of its replies when `replyId` is given. */
-    editComment(threadId: string, body: string, replyId?: string): boolean;
-    addReply(threadId: string, input: {
-        body: string;
-        author: ReviewAuthor;
-        id?: string;
-    }): CommentReply | null;
-    deleteReply(threadId: string, replyId: string): boolean;
-    resolveThread(id: string, resolved?: boolean, by?: ReviewAuthor): boolean;
-    deleteThread(id: string): boolean;
-    /** Deletes every thread whose text is no longer in the document. */
-    removeOrphanedThreads(): string[];
-    setActiveThread(id: string | null): void;
-    /**
-     * Updates anchors from the document. Threads missing from `anchors` become
-     * orphaned. Threads that were deleted but whose mark re-appeared (e.g. after
-     * undoing "Delete Comment") are restored. Returns true if anything changed.
-     */
-    syncAnchors(anchors: Map<string, CommentAnchor>): boolean;
-    /** Replaces all threads, e.g. with data loaded from a server. */
-    load(json: string | CommentThread[] | SerializedComments): void;
-    clear(): void;
-    toJSON(): SerializedComments;
-    private updateThread;
-    private computeSnapshot;
-    private emit;
-}
-declare function createCommentStore(options?: CommentStoreOptions): CommentStore;
+declare function setMentionRoleAt(editor: any, pos: number, role: string | null): boolean;
 /**
- * Short, human-readable timestamp for review UIs ("just now", "5m ago",
- * "3h ago", then a locale date). Shared by the React and Svelte components.
+ * Helper to configure the Mention extension with preset defaults.
  */
-declare function formatReviewTime(timestamp: number, now?: number): string;
+declare function createMentionExtension(options?: Partial<MentionOptions>): _tiptap_core.Node<MentionOptions$1<any, _tiptap_extension_mention.MentionNodeAttrs>, any>;
 
 declare const INSERTION_MARK_NAME = "insertion";
 declare const DELETION_MARK_NAME = "deletion";
@@ -172,12 +59,18 @@ declare const DELETION_MARK_NAME = "deletion";
 declare const FORMAT_CHANGE_MARK_NAME = "formatChange";
 /** Node attribute recording a tracked block change (type, attributes or wrapping). */
 declare const BLOCK_CHANGE_ATTRIBUTE = "blockChange";
+/**
+ * Attribute of the insertion and deletion marks linking the two ends of a
+ * tracked move: the deletion is where the text moved from, the insertion
+ * where it moved to. Serialized as `data-move-id`.
+ */
+declare const MOVE_ID_ATTRIBUTE = "moveId";
 /**
  * Set this transaction meta to `true` to apply a change without tracking it,
  * e.g. `editor.chain().command(({ tr }) => { tr.setMeta(TRACK_CHANGES_SKIP_META, true); return true; }).setContent(…).run()`.
  */
 declare const TRACK_CHANGES_SKIP_META = "trackChangesSkip";
-type TrackedChangeType = "insertion" | "deletion" | "format" | "block";
+type TrackedChangeType = "insertion" | "deletion" | "format" | "block" | "move";
 /**
  * How tracked content is rendered by serializers:
  * - `accepted` (default): as if every change were accepted (deleted text is
@@ -192,6 +85,11 @@ interface TrackedChangeAttributes {
     authorName: string;
     authorColor: string | null;
     createdAt: number;
+    /**
+     * Insertion/deletion marks only: links a deletion (moved from) and an
+     * insertion (moved to) into one tracked move.
+     */
+    moveId?: string | null;
 }
 /** A serializable mark (`mark.toJSON()`). */
 interface TrackedMark {
@@ -215,9 +113,16 @@ interface TrackedBlockSnapshot {
         attrs: Record<string, any>;
     }[];
 }
+/**
+ * Whole-block operation of a `blockChange` record: the block was inserted
+ * (rejecting removes it) or deleted (accepting removes it). Produced by
+ * `compareDocuments`; absent for type/attribute/wrapping changes.
+ */
+type TrackedBlockOperation = "insert" | "delete";
 /** Value of the `blockChange` node attribute. */
 interface TrackedBlockChangeAttributes extends TrackedChangeAttributes {
     previous: TrackedBlockSnapshot;
+    operation?: TrackedBlockOperation;
 }
 interface TrackedFormatSummary {
     /** Labels of added formatting, e.g. `["Bold"]`. */
@@ -249,10 +154,32 @@ interface TrackedChange {
     description: string;
     /** Formatting changes (`type: "format"`). */
     format?: TrackedFormatSummary;
-    /** Block changes (`type: "block"`): the first block's previous and current state. */
+    /**
+     * Block changes (`type: "block"`): the first block's previous and current
+     * state, and the whole-block operation for inserted/deleted blocks.
+     */
     block?: {
         previous: TrackedBlockSnapshot;
         current: TrackedBlockSnapshot;
+        operation?: TrackedBlockOperation;
+    };
+    /**
+     * Moves (`type: "move"`): where the text was moved from (struck through
+     * until accepted) and where it was moved to. `ranges` holds both.
+     */
+    move?: {
+        from: {
+            from: number;
+            to: number;
+        }[];
+        to: {
+            from: number;
+            to: number;
+        }[];
+        /** The moved text at its source. */
+        fromText: string;
+        /** The moved text at its destination. */
+        toText: string;
     };
 }
 interface TrackChangesSnapshot {
@@ -275,6 +202,10 @@ interface TrackChangesOptions {
     formatChangeHTMLAttributes: Record<string, any>;
     /** Class added to blocks with a tracked block change (margin bar by default). */
     blockChangeClass: string;
+    /** Extra class of wholly inserted blocks (`blockChange.operation: "insert"`, from comparisons). */
+    blockInsertedClass: string;
+    /** Extra class of wholly deleted blocks (`blockChange.operation: "delete"`, from comparisons). */
+    blockDeletedClass: string;
     /** Track mark changes (bold, links, font size, …) on existing text. Default `true`. */
     trackFormatting: boolean;
     /** Track textblock type/attribute and wrapping (list, quote) changes. Default `true`. */
@@ -290,6 +221,19 @@ interface TrackChangesOptions {
     ignoredMarks: string[];
     /** Node attributes ignored when comparing blocks (e.g. generated ids). */
     ignoredBlockAttributes: string[];
+    /**
+     * Record a cut and paste (or a drag) of the same text as one tracked move
+     * instead of a deletion and an insertion. Default `true`.
+     */
+    trackMoves: boolean;
+    /**
+     * Decides whether moved text is big enough to be a move. Default
+     * `isMoveSized` (a paragraph, or at least a sentence of two words, as in
+     * Word); pass `() => true` to record every cut/paste or drag as a move.
+     */
+    isMove: (text: string) => boolean;
+    /** HTML attributes (e.g. `class`) of moved text, at both ends. Replaces the default green double line. */
+    moveHTMLAttributes: Record<string, any>;
 }
 /**
  * External store over the editor's tracked-change state. Snapshots only
@@ -325,27 +269,39 @@ declare module "@tiptap/core" {
             /** Rejects one change (single undo step). */
             rejectChange: (id: string) => ReturnType;
             acceptAllChanges: () => ReturnType;
+            /** Accepts a tracked move: removes the source, keeps the destination. */
+            acceptMove: (id: string) => ReturnType;
+            /** Rejects a tracked move: restores the source, removes the destination. */
+            rejectMove: (id: string) => ReturnType;
             rejectAllChanges: () => ReturnType;
             /** Selects the next change after the selection, wrapping around. */
             selectNextChange: () => ReturnType;
             /** Selects the previous change before the selection, wrapping around. */
             selectPreviousChange: () => ReturnType;
+            /** Selects a change (a move's destination, a block change's content). */
+            selectChange: (id: string) => ReturnType;
         };
     }
 }
+interface TrackedMarkOptions {
+    HTMLAttributes: Record<string, any>;
+    /** Attributes used instead of `HTMLAttributes` when the mark is one end of a move. */
+    moveHTMLAttributes: Record<string, any>;
+}
+/** Default classes of moved text: green double underline (destination) / strike (source), as in Word. */
+declare const MOVE_TO_CLASS = "pixerate-move-to underline decoration-double decoration-emerald-600 text-emerald-700 dark:text-emerald-400";
+declare const MOVE_FROM_CLASS = "pixerate-move-from line-through decoration-double decoration-emerald-600 text-emerald-700 dark:text-emerald-400";
 /**
- * Text inserted while tracking was on. Rendered as `<ins>`.
+ * Text inserted while tracking was on. Rendered as `<ins>`. With a `moveId`
+ * it is the destination of a tracked move.
  */
-declare const TrackedInsertion: Mark<{
-    HTMLAttributes: Record<string, any>;
-}, any>;
+declare const TrackedInsertion: Mark<TrackedMarkOptions, any>;
 /**
  * Text deleted while tracking was on. The text stays in the document until
- * the change is accepted. Rendered as `<del>` (struck through).
+ * the change is accepted. Rendered as `<del>` (struck through). With a
+ * `moveId` it is the source of a tracked move.
  */
-declare const TrackedDeletion: Mark<{
-    HTMLAttributes: Record<string, any>;
-}, any>;
+declare const TrackedDeletion: Mark<TrackedMarkOptions, any>;
 /**
  * Existing text whose formatting changed while tracking was on. Stores the
  * formatting before and after the change, rendered as
@@ -358,6 +314,8 @@ declare const TrackedFormatChange: Mark<{
 declare function describeFormatChange(summary: TrackedFormatSummary): string;
 /** Describes a block change, e.g. `Changed Paragraph to Heading 2`. */
 declare function describeBlockChange(previous: TrackedBlockSnapshot, current: TrackedBlockSnapshot, ignoredAttributes?: readonly string[]): string;
+/** Short label of a change's type for review UIs (`Moved` for a move). */
+declare function trackedChangeLabel(change: Pick<TrackedChange, "type">): string;
 /**
  * Lists tracked changes in document order. Accepts an editor, an editor
  * state or a ProseMirror document.
@@ -373,17 +331,25 @@ declare function getTrackChangesStore(editor: Editor | null | undefined): TrackC
  * (`accepted` by default). The input document is not modified.
  */
 declare function resolveTrackedChanges(doc: Node, view?: TrackedChangesView): Node;
+/**
+ * Whether moved text is big enough to be recorded as a move rather than a
+ * deletion and an insertion, as in Word: a paragraph (the text holds a
+ * paragraph break) or at least a sentence of two or more words.
+ */
+declare function isMoveSized(text: string): boolean;
 /**
  * Suggestion mode / track changes. When enabled, typed and pasted content is
  * marked as an insertion and deleted content is kept but marked as a
  * deletion (struck through) until the change is accepted or rejected.
  * Formatting changes on existing text are recorded with the `formatChange`
  * mark, and textblock type/attribute/wrapping changes with the `blockChange`
- * node attribute.
+ * node attribute. A cut and paste (or a drag) of a sentence or paragraph is
+ * recorded as a move: a deletion and an insertion linked by `moveId`, listed
+ * as one change and accepted or rejected together.
  *
  * Deleting your own insertion really deletes it. Paragraph splits and joins
  * are not tracked. IME composition is tracked once the composition ends.
  */
 declare const TrackChanges: Extension<TrackChangesOptions, TrackChangesStorage>;
 
-export { createCommentStore as A, BLOCK_CHANGE_ATTRIBUTE as B, type CommentAnchor as C, DELETION_MARK_NAME as D, createMentionExtension as E, FORMAT_CHANGE_MARK_NAME as F, createReviewId as G, describeBlockChange as H, INSERTION_MARK_NAME as I, describeFormatChange as J, formatReviewTime as K, getTrackChangesStore as L, Mention as M, getTrackedChangeAt as N, getTrackedChanges as O, isTrackChangesEnabled as P, resolveTrackedChanges as Q, type ReviewAuthor as R, type SerializedComments as S, TRACK_CHANGES_SKIP_META as T, trackChangesPluginKey as U, type CommentReply as a, CommentStore as b, type CommentStoreListener as c, type CommentStoreOptions as d, type CommentStoreSnapshot as e, type CommentThread as f, type CreateThreadInput as g, type MentionEntity as h, type MentionOptions as i, TrackChanges as j, type TrackChangesOptions as k, type TrackChangesSnapshot as l, type TrackChangesStorage as m, TrackChangesStore as n, type TrackedBlockChangeAttributes as o, type TrackedBlockSnapshot as p, type TrackedChange as q, type TrackedChangeAttributes as r, type TrackedChangeType as s, type TrackedChangesView as t, TrackedDeletion as u, TrackedFormatChange as v, type TrackedFormatChangeAttributes as w, type TrackedFormatSummary as x, TrackedInsertion as y, type TrackedMark as z };
+export { describeFormatChange as A, BLOCK_CHANGE_ATTRIBUTE as B, getMentionNodes as C, DELETION_MARK_NAME as D, getTrackChangesStore as E, FORMAT_CHANGE_MARK_NAME as F, getTrackedChangeAt as G, getTrackedChanges as H, INSERTION_MARK_NAME as I, isMoveSized as J, isTrackChangesEnabled as K, resolveTrackedChanges as L, MOVE_FROM_CLASS as M, setMentionRoleAt as N, trackChangesPluginKey as O, trackedChangeLabel as P, TRACK_CHANGES_SKIP_META as T, MOVE_ID_ATTRIBUTE as a, MOVE_TO_CLASS as b, Mention as c, type MentionEntity as d, type MentionNodeInfo as e, type MentionOptions as f, TrackChanges as g, type TrackChangesOptions as h, type TrackChangesSnapshot as i, type TrackChangesStorage as j, TrackChangesStore as k, type TrackedBlockChangeAttributes as l, type TrackedBlockOperation as m, type TrackedBlockSnapshot as n, type TrackedChange as o, type TrackedChangeAttributes as p, type TrackedChangeType as q, type TrackedChangesView as r, TrackedDeletion as s, TrackedFormatChange as t, type TrackedFormatChangeAttributes as u, type TrackedFormatSummary as v, TrackedInsertion as w, type TrackedMark as x, createMentionExtension as y, describeBlockChange as z };