@dineug/erd-editor 3.8.0 → 3.9.1

package/dist/engine/peer-store.d.ts

@@ -0,0 +1,93 @@
+import { AnyAction, CompositionActions } from '@dineug/r-html';
+import { FocusType } from './modules/editor/state';
+import { RootState } from './state';
+import { Unsubscribe, ValuesType } from '../internal-types';
+export type PeerStoreOptions = {
+    nickname: string;
+    toWidth?: (text: string) => number;
+    /** Sends the focused cell to the other peers. A headless session turns it off. */
+    presence?: boolean;
+    /** Refuses every dispatch, undo and redo, as a readonly document does. */
+    readonly?: boolean;
+};
+/** The cell to focus before an edit, so the others see where the peer works. */
+export type DispatchFocus = {
+    tableId: string;
+    columnId?: string;
+    focusType: FocusType;
+};
+export type DispatchOptions = {
+    /** Names the dispatch as one undo unit, echoed back by undo and redo. */
+    label?: string;
+    focus?: DispatchFocus;
+};
+export type DispatchReport = {
+    label: string | null;
+    /** The document changes the dispatch made, version stamped, in order. */
+    actions: AnyAction[];
+    createdIds: string[];
+    /** Outbound batches that carried a document change. */
+    batches: number;
+    /** Undo entries the history took in. */
+    historyEntries: number;
+};
+/**
+ * What an undo or redo reverted: the dispatch's label, how many history
+ * entries it took, and the labels passed over because the engine made them
+ * no undo entry. Zero entries means there was nothing left to revert.
+ */
+export type RevertResult = {
+    label: string | null;
+    entries: number;
+    skipped: string[];
+};
+/** Why a peer store refused a call before dispatching anything. */
+export declare const PeerStoreErrorCode: {
+    readonly readonly: "readonly";
+    readonly destroyed: "destroyed";
+};
+export type PeerStoreErrorCode = ValuesType<typeof PeerStoreErrorCode>;
+/** A refusal: the code says why, operation names the call, and nothing moved. */
+export declare class PeerStoreError extends Error {
+    readonly code: PeerStoreErrorCode;
+    readonly operation: string;
+    constructor(code: PeerStoreErrorCode, operation: string);
+}
+export type PeerStore = {
+    readonly editorId: string;
+    /** The document as the element would save it. */
+    readonly value: string;
+    /** The live state, for readers that serialize it another way. */
+    readonly state: RootState;
+    readonly isReadonly: boolean;
+    readonly isDestroyed: boolean;
+    setReadonly: (readonly: boolean) => void;
+    /**
+     * Replaces the document and forgets every undo entry and label with it,
+     * since those were taken against the old one. The one reseed operation.
+     */
+    setInitialValue: (value: string) => void;
+    mergeClock: (version: number) => void;
+    dispatch: (actions: CompositionActions, options?: DispatchOptions) => DispatchReport;
+    /** Applies another peer's batch now, so a read right after sees it. */
+    receive: (actions: AnyAction[] | AnyAction) => void;
+    /**
+     * Runs dispatches as one undo unit under label, so one undo reverts every
+     * entry they made. A group inside another joins it; undo, redo and a reseed
+     * are refused inside one, since the unit would no longer match the history.
+     */
+    group: <T>(label: string, run: () => T) => T;
+    undo: () => RevertResult;
+    redo: () => RevertResult;
+    subscribe: (fn: (actions: AnyAction[]) => void) => Unsubscribe;
+    /** Closes the history's stream groups, then the outbound pipe's. */
+    flushStreamBuffers: () => void;
+    destroy: () => void;
+};
+/**
+ * A collaborating editor with no screen: the element's store pipeline, driven
+ * by dispatches instead of a pointer. Stream buffers close when a dispatch
+ * ends rather than after a quiet period, so one dispatch is one outbound batch.
+ */
+export declare function createPeerStore({ nickname, toWidth, presence, readonly, }: PeerStoreOptions): PeerStore;
+//# sourceMappingURL=peer-store.d.ts.map

package/dist/engine/presence.d.ts

@@ -0,0 +1,23 @@
+import { Editor } from './modules/editor/state';
+import { RxStore } from './rx-store';
+/** A third of the expiry, so two beats can go missing before a peer drops the cell. */
+export declare const FOCUS_HEARTBEAT_MS: number;
+export type FocusPresence = {
+    destroy: () => void;
+};
+declare const SHARED_TRACKER_MAPS: readonly ["sharedMouseTrackerMap", "sharedFocusTrackerMap", "sharedSelectionTrackerMap", "sharedDragSelectTrackerMap"];
+type SharedTrackerMaps = Pick<Editor, (typeof SHARED_TRACKER_MAPS)[number]>;
+/**
+ * Clears the expiry the engine set on every tracker another peer sent, and the
+ * trackers with it. A pending expiry is a Node timer the reducer never releases,
+ * so a closed peer's process would wait up to 90 seconds for it.
+ */
+export declare function clearSharedTrackers(editor: SharedTrackerMaps): void;
+/**
+ * The focus half of the element's presence tracker: the focused cell goes out
+ * when it changes, again on every heartbeat and whenever a peer joins. Mouse,
+ * selection and drag selection are never sent.
+ */
+export declare function createFocusPresence(store: Pick<RxStore, 'state' | 'subscribe' | 'dispatch'>): FocusPresence;
+export {};
+//# sourceMappingURL=presence.d.ts.map

package/dist/engine/rx-operators/bufferCircuitBreaker.d.ts

@@ -1,4 +1,9 @@
 import { AnyAction } from '@dineug/r-html';
 import { Observable } from 'rxjs';
+/**
+ * Holds the source's batches while the circuit is open, flushes them when it
+ * closes and lets batches straight through until it opens again. The source is
+ * subscribed once, so a cold upstream's timers cannot flush ahead of its value.
+ */
 export declare const bufferCircuitBreaker: (openingNotifier$: Observable<any>, closingNotifier$: Observable<any>) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
 //# sourceMappingURL=bufferCircuitBreaker.d.ts.map

package/dist/engine/rx-operators/createSharedStreamActionsCompressor.d.ts

@@ -0,0 +1,10 @@
+import { AnyAction } from '@dineug/r-html';
+import { Observable } from 'rxjs';
+import { StreamBufferOperator } from './groupByStreamActions';
+/**
+ * Builds the outbound compressor around what closes an edit stream's group,
+ * left to groupByStreamActions' 200 ms quiet period when omitted. Presence
+ * keeps its own 100 ms throttle either way.
+ */
+export declare const createSharedStreamActionsCompressor: (streamBufferOperator?: StreamBufferOperator) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+//# sourceMappingURL=createSharedStreamActionsCompressor.d.ts.map

package/dist/engine/rx-operators/flushOnNotifier.d.ts

@@ -0,0 +1,9 @@
+import { Observable } from 'rxjs';
+import { StreamBufferOperator } from './groupByStreamActions';
+/**
+ * Closes a stream buffer when the notifier fires instead of after a quiet
+ * period. A group arms only once it holds a value, so a tick with nothing
+ * pending emits nothing and an extra tick is harmless.
+ */
+export declare const flushOnNotifier: (notifier$: Observable<unknown>) => StreamBufferOperator;
+//# sourceMappingURL=flushOnNotifier.d.ts.map

package/dist/engine/rx-operators/groupByStreamActions.d.ts

@@ -1,6 +1,8 @@
 import { AnyAction } from '@dineug/r-html';
 import { MonoTypeOperatorFunction, Observable } from 'rxjs';
 type Regroup = [string, Array<string> | ReadonlyArray<string>];
-export declare const groupByStreamActions: (streamActionTypes: Array<string> | ReadonlyArray<string>, regroups?: Regroup[], bufferClosingNotifierOperator?: MonoTypeOperatorFunction<Array<AnyAction>>) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+/** Runs on a stream group's batches; each value it emits closes the buffer. */
+export type StreamBufferOperator = MonoTypeOperatorFunction<Array<AnyAction>>;
+export declare const groupByStreamActions: (streamActionTypes: Array<string> | ReadonlyArray<string>, regroups?: Regroup[], bufferClosingNotifierOperator?: StreamBufferOperator) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
 export {};
 //# sourceMappingURL=groupByStreamActions.d.ts.map

package/dist/engine/rx-operators/sharedStreamActionsCompressor.d.ts

@@ -1,4 +1,3 @@
-import { AnyAction } from '@dineug/r-html';
-import { Observable } from 'rxjs';
-export declare const sharedStreamActionsCompressor: (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+/** The editor's compressor: a 200 ms quiet period closes each stream group. */
+export declare const sharedStreamActionsCompressor: (source$: import('rxjs').Observable<Array<import('@dineug/r-html').AnyAction>>) => import('rxjs').Observable<import('@dineug/r-html').AnyAction[]>;
 //# sourceMappingURL=sharedStreamActionsCompressor.d.ts.map

package/dist/engine/rx-store.d.ts

@@ -7,12 +7,25 @@ export type RxStore = Store & {
     undo: () => void;
     redo: () => void;
     history: History;
+    resetHistory: () => void;
     change$: Observable<Array<AnyAction>>;
+    /**
+     * Closes the stream groups the history is still buffering, now. A no-op
+     * unless the store was created with manualStreamFlush.
+     */
+    flushStreamBuffers: () => void;
 };
 export type RxStoreOptions = {
     getReadonly?: () => boolean;
     getHistory?: (options: HistoryOptions) => History;
+    /** Closes stream buffers on flushStreamBuffers() instead of after 200 ms. */
+    manualStreamFlush?: boolean;
+    /**
+     * Keeps the state a plain object when false. Nothing renders from a
+     * headless store, and the reactive proxy reads DOM globals Node lacks.
+     */
+    observable?: boolean;
 };
 export declare const HISTORY_LIMIT = 2048;
-export declare function createRxStore(context: EngineContext, { getReadonly, getHistory }?: RxStoreOptions): RxStore;
+export declare function createRxStore(context: EngineContext, { getReadonly, getHistory, manualStreamFlush, observable, }?: RxStoreOptions): RxStore;
 //# sourceMappingURL=rx-store.d.ts.map

package/dist/engine/shared-store.d.ts

@@ -7,10 +7,20 @@ export type SharedStore = {
     dispatch: (actions: Array<AnyAction> | AnyAction) => void;
     dispatchSync: (actions: Array<AnyAction> | AnyAction) => void;
     subscribe: (fn: (value: AnyAction[]) => void) => Unsubscribe;
+    /**
+     * Sends the stream groups still held back from the peers, now. A no-op
+     * unless the store was created with manualStreamFlush.
+     */
+    flushStreamBuffers: () => void;
     destroy: () => void;
 };
 export type SharedStoreConfig = {
     getNickname?: () => string;
 };
-export declare function createSharedStore(store: RxStore, config?: SharedStoreConfig): SharedStore;
+/** Not part of getSharedStore's config: only a headless peer sets this. */
+export type SharedStoreInternalOptions = {
+    /** Closes stream buffers on flushStreamBuffers() instead of after 200 ms. */
+    manualStreamFlush?: boolean;
+};
+export declare function createSharedStore(store: RxStore, config?: SharedStoreConfig, internal?: SharedStoreInternalOptions): SharedStore;
 //# sourceMappingURL=shared-store.d.ts.map

package/dist/engine/stream-flush.d.ts

@@ -0,0 +1,12 @@
+import { RxStore } from './rx-store';
+import { SharedStore } from './shared-store';
+export type StreamFlusher = {
+    /** History first, then the outbound pipe, so a batch never precedes its undo entry. */
+    flush: () => void;
+};
+/**
+ * Closes both stores' stream buffers now. Each store knows how many ticks its
+ * own pipe needs, so this knows neither the tick count nor any rxjs type.
+ */
+export declare function createStreamFlusher(rxStore: Pick<RxStore, 'flushStreamBuffers'>, sharedStore: Pick<SharedStore, 'flushStreamBuffers'>): StreamFlusher;
+//# sourceMappingURL=stream-flush.d.ts.map

package/dist/engine/tag.d.ts

@@ -4,6 +4,8 @@ export declare const Tag: {
     readonly shared: 1;
     readonly changeOnly: 2;
     readonly following: 4;
+    /** A step a pointer drag streams, where an undo of the same move is one jump. */
+    readonly drag: 8;
 };
 export declare function attachActionTag(tag: number, action: AnyAction): AnyAction;
 export declare function attachActionsTag(tag: number, actions: AnyAction[]): AnyAction[];

package/dist/engine/to-width.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The text width a peer measures with no canvas, the same estimate the
+ * replica worker falls back to. A reload recalculates every width, so an
+ * estimate written by a headless edit never outlives the next open.
+ */
+export declare const defaultToWidth: (text: string) => number;
+//# sourceMappingURL=to-width.d.ts.map