@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/engine/index.js

@@ -1,56 +1,2 @@
-import { $ as e, In as t, c as n, fr as r, jc as i, kc as a, n as o, r as s, t as c, tc as l, u, v as d, y as f } from "../loadValue-B5ojYrZ-.js";
-import { Observable as p, Subject as m, debounceTime as h, map as g } from "rxjs";
-import { omit as _ } from "es-toolkit";
-//#region src/engine/replication-store.ts
-var v = l(f), y = { change: "change" };
-function b(l) {
-	let b = /* @__PURE__ */ new Set(), x = u({
-		...l,
-		routes: !1
-	}), { clock: S } = x, C = s(x, !1);
-	C.dispatchSync(r({
-		width: 0,
-		height: 0
-	}));
-	let w = o(C), T = new m(), E = new p((e) => C.subscribe((t) => e.next(t))).pipe(n(f), h(200)), D = /* @__PURE__ */ new Set(), O = null, k = (e) => (D.has(e) || D.add(e), () => {
-		D.delete(e);
-	}), A = (e, n) => {
-		D.forEach((r) => {
-			let i = Reflect.get(r, e);
-			t(i, n);
-		});
-	}, j = (t) => {
-		O = null, C.dispatchSync(e(c(t)));
-	}, M = (e) => {
-		T.next([e].flat());
-	};
-	return b.add(E.subscribe(() => {
-		let e = a(C.state), t = O !== null && e !== O;
-		O !== null && (O = e), A(y.change, {
-			value: e,
-			changed: t
-		});
-	})).add(T.pipe(n(d), g((e) => e.map((e) => _(e, ["tags"])))).subscribe((e) => {
-		e.some(({ type: e }) => v(e)) && (O ??= a(C.state));
-		let t = S.getNextVersion();
-		e.forEach((e) => e.version ??= t), C.dispatchSync(e), e.forEach((e) => S.merge(e.version));
-	})), Object.freeze({
-		get value() {
-			return a(C.state);
-		},
-		get runtimeValue() {
-			return i(C.state);
-		},
-		on: k,
-		setInitialValue: j,
-		dispatch: (e) => {
-			queueMicrotask(() => M(e));
-		},
-		dispatchSync: M,
-		destroy: () => {
-			Array.from(b).forEach((e) => e.unsubscribe()), b.clear(), D.clear(), C.destroy(), w.destroy();
-		}
-	});
-}
-//#endregion
-export { b as createReplicationStore };
+import { createReplicationStore } from "./replication-store.js";
+export { createReplicationStore };

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

@@ -0,0 +1,42 @@
+//#region src/engine/modules/dictionary/actions.ts
+var ActionType = {
+	addDictionary: "dictionary.add",
+	updateDictionary: "dictionary.update",
+	removeDictionary: "dictionary.remove"
+};
+var DictionaryKind = {
+	word: "word",
+	term: "term",
+	domain: "domain"
+};
+var DictionaryKindList = Object.values(DictionaryKind);
+var DictionaryFields = {
+	[DictionaryKind.word]: [
+		"name",
+		"abbreviation",
+		"englishName",
+		"description",
+		"synonyms",
+		"forbiddenWords"
+	],
+	[DictionaryKind.term]: [
+		"name",
+		"physicalName",
+		"domainId",
+		"description",
+		"synonyms"
+	],
+	[DictionaryKind.domain]: [
+		"name",
+		"category",
+		"dataType",
+		"description"
+	]
+};
+var DictionaryStoredFields = {
+	[DictionaryKind.word]: [...DictionaryFields.word, "order"],
+	[DictionaryKind.term]: [...DictionaryFields.term, "order"],
+	[DictionaryKind.domain]: [...DictionaryFields.domain, "order"]
+};
+//#endregion
+export { ActionType, DictionaryFields, DictionaryKind, DictionaryKindList, DictionaryStoredFields };

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

@@ -0,0 +1,106 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { arrayHas } from "../../../utils/arrayHas.js";
+import { textInRange } from "../../../utils/validation.js";
+import { createAction } from "../../../r-html/dist/store/index.js";
+import { ActionType, DictionaryKind, DictionaryKindList, DictionaryStoredFields } from "./actions.js";
+import { domainColumnIds } from "./domainLinks.js";
+import { getLiveDomainName, listId, unlistId } from "./membership.js";
+import { createDomain } from "../../../utils/collection/domain.entity.js";
+import { createTerm } from "../../../utils/collection/term.entity.js";
+import { createWord } from "../../../utils/collection/word.entity.js";
+import { raiseDictionaryGeneration } from "./dictionaryIndex.js";
+import { isString } from "es-toolkit";
+//#region src/engine/modules/dictionary/atom.actions.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 CREATE = {
+	[DictionaryKind.word]: createWord,
+	[DictionaryKind.term]: createTerm,
+	[DictionaryKind.domain]: createDomain
+};
+var hasDictionaryKind = arrayHas(DictionaryKindList);
+var dictionaryCollection = (state, kind) => query(state.collections).collection(COLLECTION_KEY[kind]);
+var selectDictionaryRow = (state, kind, id) => dictionaryCollection(state, kind).selectById(id);
+var dictionaryIds = (state, kind) => state.doc[IDS_KEY[kind]];
+function dictionaryEntries(kind, values) {
+	if (!values || typeof values !== "object") return [];
+	const entries = [];
+	for (const field of DictionaryStoredFields[kind]) {
+		const value = Reflect.get(values, field);
+		if (isString(value)) entries.push([field, value]);
+	}
+	return entries;
+}
+function writeDictionaryValues(state, kind, id, values, version) {
+	const collection = dictionaryCollection(state, kind);
+	let renamed = false;
+	for (const [field, value] of dictionaryEntries(kind, values)) collection.replaceOperator(state.lww, version, id, field, () => {
+		collection.updateOne(id, (entity) => {
+			Reflect.set(entity, field, value);
+		});
+		if (field === "name") renamed = true;
+	});
+	return renamed && kind === DictionaryKind.domain;
+}
+function measureDomainColumns(state, domainId, { toWidth }) {
+	const width = textInRange(toWidth(getLiveDomainName(state, domainId)));
+	const columns = state.collections.tableColumnEntities;
+	if (!domainId) {
+		for (const column of Object.values(columns)) if (column.domainId === domainId) column.ui.widthDomain = width;
+		return;
+	}
+	for (const id of domainColumnIds(state, domainId)) columns[id].ui.widthDomain = width;
+}
+var addDictionaryAction = createAction(ActionType.addDictionary);
+var addDictionary = (state, { payload: { kind, id, values }, version }, ctx) => {
+	if (!hasDictionaryKind(kind)) return;
+	raiseDictionaryGeneration(state, kind);
+	const safeVersion = version ?? ctx.clock.getVersion();
+	const collection = dictionaryCollection(state, kind);
+	collection.getOrCreate(id, (id) => CREATE[kind]({ id }));
+	let listed = false;
+	collection.addOperator(state.lww, safeVersion, id, () => {
+		listed = listId(dictionaryIds(state, kind), id);
+	});
+	const renamed = writeDictionaryValues(state, kind, id, values, safeVersion);
+	if (kind === DictionaryKind.domain && (listed || renamed)) measureDomainColumns(state, id, ctx);
+};
+var updateDictionaryAction = createAction(ActionType.updateDictionary);
+var updateDictionary = (state, { payload: { kind, id, values }, version }, ctx) => {
+	if (!hasDictionaryKind(kind)) return;
+	raiseDictionaryGeneration(state, kind);
+	const safeVersion = version ?? ctx.clock.getVersion();
+	dictionaryCollection(state, kind).getOrCreate(id, (id) => CREATE[kind]({ id }));
+	if (writeDictionaryValues(state, kind, id, values, safeVersion)) measureDomainColumns(state, id, ctx);
+};
+var removeDictionaryAction = createAction(ActionType.removeDictionary);
+var removeDictionary = (state, { payload: { kind, id }, version }, ctx) => {
+	if (!hasDictionaryKind(kind)) return;
+	raiseDictionaryGeneration(state, kind);
+	const safeVersion = version ?? ctx.clock.getVersion();
+	let unlisted = false;
+	dictionaryCollection(state, kind).removeOperator(state.lww, safeVersion, id, () => {
+		unlisted = unlistId(dictionaryIds(state, kind), id);
+	});
+	if (kind === DictionaryKind.domain && unlisted) measureDomainColumns(state, id, ctx);
+};
+var dictionaryReducers = {
+	[ActionType.addDictionary]: addDictionary,
+	[ActionType.updateDictionary]: updateDictionary,
+	[ActionType.removeDictionary]: removeDictionary
+};
+var actions = {
+	addDictionaryAction,
+	updateDictionaryAction,
+	removeDictionaryAction
+};
+//#endregion
+export { actions, addDictionaryAction, dictionaryEntries, dictionaryIds, dictionaryReducers, hasDictionaryKind, measureDomainColumns, removeDictionaryAction, selectDictionaryRow, updateDictionaryAction };

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

@@ -0,0 +1,331 @@
+import { query } from "../../../erd-editor-schema/dist/query/index.js";
+import { DictionaryKind } from "./actions.js";
+import { isListed } from "./membership.js";
+import { getDomainNames, getTermNames, getWordIndex, normalizeDictionaryName } from "./dictionaryIndex.js";
+import { WordTokenKind, compose, decompose } from "./derive.js";
+//#region src/engine/modules/dictionary/checks.ts
+var DictionaryCheckCode = {
+	duplicateName: "duplicateName",
+	unknownDomain: "unknownDomain",
+	unregisteredWord: "unregisteredWord",
+	forbiddenWord: "forbiddenWord",
+	synonymWord: "synonymWord",
+	physicalNameMismatch: "physicalNameMismatch",
+	domainTypeMismatch: "domainTypeMismatch"
+};
+Object.values(DictionaryCheckCode);
+var DictionaryCheckLevel = {
+	error: "error",
+	warning: "warning"
+};
+var DictionaryCheckLevelOf = {
+	duplicateName: DictionaryCheckLevel.error,
+	unknownDomain: DictionaryCheckLevel.error,
+	unregisteredWord: DictionaryCheckLevel.warning,
+	forbiddenWord: DictionaryCheckLevel.error,
+	synonymWord: DictionaryCheckLevel.warning,
+	physicalNameMismatch: DictionaryCheckLevel.warning,
+	domainTypeMismatch: DictionaryCheckLevel.warning
+};
+var TOKEN_CODE = {
+	[WordTokenKind.synonym]: DictionaryCheckCode.synonymWord,
+	[WordTokenKind.forbidden]: DictionaryCheckCode.forbiddenWord,
+	[WordTokenKind.unregistered]: DictionaryCheckCode.unregisteredWord
+};
+var uniqueNames = (rows) => [...new Set(rows.map(({ name }) => normalizeDictionaryName(name)))];
+var NONE = Object.freeze([]);
+function wordFindings(index, name) {
+	if (index.byName.size === 0) return NONE;
+	const findings = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const token of decompose(index, name)) {
+		if (token.kind === WordTokenKind.word) continue;
+		const code = TOKEN_CODE[token.kind];
+		const key = `${code}:${token.text}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		findings.push({
+			code,
+			text: token.text,
+			suggestions: uniqueNames(token.words)
+		});
+	}
+	return findings.length ? findings : NONE;
+}
+function pushFindings(findings, field, push) {
+	for (const { code, text, suggestions } of findings) push({
+		code,
+		field,
+		text,
+		suggestions
+	});
+}
+var wordChecks = (state, field, name, push) => pushFindings(wordFindings(getWordIndex(state), name), field, push);
+function mismatchCheck(terms, words, logicalName, physicalName, push) {
+	const name = normalizeDictionaryName(logicalName);
+	const term = name ? terms.byName.get(name)?.[0] : void 0;
+	if (!term) return;
+	const derived = term.physicalName.trim() || (words.byName.size === 0 ? "" : compose(decompose(words, name)) ?? "");
+	if (!derived || physicalName.trim() === derived) return;
+	push({
+		code: DictionaryCheckCode.physicalNameMismatch,
+		field: "name",
+		text: physicalName,
+		suggestions: [derived]
+	});
+}
+function unknownDomainText(state, domainId, domainIds = state.doc.domainIds) {
+	if (!domainId || domainIds.length === 0 || isListed(domainIds, domainId)) return null;
+	return state.collections.domainEntities[domainId]?.name || domainId;
+}
+function domainCheck(state, domainId, push, domainIds = state.doc.domainIds) {
+	const text = unknownDomainText(state, domainId, domainIds);
+	if (text === null) return;
+	push({
+		code: DictionaryCheckCode.unknownDomain,
+		field: "domainId",
+		text,
+		suggestions: []
+	});
+}
+function linkedDomainType(state, domainId, domainIds = state.doc.domainIds) {
+	if (!domainId || !isListed(domainIds, domainId)) return null;
+	return state.collections.domainEntities[domainId]?.dataType ?? null;
+}
+function domainTypeCheck(state, { domainId, dataType }, push, domainIds = state.doc.domainIds) {
+	const domainType = linkedDomainType(state, domainId, domainIds);
+	if (domainType === null || domainType === dataType) return;
+	push({
+		code: DictionaryCheckCode.domainTypeMismatch,
+		field: "domainId",
+		text: dataType,
+		suggestions: [domainType]
+	});
+}
+var NAME_INDEX = {
+	[DictionaryKind.word]: getWordIndex,
+	[DictionaryKind.term]: getTermNames,
+	[DictionaryKind.domain]: getDomainNames
+};
+function sharesName(index, name, id) {
+	const named = name ? index.byName.get(name) : void 0;
+	return !!named && named.length > 1 && named.some((row) => row.id === id);
+}
+function duplicateCheck(index, row, push) {
+	const name = normalizeDictionaryName(row.name);
+	if (!sharesName(index, name, row.id)) return;
+	push({
+		code: DictionaryCheckCode.duplicateName,
+		field: "name",
+		text: name,
+		suggestions: []
+	});
+}
+function collect(target, field, run) {
+	const checks = [];
+	run((wanted) => !field || wanted === field, (check) => checks.push({
+		...check,
+		target
+	}));
+	return checks;
+}
+var checkTable = (state, table, field) => collect({
+	kind: "table",
+	id: table.id,
+	tableId: table.id
+}, field, (wants, push) => {
+	wants("logicalName") && wordChecks(state, "logicalName", table.logicalName, push);
+	wants("name") && mismatchCheck(getTermNames(state), getWordIndex(state), table.logicalName, table.name, push);
+});
+var checkColumn = (state, column, field) => collect({
+	kind: "column",
+	id: column.id,
+	tableId: column.tableId
+}, field, (wants, push) => {
+	wants("logicalName") && wordChecks(state, "logicalName", column.logicalName, push);
+	wants("name") && mismatchCheck(getTermNames(state), getWordIndex(state), column.logicalName, column.name, push);
+	if (!wants("domainId")) return;
+	domainCheck(state, column.domainId, push);
+	domainTypeCheck(state, column, push);
+});
+function checkDictionaryRow(state, kind, row, field) {
+	return collect({
+		kind,
+		id: row.id,
+		tableId: ""
+	}, field, (wants, push) => {
+		wants("name") && duplicateCheck(NAME_INDEX[kind](state), row, push);
+		if (kind !== DictionaryKind.term) return;
+		const term = row;
+		wants("name") && wordChecks(state, "name", term.name, push);
+		wants("domainId") && domainCheck(state, term.domainId, push);
+	});
+}
+function markOf(checks) {
+	let mark = null;
+	for (const { code } of checks) {
+		mark = DictionaryCheckLevelOf[code];
+		if (mark === DictionaryCheckLevel.error) break;
+	}
+	return mark;
+}
+var keptOf = /* @__PURE__ */ new WeakMap();
+function beginWalk(collection) {
+	let kept = keptOf.get(collection);
+	if (!kept) {
+		kept = {
+			held: /* @__PURE__ */ new Map(),
+			walk: 0,
+			met: 0
+		};
+		keptOf.set(collection, kept);
+	}
+	kept.walk++;
+	kept.met = 0;
+	return kept;
+}
+function endWalk(kept, walk) {
+	if (kept.walk !== walk || kept.held.size === kept.met) return;
+	for (const [id, held] of kept.held) if (held.walk !== walk) kept.held.delete(id);
+}
+var sameInputs = (a, b) => a.length === b.length && a.every((value, index) => value === b[index]);
+function readingOf(held, readings, words, text) {
+	const reading = held?.reading;
+	if (reading && reading.words === words && reading.text === text) return reading;
+	let read = readings.get(text);
+	if (!read) {
+		read = {
+			words,
+			text,
+			name: normalizeDictionaryName(text),
+			findings: wordFindings(words, text)
+		};
+		readings.set(text, read);
+	}
+	return read;
+}
+function heldChecks(kept, readings, target, words, text, inputsOf, run) {
+	let held = kept.held.get(target.id);
+	if (held?.walk !== kept.walk) kept.met++;
+	const reading = readingOf(held, readings, words, text);
+	const inputs = inputsOf(reading);
+	if (!held || held.reading !== reading || !sameInputs(held.inputs, inputs)) {
+		const checks = [];
+		run((check) => checks.push({
+			...check,
+			target
+		}), reading);
+		held = {
+			walk: kept.walk,
+			reading,
+			inputs,
+			checks: checks.length ? checks : NONE
+		};
+		kept.held.set(target.id, held);
+	}
+	held.walk = kept.walk;
+	return held.checks;
+}
+var termPhysicalName = (terms, name) => terms.byName.get(name)?.[0]?.physicalName ?? null;
+var sheetChecksOf = /* @__PURE__ */ new WeakMap();
+function sheetChecks(kind, index) {
+	let checks = sheetChecksOf.get(index);
+	if (!checks) {
+		checks = index.rows.flatMap((row) => collect({
+			kind,
+			id: row.id,
+			tableId: ""
+		}, void 0, (_, push) => duplicateCheck(index, row, push)));
+		sheetChecksOf.set(index, checks);
+	}
+	return checks;
+}
+var termSheetChecksOf = /* @__PURE__ */ new WeakMap();
+function* termSheetSteps(state, readings, words, terms, domains) {
+	const sheet = termSheetChecksOf.get(terms);
+	if (sheet && sheet.words === words && sheet.domains === domains) {
+		yield sheet.checks;
+		return;
+	}
+	const kept = beginWalk(state.collections.termEntities);
+	const { walk } = kept;
+	const { domainIds } = state.doc;
+	const checks = [];
+	for (const term of terms.rows) {
+		const { id, name, domainId } = term;
+		const found = heldChecks(kept, readings, {
+			kind: DictionaryKind.term,
+			id,
+			tableId: ""
+		}, words, name, (reading) => [sharesName(terms, reading.name, id), unknownDomainText(state, domainId, domainIds)], (push, reading) => {
+			duplicateCheck(terms, term, push);
+			pushFindings(reading.findings, "name", push);
+			domainCheck(state, domainId, push, domainIds);
+		});
+		for (const check of found) checks.push(check);
+		yield found;
+	}
+	endWalk(kept, walk);
+	termSheetChecksOf.set(terms, {
+		words,
+		domains,
+		checks
+	});
+}
+function* walkDictionaryChecks(state) {
+	const { doc, collections } = state;
+	const words = getWordIndex(state);
+	const terms = getTermNames(state);
+	const domains = getDomainNames(state);
+	const readings = /* @__PURE__ */ new Map();
+	yield sheetChecks(DictionaryKind.word, words);
+	yield* termSheetSteps(state, readings, words, terms, domains);
+	yield sheetChecks(DictionaryKind.domain, domains);
+	const tableKept = beginWalk(collections.tableEntities);
+	const tableWalk = tableKept.walk;
+	const columnKept = beginWalk(collections.tableColumnEntities);
+	const columnWalk = columnKept.walk;
+	const { domainIds } = doc;
+	const tables = query(collections).collection("tableEntities").selectByIds(doc.tableIds);
+	const columns = query(collections).collection("tableColumnEntities");
+	for (const table of tables) {
+		const { id, logicalName, name } = table;
+		yield heldChecks(tableKept, readings, {
+			kind: "table",
+			id,
+			tableId: id
+		}, words, logicalName, (reading) => [name, termPhysicalName(terms, reading.name)], (push, reading) => {
+			pushFindings(reading.findings, "logicalName", push);
+			mismatchCheck(terms, words, logicalName, name, push);
+		});
+		for (const column of columns.selectByIds(table.columnIds)) {
+			const { id, tableId, logicalName, name, domainId, dataType } = column;
+			yield heldChecks(columnKept, readings, {
+				kind: "column",
+				id,
+				tableId
+			}, words, logicalName, (reading) => [
+				tableId,
+				name,
+				termPhysicalName(terms, reading.name),
+				unknownDomainText(state, domainId, domainIds),
+				dataType,
+				linkedDomainType(state, domainId, domainIds)
+			], (push, reading) => {
+				pushFindings(reading.findings, "logicalName", push);
+				mismatchCheck(terms, words, logicalName, name, push);
+				domainCheck(state, domainId, push, domainIds);
+				domainTypeCheck(state, column, push, domainIds);
+			});
+		}
+	}
+	endWalk(tableKept, tableWalk);
+	endWalk(columnKept, columnWalk);
+}
+function listDictionaryChecks(state) {
+	const checks = [];
+	for (const step of walkDictionaryChecks(state)) for (const check of step) checks.push(check);
+	return checks;
+}
+//#endregion
+export { DictionaryCheckCode, DictionaryCheckLevel, DictionaryCheckLevelOf, checkColumn, checkDictionaryRow, checkTable, listDictionaryChecks, markOf, walkDictionaryChecks };

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

@@ -0,0 +1,101 @@
+import { toLiveDomainId } from "./membership.js";
+import { findTerm, getWordIndex, normalizeDictionaryName } from "./dictionaryIndex.js";
+//#region src/engine/modules/dictionary/derive.ts
+var WordTokenKind = {
+	word: "word",
+	synonym: "synonym",
+	forbidden: "forbidden",
+	unregistered: "unregistered"
+};
+var SEPARATORS = /[\s_\-·/]+/u;
+var splitNameUnits = (logicalName) => normalizeDictionaryName(logicalName).split(SEPARATORS).filter((unit) => unit !== "");
+var hasMarks = (marks) => marks.words.length > 0 || marks.synonymOf.length > 0 || marks.forbiddenOf.length > 0;
+function longestMatch(root, unit, start) {
+	let node = root;
+	let found = null;
+	for (let index = start; index < unit.length; index++) {
+		node = node.next.get(unit.charCodeAt(index));
+		if (!node) break;
+		if (node.marks && hasMarks(node.marks)) found = {
+			end: index + 1,
+			marks: node.marks
+		};
+	}
+	return found;
+}
+function toToken(text, marks) {
+	if (marks.words.length) return {
+		text,
+		kind: WordTokenKind.word,
+		words: marks.words
+	};
+	if (marks.forbiddenOf.length) return {
+		text,
+		kind: WordTokenKind.forbidden,
+		words: marks.forbiddenOf
+	};
+	return {
+		text,
+		kind: WordTokenKind.synonym,
+		words: marks.synonymOf
+	};
+}
+var unregistered = (text) => ({
+	text,
+	kind: WordTokenKind.unregistered,
+	words: []
+});
+function decompose(index, logicalName) {
+	const tokens = [];
+	for (const unit of splitNameUnits(logicalName)) {
+		let pending = 0;
+		let position = 0;
+		while (position < unit.length) {
+			const match = longestMatch(index.root, unit, position);
+			if (!match) {
+				position++;
+				continue;
+			}
+			if (pending < position) tokens.push(unregistered(unit.slice(pending, position)));
+			tokens.push(toToken(unit.slice(position, match.end), match.marks));
+			position = match.end;
+			pending = position;
+		}
+		if (pending < unit.length) tokens.push(unregistered(unit.slice(pending)));
+	}
+	return tokens;
+}
+function compose(tokens) {
+	if (tokens.length === 0) return null;
+	const abbreviations = [];
+	for (const token of tokens) {
+		if (token.kind !== WordTokenKind.word) return null;
+		const abbreviation = token.words[0]?.abbreviation.trim() ?? "";
+		if (!abbreviation) return null;
+		abbreviations.push(abbreviation);
+	}
+	return abbreviations.join("_");
+}
+function composeName(state, logicalName) {
+	const index = getWordIndex(state);
+	if (index.byName.size === 0) return null;
+	return compose(decompose(index, logicalName));
+}
+function derivePhysical(state, logicalName) {
+	const name = normalizeDictionaryName(logicalName);
+	if (!name) return null;
+	const term = findTerm(state, name);
+	if (term) return {
+		physicalName: term.physicalName.trim() || (composeName(state, name) ?? ""),
+		domainId: toLiveDomainId(state, term.domainId),
+		term
+	};
+	const physicalName = composeName(state, name);
+	return physicalName ? {
+		physicalName,
+		domainId: "",
+		term: null
+	} : null;
+}
+//#endregion
+export { WordTokenKind, compose, composeName, decompose, derivePhysical, splitNameUnits };