@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/generator-code/typescript.js

@@ -0,0 +1,67 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { orderByNameASC } from "../tableName.js";
+import { getNameCase } from "./utils.js";
+import { getJsonShape, isNullableColumn, toTypeScriptPropertyKey, toTypeScriptTypeName } from "./jsonShape.js";
+import { formatComment } from "./zod.js";
+//#region src/utils/generator-code/typescript.ts
+var INDENT = "  ";
+var TYPES = {
+	boolean: "boolean",
+	integer: "number",
+	number: "number",
+	string: "string",
+	uuid: "string",
+	guid: "string",
+	date: "string",
+	time: "string",
+	naiveDateTime: "string",
+	offsetDateTime: "string",
+	base64: "string",
+	json: "unknown",
+	ipv4: "string",
+	ipv6: "string",
+	null: "null"
+};
+var NULL_HOLDING_TYPES = /* @__PURE__ */ new Set(["unknown", "null"]);
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const stringBuffer = [""];
+	query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).forEach((table) => {
+		formatTable(state, {
+			buffer: stringBuffer,
+			table
+		});
+		stringBuffer.push("");
+	});
+	return stringBuffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const { settings: { tableNameCase }, collections } = state;
+	const typeName = toTypeScriptTypeName(getNameCase(table.name, tableNameCase));
+	formatComment(buffer, "", table.comment);
+	buffer.push(`export interface ${typeName} {`);
+	query(collections).collection("tableColumnEntities").selectByIds(table.columnIds).forEach((column) => {
+		formatColumn(state, {
+			buffer,
+			column
+		});
+	});
+	buffer.push(`}`);
+}
+function formatColumn({ settings: { columnNameCase, database } }, { buffer, column }) {
+	const key = toTypeScriptPropertyKey(getNameCase(column.name, columnNameCase));
+	const type = toTypeScriptType(getJsonShape(column.dataType, database), isNullableColumn(column));
+	formatComment(buffer, INDENT, column.comment);
+	buffer.push(`${INDENT}${key}: ${type};`);
+}
+function toTypeScriptType(shape, nullable) {
+	const element = elementType(shape);
+	const isUnion = shape.kind === "enum" && shape.members.length > 1;
+	const type = shape.arrayDepth === 0 ? element : `${isUnion ? `(${element})` : element}${"[]".repeat(shape.arrayDepth)}`;
+	return nullable && !NULL_HOLDING_TYPES.has(type) ? `${type} | null` : type;
+}
+function elementType({ kind, members }) {
+	return kind === "enum" ? members.map((member) => JSON.stringify(member)).join(" | ") : TYPES[kind];
+}
+//#endregion
+export { createCode, formatTable };

package/dist/utils/generator-code/utils.js

@@ -0,0 +1,87 @@
+import { Database, NameCase, ReferentialActionToSQL, RelationshipType } from "../../constants/schema.js";
+import { arrayHas } from "../arrayHas.js";
+import { pascalCase } from "../index.js";
+import { DatabaseHintMap } from "../../constants/sql/dataType/index.js";
+import { ALL_REFERENTIAL_ACTIONS } from "../schema-sql/utils.js";
+import { camelCase, snakeCase } from "es-toolkit";
+//#region src/utils/generator-code/utils.ts
+var hasOneRelationship = arrayHas([RelationshipType.ZeroOne, RelationshipType.OneOnly]);
+var hasNRelationship = arrayHas([RelationshipType.ZeroN, RelationshipType.OneN]);
+var WORD = /[0-9A-Za-z_]/;
+var ARGUMENTS = /\([^)]*\)/g;
+var WHITESPACE = /\s+/g;
+var NUMBER_ARGUMENTS = /^\s*number\s*\(\s*(\*|\d+)\s*,\s*(\d+)\s*\)\s*$/i;
+var FLOAT_PRECISION = /^\s*float\s*\(\s*(\d+)\s*\)/i;
+var FLOAT_PRECISION_DATABASES = /* @__PURE__ */ new Set([
+	Database.MariaDB,
+	Database.MSSQL,
+	Database.MySQL,
+	Database.PostgreSQL
+]);
+var LINE_TERMINATOR = /\r\n|[\n\r\u2028\u2029]/;
+function getPrimitiveType(dataType, database) {
+	if (fractionalNumber(dataType, database)) return "decimal";
+	const hint = findDataTypeHint(dataType, database);
+	const precision = Number(FLOAT_PRECISION.exec(dataType)?.[1]);
+	if (precision >= 1 && precision <= 53 && hint?.name.toLowerCase() === "float" && FLOAT_PRECISION_DATABASES.has(database)) return precision <= 24 ? "float" : "double";
+	return hint?.primitiveType ?? "string";
+}
+function findDataTypeHint(dataType, database) {
+	const value = dataType.toLowerCase().replace(ARGUMENTS, "");
+	let matched;
+	for (const dataTypeHint of getDataTypeHints(database)) {
+		const name = dataTypeHint.name.toLowerCase();
+		if (value.indexOf(name) === 0 && !WORD.test(value.charAt(name.length)) && (!matched || name.length > matched.name.length)) matched = dataTypeHint;
+	}
+	return matched;
+}
+function fractionalNumber(dataType, database) {
+	if (database !== Database.Oracle && database !== Database.Snowflake) return null;
+	const matched = NUMBER_ARGUMENTS.exec(dataType);
+	if (!matched) return null;
+	const [, precision, scale] = matched;
+	if (Number(scale) === 0) return null;
+	return [precision === "*" ? 38 : Number(precision), Number(scale)];
+}
+function baseTypeName(dataType) {
+	return dataType.toLowerCase().replace(ARGUMENTS, " ").replace(WHITESPACE, " ").trim();
+}
+function splitLines(value) {
+	return value.split(LINE_TERMINATOR);
+}
+var TYPESCRIPT_DIRECTIVE = /^(\s*)@(?=ts-)/i;
+function escapeTypeScriptDirective(line) {
+	return line.replace(TYPESCRIPT_DIRECTIVE, "$1\\@");
+}
+function getDataTypeHints(database) {
+	return DatabaseHintMap[database] ?? [];
+}
+function getNameCase(name, nameCase) {
+	let changeName = name;
+	switch (nameCase) {
+		case NameCase.camelCase:
+			changeName = camelCase(name);
+			break;
+		case NameCase.pascalCase:
+			changeName = pascalCase(name);
+			break;
+		case NameCase.snakeCase: changeName = snakeCase(name);
+	}
+	return changeName;
+}
+function referentialActionEntries({ onDelete, onUpdate }, support = ALL_REFERENTIAL_ACTIONS) {
+	const entries = [];
+	if (support.onDelete.includes(onDelete)) entries.push({
+		key: "onDelete",
+		action: onDelete,
+		sql: ReferentialActionToSQL[onDelete]
+	});
+	if (support.onUpdate.includes(onUpdate)) entries.push({
+		key: "onUpdate",
+		action: onUpdate,
+		sql: ReferentialActionToSQL[onUpdate]
+	});
+	return entries;
+}
+//#endregion
+export { LINE_TERMINATOR, baseTypeName, escapeTypeScriptDirective, findDataTypeHint, fractionalNumber, getDataTypeHints, getNameCase, getPrimitiveType, hasNRelationship, hasOneRelationship, referentialActionEntries, splitLines };

package/dist/utils/generator-code/zod.js

@@ -0,0 +1,106 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { orderByNameASC } from "../tableName.js";
+import { escapeTypeScriptDirective, getNameCase, splitLines } from "./utils.js";
+import { getJsonShape, isNullableColumn, toTypeScriptPropertyKey, toTypeScriptTypeName } from "./jsonShape.js";
+//#region src/utils/generator-code/zod.ts
+var IMPORT_LINE = "import * as z from \"zod\";";
+var INDENT = "  ";
+var INT32_MIN = -2147483648;
+var INT32_MAX = 2147483647;
+var UINT32_MAX = 4294967295;
+var SCHEMAS = {
+	boolean: "z.boolean()",
+	number: "z.number()",
+	uuid: "z.uuid()",
+	guid: "z.guid()",
+	date: "z.iso.date()",
+	time: "z.iso.time()",
+	naiveDateTime: "z.iso.datetime({ local: true })",
+	offsetDateTime: "z.iso.datetime({ offset: true })",
+	base64: "z.base64()",
+	json: "z.json()",
+	ipv4: "z.ipv4()",
+	ipv6: "z.ipv6()",
+	null: "z.null()"
+};
+var ZOD_RESERVED_TYPE_NAMES = /* @__PURE__ */ new Set(["as", "z"]);
+function createCode(state) {
+	const { doc: { tableIds }, collections } = state;
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC);
+	if (tables.length === 0) return "";
+	const buffer = ["", IMPORT_LINE];
+	tables.forEach((table) => {
+		buffer.push("");
+		formatTable(state, {
+			buffer,
+			table
+		});
+	});
+	buffer.push("");
+	return buffer.join("\n");
+}
+function createTableCode(state, table) {
+	const buffer = [
+		"",
+		IMPORT_LINE,
+		""
+	];
+	formatTable(state, {
+		buffer,
+		table
+	});
+	buffer.push("");
+	return buffer.join("\n");
+}
+function formatTable(state, { buffer, table }) {
+	const { settings: { tableNameCase }, collections } = state;
+	const typeName = toZodTypeName(getNameCase(table.name, tableNameCase));
+	const schemaName = `${typeName}Schema`;
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	formatComment(buffer, "", table.comment);
+	if (columns.length === 0) buffer.push(`export const ${schemaName} = z.object({});`);
+	else {
+		buffer.push(`export const ${schemaName} = z.object({`);
+		columns.forEach((column) => formatColumn(state, buffer, column));
+		buffer.push("});");
+	}
+	buffer.push(`export type ${typeName} = z.infer<typeof ${schemaName}>;`);
+}
+function formatColumn({ settings: { columnNameCase, database } }, buffer, column) {
+	const key = getNameCase(column.name, columnNameCase);
+	const schema = toZodSchema(getJsonShape(column.dataType, database));
+	formatComment(buffer, INDENT, column.comment);
+	buffer.push(`${INDENT}${toZodPropertyKey(key)}: ${schema}${isNullableColumn(column) ? ".nullable()" : ""},`);
+}
+function toZodSchema(shape) {
+	let schema = elementSchema(shape);
+	for (let depth = 0; depth < shape.arrayDepth; depth++) schema = `z.array(${schema})`;
+	return schema;
+}
+function toZodTypeName(name) {
+	return ZOD_RESERVED_TYPE_NAMES.has(name) ? `${name}_` : toTypeScriptTypeName(name);
+}
+function toZodPropertyKey(name) {
+	return name === "__proto__" ? "[\"__proto__\"]" : toTypeScriptPropertyKey(name);
+}
+function formatComment(buffer, indent, comment) {
+	const lines = splitLines(comment).map((line) => escapeTypeScriptDirective(line.trimEnd()));
+	while (lines.length > 0 && lines[0] === "") lines.shift();
+	while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+	lines.forEach((line) => buffer.push(line === "" ? `${indent}//` : `${indent}// ${line}`));
+}
+function elementSchema(shape) {
+	switch (shape.kind) {
+		case "integer": return integerSchema(shape);
+		case "string": return shape.maxLength === null ? "z.string()" : `z.string().max(${shape.maxLength})`;
+		case "enum": return `z.enum([${shape.members.map((member) => JSON.stringify(member)).join(", ")}])`;
+	}
+	return SCHEMAS[shape.kind];
+}
+function integerSchema({ minimum, maximum }) {
+	if (minimum === INT32_MIN && maximum === INT32_MAX) return "z.int32()";
+	if (minimum === 0 && maximum === UINT32_MAX) return "z.uint32()";
+	return `z.int()${minimum === null ? "" : `.min(${minimum})`}${maximum === null ? "" : `.max(${maximum})`}`;
+}
+//#endregion
+export { createCode, createTableCode, formatComment, formatTable, toZodPropertyKey, toZodSchema, toZodTypeName };

package/dist/utils/globalEventObservable.js

@@ -0,0 +1,67 @@
+import { isMiddleButtonPress, isMouseEvent } from "./domEvent.js";
+import { forwardMoveStartEvent } from "./internalEvents.js";
+import { animationFrames, defer, filter, fromEvent, map, merge, share, takeUntil } from "rxjs";
+//#region src/utils/globalEventObservable.ts
+function windowEvent$(type) {
+	return defer(() => fromEvent(window, type));
+}
+windowEvent$("keyup");
+var mousedown$ = windowEvent$("mousedown");
+var mousemove$ = windowEvent$("mousemove");
+var mouseup$ = windowEvent$("mouseup");
+var touchstart$ = windowEvent$("touchstart");
+var touchmove$ = windowEvent$("touchmove");
+var touchend$ = windowEvent$("touchend");
+var dragstart$ = windowEvent$("dragstart");
+var pointercancel$ = windowEvent$("pointercancel");
+var windowBlur$ = windowEvent$("blur");
+var animationFrames$ = animationFrames().pipe(share());
+var forwardMoveStartEvent$ = windowEvent$(forwardMoveStartEvent.type).pipe(map((event) => event.detail.originEvent));
+var moveStart$ = merge(mousedown$, touchstart$, forwardMoveStartEvent$);
+function middlePanPress$(target) {
+	return fromEvent(target, forwardMoveStartEvent.type).pipe(map(({ detail }) => detail.originEvent), filter(isMiddleButtonPress));
+}
+var moveEnd$ = merge(mouseup$, touchend$, dragstart$, pointercancel$, windowBlur$);
+var prevX = 0;
+var prevY = 0;
+if (typeof window !== "undefined") moveStart$.subscribe((event) => {
+	if (isMouseEvent(event)) {
+		prevX = event.clientX;
+		prevY = event.clientY;
+	} else {
+		prevX = event.touches[0].clientX;
+		prevY = event.touches[0].clientY;
+	}
+});
+var move$ = merge(mousemove$.pipe(map((event) => {
+	const x = event.clientX;
+	const y = event.clientY;
+	const movementX = x - prevX;
+	const movementY = y - prevY;
+	prevX = x;
+	prevY = y;
+	return {
+		event,
+		movementX,
+		movementY,
+		x,
+		y
+	};
+})), touchmove$.pipe(filter((event) => event.touches.length === 1), map((event) => {
+	const x = event.touches[0].clientX;
+	const y = event.touches[0].clientY;
+	const movementX = x - prevX;
+	const movementY = y - prevY;
+	prevX = x;
+	prevY = y;
+	return {
+		event,
+		movementX,
+		movementY,
+		x,
+		y
+	};
+})));
+var drag$ = move$.pipe(takeUntil(moveEnd$));
+//#endregion
+export { animationFrames$, drag$, middlePanPress$, mousedown$, mousemove$, mouseup$, move$, moveEnd$, moveStart$, touchend$, touchmove$, touchstart$ };

package/dist/utils/highlightWords.js

@@ -0,0 +1,48 @@
+import { escapeRegExp } from "es-toolkit";
+//#region src/utils/highlightWords.ts
+function findChunks({ searchWords, textToHighlight, caseSensitive = false }) {
+	return searchWords.filter((word) => word).flatMap((word) => {
+		const pattern = new RegExp(escapeRegExp(word), caseSensitive ? "g" : "gi");
+		return Array.from(textToHighlight.matchAll(pattern), (match) => ({
+			start: match.index,
+			end: match.index + match[0].length
+		}));
+	});
+}
+function combineRanges(ranges) {
+	const combined = [];
+	for (const range of [...ranges].sort((a, b) => a.start - b.start)) {
+		const last = combined[combined.length - 1];
+		if (last && range.start <= last.end) combined[combined.length - 1] = {
+			start: last.start,
+			end: Math.max(last.end, range.end)
+		};
+		else combined.push(range);
+	}
+	return combined;
+}
+function findAll({ searchWords, textToHighlight, caseSensitive, findChunks: find = findChunks }) {
+	const lit = combineRanges(find({
+		searchWords,
+		textToHighlight,
+		caseSensitive
+	}));
+	const chunks = [];
+	const append = (start, end, highlight) => {
+		if (end > start) chunks.push({
+			start,
+			end,
+			highlight
+		});
+	};
+	let lastIndex = 0;
+	for (const { start, end } of lit) {
+		append(lastIndex, start, false);
+		append(start, end, true);
+		lastIndex = end;
+	}
+	append(lastIndex, textToHighlight.length, false);
+	return chunks;
+}
+//#endregion
+export { findAll, findChunks };

package/dist/utils/icon.js

@@ -0,0 +1,35 @@
+import { RelationshipType } from "../constants/schema.js";
+import { ICON_VIEW_BOX, getIcon } from "../components/primitives/icon/icons.js";
+//#region src/utils/icon.ts
+var relationshipTypeToIconName = {
+	[1]: "ZeroOneN",
+	[RelationshipType.ZeroOne]: "ZeroOne",
+	[RelationshipType.ZeroN]: "ZeroN",
+	[RelationshipType.OneOnly]: "OneOnly",
+	[RelationshipType.OneN]: "OneN",
+	[32]: "One",
+	[64]: "N"
+};
+var CURSOR_SIZE = 32;
+var CURSOR_HALO_WIDTH = 4;
+var BLACK = "#000";
+var WHITE = "#fff";
+var escapeAttribute = (value) => String(value).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+var element = ([tag, attrs]) => {
+	return `<${tag}${Object.entries(attrs).filter(([, value]) => value !== void 0).map(([key, value]) => ` ${key}="${escapeAttribute(value)}"`).join("")}/>`;
+};
+var layer = (children, stroke, strokeWidth) => `<g stroke="${stroke}" stroke-width="${strokeWidth}">${children}</g>`;
+function toCursorImage(node, isDarkMode) {
+	const ink = isDarkMode ? WHITE : BLACK;
+	const halo = isDarkMode ? BLACK : WHITE;
+	const children = node.map(element).join("");
+	const markup = `<svg xmlns="http://www.w3.org/2000/svg" width="${CURSOR_SIZE}" height="${CURSOR_SIZE}" viewBox="${ICON_VIEW_BOX}" fill="none" stroke-linecap="round" stroke-linejoin="round">` + layer(children, halo, CURSOR_HALO_WIDTH) + layer(children, ink, 2) + "</svg>";
+	return `data:image/svg+xml,${encodeURIComponent(markup)}`;
+}
+function getRelationshipIcon(relationshipType, isDarkMode) {
+	const icon = getIcon(relationshipTypeToIconName[relationshipType]);
+	if (!icon) return null;
+	return toCursorImage(icon.node, isDarkMode);
+}
+//#endregion
+export { getRelationshipIcon, toCursorImage };

package/dist/utils/index.js

@@ -0,0 +1,26 @@
+import { toScenePoint } from "../konva/scene/viewport.js";
+import { camelCase, range, upperFirst } from "es-toolkit";
+//#region src/utils/index.ts
+var toZIndex = (data) => data.ui.zIndex;
+var nextZIndex = (tables, memos) => Math.max(1, ...tables.map(toZIndex), ...memos.map(toZIndex)) + 1;
+var isSamePoint = (a) => (b) => a.y === b.y && a.x === b.x;
+function nextPoint(settings, tables, memos) {
+	const point = toScenePoint(settings, {
+		x: 200,
+		y: 100
+	});
+	const points = [...tables, ...memos].map(({ ui }) => ui);
+	while (points.some(isSamePoint(point))) {
+		point.x += 50;
+		point.y += 50;
+	}
+	return point;
+}
+function safeRange(a, b) {
+	return a < b ? range(a, b + 1) : range(b, a + 1);
+}
+function pascalCase(value) {
+	return upperFirst(camelCase(value ?? ""));
+}
+//#endregion
+export { nextPoint, nextZIndex, pascalCase, safeRange };

package/dist/utils/internalEvents.js

@@ -0,0 +1,26 @@
+//#region src/utils/internalEvents.ts
+var InternalEventType = {
+	focus: "@dineug/erd-editor/internal-focus",
+	forceFocus: "@dineug/erd-editor/internal-force-focus",
+	forwardMoveStart: "@dineug/erd-editor/internal-forward-move-start"
+};
+function createInternalEvent(type, defaultOptions) {
+	function actionCreator(payload, options) {
+		return new CustomEvent(type, {
+			detail: payload,
+			...defaultOptions,
+			...options
+		});
+	}
+	actionCreator.toString = () => `${type}`;
+	actionCreator.type = type;
+	return actionCreator;
+}
+var focusEvent = createInternalEvent(InternalEventType.focus);
+var forceFocusEvent = createInternalEvent(InternalEventType.forceFocus);
+var forwardMoveStartEvent = createInternalEvent(InternalEventType.forwardMoveStart, {
+	bubbles: true,
+	composed: true
+});
+//#endregion
+export { InternalEventType, focusEvent, forceFocusEvent, forwardMoveStartEvent };

package/dist/utils/keyboard-shortcut/bindKeys.js

@@ -0,0 +1,30 @@
+import { isModifierHeld, matchesPress, parseKeybinding } from "./utils.js";
+//#region src/utils/keyboard-shortcut/bindKeys.ts
+var SEQUENCE_TIMEOUT = 1e3;
+function bindKeys(target, handlers) {
+	const bindings = Object.entries(handlers).map(([shortcut, handler]) => [parseKeybinding(shortcut), handler]);
+	const pending = /* @__PURE__ */ new Map();
+	let timer;
+	const handleKeydown = (event) => {
+		if (!(event instanceof KeyboardEvent)) return;
+		bindings.forEach(([sequence, handler]) => {
+			const presses = pending.get(sequence) ?? sequence;
+			if (!matchesPress(event, presses[0])) {
+				if (!isModifierHeld(event, event.key)) pending.delete(sequence);
+			} else if (presses.length > 1) pending.set(sequence, presses.slice(1));
+			else {
+				pending.delete(sequence);
+				handler(event);
+			}
+		});
+		clearTimeout(timer);
+		timer = setTimeout(() => pending.clear(), SEQUENCE_TIMEOUT);
+	};
+	target.addEventListener("keydown", handleKeydown);
+	return () => {
+		target.removeEventListener("keydown", handleKeydown);
+		clearTimeout(timer);
+	};
+}
+//#endregion
+export { bindKeys };

package/dist/utils/keyboard-shortcut/index.d.ts

@@ -37,7 +37,7 @@ export declare const KeyBindingName: {
     readonly zenMode: "zenMode";
 };
 export type KeyBindingName = ValuesType<typeof KeyBindingName>;
-export declare const KeyBindingNameList: ("undo" | "redo" | "addColumn" | "removeColumn" | "search" | "stop" | "selectAllColumn" | "primaryKey" | "edit" | "addMemo" | "addTable" | "removeTable" | "addTableGroup" | "findReplace" | "groupSelectedTables" | "removeSelection" | "selectAllTable" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "focusView" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
+export declare const KeyBindingNameList: ("edit" | "stop" | "search" | "findReplace" | "undo" | "redo" | "addTable" | "addColumn" | "addMemo" | "addTableGroup" | "groupSelectedTables" | "removeTable" | "removeColumn" | "removeSelection" | "primaryKey" | "selectAllTable" | "selectAllColumn" | "relationshipZeroOne" | "relationshipZeroN" | "relationshipOneOnly" | "relationshipOneN" | "tableProperties" | "focusView" | "zoomIn" | "zoomOut" | "zoomReset" | "handTool" | "zenMode")[];
 /**
  * The chords a press inside a floating panel still carries to the editor:
  * Find and Replace's own, search, the document's undo and redo, and the zoom.
@@ -51,6 +51,12 @@ export type KeyBindingMap = Record<KeyBindingName, ShortcutOption[]>;
  */
 export declare function stopsAtPanel(event: KeyboardEvent, keyBindingMap: KeyBindingMap, passing?: ReadonlyArray<KeyBindingName>): boolean;
 export declare const createKeyBindingMap: () => KeyBindingMap;
+/**
+ * Keeps the chords of the bindings named and empties every other binding, in
+ * place, so useKeyBindingMap binds those alone and a reader of any name still
+ * finds a list. In place, since the app context hands every reader this one object.
+ */
+export declare function pickKeyBindingMap(keyBindingMap: KeyBindingMap, names: ReadonlyArray<KeyBindingName>): void;
 /**
  * Whether the press is one of the chords given, matched as bindKeys matches a
  * press, so a panel reads a binding as the editor root does. Of a sequence it