@dineug/erd-editor 4.1.0 → 5.0.0

package/dist/engine/modules/dictionary/generator.actions.d.ts

@@ -0,0 +1,126 @@
+import { GeneratorAction } from '../../generator.actions';
+import { ValuesType } from '../../../internal-types';
+import { DictionaryCsvRow } from '../../../utils/dictionary-csv/dictionaryCsv';
+import { DictionaryKind, DictionaryValues } from './actions';
+import { DictionaryEntryChange } from './entryWrites';
+/**
+ * Adds one row at the end of its sheet with the values given, none for an
+ * empty row; nothing when its name is another row's or its domain unknown.
+ */
+export declare const addDictionaryEntryAction$: <K extends DictionaryKind>(kind: K, values?: Partial<DictionaryValues[K]>) => GeneratorAction;
+/** Where inserted rows go: before or after a listed row, or at the end for none. */
+export type DictionaryInsertAnchor = {
+    id: string;
+    place: 'before' | 'after';
+} | null;
+/**
+ * Inserts empty rows before or after a row in one dispatch, at the end when it
+ * is gone, keying the rows around the place again where no key fits between
+ * them. Only the editor sends it, so it stays out of the barrel.
+ */
+export declare const insertDictionaryEntriesAction$: (kind: DictionaryKind, count: number, anchor?: DictionaryInsertAnchor) => GeneratorAction;
+/** Which way a sort runs. */
+export declare const DictionarySortDirection: {
+    readonly ascending: "ascending";
+    readonly descending: "descending";
+};
+export type DictionarySortDirection = ValuesType<typeof DictionarySortDirection>;
+/**
+ * Orders a sheet by one field for everyone in one dispatch, by the text a cell
+ * shows in the language given, numbers as numbers, empty cells last, ties as
+ * they stood; nothing for a sheet in that order. Only the editor sends it.
+ */
+export declare const sortDictionaryAction$: (kind: DictionaryKind, field: string, direction: DictionarySortDirection, locale?: string) => GeneratorAction;
+/**
+ * Writes the fields of a listed row that change, and the type of every column
+ * a domain's new type reaches; nothing when the row is refused or unlisted.
+ */
+export declare const updateDictionaryEntryAction$: <K extends DictionaryKind>(kind: K, id: string, values: Partial<DictionaryValues[K]>) => GeneratorAction;
+/**
+ * Removes each listed row named, once, in one dispatch, from the end of the
+ * list back, each after every named row behind it: removing a whole sheet or
+ * its tail moves no other row, while rows a scattered pick leaves still move.
+ */
+export declare const removeDictionaryEntriesAction$: (kind: DictionaryKind, ids: ReadonlyArray<string>) => GeneratorAction;
+/**
+ * A grid's commit: an update of each listed row named and an add of each row
+ * past the end, in one dispatch, or nothing at all when any row is refused.
+ */
+export declare const commitDictionaryCellsAction$: <K extends DictionaryKind>(kind: K, changes: ReadonlyArray<DictionaryEntryChange<K>>) => GeneratorAction;
+/**
+ * A file's rows, folded by name and upserted by name in one dispatch: only the
+ * adds and the fields that change, so the same file again sends nothing.
+ */
+export declare const importDictionaryAction$: <K extends DictionaryKind>(kind: K, rows: ReadonlyArray<DictionaryCsvRow<K>>) => GeneratorAction;
+/**
+ * Writes a column's logical name and what the dictionaries derive of it in
+ * one dispatch, the derivation only while the physical name is empty or
+ * derived; nothing when every value already holds.
+ */
+export declare const setColumnLogicalNameAction$: (tableId: string, columnId: string, value: string) => GeneratorAction;
+/**
+ * The logical names of several columns and what the dictionaries derive of
+ * them in one dispatch, as Replace All writes them; the domains they link are
+ * read over all of them at once, which separate generators would not do.
+ */
+export declare const setColumnLogicalNamesAction$: (names: ReadonlyArray<{
+    tableId: string;
+    columnId: string;
+    value: string;
+}>) => GeneratorAction;
+/** The table's logical name and its derived name, as a column's are. */
+export declare const setTableLogicalNameAction$: (tableId: string, value: string) => GeneratorAction;
+/** Derives a column's name from the logical name it holds, as its editor closes. */
+export declare const deriveColumnNameAction$: (tableId: string, columnId: string) => GeneratorAction;
+/** Derives a table's name from the logical name it holds, as its editor closes. */
+export declare const deriveTableNameAction$: (tableId: string) => GeneratorAction;
+/** What a derivation again covers. */
+export declare const RederiveScope: {
+    readonly column: "column";
+    readonly table: "table";
+    readonly selection: "selection";
+    readonly document: "document";
+};
+export type RederiveScope = ValuesType<typeof RederiveScope>;
+/**
+ * One column; one table, its name and every column; the selected tables so;
+ * or every table of the document so.
+ */
+export type RederiveNamesTarget = {
+    scope: typeof RederiveScope.column;
+    tableId: string;
+    columnId: string;
+} | {
+    scope: typeof RederiveScope.table;
+    tableId: string;
+} | {
+    scope: typeof RederiveScope.selection;
+} | {
+    scope: typeof RederiveScope.document;
+};
+/**
+ * Puts each name the target covers back under the dictionaries, its flag on,
+ * and derives it again, one dispatch and one undo; a name with no logical
+ * name, or a column whose new name another column holds, is left as it is.
+ */
+export declare const rederiveNamesAction$: (target: RederiveNamesTarget) => GeneratorAction;
+/**
+ * Links a column to a live domain and gives it the domain's type, the data
+ * type sync spreading it, in one dispatch; '' unlinks alone. A domain the
+ * document does not list links nothing.
+ */
+export declare const setColumnDomainAction$: (tableId: string, columnId: string, domainId: string) => GeneratorAction;
+export declare const actions$: {
+    addDictionaryEntryAction$: <K extends DictionaryKind>(kind: K, values?: Partial<DictionaryValues[K]>) => GeneratorAction;
+    updateDictionaryEntryAction$: <K extends DictionaryKind>(kind: K, id: string, values: Partial<DictionaryValues[K]>) => GeneratorAction;
+    removeDictionaryEntriesAction$: (kind: DictionaryKind, ids: ReadonlyArray<string>) => GeneratorAction;
+    importDictionaryAction$: <K extends DictionaryKind>(kind: K, rows: ReadonlyArray<DictionaryCsvRow<K>>) => GeneratorAction;
+    commitDictionaryCellsAction$: <K extends DictionaryKind>(kind: K, changes: ReadonlyArray<DictionaryEntryChange<K>>) => GeneratorAction;
+    setColumnLogicalNameAction$: (tableId: string, columnId: string, value: string) => GeneratorAction;
+    setTableLogicalNameAction$: (tableId: string, value: string) => GeneratorAction;
+    deriveColumnNameAction$: (tableId: string, columnId: string) => GeneratorAction;
+    deriveTableNameAction$: (tableId: string) => GeneratorAction;
+    rederiveNamesAction$: (target: RederiveNamesTarget) => GeneratorAction;
+    setColumnDomainAction$: (tableId: string, columnId: string, domainId: string) => GeneratorAction;
+};
+//# sourceMappingURL=generator.actions.d.ts.map

package/dist/engine/modules/dictionary/generator.actions.js

@@ -0,0 +1,217 @@
+import { generateOrderKeys } from "../../../erd-editor-schema/dist/orderKey.js";
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { DictionaryFields, DictionaryKind } from "./actions.js";
+import { getLiveDomainName, isListed } from "./membership.js";
+import { changeColumnLogicalNameAction } from "../table-column/atom.actions.js";
+import { toDomainTypeActions } from "./domainTypes.js";
+import { orderedDictionaryRows } from "./dictionaryIndex.js";
+import { dictionaryIds, hasDictionaryKind, removeDictionaryAction } from "./atom.actions.js";
+import { SelectType } from "../editor/state.js";
+import { changeTableLogicalNameAction } from "../table/atom.actions.js";
+import { toColumnNameWrites, toTableNameWrites } from "./derivedNames.js";
+import { placeOrderKeys } from "./orderKeys.js";
+import { toDictionaryCommit, toDictionaryImport } from "./entryWrites.js";
+//#region src/engine/modules/dictionary/generator.actions.ts
+var tableOf = (state, id) => query(state.collections).collection("tableEntities").selectById(id);
+var columnOf = (state, id) => query(state.collections).collection("tableColumnEntities").selectById(id);
+function* commit(state, kind, changes) {
+	if (!hasDictionaryKind(kind)) return;
+	const { actions } = toDictionaryCommit(state, kind, changes);
+	if (actions.length) yield actions;
+}
+var addDictionaryEntryAction$ = (kind, values = {}) => function* (state) {
+	yield* commit(state, kind, [{ values }]);
+};
+function insertIndexOf(rows, anchor) {
+	const index = anchor ? rows.findIndex(({ id }) => id === anchor.id) : -1;
+	if (!anchor || index === -1) return rows.length;
+	return anchor.place === "after" ? index + 1 : index;
+}
+var insertDictionaryEntriesAction$ = (kind, count, anchor = null) => function* (state) {
+	if (!hasDictionaryKind(kind) || count <= 0) return;
+	const rows = orderedDictionaryRows(state, kind);
+	const { keys, rekeyed } = placeOrderKeys(rows, insertIndexOf(rows, anchor), count);
+	yield* commit(state, kind, [...rekeyed.map(({ id, order }) => ({
+		id,
+		values: { order }
+	})), ...keys.map((order) => ({ values: { order } }))]);
+};
+var DictionarySortDirection = {
+	ascending: "ascending",
+	descending: "descending"
+};
+var sortDictionaryAction$ = (kind, field, direction, locale) => function* (state) {
+	if (!hasDictionaryKind(kind)) return;
+	if (!DictionaryFields[kind].includes(field)) return;
+	const collator = new Intl.Collator(locale, { numeric: true });
+	const sign = direction === DictionarySortDirection.descending ? -1 : 1;
+	const textOf = (row) => kind === DictionaryKind.term && field === "domainId" ? getLiveDomainName(state, Reflect.get(row, "domainId")) : Reflect.get(row, field);
+	const rows = orderedDictionaryRows(state, kind).map((row, index) => ({
+		row,
+		index,
+		text: textOf(row)
+	}));
+	rows.sort((a, b) => {
+		const emptyA = a.text === "";
+		if (emptyA !== (b.text === "")) return emptyA ? 1 : -1;
+		return sign * collator.compare(a.text, b.text) || a.index - b.index;
+	});
+	if (rows.every(({ index }, at) => index === at)) return;
+	const keys = generateOrderKeys(null, null, rows.length);
+	yield* commit(state, kind, rows.flatMap(({ row }, at) => row.order === keys[at] ? [] : [{
+		id: row.id,
+		values: { order: keys[at] }
+	}]));
+};
+var updateDictionaryEntryAction$ = (kind, id, values) => function* (state) {
+	yield* commit(state, kind, [{
+		id,
+		values
+	}]);
+};
+var removeDictionaryEntriesAction$ = (kind, ids) => function* (state) {
+	if (!hasDictionaryKind(kind)) return;
+	const listed = dictionaryIds(state, kind);
+	const named = new Set(ids.filter((id) => isListed(listed, id)));
+	if (!named.size) return;
+	const removed = [];
+	for (let index = listed.length - 1; index >= 0; index--) if (named.has(listed[index])) removed.push(listed[index]);
+	yield removed.map((id) => removeDictionaryAction({
+		kind,
+		id
+	}));
+};
+var commitDictionaryCellsAction$ = (kind, changes) => function* (state) {
+	yield* commit(state, kind, changes);
+};
+var importDictionaryAction$ = (kind, rows) => function* (state) {
+	if (!hasDictionaryKind(kind)) return;
+	const { actions } = toDictionaryImport(state, kind, rows);
+	if (actions.length) yield actions;
+};
+function columnNameActions(state, names) {
+	const actions = [];
+	const links = [];
+	const ledger = /* @__PURE__ */ new Map();
+	for (const { tableId, columnId, logicalName } of names) {
+		const column = columnOf(state, columnId);
+		if (!column) continue;
+		const value = logicalName ?? column.logicalName;
+		if (logicalName !== null && logicalName !== column.logicalName) actions.push(changeColumnLogicalNameAction({
+			tableId,
+			id: columnId,
+			value
+		}));
+		const writes = toColumnNameWrites(state, tableId, column, value, false, ledger);
+		actions.push(...writes.actions);
+		if (writes.link) links.push(writes.link);
+	}
+	if (links.length) actions.push(...toDomainTypeActions(state, { links }));
+	return actions;
+}
+function tableNameActions(state, tableId, logicalName) {
+	const table = tableOf(state, tableId);
+	if (!table) return [];
+	const value = logicalName ?? table.logicalName;
+	const actions = logicalName !== null && logicalName !== table.logicalName ? [changeTableLogicalNameAction({
+		id: tableId,
+		value
+	})] : [];
+	actions.push(...toTableNameWrites(state, table, value));
+	return actions;
+}
+var setColumnLogicalNameAction$ = (tableId, columnId, value) => function* (state) {
+	const actions = columnNameActions(state, [{
+		tableId,
+		columnId,
+		logicalName: value
+	}]);
+	if (actions.length) yield actions;
+};
+var setColumnLogicalNamesAction$ = (names) => function* (state) {
+	const actions = columnNameActions(state, names.map(({ tableId, columnId, value }) => ({
+		tableId,
+		columnId,
+		logicalName: value
+	})));
+	if (actions.length) yield actions;
+};
+var setTableLogicalNameAction$ = (tableId, value) => function* (state) {
+	const actions = tableNameActions(state, tableId, value);
+	if (actions.length) yield actions;
+};
+var deriveColumnNameAction$ = (tableId, columnId) => function* (state) {
+	const actions = columnNameActions(state, [{
+		tableId,
+		columnId,
+		logicalName: null
+	}]);
+	if (actions.length) yield actions;
+};
+var deriveTableNameAction$ = (tableId) => function* (state) {
+	const actions = tableNameActions(state, tableId, null);
+	if (actions.length) yield actions;
+};
+var RederiveScope = {
+	column: "column",
+	table: "table",
+	selection: "selection",
+	document: "document"
+};
+function rederivedTableIds(state, target) {
+	const { doc, editor } = state;
+	const listed = new Set(doc.tableIds);
+	const isInDoc = (id) => listed.has(id);
+	switch (target.scope) {
+		case RederiveScope.table: return isInDoc(target.tableId) ? [target.tableId] : [];
+		case RederiveScope.selection: return Object.entries(editor.selectedMap).filter(([id, type]) => type === SelectType.table && isInDoc(id)).map(([id]) => id);
+		case RederiveScope.document: return [...doc.tableIds];
+		default: return [];
+	}
+}
+var rederiveNamesAction$ = (target) => function* (state) {
+	const actions = [];
+	const links = [];
+	const ledger = /* @__PURE__ */ new Map();
+	const deriveColumn = (tableId, columnId) => {
+		const column = columnOf(state, columnId);
+		if (!column) return;
+		const writes = toColumnNameWrites(state, tableId, column, column.logicalName, true, ledger);
+		actions.push(...writes.actions);
+		if (writes.link) links.push(writes.link);
+	};
+	if (target.scope === RederiveScope.column) deriveColumn(target.tableId, target.columnId);
+	for (const tableId of rederivedTableIds(state, target)) {
+		const table = tableOf(state, tableId);
+		if (!table) continue;
+		actions.push(...toTableNameWrites(state, table, table.logicalName, true));
+		for (const columnId of table.columnIds) deriveColumn(tableId, columnId);
+	}
+	if (links.length) actions.push(...toDomainTypeActions(state, { links }));
+	if (actions.length) yield actions;
+};
+var setColumnDomainAction$ = (tableId, columnId, domainId) => function* (state) {
+	if (!columnOf(state, columnId)) return;
+	if (domainId !== "" && !isListed(state.doc.domainIds, domainId)) return;
+	const actions = toDomainTypeActions(state, { links: [{
+		tableId,
+		id: columnId,
+		value: domainId
+	}] });
+	if (actions.length) yield actions;
+};
+var actions$ = {
+	addDictionaryEntryAction$,
+	updateDictionaryEntryAction$,
+	removeDictionaryEntriesAction$,
+	importDictionaryAction$,
+	commitDictionaryCellsAction$,
+	setColumnLogicalNameAction$,
+	setTableLogicalNameAction$,
+	deriveColumnNameAction$,
+	deriveTableNameAction$,
+	rederiveNamesAction$,
+	setColumnDomainAction$
+};
+//#endregion
+export { DictionarySortDirection, RederiveScope, actions$, addDictionaryEntryAction$, commitDictionaryCellsAction$, deriveColumnNameAction$, deriveTableNameAction$, importDictionaryAction$, insertDictionaryEntriesAction$, rederiveNamesAction$, removeDictionaryEntriesAction$, setColumnDomainAction$, setColumnLogicalNameAction$, setColumnLogicalNamesAction$, setTableLogicalNameAction$, sortDictionaryAction$, updateDictionaryEntryAction$ };

package/dist/engine/modules/dictionary/history.d.ts

@@ -0,0 +1,14 @@
+import { AnyAction } from '@dineug/r-html';
+import { PushUndoHistory } from '../../history.actions';
+/**
+ * Turns round the adds and removes an undo sends, in the slots they hold: the
+ * undo of an import then takes its rows off the end of each list, and the undo
+ * of a removal sent from the end puts the rows back in their order.
+ */
+export declare function reverseDictionaryListings(undoActions: AnyAction[]): void;
+export declare const dictionaryPushUndoHistoryMap: {
+    "dictionary.add": PushUndoHistory;
+    "dictionary.update": PushUndoHistory;
+    "dictionary.remove": PushUndoHistory;
+};
+//# sourceMappingURL=history.d.ts.map

package/dist/engine/modules/dictionary/history.js

@@ -0,0 +1,54 @@
+import { ActionType } from "./actions.js";
+import { isListed } from "./membership.js";
+import { addDictionaryAction, dictionaryEntries, dictionaryIds, hasDictionaryKind, removeDictionaryAction, selectDictionaryRow, updateDictionaryAction } from "./atom.actions.js";
+//#region src/engine/modules/dictionary/history.ts
+function pushPreviousValues(undoActions, { kind, id, values }, state) {
+	const entity = selectDictionaryRow(state, kind, id);
+	const fields = dictionaryEntries(kind, values);
+	if (!entity || !fields.length) return;
+	undoActions.push(updateDictionaryAction({
+		kind,
+		id,
+		values: Object.fromEntries(fields.map(([field]) => [field, Reflect.get(entity, field)]))
+	}));
+}
+var addDictionary = (undoActions, { payload }, state) => {
+	const { kind, id } = payload;
+	if (!hasDictionaryKind(kind)) return;
+	if (isListed(dictionaryIds(state, kind), id)) {
+		pushPreviousValues(undoActions, payload, state);
+		return;
+	}
+	undoActions.push(removeDictionaryAction({
+		kind,
+		id
+	}));
+};
+var removeDictionary = (undoActions, { payload: { kind, id } }, state) => {
+	if (!hasDictionaryKind(kind)) return;
+	if (!isListed(dictionaryIds(state, kind), id)) return;
+	undoActions.push(addDictionaryAction({
+		kind,
+		id
+	}));
+};
+var updateDictionary = (undoActions, { payload }, state) => {
+	if (!hasDictionaryKind(payload.kind)) return;
+	pushPreviousValues(undoActions, payload, state);
+};
+var isListing = ({ type }) => type === ActionType.addDictionary || type === ActionType.removeDictionary;
+function reverseDictionaryListings(undoActions) {
+	const slots = undoActions.flatMap((action, index) => isListing(action) ? [index] : []);
+	for (let low = 0, high = slots.length - 1; low < high; low++, high--) {
+		const action = undoActions[slots[low]];
+		undoActions[slots[low]] = undoActions[slots[high]];
+		undoActions[slots[high]] = action;
+	}
+}
+var dictionaryPushUndoHistoryMap = {
+	[ActionType.addDictionary]: addDictionary,
+	[ActionType.updateDictionary]: updateDictionary,
+	[ActionType.removeDictionary]: removeDictionary
+};
+//#endregion
+export { dictionaryPushUndoHistoryMap, reverseDictionaryListings };

package/dist/engine/modules/dictionary/membership.d.ts

@@ -0,0 +1,28 @@
+import { RootState } from '../../state';
+/** Whether a dictionary's id list holds the id, without walking the list. */
+export declare const isListed: (list: string[], id: string) => boolean;
+/** Puts the id at the end of the list unless it holds it; true when it did. */
+export declare function listId(list: string[], id: string): boolean;
+/**
+ * Takes the id out of the list if it holds it; true when it did. It looks from
+ * the end, where a removal and an undo send their rows, since every element a
+ * splice moves in a state list goes through its proxy.
+ */
+export declare function unlistId(list: string[], id: string): boolean;
+/**
+ * The id while it names a domain the document lists, else '': what a paste
+ * links, since a copy from another document can name one this one lacks.
+ */
+export declare const toLiveDomainId: (state: RootState, domainId?: string) => string;
+/**
+ * The domain a pasted column keeps: a live one whose data type the column holds,
+ * else ''. A copy can name a domain whose type changed since it was taken, and a
+ * link off its domain's type would break the rule that a domain governs its type.
+ */
+export declare function toPastedDomainId(state: RootState, domainId: string | undefined, dataType: string): string;
+/**
+ * The name of the domain an id links, or '' while it links none in the
+ * document: a removed domain's name is kept for its undo and shown nowhere.
+ */
+export declare function getLiveDomainName(state: RootState, domainId: string): string;
+//# sourceMappingURL=membership.d.ts.map

package/dist/engine/modules/dictionary/membership.js

@@ -0,0 +1,42 @@
+//#region src/engine/modules/dictionary/membership.ts
+var listings = /* @__PURE__ */ new WeakMap();
+function listingOf(list) {
+	const held = listings.get(list);
+	if (held && held.length === list.length) return held;
+	const listing = {
+		ids: new Set(list),
+		length: list.length
+	};
+	listings.set(list, listing);
+	return listing;
+}
+var isListed = (list, id) => listingOf(list).ids.has(id);
+function listId(list, id) {
+	const listing = listingOf(list);
+	if (listing.ids.has(id)) return false;
+	list.push(id);
+	listing.ids.add(id);
+	listing.length = list.length;
+	return true;
+}
+function unlistId(list, id) {
+	const listing = listingOf(list);
+	if (!listing.ids.has(id)) return false;
+	const index = list.lastIndexOf(id);
+	if (index !== -1) list.splice(index, 1);
+	listing.ids.delete(id);
+	listing.length = list.length;
+	return true;
+}
+var toLiveDomainId = (state, domainId) => domainId && isListed(state.doc.domainIds, domainId) ? domainId : "";
+function toPastedDomainId(state, domainId, dataType) {
+	const id = toLiveDomainId(state, domainId);
+	const domainType = state.collections.domainEntities[id]?.dataType ?? "";
+	return id && domainType === dataType ? id : "";
+}
+function getLiveDomainName(state, domainId) {
+	if (!domainId || !isListed(state.doc.domainIds, domainId)) return "";
+	return state.collections.domainEntities[domainId]?.name ?? "";
+}
+//#endregion
+export { getLiveDomainName, isListed, listId, toLiveDomainId, toPastedDomainId, unlistId };

package/dist/engine/modules/dictionary/orderKeys.d.ts

@@ -0,0 +1,13 @@
+import { Ordered } from '@dineug/erd-editor-schema';
+/** The keys of the rows a placement adds, and the listed rows it keys again. */
+export type OrderPlacement = {
+    keys: string[];
+    rekeyed: Ordered[];
+};
+/**
+ * Keys for count new rows placed at index at of a sheet's rows in key order,
+ * rows.length for its end. Where no key fits between the neighbours, the rows
+ * around the place are keyed again with them, so the sheet reads as asked.
+ */
+export declare function placeOrderKeys(rows: ReadonlyArray<Ordered>, at: number, count: number): OrderPlacement;
+//# sourceMappingURL=orderKeys.d.ts.map

package/dist/engine/modules/dictionary/orderKeys.js

@@ -0,0 +1,28 @@
+import { generateOrderKeys, isOrderKey } from "../../../erd-editor-schema/dist/orderKey.js";
+//#region src/engine/modules/dictionary/orderKeys.ts
+function placeOrderKeys(rows, at, count) {
+	let start = at;
+	while (start > 0 && !isOrderKey(rows[start - 1].order)) start--;
+	const low = start > 0 ? rows[start - 1].order : null;
+	let end = at;
+	while (low !== null && end < rows.length && isOrderKey(rows[end].order) && rows[end].order <= low) end++;
+	const high = end < rows.length && isOrderKey(rows[end].order) ? rows[end].order : null;
+	const before = rows.slice(start, at);
+	const after = rows.slice(at, end);
+	const keys = generateOrderKeys(low, high, before.length + count + after.length);
+	const rekeyed = [];
+	const rekey = (row, order) => {
+		if (row.order !== order) rekeyed.push({
+			id: row.id,
+			order
+		});
+	};
+	before.forEach((row, index) => rekey(row, keys[index]));
+	after.forEach((row, index) => rekey(row, keys[before.length + count + index]));
+	return {
+		keys: keys.slice(before.length, before.length + count),
+		rekeyed
+	};
+}
+//#endregion
+export { placeOrderKeys };

package/dist/engine/modules/dictionary/termIndex.d.ts

@@ -0,0 +1,24 @@
+import { Term } from '../../../internal-types';
+/** The most terms a logical name cell offers while it is typed. */
+export declare const TERM_COMPLETION_LIMIT = 8;
+/**
+ * The listed terms sorted by their keys in code unit order, one per name, the
+ * first listed answering for it; keys and terms share each position.
+ */
+export type TermIndex = {
+    keys: ReadonlyArray<string>;
+    terms: ReadonlyArray<Term>;
+};
+/** A term name or a typed prefix as completion compares it: composed and in lower case. */
+export declare const toTermKey: (text: string) => string;
+/** Sorts the named terms by key, a name in two cases ordered by the name itself. */
+export declare function buildTermIndex(terms: ReadonlyArray<Term>): TermIndex;
+/** The term sheet's completion index, built once per generation of the sheet. */
+export declare const getTermIndex: (state: import('../../state').RootState) => TermIndex;
+/**
+ * The terms whose names start with what is typed, at most the limit, in key
+ * order. A lower bound search finds the first key, so a query reads at most
+ * one key per halving, then one per term it gives and one that ends the run.
+ */
+export declare function completeTerms(index: TermIndex, typed: string, limit?: number): Term[];
+//# sourceMappingURL=termIndex.d.ts.map

package/dist/engine/modules/dictionary/termIndex.js

@@ -0,0 +1,42 @@
+import { DictionaryKind } from "./actions.js";
+import { dictionaryCache, normalizeDictionaryName } from "./dictionaryIndex.js";
+var toTermKey = (text) => text.normalize("NFC").toLowerCase();
+var byCodeUnit = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+function buildTermIndex(terms) {
+	const named = /* @__PURE__ */ new Map();
+	for (const term of terms) {
+		const name = normalizeDictionaryName(term.name);
+		if (name && !named.has(name)) named.set(name, term);
+	}
+	const entries = [...named].map(([name, term]) => ({
+		key: toTermKey(name),
+		name,
+		term
+	}));
+	entries.sort((a, b) => byCodeUnit(a.key, b.key) || byCodeUnit(a.name, b.name));
+	return {
+		keys: entries.map(({ key }) => key),
+		terms: entries.map(({ term }) => term)
+	};
+}
+var getTermIndex = dictionaryCache(DictionaryKind.term, buildTermIndex);
+function completeTerms(index, typed, limit = 8) {
+	const prefix = toTermKey(typed.trimStart());
+	if (!prefix || limit <= 0) return [];
+	const { keys, terms } = index;
+	let low = 0;
+	let high = keys.length;
+	while (low < high) {
+		const middle = low + high >>> 1;
+		if (keys[middle] < prefix) low = middle + 1;
+		else high = middle;
+	}
+	const found = [];
+	for (let position = low; position < keys.length && found.length < limit; position++) {
+		if (!keys[position].startsWith(prefix)) break;
+		found.push(terms[position]);
+	}
+	return found;
+}
+//#endregion
+export { buildTermIndex, completeTerms, getTermIndex, toTermKey };

package/dist/engine/modules/editor/actions.d.ts

@@ -1,9 +1,10 @@
 import { Reducer } from '@dineug/r-html';
 import { EngineContext } from '../../context';
+import { DictionaryKind } from '../dictionary/actions';
 import { RootState } from '../../state';
 import { LWW, Point, ValuesType } from '../../../internal-types';
 import { Rect } from '../../../utils/dragSelect';
-import { FocusType, MoveKey, SelectType, SharedFocus, ShowMode, ViewKind, VisualizationMode } from './state';
+import { CenterStep, FocusType, MoveKey, ScreenUnit, SelectType, SharedFocus, ShowMode, ViewKind, VisualizationMode } from './state';
 export declare const ActionType: {
     readonly changeHasHistory: "editor.changeHasHistory";
     readonly selectAll: "editor.selectAll";
@@ -55,13 +56,24 @@ export declare const ActionType: {
     readonly viewSetLayout: "editor.viewSetLayout";
     readonly viewChangeShowMode: "editor.viewChangeShowMode";
     readonly viewSetCenters: "editor.viewSetCenters";
+    readonly viewStepCenters: "editor.viewStepCenters";
     readonly changeVisualizationMode: "editor.changeVisualizationMode";
+    readonly endScreenSettings: "editor.endScreenSettings";
 };
 export type ActionType = ValuesType<typeof ActionType>;
+/**
+ * Set on the clear and the load of a schema import, and of their undo, which
+ * leave the store's words, terms and domains and their lists as they are.
+ */
+export type DictionaryLoadFlag = {
+    keepDictionaries?: boolean;
+};
 export type ActionMap = {
     [ActionType.changeHasHistory]: {
         hasUndo: boolean;
         hasRedo: boolean;
+        /** The dictionary sheet whose history this is, none for the document's. */
+        sheet?: DictionaryKind;
     };
     [ActionType.selectAll]: void;
     [ActionType.unselectAll]: void;
@@ -70,8 +82,8 @@ export type ActionMap = {
         width: number;
         height: number;
     };
-    [ActionType.clear]: void;
-    [ActionType.loadJson]: {
+    [ActionType.clear]: DictionaryLoadFlag | void;
+    [ActionType.loadJson]: DictionaryLoadFlag & {
         value: string;
     };
     [ActionType.initialClear]: void;
@@ -206,9 +218,16 @@ export type ActionMap = {
         tableIds: string[];
         kind?: ViewKind;
     };
+    [ActionType.viewStepCenters]: {
+        step: CenterStep;
+        kind?: ViewKind;
+    };
     [ActionType.changeVisualizationMode]: {
         value: VisualizationMode;
     };
+    [ActionType.endScreenSettings]: {
+        units: ScreenUnit[];
+    };
 };
 export type ReducerType<T extends keyof ActionMap> = Reducer<RootState, T, ActionMap, EngineContext>;
 //# sourceMappingURL=actions.d.ts.map