@dineug/erd-editor 3.9.1 → 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,34 +1,34 @@
-import { Li as e, Tn as t, Zn as n, b as r, c as i, g as a, m as o, rn as s, t as c, tt as l, ya as u } from "../store-hooks-DuNN9ZKu.js";
-import { n as d, t as f } from "../schemaGCService-_8A8Oh9Q.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 = a(b), C = i(S, !1);
-	C.dispatchSync(t({
+	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(r), _(200)), D = /* @__PURE__ */ new Set(), O = new f(), 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((n) => {
 			let r = Reflect.get(n, e);
-			s(r, t);
+			a(r, t);
 		});
-	}, j = (t) => {
-		let r = e(t);
-		C.dispatchSync(l(p(r) ? "{}" : r)), O.run(u(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(n()));
+	}, j = (n) => {
+		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(r), 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 u(C.state);
+			return c(C.state);
 		},
 		on: k,
 		setInitialValue: j,

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

@@ -6,4 +6,10 @@ import { StreamBufferOperator } from './groupByStreamActions';
  * 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/shared-store.d.ts

@@ -8,8 +8,8 @@ export type SharedStore = {
     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.
+     * 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;