@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/components/explorer/explorerSearch.js

@@ -0,0 +1,298 @@
+import { arrayHas } from "../../utils/arrayHas.js";
+import { nextTick } from "../../r-html/dist/observable/scheduler.js";
+import { Open } from "../../constants/open.js";
+import { changeOpenMapAction } from "../../engine/modules/editor/atom.actions.js";
+import { localized } from "../localized/Localized.js";
+import { openStatusToast } from "../toast-container/openStatusToast.js";
+import { isTakenOver } from "../../utils/takeover.js";
+import { FindField, FindFieldList, FindTextActionTypes, findMatches, nextReplace, rematchField, resumeRun, treeOrderOf } from "../../utils/find-replace/findMatches.js";
+import { createMatcher } from "../../utils/find-replace/matcher.js";
+import { explorerViewOf } from "./explorerView.js";
+import { isExplorerShown, openExplorer } from "./explorerCommands.js";
+import { toErdTarget } from "../erd/erdTarget.js";
+import { toReplaceActions } from "../../utils/find-replace/replaceActions.js";
+import { jumpTo } from "./explorerNavigation.js";
+import { matchAncestorIds, matchRowId } from "./explorerTree.js";
+import { showNextMatchAction$ } from "./matchTarget.js";
+var runtimes = /* @__PURE__ */ new WeakMap();
+function searchRuntimeOf(store) {
+	let runtime = runtimes.get(store);
+	if (!runtime) {
+		runtime = {
+			matcher: null,
+			pendingSearch: null,
+			replacing: false,
+			stale: false,
+			run: null,
+			stopped: false,
+			focusTaken: 0
+		};
+		runtimes.set(store, runtime);
+	}
+	return runtime;
+}
+var isTextAction = arrayHas(FindTextActionTypes);
+var isSameMatch = (a, b) => a.field === b.field && a.id === b.id && a.start === b.start;
+var isSearching = (store) => explorerViewOf(store).query.length > 0;
+function statusText(status, { t }) {
+	if (status === "noMoreMatches") return t("findReplace.noMoreMatches");
+	if (status === "noChanges") return t("findReplace.noChanges");
+	return t("findReplace.replaced", { count: status.replaced });
+}
+function countText(store, i18n) {
+	const { query, error, matches, current, status } = explorerViewOf(store);
+	const { t } = i18n;
+	if (status) return statusText(status, i18n);
+	if (error === "invalid") return t("findReplace.invalidRegex");
+	if (!query) return "";
+	if (!matches.length) return t("findReplace.noResults");
+	if (current === -1) return t("findReplace.matchCount", { count: matches.length });
+	return t("findReplace.position", {
+		current: current + 1,
+		total: matches.length
+	});
+}
+var sameIds = (a, b) => a.length === b.length && a.every((id, index) => id === b[index]);
+var sameOrder = (a, b) => a !== null && sameIds(a.tableIds, b.tableIds) && sameIds(a.tableGroupIds, b.tableGroupIds);
+function inWalkOrder(matches, { tableIds, tableGroupIds }) {
+	const tableRank = new Map(tableIds.map((id, index) => [id, index]));
+	const groupRank = new Map(tableGroupIds.map((id, index) => [id, tableIds.length + index]));
+	const last = tableIds.length + tableGroupIds.length;
+	const rankOf = ({ field, id, tableId }) => {
+		if (field === FindField.memo) return last;
+		if (field === FindField.tableGroupName) return groupRank.get(id) ?? last;
+		return tableRank.get(tableId) ?? last;
+	};
+	return matches.map((match, index) => ({
+		match,
+		index,
+		rank: rankOf(match)
+	})).sort((a, b) => a.rank - b.rank || a.index - b.index).map(({ match }) => match);
+}
+function newRun(store) {
+	const view = explorerViewOf(store);
+	const runtime = searchRuntimeOf(store);
+	runtime.run = null;
+	runtime.stopped = false;
+	const order = treeOrderOf(store.state);
+	if (!sameOrder(view.order, order) && view.matches.length) {
+		const current = view.matches[view.current];
+		view.matches = inWalkOrder(view.matches, order);
+		view.current = current ? view.matches.indexOf(current) : -1;
+	}
+	view.order = order;
+}
+function cancelPendingSearch(store) {
+	const runtime = searchRuntimeOf(store);
+	runtime.pendingSearch !== null && clearTimeout(runtime.pendingSearch);
+	runtime.pendingSearch = null;
+}
+function refresh(store, keepCurrent = false) {
+	const view = explorerViewOf(store);
+	const runtime = searchRuntimeOf(store);
+	cancelPendingSearch(store);
+	runtime.stale = false;
+	if (!runtime.run || !view.order) view.order = treeOrderOf(store.state);
+	const previous = view.matches[view.current];
+	const created = createMatcher(view.query, view);
+	runtime.matcher = created.matcher;
+	view.error = created.error;
+	view.matches = runtime.matcher ? findMatches(store.state, runtime.matcher, view.fields, view.order) : [];
+	view.current = keepCurrent && previous ? view.matches.findIndex((match) => isSameMatch(match, previous)) : -1;
+}
+function search(store) {
+	explorerViewOf(store).searchCollapsed = {};
+	newRun(store);
+	refresh(store);
+}
+function searchEdited(store) {
+	explorerViewOf(store).status = null;
+	refresh(store, true);
+}
+function searchPending(store) {
+	if (searchRuntimeOf(store).pendingSearch === null) return false;
+	search(store);
+	return true;
+}
+function requestSearchFocus(store) {
+	const view = explorerViewOf(store);
+	view.focusRequest++;
+	const request = view.focusRequest;
+	nextTick(() => {
+		const runtime = searchRuntimeOf(store);
+		if (runtime.focusTaken < request) runtime.focusTaken = request;
+	});
+}
+function takeSearchFocus(store) {
+	const view = explorerViewOf(store);
+	const runtime = searchRuntimeOf(store);
+	if (runtime.focusTaken >= view.focusRequest) return false;
+	runtime.focusTaken = view.focusRequest;
+	return true;
+}
+var SEARCH_DIALOGS = [
+	Open.tableProperties,
+	Open.themeBuilder,
+	Open.exportImage,
+	Open.localePicker,
+	Open.mapColumns
+];
+var hasSearchDialog = (store) => SEARCH_DIALOGS.some((name) => store.state.editor.openMap[name]);
+function closeDialogs(store) {
+	if (!hasSearchDialog(store)) return;
+	store.dispatchSync(changeOpenMapAction(Object.fromEntries(SEARCH_DIALOGS.map((name) => [name, false]))));
+}
+function focusSearch(store) {
+	closeDialogs(store);
+	requestSearchFocus(store);
+}
+function openSearch(store, emitter) {
+	if (isTakenOver(store.state)) return;
+	const view = explorerViewOf(store);
+	const runtime = searchRuntimeOf(store);
+	runtime.stale = false;
+	closeDialogs(store);
+	openExplorer(store);
+	view.status = null;
+	search(store);
+	if (!isExplorerShown(store)) {
+		openStatusToast(emitter, {
+			key: "explorer.tooNarrow",
+			title: localized("explorer.tooNarrow")
+		});
+		return;
+	}
+	requestSearchFocus(store);
+}
+function revealMatch(store, match) {
+	const view = explorerViewOf(store);
+	const hidden = matchAncestorIds(match).filter((id) => view.searchCollapsed[id]);
+	if (!hidden.length) return;
+	const next = { ...view.searchCollapsed };
+	hidden.forEach((id) => delete next[id]);
+	view.searchCollapsed = next;
+}
+function goTo(store, index) {
+	const view = explorerViewOf(store);
+	const match = view.matches[index];
+	if (!match) return;
+	view.current = index;
+	view.status = null;
+	view.activeId = matchRowId(match);
+	revealMatch(store, match);
+	newRun(store);
+	jumpTo(store, toErdTarget(match));
+}
+function goToNext(store) {
+	searchPending(store);
+	const { matches, current } = explorerViewOf(store);
+	const total = matches.length;
+	total && goTo(store, current + 1 >= total ? 0 : current + 1);
+}
+function goToPrevious(store) {
+	searchPending(store);
+	const { matches, current } = explorerViewOf(store);
+	const total = matches.length;
+	total && goTo(store, current <= 0 ? total - 1 : current - 1);
+}
+function goToMatch(store, match) {
+	searchPending(store);
+	goTo(store, explorerViewOf(store).matches.findIndex((found) => isSameMatch(found, match)));
+}
+function dispatchOwn(store, actions) {
+	const runtime = searchRuntimeOf(store);
+	runtime.replacing = true;
+	try {
+		store.dispatchSync(actions);
+	} finally {
+		runtime.replacing = false;
+	}
+}
+function replaceOne(store) {
+	const view = explorerViewOf(store);
+	const runtime = searchRuntimeOf(store);
+	searchPending(store) || refresh(store, true);
+	const began = resumeRun(store.state, view.fields, runtime.run, view.order ?? void 0);
+	const match = view.matches[view.current];
+	const { matcher } = runtime;
+	if (!match || !matcher) {
+		if (runtime.stopped && began) {
+			view.status = "noMoreMatches";
+			return;
+		}
+		goToNext(store);
+		return;
+	}
+	const { value } = matcher.replace(match.text, view.replacement, match.start);
+	const { actions } = toReplaceActions(view.matches, matcher, view.replacement, match);
+	const after = rematchField(view.matches, matcher, match, value);
+	const step = nextReplace(after, match, value, began);
+	const next = after[step.index];
+	const batch = next ? [...actions, showNextMatchAction$(next, match, value)] : actions;
+	batch.length && dispatchOwn(store, batch);
+	view.matches = after;
+	runtime.run = step.run;
+	runtime.stopped = !next && after.length > 0;
+	view.status = runtime.stopped ? "noMoreMatches" : null;
+	view.current = step.index;
+	if (next) {
+		view.activeId = matchRowId(next);
+		revealMatch(store, next);
+	}
+}
+function replaceAll(store) {
+	const view = explorerViewOf(store);
+	const runtime = searchRuntimeOf(store);
+	searchPending(store) || refresh(store, true);
+	newRun(store);
+	const { matcher } = runtime;
+	if (!matcher || !view.matches.length) return;
+	const { actions, replaced } = toReplaceActions(view.matches, matcher, view.replacement);
+	actions.length && dispatchOwn(store, actions);
+	refresh(store);
+	view.status = replaced ? { replaced } : "noChanges";
+}
+function setQuery(store, query) {
+	const view = explorerViewOf(store);
+	const runtime = searchRuntimeOf(store);
+	view.query = query;
+	view.status = null;
+	if (!view.regex) return search(store);
+	newRun(store);
+	cancelPendingSearch(store);
+	runtime.pendingSearch = setTimeout(() => {
+		runtime.pendingSearch = null;
+		isExplorerShown(store) ? search(store) : runtime.stale = true;
+	}, 150);
+}
+function setReplacement(store, replacement) {
+	explorerViewOf(store).replacement = replacement;
+}
+function toggleOption(store, key) {
+	const view = explorerViewOf(store);
+	view[key] = !view[key];
+	if (key === "preserveCase") {
+		const runtime = searchRuntimeOf(store);
+		runtime.matcher = createMatcher(view.query, view).matcher;
+		return;
+	}
+	view.status = null;
+	search(store);
+}
+function toggleField(store, field) {
+	const view = explorerViewOf(store);
+	view.fields = view.fields.includes(field) ? view.fields.filter((value) => value !== field) : FindFieldList.filter((value) => value === field || view.fields.includes(value));
+	view.status = null;
+	search(store);
+}
+function noteBatch(store, actions) {
+	const runtime = searchRuntimeOf(store);
+	if (runtime.replacing) return false;
+	runtime.stale ||= actions.some(({ type }) => isTextAction(type));
+	return runtime.stale;
+}
+function searchIfStale(store) {
+	if (searchRuntimeOf(store).stale && isSearching(store) && isExplorerShown(store)) searchEdited(store);
+}
+//#endregion
+export { cancelPendingSearch, countText, focusSearch, goToMatch, goToNext, goToPrevious, hasSearchDialog, isSearching, noteBatch, openSearch, replaceAll, replaceOne, searchIfStale, searchRuntimeOf, setQuery, setReplacement, takeSearchFocus, toggleField, toggleOption };

package/dist/components/explorer/explorerTree.js

@@ -0,0 +1,331 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnUIKey, OrderType } from "../../constants/schema.js";
+import { bHas } from "../../utils/bit.js";
+import { isMemoShown } from "../../utils/memo.js";
+import { orderByNameASC } from "../../utils/tableName.js";
+import { getTableIndexIds } from "../../utils/tableKeys.js";
+import { getTableGroupMembers, isTableGroupShown } from "../../utils/tableGroup.js";
+import { FindField, isTableLogicalName } from "../../utils/find-replace/findMatches.js";
+import { TABLES_FOLDER_ID } from "./explorerView.js";
+//#region src/components/explorer/explorerTree.ts
+var TABLE_GROUPS_FOLDER_ID = "f:tableGroups";
+var MEMOS_FOLDER_ID = "f:memos";
+var tableRowId = (tableId) => `t:${tableId}`;
+var columnsFolderId = (tableId) => `${tableRowId(tableId)}/f:columns`;
+var indexesFolderId = (tableId) => `${tableRowId(tableId)}/f:indexes`;
+var foreignKeysFolderId = (tableId) => `${tableRowId(tableId)}/f:foreignKeys`;
+var columnRowId = (columnId) => `c:${columnId}`;
+var indexRowId = (indexId) => `i:${indexId}`;
+var foreignKeyRowId = (relationshipId) => `r:${relationshipId}`;
+var groupRowId = (tableGroupId) => `g:${tableGroupId}`;
+var groupTableRowId = (tableGroupId, tableId) => `${groupRowId(tableGroupId)}/${tableRowId(tableId)}`;
+var memoRowId = (memoId) => `m:${memoId}`;
+var excerptRowId = (parentId, { field, start }) => `${parentId}/x:${field}:${start}`;
+var folder = (id, name, children) => {
+	const list = children();
+	return list.length ? {
+		id,
+		hasChildren: true,
+		children: () => list,
+		data: {
+			kind: "folder",
+			folder: name,
+			count: list.length
+		}
+	} : null;
+};
+var present = (nodes) => nodes.filter((node) => node !== null);
+var firstLine = (text) => text.split(/\r?\n/, 1)[0].trim();
+var leaf = (id, data) => ({
+	id,
+	hasChildren: false,
+	children: () => [],
+	data
+});
+var columnData = (tableId, column) => ({
+	kind: "column",
+	tableId,
+	columnId: column.id,
+	name: column.name,
+	logicalName: column.logicalName,
+	dataType: column.dataType,
+	primaryKey: bHas(column.ui.keys, ColumnUIKey.primaryKey),
+	foreignKey: bHas(column.ui.keys, ColumnUIKey.foreignKey)
+});
+function columnNodes(state, table) {
+	return query(state.collections).collection("tableColumnEntities").selectByIds(table.columnIds).map((column) => leaf(columnRowId(column.id), columnData(table.id, column)));
+}
+function indexData(state, tableId, index) {
+	const { collections } = state;
+	const columns = query(collections).collection("tableColumnEntities");
+	return {
+		kind: "index",
+		tableId,
+		indexId: index.id,
+		name: index.name,
+		unique: index.unique,
+		columns: query(collections).collection("indexColumnEntities").selectByIds(index.indexColumnIds).map((indexColumn) => {
+			const name = columns.selectById(indexColumn.columnId)?.name ?? "";
+			return indexColumn.orderType === OrderType.DESC ? `${name} DESC` : name;
+		}).join(", ")
+	};
+}
+function indexNodes(state, table) {
+	return query(state.collections).collection("indexEntities").selectByIds(getTableIndexIds(state, table.id)).map((index) => leaf(indexRowId(index.id), indexData(state, table.id, index)));
+}
+function foreignKeyNodes(state, table) {
+	const { doc, collections } = state;
+	const columns = query(collections).collection("tableColumnEntities");
+	const tables = query(collections).collection("tableEntities");
+	const names = (ids) => columns.selectByIds(ids).map((column) => column.name).join(", ");
+	return query(collections).collection("relationshipEntities").selectByIds(doc.relationshipIds).filter((relationship) => relationship.end.tableId === table.id && doc.tableIds.includes(relationship.start.tableId)).map((relationship) => leaf(foreignKeyRowId(relationship.id), {
+		kind: "foreignKey",
+		relationshipId: relationship.id,
+		tableId: table.id,
+		identification: relationship.identification,
+		columns: names(relationship.end.columnIds),
+		parent: tables.selectById(relationship.start.tableId)?.name ?? "",
+		parentColumns: names(relationship.start.columnIds)
+	}));
+}
+var tableData = (table) => ({
+	kind: "table",
+	tableId: table.id,
+	name: table.name,
+	logicalName: table.logicalName
+});
+function tableNode(state, table) {
+	return {
+		id: tableRowId(table.id),
+		hasChildren: true,
+		children: () => present([
+			folder(columnsFolderId(table.id), "columns", () => columnNodes(state, table)),
+			folder(indexesFolderId(table.id), "indexes", () => indexNodes(state, table)),
+			folder(foreignKeysFolderId(table.id), "foreignKeys", () => foreignKeyNodes(state, table))
+		]),
+		data: tableData(table)
+	};
+}
+var tableGroupData = (group) => ({
+	kind: "tableGroup",
+	tableGroupId: group.id,
+	name: group.name,
+	color: group.color
+});
+function tableGroupNodes(state) {
+	const { doc, collections } = state;
+	const groupMembers = getTableGroupMembers(state);
+	return query(collections).collection("tableGroupEntities").selectByIds(doc.tableGroupIds).sort(orderByNameASC).map((group) => {
+		const members = () => [...groupMembers.get(group.id) ?? []].sort(orderByNameASC).map((table) => leaf(groupTableRowId(group.id, table.id), {
+			kind: "groupTable",
+			tableGroupId: group.id,
+			tableId: table.id,
+			name: table.name,
+			logicalName: table.logicalName
+		}));
+		return {
+			id: groupRowId(group.id),
+			hasChildren: groupMembers.has(group.id),
+			children: members,
+			data: tableGroupData(group)
+		};
+	});
+}
+var memoData = (memo) => ({
+	kind: "memo",
+	memoId: memo.id,
+	text: firstLine(memo.value)
+});
+function memoNodes(state) {
+	const { doc, collections } = state;
+	return query(collections).collection("memoEntities").selectByIds(doc.memoIds).map((memo) => leaf(memoRowId(memo.id), memoData(memo)));
+}
+function buildExplorerTree(state) {
+	const { doc, collections } = state;
+	return present([
+		folder(TABLES_FOLDER_ID, "tables", () => query(collections).collection("tableEntities").selectByIds(doc.tableIds).sort(orderByNameASC).map((table) => tableNode(state, table))),
+		isTableGroupShown(state) ? folder(TABLE_GROUPS_FOLDER_ID, "tableGroups", () => tableGroupNodes(state)) : null,
+		isMemoShown(state) ? folder(MEMOS_FOLDER_ID, "memos", () => memoNodes(state)) : null
+	]);
+}
+function matchRowId(match) {
+	const { field, id } = match;
+	switch (field) {
+		case FindField.tableName: return tableRowId(id);
+		case FindField.columnName: return columnRowId(id);
+		case FindField.logicalName: return isTableLogicalName(match) ? tableRowId(id) : columnRowId(id);
+		case FindField.indexName: return indexRowId(id);
+		case FindField.tableGroupName: return groupRowId(id);
+		case FindField.tableComment: return excerptRowId(tableRowId(id), match);
+		case FindField.columnComment: return excerptRowId(columnRowId(id), match);
+		case FindField.memo: return excerptRowId(memoRowId(id), match);
+	}
+}
+function matchAncestorIds(match) {
+	const { field, id, tableId } = match;
+	switch (field) {
+		case FindField.tableName: return [TABLES_FOLDER_ID];
+		case FindField.logicalName: return isTableLogicalName(match) ? [TABLES_FOLDER_ID] : [
+			TABLES_FOLDER_ID,
+			tableRowId(tableId),
+			columnsFolderId(tableId)
+		];
+		case FindField.tableComment: return [TABLES_FOLDER_ID, tableRowId(id)];
+		case FindField.columnName: return [
+			TABLES_FOLDER_ID,
+			tableRowId(tableId),
+			columnsFolderId(tableId)
+		];
+		case FindField.columnComment: return [
+			TABLES_FOLDER_ID,
+			tableRowId(tableId),
+			columnsFolderId(tableId),
+			columnRowId(id)
+		];
+		case FindField.indexName: return [
+			TABLES_FOLDER_ID,
+			tableRowId(tableId),
+			indexesFolderId(tableId)
+		];
+		case FindField.tableGroupName: return [TABLE_GROUPS_FOLDER_ID];
+		case FindField.memo: return [MEMOS_FOLDER_ID, memoRowId(id)];
+	}
+}
+var excerpt = (parentId, match) => leaf(excerptRowId(parentId, match), {
+	kind: "excerpt",
+	match
+});
+var branch = (id, data, list) => list.length ? {
+	id,
+	hasChildren: true,
+	children: () => list,
+	data
+} : leaf(id, data);
+function searchTableNode(state, hits) {
+	const { table } = hits;
+	const base = tableRowId(table.id);
+	const columns = query(state.collections).collection("tableColumnEntities");
+	const indexes = query(state.collections).collection("indexEntities");
+	return branch(base, {
+		...tableData(table),
+		matches: hits.name
+	}, present([
+		...hits.comment.map((match) => excerpt(base, match)),
+		folder(columnsFolderId(table.id), "columns", () => columns.selectByIds([...hits.columns.keys()]).map((column) => {
+			const found = hits.columns.get(column.id);
+			const id = columnRowId(column.id);
+			return branch(id, {
+				...columnData(table.id, column),
+				matches: found.name
+			}, found.comment.map((match) => excerpt(id, match)));
+		})),
+		folder(indexesFolderId(table.id), "indexes", () => indexes.selectByIds(getTableIndexIds(state, table.id).filter((id) => hits.indexes.has(id))).map((index) => leaf(indexRowId(index.id), {
+			...indexData(state, table.id, index),
+			matches: hits.indexes.get(index.id)
+		})))
+	]));
+}
+function gatherHits(state, matches) {
+	const { doc, collections } = state;
+	const tables = query(collections).collection("tableEntities");
+	const shownTables = new Set(doc.tableIds);
+	const shownGroups = new Set(doc.tableGroupIds);
+	const shownMemos = new Set(doc.memoIds);
+	const tableHits = /* @__PURE__ */ new Map();
+	const groupHits = /* @__PURE__ */ new Map();
+	const memoHits = /* @__PURE__ */ new Map();
+	const add = (map, key, match) => {
+		const list = map.get(key);
+		list ? list.push(match) : map.set(key, [match]);
+	};
+	for (const match of matches) {
+		if (match.field === FindField.tableGroupName) {
+			shownGroups.has(match.id) && add(groupHits, match.id, match);
+			continue;
+		}
+		if (match.field === FindField.memo) {
+			shownMemos.has(match.id) && add(memoHits, match.id, match);
+			continue;
+		}
+		const table = shownTables.has(match.tableId) ? tables.selectById(match.tableId) : void 0;
+		if (!table) continue;
+		let hits = tableHits.get(table.id);
+		if (!hits) {
+			hits = {
+				table,
+				name: [],
+				comment: [],
+				columns: /* @__PURE__ */ new Map(),
+				indexes: /* @__PURE__ */ new Map()
+			};
+			tableHits.set(table.id, hits);
+		}
+		switch (match.field) {
+			case FindField.tableName:
+				hits.name.push(match);
+				break;
+			case FindField.tableComment:
+				hits.comment.push(match);
+				break;
+			case FindField.indexName:
+				add(hits.indexes, match.id, match);
+				break;
+			default: {
+				if (isTableLogicalName(match)) {
+					hits.name.push(match);
+					break;
+				}
+				if (!table.columnIds.includes(match.id)) break;
+				let column = hits.columns.get(match.id);
+				if (!column) {
+					column = {
+						name: [],
+						comment: []
+					};
+					hits.columns.set(match.id, column);
+				}
+				match.field === FindField.columnComment ? column.comment.push(match) : column.name.push(match);
+			}
+		}
+	}
+	return {
+		tableHits,
+		groupHits,
+		memoHits
+	};
+}
+function buildSearchTree(state, matches) {
+	const { collections } = state;
+	const { tableHits, groupHits, memoHits } = gatherHits(state, matches);
+	const groups = query(collections).collection("tableGroupEntities");
+	const memos = query(collections).collection("memoEntities");
+	const roots = present([
+		folder(TABLES_FOLDER_ID, "tables", () => [...tableHits.values()].map((hits) => searchTableNode(state, hits))),
+		folder(TABLE_GROUPS_FOLDER_ID, "tableGroups", () => groups.selectByIds([...groupHits.keys()]).map((group) => leaf(groupRowId(group.id), {
+			...tableGroupData(group),
+			matches: groupHits.get(group.id)
+		}))),
+		folder(MEMOS_FOLDER_ID, "memos", () => memos.selectByIds([...memoHits.keys()]).map((memo) => {
+			const id = memoRowId(memo.id);
+			return branch(id, memoData(memo), memoHits.get(memo.id).map((match) => excerpt(id, match)));
+		}))
+	]);
+	const branchIds = [];
+	const collect = (nodes) => nodes.forEach((node) => {
+		if (!node.hasChildren) return;
+		branchIds.push(node.id);
+		collect(node.children());
+	});
+	collect(roots);
+	return {
+		roots,
+		branchIds
+	};
+}
+function searchExpanded(branchIds, collapsed) {
+	const expanded = {};
+	for (const id of branchIds) if (!collapsed[id]) expanded[id] = true;
+	return expanded;
+}
+//#endregion
+export { buildExplorerTree, buildSearchTree, matchAncestorIds, matchRowId, searchExpanded };

package/dist/components/explorer/explorerView.js

@@ -0,0 +1,46 @@
+import { observable } from "../../r-html/dist/observable/index.js";
+import { DEFAULT_FIND_FIELDS } from "../../utils/find-replace/findMatches.js";
+//#region src/components/explorer/explorerView.ts
+var TABLES_FOLDER_ID = "f:tables";
+var views = /* @__PURE__ */ new WeakMap();
+var scrolls = /* @__PURE__ */ new WeakMap();
+function explorerViewOf(store) {
+	let view = views.get(store);
+	if (!view) {
+		view = observable({
+			open: false,
+			zenReveal: false,
+			width: 260,
+			expanded: { [TABLES_FOLDER_ID]: true },
+			activeId: null,
+			query: "",
+			replacement: "",
+			matchCase: false,
+			wholeWord: false,
+			regex: false,
+			preserveCase: false,
+			fields: [...DEFAULT_FIND_FIELDS],
+			replaceOpen: false,
+			scopesOpen: false,
+			current: -1,
+			status: null,
+			matches: [],
+			error: null,
+			order: null,
+			searchCollapsed: {},
+			focusRequest: 0
+		}, { shallow: true });
+		views.set(store, view);
+	}
+	return view;
+}
+function explorerScrollOf(store) {
+	let scroll = scrolls.get(store);
+	if (!scroll) {
+		scroll = { top: 0 };
+		scrolls.set(store, scroll);
+	}
+	return scroll;
+}
+//#endregion
+export { TABLES_FOLDER_ID, explorerScrollOf, explorerViewOf };

package/dist/components/explorer/matchTarget.d.ts

@@ -1,14 +1,7 @@
-import { ErdTarget } from '../erd/goToErdTarget';
 import { EngineContext } from '../../engine/context';
 import { GeneratorAction } from '../../engine/generator.actions';
 import { RootState } from '../../engine/state';
 import { FindMatch } from '../../utils/find-replace';
-/**
- * Where on the ERD canvas a match's text is edited: its table, column cell,
- * memo or table group, with the match, which a cell too wide is scrolled to
- * by. An index goes to its table, a logical name to the cell the view draws.
- */
-export declare function toErdTarget(match: FindMatch): ErdTarget;
 /**
  * The state as a jump measures it once a replacement is in: the field holding
  * the new text at the width its reducer gives it, a name a logical name derives