@pascal-app/editor 1.0.0-beta.5 → 1.0.0

package/src/lib/floorplan/floorplan-export.tsx

@@ -7,7 +7,9 @@ import {
   type FloorplanGeometry,
   type FloorplanPalette,
   type FloorplanPoint,
+  isNodeKindEnabled,
   type LiveNodeOverrides,
+  type NodeCategory,
   nodeRegistry,
   resolveBuildingForLevel,
   useScene,
@@ -20,10 +22,13 @@ import { resolveSvgAnnotationCollisions } from '../../components/editor-2d/rende
 import { FloorplanGeometryRenderer } from '../../components/editor-2d/renderers/floorplan-geometry-renderer'
 import {
   buildContext,
+  collectDirectFloorplanScopeNodes,
   collectFloorplanLinkedLevelNodes,
   floorplanLayerRank,
   getFloorplanLevelData,
+  isFloorplanHierarchyVisible,
   isFloorplanNodeVisible,
+  siteToFloorplanTransform,
   splitFloorplanOverlay,
 } from '../../components/editor-2d/renderers/floorplan-registry-layer'
 import useDrawingView, { DRAWING_TYPE_OPTIONS } from '../../store/use-drawing-view'
@@ -69,6 +74,20 @@ import { FLOORPLAN_VIEW_ROTATION_DEG } from './geometry'
  */
 export type FloorplanExportScope = 'full' | 'structure'
 
+/**
+ * Whether a node belongs in the given export scope. `'full'` short-circuits
+ * and admits every node; `'structure'` admits only `structure`-category
+ * nodes. An `undefined` definition (unregistered node type) behaves like a
+ * node with no category.
+ */
+export function isFloorplanNodeInExportScope(
+  definition: { category?: NodeCategory } | undefined,
+  scope: FloorplanExportScope,
+): boolean {
+  if (scope === 'full') return true
+  return definition?.category === 'structure'
+}
+
 const SVG_NS = 'http://www.w3.org/2000/svg'
 /** Minimum and proportional margin around the structural drawing bounds. */
 const MIN_PLAN_PADDING_M = 1
@@ -131,12 +150,27 @@ type ExportGeometry = {
   annotations: FloorplanGeometry | null
 }
 
+type ExportGeometryContext = {
+  children: AnyNode[]
+  siblings: AnyNode[]
+  parent: AnyNode
+  outputTransform: { translate: FloorplanPoint; rotate: number }
+}
+
+type ExportGeometryEntry = {
+  id: AnyNodeId
+  node: AnyNode
+  parentOverride?: AnyNode
+  context?: ExportGeometryContext
+  scopeRank?: number
+}
+
 export type FloorplanPageLayout = {
   planBox: { x: number; y: number; width: number; height: number }
 }
 
 export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<void> {
-  const nodes = useScene.getState().nodes
+  const { nodes, installedPlugins } = useScene.getState()
   const viewer = useViewer.getState()
   const unit = viewer.unit
   const metricNotation = viewer.metricNotation
@@ -183,6 +217,7 @@ export async function exportFloorplanPdf(scope: FloorplanExportScope): Promise<v
         annotationVisibility,
         drawingType,
         wallDimensionReference,
+        installedPlugins,
       )
       const schedules = collectFloorplanSchedules(nodes, level.id, unit)
       if (geometries.length === 0 && schedules.length === 0) continue
@@ -721,7 +756,7 @@ function applyFloorplanViewport(
   mounted.svg.insertBefore(background, mounted.svg.firstChild)
 }
 
-function collectFloorplanGeometry(
+export function collectFloorplanGeometry(
   nodes: Record<string, AnyNode>,
   levelId: AnyNodeId,
   scope: FloorplanExportScope,
@@ -730,10 +765,11 @@ function collectFloorplanGeometry(
   annotationVisibility: FloorplanAnnotationVisibility,
   drawingType: ConstructionDrawingType,
   wallDimensionReference: FloorplanWallDimensionReference,
+  installedPlugins: readonly string[],
 ): ExportGeometry[] {
   const noLiveOverrides = new Map<string, LiveNodeOverrides>()
   const levelNodeIdsByType = new Map<string, AnyNodeId[]>()
-  const entries: { id: AnyNodeId; node: AnyNode; parentOverride?: AnyNode }[] = []
+  const entries: ExportGeometryEntry[] = []
 
   const visit = (id: AnyNodeId) => {
     const node = nodes[id]
@@ -747,7 +783,7 @@ function collectFloorplanGeometry(
     if (
       def?.floorplan &&
       isFloorplanNodeVisible(node) &&
-      (scope === 'full' || def.category === 'structure')
+      isFloorplanNodeInExportScope(def, scope)
     ) {
       const drawingNode = resolveNodeForDrawingType(node, nodes, drawingType)
       if (drawingNode) entries.push({ id, node: drawingNode })
@@ -758,31 +794,74 @@ function collectFloorplanGeometry(
   visit(levelId)
 
   const activeLevelNode = nodes[levelId]
+  const collectedIds = new Set(entries.map((entry) => entry.id))
   if (activeLevelNode) {
-    const collectedIds = new Set(entries.map((entry) => entry.id))
     for (const linked of collectFloorplanLinkedLevelNodes(nodes, levelId, collectedIds)) {
       const definition = nodeRegistry.get(linked.node.type)
-      if (
-        isFloorplanNodeVisible(linked.node) &&
-        (scope === 'full' || definition?.category === 'structure')
-      ) {
+      if (isFloorplanNodeVisible(linked.node) && isFloorplanNodeInExportScope(definition, scope)) {
         const drawingNode = resolveNodeForDrawingType(linked.node, nodes, drawingType)
         if (drawingNode) {
           entries.push({ id: linked.id, node: drawingNode, parentOverride: activeLevelNode })
+          collectedIds.add(linked.id)
         }
       }
     }
   }
 
-  // Document order is paint order — sort the same way the live layer does so
-  // zones sit under walls/slabs/furniture rather than on top of them.
-  entries.sort((a, b) => floorplanLayerRank(a.node.type) - floorplanLayerRank(b.node.type))
+  const buildingId = resolveBuildingForLevel(levelId, nodes as Record<AnyNodeId, AnyNode>)
+  const buildingNode = buildingId ? nodes[buildingId] : undefined
+  const siteNode =
+    buildingNode?.type === 'building' && buildingNode.parentId
+      ? nodes[buildingNode.parentId as AnyNodeId]
+      : undefined
+  if (siteNode?.type === 'site' && buildingNode?.type === 'building') {
+    const siteScopedNodes = collectDirectFloorplanScopeNodes(nodes, siteNode, 'site')
+    const outputTransform = siteToFloorplanTransform(
+      buildingNode.position,
+      buildingNode.rotation[1],
+    )
+    for (const node of siteScopedNodes) {
+      if (collectedIds.has(node.id) || !isNodeKindEnabled(node.type, installedPlugins)) continue
+      const drawingNode = resolveNodeForDrawingType(node, nodes, drawingType)
+      if (!drawingNode) continue
+      const definition = nodeRegistry.get(drawingNode.type)
+      if (
+        !definition?.floorplan ||
+        !isFloorplanNodeInExportScope(definition, scope) ||
+        !isFloorplanHierarchyVisible(drawingNode, nodes, noLiveOverrides, siteNode.id)
+      ) {
+        continue
+      }
+      const childIds = 'children' in node ? node.children : undefined
+      const children = Array.isArray(childIds)
+        ? childIds.map((childId) => nodes[childId]).filter((child): child is AnyNode => !!child)
+        : []
+      const siblings = siteScopedNodes.filter(
+        (candidate) => candidate.id !== node.id && candidate.type === node.type,
+      )
+      entries.push({
+        id: node.id,
+        node: drawingNode,
+        context: { children, siblings, parent: siteNode, outputTransform },
+        scopeRank: -1,
+      })
+      collectedIds.add(node.id)
+    }
+  }
+
+  // Document order is paint order. Site context sits below level
+  // architecture, then each scope retains the live layer's z-order.
+  entries.sort(
+    (a, b) =>
+      (a.scopeRank ?? 0) - (b.scopeRank ?? 0) ||
+      floorplanLayerRank(a.node.type) - floorplanLayerRank(b.node.type),
+  )
 
   // One-shot per-type cache for `computeFloorplanLevelData`; value type is
   // module-private to the registry layer, so let it infer.
   const levelDataCache = new Map()
   const out: ExportGeometry[] = []
-  for (const { id, node, parentOverride } of entries) {
+  for (const { id, node, parentOverride, context } of entries) {
     const builder = nodeRegistry.get(node.type)?.floorplan
     if (!builder) continue
     const levelData = getFloorplanLevelData(
@@ -803,9 +882,25 @@ function collectFloorplanGeometry(
       ),
       levelData,
     )
-    const ctx = parentOverride ? { ...baseContext, parent: parentOverride } : baseContext
-    const geometry = builder(node, ctx)
-    if (!geometry) continue
+    const ctx = context
+      ? {
+          ...baseContext,
+          children: context.children,
+          siblings: context.siblings,
+          parent: context.parent,
+        }
+      : parentOverride
+        ? { ...baseContext, parent: parentOverride }
+        : baseContext
+    const builtGeometry = builder(node, ctx)
+    if (!builtGeometry) continue
+    const geometry = context
+      ? {
+          kind: 'group' as const,
+          children: [builtGeometry],
+          transform: context.outputTransform,
+        }
+      : builtGeometry
     const visibleGeometry = filterFloorplanAnnotationGeometry(geometry, annotationVisibility)
     if (!visibleGeometry) continue
     const { base, overlay } = splitFloorplanOverlay(visibleGeometry)

package/src/lib/floorplan/floorplan-pdfkit-renderer.test.ts

@@ -85,6 +85,32 @@ describe('renderFloorplanGeometryToPdfKit', () => {
     expect([...new Set(baseFonts)]).toEqual(['Courier'])
     expect([...new Set(fontSizes)]).toEqual(['1.6'])
   })
+  test('uses even-odd fill for compound plugin paths', async () => {
+    const geometry = {
+      kind: 'path',
+      d: 'M0,0H4V4H0ZM1,1H3V3H1Z',
+      fill: '#3f6b2f',
+      fillRule: 'evenodd',
+    } satisfies FloorplanGeometry
+
+    const pdf = await renderTestPdf(geometry)
+
+    expect(pdf).toMatch(/f\*/)
+  })
+
+  test('writes a data-url PNG image without resolving it as an asset', async () => {
+    const geometry = {
+      kind: 'image',
+      url: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mNk+A8AAQUBAScY42YAAAAASUVORK5CYII=',
+      center: [2, 2],
+      width: 1,
+      height: 1,
+    } satisfies FloorplanGeometry
+
+    const pdf = await renderTestPdf(geometry)
+
+    expect(pdf).toContain('/Subtype /Image')
+  })
 })
 
 async function renderTestPdf(geometry: FloorplanGeometry, rotationDeg = 0): Promise<string> {

package/src/lib/floorplan/floorplan-pdfkit-renderer.ts

@@ -191,6 +191,7 @@ function paintStyledGeometry(
   const opacity = geometry.opacity ?? 1
   const fillOpacity = (geometry.fillOpacity ?? 1) * opacity
   const strokeOpacity = (geometry.strokeOpacity ?? 1) * opacity
+  const fillRule = geometry.fillRule === 'evenodd' ? 'even-odd' : 'non-zero'
 
   if (fill) raw.fillColor(fill).fillOpacity(fillOpacity)
   if (stroke) {
@@ -206,8 +207,8 @@ function paintStyledGeometry(
     )
   }
 
-  if (fill && stroke) raw.fillAndStroke(fill, stroke)
-  else if (fill) raw.fill(fill)
+  if (fill && stroke) raw.fillAndStroke(fill, stroke, fillRule)
+  else if (fill) raw.fill(fill, fillRule)
   else if (stroke) raw.stroke(stroke)
 }
 
@@ -620,29 +621,36 @@ async function drawImage(
   doc: FloorplanPdfDocument,
   geometry: Extract<FloorplanGeometry, { kind: 'image' }>,
 ): Promise<void> {
-  try {
-    const url = await loadAssetUrl(geometry.url)
-    if (!url) return
-    const response = await fetch(url)
-    if (!response.ok) return
-    const dataUrl = await blobToDataUrl(await response.blob())
-    const raw = doc.raw
-    raw.save().translate(geometry.center[0], geometry.center[1])
-    if (geometry.rotation) raw.rotate((geometry.rotation * 180) / Math.PI)
-    raw.opacity(geometry.opacity ?? 1)
-    const options =
-      geometry.preserveAspectRatio === 'none'
-        ? { width: geometry.width, height: geometry.height }
-        : {
-            fit: [geometry.width, geometry.height] as [number, number],
-            align: 'center' as const,
-            valign: 'center' as const,
-          }
-    raw.image(dataUrl, -geometry.width / 2, -geometry.height / 2, options)
-    raw.restore()
-  } catch {
-    return
+  const source = geometry.url.startsWith('data:') ? geometry.url : await loadAssetUrl(geometry.url)
+  if (!source) {
+    throw new Error('[floorplan-export] Could not resolve a floorplan image')
+  }
+
+  let dataUrl = source
+  if (!source.startsWith('data:')) {
+    const response = await fetch(source)
+    if (!response.ok) {
+      throw new Error(
+        `[floorplan-export] Could not load a floorplan image (HTTP ${response.status})`,
+      )
+    }
+    dataUrl = await blobToDataUrl(await response.blob())
   }
+
+  const raw = doc.raw
+  raw.save().translate(geometry.center[0], geometry.center[1])
+  if (geometry.rotation) raw.rotate((geometry.rotation * 180) / Math.PI)
+  raw.opacity(geometry.opacity ?? 1)
+  const options =
+    geometry.preserveAspectRatio === 'none'
+      ? { width: geometry.width, height: geometry.height }
+      : {
+          fit: [geometry.width, geometry.height] as [number, number],
+          align: 'center' as const,
+          valign: 'center' as const,
+        }
+  raw.image(dataUrl, -geometry.width / 2, -geometry.height / 2, options)
+  raw.restore()
 }
 
 function blobToDataUrl(blob: Blob): Promise<string> {

package/src/lib/floorplan/floorplan-readonly.ts

@@ -52,6 +52,7 @@ export function buildFloorplanContext(
     siblings,
     parent,
     levelData,
+    sceneNodes: nodes,
     extensions: createFloorplanContextExtensions({
       automaticDimensions: viewState.automaticDimensions,
       metricNotation: viewState.metricNotation ?? 'meters',

package/src/lib/floorplan-grid-event-point.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, test } from 'bun:test'
+import { resolveGenericFloorplanGridEventPoint } from './floorplan-grid-event-point'
+
+const snapHalf = ([x, z]: [number, number]): [number, number] => [
+  Math.round(x / 0.5) * 0.5,
+  Math.round(z / 0.5) * 0.5,
+]
+
+describe('resolveGenericFloorplanGridEventPoint', () => {
+  test('passes the raw pointer to registry tools so attachment can win before grid', () => {
+    expect(
+      resolveGenericFloorplanGridEventPoint({
+        point: [0.73, 0.32],
+        registryToolOwnsSnapping: true,
+        snap: snapHalf,
+      }),
+    ).toEqual([0.73, 0.32])
+  })
+
+  test('keeps the floorplan snap for interactions without a registry-owned resolver', () => {
+    expect(
+      resolveGenericFloorplanGridEventPoint({
+        point: [0.73, 0.32],
+        registryToolOwnsSnapping: false,
+        snap: snapHalf,
+      }),
+    ).toEqual([0.5, 0.5])
+  })
+})

package/src/lib/floorplan-grid-event-point.ts

@@ -0,0 +1,13 @@
+export type FloorplanGridEventPoint = [number, number]
+
+export function resolveGenericFloorplanGridEventPoint({
+  point,
+  registryToolOwnsSnapping,
+  snap,
+}: {
+  point: FloorplanGridEventPoint
+  registryToolOwnsSnapping: boolean
+  snap: (point: FloorplanGridEventPoint) => FloorplanGridEventPoint
+}): FloorplanGridEventPoint {
+  return registryToolOwnsSnapping ? point : snap(point)
+}