@fileverse-dev/ddoc 5.0.7 → 5.1.1

package/dist/{markdown-source-pane-DslilGqY.mjs → markdown-source-pane-Czkf5b3H.mjs}

@@ -3,7 +3,7 @@ var Wr = (t, e, O) => e in t ? Vr(t, e, { enumerable: !0, configurable: !0, writ
 var gt = (t, e, O) => Wr(t, typeof e != "symbol" ? e + "" : e, O);
 import { jsx as Cr } from "react/jsx-runtime";
 import { useRef as pe, useEffect as St } from "react";
-import { s as y, A as pO, T as dO, a as Gr, S as et, b as Lr, P as fO, E as j, i as QO, c as _, D as le, k as tt, F as Ar, M as Pt, W as Er, R as Ur, d as mO, N as oe, e as V, f as Mr, g as Ot, h as ce, p as $O, j as Y, t as h, l as Ir, I as rt, L as at, m as ye, n as ue, o as Qe, q as gO, r as te, u as SO, v as Br, w as Nr, x as PO, y as kO, z as Dr, B as Fr, C as Kr, G as Oe, H as ZO, J as Jr, K as kt, O as Hr, Q as ea, U as ta, V as Oa, X as ra, Y as aa, Z as ia, _ as sa, $ as na, a0 as la, a1 as oa, a2 as ca } from "./index-D4hYioav.mjs";
+import { s as y, A as pO, T as dO, a as Gr, S as et, b as Lr, P as fO, E as j, i as QO, c as _, D as le, k as tt, F as Ar, M as Pt, W as Er, R as Ur, d as mO, N as oe, e as V, f as Mr, g as Ot, h as ce, p as $O, j as Y, t as h, l as Ir, I as rt, L as at, m as ye, n as ue, o as Qe, q as gO, r as te, u as SO, v as Br, w as Nr, x as PO, y as kO, z as Dr, B as Fr, C as Kr, G as Oe, H as ZO, J as Jr, K as kt, O as Hr, Q as ea, U as ta, V as Oa, X as ra, Y as aa, Z as ia, _ as sa, $ as na, a0 as la, a1 as oa, a2 as ca } from "./index-mGcKslYf.mjs";
 class ua {
   /**
   Create a new completion context. (Mostly useful for testing

package/dist/package/extensions/caret-marks/caret-marks.d.ts

@@ -0,0 +1,13 @@
+import { Extension } from '@tiptap/core';
+import { PluginKey } from '@tiptap/pm/state';
+import { DecorationSet } from '@tiptap/pm/view';
+import { DispatchContext } from './dispatch-context';
+
+export declare const caretMarksPluginKey: PluginKey<DispatchContext>;
+export declare const caretMarksDecorationKey: PluginKey<DecorationSet>;
+/**
+ * Google-Docs paragraph mark: an empty block remembers its caret style in
+ * `caretMarks` (JSON marks; '[]' = explicitly cleared, null = never stamped).
+ * See docs/FORMATTING_INHERITANCE.md.
+ */
+export declare const CaretMarks: Extension<any, any>;

package/dist/package/extensions/caret-marks/caret-style.d.ts

@@ -0,0 +1,24 @@
+import { Editor } from '@tiptap/core';
+import { Mark, Node as ProseMirrorNode, Schema } from '@tiptap/pm/model';
+import { Selection } from '@tiptap/pm/state';
+
+export declare const CARET_MARKS_ATTR = "caretMarks";
+/** Both EditorState and Transaction have this shape. */
+export type CaretSource = {
+    storedMarks: readonly Mark[] | null;
+    selection: Selection;
+    doc: ProseMirrorNode;
+};
+export declare const serializeMarks: (marks: readonly Mark[]) => string;
+export declare const parseMarks: (schema: Schema, value: unknown) => Mark[];
+/**
+ * Fill the font properties the marks leave unset from a legacy paragraph's
+ * fontFamily / fontSize attrs (old docs). Explicit marks win.
+ */
+export declare const fillLegacyFont: (schema: Schema, marks: readonly Mark[], legacyBlock: ProseMirrorNode | null) => Mark[];
+/** What typing a character would produce right now, legacy font filled in. */
+export declare const caretStyle: (source: CaretSource, legacyBlock: ProseMirrorNode | null) => Mark[];
+/** Marks Tiptap lets cross a split (everything but link). */
+export declare const filterSplittable: (marks: readonly Mark[], editor: Editor) => Mark[];
+/** A stamp carries the font; a block never holds both the stamp and the legacy attrs. */
+export declare const stampAttrs: (attrs: Record<string, unknown>, style: readonly Mark[]) => Record<string, unknown>;

package/dist/package/extensions/caret-marks/dispatch-context.d.ts

@@ -0,0 +1,32 @@
+import { Mark } from '@tiptap/pm/model';
+import { EditorState, PluginKey, Transaction } from '@tiptap/pm/state';
+
+export type OldCaret = {
+    wasEmpty: boolean;
+    /** Opening position of the pre-root caret block, tracked per step; null once its opening token went. */
+    pos: number | null;
+    /**
+     * marksAcross of the last deletion inside that block; null when nothing was
+     * deleted there. Meaningful only while `pos !== null` (the block survived).
+     */
+    deletedMarks: readonly Mark[] | null;
+};
+export type Pending = {
+    marks: readonly Mark[] | null;
+    explicit: boolean;
+};
+/**
+ * Provenance of the dispatch in progress. ProseMirror's append loop hands a
+ * hook only the transactions it has not seen, so the root's origin, stored
+ * marks and steps live here, rebuilt at every root transaction.
+ */
+export type DispatchContext = {
+    local: boolean;
+    docChanged: boolean;
+    oldCaret: OldCaret | null;
+    pending: Pending | null;
+};
+export declare const EMPTY_CONTEXT: DispatchContext;
+export declare const isRootTransaction: (tr: Transaction) => boolean;
+export declare const isLocalRoot: (tr: Transaction) => boolean;
+export declare const applyDispatchContext: (tr: Transaction, prev: DispatchContext, oldState: EditorState, key: PluginKey) => DispatchContext;

package/dist/package/extensions/caret-marks/index.d.ts

@@ -0,0 +1,3 @@
+export { CaretMarks, caretMarksPluginKey, caretMarksDecorationKey, } from './caret-marks';
+export { CARET_MARKS_ATTR, caretStyle, fillLegacyFont, filterSplittable, parseMarks, serializeMarks, stampAttrs, } from './caret-style';
+export { captureSplit, declareSplit, type SplitCapture, } from './split-declaration';

package/dist/package/extensions/caret-marks/split-declaration.d.ts

@@ -0,0 +1,11 @@
+import { Editor } from '@tiptap/core';
+import { Mark } from '@tiptap/pm/model';
+import { Transaction } from '@tiptap/pm/state';
+
+export type SplitCapture = {
+    style: Mark[];
+    pos: number;
+    sourceWasEmpty: boolean;
+};
+export declare const captureSplit: (tr: Transaction, editor: Editor) => SplitCapture | null;
+export declare const declareSplit: (tr: Transaction, capture: SplitCapture) => void;

package/dist/package/extensions/caret-marks/test-helpers.d.ts

@@ -0,0 +1,72 @@
+import { Editor } from '@tiptap/react';
+import { AnyExtension } from '@tiptap/core';
+import { Mark, Node as ProseMirrorNode } from '@tiptap/pm/model';
+import { Plugin, Transaction } from '@tiptap/pm/state';
+import { UndoManager } from 'yjs';
+
+import * as Y from 'yjs';
+/**
+ * Mounted, Collaboration-backed editor with the production extension set.
+ * Collaboration owns the doc, so content is set after construction; pass
+ * `null` to leave it to a Yjs sync.
+ */
+export declare const makeEditor: (schemaVersion: number, content?: string | null, options?: {
+    ydoc?: Y.Doc;
+    extensions?: AnyExtension[];
+}) => Editor;
+export declare const track: (editor: Editor) => Editor;
+export declare const destroyTracked: () => void;
+/** Position just after the first occurrence of `text`. */
+export declare const endOf: (editor: Editor, text: string) => number;
+export declare const startOf: (editor: Editor, text: string) => number;
+export declare const selectText: (editor: Editor, text: string) => boolean;
+/** A click or arrow key: a selection change and nothing else. */
+export declare const caretTo: (editor: Editor, pos: number) => boolean;
+/**
+ * The real keydown path. `commands.keyboardShortcut('Enter')` replays only
+ * the handler's steps and drops its selection and stored marks.
+ */
+export declare const pressKey: (editor: Editor, key: string) => boolean;
+export declare const pressEnter: (editor: Editor) => boolean;
+/** The transaction the browser produces for typed text (uses storedMarks). */
+export declare const type: (editor: Editor, text?: string) => void;
+export declare const markNames: (marks: readonly Mark[] | null | undefined) => string[];
+/**
+ * Types `x` and reports what the character got — what the user sees. One
+ * character, so a test can read names and textStyle off the same caret.
+ */
+export declare const typedRun: (editor: Editor) => {
+    names: string[];
+    textStyle: import('prosemirror-model').Attrs | null;
+};
+export declare const typedMarks: (editor: Editor) => string[];
+export declare const typedTextStyle: (editor: Editor) => import('prosemirror-model').Attrs | null;
+/**
+ * jsdom has no DOM-change path; this is what prosemirror-view dispatches
+ * for a native deletion: delete, then ensureMarks(marksAcross).
+ */
+export declare const nativeDelete: (editor: Editor, from: number, to: number) => void;
+export declare const backspace: (editor: Editor) => void;
+/** Every textblock in document order, with its opening position. */
+export declare const textblocks: (editor: Editor) => {
+    node: ProseMirrorNode;
+    pos: number;
+}[];
+/** The block Enter created: always the one after the original. */
+export declare const createdBlock: (editor: Editor) => {
+    node: ProseMirrorNode;
+    pos: number;
+};
+export declare const caretBlock: (editor: Editor) => {
+    node: ProseMirrorNode;
+    pos: number;
+};
+export declare const stampOf: (node: ProseMirrorNode | undefined) => string | null;
+export declare const storedMarkNames: (editor: Editor) => string[] | null;
+/** Write a stamp by hand (test setup for stale / pre-existing stamps). */
+export declare const stampBlock: (editor: Editor, pos: number, marks: readonly Mark[] | string) => void;
+/** The y-sync plugin Collaboration registered (its key name is 'y-sync$…'). */
+export declare const ySyncPlugin: (editor: Editor) => Plugin;
+/** Dispatch a transaction tagged as a remote (y-sync) change. */
+export declare const applyRemote: (editor: Editor, mutate: (tr: Transaction) => Transaction) => void;
+export declare const undoManager: (editor: Editor) => UndoManager;

package/dist/package/sync-local/SyncManager.d.ts

@@ -29,6 +29,14 @@ export declare class SyncManager {
     private hydrationIncomplete;
     private wireFormat;
     private lastReportedWriteFormat;
+    private sessionGen;
+    private sendFailures;
+    private sendRetryTimer;
+    private lastConnectConfig;
+    private resumable;
+    private resuming;
+    private resumeFailures;
+    private nextResumeAt;
     getWireFormat(): WireFormat;
     private encryptForWire;
     private emitWireTelemetry;
@@ -54,6 +62,7 @@ export declare class SyncManager {
     updateRefs(_services: CollabServices | undefined, callbacks: CollabCallbacks | undefined, onLocalUpdate?: (updatedDocContent: string, updateChunk: string) => void): void;
     get isConnected(): boolean;
     get isReady(): boolean;
+    get isResuming(): boolean;
     get awareness(): Awareness | null;
     get status(): CollabStatus;
     get collabState(): CollabState;
@@ -64,6 +73,11 @@ export declare class SyncManager {
     private runEntryActions;
     connect(config: CollabConnectionConfig): Promise<void>;
     disconnect(): Promise<void>;
+    /** Reopens a session that ended on a transient loss (see dropToResumableIdle). A cheap
+     *  no-op in every other state, so hosts can call it on each local edit, tab focus and
+     *  network return. */
+    resume(): void;
+    private dropToResumableIdle;
     /** Owner rename mid-session — see SocketClient.updateDocumentMeta. */
     updateTitle(args: {
         encryptedTitle: string;
@@ -80,11 +94,16 @@ export declare class SyncManager {
     private flushUpdates;
     private awaitFlush;
     /**
-     * Fire-and-forget: merge all queued updates, encrypt, and emit via Socket.IO
-     * without awaiting the server ACK. The server broadcasts to peers immediately
-     * (before MongoDB write), so content reaches observers in near-real-time.
+     * Live path: merge the queued updates, encrypt, and emit via Socket.IO without waiting on
+     * earlier acks, so peers see typing at the flush cadence. A batch the server does not ack
+     * is re-queued, never dropped.
      */
     private sendUpdateBatch;
+    private takeBatch;
+    private isUndeliverable;
+    private requeueUnacked;
+    private markSendSucceeded;
+    private scheduleSendRetry;
     private sendUpdateBatchAttempt;
     private isRevocationResponse;
     private isSessionTerminatedResponse;
@@ -112,6 +131,7 @@ export declare class SyncManager {
     private cleanupAwareness;
     private broadcastLocalContents;
     private processUpdateQueue;
+    private removeFromQueue;
     private processNextUpdate;
     private handleRemoteContentUpdate;
     private applyRemoteYjsUpdate;

package/dist/package/sync-local/socketClient.d.ts

@@ -57,7 +57,9 @@ export declare class SocketClient {
     private _socket;
     private _webSocketStatus;
     private _isIntentionalDisconnect;
+    private _pendingAckFailures;
     get isConnected(): boolean;
+    get isSocketOpen(): boolean;
     get status(): SocketStatusEnum;
     private _websocketServiceDid;
     private roomId;
@@ -94,6 +96,7 @@ export declare class SocketClient {
     registerAwareness(awareness: Awareness): void;
     private _stampSocketId;
     private _emitWithAck;
+    private _failPendingAcks;
     private _fetchRoomMembers;
     private _recomputePresence;
     sendUpdate({ update }: {

package/dist/{split-view-toolbar-BGeKurwZ.mjs → split-view-toolbar-hec3sLWd.mjs}

@@ -1,7 +1,7 @@
 import { jsx as m, jsxs as L } from "react/jsx-runtime";
 import { useRef as D, useState as E, useEffect as A } from "react";
 import { DynamicDropdown as P, Tooltip as O, IconButton as T } from "@fileverse/ui";
-import { a3 as _, a4 as w, c as R } from "./index-D4hYioav.mjs";
+import { a3 as _, a4 as w, c as R } from "./index-mGcKslYf.mjs";
 const p = (e, n, o = n) => {
   const { state: i } = e, l = i.changeByRange((t) => {
     const d = i.sliceDoc(t.from, t.to), r = i.sliceDoc(