@pixerate/editor 0.23.0 → 0.25.0

package/dist/comment-store-BEMgVlAA.d.ts

@@ -0,0 +1,135 @@
+/**
+ * Who made a comment, reply or tracked change.
+ */
+interface ReviewAuthor {
+    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;
+}
+type CommentStoreListener = (snapshot: CommentStoreSnapshot) => void;
+/**
+ * Generates a reasonably unique id without depending on `crypto`.
+ */
+declare function createReviewId(prefix?: string): string;
+/**
+ * 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).
+ */
+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;
+/**
+ * Short, human-readable timestamp for review UIs ("just now", "5m ago",
+ * "3h ago", then a locale date). Shared by the React and Svelte components.
+ */
+declare function formatReviewTime(timestamp: number, now?: number): string;
+
+export { type CommentAnchor as C, type ReviewAuthor as R, type SerializedComments as S, 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, createCommentStore as h, createReviewId as i, formatReviewTime as j };

package/dist/compare/index.cjs

@@ -0,0 +1,15 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});require('../chunk-PL4JB3BF.cjs');
+
+
+
+
+
+var _chunkAL6JMGWWcjs = require('../chunk-AL6JMGWW.cjs');
+require('../chunk-X4N4WUKB.cjs');
+
+
+
+
+
+exports.compareDocuments = _chunkAL6JMGWWcjs.compareDocuments; exports.compareHtml = _chunkAL6JMGWWcjs.compareHtml; exports.diffChanges = _chunkAL6JMGWWcjs.diffChanges; exports.diffSequences = _chunkAL6JMGWWcjs.diffSequences;
+//# sourceMappingURL=index.cjs.map

package/dist/compare/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/editor/editor/packages/core/dist/compare/index.cjs"],"names":[],"mappings":"AAAA,0GAA8B;AAC9B;AACE;AACA;AACA;AACA;AACF,yDAA8B;AAC9B,iCAA8B;AAC9B;AACE;AACA;AACA;AACA;AACF,iOAAC","file":"/home/runner/work/editor/editor/packages/core/dist/compare/index.cjs"}

package/dist/compare/index.d.cts

@@ -0,0 +1,58 @@
+export { C as CompareDocumentsOptions, a as CompareDocumentsResult, b as CompareSource, c as CompareSummary, d as compareDocuments, e as compareHtml } from '../documents-Gp7wb0Me.cjs';
+import '@tiptap/pm/model';
+import '../comment-store-BEMgVlAA.cjs';
+
+/**
+ * Generic sequence diff: common prefix/suffix stripping, Myers' O((N+M)·D)
+ * algorithm for small segments and patience anchors (items unique on both
+ * sides, longest increasing subsequence) to split long ones. Dependency-free.
+ */
+type DiffOpType = "equal" | "delete" | "insert";
+/** A run of consecutive operations of one type. */
+interface DiffRun {
+    type: DiffOpType;
+    /** Start index in `a` (for `insert`, where the items go in `a`). */
+    aIndex: number;
+    /** Start index in `b` (for `delete`, where the items were in `b`). */
+    bIndex: number;
+    length: number;
+}
+/** A change: a deleted range of `a`, an inserted range of `b`, or both (replaced). */
+interface DiffChange {
+    kind: "inserted" | "deleted" | "replaced";
+    aStart: number;
+    aEnd: number;
+    bStart: number;
+    bEnd: number;
+}
+interface DiffSequencesOptions<T> {
+    /**
+     * Key of an item: items with the same key are equal. Defaults to the item
+     * itself for strings, numbers and booleans, and `JSON.stringify` otherwise.
+     * Keys enable patience anchors for long inputs.
+     */
+    hash?: (item: T) => string | number | boolean;
+    /**
+     * Custom equality. Without `hash`, segments longer than `direct` are only
+     * diffed while the edit distance stays below `direct`, otherwise replaced.
+     */
+    equals?: (a: T, b: T) => boolean;
+    /**
+     * Segments with more items (both sides together) are split at anchors
+     * first so Myers' saved frontiers (O(D²) memory) stay small. Default 3000.
+     */
+    direct?: number;
+    /** Maximum anchor recursion depth before a long segment is replaced whole. Default 8. */
+    maxDepth?: number;
+}
+/**
+ * Diffs two sequences and returns the edit script as runs of equal, deleted
+ * and inserted items, in order. Within a changed stretch deletions come
+ * before insertions. The script is minimal for segments up to `direct`
+ * items; longer inputs are split at patience anchors (bounded work).
+ */
+declare function diffSequences<T>(a: readonly T[], b: readonly T[], options?: DiffSequencesOptions<T>): DiffRun[];
+/** Groups an edit script into inserted, deleted and replaced ranges. */
+declare function diffChanges<T>(a: readonly T[], b: readonly T[], options?: DiffSequencesOptions<T>): DiffChange[];
+
+export { type DiffChange, type DiffOpType, type DiffRun, type DiffSequencesOptions, diffChanges, diffSequences };

package/dist/compare/index.d.ts

@@ -0,0 +1,58 @@
+export { C as CompareDocumentsOptions, a as CompareDocumentsResult, b as CompareSource, c as CompareSummary, d as compareDocuments, e as compareHtml } from '../documents-CHT1U5Vs.js';
+import '@tiptap/pm/model';
+import '../comment-store-BEMgVlAA.js';
+
+/**
+ * Generic sequence diff: common prefix/suffix stripping, Myers' O((N+M)·D)
+ * algorithm for small segments and patience anchors (items unique on both
+ * sides, longest increasing subsequence) to split long ones. Dependency-free.
+ */
+type DiffOpType = "equal" | "delete" | "insert";
+/** A run of consecutive operations of one type. */
+interface DiffRun {
+    type: DiffOpType;
+    /** Start index in `a` (for `insert`, where the items go in `a`). */
+    aIndex: number;
+    /** Start index in `b` (for `delete`, where the items were in `b`). */
+    bIndex: number;
+    length: number;
+}
+/** A change: a deleted range of `a`, an inserted range of `b`, or both (replaced). */
+interface DiffChange {
+    kind: "inserted" | "deleted" | "replaced";
+    aStart: number;
+    aEnd: number;
+    bStart: number;
+    bEnd: number;
+}
+interface DiffSequencesOptions<T> {
+    /**
+     * Key of an item: items with the same key are equal. Defaults to the item
+     * itself for strings, numbers and booleans, and `JSON.stringify` otherwise.
+     * Keys enable patience anchors for long inputs.
+     */
+    hash?: (item: T) => string | number | boolean;
+    /**
+     * Custom equality. Without `hash`, segments longer than `direct` are only
+     * diffed while the edit distance stays below `direct`, otherwise replaced.
+     */
+    equals?: (a: T, b: T) => boolean;
+    /**
+     * Segments with more items (both sides together) are split at anchors
+     * first so Myers' saved frontiers (O(D²) memory) stay small. Default 3000.
+     */
+    direct?: number;
+    /** Maximum anchor recursion depth before a long segment is replaced whole. Default 8. */
+    maxDepth?: number;
+}
+/**
+ * Diffs two sequences and returns the edit script as runs of equal, deleted
+ * and inserted items, in order. Within a changed stretch deletions come
+ * before insertions. The script is minimal for segments up to `direct`
+ * items; longer inputs are split at patience anchors (bounded work).
+ */
+declare function diffSequences<T>(a: readonly T[], b: readonly T[], options?: DiffSequencesOptions<T>): DiffRun[];
+/** Groups an edit script into inserted, deleted and replaced ranges. */
+declare function diffChanges<T>(a: readonly T[], b: readonly T[], options?: DiffSequencesOptions<T>): DiffChange[];
+
+export { type DiffChange, type DiffOpType, type DiffRun, type DiffSequencesOptions, diffChanges, diffSequences };

package/dist/compare/index.js

@@ -0,0 +1,15 @@
+import "../chunk-HLIMTC6N.js";
+import {
+  compareDocuments,
+  compareHtml,
+  diffChanges,
+  diffSequences
+} from "../chunk-NAXVVS5I.js";
+import "../chunk-UAKDG62Z.js";
+export {
+  compareDocuments,
+  compareHtml,
+  diffChanges,
+  diffSequences
+};
+//# sourceMappingURL=index.js.map

package/dist/compare/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}