import type { Document, ElementRecord, Geometry, Id, Json, Point, Registry } from '../canvas-core/types.ts'; import { connectionPathValid } from '../canvas-core/features.ts'; import { unitScale } from '../canvas-core/units.ts'; import { fault } from '../canvas-core/values.ts'; import type { CanvasNode } from '../canvas-elements.ts'; import type { CanvasEdgeModel, EdgeData } from '../canvas-v2.ts'; import { childCanvasTransform, toWorld, transformPath, type Transform } from '../canvas-core/coordinates.ts'; export { toWorld, toLocal, transformPath, type Transform } from '../canvas-core/coordinates.ts'; const origin:Transform={x:0,y:0,scale:1,rotation:0}; export type ProjectionNode = Omit & { type: NonNullable | 'unsupported' }; const nodeTypes: Record> = { 'plain-text': 'plainText', 'plain-image': 'plainImage', frame: 'frame', icon: 'icon' }; const object = (value: Json | undefined) => value && typeof value === 'object' && !Array.isArray(value) ? value : {}; /** Renderer projection retains identity/owner in the model, including nested and collapsed canvases. */ export function projectCanvas(document: Document, canvasId: Id, registry: Registry, selected: ReadonlySet | { has(id: Id): boolean }, geometry: (id: Id) => Geometry | undefined, edgePreview?: { target: { id: Id }; path: Json } | null) { if (!document.canvases.has(canvasId)) throw fault('canvas_not_loaded', [canvasId]); const transforms = new Map([[canvasId, origin]]), hiddenBy = new Map(), childByEntry = new Map(); for (const canvas of document.canvases.values()) if (canvas.parent) childByEntry.set(canvas.parent.entryElementId, canvas.id); const members = new Map(); for (const element of document.elements.values()) { const list = members.get(element.ownerCanvasId) ?? []; list.push(element); members.set(element.ownerCanvasId, list); } const nodes: ProjectionNode[] = [], visible = new Set(); const visit = (id: Id, depth: number) => { const transform = transforms.get(id)!; for (const element of members.get(id) ?? []) if (element.structure === 'node') { const g = geometry(element.id) ?? element.geometry, center = toWorld(transform, { x: g.x + g.width / 2, y: g.y + g.height / 2 }); const width = g.width * transform.scale, height = g.height * transform.scale, known = registry.resolve(element) === 'known'; const type = !known ? 'unsupported' : nodeTypes[element.componentId] ?? 'material'; const child = childByEntry.get(element.id), data = element.data; const projected: ProjectionNode = { id: element.id, type, position: { x: center.x - width / 2, y: center.y - height / 2 }, width, height, selected: selected.has(element.id), draggable: known && registry.supports(element, 'geometry.move'), zIndex: element.componentId === 'frame' ? depth - 100 : depth * 2, style: { width, height, ...(element.componentId === 'frame' ? { pointerEvents: 'none' as const } : {}) }, data: { ...data, kind: element.componentId as CanvasNode['data']['kind'], title: typeof data.title === 'string' ? data.title : element.componentId, text: typeof data.text === 'string' ? data.text : '', rotation: (g.rotation + transform.rotation) % 360, viewScale: transform.scale*(known?unitScale(data.presentation):1), ...(child ? { subgraph: { boardId: child } } : {}) } as CanvasNode['data'], }; nodes.push(projected); visible.add(element.id); if (child) { const presentation = object(data.presentation); if (presentation.collapsed === true || !known) { const stack = [child]; while (stack.length) { const hidden = stack.pop()!; hiddenBy.set(hidden, element.id); for (const canvas of document.canvases.values()) if (canvas.parent?.canvasId === hidden) stack.push(canvas.id); } } else { transforms.set(child, childCanvasTransform(transform,g,data.presentation)); visit(child, depth + 1); } } } }; visit(canvasId, 0); const edges: CanvasEdgeModel[] = []; for (const element of document.elements.values()) if (element.structure === 'connection' && transforms.has(element.ownerCanvasId)) { const endpoint = (id: Id) => visible.has(id) ? id : hiddenBy.get(document.elements.get(id)?.ownerCanvasId ?? ''); const source = endpoint(element.source.elementId), target = endpoint(element.target.elementId); if (!source || !target || source === target) continue; const path = transformPath(edgePreview?.target.id === element.id ? edgePreview.path : element.path, transforms.get(element.ownerCanvasId)!); const renderPath = registry.resolve(element) === 'known' && connectionPathValid(path) ? path : undefined; const { path: unusedPath, ...edgeData } = element.data; void unusedPath; edges.push({ id: element.id, source, target, sourceHandle: source === element.source.elementId ? element.source.portId : undefined, targetHandle: target === element.target.elementId ? element.target.portId : undefined, selected: selected.has(element.id), data: { ...edgeData, ...(renderPath ? { path: renderPath } : {}) } as EdgeData }); } return { nodes, edges, transforms }; }