@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/erd-editor-schema/dist/storageForm.js

@@ -0,0 +1,209 @@
+import { compareByOrder } from "./orderKey.js";
+import { DictionaryFields, stringifyDocument, toDictionaryRows } from "./dictionaryRows.js";
+import { normalizeSettings } from "./normalizeSettings.js";
+//#region ../erd-editor-schema/dist/storageForm.js
+var SCHEMA_URL = "https://raw.githubusercontent.com/dineug/erd-editor/main/json-schema/schema.json";
+var compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+var liveIds = (ids, entities) => [...new Set(ids)].filter((id) => Object.hasOwn(entities, id));
+var toRecord = (entities, order = (a, b) => compare(a.id, b.id)) => Object.fromEntries(entities.sort(order).map((entity) => [entity.id, entity]));
+function toDocumentSettings(settings) {
+	const source = normalizeSettings(settings);
+	const written = {
+		originX: source.originX,
+		originY: source.originY,
+		zoomLevel: source.zoomLevel,
+		show: source.show,
+		database: source.database,
+		databaseName: source.databaseName,
+		canvasType: source.canvasType,
+		language: source.language,
+		tableNameCase: source.tableNameCase,
+		columnNameCase: source.columnNameCase,
+		bracketType: source.bracketType,
+		relationshipDataTypeSync: source.relationshipDataTypeSync,
+		columnOrder: source.columnOrder,
+		maxWidthComment: source.maxWidthComment,
+		lockSettings: source.lockSettings
+	};
+	if (source.ddlScripts) written.ddlScripts = source.ddlScripts;
+	if (source.nameViewMode !== void 0) written.nameViewMode = source.nameViewMode;
+	return written;
+}
+var holdsValue = (key, entity) => DictionaryFields[key].some((field) => {
+	const value = Reflect.get(entity, field);
+	return field !== "id" && typeof value === "string" && value.trim() !== "";
+});
+var textField = (key, value) => value === "" ? {} : { [key]: value };
+var logicalNameField = (logicalName) => typeof logicalName === "string" && logicalName.trim() !== "" ? { logicalName } : {};
+var writtenRows = (key, entities) => entities.length !== 0 ? toDictionaryRows(key, entities) : void 0;
+var holdsEntries = (value) => Array.isArray(value) ? value.length !== 0 : value !== void 0 && Object.keys(value).length !== 0;
+function withEntries(fields) {
+	const held = Object.entries(fields).filter(([, value]) => holdsEntries(value));
+	return held.length !== 0 ? Object.fromEntries(held) : void 0;
+}
+function toDocument(schema) {
+	const doc = schema.doc ?? {};
+	const collections = schema.collections ?? {};
+	const tableEntities = collections.tableEntities ?? {};
+	const tableColumnEntities = collections.tableColumnEntities ?? {};
+	const relationshipEntities = collections.relationshipEntities ?? {};
+	const indexEntities = collections.indexEntities ?? {};
+	const indexColumnEntities = collections.indexColumnEntities ?? {};
+	const memoEntities = collections.memoEntities ?? {};
+	const tableGroupEntities = collections.tableGroupEntities ?? {};
+	const tableGroupIds = liveIds(doc.tableGroupIds ?? [], tableGroupEntities);
+	const keptGroups = new Set(tableGroupIds);
+	const wordEntities = collections.wordEntities ?? {};
+	const termEntities = collections.termEntities ?? {};
+	const domainEntities = collections.domainEntities ?? {};
+	const domainIds = liveIds(doc.domainIds ?? [], domainEntities).filter((id) => holdsValue("domainEntities", domainEntities[id]));
+	const keptDomains = new Set(domainIds);
+	const tableIds = liveIds(doc.tableIds ?? [], tableEntities);
+	const keptTables = new Set(tableIds);
+	const columnIdsOf = /* @__PURE__ */ new Map();
+	const tables = tableIds.map((id) => {
+		const table = tableEntities[id];
+		const columnIds = liveIds(table.columnIds, tableColumnEntities);
+		columnIdsOf.set(id, new Set(columnIds));
+		return {
+			id: table.id,
+			...textField("name", table.name),
+			...logicalNameField(table.logicalName),
+			...textField("comment", table.comment),
+			columnIds,
+			...keptGroups.has(table.groupId) ? { groupId: table.groupId } : {},
+			...table.nameDerived === true ? { nameDerived: true } : {},
+			ui: {
+				x: table.ui.x,
+				y: table.ui.y,
+				...textField("color", table.ui.color)
+			}
+		};
+	});
+	const columns = [...new Set(tables.flatMap((table) => table.columnIds))].map((id) => {
+		const column = tableColumnEntities[id];
+		return {
+			id: column.id,
+			tableId: column.tableId,
+			...textField("name", column.name),
+			...textField("comment", column.comment),
+			...textField("dataType", column.dataType),
+			...textField("default", column.default),
+			options: column.options,
+			...logicalNameField(column.logicalName),
+			...keptDomains.has(column.domainId) ? { domainId: column.domainId } : {}
+		};
+	});
+	const relationshipIds = liveIds(doc.relationshipIds ?? [], relationshipEntities).filter((id) => {
+		const { start, end } = relationshipEntities[id];
+		return keptTables.has(start.tableId) && keptTables.has(end.tableId);
+	});
+	const relationships = relationshipIds.map((id) => {
+		const relationship = relationshipEntities[id];
+		const { start, end } = relationship;
+		return {
+			id: relationship.id,
+			relationshipType: relationship.relationshipType,
+			onDelete: relationship.onDelete,
+			onUpdate: relationship.onUpdate,
+			start: {
+				tableId: start.tableId,
+				columnIds: start.columnIds
+			},
+			end: {
+				tableId: end.tableId,
+				columnIds: end.columnIds
+			}
+		};
+	});
+	const indexIds = liveIds(doc.indexIds ?? [], indexEntities).filter((id) => keptTables.has(indexEntities[id].tableId));
+	const indexes = indexIds.map((id) => {
+		const index = indexEntities[id];
+		const columnIds = columnIdsOf.get(index.tableId);
+		const indexColumnIds = liveIds(index.indexColumnIds, indexColumnEntities).filter((indexColumnId) => columnIds.has(indexColumnEntities[indexColumnId].columnId));
+		return {
+			id: index.id,
+			...textField("name", index.name),
+			tableId: index.tableId,
+			indexColumnIds,
+			unique: index.unique
+		};
+	});
+	const indexColumns = [...new Set(indexes.flatMap((index) => index.indexColumnIds))].map((id) => {
+		const indexColumn = indexColumnEntities[id];
+		return {
+			id: indexColumn.id,
+			indexId: indexColumn.indexId,
+			columnId: indexColumn.columnId,
+			orderType: indexColumn.orderType
+		};
+	});
+	const memoIds = liveIds(doc.memoIds ?? [], memoEntities);
+	const memos = memoIds.map((id) => {
+		const memo = memoEntities[id];
+		const { ui } = memo;
+		return {
+			id: memo.id,
+			...textField("value", memo.value),
+			ui: {
+				x: ui.x,
+				y: ui.y,
+				width: ui.width,
+				height: ui.height,
+				...textField("color", ui.color)
+			}
+		};
+	});
+	const tableGroups = tableGroupIds.map((id) => {
+		const tableGroup = tableGroupEntities[id];
+		const { ui } = tableGroup;
+		return {
+			id: tableGroup.id,
+			...textField("name", tableGroup.name),
+			...textField("color", tableGroup.color),
+			ui: {
+				x: ui.x,
+				y: ui.y,
+				width: ui.width,
+				height: ui.height
+			}
+		};
+	});
+	const words = liveIds(doc.wordIds ?? [], wordEntities).map((id) => wordEntities[id]).filter((word) => holdsValue("wordEntities", word)).sort(compareByOrder);
+	const terms = liveIds(doc.termIds ?? [], termEntities).map((id) => termEntities[id]).map((term) => keptDomains.has(term.domainId) ? term : {
+		...term,
+		domainId: ""
+	}).filter((term) => holdsValue("termEntities", term)).sort(compareByOrder);
+	const domains = domainIds.map((id) => domainEntities[id]).sort(compareByOrder);
+	const writtenDoc = withEntries({
+		tableIds,
+		relationshipIds,
+		indexIds,
+		memoIds,
+		tableGroupIds
+	});
+	const writtenCollections = withEntries({
+		tableEntities: toRecord(tables),
+		tableColumnEntities: toRecord(columns, (a, b) => compare(a.tableId, b.tableId) || compare(a.id, b.id)),
+		relationshipEntities: toRecord(relationships),
+		indexEntities: toRecord(indexes),
+		indexColumnEntities: toRecord(indexColumns, (a, b) => compare(a.indexId, b.indexId) || compare(a.id, b.id)),
+		memoEntities: toRecord(memos),
+		tableGroupEntities: toRecord(tableGroups),
+		wordEntities: writtenRows("wordEntities", words),
+		termEntities: writtenRows("termEntities", terms),
+		domainEntities: writtenRows("domainEntities", domains)
+	});
+	return {
+		$schema: SCHEMA_URL,
+		version: "3.0.0",
+		settings: toDocumentSettings(schema.settings),
+		doc: writtenDoc ?? {},
+		...writtenCollections ? { collections: writtenCollections } : {}
+	};
+}
+function toDocumentJson(schema) {
+	return `${stringifyDocument(toDocument(schema))}\n`;
+}
+//#endregion
+export { toDocument, toDocumentJson };

package/dist/erd-editor-schema/dist/utils/bit.js

@@ -0,0 +1,6 @@
+//#region ../erd-editor-schema/dist/utils/bit.js
+function bHas(bit, value) {
+	return (bit & value) === value;
+}
+//#endregion
+export { bHas };

package/dist/erd-editor-schema/dist/v2/migrations/relationshipType.migration.js

@@ -0,0 +1,14 @@
+//#region ../erd-editor-schema/dist/v2/migrations/relationshipType.migration.js
+var migrationRelationshipTypes = [
+	"ZeroOneN",
+	"One",
+	"N"
+];
+var migrationRelationshipTypeMap = {
+	ZeroOneN: "ZeroN",
+	One: "OneOnly",
+	N: "OneN"
+};
+var migrationRelationshipType = (relationshipType) => migrationRelationshipTypes.includes(relationshipType) ? migrationRelationshipTypeMap[relationshipType] : relationshipType;
+//#endregion
+export { migrationRelationshipType };

package/dist/erd-editor-schema/dist/v2/parser/canvas.js

@@ -0,0 +1,91 @@
+import { assign, validString } from "../../helper.js";
+import { BracketTypeList, CANVAS_SIZE_MAX, CANVAS_SIZE_MIN, CANVAS_ZOOM_MIN, CanvasTypeList, ColumnTypeList, DatabaseList, HighlightThemeList, LanguageList, NameCaseList } from "../schema/canvasEntity.js";
+import { clamp, difference, isBoolean, isNil, isNumber, isPlainObject, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v2/parser/canvas.js
+var createCanvasEntity = () => ({
+	version: "2.2.11",
+	width: 2e3,
+	height: 2e3,
+	scrollTop: 0,
+	scrollLeft: 0,
+	zoomLevel: 1,
+	show: {
+		tableComment: true,
+		columnComment: true,
+		columnDataType: true,
+		columnDefault: true,
+		columnAutoIncrement: false,
+		columnPrimaryKey: true,
+		columnUnique: false,
+		columnNotNull: true,
+		relationship: true
+	},
+	database: "MySQL",
+	databaseName: "",
+	canvasType: "ERD",
+	language: "GraphQL",
+	tableCase: "pascalCase",
+	columnCase: "camelCase",
+	highlightTheme: "VS2015",
+	bracketType: "none",
+	setting: {
+		relationshipDataTypeSync: true,
+		relationshipOptimization: false,
+		columnOrder: [
+			"columnName",
+			"columnDataType",
+			"columnNotNull",
+			"columnUnique",
+			"columnAutoIncrement",
+			"columnDefault",
+			"columnComment"
+		]
+	},
+	pluginSerializationMap: {}
+});
+var sizeInRange = (value) => clamp(value, CANVAS_SIZE_MIN, CANVAS_SIZE_MAX);
+var zoomInRange = (value) => clamp(value, CANVAS_ZOOM_MIN, 1);
+function createAndMergeCanvasEntity(json) {
+	const entity = createCanvasEntity();
+	if (isNil(json)) return entity;
+	const assignNumber = assign(isNumber, entity, json);
+	const assignString = assign(isString, entity, json);
+	const showAssignBoolean = assign(isBoolean, entity.show, json.show);
+	const settingAssignBoolean = assign(isBoolean, entity.setting, json.setting);
+	if (isNumber(json.width)) entity.width = sizeInRange(json.width);
+	if (isNumber(json.height)) entity.height = sizeInRange(json.height);
+	if (isNumber(json.zoomLevel)) entity.zoomLevel = zoomInRange(json.zoomLevel);
+	assignString("version");
+	assignString("databaseName");
+	assignNumber("scrollTop");
+	assignNumber("scrollLeft");
+	assign(validString(DatabaseList), entity, json)("database");
+	assign(validString(CanvasTypeList), entity, json)("canvasType");
+	assign(validString(LanguageList), entity, json)("language");
+	assign(validString(NameCaseList), entity, json)("tableCase");
+	assign(validString(NameCaseList), entity, json)("columnCase");
+	assign(validString(HighlightThemeList), entity, json)("highlightTheme");
+	assign(validString(BracketTypeList), entity, json)("bracketType");
+	showAssignBoolean("tableComment");
+	showAssignBoolean("columnComment");
+	showAssignBoolean("columnDataType");
+	showAssignBoolean("columnDefault");
+	showAssignBoolean("columnAutoIncrement");
+	showAssignBoolean("columnPrimaryKey");
+	showAssignBoolean("columnUnique");
+	showAssignBoolean("columnNotNull");
+	showAssignBoolean("relationship");
+	settingAssignBoolean("relationshipDataTypeSync");
+	settingAssignBoolean("relationshipOptimization");
+	if (json.setting?.columnOrder && ColumnTypeList.length === json.setting.columnOrder.length && difference(ColumnTypeList, json.setting.columnOrder).length === 0) entity.setting.columnOrder = json.setting.columnOrder;
+	if (isPlainObject(json.pluginSerializationMap)) {
+		const pluginSerializationMap = json.pluginSerializationMap;
+		for (const key of Object.keys(pluginSerializationMap)) {
+			const value = pluginSerializationMap[key];
+			if (isString(value)) entity.pluginSerializationMap[key] = value;
+		}
+	}
+	return entity;
+}
+//#endregion
+export { createAndMergeCanvasEntity };

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

@@ -0,0 +1,16 @@
+import { createAndMergeCanvasEntity } from "./canvas.js";
+import { createAndMergeMemoEntity } from "./memo.js";
+import { createAndMergeRelationshipEntity } from "./relationship.js";
+import { createAndMergeTableEntity } from "./table.js";
+//#region ../erd-editor-schema/dist/v2/parser/index.js
+function parser(source) {
+	const json = source;
+	return {
+		canvas: createAndMergeCanvasEntity(json.canvas),
+		table: createAndMergeTableEntity(json.table),
+		relationship: createAndMergeRelationshipEntity(json.relationship),
+		memo: createAndMergeMemoEntity(json.memo)
+	};
+}
+//#endregion
+export { parser };

package/dist/erd-editor-schema/dist/v2/parser/memo.js

@@ -0,0 +1,40 @@
+import { assign } from "../../helper.js";
+import { isBoolean, isNil, isNumber, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v2/parser/memo.js
+var createMemoEntity = () => ({ memos: [] });
+var createMemo = () => ({
+	id: "",
+	value: "",
+	ui: {
+		active: false,
+		left: 200,
+		top: 200,
+		zIndex: 2,
+		width: 127,
+		height: 127
+	}
+});
+function createAndMergeMemoEntity(json) {
+	const entity = createMemoEntity();
+	if (isNil(json) || !Array.isArray(json.memos)) return entity;
+	for (const memo of json.memos) {
+		const target = createMemo();
+		const assignString = assign(isString, target, memo);
+		const uiAssignNumber = assign(isNumber, target.ui, memo.ui);
+		const uiAssignBoolean = assign(isBoolean, target.ui, memo.ui);
+		const uiAssignString = assign(isString, target.ui, memo.ui);
+		assignString("id");
+		assignString("value");
+		uiAssignBoolean("active");
+		uiAssignString("color");
+		uiAssignNumber("left");
+		uiAssignNumber("top");
+		uiAssignNumber("zIndex");
+		uiAssignNumber("width");
+		uiAssignNumber("height");
+		entity.memos.push(target);
+	}
+	return entity;
+}
+//#endregion
+export { createAndMergeMemoEntity };

package/dist/erd-editor-schema/dist/v2/parser/relationship.js

@@ -0,0 +1,62 @@
+import { assign, validString } from "../../helper.js";
+import { migrationRelationshipType } from "../migrations/relationshipType.migration.js";
+import { DirectionList, RelationshipTypeList, StartRelationshipTypeList } from "../schema/relationshipEntity.js";
+import { isBoolean, isNil, isNumber, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v2/parser/relationship.js
+var createRelationshipEntity = () => ({ relationships: [] });
+var createRelationship = () => ({
+	id: "",
+	identification: false,
+	relationshipType: "ZeroN",
+	startRelationshipType: "Dash",
+	start: {
+		tableId: "",
+		columnIds: [],
+		x: 0,
+		y: 0,
+		direction: "bottom"
+	},
+	end: {
+		tableId: "",
+		columnIds: [],
+		x: 0,
+		y: 0,
+		direction: "bottom"
+	},
+	constraintName: "",
+	visible: true
+});
+function createAndMergeRelationshipEntity(json) {
+	const entity = createRelationshipEntity();
+	if (isNil(json) || !Array.isArray(json.relationships)) return entity;
+	for (const relationship of json.relationships) {
+		const target = createRelationship();
+		const assignString = assign(isString, target, relationship);
+		const assignBoolean = assign(isBoolean, target, relationship);
+		const startAssignNumber = assign(isNumber, target.start, relationship.start);
+		const startAssignString = assign(isString, target.start, relationship.start);
+		const endAssignNumber = assign(isNumber, target.end, relationship.end);
+		const endAssignString = assign(isString, target.end, relationship.end);
+		assignString("id");
+		assignString("constraintName");
+		assignBoolean("identification");
+		assignBoolean("visible");
+		assign(validString(RelationshipTypeList), target, relationship)("relationshipType");
+		target.relationshipType = migrationRelationshipType(target.relationshipType);
+		assign(validString(StartRelationshipTypeList), target, relationship)("startRelationshipType");
+		startAssignString("tableId");
+		startAssignNumber("x");
+		startAssignNumber("y");
+		assign(validString(DirectionList), target.start, relationship.start)("direction");
+		if (Array.isArray(relationship.start?.columnIds)) target.start.columnIds = relationship.start?.columnIds.filter(isString);
+		endAssignString("tableId");
+		endAssignNumber("x");
+		endAssignNumber("y");
+		assign(validString(DirectionList), target.end, relationship.end)("direction");
+		if (Array.isArray(relationship.end?.columnIds)) target.end.columnIds = relationship.end?.columnIds.filter(isString);
+		entity.relationships.push(target);
+	}
+	return entity;
+}
+//#endregion
+export { createAndMergeRelationshipEntity };

package/dist/erd-editor-schema/dist/v2/parser/table.js

@@ -0,0 +1,125 @@
+import { assign, validString } from "../../helper.js";
+import { OrderType, OrderTypeList } from "../schema/tableEntity.js";
+import { isBoolean, isNil, isNumber, isString } from "es-toolkit";
+//#region ../erd-editor-schema/dist/v2/parser/table.js
+var createTableEntity = () => ({
+	tables: [],
+	indexes: []
+});
+var createTable = () => ({
+	id: "",
+	name: "",
+	comment: "",
+	columns: [],
+	ui: {
+		active: false,
+		left: 200,
+		top: 100,
+		zIndex: 2,
+		widthName: 60,
+		widthComment: 60
+	},
+	visible: true
+});
+var createColumn = () => ({
+	id: "",
+	name: "",
+	comment: "",
+	dataType: "",
+	default: "",
+	option: {
+		autoIncrement: false,
+		primaryKey: false,
+		unique: false,
+		notNull: false
+	},
+	ui: {
+		active: false,
+		pk: false,
+		fk: false,
+		pfk: false,
+		widthName: 60,
+		widthComment: 60,
+		widthDataType: 60,
+		widthDefault: 60
+	}
+});
+var createIndex = () => ({
+	id: "",
+	name: "",
+	tableId: "",
+	columns: [],
+	unique: false
+});
+var createIndexColumn = () => ({
+	id: "",
+	orderType: OrderType.ASC
+});
+function createAndMergeTableEntity(json) {
+	const entity = createTableEntity();
+	if (isNil(json)) return entity;
+	if (Array.isArray(json.tables)) for (const table of json.tables) {
+		const targetTable = createTable();
+		const assignString = assign(isString, targetTable, table);
+		const assignBoolean = assign(isBoolean, targetTable, table);
+		const uiAssignNumber = assign(isNumber, targetTable.ui, table.ui);
+		const uiAssignBoolean = assign(isBoolean, targetTable.ui, table.ui);
+		const uiAssignString = assign(isString, targetTable.ui, table.ui);
+		assignString("id");
+		assignString("name");
+		assignString("comment");
+		assignBoolean("visible");
+		uiAssignBoolean("active");
+		uiAssignString("color");
+		uiAssignNumber("left");
+		uiAssignNumber("top");
+		uiAssignNumber("zIndex");
+		uiAssignNumber("widthName");
+		uiAssignNumber("widthComment");
+		if (Array.isArray(table.columns)) for (const column of table.columns) {
+			const targetColumn = createColumn();
+			const assignString = assign(isString, targetColumn, column);
+			const uiAssignNumber = assign(isNumber, targetColumn.ui, column.ui);
+			const uiAssignBoolean = assign(isBoolean, targetColumn.ui, column.ui);
+			const optionAssignBoolean = assign(isBoolean, targetColumn.option, column.option);
+			assignString("id");
+			assignString("name");
+			assignString("comment");
+			assignString("dataType");
+			assignString("default");
+			optionAssignBoolean("autoIncrement");
+			optionAssignBoolean("primaryKey");
+			optionAssignBoolean("unique");
+			optionAssignBoolean("notNull");
+			uiAssignBoolean("active");
+			uiAssignBoolean("pk");
+			uiAssignBoolean("fk");
+			uiAssignBoolean("pfk");
+			uiAssignNumber("widthName");
+			uiAssignNumber("widthComment");
+			uiAssignNumber("widthDataType");
+			uiAssignNumber("widthDefault");
+			targetTable.columns.push(targetColumn);
+		}
+		entity.tables.push(targetTable);
+	}
+	if (Array.isArray(json.indexes)) for (const index of json.indexes) {
+		const targetIndex = createIndex();
+		const assignString = assign(isString, targetIndex, index);
+		const assignBoolean = assign(isBoolean, targetIndex, index);
+		assignString("id");
+		assignString("name");
+		assignString("tableId");
+		assignBoolean("unique");
+		if (Array.isArray(index.columns)) for (const column of index.columns) {
+			const targetColumn = createIndexColumn();
+			assign(isString, targetColumn, column)("id");
+			assign(validString(OrderTypeList), targetColumn, column)("orderType");
+			targetIndex.columns.push(targetColumn);
+		}
+		entity.indexes.push(targetIndex);
+	}
+	return entity;
+}
+//#endregion
+export { createAndMergeTableEntity };

package/dist/erd-editor-schema/dist/v2/schema/canvasEntity.js

@@ -0,0 +1,65 @@
+//#region ../erd-editor-schema/dist/v2/schema/canvasEntity.js
+var ColumnType = {
+	columnUnique: "columnUnique",
+	columnAutoIncrement: "columnAutoIncrement",
+	columnName: "columnName",
+	columnDataType: "columnDataType",
+	columnNotNull: "columnNotNull",
+	columnDefault: "columnDefault",
+	columnComment: "columnComment"
+};
+var ColumnTypeList = Object.values(ColumnType);
+var CanvasType = {
+	ERD: "ERD",
+	"@vuerd/builtin-sql-ddl": "@vuerd/builtin-sql-ddl",
+	"@vuerd/builtin-grid": "@vuerd/builtin-grid",
+	"@vuerd/builtin-generator-code": "@vuerd/builtin-generator-code",
+	"@vuerd/builtin-visualization": "@vuerd/builtin-visualization"
+};
+var CanvasTypeList = Object.values(CanvasType);
+var Database = {
+	MariaDB: "MariaDB",
+	MSSQL: "MSSQL",
+	MySQL: "MySQL",
+	Oracle: "Oracle",
+	PostgreSQL: "PostgreSQL",
+	SQLite: "SQLite"
+};
+var DatabaseList = Object.values(Database);
+var Language = {
+	GraphQL: "GraphQL",
+	"C#": "C#",
+	Java: "Java",
+	Kotlin: "Kotlin",
+	TypeScript: "TypeScript",
+	JPA: "JPA",
+	Scala: "Scala"
+};
+var LanguageList = Object.values(Language);
+var NameCase = {
+	none: "none",
+	camelCase: "camelCase",
+	pascalCase: "pascalCase",
+	snakeCase: "snakeCase"
+};
+var NameCaseList = Object.values(NameCase);
+var HighlightTheme = {
+	AtomOneDark: "AtomOneDark",
+	AtomOneLight: "AtomOneLight",
+	MonokaiSublime: "MonokaiSublime",
+	GithubGist: "GithubGist",
+	VS2015: "VS2015"
+};
+var HighlightThemeList = Object.values(HighlightTheme);
+var BracketType = {
+	none: "none",
+	doubleQuote: "doubleQuote",
+	singleQuote: "singleQuote",
+	backtick: "backtick"
+};
+var BracketTypeList = Object.values(BracketType);
+var CANVAS_ZOOM_MIN = .1;
+var CANVAS_SIZE_MIN = 2e3;
+var CANVAS_SIZE_MAX = 2e4;
+//#endregion
+export { BracketType, BracketTypeList, CANVAS_SIZE_MAX, CANVAS_SIZE_MIN, CANVAS_ZOOM_MIN, CanvasType, CanvasTypeList, ColumnType, ColumnTypeList, Database, DatabaseList, HighlightTheme, HighlightThemeList, Language, LanguageList, NameCase, NameCaseList };

package/dist/erd-editor-schema/dist/v2/schema/relationshipEntity.js

@@ -0,0 +1,25 @@
+//#region ../erd-editor-schema/dist/v2/schema/relationshipEntity.js
+var RelationshipType = {
+	ZeroOneN: "ZeroOneN",
+	ZeroOne: "ZeroOne",
+	ZeroN: "ZeroN",
+	OneOnly: "OneOnly",
+	OneN: "OneN",
+	One: "One",
+	N: "N"
+};
+var RelationshipTypeList = Object.values(RelationshipType);
+var StartRelationshipType = {
+	Ring: "Ring",
+	Dash: "Dash"
+};
+var StartRelationshipTypeList = Object.values(StartRelationshipType);
+var Direction = {
+	left: "left",
+	right: "right",
+	top: "top",
+	bottom: "bottom"
+};
+var DirectionList = Object.values(Direction);
+//#endregion
+export { Direction, DirectionList, RelationshipType, RelationshipTypeList, StartRelationshipType, StartRelationshipTypeList };

package/dist/erd-editor-schema/dist/v2/schema/tableEntity.js

@@ -0,0 +1,8 @@
+//#region ../erd-editor-schema/dist/v2/schema/tableEntity.js
+var OrderType = {
+	ASC: "ASC",
+	DESC: "DESC"
+};
+var OrderTypeList = Object.values(OrderType);
+//#endregion
+export { OrderType, OrderTypeList };