@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/erd-editor-schema/dist/v3/parser/doc.js

@@ -0,0 +1,29 @@
+import { assign } from "../../helper.js";
+import { isNil, isPlainObject } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/doc.js
+var createDoc = () => ({
+	tableIds: [],
+	relationshipIds: [],
+	indexIds: [],
+	memoIds: [],
+	tableGroupIds: [],
+	wordIds: [],
+	termIds: [],
+	domainIds: []
+});
+function createAndMergeDoc(json) {
+	const doc = createDoc();
+	if (!isPlainObject(json) || isNil(json)) return doc;
+	const assignArray = assign(Array.isArray, doc, json);
+	assignArray("tableIds");
+	assignArray("relationshipIds");
+	assignArray("indexIds");
+	assignArray("memoIds");
+	assignArray("tableGroupIds");
+	assignArray("wordIds");
+	assignArray("termIds");
+	assignArray("domainIds");
+	return doc;
+}
+//#endregion
+export { createAndMergeDoc };

package/dist/erd-editor-schema/dist/v3/parser/domain.entity.js

@@ -0,0 +1,28 @@
+import { assign } from "../../helper.js";
+import { isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/domain.entity.js
+var createDomain = () => ({
+	id: "",
+	name: "",
+	category: "",
+	dataType: "",
+	description: "",
+	order: ""
+});
+function createAndMergeDomainEntities(values) {
+	const entities = {};
+	for (const value of values) {
+		const target = createDomain();
+		const assignString = assign(isString, target, value);
+		assignString("id");
+		assignString("name");
+		assignString("category");
+		assignString("dataType");
+		assignString("description");
+		assignString("order");
+		if (target.id) entities[target.id] = target;
+	}
+	return entities;
+}
+//#endregion
+export { createAndMergeDomainEntities, createDomain };

package/dist/erd-editor-schema/dist/v3/parser/index.entity.js

@@ -0,0 +1,33 @@
+import { assign, entryId, restoreSequence } from "../../helper.js";
+import { isBoolean, isNil, isPlainObject, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/index.entity.js
+var createIndex = () => ({
+	id: "",
+	name: "",
+	tableId: "",
+	indexColumnIds: [],
+	seqIndexColumnIds: [],
+	unique: false
+});
+function createAndMergeIndexEntities(json) {
+	const entities = {};
+	if (!isPlainObject(json) || isNil(json)) return entities;
+	for (const [key, value] of Object.entries(json)) {
+		if (!isPlainObject(value)) continue;
+		const target = createIndex();
+		const assignString = assign(isString, target, value);
+		const assignBoolean = assign(isBoolean, target, value);
+		const assignArray = assign(Array.isArray, target, value);
+		target.id = entryId(key, value);
+		assignString("name");
+		assignString("tableId");
+		assignBoolean("unique");
+		assignArray("indexColumnIds");
+		assignArray("seqIndexColumnIds");
+		target.seqIndexColumnIds = restoreSequence(target.indexColumnIds, target.seqIndexColumnIds);
+		if (target.id) entities[target.id] = target;
+	}
+	return entities;
+}
+//#endregion
+export { createAndMergeIndexEntities, createIndex };

package/dist/erd-editor-schema/dist/v3/parser/index.js

@@ -0,0 +1,107 @@
+import { settleOrderKeys } from "../../orderKey.js";
+import { entryId } from "../../helper.js";
+import { fromDictionaryRows } from "../../dictionaryRows.js";
+import { createAndMergeDoc } from "./doc.js";
+import { createAndMergeDomainEntities } from "./domain.entity.js";
+import { createAndMergeIndexEntities } from "./index.entity.js";
+import { createAndMergeIndexColumnEntities } from "./indexColumn.entity.js";
+import { createAndMergeMemoEntities } from "./memo.entity.js";
+import { createAndMergeRelationshipEntities } from "./relationship.entity.js";
+import { createAndMergeSettings } from "./settings.js";
+import { createAndMergeTableEntities } from "./table.entity.js";
+import { createAndMergeTableColumnEntities } from "./tableColumn.entity.js";
+import { createAndMergeTableGroupEntities } from "./tableGroup.entity.js";
+import { createAndMergeTermEntities } from "./term.entity.js";
+import { createAndMergeWordEntities } from "./word.entity.js";
+import { isNumber, isPlainObject, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/index.js
+function parser(source) {
+	const json = source;
+	const settings = createAndMergeSettings(json.settings);
+	const doc = createAndMergeDoc(json.doc);
+	const tableEntities = createAndMergeTableEntities(json.collections?.tableEntities);
+	const tableColumnEntities = createAndMergeTableColumnEntities(json.collections?.tableColumnEntities);
+	const relationshipEntities = createAndMergeRelationshipEntities(json.collections?.relationshipEntities);
+	const indexEntities = createAndMergeIndexEntities(json.collections?.indexEntities);
+	const indexColumnEntities = createAndMergeIndexColumnEntities(json.collections?.indexColumnEntities);
+	const memoEntities = createAndMergeMemoEntities(json.collections?.memoEntities);
+	const tableGroupEntities = createAndMergeTableGroupEntities(json.collections?.tableGroupEntities);
+	for (const [list, collection] of HELD_LISTS) if (!Array.isArray(json.doc?.[list])) doc[list] = heldIds(json.collections?.[collection]);
+	const words = fromDictionaryRows(json.collections?.wordEntities);
+	const terms = fromDictionaryRows(json.collections?.termEntities);
+	const domains = fromDictionaryRows(json.collections?.domainEntities);
+	const wordEntities = createAndMergeWordEntities(words);
+	const termEntities = createAndMergeTermEntities(terms);
+	const domainEntities = createAndMergeDomainEntities(domains);
+	if (!Array.isArray(json.doc?.wordIds)) doc.wordIds = rowIds(words);
+	if (!Array.isArray(json.doc?.termIds)) doc.termIds = rowIds(terms);
+	if (!Array.isArray(json.doc?.domainIds)) doc.domainIds = rowIds(domains);
+	settleOrderKeys(wordEntities, doc.wordIds);
+	settleOrderKeys(termEntities, doc.termIds);
+	settleOrderKeys(domainEntities, doc.domainIds);
+	clearUnknownDomains(domainEntities, tableColumnEntities, termEntities);
+	stackInDocOrder(tableEntities, doc.tableIds, json.collections?.tableEntities, 2);
+	stackInDocOrder(memoEntities, doc.memoIds, json.collections?.memoEntities, Math.max(1, ...doc.tableIds.map((id) => tableEntities[id]?.ui.zIndex ?? 0)) + 1);
+	stackInDocOrder(tableGroupEntities, doc.tableGroupIds, json.collections?.tableGroupEntities, 1);
+	return {
+		$schema: "https://raw.githubusercontent.com/dineug/erd-editor/main/json-schema/schema.json",
+		version: "3.0.0",
+		settings,
+		doc,
+		collections: {
+			tableEntities,
+			tableColumnEntities,
+			relationshipEntities,
+			indexEntities,
+			indexColumnEntities,
+			memoEntities,
+			tableGroupEntities,
+			wordEntities,
+			termEntities,
+			domainEntities
+		}
+	};
+}
+var HELD_LISTS = [
+	["tableIds", "tableEntities"],
+	["relationshipIds", "relationshipEntities"],
+	["indexIds", "indexEntities"],
+	["memoIds", "memoEntities"],
+	["tableGroupIds", "tableGroupEntities"]
+];
+function heldIds(source) {
+	if (!isPlainObject(source)) return [];
+	const ids = Object.entries(source).filter(([, value]) => isPlainObject(value)).map(([key, value]) => entryId(key, value)).filter((id) => id !== "");
+	return [...new Set(ids)];
+}
+var rowIds = (values) => [...new Set(values.map((value) => value.id).filter((id) => isString(id) && id !== ""))];
+function clearUnknownDomains(domains, ...linked) {
+	const known = new Set(Object.keys(domains));
+	for (const entities of linked) for (const entity of Object.values(entities)) if (entity.domainId && !known.has(entity.domainId)) entity.domainId = "";
+}
+function stackInDocOrder(entities, ids, source, base) {
+	const stacked = idsWithZIndex(source);
+	ids.forEach((id, index) => {
+		const entity = entities[id];
+		if (!entity || stacked.has(id)) return;
+		entity.ui.zIndex = base + index;
+		stacked.add(id);
+	});
+}
+function idsWithZIndex(source) {
+	const ids = /* @__PURE__ */ new Set();
+	if (!isPlainObject(source)) return ids;
+	for (const [key, value] of Object.entries(source)) {
+		if (!isPlainObject(value)) continue;
+		const id = entryId(key, value);
+		const ui = value.ui;
+		if (isPlainObject(ui) && isNumber(ui.zIndex)) ids.add(id);
+		else ids.delete(id);
+	}
+	return ids;
+}
+function createSchema() {
+	return parser({});
+}
+//#endregion
+export { createSchema, parser };

package/dist/erd-editor-schema/dist/v3/parser/indexColumn.entity.js

@@ -0,0 +1,27 @@
+import { assign, entryId, validNumber } from "../../helper.js";
+import { OrderType, OrderTypeList } from "../schema/indexColumn.entity.js";
+import { isNil, isPlainObject, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/indexColumn.entity.js
+var createIndexColumn = () => ({
+	id: "",
+	indexId: "",
+	columnId: "",
+	orderType: OrderType.ASC
+});
+function createAndMergeIndexColumnEntities(json) {
+	const entities = {};
+	if (!isPlainObject(json) || isNil(json)) return entities;
+	for (const [key, value] of Object.entries(json)) {
+		if (!isPlainObject(value)) continue;
+		const target = createIndexColumn();
+		const assignString = assign(isString, target, value);
+		target.id = entryId(key, value);
+		assignString("indexId");
+		assignString("columnId");
+		assign(validNumber(OrderTypeList), target, value)("orderType");
+		if (target.id) entities[target.id] = target;
+	}
+	return entities;
+}
+//#endregion
+export { createAndMergeIndexColumnEntities, createIndexColumn };

package/dist/erd-editor-schema/dist/v3/parser/memo.entity.js

@@ -0,0 +1,38 @@
+import { assign, entryId } from "../../helper.js";
+import { isNil, isNumber, isPlainObject, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/memo.entity.js
+var createMemo = () => ({
+	id: "",
+	value: "",
+	ui: {
+		x: 200,
+		y: 100,
+		zIndex: 2,
+		width: 116,
+		height: 100,
+		color: ""
+	}
+});
+function createAndMergeMemoEntities(json) {
+	const entities = {};
+	if (!isPlainObject(json) || isNil(json)) return entities;
+	for (const [key, value] of Object.entries(json)) {
+		if (!isPlainObject(value)) continue;
+		const target = createMemo();
+		const assignString = assign(isString, target, value);
+		const uiAssignNumber = assign(isNumber, target.ui, value.ui);
+		const uiAssignString = assign(isString, target.ui, value.ui);
+		target.id = entryId(key, value);
+		assignString("value");
+		uiAssignString("color");
+		uiAssignNumber("x");
+		uiAssignNumber("y");
+		uiAssignNumber("zIndex");
+		uiAssignNumber("width");
+		uiAssignNumber("height");
+		if (target.id) entities[target.id] = target;
+	}
+	return entities;
+}
+//#endregion
+export { createAndMergeMemoEntities, createMemo };

package/dist/erd-editor-schema/dist/v3/parser/migrateScroll.js

@@ -0,0 +1,11 @@
+import { round } from "es-toolkit/compat";
+//#region ../erd-editor-schema/dist/v3/parser/migrateScroll.js
+var boxTerm = (length, zoomLevel) => length * (1 - zoomLevel) / 2;
+function migrateScrollToOrigin(box) {
+	return {
+		originX: round(box.scrollLeft + boxTerm(box.width, box.zoomLevel), 4),
+		originY: round(box.scrollTop + boxTerm(box.height, box.zoomLevel), 4)
+	};
+}
+//#endregion
+export { migrateScrollToOrigin };

package/dist/erd-editor-schema/dist/v3/parser/relationship.entity.js

@@ -0,0 +1,60 @@
+import { assign, entryId, validNumber } from "../../helper.js";
+import { Direction, DirectionList, ReferentialAction, ReferentialActionList, RelationshipType, RelationshipTypeList, StartRelationshipType, StartRelationshipTypeList } from "../schema/relationship.entity.js";
+import { isBoolean, isNil, isNumber, isPlainObject, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/relationship.entity.js
+var createRelationship = () => ({
+	id: "",
+	identification: false,
+	relationshipType: RelationshipType.ZeroN,
+	startRelationshipType: StartRelationshipType.dash,
+	onDelete: ReferentialAction.none,
+	onUpdate: ReferentialAction.none,
+	start: {
+		tableId: "",
+		columnIds: [],
+		x: 0,
+		y: 0,
+		direction: Direction.bottom
+	},
+	end: {
+		tableId: "",
+		columnIds: [],
+		x: 0,
+		y: 0,
+		direction: Direction.bottom
+	}
+});
+function createAndMergeRelationshipEntities(json) {
+	const entities = {};
+	if (!isPlainObject(json) || isNil(json)) return entities;
+	for (const [key, value] of Object.entries(json)) {
+		if (!isPlainObject(value)) continue;
+		const target = createRelationship();
+		assign(isString, target, value);
+		const assignBoolean = assign(isBoolean, target, value);
+		const startAssignNumber = assign(isNumber, target.start, value.start);
+		const startAssignString = assign(isString, target.start, value.start);
+		const endAssignNumber = assign(isNumber, target.end, value.end);
+		const endAssignString = assign(isString, target.end, value.end);
+		target.id = entryId(key, value);
+		assignBoolean("identification");
+		assign(validNumber(RelationshipTypeList), target, value)("relationshipType");
+		assign(validNumber(StartRelationshipTypeList), target, value)("startRelationshipType");
+		assign(validNumber(ReferentialActionList), target, value)("onDelete");
+		assign(validNumber(ReferentialActionList), target, value)("onUpdate");
+		startAssignString("tableId");
+		startAssignNumber("x");
+		startAssignNumber("y");
+		assign(validNumber(DirectionList), target.start, value.start)("direction");
+		assign(Array.isArray, target.start, value.start)("columnIds");
+		endAssignString("tableId");
+		endAssignNumber("x");
+		endAssignNumber("y");
+		assign(validNumber(DirectionList), target.end, value.end)("direction");
+		assign(Array.isArray, target.end, value.end)("columnIds");
+		if (target.id) entities[target.id] = target;
+	}
+	return entities;
+}
+//#endregion
+export { createAndMergeRelationshipEntities, createRelationship };

package/dist/erd-editor-schema/dist/v3/parser/settings.js

@@ -0,0 +1,140 @@
+import { migrateScrollToOrigin } from "./migrateScroll.js";
+import { BracketType, BracketTypeList, CANVAS_SIZE_MAX, CANVAS_SIZE_MIN, CANVAS_ZOOM_MAX, CANVAS_ZOOM_MIN, CanvasType, ColumnType, ColumnTypeList, Database, DatabaseList, InvertedLockSettings, Language, LanguageList, LockSettingFields, LockSettingType, LockSettingTypeList, NameCase, NameCaseList, NameViewMode, NameViewModeList, Show, isSettingLocked } from "../schema/settings.js";
+import { assign, validNumber, validString } from "../../helper.js";
+import { clamp, difference, isBoolean, isNil, isNumber, isPlainObject, isString, pick, uniq } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/settings.js
+var defaultShow = Show.tableComment | Show.columnComment | Show.columnDataType | Show.columnDefault | Show.columnPrimaryKey | Show.columnNotNull | Show.relationship;
+var LOCK_ALL = LockSettingTypeList.reduce((acc, bit) => acc | bit, 0) & ~InvertedLockSettings;
+var LOCKED_FIELDS = LockSettingTypeList.flatMap((bit) => LockSettingFields[bit]);
+var toLockedValues = (settings) => pick(settings, LOCKED_FIELDS);
+var DEFAULT_COLUMN_ORDER = [
+	ColumnType.columnLogicalName,
+	ColumnType.columnName,
+	ColumnType.columnDataType,
+	ColumnType.columnDomain,
+	ColumnType.columnNotNull,
+	ColumnType.columnUnique,
+	ColumnType.columnAutoIncrement,
+	ColumnType.columnDefault,
+	ColumnType.columnComment
+];
+var createSettings = () => {
+	const settings = {
+		originX: 0,
+		originY: 0,
+		zoomLevel: 1,
+		show: defaultShow,
+		database: Database.MySQL,
+		databaseName: "",
+		canvasType: CanvasType.ERD,
+		language: Language.GraphQL,
+		tableNameCase: NameCase.pascalCase,
+		columnNameCase: NameCase.camelCase,
+		bracketType: BracketType.none,
+		relationshipDataTypeSync: true,
+		columnOrder: [...DEFAULT_COLUMN_ORDER],
+		maxWidthComment: -1,
+		lockSettings: LOCK_ALL,
+		ddlScripts: {
+			before: "",
+			after: ""
+		},
+		nameViewMode: NameViewMode.physical
+	};
+	return {
+		...settings,
+		lockedValues: toLockedValues(settings)
+	};
+};
+var isOrderOf = (columnTypes, order) => order.length === columnTypes.length && difference(columnTypes, order).length === 0;
+var isKnownColumnType = (value) => ColumnTypeList.includes(value);
+function indexOfHeld(order, columnTypes) {
+	for (const columnType of columnTypes) {
+		const index = order.indexOf(columnType);
+		if (index !== -1) return index;
+	}
+	return -1;
+}
+function toFullColumnOrder(order) {
+	if (!Array.isArray(order)) return null;
+	if (isOrderOf(ColumnTypeList, order)) return order;
+	const full = uniq(order.filter(isKnownColumnType));
+	if (!full.length) return null;
+	DEFAULT_COLUMN_ORDER.forEach((columnType, index) => {
+		if (full.includes(columnType)) return;
+		const before = indexOfHeld(full, DEFAULT_COLUMN_ORDER.slice(0, index).reverse());
+		full.splice(before === -1 ? indexOfHeld(full, DEFAULT_COLUMN_ORDER.slice(index + 1)) : before + 1, 0, columnType);
+	});
+	return full;
+}
+function toSavedColumnOrder(order) {
+	if (!Array.isArray(order)) return order;
+	const seven = order.filter((columnType) => columnType !== ColumnType.columnLogicalName && columnType !== ColumnType.columnDomain);
+	const full = toFullColumnOrder(seven);
+	return full?.length === order.length && full.every((columnType, index) => columnType === order[index]) ? seven : order;
+}
+var LEGACY_CANVAS_SIZE = 2e3;
+var isFiniteNumber = (value) => Number.isFinite(value);
+var sizeInRange = (value) => clamp(value, CANVAS_SIZE_MIN, CANVAS_SIZE_MAX);
+var zoomInRange = (value) => clamp(value, CANVAS_ZOOM_MIN, CANVAS_ZOOM_MAX);
+var maxWidthCommentInRange = (value) => clamp(value, 60, 200);
+function toLegacyScrollBox(json, zoomLevel) {
+	const size = (value) => isNumber(value) ? sizeInRange(value) : LEGACY_CANVAS_SIZE;
+	const scroll = (value) => isNumber(value) ? value : 0;
+	return {
+		width: size(json.width),
+		height: size(json.height),
+		zoomLevel,
+		scrollLeft: scroll(json.scrollLeft),
+		scrollTop: scroll(json.scrollTop)
+	};
+}
+function createAndMergeSettings(json) {
+	const settings = createSettings();
+	if (!isPlainObject(json) || isNil(json)) return settings;
+	const assignNumber = assign(isNumber, settings, json);
+	const assignString = assign(isString, settings, json);
+	const assignBoolean = assign(isBoolean, settings, json);
+	if (isNumber(json.zoomLevel)) settings.zoomLevel = zoomInRange(json.zoomLevel);
+	if (isNumber(json.maxWidthComment) && json.maxWidthComment !== -1) settings.maxWidthComment = maxWidthCommentInRange(json.maxWidthComment);
+	assignNumber("show");
+	assignString("databaseName");
+	assignString("canvasType");
+	assignBoolean("relationshipDataTypeSync");
+	assign(validNumber(DatabaseList), settings, json)("database");
+	assign(validNumber(LanguageList), settings, json)("language");
+	assign(validNumber(NameCaseList), settings, json)("tableNameCase");
+	assign(validNumber(NameCaseList), settings, json)("columnNameCase");
+	assign(validNumber(BracketTypeList), settings, json)("bracketType");
+	assign(validString(NameViewModeList), settings, json)("nameViewMode");
+	settings.columnOrder = toFullColumnOrder(json.columnOrder) ?? settings.columnOrder;
+	if (isFiniteNumber(json.originX) && isFiniteNumber(json.originY)) {
+		settings.originX = json.originX;
+		settings.originY = json.originY;
+	} else {
+		const { originX, originY } = migrateScrollToOrigin(toLegacyScrollBox(json, settings.zoomLevel));
+		settings.originX = originX;
+		settings.originY = originY;
+	}
+	if (isNumber(json.lockSettings)) {
+		settings.lockSettings = json.lockSettings | 0;
+		if (isSettingLocked(settings.lockSettings, LockSettingType.canvasType) && settings.canvasType === CanvasType.settings) settings.canvasType = CanvasType.ERD;
+		settings.lockedValues = toLockedValues(settings);
+	} else resetPreLockView(settings);
+	const assignScript = assign(isString, settings.ddlScripts, json.ddlScripts);
+	assignScript("before");
+	assignScript("after");
+	return settings;
+}
+function resetPreLockView(settings) {
+	const { originX, originY, zoomLevel, canvasType } = createSettings();
+	Object.assign(settings, {
+		originX,
+		originY,
+		zoomLevel,
+		canvasType
+	});
+	settings.lockedValues = toLockedValues(settings);
+}
+//#endregion
+export { createAndMergeSettings, resetPreLockView, toFullColumnOrder, toLockedValues, toSavedColumnOrder };

package/dist/erd-editor-schema/dist/v3/parser/table.entity.js

@@ -0,0 +1,55 @@
+import { assign, entryId, restoreSequence } from "../../helper.js";
+import { isBoolean, isNil, isNumber, isPlainObject, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/table.entity.js
+var createTable = () => ({
+	id: "",
+	name: "",
+	logicalName: "",
+	comment: "",
+	columnIds: [],
+	seqColumnIds: [],
+	groupId: "",
+	nameDerived: false,
+	ui: {
+		x: 200,
+		y: 100,
+		zIndex: 2,
+		widthName: 60,
+		widthLogicalName: 60,
+		widthComment: 60,
+		color: ""
+	}
+});
+function createAndMergeTableEntities(json) {
+	const entities = {};
+	if (!isPlainObject(json) || isNil(json)) return entities;
+	for (const [key, value] of Object.entries(json)) {
+		if (!isPlainObject(value)) continue;
+		const target = createTable();
+		const assignString = assign(isString, target, value);
+		const assignArray = assign(Array.isArray, target, value);
+		const assignBoolean = assign(isBoolean, target, value);
+		const uiAssignNumber = assign(isNumber, target.ui, value.ui);
+		const uiAssignString = assign(isString, target.ui, value.ui);
+		target.id = entryId(key, value);
+		assignString("name");
+		assignString("logicalName");
+		assignString("comment");
+		assignString("groupId");
+		assignBoolean("nameDerived");
+		assignArray("columnIds");
+		assignArray("seqColumnIds");
+		uiAssignString("color");
+		uiAssignNumber("x");
+		uiAssignNumber("y");
+		uiAssignNumber("zIndex");
+		uiAssignNumber("widthName");
+		uiAssignNumber("widthLogicalName");
+		uiAssignNumber("widthComment");
+		target.seqColumnIds = restoreSequence(target.columnIds, target.seqColumnIds);
+		if (target.id) entities[target.id] = target;
+	}
+	return entities;
+}
+//#endregion
+export { createAndMergeTableEntities, createTable };

package/dist/erd-editor-schema/dist/v3/parser/tableColumn.entity.js

@@ -0,0 +1,54 @@
+import { assign, entryId } from "../../helper.js";
+import { isNil, isNumber, isPlainObject, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/tableColumn.entity.js
+var createColumn = () => ({
+	id: "",
+	tableId: "",
+	name: "",
+	comment: "",
+	dataType: "",
+	default: "",
+	options: 0,
+	logicalName: "",
+	domainId: "",
+	ui: {
+		keys: 0,
+		widthName: 60,
+		widthLogicalName: 60,
+		widthComment: 60,
+		widthDataType: 60,
+		widthDomain: 60,
+		widthDefault: 60
+	}
+});
+function createAndMergeTableColumnEntities(json) {
+	const entities = {};
+	if (!isPlainObject(json) || isNil(json)) return entities;
+	for (const [key, value] of Object.entries(json)) {
+		if (!isPlainObject(value)) continue;
+		const target = createColumn();
+		const assignString = assign(isString, target, value);
+		const assignNumber = assign(isNumber, target, value);
+		const uiAssignNumber = assign(isNumber, target.ui, value.ui);
+		target.id = entryId(key, value);
+		assignString("tableId");
+		assignString("name");
+		assignString("comment");
+		assignString("dataType");
+		assignString("default");
+		assignNumber("options");
+		assignString("logicalName");
+		assignString("domainId");
+		uiAssignNumber("keys");
+		uiAssignNumber("widthName");
+		uiAssignNumber("widthLogicalName");
+		uiAssignNumber("widthComment");
+		uiAssignNumber("widthDataType");
+		uiAssignNumber("widthDomain");
+		uiAssignNumber("widthDefault");
+		if (target.id) entities[target.id] = target;
+	}
+	return entities;
+}
+//#endregion
+export { createAndMergeTableColumnEntities, createColumn };

package/dist/erd-editor-schema/dist/v3/parser/tableGroup.entity.js

@@ -0,0 +1,37 @@
+import { assign, entryId } from "../../helper.js";
+import { isNil, isNumber, isPlainObject, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/tableGroup.entity.js
+var createTableGroup = () => ({
+	id: "",
+	name: "",
+	color: "",
+	ui: {
+		x: 200,
+		y: 100,
+		width: 400,
+		height: 300,
+		zIndex: 1
+	}
+});
+function createAndMergeTableGroupEntities(json) {
+	const entities = {};
+	if (!isPlainObject(json) || isNil(json)) return entities;
+	for (const [key, value] of Object.entries(json)) {
+		if (!isPlainObject(value)) continue;
+		const target = createTableGroup();
+		const assignString = assign(isString, target, value);
+		const uiAssignNumber = assign(isNumber, target.ui, value.ui);
+		target.id = entryId(key, value);
+		assignString("name");
+		assignString("color");
+		uiAssignNumber("x");
+		uiAssignNumber("y");
+		uiAssignNumber("width");
+		uiAssignNumber("height");
+		uiAssignNumber("zIndex");
+		if (target.id) entities[target.id] = target;
+	}
+	return entities;
+}
+//#endregion
+export { createAndMergeTableGroupEntities, createTableGroup };

package/dist/erd-editor-schema/dist/v3/parser/term.entity.js

@@ -0,0 +1,30 @@
+import { assign } from "../../helper.js";
+import { isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v3/parser/term.entity.js
+var createTerm = () => ({
+	id: "",
+	name: "",
+	physicalName: "",
+	domainId: "",
+	description: "",
+	synonyms: "",
+	order: ""
+});
+function createAndMergeTermEntities(values) {
+	const entities = {};
+	for (const value of values) {
+		const target = createTerm();
+		const assignString = assign(isString, target, value);
+		assignString("id");
+		assignString("name");
+		assignString("physicalName");
+		assignString("domainId");
+		assignString("description");
+		assignString("synonyms");
+		assignString("order");
+		if (target.id) entities[target.id] = target;
+	}
+	return entities;
+}
+//#endregion
+export { createAndMergeTermEntities, createTerm };