@dineug/erd-editor 3.9.0 → 3.9.2

package/README.md

@@ -160,6 +160,24 @@ erd-editor {
 | `change` | The document changed. Debounced, and never fired while `readonly`. Read `editor.value`. |
 | `changePresetTheme` | The theme was changed from inside the editor. `event.detail` carries the new options. |
 
+## Key bindings
+
+`createKeyBindingMap()` returns the shortcuts an editor listens for until `setKeyBindingMap`
+changes them, as a new map on every call. Each is a [tinykeys](https://github.com/jamiebuilds/tinykeys)
+chord that names its key by `KeyboardEvent.code`, where `$mod` is Cmd on macOS and Ctrl elsewhere.
+
+```js
+import { createKeyBindingMap } from '@dineug/erd-editor';
+
+const shortcuts = Object.values(createKeyBindingMap())
+  .flat()
+  .map(({ shortcut }) => shortcut); // '$mod+KeyK', 'Alt+Enter', ...
+```
+
+The editor listens on its own element, so a host that takes keys before the page does, with
+global hotkeys or a capture-phase `keydown` listener, has to let these through while the editor
+is focused. The `KeyBindingMap`, `KeyBindingName` and `ShortcutOption` types come with it.
+
 ## Syntax highlighting
 
 The SQL and code-generation panels are highlighted by [Shiki](https://shiki.style), in a shared

package/dist/engine/index.js

@@ -1,33 +1,34 @@
-import { $i as e, Ln as t, Xt as n, Z as r, _ as i, fn as a, h as o, n as s, r as c, t as l, u, x as d, xi as f } from "../schemaGCService-CFiz1xOG.js";
+import { Ii as e, Xn as t, c as n, et as r, h as i, nn as a, p as o, t as s, va as c, wn as l, y as u } from "../store-hooks-DuzDVhPy.js";
+import { n as d, t as f } from "../schemaGCService-BagQ1wfF.js";
 import { isEmpty as p } from "es-toolkit/compat";
 import { omit as m } from "es-toolkit";
 import { Observable as h, Subject as g, debounceTime as _, map as v } from "rxjs";
 //#region src/engine/replication-store.ts
 var y = { change: "change" };
 function b(b) {
-	let x = /* @__PURE__ */ new Set(), S = i(b), C = u(S, !1);
-	C.dispatchSync(a({
+	let x = /* @__PURE__ */ new Set(), S = i(b), C = n(S, !1);
+	C.dispatchSync(l({
 		width: 0,
 		height: 0
 	}));
-	let w = c(C), T = new g(), E = new h((e) => C.subscribe((t) => e.next(t))).pipe(o(d), _(200)), D = /* @__PURE__ */ new Set(), O = new l(), k = (e) => (D.has(e) || D.add(e), () => {
+	let w = s(C), T = new g(), E = new h((e) => C.subscribe((t) => e.next(t))).pipe(o(u), _(200)), D = /* @__PURE__ */ new Set(), O = new f(), k = (e) => (D.has(e) || D.add(e), () => {
 		D.delete(e);
 	}), A = (e, t) => {
-		D.forEach((r) => {
-			let i = Reflect.get(r, e);
-			n(i, t);
+		D.forEach((n) => {
+			let r = Reflect.get(n, e);
+			a(r, t);
 		});
 	}, j = (n) => {
-		let i = f(n);
-		C.dispatchSync(r(p(i) ? "{}" : i)), O.run(e(C.state)).then((e) => {
-			(e.tableIds.length || e.tableColumnIds.length || e.relationshipIds.length || e.indexIds.length || e.indexColumnIds.length || e.memoIds.length) && (s(C.state, e), C.dispatchSync(t()));
+		let i = e(n);
+		C.dispatchSync(r(p(i) ? "{}" : i)), O.run(c(C.state)).then((e) => {
+			(e.tableIds.length || e.tableColumnIds.length || e.relationshipIds.length || e.indexIds.length || e.indexColumnIds.length || e.memoIds.length) && (d(C.state, e), C.dispatchSync(t()));
 		});
 	}, M = (e) => {
 		T.next([e].flat());
 	};
-	return x.add(E.subscribe(() => A(y.change, void 0))).add(T.pipe(o(d), v((e) => e.map((e) => m(e, ["tags"])))).subscribe(C.dispatchSync)), Object.freeze({
+	return x.add(E.subscribe(() => A(y.change, void 0))).add(T.pipe(o(u), v((e) => e.map((e) => m(e, ["tags"])))).subscribe(C.dispatchSync)), Object.freeze({
 		get value() {
-			return e(C.state);
+			return c(C.state);
 		},
 		on: k,
 		setInitialValue: j,

package/dist/engine/modules/relationship/fkColumns.d.ts

@@ -0,0 +1,9 @@
+import { AnyAction } from '@dineug/r-html';
+import { Column } from '../../../internal-types';
+/**
+ * Adds a NOT NULL copy of each start column to the end table under the id at
+ * the same index of endColumnIds, carrying its name, data type, default and
+ * comment. The caller owns the ids because the relationship needs them too.
+ */
+export declare const toForeignKeyActions: (startColumns: Column[], endTableId: string, endColumnIds: string[]) => AnyAction[];
+//# sourceMappingURL=fkColumns.d.ts.map

package/dist/engine/modules/relationship/generator.actions.d.ts

@@ -1,2 +1,11 @@
-export declare const actions$: {};
+import { GeneratorAction } from '../../generator.actions';
+/**
+ * Draws a relationship between two live tables in one batch, giving the start
+ * table a primary key first when it has none and copying the keys onto the end
+ * table, which may be the start table itself. An unknown table yields nothing.
+ */
+export declare const addRelationshipAction$: (startTableId: string, endTableId: string, relationshipType: number) => GeneratorAction;
+export declare const actions$: {
+    addRelationshipAction$: (startTableId: string, endTableId: string, relationshipType: number) => GeneratorAction;
+};
 //# sourceMappingURL=generator.actions.d.ts.map

package/dist/engine/modules/table/generator.actions.d.ts

@@ -4,10 +4,17 @@ export declare const addTableAction$: () => GeneratorAction;
 export declare const removeTableAction$: (id?: string) => GeneratorAction;
 export declare const selectTableAction$: (id: string, $mod: boolean) => GeneratorAction;
 export declare const pasteTableAction$: (columns: Column[]) => GeneratorAction;
+/**
+ * Runs the engine's sort once, on copies of the live tables, and places each
+ * table at the point it found. A replayed table.sort measures each replica's
+ * own text, so only the placed points come out the same everywhere.
+ */
+export declare const sortTablesToMoveAction$: () => GeneratorAction;
 export declare const actions$: {
     addTableAction$: () => GeneratorAction;
     removeTableAction$: (id?: string) => GeneratorAction;
     selectTableAction$: (id: string, $mod: boolean) => GeneratorAction;
     pasteTableAction$: (columns: Column[]) => GeneratorAction;
+    sortTablesToMoveAction$: () => GeneratorAction;
 };
 //# sourceMappingURL=generator.actions.d.ts.map

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,15 @@
+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;
+/**
+ * Closes a stream buffer after groupByStreamActions' 200 ms quiet period, or
+ * at once when the notifier fires: the editor keeps its timing, and a host
+ * can still send what is held before it lets the store go.
+ */
+export declare const quietPeriodOrNotifier: (notifier$: Observable<unknown>, quietMs?: number) => 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

@@ -9,11 +9,23 @@ export type RxStore = Store & {
     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, rather than
+     * after their quiet period: what a host calls before it lets a store go.
+     */
+    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/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