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

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.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, test } from 'bun:test'
+import { LevelNode, WallNode } from '@pascal-app/core/schema'
+import { buildFloorplanContext } from './floorplan-readonly'
+
+const viewState = {
+  selected: false,
+  unit: 'metric' as const,
+  highlighted: false,
+  hovered: false,
+  moving: false,
+  palette: undefined,
+}
+
+describe('read-only floorplan context', () => {
+  test('does not invent siblings for parentless nodes', () => {
+    const first = LevelNode.parse({ id: 'level_first', type: 'level' })
+    const second = LevelNode.parse({ id: 'level_second', type: 'level' })
+    const nodes = { [first.id]: first, [second.id]: second }
+
+    expect(buildFloorplanContext(first, nodes, viewState).siblings).toEqual([])
+  })
+
+  test('resolves same-kind siblings from the parent child order', () => {
+    const first = WallNode.parse({
+      id: 'wall_first',
+      type: 'wall',
+      parentId: 'level_ground',
+      start: [0, 0],
+      end: [1, 0],
+    })
+    const second = WallNode.parse({
+      id: 'wall_second',
+      type: 'wall',
+      parentId: 'level_ground',
+      start: [1, 0],
+      end: [2, 0],
+    })
+    const level = LevelNode.parse({
+      id: 'level_ground',
+      type: 'level',
+      children: [first.id, second.id],
+    })
+    const nodes = { [level.id]: level, [first.id]: first, [second.id]: second }
+
+    expect(buildFloorplanContext(first, nodes, viewState).siblings).toEqual([second])
+  })
+})

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

@@ -0,0 +1,85 @@
+import type { AnyNode, AnyNodeId, FloorplanPalette, GeometryContext } from '@pascal-app/core'
+import {
+  createFloorplanContextExtensions,
+  type FloorplanWallDimensionReference,
+} from './floorplan-extension'
+
+export type FloorplanViewState = {
+  automaticDimensions?: boolean
+  selected: boolean
+  unit: 'metric' | 'imperial'
+  metricNotation?: 'meters' | 'millimeters'
+  purpose?: 'edit' | 'document'
+  wallDimensionReference?: FloorplanWallDimensionReference
+  highlighted: boolean
+  hovered: boolean
+  moving: boolean
+  palette: FloorplanPalette | undefined
+}
+
+export function buildFloorplanContext(
+  node: AnyNode,
+  nodes: Record<string, AnyNode>,
+  viewState: FloorplanViewState,
+  levelData?: unknown,
+): GeometryContext {
+  const resolve = <N = AnyNode>(id: AnyNodeId): N | undefined => nodes[id] as N | undefined
+  const childIds = (node as { children?: AnyNodeId[] }).children
+  const children = Array.isArray(childIds)
+    ? childIds.map((id) => nodes[id]).filter((child): child is AnyNode => child !== undefined)
+    : []
+  const parentId = node.parentId as AnyNodeId | null
+  const parent = parentId ? (nodes[parentId] ?? null) : null
+  let siblings: AnyNode[] = []
+  if (parent) {
+    const parentChildIds = (parent as { children?: AnyNodeId[] }).children
+    siblings = Array.isArray(parentChildIds)
+      ? parentChildIds
+          .filter((id) => id !== node.id)
+          .map((id) => nodes[id])
+          .filter((sibling): sibling is AnyNode => sibling?.type === node.type)
+      : Object.values(nodes).filter(
+          (candidate) =>
+            candidate.id !== node.id &&
+            candidate.type === node.type &&
+            candidate.parentId === node.parentId,
+        )
+  }
+
+  return {
+    resolve,
+    children,
+    siblings,
+    parent,
+    levelData,
+    sceneNodes: nodes,
+    extensions: createFloorplanContextExtensions({
+      automaticDimensions: viewState.automaticDimensions,
+      metricNotation: viewState.metricNotation ?? 'meters',
+      purpose: viewState.purpose ?? 'edit',
+      wallDimensionReference: viewState.wallDimensionReference,
+    }),
+    viewState: viewState.palette
+      ? {
+          selected: viewState.selected,
+          unit: viewState.unit,
+          highlighted: viewState.highlighted,
+          hovered: viewState.hovered,
+          moving: viewState.moving,
+          palette: viewState.palette,
+        }
+      : undefined,
+  }
+}
+
+export function floorplanLayerRank(type: string): number {
+  switch (type) {
+    case 'zone':
+      return 0
+    case 'slab':
+    case 'ceiling':
+      return 1
+    default:
+      return 2
+  }
+}

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)
+}