@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/tableGroup.js

@@ -0,0 +1,146 @@
+import { query } from "../erd-editor-schema/dist/query/index.js";
+import { Show } from "../constants/schema.js";
+import { arrayHas } from "./arrayHas.js";
+import { bHas } from "./bit.js";
+import { getTableRect, unionRect } from "../konva/scene/metrics.js";
+import { toOpaqueHex } from "./tableColor.js";
+import { contrastTextColor } from "./contrastText.js";
+//#region src/utils/tableGroup.ts
+function getTableGroupId({ doc }, table) {
+	return table.groupId && doc.tableGroupIds.includes(table.groupId) ? table.groupId : "";
+}
+function getMemberTables(state, groupId) {
+	const { doc, collections } = state;
+	if (!groupId || !doc.tableGroupIds.includes(groupId)) return [];
+	return query(collections).collection("tableEntities").selectByIds(doc.tableIds).filter((table) => table.groupId === groupId);
+}
+function getTableGroupMemberIds(state, groupId) {
+	return getMemberTables(state, groupId).map(({ id }) => id);
+}
+function padRect(rect, padding = 24) {
+	const top = padding + 28;
+	return {
+		x: rect.x - padding,
+		y: rect.y - top,
+		width: rect.width + padding * 2,
+		height: rect.height + padding + top
+	};
+}
+function getTableGroupRect(state, group, { excludeTableIds = [], members = getMemberTables(state, group.id) } = {}) {
+	const { x, y, width, height } = group.ui;
+	const excluded = new Set(excludeTableIds);
+	return members.filter((table) => !excluded.has(table.id)).reduce((rect, table) => unionRect(rect, padRect(getTableRect(state, table))), {
+		x,
+		y,
+		width,
+		height
+	});
+}
+function seedTableGroupBoxes(groups) {
+	return new Map(groups.map(({ id, ui: { x, y, width, height } }) => [id, {
+		x,
+		y,
+		width,
+		height
+	}]));
+}
+function growTableGroupBox(boxes, table, rect) {
+	const box = table.groupId ? boxes.get(table.groupId) : void 0;
+	if (box) boxes.set(table.groupId, unionRect(box, padRect(rect)));
+}
+function getTableGroupRects(state, { excludeTableIds = [] } = {}) {
+	const { doc, collections } = state;
+	const boxes = seedTableGroupBoxes(query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds));
+	if (!boxes.size) return boxes;
+	const excluded = new Set(excludeTableIds);
+	query(collections).collection("tableEntities").selectByIds(doc.tableIds).forEach((table) => {
+		if (excluded.has(table.id)) return;
+		growTableGroupBox(boxes, table, getTableRect(state, table));
+	});
+	return boxes;
+}
+function getTableGroupMembers(state) {
+	const { doc, collections } = state;
+	const listed = new Set(doc.tableGroupIds);
+	const members = /* @__PURE__ */ new Map();
+	if (!listed.size) return members;
+	query(collections).collection("tableEntities").selectByIds(doc.tableIds).forEach((table) => {
+		if (!listed.has(table.groupId)) return;
+		const list = members.get(table.groupId);
+		list ? list.push(table) : members.set(table.groupId, [table]);
+	});
+	return members;
+}
+function getTablesGroupRect(state, tableIds) {
+	const { doc, collections } = state;
+	const rects = query(collections).collection("tableEntities").selectByIds(tableIds.filter(arrayHas(doc.tableIds))).map((table) => getTableRect(state, table));
+	return rects.length ? padRect(rects.reduce(unionRect)) : null;
+}
+function getTableGroupWraps(state, points = []) {
+	const { doc, collections } = state;
+	const placed = new Map(points.map((point) => [point.id, point]));
+	const rectsByGroup = /* @__PURE__ */ new Map();
+	query(collections).collection("tableEntities").selectByIds(doc.tableIds).forEach((table) => {
+		const groupId = getTableGroupId(state, table);
+		if (!groupId) return;
+		const { x, y } = placed.get(table.id) ?? table.ui;
+		const rect = {
+			...getTableRect(state, table),
+			x,
+			y
+		};
+		const rects = rectsByGroup.get(groupId);
+		rects ? rects.push(rect) : rectsByGroup.set(groupId, [rect]);
+	});
+	return doc.tableGroupIds.flatMap((id) => {
+		const rects = rectsByGroup.get(id);
+		return rects ? [{
+			...padRect(rects.reduce(unionRect)),
+			id
+		}] : [];
+	});
+}
+function getTableCenter(state, table) {
+	const { x, y, width, height } = getTableRect(state, table);
+	return {
+		x: x + width / 2,
+		y: y + height / 2
+	};
+}
+function isPointInRect({ x, y }, rect) {
+	return rect.x <= x && x <= rect.x + rect.width && rect.y <= y && y <= rect.y + rect.height;
+}
+function findTableGroupsAt(state, points, { boxes, ...options } = {}) {
+	if (!points.length) return [];
+	const { doc, collections } = state;
+	const rects = boxes ?? getTableGroupRects(state, options);
+	const candidates = query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds).flatMap((group) => {
+		const rect = rects.get(group.id);
+		return rect ? [{
+			group,
+			rect
+		}] : [];
+	});
+	return points.map((point) => candidates.reduce((top, { group, rect }) => (!top || top.ui.zIndex <= group.ui.zIndex) && isPointInRect(point, rect) ? group : top, null));
+}
+var nextTableGroupZIndex = (groups) => Math.max(0, ...groups.map(({ ui }) => ui.zIndex)) + 1;
+var isTableGroupShown = ({ settings }) => !bHas(settings.show, Show.hideTableGroup);
+function getTableGroupColors(group) {
+	const background = toOpaqueHex(group.color);
+	const foreground = background && contrastTextColor(background);
+	return background && foreground ? {
+		background,
+		foreground
+	} : null;
+}
+function getTableHeaderTint(state, table, source = "document") {
+	if (source !== "document" || !isTableGroupShown(state)) return null;
+	return getTableGroupTint(state, getTableGroupId(state, table), source);
+}
+function getTableGroupTint(state, groupId, source = "document") {
+	if (!groupId || source !== "document" || !isTableGroupShown(state)) return null;
+	const group = state.collections.tableGroupEntities[groupId];
+	return group ? getTableGroupColors(group) : null;
+}
+//#endregion
+export { findTableGroupsAt, getTableCenter, getTableGroupColors, getTableGroupId, getTableGroupMemberIds, getTableGroupMembers, getTableGroupRect, getTableGroupRects, getTableGroupTint, getTableGroupWraps, getTableHeaderTint, getTablesGroupRect, growTableGroupBox, isPointInRect, isTableGroupShown, nextTableGroupZIndex, padRect, seedTableGroupBoxes };

package/dist/utils/tableKeys.js

@@ -0,0 +1,82 @@
+import { query } from "../erd-editor-schema/dist/query/index.js";
+import { ColumnOption } from "../constants/schema.js";
+import { bHas } from "./bit.js";
+import { splitsTableName, tableNamePart } from "./tableName.js";
+//#region src/utils/tableKeys.ts
+var indexListGeneration = 0;
+function invalidateTableIndexes() {
+	indexListGeneration++;
+}
+var tableIndexesCache = /* @__PURE__ */ new WeakMap();
+function getTableIndexIds({ doc, collections }, tableId) {
+	const { indexIds } = doc;
+	const entities = collections.indexEntities;
+	if (!indexIds.length) return [];
+	const cached = tableIndexesCache.get(indexIds);
+	if (cached?.generation === indexListGeneration && cached.entities === entities) return cached.byTable.get(tableId) ?? [];
+	const byTable = /* @__PURE__ */ new Map();
+	for (const index of query(collections).collection("indexEntities").selectByIds(indexIds)) {
+		const ids = byTable.get(index.tableId);
+		if (ids) ids.push(index.id);
+		else byTable.set(index.tableId, [index.id]);
+	}
+	tableIndexesCache.set(indexIds, {
+		generation: indexListGeneration,
+		entities,
+		byTable
+	});
+	return byTable.get(tableId) ?? [];
+}
+function getColumnKeys({ collections, settings }, table) {
+	const tableName = splitsTableName(settings.database) ? tableNamePart(table.name, settings.bracketType) : table.name;
+	const columns = query(collections).collection("tableColumnEntities").selectByIds(table.columnIds);
+	const primaryKeyColumns = columns.filter((column) => bHas(column.options, ColumnOption.primaryKey));
+	const keys = primaryKeyColumns.length ? [{
+		id: `primaryKey:${table.id}`,
+		kind: "primaryKey",
+		name: `PK_${tableName}`,
+		columnIds: primaryKeyColumns.map((column) => column.id)
+	}] : [];
+	for (const column of columns) {
+		if (!bHas(column.options, ColumnOption.unique)) continue;
+		keys.push({
+			id: `unique:${column.id}`,
+			kind: "unique",
+			name: `UQ_${tableName}_${column.name}`,
+			columnIds: [column.id]
+		});
+	}
+	return keys;
+}
+function getUniqueIndexKeys(state, table) {
+	const tableColumnIds = new Set(table.columnIds);
+	const indexColumns = query(state.collections).collection("indexColumnEntities");
+	return query(state.collections).collection("indexEntities").selectByIds(getTableIndexIds(state, table.id)).filter((index) => index.unique).map((index) => ({
+		indexId: index.id,
+		columnIds: indexColumns.selectByIds(index.indexColumnIds).map((indexColumn) => indexColumn.columnId).filter((columnId) => tableColumnIds.has(columnId))
+	}));
+}
+function getAlternateKeys(state, table) {
+	const positions = new Map(table.columnIds.map((id, index) => [id, index]));
+	return getUniqueIndexKeys(state, table).filter((key) => key.columnIds.length > 1).sort((a, b) => compareKeys(a, b, positions));
+}
+function compareKeys(a, b, positions) {
+	const length = Math.min(a.columnIds.length, b.columnIds.length);
+	for (let index = 0; index < length; index++) {
+		const order = positions.get(a.columnIds[index]) - positions.get(b.columnIds[index]);
+		if (order) return order;
+	}
+	if (a.columnIds.length !== b.columnIds.length) return a.columnIds.length - b.columnIds.length;
+	return a.indexId < b.indexId ? -1 : 1;
+}
+function getAlternateKeyMarks(state, table) {
+	const marks = {};
+	getAlternateKeys(state, table).forEach((key, keyIndex) => {
+		key.columnIds.forEach((columnId, columnIndex) => {
+			(marks[columnId] ??= []).push(`AK${keyIndex + 1}.${columnIndex + 1}`);
+		});
+	});
+	return Object.fromEntries(Object.entries(marks).map(([columnId, mark]) => [columnId, mark.join(",")]));
+}
+//#endregion
+export { getAlternateKeyMarks, getAlternateKeys, getColumnKeys, getTableIndexIds, getUniqueIndexKeys, invalidateTableIndexes };

package/dist/utils/tableName.d.ts

@@ -0,0 +1,47 @@
+import { Column } from '../internal-types';
+/** What an automatic name is numbered against: an entity's id and its name. */
+type Named = {
+    id: string;
+    name: string;
+};
+export declare function getBracket(bracketType: number): string;
+/**
+ * The parts of an unquoted name, split at each dot outside brackets or double
+ * quotes as SQL Server reads it, so [sales.v2].users is two parts.
+ */
+export declare function splitNameParts(name: string): string[];
+/** Whether a name part is written in one pair of brackets or double quotes. */
+export declare function isDelimitedPart(part: string): boolean;
+/** The name a part in brackets or double quotes holds; any other part as is. */
+export declare function unquoteNamePart(part: string): string;
+/**
+ * A table name split at its last dot outside brackets or double quotes into
+ * schema and table, both as written, where it is unquoted; quoted, the whole
+ * name is one identifier and the schema is empty.
+ */
+export declare function splitTableName(name: string, bracketType: number): [schema: string, table: string];
+/**
+ * The part of a table name that automatic constraint and index names take, one
+ * pair of brackets or quotes off where unquoted, so sales.users and
+ * [sales].[users] give PK_users, which every database reads as one identifier.
+ */
+export declare function tableNamePart(name: string, bracketType: number): string;
+/**
+ * Whether a database's DDL builds automatic names from tableNamePart: the six
+ * generators that read an unquoted dot as a schema do, while Databricks and
+ * Snowflake write the whole table name into them.
+ */
+export declare function splitsTableName(database: number): boolean;
+export declare function orderByNameASC<T extends {
+    name: string;
+}>(a: T, b: T): 0 | 1 | -1;
+export declare function autoName<T extends Named>(list: T[], id: string, name: string, num?: number): string;
+/**
+ * autoName for an automatic foreign key or index name, also numbering a name
+ * equal to an earlier one but for case, quoted or not, since the databases fold
+ * an unquoted name and MySQL and MariaDB a quoted index name too.
+ */
+export declare function autoNameIgnoreCase(names: Named[], name: string): string;
+export declare function primaryKeyColumns(columns: Column[]): Column[];
+export {};
+//# sourceMappingURL=tableName.d.ts.map

package/dist/utils/tableName.js

@@ -0,0 +1,72 @@
+import { BracketTypeMap, ColumnOption, Database } from "../constants/schema.js";
+import { bHas } from "./bit.js";
+//#region src/utils/tableName.ts
+function getBracket(bracketType) {
+	return BracketTypeMap[bracketType] ?? "";
+}
+var NAME_PART = /(?:\[(?:[^\]]|\]\])*\]|"(?:[^"]|"")*"|[^.])*/y;
+var DELIMITED_PART = /^(?:\[((?:[^\]]|\]\])*)\]|"((?:[^"]|"")*)")$/;
+function splitNameParts(name) {
+	const parts = [];
+	let index = 0;
+	do {
+		NAME_PART.lastIndex = index;
+		const [part] = NAME_PART.exec(name);
+		parts.push(part);
+		index += part.length + 1;
+	} while (index <= name.length);
+	return parts;
+}
+function isDelimitedPart(part) {
+	return DELIMITED_PART.test(part);
+}
+function unquoteNamePart(part) {
+	const match = DELIMITED_PART.exec(part);
+	if (!match) return part;
+	const [, bracketed, quoted] = match;
+	return bracketed === void 0 ? quoted.replaceAll("\"\"", "\"") : bracketed.replaceAll("]]", "]");
+}
+function splitTableName(name, bracketType) {
+	if (getBracket(bracketType) !== "") return ["", name];
+	const parts = splitNameParts(name);
+	const table = parts[parts.length - 1];
+	return parts.length === 1 ? ["", name] : [name.slice(0, name.length - table.length - 1), table];
+}
+function tableNamePart(name, bracketType) {
+	const [, table] = splitTableName(name, bracketType);
+	return getBracket(bracketType) === "" ? unquoteNamePart(table) : table;
+}
+var TABLE_NAME_PART_DATABASES = /* @__PURE__ */ new Set([
+	Database.MariaDB,
+	Database.MSSQL,
+	Database.MySQL,
+	Database.Oracle,
+	Database.PostgreSQL,
+	Database.SQLite
+]);
+function splitsTableName(database) {
+	return TABLE_NAME_PART_DATABASES.has(database);
+}
+function orderByNameASC(a, b) {
+	const nameA = a.name.toLowerCase();
+	const nameB = b.name.toLowerCase();
+	if (nameA < nameB) return -1;
+	else if (nameA > nameB) return 1;
+	return 0;
+}
+function autoName(list, id, name, num = 1) {
+	return numberName(list, id, name, num, (value) => value);
+}
+function autoNameIgnoreCase(names, name) {
+	return numberName(names, "", name, 1, (value) => value.toLowerCase());
+}
+function numberName(list, id, name, num, fold) {
+	const folded = fold(name);
+	if (!(name !== "" && list.some((value) => value.id !== id && fold(value.name) === folded))) return name;
+	return numberName(list, id, name.replace(/[0-9]/g, "") + num, num + 1, fold);
+}
+function primaryKeyColumns(columns) {
+	return columns.filter(({ options }) => bHas(options, ColumnOption.primaryKey));
+}
+//#endregion
+export { autoName, autoNameIgnoreCase, getBracket, isDelimitedPart, orderByNameASC, primaryKeyColumns, splitNameParts, splitTableName, splitsTableName, tableNamePart, unquoteNamePart };

package/dist/utils/takeover.js

@@ -0,0 +1,10 @@
+import { Open } from "../constants/open.js";
+//#region src/utils/takeover.ts
+var TAKEOVERS = [
+	Open.automaticTablePlacement,
+	Open.diffViewer,
+	Open.timeTravel
+];
+var isTakenOver = ({ editor }) => TAKEOVERS.some((key) => editor.openMap[key]);
+//#endregion
+export { TAKEOVERS, isTakenOver };

package/dist/utils/text.js

@@ -0,0 +1,47 @@
+import { css } from "../r-html/dist/template/css.js";
+import { typography } from "../styles/typography.styles.js";
+import { TextFontFamily } from "../styles/fonts.styles.js";
+//#region src/utils/text.ts
+var TEXT_PADDING = 2;
+var canvas = null;
+var canvasContext;
+var ghostText = css`
+  visibility: hidden;
+  position: fixed;
+  top: -100px;
+  white-space: nowrap;
+  font-family: var(--text-font-family);
+  ${typography.paragraph};
+`;
+function getCanvas() {
+	if (canvas) return canvas;
+	canvas = document.createElement("canvas");
+	return canvas;
+}
+function getCanvasContext() {
+	const canvas = getCanvas();
+	if (canvasContext) return canvasContext;
+	canvasContext = canvas.getContext("2d");
+	if (canvasContext) canvasContext.font = `400 12px ${TextFontFamily}`;
+	return canvasContext;
+}
+function createText() {
+	const canvasContext = getCanvasContext();
+	const span = document.createElement("span");
+	span.className = ghostText.toString();
+	const toWidth = (text) => {
+		let width = 0;
+		if (canvasContext) width = canvasContext.measureText(text).width;
+		else {
+			span.innerText = text;
+			width = span.offsetWidth;
+		}
+		return Math.round(width) + TEXT_PADDING;
+	};
+	return {
+		span,
+		toWidth
+	};
+}
+//#endregion
+export { createText };

package/dist/utils/validation.js

@@ -0,0 +1,47 @@
+import { BracketTypeList, CANVAS_SIZE_MAX, CANVAS_SIZE_MIN, CANVAS_ZOOM_MAX, CANVAS_ZOOM_MIN, CanvasTypeList, ColumnTypeList, DatabaseList, LanguageList, NameCaseList, NameViewModeList } from "../constants/schema.js";
+import { DatabaseVendorList } from "../constants/sql/database.js";
+import { arrayHas } from "./arrayHas.js";
+import { clamp, isString } from "es-toolkit";
+import { round } from "es-toolkit/compat";
+//#region src/utils/validation.ts
+var NOT_NUM = /[^0-9]/g;
+var toNumString = (value) => value.replace(NOT_NUM, "");
+var canvasInRange = (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 canvasSizeInRange(size) {
+	return canvasInRange(isString(size) ? Number(toNumString(size)) : size);
+}
+function zoomLevelInRange(zoom) {
+	return round(zoomInRange(zoom), 2);
+}
+function toMaxWidthCommentFormat(width) {
+	return `${maxWidthCommentInRange(isString(width) ? Number(toNumString(width)) : width)}px`;
+}
+function toZoomFormat(zoomLevel) {
+	return `${(zoomLevel * 100).toFixed()}%`;
+}
+var hasDatabase = arrayHas(DatabaseList);
+var hasNameCase = arrayHas(NameCaseList);
+var hasBracketType = arrayHas(BracketTypeList);
+var hasLanguage = arrayHas(LanguageList);
+var hasColumnType = arrayHas(ColumnTypeList);
+var hasDatabaseVendor = arrayHas(DatabaseVendorList);
+var hasCanvasType = arrayHas(CanvasTypeList);
+var hasNameViewMode = arrayHas(NameViewModeList);
+function textInRange(width) {
+	return Math.max(width, 60);
+}
+function toSafeString(value) {
+	return isString(value) ? value.trim() : "";
+}
+function isHighLevelTable(zoomLevel) {
+	return zoomLevel <= .7;
+}
+var EDITABLE_SELECTOR = "input, textarea, [contenteditable]";
+function isEditableTarget(target) {
+	const el = target;
+	return Boolean(el && typeof el.closest === "function" && el.closest(EDITABLE_SELECTOR));
+}
+//#endregion
+export { canvasSizeInRange, hasBracketType, hasCanvasType, hasColumnType, hasDatabase, hasDatabaseVendor, hasLanguage, hasNameCase, hasNameViewMode, isEditableTarget, isHighLevelTable, maxWidthCommentInRange, textInRange, toMaxWidthCommentFormat, toNumString, toSafeString, toZoomFormat, zoomInRange, zoomLevelInRange };

package/dist/utils/virtualRange.js

@@ -0,0 +1,21 @@
+function visibleRange(count, scrollTop, height, rowHeight) {
+	if (count === 0) return {
+		first: 0,
+		last: -1
+	};
+	const first = Math.max(0, Math.floor(scrollTop / rowHeight) - 8);
+	const last = Math.min(count - 1, Math.ceil((scrollTop + height) / rowHeight) - 1 + 8);
+	return {
+		first,
+		last: Math.max(first - 1, last)
+	};
+}
+function offsetToShow(index, scrollTop, height, rowHeight) {
+	const top = index * rowHeight;
+	const bottom = top + rowHeight;
+	if (top < scrollTop) return top;
+	if (bottom > scrollTop + height) return Math.max(0, bottom - height);
+	return scrollTop;
+}
+//#endregion
+export { offsetToShow, visibleRange };

package/dist/uuid/dist/uuid25.js

@@ -0,0 +1,11 @@
+import { uuidv7 } from "./uuidv7.js";
+//#region ../uuid/dist/uuid25.js
+function toUuid25(bytes) {
+	if (bytes.length !== 16) throw new RangeError(`A UUID is 16 bytes, not ${bytes.length}`);
+	let value = 0n;
+	for (const byte of bytes) value = value << 8n | BigInt(byte);
+	return value.toString(36).padStart(25, "0");
+}
+var uuid25 = () => toUuid25(uuidv7());
+//#endregion
+export { toUuid25, uuid25 };

package/dist/uuid/dist/uuidv7.js

@@ -0,0 +1,25 @@
+//#region ../uuid/dist/uuidv7.js
+var seedCounter = (high, low) => (high & 511) * 2 ** 32 + low;
+function createUuidv7({ now = () => Date.now(), random = (words) => crypto.getRandomValues(words) } = {}) {
+	let timestamp = -1;
+	let counter = 0;
+	return () => {
+		const [high, low, tail] = random(/* @__PURE__ */ new Uint32Array(3));
+		const current = now();
+		if (current > timestamp) {
+			timestamp = current;
+			counter = seedCounter(high, low);
+		} else counter++;
+		const bytes = /* @__PURE__ */ new Uint8Array(16);
+		const view = new DataView(bytes.buffer);
+		view.setUint16(0, Math.floor(timestamp / 2 ** 32));
+		view.setUint32(2, timestamp % 2 ** 32);
+		view.setUint16(6, 28672 + Math.floor(counter / 2 ** 30));
+		view.setUint32(8, 2147483648 + counter % 2 ** 30);
+		view.setUint32(12, tail);
+		return bytes;
+	};
+}
+var uuidv7 = createUuidv7();
+//#endregion
+export { createUuidv7, uuidv7 };