@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/konva/scene/columnDropTarget.js

@@ -0,0 +1,43 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { getVisibleColumnIds, getVisibleIds } from "./viewLayout.js";
+import { getColumnRect, getTableRect } from "./metrics.js";
+import { getCullingRect, isTableVisible } from "./viewport.js";
+import { isEqual } from "es-toolkit";
+//#region src/konva/scene/columnDropTarget.ts
+var APPEND_BAND = 8;
+function findColumnDropTarget(state, point, source = "document") {
+	const { collections } = state;
+	const cullingRect = getCullingRect(state, source);
+	const cards = query(collections).collection("tableEntities").selectByIds(getVisibleIds(state, source).tableIds).filter((table) => isTableVisible(cullingRect, state, table, source)).sort((a, b) => a.ui.zIndex - b.ui.zIndex).reverse().map((table) => ({
+		table,
+		rect: getTableRect(state, table, source)
+	}));
+	const within = (rect, band, lane) => point.x >= rect.x - lane && point.x <= rect.x + rect.width && point.y >= rect.y && point.y <= rect.y + rect.height + band;
+	const card = cards.find(({ rect }) => within(rect, 0, 0)) ?? cards.find(({ rect }) => within(rect, 0, 24)) ?? cards.find(({ rect }) => within(rect, APPEND_BAND, 24));
+	if (!card) return null;
+	const { table } = card;
+	const columnIds = getVisibleColumnIds(state, table, source);
+	const append = {
+		tableId: table.id,
+		columnId: null,
+		index: columnIds.length
+	};
+	if (!columnIds.length) return append;
+	const firstRow = getColumnRect(state, table, 0, source);
+	if (point.y < firstRow.y) return null;
+	const index = Math.floor((point.y - firstRow.y) / firstRow.height);
+	if (index >= columnIds.length) return append;
+	return {
+		tableId: table.id,
+		columnId: columnIds[index],
+		index
+	};
+}
+function isDropInPlace({ collections }, { tableId, columnIds }, target) {
+	if (target.columnId !== null) return columnIds.includes(target.columnId);
+	if (target.tableId !== tableId) return false;
+	const table = query(collections).collection("tableEntities").selectById(tableId);
+	return isEqual(table?.columnIds.slice(-columnIds.length), columnIds);
+}
+//#endregion
+export { findColumnDropTarget, isDropInPlace };

package/dist/konva/scene/contentBounds.js

@@ -0,0 +1,48 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { isMemoShown } from "../../utils/memo.js";
+import { getVisibleIds } from "./viewLayout.js";
+import { getMemoRect, getTableRect, unionRect } from "./metrics.js";
+import { growTableGroupBox, isTableGroupShown, seedTableGroupBoxes } from "../../utils/tableGroup.js";
+//#region src/konva/scene/contentBounds.ts
+function getContentRect(state) {
+	return getContentRectAfter(state, []);
+}
+function hasContent(state) {
+	const { doc } = state;
+	return doc.tableIds.length > 0 || doc.memoIds.length > 0 && isMemoShown(state) || doc.tableGroupIds.length > 0 && isTableGroupShown(state);
+}
+function getSceneContentRect(state, source = "document") {
+	return getContentRectAfter(state, [], source);
+}
+function getContentRects(state, moves = [], source = "document", groupRects = []) {
+	const { collections, doc } = state;
+	const { tableIds, memoIds, tableGroupIds } = source === "document" ? doc : getVisibleIds(state, source);
+	const shownMemoIds = isMemoShown(state) ? memoIds : [];
+	const moved = new Map(moves.map((move) => [move.id, move]));
+	const groups = tableGroupIds.length && isTableGroupShown(state) ? query(collections).collection("tableGroupEntities").selectByIds(tableGroupIds) : [];
+	const groupBoxes = seedTableGroupBoxes(groups);
+	const placedGroups = new Map(groupRects.map(({ id, ...rect }) => [id, rect]));
+	const tables = query(collections).collection("tableEntities").selectByIds(tableIds);
+	const memos = query(collections).collection("memoEntities").selectByIds(shownMemoIds);
+	return [
+		...tables.map((table) => {
+			const rect = getTableRect(state, table, source);
+			const move = moved.get(table.id);
+			if (move) return {
+				...rect,
+				x: move.x,
+				y: move.y
+			};
+			growTableGroupBox(groupBoxes, table, rect);
+			return rect;
+		}),
+		...memos.map(getMemoRect),
+		...groups.map((group) => placedGroups.get(group.id) ?? groupBoxes.get(group.id))
+	];
+}
+function getContentRectAfter(state, moves, source = "document", groupRects = []) {
+	const boxes = getContentRects(state, moves, source, groupRects);
+	return boxes.length ? boxes.reduce(unionRect) : null;
+}
+//#endregion
+export { getContentRect, getContentRectAfter, getContentRects, getSceneContentRect, hasContent, unionRect };

package/dist/konva/scene/fitZoom.d.ts

@@ -1,4 +1,5 @@
 import { Viewport } from '../../engine/modules/editor/state';
+import { RxStore } from '../../engine/rx-store';
 import { Rect } from './metrics';
 /**
  * Scene units left around the content when a fit takes it in, so a table at
@@ -13,4 +14,10 @@ export declare const PREVIEW_ZOOM_MAX = 0.7;
  * the floor every zoom has and a ceiling, the preview's unless a view names its own.
  */
 export declare function previewZoomLevel(content: Rect, viewport: Viewport, maxZoom?: number): number;
+/**
+ * Fits everything the document draws into the screen and centres it, no closer
+ * than the zoom given. A screen not yet measured or a document holding nothing
+ * leaves the zoom and the origin as they are.
+ */
+export declare function fitDocument(store: RxStore, maxZoom?: number): void;
 //# sourceMappingURL=fitZoom.d.ts.map

package/dist/konva/scene/fitZoom.js

@@ -0,0 +1,31 @@
+import { CANVAS_ZOOM_MAX, CANVAS_ZOOM_MIN } from "../../constants/schema.js";
+import { getContentRect } from "./contentBounds.js";
+import { changeZoomLevelAction, hasViewport, scrollToAction } from "../../engine/modules/settings/atom.actions.js";
+import { getScrollToCenter, getViewTransform } from "../../components/erd/minimap/minimapGeometry.js";
+import { clamp } from "es-toolkit";
+import { round } from "es-toolkit/compat";
+var PREVIEW_ZOOM_MAX = .7;
+function previewZoomLevel(content, viewport, maxZoom = PREVIEW_ZOOM_MAX) {
+	const fit = Math.min(viewport.width / (content.width + 200), viewport.height / (content.height + 200));
+	return clamp(round(fit, 2), CANVAS_ZOOM_MIN, maxZoom);
+}
+function fitDocument(store, maxZoom = CANVAS_ZOOM_MAX) {
+	const { state } = store;
+	const { viewport } = state.editor;
+	const content = getContentRect(state);
+	if (!content || !hasViewport(viewport)) return;
+	const zoomLevel = previewZoomLevel(content, viewport, maxZoom);
+	const origin = getScrollToCenter({
+		...getViewTransform(state),
+		zoomLevel
+	}, {
+		x: content.x + content.width / 2,
+		y: content.y + content.height / 2
+	});
+	store.dispatchSync(changeZoomLevelAction({ value: zoomLevel }), scrollToAction({
+		originX: origin.x,
+		originY: origin.y
+	}));
+}
+//#endregion
+export { PREVIEW_ZOOM_MAX, fitDocument, previewZoomLevel };

package/dist/konva/scene/konvaFlip.js

@@ -0,0 +1,125 @@
+import { beginAnimation, endAnimation, onBeforeFlush } from "../../r-html-konva/dist/batchDraw.js";
+import { Easings, Tween } from "konva/lib/Tween";
+//#region src/konva/scene/konvaFlip.ts
+var FLIP_DURATION = .3;
+var CLOSE_TIMEOUT = 500;
+var FADE = "flipFade";
+function invertOffset(node, before) {
+	const after = node.getAbsolutePosition();
+	const scale = node.getAbsoluteScale();
+	return {
+		x: (after.x - before.x) / (scale.x || 1),
+		y: (after.y - before.y) / (scale.y || 1)
+	};
+}
+function createKonvaFlip(nodes) {
+	const moving = /* @__PURE__ */ new Map();
+	const fading = /* @__PURE__ */ new Map();
+	let snapshots = null;
+	let unlisten = null;
+	const run = (running, node, layer, attrs, settle, onUpdate) => {
+		beginAnimation(layer);
+		let closed = false;
+		let timerId = -1;
+		const close = () => {
+			if (closed) return;
+			closed = true;
+			clearTimeout(timerId);
+			running.delete(node);
+			settle();
+			endAnimation(layer);
+		};
+		const tween = new Tween({
+			node,
+			...attrs,
+			duration: FLIP_DURATION,
+			easing: Easings.EaseInOut,
+			onFinish: close,
+			onReset: close
+		});
+		tween.onUpdate = onUpdate;
+		running.set(node, () => {
+			tween.destroy();
+			close();
+		});
+		timerId = setTimeout(() => running.get(node)?.(), CLOSE_TIMEOUT);
+		tween.play();
+	};
+	const start = (node, layer, x, y) => {
+		moving.get(node)?.();
+		node.offsetX(x);
+		node.offsetY(y);
+		run(moving, node, layer, {
+			offsetX: 0,
+			offsetY: 0
+		}, () => {
+			node.offsetX(0);
+			node.offsetY(0);
+		});
+	};
+	const fade = (node, layer) => {
+		fading.get(node)?.();
+		let opacity = node.opacity();
+		let writing = false;
+		const apply = () => {
+			writing = true;
+			node.opacity(opacity * (node.getAttr(FADE) ?? 1));
+			writing = false;
+		};
+		node.on(`opacityChange.${FADE}`, () => {
+			if (!writing) opacity = node.opacity();
+		});
+		node.setAttr(FADE, 0);
+		apply();
+		const settle = () => {
+			node.off(`opacityChange.${FADE}`);
+			node.setAttr(FADE, void 0);
+			apply();
+		};
+		run(fading, node, layer, { [FADE]: 1 }, settle, apply);
+	};
+	const disarm = () => {
+		const taken = snapshots;
+		snapshots = null;
+		unlisten?.();
+		unlisten = null;
+		return taken;
+	};
+	const play = () => {
+		const taken = disarm();
+		if (!taken) return;
+		for (const before of taken) {
+			const { node } = before;
+			const layer = node.getLayer();
+			if (!layer || !node.getStage()) continue;
+			const { x, y } = invertOffset(node, before);
+			if (!x && !y) continue;
+			start(node, layer, x, y);
+		}
+		const known = new Set(taken.map(({ node }) => node));
+		for (const node of nodes()) {
+			const layer = node.getLayer();
+			if (known.has(node) || !layer || !node.getStage()) continue;
+			fade(node, layer);
+		}
+	};
+	return {
+		snapshot() {
+			snapshots = nodes().map((node) => {
+				const { x, y } = node.getAbsolutePosition();
+				return {
+					node,
+					x,
+					y
+				};
+			});
+			unlisten ??= onBeforeFlush(play);
+		},
+		cancel() {
+			disarm();
+			[...moving.values(), ...fading.values()].forEach((stop) => stop());
+		}
+	};
+}
+//#endregion
+export { FLIP_DURATION, createKonvaFlip };

package/dist/konva/scene/metrics.js

@@ -0,0 +1,59 @@
+import { getTablePoint, getVisibleColumnIds } from "./viewLayout.js";
+import { calcMemoHeight, calcMemoWidth } from "../../utils/calcMemo.js";
+import { calcTableWidths, calcViewTableWidths, tableHeaderHeight, tableRowHeight } from "../../utils/calcTable.js";
+import { tableToObjectPoint } from "../../utils/draw-relationship/calc.js";
+//#region src/konva/scene/metrics.ts
+function unionRect(a, b) {
+	const x = Math.min(a.x, b.x);
+	const y = Math.min(a.y, b.y);
+	return {
+		x,
+		y,
+		width: Math.max(a.x + a.width, b.x + b.width) - x,
+		height: Math.max(a.y + a.height, b.y + b.height) - y
+	};
+}
+var TABLE_INSET = 9;
+function getTableRect(state, table, source = "document") {
+	const { width, height } = tableToObjectPoint(state, table, source);
+	const { x, y } = getTablePoint(state, table, source);
+	return {
+		x,
+		y,
+		width,
+		height
+	};
+}
+function getTableWidths(state, table, source = "document") {
+	return source === "document" ? calcTableWidths(table, state) : calcViewTableWidths(table, state, getVisibleColumnIds(state, table, source));
+}
+function getColumnRect(state, table, index, source = "document") {
+	const { x, y, width } = getTableRect(state, table, source);
+	const rowHeight = tableRowHeight(source);
+	return {
+		x: x + TABLE_INSET,
+		y: y + TABLE_INSET + tableHeaderHeight(source) + index * rowHeight,
+		width: width - TABLE_INSET * 2,
+		height: rowHeight
+	};
+}
+function getTableHeaderRect(state, table, source = "document") {
+	const { x, y, width } = getTableRect(state, table, source);
+	return {
+		x,
+		y,
+		width,
+		height: TABLE_INSET + tableHeaderHeight(source)
+	};
+}
+function getMemoRect(memo) {
+	const { x, y } = memo.ui;
+	return {
+		x,
+		y,
+		width: calcMemoWidth(memo),
+		height: calcMemoHeight(memo)
+	};
+}
+//#endregion
+export { getColumnRect, getMemoRect, getTableHeaderRect, getTableRect, getTableWidths, unionRect };

package/dist/konva/scene/renderScene.js

@@ -0,0 +1,37 @@
+import { useProvider } from "../../r-html/dist/context/useProvider.js";
+import { appContext } from "../../components/appContext.js";
+import { renderKonva } from "../../r-html-konva/dist/host.js";
+import { localeContext } from "../../components/localeContext.js";
+import { trackSceneHits } from "../../components/erd/hitTest.js";
+import { themeContext } from "../../components/themeContext.js";
+import { Stage } from "konva/lib/Stage";
+//#region src/konva/scene/renderScene.ts
+function renderScene({ app, container, scene, width, height, theme, i18n }) {
+	const stage = new Stage({
+		container,
+		width,
+		height
+	});
+	const target = {
+		host: stage.container(),
+		parentElement: null
+	};
+	const appProvider = useProvider(target, appContext, app);
+	const themeProvider = theme ? useProvider(target, themeContext, theme) : null;
+	const localeProvider = i18n ? useProvider(target, localeContext, i18n) : null;
+	const untrack = trackSceneHits(stage);
+	renderKonva(stage, scene);
+	return {
+		stage,
+		destroy: () => {
+			untrack();
+			renderKonva(stage, null);
+			localeProvider?.destroy();
+			themeProvider?.destroy();
+			appProvider.destroy();
+			stage.destroy();
+		}
+	};
+}
+//#endregion
+export { renderScene };

package/dist/konva/scene/stacking.js

@@ -0,0 +1,13 @@
+//#region src/konva/scene/stacking.ts
+function stackTablesAndMemos(tables, memos) {
+	return [...tables.map((entity) => ({
+		kind: "table",
+		entity
+	})), ...memos.map((entity) => ({
+		kind: "memo",
+		entity
+	}))].sort((a, b) => a.entity.ui.zIndex - b.entity.ui.zIndex);
+}
+var stackedKey = ({ kind, entity }) => `${kind}:${entity.id}`;
+//#endregion
+export { stackTablesAndMemos, stackedKey };

package/dist/konva/scene/viewFreeze.js

@@ -0,0 +1,29 @@
+import { observable } from "../../r-html/dist/observable/index.js";
+import { getSceneContentRect } from "./contentBounds.js";
+import { getSceneTransform } from "./viewport.js";
+//#region src/konva/scene/viewFreeze.ts
+var state = observable({ frozen: {} });
+var sceneKeyOf = (root, source) => `${root.editor.id}:${source}`;
+var frozenOf = (root, source) => state.frozen[sceneKeyOf(root, source)] ?? null;
+function freezeView(root, source = "document") {
+	const { originX, originY } = getSceneTransform(root, source);
+	state.frozen[sceneKeyOf(root, source)] = {
+		content: getSceneContentRect(root, source),
+		origin: {
+			x: originX,
+			y: originY
+		}
+	};
+}
+function thawView(root, source = "document") {
+	Reflect.deleteProperty(state.frozen, sceneKeyOf(root, source));
+}
+function getViewContentRect(root, source = "document") {
+	const frozen = frozenOf(root, source);
+	return frozen ? frozen.content : getSceneContentRect(root, source);
+}
+function getFrozenOrigin(root, source = "document") {
+	return frozenOf(root, source)?.origin ?? null;
+}
+//#endregion
+export { freezeView, getFrozenOrigin, getViewContentRect, sceneKeyOf, thawView };

package/dist/konva/scene/viewLayout.js

@@ -0,0 +1,171 @@
+import { query } from "../../erd-editor-schema/dist/query/index.js";
+import { ColumnUIKey } from "../../constants/schema.js";
+import { observable } from "../../r-html/dist/observable/index.js";
+import { ShowMode } from "../../engine/modules/editor/state.js";
+import { bHas } from "../../utils/bit.js";
+import { getSourceView } from "../../engine/modules/editor/view.js";
+import { isMemoShown } from "../../utils/memo.js";
+//#region src/konva/scene/viewLayout.ts
+var NONE = Object.freeze({
+	tableIds: [],
+	memoIds: [],
+	relationshipIds: [],
+	tableGroupIds: []
+});
+var DIM_OPACITY = .2;
+function getTablePoint(state, table, source = "document") {
+	const { x, y } = getSourceView(state, source)?.positions[table.id] ?? table.ui;
+	return {
+		x,
+		y
+	};
+}
+var isKeyColumn = (keys) => bHas(keys, ColumnUIKey.primaryKey) || bHas(keys, ColumnUIKey.foreignKey);
+function forEachRelationshipEnd(state, visit) {
+	const relationships = query(state.collections).collection("relationshipEntities").selectByIds(state.doc.relationshipIds);
+	for (const { start, end } of relationships) {
+		visit(start.tableId, start.columnIds);
+		visit(end.tableId, end.columnIds);
+	}
+}
+function relationshipColumnIds(state, table) {
+	const ids = /* @__PURE__ */ new Set();
+	forEachRelationshipEnd(state, (tableId, columnIds) => {
+		if (tableId !== table.id) return;
+		columnIds.forEach((id) => ids.add(id));
+	});
+	return ids;
+}
+function relationshipColumnIdsByTable(state) {
+	const byTable = /* @__PURE__ */ new Map();
+	forEachRelationshipEnd(state, (tableId, columnIds) => {
+		const ids = byTable.get(tableId) ?? /* @__PURE__ */ new Set();
+		columnIds.forEach((id) => ids.add(id));
+		byTable.set(tableId, ids);
+	});
+	return byTable;
+}
+function getVisibleColumnIds(state, table, source = "document") {
+	const view = getSourceView(state, source);
+	if (!view || view.showMode === ShowMode.allFields) return table.columnIds;
+	if (view.showMode === ShowMode.nameOnly) return [];
+	const related = relationshipColumnIds(state, table);
+	return query(state.collections).collection("tableColumnEntities").selectByIds(table.columnIds).filter((column) => isKeyColumn(column.ui.keys) || related.has(column.id)).map((column) => column.id);
+}
+function reach(centerIds, relationships) {
+	const centers = new Set(centerIds);
+	const reached = new Set(centers);
+	for (const { start, end } of relationships) {
+		if (centers.has(start.tableId)) reached.add(end.tableId);
+		if (centers.has(end.tableId)) reached.add(start.tableId);
+	}
+	return reached;
+}
+function getReachedTableIds(state, centerIds) {
+	const { doc, collections } = state;
+	const reached = reach(centerIds, query(collections).collection("relationshipEntities").selectByIds(doc.relationshipIds));
+	return doc.tableIds.filter((id) => reached.has(id));
+}
+function getVisibleIds(state, source = "document") {
+	const { doc, collections } = state;
+	if (source === "document") return {
+		tableIds: doc.tableIds,
+		memoIds: isMemoShown(state) ? doc.memoIds : [],
+		relationshipIds: doc.relationshipIds,
+		tableGroupIds: doc.tableGroupIds
+	};
+	const view = getSourceView(state, source);
+	if (!view) return NONE;
+	const relationships = query(collections).collection("relationshipEntities").selectByIds(doc.relationshipIds);
+	const shown = new Set(Object.keys(view.positions));
+	const tableIds = doc.tableIds.filter((id) => shown.has(id));
+	const inView = new Set(tableIds);
+	return {
+		tableIds,
+		memoIds: [],
+		tableGroupIds: [],
+		relationshipIds: relationships.filter(({ start, end }) => inView.has(start.tableId) && inView.has(end.tableId)).map((relationship) => relationship.id)
+	};
+}
+var hover = observable({ tableId: {} });
+var hoverView = /* @__PURE__ */ new Map();
+function dropHover(editorId) {
+	hoverView.delete(editorId);
+	Reflect.deleteProperty(hover.tableId, editorId);
+}
+function setViewHoverTable(root, tableId, source = "document") {
+	const view = getSourceView(root, source);
+	const { id } = root.editor;
+	if (tableId === null || !view) {
+		if (hoverView.get(id)?.kind === source) dropHover(id);
+		return;
+	}
+	hoverView.set(id, view);
+	hover.tableId[id] = tableId;
+}
+function clearViewHoverTable(root, tableId, source = "document") {
+	const { id } = root.editor;
+	if (hover.tableId[id] !== tableId || hoverView.get(id)?.kind !== source) return;
+	dropHover(id);
+}
+function getViewHoverTable(root, source = "document") {
+	const { id } = root.editor;
+	const held = hover.tableId[id];
+	return held !== void 0 && hoverView.get(id) === getSourceView(root, source) ? held : null;
+}
+var pinned = observable({ tableId: {} });
+var pinnedView = /* @__PURE__ */ new Map();
+function dropPin(editorId) {
+	pinnedView.delete(editorId);
+	Reflect.deleteProperty(pinned.tableId, editorId);
+}
+function setViewPinnedTable(root, tableId, source = "document") {
+	const view = getSourceView(root, source);
+	if (!view) return;
+	const { id } = root.editor;
+	if ((pinnedView.get(id) === view ? pinned.tableId[id] : void 0) === tableId) {
+		dropPin(id);
+		return;
+	}
+	pinnedView.set(id, view);
+	pinned.tableId[id] = tableId;
+}
+function clearViewPinnedTable(root, source = "document") {
+	const view = getSourceView(root, source);
+	if (!view) return;
+	const { id } = root.editor;
+	if (pinnedView.get(id) === view) dropPin(id);
+}
+function getViewPinnedTable(root, source = "document") {
+	const { id } = root.editor;
+	const held = pinned.tableId[id];
+	return held !== void 0 && pinnedView.get(id) === getSourceView(root, source) ? held : null;
+}
+function getHighlightIds(state, source = "document") {
+	if (!getSourceView(state, source)) return {
+		tableIds: /* @__PURE__ */ new Set(),
+		relationshipIds: /* @__PURE__ */ new Set()
+	};
+	const shown = getVisibleIds(state, source);
+	const shownTables = new Set(shown.tableIds);
+	const hovered = getViewHoverTable(state, source);
+	const held = getViewPinnedTable(state, source);
+	const lit = /* @__PURE__ */ new Set();
+	if (hovered !== null && shownTables.has(hovered)) lit.add(hovered);
+	if (held !== null && shownTables.has(held)) lit.add(held);
+	const tableIds = new Set(lit);
+	const relationshipIds = /* @__PURE__ */ new Set();
+	const relationships = query(state.collections).collection("relationshipEntities").selectByIds(shown.relationshipIds);
+	for (const { id, start, end } of relationships) {
+		if (!lit.has(start.tableId) && !lit.has(end.tableId)) continue;
+		relationshipIds.add(id);
+		tableIds.add(start.tableId);
+		tableIds.add(end.tableId);
+	}
+	return {
+		tableIds,
+		relationshipIds
+	};
+}
+//#endregion
+export { DIM_OPACITY, clearViewHoverTable, clearViewPinnedTable, getHighlightIds, getReachedTableIds, getTablePoint, getViewHoverTable, getViewPinnedTable, getVisibleColumnIds, getVisibleIds, relationshipColumnIdsByTable, setViewHoverTable, setViewPinnedTable };

package/dist/konva/scene/viewport.js

@@ -0,0 +1,86 @@
+import { DEFAULT_WIDTH } from "../../constants/layout.js";
+import { getRouteBBox } from "../../utils/draw-relationship/index.js";
+import { getActiveView, getSourceView } from "../../engine/modules/editor/view.js";
+import { getMemoRect, getTableRect } from "./metrics.js";
+//#region src/konva/scene/viewport.ts
+function getActiveTransform(state) {
+	return getActiveView(state) ?? state.settings;
+}
+function getSceneTransform(state, source = "document") {
+	return getSourceView(state, source) ?? state.settings;
+}
+function getZoomTransform(state, source) {
+	return source ? getSceneTransform(state, source) : getActiveTransform(state);
+}
+function getSceneOrigin({ originX, originY }) {
+	return {
+		x: originX,
+		y: originY
+	};
+}
+var safeZoom = (zoomLevel) => zoomLevel > 0 ? zoomLevel : 1;
+function toScreenPoint(transform, point) {
+	const origin = getSceneOrigin(transform);
+	return {
+		x: origin.x + point.x * transform.zoomLevel,
+		y: origin.y + point.y * transform.zoomLevel
+	};
+}
+function toScenePoint(transform, point) {
+	const zoomLevel = safeZoom(transform.zoomLevel);
+	const origin = getSceneOrigin({
+		...transform,
+		zoomLevel
+	});
+	return {
+		x: (point.x - origin.x) / zoomLevel,
+		y: (point.y - origin.y) / zoomLevel
+	};
+}
+function getOriginToPlace(zoomLevel, scene, screen) {
+	return {
+		x: screen.x - scene.x * zoomLevel,
+		y: screen.y - scene.y * zoomLevel
+	};
+}
+function createCullingRect(options) {
+	const { viewportWidth, viewportHeight } = options;
+	const zoomLevel = safeZoom(options.zoomLevel);
+	const origin = getSceneOrigin({
+		...options,
+		zoomLevel
+	});
+	const screenWidth = (viewportWidth > 0 ? viewportWidth : DEFAULT_WIDTH) / zoomLevel;
+	const screenHeight = (viewportHeight > 0 ? viewportHeight : 675) / zoomLevel;
+	return {
+		x: -origin.x / zoomLevel - screenWidth,
+		y: -origin.y / zoomLevel - screenHeight,
+		width: screenWidth * 3,
+		height: screenHeight * 3
+	};
+}
+function getCullingRect(state, source = "document") {
+	const { originX, originY, zoomLevel } = getSceneTransform(state, source);
+	const { viewport } = state.editor;
+	return createCullingRect({
+		originX,
+		originY,
+		zoomLevel,
+		viewportWidth: viewport.width,
+		viewportHeight: viewport.height
+	});
+}
+function intersects(rect, other) {
+	return !(other.x > rect.x + rect.width || other.x + other.width < rect.x || other.y > rect.y + rect.height || other.y + other.height < rect.y);
+}
+function isTableVisible(rect, state, table, source = "document") {
+	return intersects(rect, getTableRect(state, table, source));
+}
+function isMemoVisible(rect, memo) {
+	return intersects(rect, getMemoRect(memo));
+}
+function isRelationshipVisible(rect, relationship, strokeWidth, source = "document") {
+	return intersects(rect, getRouteBBox(relationship, strokeWidth, source));
+}
+//#endregion
+export { createCullingRect, getActiveTransform, getCullingRect, getOriginToPlace, getSceneOrigin, getSceneTransform, getZoomTransform, intersects, isMemoVisible, isRelationshipVisible, isTableVisible, toScenePoint, toScreenPoint };