@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/components/dictionary/Dictionary.styles.js

@@ -0,0 +1,208 @@
+import { css } from "../../r-html/dist/template/css.js";
+import { typography } from "../../styles/typography.styles.js";
+//#region src/components/dictionary/Dictionary.styles.ts
+var root = css`
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  height: 100%;
+  overflow: hidden;
+  background-color: var(--canvas-background);
+  ${typography.paragraph};
+`;
+var bar = css`
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  flex: 0 0 auto;
+  gap: 6px 8px;
+  min-width: 0;
+  padding: 8px 12px;
+  border-bottom: 1px solid var(--dictionary-grid-line);
+`;
+var segments = css`
+  display: inline-flex;
+  flex: 0 0 auto;
+  border: 1px solid var(--dictionary-grid-line);
+  border-radius: 6px;
+  overflow: hidden;
+`;
+var segment = css`
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  height: 26px;
+  padding: 0 10px;
+  color: var(--foreground);
+  cursor: pointer;
+  white-space: nowrap;
+  ${typography.paragraph};
+
+  &:focus-visible {
+    outline: 2px solid var(--focus);
+    outline-offset: -2px;
+  }
+
+  & + & {
+    border-inline-start: 1px solid var(--dictionary-grid-line);
+  }
+
+  &:hover {
+    color: var(--active);
+    background-color: var(--gray-color-4);
+  }
+
+  &[aria-pressed='true'] {
+    color: var(--accent-color-11);
+    background-color: var(--accent-color-3);
+  }
+`;
+var count = css`
+  color: var(--placeholder);
+  font-variant-numeric: tabular-nums;
+
+  [aria-pressed='true'] > & {
+    color: inherit;
+    opacity: 0.72;
+  }
+`;
+var countError = css`
+  color: var(--dictionary-error-foreground);
+  font-weight: 500;
+
+  [aria-pressed='true'] > & {
+    color: var(--dictionary-error-foreground);
+    opacity: 1;
+  }
+`;
+var countWarning = css`
+  color: var(--dictionary-warning-foreground);
+  font-weight: 500;
+
+  [aria-pressed='true'] > & {
+    color: var(--dictionary-warning-foreground);
+    opacity: 1;
+  }
+`;
+var searchField = css`
+  position: relative;
+  display: flex;
+  align-items: center;
+  flex: 0 1 260px;
+  min-width: 120px;
+  height: 28px;
+  color: var(--placeholder);
+`;
+var searchIcon = css`
+  position: absolute;
+  inset-inline-start: 8px;
+  display: flex;
+  pointer-events: none;
+`;
+var search = css`
+  width: 100%;
+  height: 100%;
+  padding-inline: 28px;
+  border: 1px solid var(--dictionary-grid-line);
+  border-radius: 6px;
+  background-color: var(--dictionary-background);
+  ${typography.paragraph};
+
+  &:focus {
+    border-color: var(--focus);
+  }
+`;
+var clear = css`
+  position: absolute;
+  inset-inline-end: 4px;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  width: 20px;
+  height: 20px;
+  padding: 0;
+  border-radius: 4px;
+  color: var(--placeholder);
+  cursor: pointer;
+
+  &:hover {
+    color: var(--active);
+    background-color: var(--gray-color-4);
+  }
+
+  &:focus-visible {
+    outline: 2px solid var(--focus);
+    outline-offset: -2px;
+  }
+`;
+var tools = css`
+  display: flex;
+  align-items: center;
+  gap: 2px;
+  margin-inline-start: auto;
+`;
+var tool = css`
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 28px;
+  height: 28px;
+  padding: 0;
+  border-radius: 6px;
+  color: var(--foreground);
+  cursor: pointer;
+
+  &:hover {
+    color: var(--active);
+    background-color: var(--gray-color-4);
+  }
+
+  &:focus-visible {
+    outline: 2px solid var(--focus);
+    outline-offset: -2px;
+  }
+`;
+var toolDanger = css`
+  &:hover {
+    color: var(--dictionary-error-foreground);
+  }
+`;
+var divider = css`
+  width: 1px;
+  height: 16px;
+  margin: 0 4px;
+  background-color: var(--dictionary-grid-line);
+`;
+var sheet = css`
+  position: relative;
+  flex: 1 1 0;
+  min-height: 0;
+  background-color: var(--dictionary-background);
+`;
+var empty = css`
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin: 0;
+  padding: 16px;
+  text-align: center;
+  color: var(--placeholder);
+  pointer-events: none;
+  ${typography.paragraph};
+`;
+var status = css`
+  display: flex;
+  align-items: center;
+  flex: 0 0 auto;
+  gap: 12px;
+  height: 24px;
+  padding: 0 12px;
+  border-top: 1px solid var(--dictionary-grid-line);
+  color: var(--foreground);
+  white-space: nowrap;
+  overflow: hidden;
+`;
+//#endregion
+export { bar, clear, count, countError, countWarning, divider, empty, root, search, searchField, searchIcon, segment, segments, sheet, status, tool, toolDanger, tools };

package/dist/components/dictionary/checkCount.js

@@ -0,0 +1,59 @@
+import { DictionaryCheckLevel, markOf } from "../../engine/modules/dictionary/checks.js";
+//#region src/components/dictionary/checkCount.ts
+var IDLE_TIMEOUT_MS = 1e3;
+function whenIdle(task) {
+	if (typeof requestIdleCallback === "function") {
+		const id = requestIdleCallback(task, { timeout: IDLE_TIMEOUT_MS });
+		return () => cancelIdleCallback(id);
+	}
+	const id = setTimeout(() => task({
+		didTimeout: true,
+		timeRemaining: () => 0
+	}));
+	return () => clearTimeout(id);
+}
+var louder = (mark, level) => mark === DictionaryCheckLevel.error ? mark : level ?? mark;
+function createCheckCount({ walk, wanted, done }) {
+	let steps = null;
+	let count = 0;
+	let mark = null;
+	let cancel = null;
+	function slice(budget) {
+		cancel = null;
+		if (!wanted()) {
+			steps = null;
+			return;
+		}
+		if (!steps) {
+			steps = walk();
+			count = 0;
+			mark = null;
+		}
+		const time = budget.didTimeout ? 8 : budget.timeRemaining();
+		const end = performance.now() + time;
+		do {
+			const step = steps.next();
+			if (step.done) {
+				steps = null;
+				done(count, mark);
+				return;
+			}
+			count += step.value.length;
+			mark = louder(mark, markOf(step.value));
+		} while (performance.now() < end);
+		cancel = whenIdle(slice);
+	}
+	return {
+		restart() {
+			steps = null;
+			if (cancel === null && wanted()) cancel = whenIdle(slice);
+		},
+		stop() {
+			cancel?.();
+			cancel = null;
+			steps = null;
+		}
+	};
+}
+//#endregion
+export { IDLE_TIMEOUT_MS, createCheckCount, whenIdle };

package/dist/components/dictionary/checkSheet.js

@@ -0,0 +1,121 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { DictionaryKind } from "../../engine/modules/dictionary/actions.js";
+import { selectDictionaryRow } from "../../engine/modules/dictionary/atom.actions.js";
+import { FocusType } from "../../engine/modules/editor/state.js";
+import { listDictionaryChecks } from "../../engine/modules/dictionary/checks.js";
+import { sourceI18n } from "../../i18n/source.js";
+import { toSearchText } from "./sheets.js";
+import { nameOf } from "../map-columns/nameOf.js";
+//#region src/components/dictionary/checkSheet.ts
+var CheckColumn = {
+	type: "type",
+	target: "target",
+	detail: "detail"
+};
+var CHECK_COLUMNS = [
+	{
+		id: CheckColumn.type,
+		labelKey: "dictionary.field.type",
+		width: 180
+	},
+	{
+		id: CheckColumn.target,
+		labelKey: "dictionary.field.target",
+		width: 240
+	},
+	{
+		id: CheckColumn.detail,
+		labelKey: "dictionary.field.detail",
+		width: 360
+	}
+];
+var CHECK_LABEL_KEY = {
+	duplicateName: "dictionary.check.duplicateName",
+	unknownDomain: "dictionary.check.unknownDomain",
+	unregisteredWord: "dictionary.check.unregisteredWord",
+	forbiddenWord: "dictionary.check.forbiddenWord",
+	synonymWord: "dictionary.check.synonymWord",
+	physicalNameMismatch: "dictionary.check.physicalNameMismatch",
+	domainTypeMismatch: "dictionary.check.domainTypeMismatch"
+};
+function checkSheetColumns(widths = {}, i18n = sourceI18n) {
+	return CHECK_COLUMNS.map(({ id, labelKey, width }) => ({
+		id,
+		label: i18n.t(labelKey),
+		width: widths[id] ?? width,
+		readonly: true
+	}));
+}
+function targetText(state, { target }, i18n) {
+	const tables = query(state.collections).collection("tableEntities");
+	const named = (entity) => entity ? nameOf(entity, i18n, state.settings) : "";
+	switch (target.kind) {
+		case "table": return named(tables.selectById(target.id));
+		case "column": {
+			const column = query(state.collections).collection("tableColumnEntities").selectById(target.id);
+			return `${named(tables.selectById(target.tableId))}.${named(column)}`;
+		}
+		case DictionaryKind.word:
+		case DictionaryKind.term:
+		case DictionaryKind.domain: return selectDictionaryRow(state, target.kind, target.id)?.name ?? "";
+	}
+}
+var EMPTY_SIDE = "—";
+var sideText = (text) => text || EMPTY_SIDE;
+function detailText({ text, suggestions }, i18n) {
+	if (!suggestions.length) return text;
+	const offered = new Intl.ListFormat(i18n.locale, { type: "unit" }).format(suggestions.map(sideText));
+	return `${sideText(text)} → ${offered}`;
+}
+function checkCellText(state, check, columnId, i18n = sourceI18n) {
+	switch (columnId) {
+		case CheckColumn.type: return i18n.t(CHECK_LABEL_KEY[check.code]);
+		case CheckColumn.target: return targetText(state, check, i18n);
+		case CheckColumn.detail: return detailText(check, i18n);
+		default: return "";
+	}
+}
+var COLUMN_FOCUS = {
+	name: FocusType.columnName,
+	logicalName: FocusType.columnLogicalName,
+	domainId: FocusType.columnDomain
+};
+var TABLE_FOCUS = {
+	name: FocusType.tableName,
+	logicalName: FocusType.tableLogicalName,
+	domainId: FocusType.tableName
+};
+function checkDestination({ target, field }) {
+	switch (target.kind) {
+		case "table": return {
+			kind: "erd",
+			target: {
+				kind: "table",
+				tableId: target.id,
+				focusType: TABLE_FOCUS[field]
+			}
+		};
+		case "column": return {
+			kind: "erd",
+			target: {
+				kind: "column",
+				tableId: target.tableId,
+				columnId: target.id,
+				focusType: COLUMN_FOCUS[field]
+			}
+		};
+		default: return {
+			kind: "entry",
+			sheet: target.kind,
+			id: target.id,
+			columnId: field
+		};
+	}
+}
+function checkRows(state, search = "", i18n = sourceI18n, checks = listDictionaryChecks(state)) {
+	const needle = toSearchText(search.trim());
+	if (!needle) return Object.freeze(checks);
+	return Object.freeze(checks.filter((check) => CHECK_COLUMNS.some(({ id }) => toSearchText(checkCellText(state, check, id, i18n)).includes(needle))));
+}
+//#endregion
+export { CheckColumn, checkCellText, checkDestination, checkRows, checkSheetColumns };

package/dist/components/dictionary/dictionary-context-menu/DictionaryContextMenu.js

@@ -0,0 +1,17 @@
+import { html } from "../../../r-html/dist/render/index.js";
+import { useI18n } from "../../localeContext.js";
+import Icon from "../../primitives/icon/Icon.js";
+import ContextMenu from "../../primitives/context-menu/ContextMenu.js";
+import Kbd from "../../primitives/kbd/Kbd.js";
+//#region src/components/dictionary/dictionary-context-menu/DictionaryContextMenu.tsx
+var DictionaryContextMenu = (props, ctx) => {
+	const i18n = useI18n(ctx);
+	return () => {
+		const { t } = i18n.value;
+		const { count, column, empty = false } = props;
+		const format = "CSV";
+		return html`<${ContextMenu.Root} .children=${html`${empty ? null : html`<${ContextMenu.Item} .onClick=${props.onInsertAbove} .children=${html`<${ContextMenu.Menu} .icon=${html`<${Icon} .name="arrow-up" .size=${14} />`} .name=${t("dictionary.menu.insertAbove", { count })} .right=${html`<${Kbd} .shortcut=${props.insertAboveShortcut} />`} />`} />`}<${ContextMenu.Item} .onClick=${props.onInsertBelow} .children=${html`<${ContextMenu.Menu} .icon=${html`<${Icon} .name="arrow-down" .size=${14} />`} .name=${t("dictionary.menu.insertBelow", { count })} .right=${html`<${Kbd} .shortcut=${props.insertShortcut} />`} />`} />${empty ? null : html`<${ContextMenu.Item} .onClick=${props.onDeleteRows} .children=${html`<${ContextMenu.Menu} .name=${t("dictionary.menu.deleteRows", { count })} .right=${html`<${Kbd} .shortcut=${props.deleteShortcut} />`} />`} />`}<${ContextMenu.Separator} />${empty || column === null ? null : html`<${ContextMenu.Item} .onClick=${props.onSortAscending} .children=${html`<${ContextMenu.Menu} .name=${t("dictionary.menu.sortAscending", { column })} />`} /><${ContextMenu.Item} .onClick=${props.onSortDescending} .children=${html`<${ContextMenu.Menu} .name=${t("dictionary.menu.sortDescending", { column })} />`} /><${ContextMenu.Separator} />`}<${ContextMenu.Item} .onClick=${props.onImport} .children=${html`<${ContextMenu.Menu} .icon=${html`<${Icon} .name="upload" .size=${14} />`} .name=${t("dictionary.import", { format })} />`} /><${ContextMenu.Item} .onClick=${props.onExport} .children=${html`<${ContextMenu.Menu} .icon=${html`<${Icon} .name="download" .size=${14} />`} .name=${t("dictionary.export", { format })} />`} />`} />`;
+	};
+};
+//#endregion
+export { DictionaryContextMenu as default };

package/dist/components/dictionary/dictionaryCommit.js

@@ -0,0 +1,237 @@
+import { DictionaryKind } from "../../engine/modules/dictionary/actions.js";
+import { getLiveDomainName, isListed, toLiveDomainId } from "../../engine/modules/dictionary/membership.js";
+import { findDomain, normalizeDictionaryName } from "../../engine/modules/dictionary/dictionaryIndex.js";
+import { dictionaryIds, selectDictionaryRow } from "../../engine/modules/dictionary/atom.actions.js";
+import { attachDictionarySheetTag$ } from "../../engine/tag.js";
+import { DictionaryRefusalCode, validateDictionaryValues } from "../../engine/modules/dictionary/entryWrites.js";
+import { commitDictionaryCellsAction$, removeDictionaryEntriesAction$ } from "../../engine/modules/dictionary/generator.actions.js";
+import { isolate } from "../../i18n/translate.js";
+import { sourceI18n } from "../../i18n/source.js";
+import { sheetField } from "./sheets.js";
+import { localized } from "../localized/Localized.js";
+import { openStatusToast } from "../toast-container/openStatusToast.js";
+import { isString } from "es-toolkit";
+//#region src/components/dictionary/dictionaryCommit.ts
+function createSheetRows(ids = []) {
+	const snapshots = /* @__PURE__ */ new Map([[0, ids]]);
+	let version = 0;
+	let received = 0;
+	let activeRow = 0;
+	let activeId = null;
+	const rowsOf = (held) => snapshots.get(held) ?? [];
+	const idAt = (rows, row) => row >= 0 && row < rows.length ? rows[row] : null;
+	const keepOnly = (keep) => {
+		for (const held of [...snapshots.keys()]) if (!keep(held)) snapshots.delete(held);
+	};
+	const groupCells = ({ changes }) => {
+		const rows = rowsOf(received);
+		const byRow = /* @__PURE__ */ new Map();
+		for (const { row, columnId, value } of changes) {
+			const cells = byRow.get(row) ?? {};
+			cells[columnId] = value;
+			byRow.set(row, cells);
+		}
+		return [...byRow.entries()].sort(([a], [b]) => a - b).map(([row, cells]) => ({
+			id: idAt(rows, row),
+			cells
+		}));
+	};
+	const resolveEdit = (event) => {
+		const id = activeId ?? idAt(rowsOf(received), event.changes[0]?.row ?? -1);
+		const cells = {};
+		for (const { columnId, value } of event.changes) cells[columnId] = value;
+		activeId = idAt(rowsOf(received), activeRow);
+		return id === null ? [] : [{
+			id,
+			cells
+		}];
+	};
+	return {
+		get version() {
+			return version;
+		},
+		get ids() {
+			return rowsOf(version);
+		},
+		get receivedIds() {
+			return rowsOf(received);
+		},
+		get activeId() {
+			return activeId;
+		},
+		bump(next, editing = false) {
+			version += 1;
+			snapshots.set(version, next);
+			keepOnly((held) => held === version || held === received);
+			if (!editing || activeId === null) activeId = idAt(next, activeRow);
+			return version;
+		},
+		receive(next) {
+			if (next === received || !snapshots.has(next)) return;
+			received = next;
+			keepOnly((held) => held >= next);
+		},
+		activate(row) {
+			activeRow = row;
+			activeId = idAt(rowsOf(received), row);
+		},
+		settle(editing) {
+			if (!editing) activeId = idAt(rowsOf(received), activeRow);
+		},
+		resolve(event) {
+			return event.source === "edit" ? resolveEdit(event) : groupCells(event);
+		}
+	};
+}
+function toDomainId(state, linked, text, cleared) {
+	if (cleared) return "";
+	const name = normalizeDictionaryName(text);
+	if (name === normalizeDictionaryName(getLiveDomainName(state, linked))) return linked;
+	if (!name) return "";
+	return findDomain(state, name)?.id ?? null;
+}
+function toEntryWrite(state, kind, { id, cells }, cleared) {
+	const existing = id === null ? null : selectDictionaryRow(state, kind, id);
+	const values = {};
+	let unknownDomain = null;
+	for (const [columnId, text] of Object.entries(cells)) {
+		const field = sheetField(kind, columnId);
+		if (!field) continue;
+		if (kind === DictionaryKind.term && field === "domainId") {
+			const linked = existing && Reflect.get(existing, "domainId");
+			const domainId = toDomainId(state, isString(linked) ? linked : "", text, cleared);
+			if (domainId === null) unknownDomain = text.trim();
+			else values.domainId = domainId;
+			continue;
+		}
+		values[field] = text;
+	}
+	return {
+		change: {
+			...id === null ? {} : { id },
+			values
+		},
+		unknownDomain
+	};
+}
+function unknownDomainRefusal(state, kind, index, { change, unknownDomain }) {
+	const existing = change.id ? selectDictionaryRow(state, kind, change.id) : void 0;
+	const name = Reflect.get(change.values, "name") ?? existing?.name;
+	return {
+		code: DictionaryRefusalCode.unknownDomain,
+		index,
+		name: normalizeDictionaryName(isString(name) ? name : ""),
+		value: unknownDomain ?? ""
+	};
+}
+var REFUSAL_MESSAGE = {
+	[DictionaryRefusalCode.duplicateName]: "dictionary.toast.duplicateNames",
+	[DictionaryRefusalCode.unknownDomain]: "dictionary.toast.unknownDomainNames"
+};
+var ROW_REMOVED = "dictionary.toast.rowRemoved";
+function reportRowRemoved({ emitter }) {
+	openStatusToast(emitter, {
+		key: ROW_REMOVED,
+		tone: "error",
+		title: localized(ROW_REMOVED)
+	});
+}
+var GRID_REFUSAL_MESSAGE = {
+	"multi-range-copy": "dictionary.toast.multiRangeCopy",
+	"paste-beyond-columns": "dictionary.toast.pasteBeyondColumns",
+	"too-many-cells": "dictionary.toast.tooManyCells"
+};
+function reportGridRefusal({ emitter }, { reason }) {
+	const message = GRID_REFUSAL_MESSAGE[reason];
+	openStatusToast(emitter, {
+		key: message,
+		tone: reason === "paste-beyond-columns" ? void 0 : "error",
+		title: localized(message)
+	});
+}
+function formatNames(i18n, names) {
+	const shown = i18n.dir === "rtl" ? names.map(isolate) : names;
+	return new Intl.ListFormat(i18n.locale, { type: "unit" }).format(shown);
+}
+function reportRefusals({ emitter }, refusals, i18n) {
+	for (const code of Object.values(DictionaryRefusalCode)) {
+		const refused = refusals.filter((refusal) => refusal.code === code);
+		if (!refused.length) continue;
+		const count = new Set(refused.map(({ index }) => index)).size;
+		const named = [...new Set(refused.map(({ value }) => value))].slice(0, 3);
+		const message = REFUSAL_MESSAGE[code];
+		openStatusToast(emitter, {
+			key: `${message}:${count}:${named.join("\n")}`,
+			tone: "error",
+			title: localized(message, {
+				count,
+				names: formatNames(i18n, named)
+			})
+		});
+	}
+}
+function commitDictionaryCells({ store, emitter }, kind, rows, event, i18n = sourceI18n) {
+	const resolved = rows.resolve(event);
+	if (!resolved.length) return false;
+	const { state } = store;
+	const listed = dictionaryIds(state, kind);
+	if (resolved.some(({ id }) => id !== null && !isListed(listed, id))) {
+		reportRowRemoved({ emitter });
+		return false;
+	}
+	const cleared = event.source === "clear";
+	const writes = resolved.map((row) => toEntryWrite(state, kind, row, cleared));
+	const changes = writes.map(({ change }) => change);
+	const refusals = [...writes.flatMap((write, index) => write.unknownDomain === null ? [] : [unknownDomainRefusal(state, kind, index, write)]), ...validateDictionaryValues(state, kind, changes)];
+	if (refusals.length) {
+		reportRefusals({ emitter }, refusals, i18n);
+		return false;
+	}
+	store.dispatch(attachDictionarySheetTag$(commitDictionaryCellsAction$(kind, changes)));
+	return true;
+}
+function activeTermDomain(state, rows) {
+	const term = rows.activeId === null ? void 0 : selectDictionaryRow(state, DictionaryKind.term, rows.activeId);
+	const linked = term && Reflect.get(term, "domainId");
+	return toLiveDomainId(state, isString(linked) ? linked : "");
+}
+function commitTermDomain({ store, emitter }, rows, { id: domainId, name }, i18n = sourceI18n) {
+	const { activeId: id } = rows;
+	if (id === null) return false;
+	const { state } = store;
+	if (!isListed(dictionaryIds(state, DictionaryKind.term), id)) {
+		reportRowRemoved({ emitter });
+		return false;
+	}
+	const term = selectDictionaryRow(state, DictionaryKind.term, id);
+	if (term && Reflect.get(term, "domainId") === domainId) return false;
+	const changes = [{
+		id,
+		values: { domainId }
+	}];
+	const refusals = validateDictionaryValues(state, DictionaryKind.term, changes).map((refusal) => refusal.code === DictionaryRefusalCode.unknownDomain ? {
+		...refusal,
+		value: name
+	} : refusal);
+	if (refusals.length) {
+		reportRefusals({ emitter }, refusals, i18n);
+		return false;
+	}
+	store.dispatch(attachDictionarySheetTag$(commitDictionaryCellsAction$(DictionaryKind.term, changes)));
+	return true;
+}
+function selectedRowIds(rows, selection) {
+	const { receivedIds } = rows;
+	const last = receivedIds.length - 1;
+	const picked = /* @__PURE__ */ new Set();
+	for (const { startRow, endRow } of selection.ranges) for (let row = Math.max(startRow, 0); row <= Math.min(endRow, last); row++) picked.add(row);
+	return [...picked].sort((a, b) => a - b).map((row) => receivedIds[row]);
+}
+function removeSelectedRows(store, kind, rows, selection) {
+	const ids = selectedRowIds(rows, selection);
+	if (!ids.length) return false;
+	store.dispatch(attachDictionarySheetTag$(removeDictionaryEntriesAction$(kind, ids)));
+	return true;
+}
+//#endregion
+export { activeTermDomain, commitDictionaryCells, commitTermDomain, createSheetRows, formatNames, removeSelectedRows, reportGridRefusal, selectedRowIds };