@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/components/quick-search/actions.js

@@ -0,0 +1,471 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { CanvasType } from "../../constants/schema.js";
+import { html } from "../../r-html/dist/render/index.js";
+import { isMemoShown } from "../../utils/memo.js";
+import { isTableGroupShown } from "../../utils/tableGroup.js";
+import { changeBracketTypeAction, changeCanvasTypeAction, changeColumnNameCaseAction, changeDatabaseAction, changeLanguageAction, changeTableNameCaseAction, toNameViewModeAction } from "../../engine/modules/settings/atom.actions.js";
+import { changeDrawTableGroupAction } from "../../engine/modules/editor/atom.actions.js";
+import { RederiveScope, rederiveNamesAction$ } from "../../engine/modules/dictionary/generator.actions.js";
+import { addMemoAction$ } from "../../engine/modules/memo/generator.actions.js";
+import { addTableAction$ } from "../../engine/modules/table/generator.actions.js";
+import { getSelectTypeIds } from "../../engine/modules/editor/utils/selection.js";
+import { addTableGroupFromTablesAction$ } from "../../engine/modules/table-group/generator.actions.js";
+import { drawStartRelationshipAction$ } from "../../engine/modules/editor/generator.actions.js";
+import { openAutomaticTablePlacementAction, openExportImageAction, setLocaleOptionAction, setThemeOptionsAction } from "../../utils/emitter.js";
+import { LOCALES, SYSTEM_LOCALE } from "../../i18n/locales.js";
+import { sourceI18n } from "../../i18n/source.js";
+import Icon from "../primitives/icon/Icon.js";
+import { exportJSON } from "../../utils/file/exportFile.js";
+import { isTakenOver } from "../../utils/takeover.js";
+import { addTableGroupAndRename } from "../erd/table-group/tableGroupName.js";
+import { toggleExplorerSearch } from "../explorer/explorerCommands.js";
+import { importAML, importDBML, importGraphQL, importJSON, importSchemaSQL } from "../../utils/file/importFile.js";
+import { menus } from "../erd/erd-context-menu/menus/databaseMenus.js";
+import { menus as menus$1 } from "../erd/erd-context-menu/menus/drawRelationshipMenus.js";
+import { resolveSchemaSQLOptions, schemaSQLSupport } from "../../utils/schema-sql/options.js";
+import { schemaSQLViewOf, showSchemaSQLExport, toggleSchemaSQLPanel } from "../schema-sql/schemaSQLView.js";
+import { documentJsonOf } from "../../engine/documentJson.js";
+import { nameViewOptions } from "../erd/nameViewOptions.js";
+import { menus as menus$2 } from "../erd/erd-context-menu/menus/tablePlacementMenus.js";
+import { toggleGeneratorCodePanel } from "../generator-code/generatorCodeView.js";
+import { readsBracket } from "../generator-code/languageSettings.js";
+import { menus as menus$3 } from "../schema-sql/schema-sql-context-menu/menus/bracketMenus.js";
+import { menus as menus$4 } from "../generator-code/generator-code-context-menu/menus/columnNameCaseMenus.js";
+import { menus as menus$5 } from "../generator-code/generator-code-context-menu/menus/languageMenus.js";
+import { menus as menus$6 } from "../generator-code/generator-code-context-menu/menus/tableNameCaseMenus.js";
+import { isStatementsSupported, menus as menus$7 } from "../schema-sql/schema-sql-context-menu/menus/statementsMenus.js";
+import { isHeaderSupported, menus as menus$8 } from "../schema-sql/schema-sql-context-menu/menus/headerMenus.js";
+import { APPEARANCE_BUTTONS } from "../theme-builder/ThemeBuilder.js";
+import { createTableActions, named } from "./documentSearch.js";
+//#region src/components/quick-search/actions.tsx
+var submenuNamed = (i18n, key, keywordsKey) => ({
+	id: key,
+	...named(i18n, key, keywordsKey)
+});
+function createImportActions(mode, i18n) {
+	return [
+		{
+			icon: html`<${Icon} .name="braces" .size=${16} />`,
+			name: "json",
+			perform: (app) => {
+				importJSON(app, mode);
+			}
+		},
+		{
+			icon: html`<${Icon} .name="database" .size=${16} />`,
+			...named(i18n, "common.tab.schemaSql"),
+			perform: (app) => {
+				importSchemaSQL(app, mode);
+			}
+		},
+		{
+			icon: html`<${Icon} .name="code" .size=${16} />`,
+			...named(i18n, { name: "GraphQL" }, "palette.keywords.graphql"),
+			perform: (app) => {
+				importGraphQL(app, mode);
+			}
+		},
+		{
+			icon: html`<${Icon} .name="code" .size=${16} />`,
+			...named(i18n, { name: "DBML" }, "palette.keywords.dbml"),
+			perform: (app) => {
+				importDBML(app, mode);
+			}
+		},
+		{
+			icon: html`<${Icon} .name="code" .size=${16} />`,
+			...named(i18n, { name: "AML" }, "palette.keywords.aml"),
+			perform: (app) => {
+				importAML(app, mode);
+			}
+		}
+	].map((action) => ({
+		...action,
+		filter: isWritableErdTab
+	}));
+}
+var checkOf = (checked) => ({
+	icon: checked ? html`<${Icon} .name="check" .size=${16} />` : null,
+	checked
+});
+function createScopeActions(app, i18n = sourceI18n, preferences = {}) {
+	const { store, keyBindingMap } = app;
+	const { settings } = store.state;
+	return [
+		{
+			...submenuNamed(i18n, "palette.tab"),
+			next: createTabActions(i18n)
+		},
+		{
+			...submenuNamed(i18n, "common.nameView"),
+			next: nameViewOptions.map((menu) => ({
+				...checkOf(menu.value === settings.nameViewMode),
+				...named(i18n, menu.labelKey),
+				perform: ({ store }) => {
+					store.dispatch(toNameViewModeAction(store.state, menu.value, store.getReadonly()));
+				}
+			})),
+			filter: ({ store }) => {
+				return store.state.settings.canvasType === CanvasType.ERD;
+			}
+		},
+		...createRederiveActions(i18n),
+		{
+			icon: html`<${Icon} .name="database" .size=${16} />`,
+			...submenuNamed(i18n, "common.database"),
+			next: menus.map((menu) => ({
+				...checkOf(menu.value === settings.database),
+				name: menu.name,
+				perform: ({ store }) => {
+					store.dispatch(changeDatabaseAction({ value: menu.value }));
+				}
+			})),
+			filter: ({ store }) => {
+				return store.state.settings.canvasType === CanvasType.ERD || store.state.settings.canvasType === CanvasType.schemaSQL || store.state.settings.canvasType === CanvasType.generatorCode;
+			}
+		},
+		{
+			icon: html`<${Icon} .name="file-input" .size=${16} />`,
+			...submenuNamed(i18n, "common.import"),
+			next: createImportActions("replace", i18n),
+			filter: isWritableErdTab
+		},
+		{
+			icon: html`<${Icon} .name="file-input" .size=${16} />`,
+			...submenuNamed(i18n, "common.importAndAdd"),
+			next: createImportActions("append", i18n),
+			filter: isWritableErdTab
+		},
+		{
+			icon: html`<${Icon} .name="file-output" .size=${16} />`,
+			...submenuNamed(i18n, "common.export"),
+			next: [
+				{
+					icon: html`<${Icon} .name="braces" .size=${16} />`,
+					name: "json",
+					perform: ({ store }) => {
+						exportJSON(documentJsonOf(store), store.state.settings.databaseName);
+					}
+				},
+				{
+					icon: html`<${Icon} .name="database" .size=${16} />`,
+					...named(i18n, "common.tab.schemaSql"),
+					perform: showSchemaSQLExport
+				},
+				{
+					icon: html`<${Icon} .name="file-image" .size=${16} />`,
+					...named(i18n, "common.image", "palette.keywords.image"),
+					perform: ({ emitter }) => {
+						emitter.emit(openExportImageAction());
+					}
+				}
+			],
+			filter: ({ store }) => {
+				return store.state.settings.canvasType === CanvasType.ERD;
+			}
+		},
+		{
+			icon: html`<${Icon} .name="table-2" .size=${16} />`,
+			...named(i18n, "common.newTable"),
+			shortcut: keyBindingMap.addTable[0]?.shortcut,
+			perform: ({ store }) => {
+				store.dispatch(addTableAction$());
+			},
+			filter: isWritableErdTab
+		},
+		{
+			icon: html`<${Icon} .name="sticky-note" .size=${16} />`,
+			...named(i18n, "common.newMemo"),
+			shortcut: keyBindingMap.addMemo[0]?.shortcut,
+			perform: ({ store }) => {
+				store.dispatch(addMemoAction$());
+			},
+			filter: (app) => isWritableErdTab(app) && isMemoShown(app.store.state)
+		},
+		{
+			icon: html`<${Icon} .name="group" .size=${16} />`,
+			...named(i18n, "common.newTableGroup"),
+			shortcut: keyBindingMap.addTableGroup[0]?.shortcut,
+			perform: ({ store }) => {
+				store.dispatch(changeDrawTableGroupAction({ value: true }));
+			},
+			filter: canAddTableGroup
+		},
+		{
+			icon: html`<${Icon} .name="group" .size=${16} />`,
+			...named(i18n, "palette.groupSelectedTables"),
+			shortcut: keyBindingMap.groupSelectedTables[0]?.shortcut,
+			perform: ({ store }) => {
+				addTableGroupAndRename(store, addTableGroupFromTablesAction$());
+			},
+			filter: (app) => canAddTableGroup(app) && hasSelectedTable(app)
+		},
+		...menus$1.map((menu) => ({
+			icon: html`<${Icon} .name=${menu.iconName} .size=${16} />`,
+			...named(i18n, menu, "common.relationship"),
+			shortcut: keyBindingMap[menu.keyBindingName][0]?.shortcut,
+			perform: ({ store }) => {
+				store.dispatch(drawStartRelationshipAction$(menu.relationshipType));
+			},
+			filter: isWritableErdTab
+		})),
+		{
+			icon: html`<${Icon} .name="wand-sparkles" .size=${16} />`,
+			...submenuNamed(i18n, "common.autoLayout"),
+			next: menus$2.map((menu) => ({
+				icon: html`<${Icon} .name=${menu.iconName} .size=${16} />`,
+				...named(i18n, menu),
+				perform: ({ emitter }) => {
+					emitter.emit(openAutomaticTablePlacementAction({ placement: menu.placement }));
+				},
+				filter: isWritableErdTab
+			})),
+			filter: isWritableErdTab
+		},
+		{
+			icon: html`<${Icon} .name="brackets" .size=${16} />`,
+			...submenuNamed(i18n, "common.bracket"),
+			next: menus$3.map((menu) => ({
+				...checkOf(menu.value === settings.bracketType),
+				...named(i18n, menu),
+				perform: ({ store }) => {
+					store.dispatch(changeBracketTypeAction({ value: menu.value }));
+				}
+			})),
+			filter: (app) => isSchemaSQLTab(app) || readsBracketHere(app)
+		},
+		...createSchemaSQLActions(app, i18n),
+		{
+			icon: html`<${Icon} .name="code" .size=${16} />`,
+			...submenuNamed(i18n, "common.codeLanguage"),
+			next: menus$5.map((menu) => ({
+				...checkOf(menu.value === settings.language),
+				name: menu.name,
+				perform: ({ store }) => {
+					store.dispatch(changeLanguageAction({ value: menu.value }));
+				}
+			})),
+			filter: ({ store }) => {
+				return store.state.settings.canvasType === CanvasType.generatorCode;
+			}
+		},
+		{
+			...submenuNamed(i18n, "common.tableNameCase"),
+			next: menus$6.map((menu) => ({
+				...checkOf(menu.value === settings.tableNameCase),
+				...named(i18n, menu),
+				perform: ({ store }) => {
+					store.dispatch(changeTableNameCaseAction({ value: menu.value }));
+				}
+			})),
+			filter: ({ store }) => {
+				return store.state.settings.canvasType === CanvasType.generatorCode;
+			}
+		},
+		{
+			...submenuNamed(i18n, "common.columnNameCase"),
+			next: menus$4.map((menu) => ({
+				...checkOf(menu.value === settings.columnNameCase),
+				...named(i18n, menu),
+				perform: ({ store }) => {
+					store.dispatch(changeColumnNameCaseAction({ value: menu.value }));
+				}
+			})),
+			filter: ({ store }) => {
+				return store.state.settings.canvasType === CanvasType.generatorCode;
+			}
+		},
+		{
+			icon: html`<${Icon} .name="panel-right" .size=${16} />`,
+			...named(i18n, "palette.codeGeneratorOptionsPanel", "palette.keywords.codeGeneratorOptionsPanel"),
+			perform: toggleGeneratorCodePanel,
+			filter: isGeneratorCodeTab
+		},
+		{
+			icon: html`<${Icon} .name="list-tree" .size=${16} />`,
+			...named(i18n, "explorer.toggle", "palette.keywords.explorer"),
+			shortcut: keyBindingMap.findReplace[0]?.shortcut,
+			perform: ({ store, emitter }) => toggleExplorerSearch(store, emitter),
+			filter: canOpenExplorer
+		},
+		...createPreferenceActions(i18n, preferences),
+		...createTableActions(app, i18n)
+	];
+}
+var isSchemaSQLTab = ({ store }) => store.state.settings.canvasType === CanvasType.schemaSQL;
+var isGeneratorCodeTab = ({ store }) => store.state.settings.canvasType === CanvasType.generatorCode;
+var readsBracketHere = (app) => isGeneratorCodeTab(app) && readsBracket(app.store.state.settings.language);
+var isWritableErdTab = ({ store }) => store.state.settings.canvasType === CanvasType.ERD && !store.getReadonly();
+var canAddTableGroup = (app) => isWritableErdTab(app) && isTableGroupShown(app.store.state);
+var hasSelectedTable = ({ store }) => {
+	const { doc, editor } = store.state;
+	return getSelectTypeIds(editor.selectedMap).tableIds.some((id) => doc.tableIds.includes(id));
+};
+var focusedColumnTarget = ({ doc, editor, collections }) => {
+	const { focusTable } = editor;
+	if (!focusTable?.columnId || !doc.tableIds.includes(focusTable.tableId)) return null;
+	return query(collections).collection("tableEntities").selectById(focusTable.tableId)?.columnIds.includes(focusTable.columnId) ? {
+		scope: RederiveScope.column,
+		tableId: focusTable.tableId,
+		columnId: focusTable.columnId
+	} : null;
+};
+var focusedTableTarget = ({ doc, editor }) => {
+	const tableId = editor.focusTable?.tableId;
+	return tableId && doc.tableIds.includes(tableId) ? {
+		scope: RederiveScope.table,
+		tableId
+	} : null;
+};
+var selectionTarget = ({ doc, editor }) => getSelectTypeIds(editor.selectedMap).tableIds.filter((id) => doc.tableIds.includes(id)).length > 1 ? { scope: RederiveScope.selection } : null;
+var documentTarget = ({ doc }) => doc.tableIds.length ? { scope: RederiveScope.document } : null;
+var REDERIVE_ROWS = [
+	{
+		labelKey: "common.derivePhysicalName",
+		keywordsKey: "palette.keywords.deriveColumn",
+		targetOf: focusedColumnTarget
+	},
+	{
+		labelKey: "common.derivePhysicalNames",
+		keywordsKey: "palette.keywords.deriveTable",
+		targetOf: focusedTableTarget
+	},
+	{
+		labelKey: "common.derivePhysicalNames",
+		keywordsKey: "palette.keywords.deriveSelection",
+		targetOf: selectionTarget
+	},
+	{
+		labelKey: "common.derivePhysicalNames",
+		keywordsKey: "palette.keywords.deriveDocument",
+		targetOf: documentTarget
+	}
+];
+function createRederiveActions(i18n) {
+	return REDERIVE_ROWS.map(({ labelKey, keywordsKey, targetOf }) => ({
+		icon: html`<${Icon} .name="refresh-cw" .size=${16} />`,
+		...named(i18n, labelKey, keywordsKey),
+		perform: ({ store }) => {
+			const target = targetOf(store.state);
+			if (target) store.dispatch(rederiveNamesAction$(target));
+		},
+		filter: (app) => isWritableErdTab(app) && targetOf(app.store.state) !== null
+	}));
+}
+function createSchemaSQLActions(app, i18n) {
+	const { settings } = app.store.state;
+	const view = schemaSQLViewOf(app);
+	const resolved = resolveSchemaSQLOptions(settings.database, view, settings.databaseName);
+	const support = schemaSQLSupport(settings.database);
+	return [
+		{
+			...submenuNamed(i18n, "palette.schemaSqlStatements", "palette.keywords.schemaSqlStatements"),
+			next: menus$7.filter((menu) => isStatementsSupported(support, menu.id)).map((menu) => ({
+				...checkOf(menu.id === resolved.statements),
+				name: menu.name,
+				perform: (app) => {
+					schemaSQLViewOf(app).statements = menu.id;
+				}
+			})),
+			filter: isSchemaSQLTab
+		},
+		{
+			...submenuNamed(i18n, "palette.schemaSqlHeader", "palette.keywords.schemaSqlHeader"),
+			next: menus$8.filter((menu) => isHeaderSupported(support, menu.id)).map((menu) => ({
+				...checkOf(menu.id === resolved.header),
+				...named(i18n, menu),
+				perform: (app) => {
+					schemaSQLViewOf(app).header = menu.id;
+				}
+			})),
+			filter: isSchemaSQLTab
+		},
+		{
+			icon: html`<${Icon} .name="panel-right" .size=${16} />`,
+			...named(i18n, "palette.schemaSqlOptionsPanel", "palette.keywords.schemaSqlOptionsPanel"),
+			perform: toggleSchemaSQLPanel,
+			filter: isSchemaSQLTab
+		}
+	];
+}
+function createPreferenceActions(i18n, { appearance, locale }) {
+	const actions = [];
+	if (appearance !== void 0) actions.push({
+		icon: html`<${Icon} .name="contrast" .size=${16} />`,
+		...submenuNamed(i18n, "common.theme"),
+		next: APPEARANCE_BUTTONS.map((option) => ({
+			...checkOf(option.appearance === appearance),
+			...named(i18n, option.labelKey),
+			perform: ({ emitter }) => {
+				emitter.emit(setThemeOptionsAction({ appearance: option.appearance }));
+			}
+		}))
+	});
+	if (locale !== void 0) {
+		const pick = (option) => ({ emitter }) => {
+			emitter.emit(setLocaleOptionAction({ locale: option }));
+		};
+		actions.push({
+			icon: html`<${Icon} .name="languages" .size=${16} />`,
+			...submenuNamed(i18n, "common.displayLanguage"),
+			next: [{
+				...checkOf(locale === SYSTEM_LOCALE),
+				...named(i18n, "common.system"),
+				perform: pick(SYSTEM_LOCALE)
+			}, ...LOCALES.map(({ code, label, english }) => ({
+				...checkOf(locale === code),
+				name: label,
+				alias: [english, code],
+				perform: pick(code)
+			}))]
+		});
+	}
+	return actions;
+}
+var canOpenExplorer = ({ store }) => !isTakenOver(store.state);
+var TABS = [
+	{
+		canvasType: CanvasType.ERD,
+		icon: "workflow",
+		labelKey: "common.tab.erd"
+	},
+	{
+		canvasType: CanvasType.visualization,
+		icon: "share-2",
+		labelKey: "common.tab.visualization"
+	},
+	{
+		canvasType: CanvasType.schemaSQL,
+		icon: "database",
+		labelKey: "common.tab.schemaSql"
+	},
+	{
+		canvasType: CanvasType.generatorCode,
+		icon: "code",
+		labelKey: "common.tab.codeGenerator"
+	},
+	{
+		canvasType: CanvasType.dictionary,
+		icon: "book-type",
+		labelKey: "common.tab.dictionary"
+	},
+	{
+		canvasType: CanvasType.settings,
+		icon: "settings",
+		labelKey: "common.tab.settings"
+	}
+];
+function createTabActions(i18n = sourceI18n) {
+	return TABS.map(({ canvasType, icon, labelKey }) => ({
+		icon: html`<${Icon} .name=${icon} .size=${16} />`,
+		...named(i18n, labelKey),
+		perform: ({ store }) => {
+			store.dispatch(changeCanvasTypeAction({ value: canvasType }));
+		},
+		filter: ({ store }) => {
+			return store.state.settings.canvasType !== canvasType;
+		}
+	}));
+}
+//#endregion
+export { createPreferenceActions, createScopeActions, createTabActions };

package/dist/components/quick-search/documentSearch.d.ts

@@ -0,0 +1,60 @@
+import { DOMTemplateLiterals } from '@dineug/r-html';
+import { AppContext } from '../appContext';
+import { RootState } from '../../engine/state';
+import { LocaleOption } from '../../i18n/locales';
+import { LabeledMenu } from '../../i18n/menuLabel';
+import { I18n, PlainMessageKey } from '../../i18n/translate';
+import { AppearanceOption } from '../../themes/radix-ui-theme';
+import { FindMatch } from '../../utils/find-replace';
+export type Action = {
+    icon?: DOMTemplateLiterals | null;
+    name: string;
+    keywords?: string;
+    shortcut?: string;
+    /** The table a row jumps to, whose keyword names the kind of row, not the table. */
+    tableId?: string;
+    /** A table row's own names, its name and logical name, which a search reads whatever the name view shows. */
+    tableNames?: string[];
+    /** What choosing the row types into the input, which stays open, instead of running a command. */
+    insert?: string;
+    /** The English of a translated name and keywords, each its own text, which a search also reads and the list never shows. */
+    alias?: string[];
+    /** The option in force among a submenu's rows, which the submenu opens on. */
+    checked?: boolean;
+    /** The message key of a row opening a submenu, by which an open palette finds that submenu again in a rebuilt level. */
+    id?: PlainMessageKey;
+    filter?: (app: AppContext) => boolean;
+    perform?: (app: AppContext) => void;
+    next?: Action[];
+};
+/** The theme and the display language the element holds, each given only while it offers that picker. */
+export type PalettePreferences = {
+    appearance?: AppearanceOption;
+    locale?: LocaleOption;
+};
+/** What names a row: a message key, or a shared menu whose name stays as written where it has no key. */
+type RowLabel = PlainMessageKey | LabeledMenu;
+/**
+ * A row's name and keywords in the reader's language. The English of each one
+ * a translation changes goes into its alias apart, so a search scores it as in
+ * English and a command is found by its English words too; English has none.
+ */
+export declare function named(i18n: Pick<I18n, 't'>, label: RowLabel, keywordsKey?: PlainMessageKey): Pick<Action, 'name' | 'keywords' | 'alias'>;
+/**
+ * Whether a row holds the keyword: as typed, or by its Hangul letters, which
+ * an IME spells out one jamo at a time and a choseong search abbreviates.
+ */
+export declare function keywordHolder(keyword: string): (action: Action) => boolean;
+/**
+ * How loose a fuzzy hit may be: stricter than fuse.js's 0.6, which fuzzed most
+ * words to some command (memo to the relationships, #us to orders), while a
+ * typo such as tabel still finds New Table. A row holding the keyword stays.
+ */
+export declare const SEARCH_THRESHOLD = 0.4;
+export declare function searchActions(actions: Action[], keyword: string): Action[];
+/** The row for one field a search found, saying where it is, which stands the reader on it when chosen. */
+export declare function createMatchAction(state: RootState, match: FindMatch, i18n?: I18n): Action;
+/** A jump to each table in the order of the names, named as the name view names it, which only the # prefix lists. */
+export declare function createTableActions({ store }: AppContext, i18n: I18n): Action[];
+export {};
+//# sourceMappingURL=documentSearch.d.ts.map

package/dist/components/quick-search/documentSearch.js

@@ -0,0 +1,132 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { nameLabelText, toNameLabel } from "../../engine/modules/editor/utils/nameView.js";
+import { orderByNameASC } from "../../utils/tableName.js";
+import { sourceI18n } from "../../i18n/source.js";
+import { goToErdTarget } from "../erd/goToErdTarget.js";
+import { FindField } from "../../utils/find-replace/findMatches.js";
+import { describeMatch, snippetOf } from "../../utils/find-replace/present.js";
+import { menuLabel } from "../../i18n/menuLabel.js";
+import { fieldIcon } from "../erd/fieldIcon.js";
+import { toErdTarget } from "../erd/erdTarget.js";
+import { hangulQueryOf, hangulTier } from "./hangul.js";
+import { isEmpty } from "es-toolkit/compat";
+import Fues from "fuse.js";
+//#region src/components/quick-search/documentSearch.tsx
+var isNonEmpty = (text) => Boolean(text);
+function tableTextsOf({ name, tableNames = [] }) {
+	const names = tableNames.filter(isNonEmpty);
+	return names.length ? names : [name];
+}
+var textsOf = (action) => {
+	const { name, keywords, alias = [], tableId } = action;
+	return tableId ? tableTextsOf(action) : [
+		name,
+		keywords,
+		...alias
+	].filter(isNonEmpty);
+};
+function textsIn(i18n, label, keywordsKey) {
+	const name = typeof label === "string" ? i18n.t(label) : menuLabel(i18n, label);
+	return keywordsKey ? {
+		name,
+		keywords: i18n.t(keywordsKey)
+	} : { name };
+}
+function named(i18n, label, keywordsKey) {
+	const row = textsIn(i18n, label, keywordsKey);
+	const english = textsIn(sourceI18n, label, keywordsKey);
+	const alias = [[row.name, english.name], [row.keywords, english.keywords]].filter(([shown, source]) => shown !== source).map(([, source]) => source).filter(isNonEmpty);
+	return alias.length ? {
+		...row,
+		alias
+	} : row;
+}
+var holdsAsTyped = (action, keyword) => {
+	const needle = keyword.toLowerCase();
+	return textsOf(action).some((text) => text.toLowerCase().includes(needle));
+};
+function tierOfAction(action, query) {
+	return textsOf(action).reduce((best, text) => {
+		const tier = hangulTier(text, query);
+		return tier !== null && (best === null || tier < best) ? tier : best;
+	}, null);
+}
+function keywordHolder(keyword) {
+	const query = hangulQueryOf(keyword);
+	return (action) => holdsAsTyped(action, keyword) || query !== null && tierOfAction(action, query) !== null;
+}
+var SEARCH_THRESHOLD = .4;
+function searchActions(actions, keyword) {
+	const found = new Fues(actions, {
+		keys: [
+			{
+				name: "name",
+				getFn: (action) => action.tableId ? tableTextsOf(action) : action.name
+			},
+			{
+				name: "keywords",
+				getFn: (action) => action.tableId ? [] : action.keywords ?? []
+			},
+			{
+				name: "alias",
+				getFn: (action) => action.tableId ? [] : action.alias ?? []
+			}
+		],
+		threshold: SEARCH_THRESHOLD
+	}).search(keyword).map((result) => result.item);
+	const query = hangulQueryOf(keyword);
+	return query ? rankHangulActions(actions, found, query) : [...found, ...heldPastFuse(actions, found, keyword)];
+}
+function heldPastFuse(actions, found, keyword) {
+	const fuzzy = new Set(found);
+	return actions.filter((action) => !fuzzy.has(action) && holdsAsTyped(action, keyword));
+}
+function rankHangulActions(actions, found, query) {
+	const fuzzy = new Map(found.map((action, index) => [action, index]));
+	const hits = actions.flatMap((action, index) => {
+		const tier = tierOfAction(action, query);
+		const order = fuzzy.get(action) ?? found.length + index;
+		return tier === null ? [] : [{
+			action,
+			tier,
+			order
+		}];
+	});
+	hits.sort((a, b) => a.tier - b.tier || a.order - b.order);
+	const spelled = new Set(hits.map((hit) => hit.action));
+	return [...hits.map((hit) => hit.action), ...found.filter((action) => !spelled.has(action))];
+}
+function createMatchAction(state, match, i18n = sourceI18n) {
+	return {
+		icon: fieldIcon(match.field, 16),
+		name: snippetOf(match, 16, 64).text || i18n.t("common.unnamed"),
+		keywords: describeMatch(state, match, i18n),
+		perform: ({ store }) => {
+			goToErdTarget(store, toErdTarget(match));
+		}
+	};
+}
+function createTableActions({ store }, i18n) {
+	const { doc: { tableIds }, collections, settings } = store.state;
+	const unnamed = i18n.t("common.unnamed");
+	const keywords = i18n.t("common.table");
+	const nameOf = (table) => {
+		const name = nameLabelText(toNameLabel(settings, table));
+		return isEmpty(name.trim()) ? unnamed : name;
+	};
+	return query(collections).collection("tableEntities").selectByIds(tableIds).sort(orderByNameASC).map((table) => ({
+		icon: fieldIcon(FindField.tableName, 16),
+		name: nameOf(table),
+		keywords,
+		tableId: table.id,
+		tableNames: [table.name, table.logicalName],
+		perform: ({ store }) => {
+			goToErdTarget(store, {
+				kind: "table",
+				tableId: table.id
+			});
+		}
+	}));
+}
+//#endregion
+export { SEARCH_THRESHOLD, createMatchAction, createTableActions, keywordHolder, named, searchActions };