346 lines
11 KiB
TypeScript
346 lines
11 KiB
TypeScript
import type { DiagramLayer } from "@/types/diagram";
|
|
import type { DiagramPosition, DiagramTable } from "@/lib/diagram/erDiagram";
|
|
import { layoutDiagramTables } from "@/lib/diagram/erDiagram";
|
|
import { sizeLayerToFit } from "@/lib/diagram/size-layer";
|
|
import { CARD_WIDTH, EMPTY_LAYER_HEIGHT, EMPTY_LAYER_WIDTH, GAP_X, GAP_Y, LAYER_CONTENT_PADDING, LAYER_HEADER_HEIGHT, MARGIN, columnsPerRowForWidth, tableCardHeight } from "@/lib/diagram/diagram-constants";
|
|
|
|
export interface LtrAutoLayoutInput {
|
|
tables: DiagramTable[];
|
|
positions: Record<string, DiagramPosition>;
|
|
layers: DiagramLayer[];
|
|
paneWidth: number;
|
|
/** Optional edges used to cluster related tables in LTR order. */
|
|
relationships?: Array<{ sourceTable: string; targetTable: string }>;
|
|
}
|
|
|
|
export interface LtrAutoLayoutResult {
|
|
positions: Record<string, DiagramPosition>;
|
|
/** Mutated copies of visible layers with updated geometry (caller should apply to store). */
|
|
layers: DiagramLayer[];
|
|
}
|
|
|
|
type LayerBox = {
|
|
layer: DiagramLayer;
|
|
width: number;
|
|
height: number;
|
|
/** Absolute table positions relative to a provisional origin (0,0) for the layer box. */
|
|
localTablePositions: Record<string, DiagramPosition>;
|
|
};
|
|
|
|
function tableHeightsMap(tables: DiagramTable[]): Record<string, number> {
|
|
const heights: Record<string, number> = {};
|
|
for (const table of tables) {
|
|
heights[table.name] = tableCardHeight(table.columns?.length ?? 0);
|
|
}
|
|
return heights;
|
|
}
|
|
|
|
/** Order tables so connected components stay adjacent (for friendlier LTR grids). */
|
|
export function orderTablesByConnectivity(tables: DiagramTable[], relationships: Array<{ sourceTable: string; targetTable: string }> = []): DiagramTable[] {
|
|
if (tables.length <= 1 || relationships.length === 0) return [...tables];
|
|
|
|
const nameSet = new Set(tables.map((t) => t.name));
|
|
const adj = new Map<string, Set<string>>();
|
|
for (const name of nameSet) adj.set(name, new Set());
|
|
|
|
for (const rel of relationships) {
|
|
if (!nameSet.has(rel.sourceTable) || !nameSet.has(rel.targetTable)) continue;
|
|
if (rel.sourceTable === rel.targetTable) continue;
|
|
adj.get(rel.sourceTable)!.add(rel.targetTable);
|
|
adj.get(rel.targetTable)!.add(rel.sourceTable);
|
|
}
|
|
|
|
const byName = new Map(tables.map((t) => [t.name, t]));
|
|
const visited = new Set<string>();
|
|
const ordered: DiagramTable[] = [];
|
|
|
|
const visitComponent = (start: string) => {
|
|
const stack = [start];
|
|
const component: string[] = [];
|
|
while (stack.length > 0) {
|
|
const name = stack.pop()!;
|
|
if (visited.has(name)) continue;
|
|
visited.add(name);
|
|
component.push(name);
|
|
for (const next of adj.get(name) ?? []) {
|
|
if (!visited.has(next)) stack.push(next);
|
|
}
|
|
}
|
|
component.sort((a, b) => a.localeCompare(b));
|
|
for (const name of component) {
|
|
const table = byName.get(name);
|
|
if (table) ordered.push(table);
|
|
}
|
|
};
|
|
|
|
// Prefer starting from tables that have edges, then isolates (stable name order)
|
|
const withEdges = tables.filter((t) => (adj.get(t.name)?.size ?? 0) > 0).sort((a, b) => a.name.localeCompare(b.name));
|
|
const isolates = tables.filter((t) => (adj.get(t.name)?.size ?? 0) === 0).sort((a, b) => a.name.localeCompare(b.name));
|
|
|
|
for (const table of withEdges) {
|
|
if (!visited.has(table.name)) visitComponent(table.name);
|
|
}
|
|
for (const table of isolates) {
|
|
if (!visited.has(table.name)) ordered.push(table);
|
|
}
|
|
|
|
return ordered;
|
|
}
|
|
|
|
/**
|
|
* Reflow unassigned (not in any visible layer) tables into an LTR grid,
|
|
* preserving approximate visual order (sort by y then x).
|
|
*/
|
|
export function reflowUnassignedTables(input: { tables: DiagramTable[]; positions: Record<string, DiagramPosition>; layers: DiagramLayer[]; paneWidth: number; yOrigin?: number }): Record<string, DiagramPosition> {
|
|
const { tables, positions, layers, paneWidth } = input;
|
|
const columnsPerRow = columnsPerRowForWidth(paneWidth);
|
|
const assigned = new Set(layers.filter((l) => l.visible).flatMap((l) => l.tableNames));
|
|
const unassigned = tables.filter((t) => !assigned.has(t.name));
|
|
if (unassigned.length === 0) return { ...positions };
|
|
|
|
const sorted = [...unassigned].sort((a, b) => {
|
|
const pa = positions[a.name] ?? { x: 0, y: 0 };
|
|
const pb = positions[b.name] ?? { x: 0, y: 0 };
|
|
if (pa.y !== pb.y) return pa.y - pb.y;
|
|
return pa.x - pb.x;
|
|
});
|
|
|
|
let layersBottom = MARGIN;
|
|
for (const layer of layers.filter((l) => l.visible)) {
|
|
if (layer.position == null || layer.height == null) continue;
|
|
layersBottom = Math.max(layersBottom, layer.position.y + layer.height);
|
|
}
|
|
|
|
const yOrigin = input.yOrigin ?? (layers.some((l) => l.visible) ? layersBottom + GAP_Y : MARGIN);
|
|
const grid = layoutDiagramTables(sorted, {
|
|
columnsPerRow,
|
|
cardWidth: CARD_WIDTH,
|
|
gapX: GAP_X,
|
|
gapY: GAP_Y,
|
|
margin: MARGIN,
|
|
});
|
|
|
|
const next = { ...positions };
|
|
const yOffset = yOrigin - MARGIN;
|
|
for (const [name, pos] of Object.entries(grid)) {
|
|
next[name] = { x: pos.x, y: pos.y + yOffset };
|
|
}
|
|
return next;
|
|
}
|
|
|
|
function measureFreeLocal(layer: DiagramLayer, positions: Record<string, DiagramPosition>, heights: Record<string, number>): LayerBox {
|
|
if (layer.tableNames.length === 0) {
|
|
return {
|
|
layer,
|
|
width: EMPTY_LAYER_WIDTH,
|
|
height: EMPTY_LAYER_HEIGHT,
|
|
localTablePositions: {},
|
|
};
|
|
}
|
|
|
|
let minX = Infinity;
|
|
let minY = Infinity;
|
|
let maxX = -Infinity;
|
|
let maxY = -Infinity;
|
|
const absolute: Record<string, DiagramPosition> = {};
|
|
|
|
for (const name of layer.tableNames) {
|
|
const position = positions[name];
|
|
if (!position) continue;
|
|
const height = heights[name] ?? 120;
|
|
absolute[name] = { ...position };
|
|
minX = Math.min(minX, position.x);
|
|
minY = Math.min(minY, position.y);
|
|
maxX = Math.max(maxX, position.x + CARD_WIDTH);
|
|
maxY = Math.max(maxY, position.y + height);
|
|
}
|
|
|
|
if (!Number.isFinite(minX) || !Number.isFinite(minY)) {
|
|
return {
|
|
layer,
|
|
width: EMPTY_LAYER_WIDTH,
|
|
height: EMPTY_LAYER_HEIGHT,
|
|
localTablePositions: {},
|
|
};
|
|
}
|
|
|
|
const originX = minX - LAYER_CONTENT_PADDING;
|
|
const originY = minY - LAYER_HEADER_HEIGHT - LAYER_CONTENT_PADDING;
|
|
const localTablePositions: Record<string, DiagramPosition> = {};
|
|
for (const [name, pos] of Object.entries(absolute)) {
|
|
localTablePositions[name] = { x: pos.x - originX, y: pos.y - originY };
|
|
}
|
|
|
|
return {
|
|
layer,
|
|
width: Math.max(EMPTY_LAYER_WIDTH, maxX - minX + LAYER_CONTENT_PADDING * 2),
|
|
height: Math.max(EMPTY_LAYER_HEIGHT, maxY - minY + LAYER_HEADER_HEIGHT + LAYER_CONTENT_PADDING * 2),
|
|
localTablePositions,
|
|
};
|
|
}
|
|
|
|
function measureAutoLocal(layer: DiagramLayer, tablesByName: Map<string, DiagramTable>, columnsPerRow: number): LayerBox {
|
|
if (layer.tableNames.length === 0) {
|
|
return {
|
|
layer,
|
|
width: EMPTY_LAYER_WIDTH,
|
|
height: EMPTY_LAYER_HEIGHT,
|
|
localTablePositions: {},
|
|
};
|
|
}
|
|
|
|
const layerTables = layer.tableNames.map((name) => tablesByName.get(name)).filter((t): t is DiagramTable => !!t);
|
|
|
|
if (layerTables.length === 0) {
|
|
return {
|
|
layer,
|
|
width: EMPTY_LAYER_WIDTH,
|
|
height: EMPTY_LAYER_HEIGHT,
|
|
localTablePositions: {},
|
|
};
|
|
}
|
|
|
|
// Layout with margin 0, then offset into layer content area
|
|
const grid = layoutDiagramTables(layerTables, {
|
|
columnsPerRow,
|
|
cardWidth: CARD_WIDTH,
|
|
gapX: GAP_X,
|
|
gapY: GAP_Y,
|
|
margin: 0,
|
|
});
|
|
|
|
const localTablePositions: Record<string, DiagramPosition> = {};
|
|
for (const [name, pos] of Object.entries(grid)) {
|
|
localTablePositions[name] = {
|
|
x: pos.x + LAYER_CONTENT_PADDING,
|
|
y: pos.y + LAYER_HEADER_HEIGHT + LAYER_CONTENT_PADDING,
|
|
};
|
|
}
|
|
|
|
// Provisional size via sizeLayerToFit against local coords (origin 0,0)
|
|
const scratch: DiagramLayer = {
|
|
...layer,
|
|
position: { x: 0, y: 0 },
|
|
tableNames: [...layer.tableNames],
|
|
};
|
|
const heights = tableHeightsMap(layerTables);
|
|
sizeLayerToFit(scratch, localTablePositions, heights);
|
|
|
|
return {
|
|
layer,
|
|
width: scratch.width ?? EMPTY_LAYER_WIDTH,
|
|
height: scratch.height ?? EMPTY_LAYER_HEIGHT,
|
|
localTablePositions,
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Auto-layout: visible layers packed at top (LTR wrap), unassigned tables
|
|
* in an LTR grid below — same column logic as initial resetLayout.
|
|
*/
|
|
export function computeLtrAutoLayout(input: LtrAutoLayoutInput): LtrAutoLayoutResult {
|
|
const { tables, positions: prevPositions, layers, paneWidth, relationships = [] } = input;
|
|
const columnsPerRow = columnsPerRowForWidth(paneWidth);
|
|
const heights = tableHeightsMap(tables);
|
|
const tablesByName = new Map(tables.map((t) => [t.name, t]));
|
|
const nextPositions: Record<string, DiagramPosition> = { ...prevPositions };
|
|
|
|
const visibleLayers = layers.filter((l) => l.visible);
|
|
const assigned = new Set(visibleLayers.flatMap((l) => l.tableNames));
|
|
const orderedTables = orderTablesByConnectivity(tables, relationships);
|
|
const unassigned = orderedTables.filter((t) => !assigned.has(t.name));
|
|
|
|
if (visibleLayers.length === 0) {
|
|
const grid = layoutDiagramTables(orderedTables, {
|
|
columnsPerRow,
|
|
cardWidth: CARD_WIDTH,
|
|
gapX: GAP_X,
|
|
gapY: GAP_Y,
|
|
margin: MARGIN,
|
|
});
|
|
return { positions: { ...nextPositions, ...grid }, layers: [] };
|
|
}
|
|
|
|
const boxes: LayerBox[] = visibleLayers.map((layer) => {
|
|
const mode = layer.layoutMode ?? "free";
|
|
if (mode === "auto") {
|
|
const layerTables = orderTablesByConnectivity(
|
|
layer.tableNames.map((n) => tablesByName.get(n)).filter((t): t is DiagramTable => !!t),
|
|
relationships,
|
|
);
|
|
const scratchLayer = { ...layer, tableNames: layerTables.map((t) => t.name) };
|
|
return measureAutoLocal(scratchLayer, tablesByName, columnsPerRow);
|
|
}
|
|
return measureFreeLocal(layer, prevPositions, heights);
|
|
});
|
|
|
|
const usableWidth = Math.max(CARD_WIDTH, paneWidth - MARGIN * 2);
|
|
let cursorX = MARGIN;
|
|
let cursorY = MARGIN;
|
|
let rowHeight = 0;
|
|
let layersBottom = MARGIN;
|
|
|
|
const updatedLayers: DiagramLayer[] = [];
|
|
|
|
for (const box of boxes) {
|
|
const { width, height, localTablePositions, layer } = box;
|
|
|
|
if (cursorX > MARGIN && cursorX + width > MARGIN + usableWidth) {
|
|
cursorX = MARGIN;
|
|
cursorY += rowHeight + GAP_Y;
|
|
rowHeight = 0;
|
|
}
|
|
|
|
const placed: DiagramLayer = {
|
|
...layer,
|
|
position: { x: cursorX, y: cursorY },
|
|
width,
|
|
height,
|
|
tableNames: [...layer.tableNames],
|
|
};
|
|
|
|
for (const [name, local] of Object.entries(localTablePositions)) {
|
|
nextPositions[name] = {
|
|
x: cursorX + local.x,
|
|
y: cursorY + local.y,
|
|
};
|
|
}
|
|
|
|
// Reconcile size from absolute table positions (auto / free with tables)
|
|
if (placed.tableNames.length > 0) {
|
|
sizeLayerToFit(placed, nextPositions, heights);
|
|
} else {
|
|
placed.width = EMPTY_LAYER_WIDTH;
|
|
placed.height = EMPTY_LAYER_HEIGHT;
|
|
placed.position = { x: cursorX, y: cursorY };
|
|
}
|
|
|
|
const finalW = placed.width ?? width;
|
|
const finalH = placed.height ?? height;
|
|
const finalX = placed.position?.x ?? cursorX;
|
|
const finalY = placed.position?.y ?? cursorY;
|
|
|
|
updatedLayers.push(placed);
|
|
|
|
cursorX = finalX + finalW + GAP_X;
|
|
rowHeight = Math.max(rowHeight, finalH);
|
|
layersBottom = Math.max(layersBottom, finalY + finalH);
|
|
}
|
|
|
|
if (unassigned.length > 0) {
|
|
const grid = layoutDiagramTables(unassigned, {
|
|
columnsPerRow,
|
|
cardWidth: CARD_WIDTH,
|
|
gapX: GAP_X,
|
|
gapY: GAP_Y,
|
|
margin: MARGIN,
|
|
});
|
|
const yOffset = layersBottom + GAP_Y - MARGIN;
|
|
for (const [name, pos] of Object.entries(grid)) {
|
|
nextPositions[name] = { x: pos.x, y: pos.y + yOffset };
|
|
}
|
|
}
|
|
|
|
return { positions: nextPositions, layers: updatedLayers };
|
|
}
|