@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/utils/find-replace/findMatches.js

@@ -0,0 +1,212 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { isMemoShown } from "../memo.js";
+import { orderByNameASC } from "../tableName.js";
+import { getTableIndexIds } from "../tableKeys.js";
+import { isTableGroupShown } from "../tableGroup.js";
+//#region src/utils/find-replace/findMatches.ts
+var FindField = {
+	tableName: "tableName",
+	tableComment: "tableComment",
+	columnName: "columnName",
+	columnComment: "columnComment",
+	memo: "memo",
+	indexName: "indexName",
+	tableGroupName: "tableGroupName",
+	logicalName: "logicalName"
+};
+var FindFieldList = Object.values(FindField);
+var DEFAULT_FIND_FIELDS = Object.freeze([
+	FindField.tableName,
+	FindField.columnName,
+	FindField.indexName,
+	FindField.tableGroupName,
+	FindField.logicalName
+]);
+var isTableLogicalName = ({ field, id, tableId }) => field === FindField.logicalName && id === tableId;
+var FindTextActionTypes = [
+	"table.add",
+	"table.remove",
+	"table.changeName",
+	"table.changeLogicalName",
+	"table.changeComment",
+	"table.sort",
+	"column.add",
+	"column.remove",
+	"column.changeName",
+	"column.changeLogicalName",
+	"column.changeComment",
+	"column.move",
+	"memo.add",
+	"memo.remove",
+	"memo.changeValue",
+	"index.add",
+	"index.remove",
+	"index.changeName",
+	"tableGroup.add",
+	"tableGroup.remove",
+	"tableGroup.changeName",
+	"settings.changeShow",
+	"editor.loadJson",
+	"editor.clear",
+	"editor.initialLoadJson",
+	"editor.initialClear"
+];
+function treeOrderOf({ doc, collections }) {
+	const tables = query(collections).collection("tableEntities").selectByIds(doc.tableIds).sort(orderByNameASC);
+	const groups = query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds).sort(orderByNameASC);
+	return {
+		tableIds: tables.map(({ id }) => id),
+		tableGroupIds: groups.map(({ id }) => id)
+	};
+}
+function inOrder(live, order) {
+	if (!order) return live;
+	const byId = new Map(live.map((entity) => [entity.id, entity]));
+	const known = new Set(order);
+	const kept = order.flatMap((id) => byId.get(id) ?? []);
+	const added = live.filter(({ id }) => !known.has(id)).sort(orderByNameASC);
+	return [...kept, ...added];
+}
+function walkFields(state, fields, order) {
+	const { doc, collections } = state;
+	const has = new Set(fields);
+	const result = [];
+	const push = (field) => {
+		result.push({
+			...field,
+			slot: result.length
+		});
+	};
+	const columnCollection = query(collections).collection("tableColumnEntities");
+	const indexCollection = query(collections).collection("indexEntities");
+	const tables = inOrder(query(collections).collection("tableEntities").selectByIds(doc.tableIds), order?.tableIds);
+	const walksColumns = has.has(FindField.columnName) || has.has(FindField.columnComment) || has.has(FindField.logicalName);
+	for (const table of tables) {
+		const tableId = table.id;
+		has.has(FindField.logicalName) && push({
+			field: FindField.logicalName,
+			id: tableId,
+			tableId,
+			text: table.logicalName
+		});
+		has.has(FindField.tableName) && push({
+			field: FindField.tableName,
+			id: tableId,
+			tableId,
+			text: table.name
+		});
+		has.has(FindField.tableComment) && push({
+			field: FindField.tableComment,
+			id: tableId,
+			tableId,
+			text: table.comment
+		});
+		const columns = walksColumns ? columnCollection.selectByIds(table.columnIds) : [];
+		for (const column of columns) {
+			has.has(FindField.logicalName) && push({
+				field: FindField.logicalName,
+				id: column.id,
+				tableId,
+				text: column.logicalName
+			});
+			has.has(FindField.columnName) && push({
+				field: FindField.columnName,
+				id: column.id,
+				tableId,
+				text: column.name
+			});
+			has.has(FindField.columnComment) && push({
+				field: FindField.columnComment,
+				id: column.id,
+				tableId,
+				text: column.comment
+			});
+		}
+		const indexes = has.has(FindField.indexName) ? indexCollection.selectByIds(getTableIndexIds(state, tableId)) : [];
+		for (const index of indexes) push({
+			field: FindField.indexName,
+			id: index.id,
+			tableId,
+			text: index.name
+		});
+	}
+	if (has.has(FindField.tableGroupName) && isTableGroupShown(state)) {
+		const groups = inOrder(query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds), order?.tableGroupIds);
+		for (const group of groups) push({
+			field: FindField.tableGroupName,
+			id: group.id,
+			tableId: "",
+			text: group.name
+		});
+	}
+	if (has.has(FindField.memo) && isMemoShown(state)) {
+		const memos = query(collections).collection("memoEntities").selectByIds(doc.memoIds);
+		for (const memo of memos) push({
+			field: FindField.memo,
+			id: memo.id,
+			tableId: "",
+			text: memo.value
+		});
+	}
+	return result;
+}
+function findMatches(state, matcher, fields = FindFieldList, order) {
+	return walkFields(state, fields, order).flatMap((field) => field.text ? matcher.find(field.text).map(({ start, end }) => ({
+		...field,
+		start,
+		end
+	})) : []);
+}
+function rematchField(matches, matcher, changed, value) {
+	const found = matcher.find(value).map(({ start, end }) => ({
+		...changed,
+		text: value,
+		start,
+		end
+	}));
+	return [
+		...matches.filter((match) => match.slot < changed.slot),
+		...found,
+		...matches.filter((match) => match.slot > changed.slot)
+	];
+}
+function indexAfter(matches, slot, offset) {
+	if (!matches.length) return -1;
+	const index = matches.findIndex((match) => match.slot > slot || match.slot === slot && match.start >= offset);
+	return index === -1 ? 0 : index;
+}
+function resumeRun(state, fields, run, order) {
+	if (!run) return null;
+	const found = walkFields(state, fields, order).find(({ field, id }) => field === run.field && id === run.id);
+	return found?.text === run.text ? {
+		...run,
+		slot: found.slot
+	} : null;
+}
+var precedes = (match, slot, offset) => match.slot < slot || match.slot === slot && match.start < offset;
+function nextReplace(after, match, value, run) {
+	const grown = value.length - match.text.length;
+	const offset = match.end + grown;
+	const began = run ?? {
+		...match,
+		wrapped: false
+	};
+	const inField = began.slot === match.slot;
+	const start = inField && match.start < began.start ? began.start + grown : began.start;
+	const index = indexAfter(after, match.slot, offset);
+	const next = after[index];
+	const wrapped = began.wrapped || next !== void 0 && precedes(next, match.slot, offset);
+	return {
+		index: wrapped && next !== void 0 && !precedes(next, began.slot, start) ? -1 : index,
+		run: {
+			field: began.field,
+			id: began.id,
+			slot: began.slot,
+			start,
+			text: inField ? value : began.text,
+			wrapped
+		}
+	};
+}
+//#endregion
+export { DEFAULT_FIND_FIELDS, FindField, FindFieldList, FindTextActionTypes, findMatches, indexAfter, isTableLogicalName, nextReplace, rematchField, resumeRun, treeOrderOf, walkFields };

package/dist/utils/find-replace/index.d.ts

@@ -1,5 +1,4 @@
 export * from './findMatches';
 export * from './matcher';
 export * from './present';
-export * from './replaceActions';
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/find-replace/matcher.js

@@ -0,0 +1,128 @@
+import { preserveCase } from "./preserveCase.js";
+import { escapeRegExp } from "es-toolkit";
+//#region src/utils/find-replace/matcher.ts
+var DEFAULT_FIND_OPTIONS = Object.freeze({
+	matchCase: false,
+	wholeWord: false,
+	regex: false,
+	preserveCase: false
+});
+var WORD_CHAR = "[\\p{L}\\p{N}\\p{M}\\p{Pc}\\p{Join_Control}]";
+var wholeWordSource = (source) => `(?:(?<!${WORD_CHAR})|(?!${WORD_CHAR}))(?:${source})(?:(?!${WORD_CHAR})|(?<!${WORD_CHAR}))`;
+var NAMED_TOKENS = /\$(?:([$&`'])|(\d\d?)|<([^>]*)>)/g;
+var TOKENS = /\$(?:([$&`'])|(\d\d?))/g;
+function expandReplacement(template, match, captures, position, subject, groups) {
+	return template.replace(groups ? NAMED_TOKENS : TOKENS, (token, symbol, digits, name) => {
+		if (symbol === "$") return "$";
+		if (symbol === "&") return match;
+		if (symbol === "`") return subject.slice(0, position);
+		if (symbol === "'") return subject.slice(position + match.length);
+		if (typeof name === "string") return groups[name] ?? "";
+		const number = digits;
+		const count = captures.length;
+		const index = Number(number);
+		if (index >= 1 && index <= count) return captures[index - 1] ?? "";
+		const first = Number(number[0]);
+		if (number.length === 2 && first >= 1 && first <= count) return (captures[first - 1] ?? "") + number[1];
+		return token;
+	});
+}
+var SYNTAX_CHARACTERS = /* @__PURE__ */ new Set("^$\\.*+?()[]{}|/");
+var BRACED_QUANTIFIER = /\{\d+(?:,\d*)?\}/y;
+function escapeFor(char) {
+	if (/^[\dA-Za-z]$/.test(char) || SYNTAX_CHARACTERS.has(char)) return `\\${char}`;
+	if (char === "-") return "\\x2d";
+	return `\\u{${char.codePointAt(0).toString(16)}}`;
+}
+function toUnicodeSource(source) {
+	let result = "";
+	let inClass = false;
+	let index = 0;
+	const readAt = (at) => String.fromCodePoint(source.codePointAt(at));
+	while (index < source.length) {
+		const char = readAt(index);
+		index += char.length;
+		if (char === "\\") {
+			if (index >= source.length) return `${result}${char}`;
+			const escaped = readAt(index);
+			index += escaped.length;
+			result += escapeFor(escaped);
+			if ("pPu".includes(escaped) && source[index] === "{") {
+				const close = source.indexOf("}", index);
+				const end = close === -1 ? source.length : close + 1;
+				result += source.slice(index, end);
+				index = end;
+			}
+		} else if (inClass) {
+			inClass = char !== "]";
+			result += char;
+		} else if (char === "[") {
+			inClass = true;
+			result += char;
+		} else if (char === "{") {
+			BRACED_QUANTIFIER.lastIndex = index - 1;
+			const quantifier = BRACED_QUANTIFIER.exec(source)?.[0];
+			result += quantifier ?? "\\{";
+			index += quantifier ? quantifier.length - 1 : 0;
+		} else result += char === "]" || char === "}" ? `\\${char}` : char;
+	}
+	return result;
+}
+function createMatcher(query, options) {
+	if (!query) return {
+		matcher: null,
+		error: "empty"
+	};
+	const flags = `g${options.matchCase ? "" : "i"}u${options.regex ? "m" : ""}`;
+	const source = options.regex ? toUnicodeSource(query) : escapeRegExp(query);
+	let pattern;
+	try {
+		pattern = new RegExp(source, flags);
+		if (options.wholeWord) pattern = new RegExp(wholeWordSource(source), flags);
+	} catch {
+		return {
+			matcher: null,
+			error: "invalid"
+		};
+	}
+	const find = (text) => {
+		const ranges = [];
+		for (const match of text.matchAll(pattern)) {
+			const start = match.index;
+			const end = start + match[0].length;
+			if (end > start) ranges.push({
+				start,
+				end
+			});
+		}
+		return ranges;
+	};
+	const replace = (text, replacement, onlyAt) => {
+		let changed = 0;
+		return {
+			value: text.replace(pattern, (...args) => {
+				const hasGroups = typeof args[args.length - 1] === "object";
+				const groups = hasGroups ? args[args.length - 1] : void 0;
+				const tail = hasGroups ? 3 : 2;
+				const match = args[0];
+				const position = args[args.length - tail];
+				const captures = args.slice(1, args.length - tail);
+				if (!match || onlyAt !== void 0 && position !== onlyAt) return match;
+				const expanded = options.regex ? expandReplacement(replacement, match, captures, position, text, groups) : replacement;
+				const cased = options.preserveCase ? preserveCase(match, expanded) : expanded;
+				if (cased !== match) changed++;
+				return cased;
+			}),
+			changed
+		};
+	};
+	return {
+		matcher: {
+			find,
+			replace
+		},
+		error: null
+	};
+}
+//#endregion
+export { DEFAULT_FIND_OPTIONS, createMatcher, expandReplacement, toUnicodeSource };

package/dist/utils/find-replace/present.js

@@ -0,0 +1,48 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { sourceI18n } from "../../i18n/source.js";
+import { FindField, isTableLogicalName } from "./findMatches.js";
+//#region src/utils/find-replace/present.ts
+var FindFieldLabel = {
+	[FindField.tableName]: "findReplace.field.tableName",
+	[FindField.tableComment]: "findReplace.field.tableComment",
+	[FindField.columnName]: "findReplace.field.columnName",
+	[FindField.columnComment]: "findReplace.field.columnComment",
+	[FindField.memo]: "findReplace.field.memo",
+	[FindField.indexName]: "findReplace.field.indexName",
+	[FindField.tableGroupName]: "findReplace.field.tableGroupName",
+	[FindField.logicalName]: "findReplace.field.logicalName"
+};
+var nameOf = (name, { t }) => name?.trim() || t("common.unnamed");
+function locationOf({ collections }, match, i18n = sourceI18n) {
+	const { field, id, tableId } = match;
+	if (field === FindField.memo || field === FindField.tableGroupName) return "";
+	const tableName = nameOf(query(collections).collection("tableEntities").selectById(tableId)?.name, i18n);
+	if (field === FindField.tableName || field === FindField.tableComment || field === FindField.indexName || isTableLogicalName(match)) return tableName;
+	return `${tableName}.${nameOf(query(collections).collection("tableColumnEntities").selectById(id)?.name, i18n)}`;
+}
+function describeMatch(state, match, i18n = sourceI18n) {
+	const location = locationOf(state, match, i18n);
+	const kind = i18n.t(FindFieldLabel[match.field]);
+	return location ? i18n.t("findReplace.matchLocation", {
+		location,
+		kind
+	}) : kind;
+}
+var splitsPair = (text, at) => /[\uD800-\uDBFF]/.test(text.charAt(at - 1)) && /[\uDC00-\uDFFF]/.test(text.charAt(at));
+function snippetOf({ text, start, end }, before = 24, length = 96) {
+	let from = Math.max(0, Math.min(start - before, text.length - length));
+	const space = from > 0 ? text.slice(from, start).search(/\s/) : -1;
+	if (space !== -1) from += space + 1;
+	let to = Math.min(text.length, Math.max(end, from + length));
+	if (from < start && splitsPair(text, from)) from -= 1;
+	if (to > end && splitsPair(text, to)) to += 1;
+	const lead = from > 0 ? "…" : "";
+	const trail = to < text.length ? "…" : "";
+	return {
+		text: `${lead}${text.slice(from, to).replace(/\s/g, " ")}${trail}`,
+		start: start - from + lead.length,
+		end: end - from + lead.length
+	};
+}
+//#endregion
+export { FindFieldLabel, describeMatch, locationOf, snippetOf };

package/dist/utils/find-replace/preserveCase.js

@@ -0,0 +1,25 @@
+//#region src/utils/find-replace/preserveCase.ts
+var SEPARATORS = ["-", "_"];
+var hasCase = (text) => text.toUpperCase() !== text.toLowerCase();
+function pieceSeparator(matched, replacement) {
+	const splits = SEPARATORS.filter((separator) => matched.includes(separator) && replacement.includes(separator) && matched.split(separator).length === replacement.split(separator).length);
+	return splits.length === 1 ? splits[0] : null;
+}
+function caseLike(matched, replacement) {
+	if (!matched || !replacement || !hasCase(matched)) return replacement;
+	if (matched === matched.toUpperCase()) return replacement.toUpperCase();
+	if (matched === matched.toLowerCase()) return replacement.toLowerCase();
+	const [first] = matched;
+	if (!hasCase(first)) return replacement;
+	const [lead] = replacement;
+	const rest = replacement.slice(lead.length);
+	return first === first.toUpperCase() ? lead.toUpperCase() + rest : lead.toLowerCase() + rest;
+}
+function preserveCase(matched, replacement) {
+	const separator = pieceSeparator(matched, replacement);
+	if (!separator) return caseLike(matched, replacement);
+	const pieces = matched.split(separator);
+	return replacement.split(separator).map((piece, index) => caseLike(pieces[index], piece)).join(separator);
+}
+//#endregion
+export { preserveCase };

package/dist/utils/find-replace/replaceActions.js

@@ -0,0 +1,70 @@
+import { changeColumnCommentAction } from "../../engine/modules/table-column/atom.actions.js";
+import { FocusType } from "../../engine/modules/editor/state.js";
+import { changeIndexNameAction } from "../../engine/modules/index/atom.actions.js";
+import { changeMemoValueAction } from "../../engine/modules/memo/atom.actions.js";
+import { changeTableCommentAction } from "../../engine/modules/table/atom.actions.js";
+import { changeTableGroupNameAction } from "../../engine/modules/table-group/atom.actions.js";
+import { setColumnLogicalNameAction$, setColumnLogicalNamesAction$, setTableLogicalNameAction$ } from "../../engine/modules/dictionary/generator.actions.js";
+import { changeTableNameAction$ } from "../../engine/modules/table/generator.actions.js";
+import { changeColumnValueAction$ } from "../../engine/modules/table-column/generator.actions.js";
+import { FindField, isTableLogicalName } from "./findMatches.js";
+//#region src/utils/find-replace/replaceActions.ts
+function toFieldAction(match, value) {
+	const { field, id, tableId } = match;
+	switch (field) {
+		case FindField.tableName: return changeTableNameAction$(id, value);
+		case FindField.tableComment: return changeTableCommentAction({
+			id,
+			value
+		});
+		case FindField.columnName: return changeColumnValueAction$(FocusType.columnName, tableId, id, value);
+		case FindField.columnComment: return changeColumnCommentAction({
+			id,
+			tableId,
+			value
+		});
+		case FindField.memo: return changeMemoValueAction({
+			id,
+			value
+		});
+		case FindField.indexName: return changeIndexNameAction({
+			id,
+			tableId,
+			value
+		});
+		case FindField.tableGroupName: return changeTableGroupNameAction({
+			id,
+			value
+		});
+		case FindField.logicalName: return isTableLogicalName(match) ? setTableLogicalNameAction$(id, value) : setColumnLogicalNameAction$(tableId, id, value);
+	}
+}
+function toReplaceActions(matches, matcher, replacement, only) {
+	const actions = [];
+	const columnLogicalNames = [];
+	const seen = /* @__PURE__ */ new Set();
+	let columnLogicalNamesAt = -1;
+	let replaced = 0;
+	for (const match of only ? [only] : matches) {
+		if (seen.has(match.slot)) continue;
+		seen.add(match.slot);
+		const { value, changed } = matcher.replace(match.text, replacement, only?.start);
+		replaced += changed;
+		if (value === match.text) continue;
+		if (match.field === FindField.logicalName && !isTableLogicalName(match)) {
+			if (columnLogicalNamesAt < 0) columnLogicalNamesAt = actions.length;
+			columnLogicalNames.push({
+				tableId: match.tableId,
+				columnId: match.id,
+				value
+			});
+		} else actions.push(toFieldAction(match, value));
+	}
+	if (columnLogicalNamesAt >= 0) actions.splice(columnLogicalNamesAt, 0, setColumnLogicalNamesAction$(columnLogicalNames));
+	return {
+		actions,
+		replaced
+	};
+}
+//#endregion
+export { toFieldAction, toReplaceActions };

package/dist/utils/flipAnimation.js

@@ -0,0 +1,52 @@
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/defineProperty.js";
+//#region src/utils/flipAnimation.ts
+var FlipAnimation = class {
+	constructor(root, selector, animationName) {
+		_defineProperty(this, "flipSnapshots", []);
+		_defineProperty(this, "root", void 0);
+		_defineProperty(this, "selector", void 0);
+		_defineProperty(this, "animationName", void 0);
+		this.root = root;
+		this.selector = selector;
+		this.animationName = animationName;
+	}
+	snapshot() {
+		this.flipSnapshots = [];
+		this.root.value?.querySelectorAll(this.selector).forEach((el) => {
+			if (el instanceof HTMLElement) {
+				const { top, left } = el.getBoundingClientRect();
+				this.flipSnapshots.push({
+					el,
+					top,
+					left
+				});
+			}
+		});
+	}
+	play() {
+		if (!this.flipSnapshots.length) return;
+		this.flipSnapshots.forEach((snapshot) => {
+			const el = snapshot.el;
+			const { top, left } = el.getBoundingClientRect();
+			const dx = snapshot.left - left;
+			const dy = snapshot.top - top;
+			if (dx || dy) {
+				el.style.transform = `translate(${dx}px,${dy}px)`;
+				el.style.transitionDuration = "0s";
+				requestAnimationFrame(() => {
+					el.classList.add(this.animationName);
+					el.style.transform = "";
+					el.style.transitionDuration = "";
+					const onTransitionend = () => {
+						el.classList.remove(this.animationName);
+						el.removeEventListener("transitionend", onTransitionend);
+					};
+					el.addEventListener("transitionend", onTransitionend);
+				});
+			}
+		});
+		this.flipSnapshots = [];
+	}
+};
+//#endregion
+export { FlipAnimation };

package/dist/utils/focus.js

@@ -0,0 +1,40 @@
+import { FocusType } from "../engine/modules/editor/state.js";
+//#region src/utils/focus.ts
+function isFocus(focusTable, focusType, tableId, columnId = null) {
+	if (!focusTable || tableId !== focusTable.tableId) return false;
+	switch (focusType) {
+		case FocusType.tableName:
+		case FocusType.tableLogicalName:
+		case FocusType.tableComment: return focusType === focusTable.focusType;
+	}
+	return columnId === focusTable.columnId && focusType === focusTable.focusType;
+}
+var isSelectColumn = (focusTable, tableId, columnId) => focusTable?.tableId === tableId && focusTable.selectColumnIds.includes(columnId);
+var isFocusColumn = (focusTable, tableId, columnId) => focusTable?.tableId === tableId && focusTable.columnId === columnId;
+function isEdit(focusTable, focusType, tableId, columnId = null) {
+	if (focusTable?.tableId !== tableId) return false;
+	switch (focusType) {
+		case FocusType.tableName:
+		case FocusType.tableLogicalName:
+		case FocusType.tableComment: return focusType === focusTable.focusType && focusTable.edit;
+	}
+	return columnId === focusTable.columnId && focusType === focusTable.focusType && focusTable.edit;
+}
+function lastCursorFocus(input) {
+	const len = input.value.length;
+	input.selectionStart = len;
+	input.selectionEnd = len;
+	input.focus();
+}
+var toSharedFocus = (focusTable) => focusTable ? {
+	tableId: focusTable.tableId,
+	columnId: focusTable.columnId,
+	focusType: focusTable.focusType
+} : null;
+var toSharedFocusKey = (focus) => focus ? JSON.stringify([
+	focus.tableId,
+	focus.columnId,
+	focus.focusType
+]) : "";
+//#endregion
+export { isEdit, isFocus, isFocusColumn, isSelectColumn, lastCursorFocus, toSharedFocus, toSharedFocusKey };

package/dist/utils/formatCount.js

@@ -0,0 +1,12 @@
+//#region src/utils/formatCount.ts
+var COUNT_FORMATS = /* @__PURE__ */ new Map();
+function formatCount(locale, count) {
+	let format = COUNT_FORMATS.get(locale);
+	if (!format) {
+		format = new Intl.NumberFormat(locale, { numberingSystem: "latn" });
+		COUNT_FORMATS.set(locale, format);
+	}
+	return format.format(count);
+}
+//#endregion
+export { formatCount };