@dineug/erd-editor 4.2.0 → 5.0.0

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

@@ -0,0 +1,88 @@
+import { ColumnOption } from "../../../constants/schema.js";
+import { changeColumnNameAction, changeColumnNameDerivedAction } from "../table-column/atom.actions.js";
+import { normalizeDictionaryName } from "./dictionaryIndex.js";
+import { bHas } from "../../../utils/bit.js";
+import { changeTableNameAction, changeTableNameDerivedAction } from "../table/atom.actions.js";
+import { toNameKey } from "../relationship/fkColumns.js";
+import { derivePhysical } from "./derive.js";
+//#region src/engine/modules/dictionary/derivedNames.ts
+function toNameWrites(state, name, derived, logicalName, force) {
+	const hasLogicalName = normalizeDictionaryName(logicalName) !== "";
+	if (force ? !hasLogicalName : name.trim() !== "" && !derived) return null;
+	const physical = derivePhysical(state, logicalName);
+	const physicalName = physical?.physicalName || null;
+	return {
+		name: physicalName !== null && physicalName !== name ? physicalName : null,
+		flag: !derived && (force || physicalName !== null),
+		domainId: physical?.domainId ?? ""
+	};
+}
+function namesOfTable(state, ledger, tableId) {
+	let names = ledger.get(tableId);
+	if (!names) {
+		const { tableEntities, tableColumnEntities } = state.collections;
+		names = /* @__PURE__ */ new Map();
+		for (const id of tableEntities[tableId]?.columnIds ?? []) {
+			const column = tableColumnEntities[id];
+			if (column) names.set(id, toNameKey(column.name));
+		}
+		ledger.set(tableId, names);
+	}
+	return names;
+}
+function isNameTaken(names, columnId, key) {
+	for (const [id, held] of names) if (id !== columnId && held === key) return true;
+	return false;
+}
+function toColumnNameWrites(state, tableId, column, logicalName, force = false, ledger = /* @__PURE__ */ new Map()) {
+	const writes = toNameWrites(state, column.name, bHas(column.options, ColumnOption.nameDerived), logicalName, force);
+	if (!writes) return {
+		actions: [],
+		link: null
+	};
+	if (writes.name !== null) {
+		const names = namesOfTable(state, ledger, tableId);
+		const key = toNameKey(writes.name);
+		if (isNameTaken(names, column.id, key)) return {
+			actions: [],
+			link: null
+		};
+		names.set(column.id, key);
+	}
+	const target = {
+		tableId,
+		id: column.id
+	};
+	const actions = [];
+	if (writes.name !== null) actions.push(changeColumnNameAction({
+		...target,
+		value: writes.name
+	}));
+	if (writes.flag) actions.push(changeColumnNameDerivedAction({
+		...target,
+		value: true
+	}));
+	return {
+		actions,
+		link: writes.domainId ? {
+			...target,
+			value: writes.domainId
+		} : null
+	};
+}
+function toTableNameWrites(state, table, logicalName, force = false) {
+	const writes = toNameWrites(state, table.name, table.nameDerived, logicalName, force);
+	if (!writes) return [];
+	const actions = [];
+	if (writes.name !== null) actions.push(changeTableNameAction({
+		id: table.id,
+		value: writes.name
+	}));
+	if (writes.flag) actions.push(changeTableNameDerivedAction({
+		id: table.id,
+		value: true
+	}));
+	return actions;
+}
+//#endregion
+export { toColumnNameWrites, toTableNameWrites };

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

@@ -0,0 +1,112 @@
+import { compareByOrder } from "../../../erd-editor-schema/dist/orderKey.js";
+import { DictionaryKind } from "./actions.js";
+//#region src/engine/modules/dictionary/dictionaryIndex.ts
+var COLLECTION_KEY = {
+	[DictionaryKind.word]: "wordEntities",
+	[DictionaryKind.term]: "termEntities",
+	[DictionaryKind.domain]: "domainEntities"
+};
+var IDS_KEY = {
+	[DictionaryKind.word]: "wordIds",
+	[DictionaryKind.term]: "termIds",
+	[DictionaryKind.domain]: "domainIds"
+};
+var normalizeDictionaryName = (name) => name.trim().normalize("NFC");
+var splitDictionaryList = (text) => text.split(",").map(normalizeDictionaryName).filter((name) => name !== "");
+var generations = /* @__PURE__ */ new WeakMap();
+function raiseDictionaryGeneration(state, kind) {
+	const collection = state.collections[COLLECTION_KEY[kind]];
+	generations.set(collection, (generations.get(collection) ?? 0) + 1);
+}
+function heldPerSheet(kind, build) {
+	const held = /* @__PURE__ */ new WeakMap();
+	return (state) => {
+		const collection = state.collections[COLLECTION_KEY[kind]];
+		const ids = state.doc[IDS_KEY[kind]];
+		const generation = generations.get(collection) ?? 0;
+		const entry = held.get(collection);
+		if (entry && entry.generation === generation && entry.ids === ids && entry.length === ids.length) return entry.value;
+		const value = build(state, collection, ids);
+		held.set(collection, {
+			generation,
+			ids,
+			length: ids.length,
+			value
+		});
+		return value;
+	};
+}
+function sortRows(_state, collection, ids) {
+	const rows = [];
+	for (const id of ids) {
+		const row = collection[id];
+		if (row) rows.push(row);
+	}
+	return rows.sort(compareByOrder);
+}
+var SHEET_ROWS = {
+	[DictionaryKind.word]: heldPerSheet(DictionaryKind.word, sortRows),
+	[DictionaryKind.term]: heldPerSheet(DictionaryKind.term, sortRows),
+	[DictionaryKind.domain]: heldPerSheet(DictionaryKind.domain, sortRows)
+};
+var orderedDictionaryRows = (state, kind) => SHEET_ROWS[kind](state);
+function dictionaryCache(kind, build) {
+	return heldPerSheet(kind, (state) => build(orderedDictionaryRows(state, kind)));
+}
+var createNode = () => ({ next: /* @__PURE__ */ new Map() });
+function marksAt(root, text) {
+	let node = root;
+	for (let index = 0; index < text.length; index++) {
+		const code = text.charCodeAt(index);
+		let next = node.next.get(code);
+		if (!next) {
+			next = createNode();
+			node.next.set(code, next);
+		}
+		node = next;
+	}
+	node.marks ??= {
+		words: [],
+		synonymOf: [],
+		forbiddenOf: []
+	};
+	return node.marks;
+}
+function pushOnce(list, value) {
+	if (!list.includes(value)) list.push(value);
+}
+function groupByName(rows, each) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const name = normalizeDictionaryName(row.name);
+		if (!name) continue;
+		const named = byName.get(name);
+		if (named) named.push(row);
+		else byName.set(name, [row]);
+		each?.(row, name);
+	}
+	return byName;
+}
+var buildNameIndex = (rows) => ({
+	rows,
+	byName: groupByName(rows)
+});
+function buildWordIndex(words) {
+	const root = createNode();
+	return {
+		rows: words,
+		byName: groupByName(words, (word, name) => {
+			marksAt(root, name).words.push(word);
+			for (const synonym of splitDictionaryList(word.synonyms)) if (synonym !== name) pushOnce(marksAt(root, synonym).synonymOf, word);
+			for (const forbidden of splitDictionaryList(word.forbiddenWords)) if (forbidden !== name) pushOnce(marksAt(root, forbidden).forbiddenOf, word);
+		}),
+		root
+	};
+}
+var getWordIndex = dictionaryCache(DictionaryKind.word, buildWordIndex);
+var getTermNames = dictionaryCache(DictionaryKind.term, buildNameIndex);
+var getDomainNames = dictionaryCache(DictionaryKind.domain, buildNameIndex);
+var findTerm = (state, name) => getTermNames(state).byName.get(normalizeDictionaryName(name))?.[0];
+var findDomain = (state, name) => getDomainNames(state).byName.get(normalizeDictionaryName(name))?.[0];
+//#endregion
+export { buildNameIndex, buildWordIndex, dictionaryCache, findDomain, findTerm, getDomainNames, getTermNames, getWordIndex, normalizeDictionaryName, orderedDictionaryRows, raiseDictionaryGeneration, splitDictionaryList };

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

@@ -0,0 +1,26 @@
+//#region src/engine/modules/dictionary/domainLinks.ts
+var linksOf = /* @__PURE__ */ new WeakMap();
+var NONE = /* @__PURE__ */ new Set();
+function domainLinks(state) {
+	const columns = state.collections.tableColumnEntities;
+	const held = linksOf.get(columns);
+	if (held) return held;
+	const links = /* @__PURE__ */ new Map();
+	for (const [id, { domainId }] of Object.entries(columns)) if (domainId) addLink(links, domainId, id);
+	linksOf.set(columns, links);
+	return links;
+}
+function addLink(links, domainId, columnId) {
+	const linking = links.get(domainId);
+	if (linking) linking.add(columnId);
+	else links.set(domainId, /* @__PURE__ */ new Set([columnId]));
+}
+var domainColumnIds = (state, domainId) => domainLinks(state).get(domainId) ?? NONE;
+function relinkDomainColumn(state, columnId, from, to) {
+	const links = linksOf.get(state.collections.tableColumnEntities);
+	if (!links || from === to) return;
+	links.get(from)?.delete(columnId);
+	if (to) addLink(links, to, columnId);
+}
+//#endregion
+export { domainColumnIds, relinkDomainColumn };

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

@@ -0,0 +1,72 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { isListed } from "./membership.js";
+import { changeColumnDataTypeAction, changeColumnDomainAction } from "../table-column/atom.actions.js";
+import { getDataTypeSyncColumns } from "../table-column/utils/dataType.js";
+//#region src/engine/modules/dictionary/domainTypes.ts
+var NO_DOMAIN_TYPES = /* @__PURE__ */ new Map();
+function domainTypeIn(state, domainTypes) {
+	const { domainEntities } = state.collections;
+	return (id) => domainTypes.get(id) ?? domainEntities[id]?.dataType ?? "";
+}
+function readDomains(state, domainTypes, links) {
+	const { collections, doc } = state;
+	const columns = query(collections).collection("tableColumnEntities");
+	const linkOf = new Map(links.map(({ id, value }) => [id, value]));
+	return {
+		columns,
+		isLiveDomain: (id) => id !== "" && isListed(doc.domainIds, id),
+		domainTypeOf: domainTypeIn(state, domainTypes),
+		domainIdOf: (id) => linkOf.get(id) ?? columns.selectById(id)?.domainId ?? ""
+	};
+}
+function toDomainUnlinkActions(state, written, { domainTypes = NO_DOMAIN_TYPES, links = [] } = {}) {
+	const { domainTypeOf, domainIdOf } = readDomains(state, domainTypes, links);
+	return written.filter(({ id, value }) => {
+		const domainId = domainIdOf(id);
+		return domainId !== "" && domainTypeOf(domainId) !== value;
+	}).map(({ tableId, id }) => changeColumnDomainAction({
+		tableId,
+		id,
+		value: ""
+	}));
+}
+function toDomainTypeActions(state, { domainTypes = NO_DOMAIN_TYPES, links = [], dataTypes = [] }) {
+	const { collections, doc, settings } = state;
+	const sentLinks = links.filter(({ value }) => value === "" || isListed(doc.domainIds, value));
+	const { columns, isLiveDomain, domainTypeOf, domainIdOf } = readDomains(state, domainTypes, sentLinks);
+	const settled = /* @__PURE__ */ new Map();
+	for (const payload of dataTypes) settled.set(payload.id, payload);
+	for (const { tableId, id, value } of sentLinks) if (value !== "") settled.set(id, {
+		tableId,
+		id,
+		value: domainTypeOf(value)
+	});
+	const changed = new Set([...domainTypes.keys()].filter(isLiveDomain));
+	if (changed.size) {
+		const tables = query(collections).collection("tableEntities").selectByIds(doc.tableIds);
+		for (const table of tables) for (const id of table.columnIds) {
+			const domainId = domainIdOf(id);
+			if (!settled.has(id) && changed.has(domainId)) settled.set(id, {
+				tableId: table.id,
+				id,
+				value: domainTypeOf(domainId)
+			});
+		}
+	}
+	const seeds = [...settled.values()];
+	const payloads = settings.relationshipDataTypeSync ? getDataTypeSyncColumns([...seeds], state, [], void 0, new Set(settled.keys())) : seeds;
+	const direct = new Set(dataTypes.map(({ id }) => id));
+	const written = payloads.filter(({ id, value }) => direct.has(id) || columns.selectById(id)?.dataType !== value);
+	const linkActions = sentLinks.filter(({ id, value }) => columns.selectById(id)?.domainId !== value).map(changeColumnDomainAction);
+	const unlinkActions = toDomainUnlinkActions(state, written, {
+		domainTypes,
+		links: sentLinks
+	});
+	return [
+		...linkActions,
+		...written.map(changeColumnDataTypeAction),
+		...unlinkActions
+	];
+}
+//#endregion
+export { domainTypeIn, toDomainTypeActions, toDomainUnlinkActions };

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

@@ -0,0 +1,197 @@
+import { uuid25 } from "../../../uuid/dist/uuid25.js";
+import { DictionaryKind } from "./actions.js";
+import { isListed } from "./membership.js";
+import { toDomainTypeActions } from "./domainTypes.js";
+import { findDomain, getDomainNames, getTermNames, getWordIndex, normalizeDictionaryName, orderedDictionaryRows } from "./dictionaryIndex.js";
+import { addDictionaryAction, dictionaryEntries, dictionaryIds, selectDictionaryRow, updateDictionaryAction } from "./atom.actions.js";
+import { composeName } from "./derive.js";
+import { placeOrderKeys } from "./orderKeys.js";
+import { isString } from "es-toolkit";
+//#region src/engine/modules/dictionary/entryWrites.ts
+var DictionaryRefusalCode = {
+	duplicateName: "duplicateName",
+	unknownDomain: "unknownDomain"
+};
+var NAMES = {
+	[DictionaryKind.word]: getWordIndex,
+	[DictionaryKind.term]: getTermNames,
+	[DictionaryKind.domain]: getDomainNames
+};
+var valuesOf = (kind, values) => Object.fromEntries(dictionaryEntries(kind, values));
+var isNameWritten = ({ existing, values }) => isString(values.name) && (!existing || existing.name !== values.name);
+var nameOf = ({ existing, values }) => normalizeDictionaryName(values.name ?? existing?.name ?? "");
+function resolveChanges(state, kind, changes) {
+	const ids = dictionaryIds(state, kind);
+	const rows = [];
+	changes.forEach(({ id, values }, index) => {
+		if (id === void 0) {
+			rows.push({
+				index,
+				existing: null,
+				values: valuesOf(kind, values)
+			});
+			return;
+		}
+		if (!isListed(ids, id)) return;
+		const existing = selectDictionaryRow(state, kind, id);
+		if (existing) rows.push({
+			index,
+			existing,
+			values: valuesOf(kind, values)
+		});
+	});
+	return rows;
+}
+function commitNamesOf(rows) {
+	const renamed = /* @__PURE__ */ new Set();
+	const counts = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		if (!isNameWritten(row)) continue;
+		if (row.existing) renamed.add(row.existing.id);
+		const name = nameOf(row);
+		if (name) counts.set(name, (counts.get(name) ?? 0) + 1);
+	}
+	return {
+		renamed,
+		counts
+	};
+}
+function refusalsOf(state, kind, row, names) {
+	const refusals = [];
+	const name = nameOf(row);
+	const refuse = (code, value) => refusals.push({
+		code,
+		index: row.index,
+		name,
+		value
+	});
+	if (name && isNameWritten(row)) {
+		if ((NAMES[kind](state).byName.get(name) ?? []).filter(({ id }) => id !== row.existing?.id && !names.renamed.has(id)).length || (names.counts.get(name) ?? 0) > 1) refuse(DictionaryRefusalCode.duplicateName, name);
+	}
+	const domainId = row.values.domainId;
+	if (kind === DictionaryKind.term && domainId && domainId !== Reflect.get(row.existing ?? {}, "domainId") && !isListed(state.doc.domainIds, domainId)) refuse(DictionaryRefusalCode.unknownDomain, domainId);
+	return refusals;
+}
+function toEntryWrites(state, kind, row, names) {
+	const values = { ...row.values };
+	const { existing } = row;
+	if (kind === DictionaryKind.term && isString(values.name)) {
+		const composed = (values.physicalName ?? Reflect.get(existing ?? {}, "physicalName") ?? "").trim() ? null : composeName(state, values.name);
+		if (composed) values.physicalName = composed;
+	}
+	const refusals = names ? refusalsOf(state, kind, {
+		...row,
+		values
+	}, names) : [];
+	const changed = Object.fromEntries(Object.entries(values).filter(([field, value]) => existing ? Reflect.get(existing, field) !== value : value !== ""));
+	const hasChanges = Object.keys(changed).length > 0;
+	if (!existing) return {
+		action: addDictionaryAction({
+			kind,
+			id: uuid25(),
+			...hasChanges ? { values: changed } : {}
+		}),
+		refusals,
+		domainType: null
+	};
+	return {
+		action: hasChanges ? updateDictionaryAction({
+			kind,
+			id: existing.id,
+			values: changed
+		}) : null,
+		refusals,
+		domainType: kind === DictionaryKind.domain && isString(changed.dataType) ? {
+			id: existing.id,
+			dataType: changed.dataType
+		} : null
+	};
+}
+function placeNewRows(state, kind, rows) {
+	const unplaced = rows.filter(({ existing, values }) => !existing && !values.order);
+	if (!unplaced.length) return [];
+	const sheet = orderedDictionaryRows(state, kind);
+	const { keys, rekeyed } = placeOrderKeys(sheet, sheet.length, unplaced.length);
+	unplaced.forEach(({ values }, index) => {
+		values.order = keys[index];
+	});
+	return rekeyed;
+}
+var rekeyActions = (kind, rekeyed) => rekeyed.map(({ id, order }) => updateDictionaryAction({
+	kind,
+	id,
+	values: { order }
+}));
+function toWriteActions(state, writes) {
+	const domainTypes = /* @__PURE__ */ new Map();
+	const actions = [];
+	for (const { action, domainType } of writes) {
+		if (action) actions.push(action);
+		if (domainType) domainTypes.set(domainType.id, domainType.dataType);
+	}
+	if (domainTypes.size) actions.push(...toDomainTypeActions(state, { domainTypes }));
+	return actions;
+}
+function validateDictionaryValues(state, kind, changes) {
+	const rows = resolveChanges(state, kind, changes);
+	const names = commitNamesOf(rows);
+	return rows.flatMap((row) => refusalsOf(state, kind, row, names));
+}
+function toDictionaryCommit(state, kind, changes) {
+	const rows = resolveChanges(state, kind, changes);
+	const rekeyed = placeNewRows(state, kind, rows);
+	const names = commitNamesOf(rows);
+	const writes = rows.map((row) => toEntryWrites(state, kind, row, names));
+	const refusals = writes.flatMap(({ refusals }) => refusals);
+	return {
+		actions: refusals.length ? [] : [...rekeyActions(kind, rekeyed), ...toWriteActions(state, writes)],
+		refusals
+	};
+}
+function toDictionaryImport(state, kind, rows) {
+	const folded = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const name = normalizeDictionaryName(row.name);
+		if (name) folded.set(name, row);
+	}
+	const names = NAMES[kind](state);
+	const unknownDomains = /* @__PURE__ */ new Map();
+	const entries = [];
+	for (const [name, row] of folded) {
+		const values = valuesOf(kind, row);
+		const domain = Reflect.get(row, "domain");
+		if (kind === DictionaryKind.term && isString(domain)) {
+			const key = normalizeDictionaryName(domain);
+			const found = key ? findDomain(state, key) : void 0;
+			values.domainId = found?.id ?? "";
+			if (key && !found && !unknownDomains.has(key)) unknownDomains.set(key, domain.trim());
+		}
+		const existing = names.byName.get(name)?.[0] ?? null;
+		entries.push({
+			index: 0,
+			existing,
+			values
+		});
+	}
+	const rekeyed = placeNewRows(state, kind, entries);
+	const writes = [];
+	let added = 0;
+	let updated = 0;
+	for (const entry of entries) {
+		const write = toEntryWrites(state, kind, entry);
+		if (write.action) {
+			writes.push(write);
+			if (entry.existing) updated++;
+			else added++;
+		}
+	}
+	return {
+		actions: [...rekeyActions(kind, rekeyed), ...toWriteActions(state, writes)],
+		added,
+		updated,
+		folded: rows.length - folded.size,
+		unknownDomains: [...unknownDomains.values()]
+	};
+}
+//#endregion
+export { DictionaryRefusalCode, toDictionaryCommit, toDictionaryImport, validateDictionaryValues };