@dineug/erd-editor 4.2.0 → 5.0.0

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.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.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.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.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

@@ -4,7 +4,7 @@ import { DictionaryKind } from '../dictionary/actions';
 import { RootState } from '../../state';
 import { LWW, Point, ValuesType } from '../../../internal-types';
 import { Rect } from '../../../utils/dragSelect';
-import { CenterStep, 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";
@@ -58,6 +58,7 @@ export declare const ActionType: {
     readonly viewSetCenters: "editor.viewSetCenters";
     readonly viewStepCenters: "editor.viewStepCenters";
     readonly changeVisualizationMode: "editor.changeVisualizationMode";
+    readonly endScreenSettings: "editor.endScreenSettings";
 };
 export type ActionType = ValuesType<typeof ActionType>;
 /**
@@ -224,6 +225,9 @@ export type ActionMap = {
     [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

package/dist/engine/modules/editor/actions.js

@@ -0,0 +1,58 @@
+//#region src/engine/modules/editor/actions.ts
+var ActionType = {
+	changeHasHistory: "editor.changeHasHistory",
+	selectAll: "editor.selectAll",
+	unselectAll: "editor.unselectAll",
+	select: "editor.select",
+	changeViewport: "editor.changeViewport",
+	clear: "editor.clear",
+	loadJson: "editor.loadJson",
+	initialClear: "editor.initialClear",
+	initialLoadJson: "editor.initialLoadJson",
+	focusTable: "editor.focusTable",
+	focusColumn: "editor.focusColumn",
+	focusTableEnd: "editor.focusTableEnd",
+	focusMoveTable: "editor.focusMoveTable",
+	editTable: "editor.editTable",
+	editTableEnd: "editor.editTableEnd",
+	editMemo: "editor.editMemo",
+	editMemoEnd: "editor.editMemoEnd",
+	editTableGroup: "editor.editTableGroup",
+	editTableGroupEnd: "editor.editTableGroupEnd",
+	scrollMemo: "editor.scrollMemo",
+	selectAllColumn: "editor.selectAllColumn",
+	drawStartRelationship: "editor.drawStartRelationship",
+	drawStartAddRelationship: "editor.drawStartAddRelationship",
+	drawEndRelationship: "editor.drawEndRelationship",
+	drawRelationship: "editor.drawRelationship",
+	hoverColumnMap: "editor.hoverColumnMap",
+	hoverRelationshipMap: "editor.hoverRelationshipMap",
+	changeOpenMap: "editor.changeOpenMap",
+	changeHandTool: "editor.changeHandTool",
+	changeDrawTableGroup: "editor.changeDrawTableGroup",
+	changeZenMode: "editor.changeZenMode",
+	dragstartColumn: "editor.dragstartColumn",
+	dragendColumn: "editor.dragendColumn",
+	sharedMouseTracker: "editor.sharedMouseTracker",
+	sharedFocusTracker: "editor.sharedFocusTracker",
+	sharedSelectionTracker: "editor.sharedSelectionTracker",
+	sharedDragSelectTracker: "editor.sharedDragSelectTracker",
+	dragSelectRect: "editor.dragSelectRect",
+	getLWW: "editor.getLWW",
+	mergeLWW: "editor.mergeLWW",
+	viewOpen: "editor.viewOpen",
+	viewClose: "editor.viewClose",
+	viewScrollTo: "editor.viewScrollTo",
+	viewStreamScrollTo: "editor.viewStreamScrollTo",
+	viewChangeZoomLevel: "editor.viewChangeZoomLevel",
+	viewStreamZoomLevel: "editor.viewStreamZoomLevel",
+	viewMoveTable: "editor.viewMoveTable",
+	viewSetLayout: "editor.viewSetLayout",
+	viewChangeShowMode: "editor.viewChangeShowMode",
+	viewSetCenters: "editor.viewSetCenters",
+	viewStepCenters: "editor.viewStepCenters",
+	changeVisualizationMode: "editor.changeVisualizationMode",
+	endScreenSettings: "editor.endScreenSettings"
+};
+//#endregion
+export { ActionType };

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

@@ -330,6 +330,15 @@ export declare const mergeLWWAction: {
     toString(): string;
     type: string;
 };
+export declare const endScreenSettingsAction: {
+    (payload: {
+        units: import('./state').ScreenUnit[];
+    }): import('@dineug/r-html').AnyAction<{
+        units: import('./state').ScreenUnit[];
+    }>;
+    toString(): string;
+    type: string;
+};
 export declare const editorReducers: {
     "editor.viewOpen": ReducerType<"editor.viewOpen">;
     "editor.viewClose": ReducerType<"editor.viewClose">;
@@ -383,6 +392,7 @@ export declare const editorReducers: {
     "editor.dragSelectRect": ReducerType<"editor.dragSelectRect">;
     "editor.getLWW": ReducerType<"editor.getLWW">;
     "editor.mergeLWW": ReducerType<"editor.mergeLWW">;
+    "editor.endScreenSettings": ReducerType<"editor.endScreenSettings">;
 };
 export declare const actions: {
     viewOpenAction: {
@@ -847,5 +857,14 @@ export declare const actions: {
         toString(): string;
         type: string;
     };
+    endScreenSettingsAction: {
+        (payload: {
+            units: import('./state').ScreenUnit[];
+        }): import('@dineug/r-html').AnyAction<{
+            units: import('./state').ScreenUnit[];
+        }>;
+        toString(): string;
+        type: string;
+    };
 };
 //# sourceMappingURL=atom.actions.d.ts.map