@dineug/erd-editor 4.1.0 → 5.0.0

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 };

package/dist/components/dictionary/dictionaryFile.d.ts

@@ -0,0 +1,23 @@
+import { AppContext } from '../appContext';
+import { DictionaryKind } from '../../engine/modules/dictionary/actions';
+import { RootState } from '../../engine/state';
+import { I18n } from '../../i18n/translate';
+/** What the tab's file input takes: a dictionary comes in one format, whichever layout its header names. */
+export declare const DICTIONARY_FILE_ACCEPT = ".csv";
+/** The file format the buttons, the menu and the empty sheet's hint name, which no language translates. */
+export declare const DICTIONARY_FILE_FORMAT = "CSV";
+/**
+ * Imports a file into the dictionary its header names in one dispatch, reports
+ * the counts and answers that dictionary; null for a read-only document or a
+ * file no layout reads, which sends nothing and says so.
+ */
+export declare function importDictionaryFile({ store, emitter }: Pick<AppContext, 'store' | 'emitter'>, file: Blob, i18n?: Pick<I18n, 'locale' | 'dir'>): Promise<DictionaryKind | null>;
+/**
+ * A dictionary's listed rows in the editor's own CSV format, in the order its
+ * sheet shows them, whatever a search shows. A term names its domain by the
+ * domain's name, and nothing for one the document does not list.
+ */
+export declare function toDictionaryCsv(state: RootState, kind: DictionaryKind): string;
+/** Saves a dictionary as its own CSV file, named after the database and the sheet. */
+export declare function exportDictionarySheet(state: RootState, kind: DictionaryKind): void;
+//# sourceMappingURL=dictionaryFile.d.ts.map

package/dist/components/dictionary/dictionaryFile.js

@@ -0,0 +1,72 @@
+import { DictionaryKind } from "../../engine/modules/dictionary/actions.js";
+import { getLiveDomainName } from "../../engine/modules/dictionary/membership.js";
+import { orderedDictionaryRows } from "../../engine/modules/dictionary/dictionaryIndex.js";
+import { attachDictionarySheetTag$ } from "../../engine/tag.js";
+import { toDictionaryImport } from "../../engine/modules/dictionary/entryWrites.js";
+import { importDictionaryAction$ } from "../../engine/modules/dictionary/generator.actions.js";
+import { sourceI18n } from "../../i18n/source.js";
+import { localized } from "../localized/Localized.js";
+import { openStatusToast } from "../toast-container/openStatusToast.js";
+import { formatNames } from "./dictionaryCommit.js";
+import { decodeCsvBytes } from "../../utils/dictionary-csv/decode.js";
+import { readDictionaryCsv, writeDictionaryCsv } from "../../utils/dictionary-csv/dictionaryCsv.js";
+import { exportCSV } from "../../utils/file/exportFile.js";
+//#region src/components/dictionary/dictionaryFile.ts
+var DICTIONARY_FILE_ACCEPT = ".csv";
+var IMPORTED = "dictionary.toast.imported";
+var UNKNOWN_DOMAINS = "dictionary.toast.unknownDomains";
+var UNKNOWN_FORMAT = "dictionary.toast.unknownFormat";
+function reportImport(emitter, { added, updated, skipped, unknownDomains }, i18n) {
+	const count = unknownDomains.length;
+	const named = unknownDomains.slice(0, 3);
+	openStatusToast(emitter, {
+		key: `${IMPORTED}:${added}:${updated}:${skipped}:${count}:${named.join("\n")}`,
+		tone: "success",
+		title: localized(IMPORTED, {
+			added,
+			updated,
+			skipped
+		}),
+		description: count ? localized(UNKNOWN_DOMAINS, {
+			count,
+			names: formatNames(i18n, named)
+		}) : void 0
+	});
+}
+async function importDictionaryFile({ store, emitter }, file, i18n = sourceI18n) {
+	const read = readDictionaryCsv(decodeCsvBytes(await file.arrayBuffer()));
+	if (store.getReadonly()) return null;
+	if (!read) {
+		openStatusToast(emitter, {
+			key: UNKNOWN_FORMAT,
+			tone: "error",
+			title: localized(UNKNOWN_FORMAT)
+		});
+		return null;
+	}
+	const { kind, rows } = read;
+	const { added, updated, folded, unknownDomains } = toDictionaryImport(store.state, kind, rows);
+	store.dispatch(attachDictionarySheetTag$(importDictionaryAction$(kind, rows)));
+	reportImport(emitter, {
+		added,
+		updated,
+		skipped: read.skipped + folded,
+		unknownDomains
+	}, i18n);
+	return kind;
+}
+function toDictionaryCsv(state, kind) {
+	switch (kind) {
+		case DictionaryKind.word: return writeDictionaryCsv(kind, orderedDictionaryRows(state, kind));
+		case DictionaryKind.term: return writeDictionaryCsv(kind, orderedDictionaryRows(state, kind).map((term) => ({
+			...term,
+			domain: getLiveDomainName(state, term.domainId)
+		})));
+		case DictionaryKind.domain: return writeDictionaryCsv(kind, orderedDictionaryRows(state, kind));
+	}
+}
+function exportDictionarySheet(state, kind) {
+	exportCSV(toDictionaryCsv(state, kind), kind, state.settings.databaseName);
+}
+//#endregion
+export { DICTIONARY_FILE_ACCEPT, exportDictionarySheet, importDictionaryFile, toDictionaryCsv };

package/dist/components/dictionary/dictionaryKeys.d.ts

@@ -0,0 +1,48 @@
+import { ValuesType } from '../../internal-types';
+import { KeyBindingMap, KeyBindingName, ShortcutOption } from '../../utils/keyboard-shortcut';
+/**
+ * The editor's chords a press in the Dictionary tab still hands on: the
+ * palette, undo and redo, which the tab runs on the sheet's own history, and
+ * find, whose chord works on every tab.
+ */
+export declare const DICTIONARY_PASSING_BINDINGS: ReadonlyArray<KeyBindingName>;
+/** What a press does to a sheet's rows in the grid. */
+export declare const RowCommand: {
+    readonly insertBelow: "insertBelow";
+    readonly insertAbove: "insertAbove";
+    readonly deleteRows: "deleteRows";
+};
+export type RowCommand = ValuesType<typeof RowCommand>;
+/** The chord a menu row shows for a row command, if one is bound. */
+export declare const rowChordOf: (keyBindingMap: KeyBindingMap, command: RowCommand) => string | undefined;
+/**
+ * Every chord the grid runs a row command by under the bindings given, Insert
+ * above's among them, which no binding names: what a host that keeps its own
+ * hotkeys off the editor's keys registers beside the binding map's.
+ */
+export declare const dictionaryRowChords: (keyBindingMap: KeyBindingMap) => ShortcutOption[];
+export type DictionaryKeyContext = {
+    keyBindingMap: KeyBindingMap;
+    /** Undoes the last edit of the sheet shown, from its own history. */
+    undo: () => void;
+    redo: () => void;
+    /** Whether the press came from inside the tab's grid. */
+    inGrid: boolean;
+    /** Whether the grid holds an open edit, whose own undo takes the press and which keeps the palette and find. */
+    isEditing: () => boolean;
+    /** Inserts as many rows below the selection as it covers. */
+    insertRows: () => void;
+    /** Inserts as many rows above the selection as it covers. */
+    insertRowsAbove: () => void;
+    /** Deletes the rows the selection covers. */
+    deleteRows: () => void;
+};
+/**
+ * Reads a press at the tab's root: undo and redo undo the sheet shown unless an
+ * edit or a field takes them, the row chords insert and delete rows in a grid
+ * with no edit open, which keeps find and the palette, and the rest stops.
+ */
+export declare function handleDictionaryKeydown(event: KeyboardEvent, { keyBindingMap, undo: undoSheet, redo: redoSheet, inGrid, isEditing, insertRows, insertRowsAbove, deleteRows, }: DictionaryKeyContext): void;
+/** Keeps a copy, a cut or a paste in the tab, which the editor root would read as a diagram's. */
+export declare const keepClipboard: (event: ClipboardEvent) => void;
+//# sourceMappingURL=dictionaryKeys.d.ts.map

package/dist/components/dictionary/dictionaryKeys.js

@@ -0,0 +1,86 @@
+import { KeyBindingName, isComposing, matchesShortcut, shortcutToTuple, stopsAtPanel } from "../../utils/keyboard-shortcut/index.js";
+import { isEditableTarget } from "../../utils/validation.js";
+//#region src/components/dictionary/dictionaryKeys.ts
+var DICTIONARY_PASSING_BINDINGS = [
+	KeyBindingName.search,
+	KeyBindingName.undo,
+	KeyBindingName.redo,
+	KeyBindingName.findReplace
+];
+var KEPT_BY_AN_EDIT = [KeyBindingName.search, KeyBindingName.findReplace];
+var RowCommand = {
+	insertBelow: "insertBelow",
+	insertAbove: "insertAbove",
+	deleteRows: "deleteRows"
+};
+var RowCommandList = Object.values(RowCommand);
+var onePressOptions = (keyBindingMap, name) => keyBindingMap[name].filter(({ shortcut }) => shortcutToTuple(shortcut).length === 1);
+function withShift({ shortcut, ...option }) {
+	const mods = shortcut.split(/\b\+/);
+	const key = mods.pop();
+	return mods.includes("Shift") ? [] : [{
+		...option,
+		shortcut: [
+			...mods,
+			"Shift",
+			key
+		].join("+")
+	}];
+}
+function rowOptions(keyBindingMap, command) {
+	switch (command) {
+		case RowCommand.insertBelow: return onePressOptions(keyBindingMap, KeyBindingName.addColumn);
+		case RowCommand.insertAbove: return onePressOptions(keyBindingMap, KeyBindingName.addColumn).flatMap(withShift);
+		case RowCommand.deleteRows: return onePressOptions(keyBindingMap, KeyBindingName.removeColumn);
+	}
+}
+var rowChordOf = (keyBindingMap, command) => rowOptions(keyBindingMap, command)[0]?.shortcut;
+var dictionaryRowChords = (keyBindingMap) => RowCommandList.flatMap((command) => rowOptions(keyBindingMap, command));
+function rowChord(event, keyBindingMap) {
+	for (const command of RowCommandList) {
+		const option = rowOptions(keyBindingMap, command).find((option) => matchesShortcut(event, [option]));
+		if (option) return {
+			command,
+			option
+		};
+	}
+}
+var chordOf = (event, keyBindingMap, names) => names.flatMap((name) => keyBindingMap[name]).find((option) => matchesShortcut(event, [option]));
+function handleDictionaryKeydown(event, { keyBindingMap, undo: undoSheet, redo: redoSheet, inGrid, isEditing, insertRows, insertRowsAbove, deleteRows }) {
+	if (!isComposing(event)) {
+		const undo = matchesShortcut(event, keyBindingMap[KeyBindingName.undo]);
+		const redo = !undo && matchesShortcut(event, keyBindingMap[KeyBindingName.redo]);
+		if (undo || redo) {
+			if (inGrid ? isEditing() : isEditableTarget(event.target)) {
+				event.stopPropagation();
+				return;
+			}
+			undo ? undoSheet() : redoSheet();
+			return;
+		}
+		const row = inGrid && !isEditing() ? rowChord(event, keyBindingMap) : void 0;
+		if (row) {
+			if (row.option.preventDefault) event.preventDefault();
+			event.stopPropagation();
+			const run = {
+				[RowCommand.insertBelow]: insertRows,
+				[RowCommand.insertAbove]: insertRowsAbove,
+				[RowCommand.deleteRows]: deleteRows
+			}[row.command];
+			run();
+			return;
+		}
+		const kept = inGrid ? chordOf(event, keyBindingMap, KEPT_BY_AN_EDIT) : void 0;
+		if (kept && isEditing()) {
+			if (kept.preventDefault) event.preventDefault();
+			event.stopPropagation();
+			return;
+		}
+	}
+	if (stopsAtPanel(event, keyBindingMap, DICTIONARY_PASSING_BINDINGS)) event.stopPropagation();
+}
+var keepClipboard = (event) => {
+	event.stopPropagation();
+};
+//#endregion
+export { DICTIONARY_PASSING_BINDINGS, RowCommand, dictionaryRowChords, handleDictionaryKeydown, keepClipboard, rowChordOf };

package/dist/components/dictionary/dictionaryView.d.ts

@@ -0,0 +1,65 @@
+import { GridHandle, GridSelection } from '@dineug/grid';
+import { AppContext } from '../appContext';
+import { DictionarySheet } from './sheets';
+/** The first cell a sheet showed, the one a grid mounted again scrolls back to. */
+export type SheetScroll = {
+    row: number;
+    col: number;
+};
+/**
+ * What the tab keeps of one sheet across its mounts. The selection and the
+ * scroll count rows of the sheet as its search shows them. Each is frozen and
+ * replaced whole, so a watcher hears one change and a grid is handed no proxy.
+ */
+export type DictionarySheetView = {
+    search: string;
+    selection: Readonly<GridSelection> | null;
+    scroll: Readonly<SheetScroll> | null;
+    /** The widths a resize left, by column id. */
+    widths: Readonly<Record<string, number>>;
+};
+export type DictionaryView = {
+    sheet: DictionarySheet;
+    sheets: Record<DictionarySheet, DictionarySheetView>;
+};
+/**
+ * The window's own place in the Dictionary tab: never in the store, the file
+ * or a change event, kept until the element goes, one per editor. The tab
+ * mounts again on every visit and reads it back.
+ */
+export declare function dictionaryViewOf({ store, }: Pick<AppContext, 'store'>): DictionaryView;
+/**
+ * Writes a sheet's search. The rows it shows change with it, so the selection
+ * and the scroll it kept, which count those rows, are dropped.
+ */
+export declare function changeSearch(view: DictionaryView, sheet: DictionarySheet, search: string): void;
+/** Keeps the selection a grid reported or was handed, as a frozen copy. */
+export declare function rememberSelection(view: DictionaryView, sheet: DictionarySheet, selection: GridSelection): void;
+/**
+ * A selection held inside the rows and columns a grid has, every index cut to
+ * the last one and a range kept start before end; a grid with no rows keeps
+ * its first cell, where a row added comes up active.
+ */
+export declare function clampSelection(selection: Readonly<GridSelection>, rowCount: number, colCount: number): GridSelection;
+/** The first cell alone, what a sheet opens on before it has a selection of its own. */
+export declare const FIRST_CELL_SELECTION: Readonly<GridSelection>;
+/**
+ * The selection a grid mounted on the sheet is handed: the one it kept, held
+ * inside the rows it shows now, or the first cell. A fresh copy, since a grid
+ * holds what it is handed.
+ */
+export declare function storedSelection(view: DictionaryView, sheet: DictionarySheet, rowCount: number, colCount: number): GridSelection;
+/** Keeps the first cell a grid showed, from its viewport report, when it moved. */
+export declare function rememberScroll(view: DictionaryView, sheet: DictionarySheet, { rowStart, colStart }: {
+    rowStart: number;
+    colStart: number;
+}): void;
+/**
+ * Scrolls a grid back to the first cell its sheet showed. A grid scrolls the
+ * least distance that shows a cell, so it goes to the last cell first, and the
+ * way back up then stops with the kept cell first in view.
+ */
+export declare function restoreScroll(handle: Pick<GridHandle, 'scrollTo'>, view: DictionaryView, sheet: DictionarySheet, rowCount: number, colCount: number): void;
+/** Keeps the width a resize left a column at, which the grid draws only while the host holds it. */
+export declare function rememberWidth(view: DictionaryView, sheet: DictionarySheet, columnId: string, width: number): void;
+//# sourceMappingURL=dictionaryView.d.ts.map

package/dist/components/dictionary/dictionaryView.js

@@ -0,0 +1,100 @@
+import { observable } from "../../r-html/dist/observable/index.js";
+import { DictionarySheet, DictionarySheetList } from "./sheets.js";
+//#region src/components/dictionary/dictionaryView.ts
+var views = /* @__PURE__ */ new WeakMap();
+var createSheetView = () => ({
+	search: "",
+	selection: null,
+	scroll: null,
+	widths: Object.freeze({})
+});
+function dictionaryViewOf({ store }) {
+	let view = views.get(store);
+	if (!view) {
+		view = observable({
+			sheet: DictionarySheet.domain,
+			sheets: Object.fromEntries(DictionarySheetList.map((sheet) => [sheet, createSheetView()]))
+		});
+		views.set(store, view);
+	}
+	return view;
+}
+function changeSearch(view, sheet, search) {
+	const sheetView = view.sheets[sheet];
+	if (sheetView.search === search) return;
+	sheetView.search = search;
+	sheetView.selection = null;
+	sheetView.scroll = null;
+}
+var copyRange = (range) => ({
+	startRow: range.startRow,
+	startCol: range.startCol,
+	endRow: range.endRow,
+	endCol: range.endCol
+});
+function rememberSelection(view, sheet, selection) {
+	view.sheets[sheet].selection = Object.freeze({
+		active: Object.freeze({ ...selection.active }),
+		ranges: Object.freeze(selection.ranges.map((range) => Object.freeze(copyRange(range))))
+	});
+}
+function clampSelection(selection, rowCount, colCount) {
+	const toRow = (row) => Math.min(Math.max(row, 0), Math.max(rowCount - 1, 0));
+	const toCol = (col) => Math.min(Math.max(col, 0), Math.max(colCount - 1, 0));
+	return {
+		active: {
+			row: toRow(selection.active.row),
+			col: toCol(selection.active.col)
+		},
+		ranges: selection.ranges.map((range) => {
+			const [startRow, endRow] = [toRow(range.startRow), toRow(range.endRow)];
+			const [startCol, endCol] = [toCol(range.startCol), toCol(range.endCol)];
+			return {
+				startRow: Math.min(startRow, endRow),
+				startCol: Math.min(startCol, endCol),
+				endRow: Math.max(startRow, endRow),
+				endCol: Math.max(startCol, endCol)
+			};
+		})
+	};
+}
+var FIRST_CELL_SELECTION = Object.freeze({
+	active: Object.freeze({
+		row: 0,
+		col: 0
+	}),
+	ranges: Object.freeze([Object.freeze({
+		startRow: 0,
+		startCol: 0,
+		endRow: 0,
+		endCol: 0
+	})])
+});
+function storedSelection(view, sheet, rowCount, colCount) {
+	return clampSelection(view.sheets[sheet].selection ?? FIRST_CELL_SELECTION, rowCount, colCount);
+}
+function rememberScroll(view, sheet, { rowStart, colStart }) {
+	const sheetView = view.sheets[sheet];
+	const kept = sheetView.scroll;
+	if (kept && kept.row === rowStart && kept.col === colStart) return;
+	sheetView.scroll = Object.freeze({
+		row: rowStart,
+		col: colStart
+	});
+}
+function restoreScroll(handle, view, sheet, rowCount, colCount) {
+	const { scroll } = view.sheets[sheet];
+	if (!scroll || rowCount <= 0 || colCount <= 0) return;
+	handle.scrollTo(rowCount - 1, colCount - 1);
+	handle.scrollTo(Math.min(scroll.row, rowCount - 1), Math.min(scroll.col, colCount - 1));
+}
+function rememberWidth(view, sheet, columnId, width) {
+	const sheetView = view.sheets[sheet];
+	if (sheetView.widths[columnId] === width) return;
+	sheetView.widths = Object.freeze({
+		...sheetView.widths,
+		[columnId]: width
+	});
+}
+//#endregion
+export { FIRST_CELL_SELECTION, changeSearch, clampSelection, dictionaryViewOf, rememberScroll, rememberSelection, rememberWidth, restoreScroll, storedSelection };

package/dist/components/dictionary/domain-cell-editor/DomainCellEditor.d.ts

@@ -0,0 +1,22 @@
+import { EditorContext } from '@dineug/grid';
+import { FC } from '@dineug/r-html';
+import { DomainOption } from '../../table-view/column/column-domain/domainOptions';
+export type DomainCellEditorProps = {
+    editor: EditorContext;
+    /** The column's header, which names the search field. */
+    label: string;
+    /** The id of the domain the cell's row links, '' for none, which the list opens on. */
+    linkedId: string;
+    /** Links the row to the domain picked, by its id, '' for None. */
+    onPick: (option: DomainOption) => void;
+    /** Runs once its edit has closed, after onPick for a pick. */
+    onClose: () => void;
+};
+/**
+ * A term's domain cell editor: a search over the domain sheet by name that only
+ * picks, as the ERD tab's domain cell does. The grid's edit writes no text: a
+ * pick cancels it and hands the tab the domain picked by its id, None as ''.
+ */
+declare const DomainCellEditor: FC<DomainCellEditorProps>;
+export default DomainCellEditor;
+//# sourceMappingURL=DomainCellEditor.d.ts.map