@pascal-app/editor 1.0.1 → 1.0.4

package/src/components/editor-2d/renderers/floorplan-draft-measurement.tsx

@@ -0,0 +1,166 @@
+'use client'
+
+/** Length plate + angle arcs for a drafted segment, in plan space. */
+type PlanPoint = readonly [number, number]
+
+export type DraftMeasurement = {
+  lengthLabel: string
+  midpoint: PlanPoint
+  direction: PlanPoint
+  angleLabels: {
+    id: string
+    label: string
+    center: PlanPoint
+    radius: number
+    startAngle: number
+    endAngle: number
+    midAngle: number
+  }[]
+}
+
+export function FloorplanDraftMeasurement({
+  measurement,
+  measurementStroke,
+  labelBackground,
+  labelText,
+  sceneRotationDeg,
+  unitsPerPixel,
+}: {
+  measurement: DraftMeasurement
+  measurementStroke: string
+  labelBackground: string
+  labelText: string
+  sceneRotationDeg: number
+  unitsPerPixel: number
+}) {
+  const stroke = measurementStroke
+  const labelBg = labelBackground
+
+  const upx = unitsPerPixel
+  const fontSize = Math.max(upx * 10, 0.08)
+  const padX = upx * 6
+  const padY = upx * 3
+
+  // Length plate: rotates to follow the wall direction, but flips 180°
+  // when its on-screen orientation would read upside-down (same trick as
+  // `floorplan-registry-layer.tsx` for dimension labels).
+  const wallAngleDeg =
+    (Math.atan2(measurement.direction[1], measurement.direction[0]) * 180) / Math.PI
+  let labelAngleDeg = wallAngleDeg
+  let screenDeg = wallAngleDeg + sceneRotationDeg
+  screenDeg = ((((screenDeg + 180) % 360) + 360) % 360) - 180
+  if (screenDeg > 90) labelAngleDeg -= 180
+  else if (screenDeg <= -90) labelAngleDeg += 180
+
+  // Push the plate perpendicular to the wall so the dashed footprint
+  // stays visible underneath.
+  const perpX = -measurement.direction[1]
+  const perpY = measurement.direction[0]
+  const offset = upx * 18
+  const cx = measurement.midpoint[0] + perpX * offset
+  const cy = measurement.midpoint[1] + perpY * offset
+
+  const lengthTextWidth = measurement.lengthLabel.length * upx * 6.2
+  const lengthPlateW = lengthTextWidth + padX * 2
+  const lengthPlateH = fontSize + padY * 2
+
+  const arcSampleCount = 32
+
+  return (
+    <g pointerEvents="none">
+      <g transform={`translate(${cx} ${cy}) rotate(${labelAngleDeg})`}>
+        <rect
+          fill={labelBg}
+          height={lengthPlateH}
+          opacity={0.92}
+          rx={upx * 3}
+          ry={upx * 3}
+          stroke={stroke}
+          strokeWidth={upx * 0.5}
+          vectorEffect="non-scaling-stroke"
+          width={lengthPlateW}
+          x={-lengthPlateW / 2}
+          y={-lengthPlateH / 2}
+        />
+        <text
+          dominantBaseline="middle"
+          fill={labelText}
+          fontFamily="ui-monospace, SFMono-Regular, Menlo, monospace"
+          fontSize={fontSize}
+          fontWeight={600}
+          textAnchor="middle"
+          x={0}
+          y={0}
+        >
+          {measurement.lengthLabel}
+        </text>
+      </g>
+
+      {measurement.angleLabels.map((arc) => {
+        // Sample the arc as a polyline — avoids the SVG arc command's
+        // sweep-flag direction quirks across negative/positive sweeps.
+        const points: string[] = []
+        for (let i = 0; i <= arcSampleCount; i += 1) {
+          const t = i / arcSampleCount
+          const a = arc.startAngle + (arc.endAngle - arc.startAngle) * t
+          const px = arc.center[0] + Math.cos(a) * arc.radius
+          const py = arc.center[1] + Math.sin(a) * arc.radius
+          points.push(`${px},${py}`)
+        }
+
+        const aFontSize = Math.max(upx * 9, 0.075)
+        const aPadX = upx * 5
+        const aPadY = upx * 2.5
+        const aTextWidth = arc.label.length * upx * 6.2
+        const aPlateW = aTextWidth + aPadX * 2
+        const aPlateH = aFontSize + aPadY * 2
+
+        const labelDist = arc.radius + upx * 16
+        const lx = arc.center[0] + Math.cos(arc.midAngle) * labelDist
+        const ly = arc.center[1] + Math.sin(arc.midAngle) * labelDist
+
+        return (
+          <g key={`draft-angle-${arc.id}`}>
+            <polyline
+              fill="none"
+              points={points.join(' ')}
+              stroke={stroke}
+              strokeLinecap="round"
+              strokeLinejoin="round"
+              strokeOpacity={0.95}
+              strokeWidth={upx * 1.2}
+              vectorEffect="non-scaling-stroke"
+            />
+            <g transform={`translate(${lx} ${ly})`}>
+              <rect
+                fill={labelBg}
+                height={aPlateH}
+                opacity={0.92}
+                rx={upx * 3}
+                ry={upx * 3}
+                stroke={stroke}
+                strokeWidth={upx * 0.5}
+                vectorEffect="non-scaling-stroke"
+                width={aPlateW}
+                x={-aPlateW / 2}
+                y={-aPlateH / 2}
+              />
+              <text
+                dominantBaseline="middle"
+                fill={labelText}
+                fontFamily="ui-monospace, SFMono-Regular, Menlo, monospace"
+                fontSize={aFontSize}
+                fontWeight={600}
+                textAnchor="middle"
+                x={0}
+                y={0}
+              >
+                {arc.label}
+              </text>
+            </g>
+          </g>
+        )
+      })}
+    </g>
+  )
+}

package/src/components/editor-2d/renderers/floorplan-geometry-renderer.tsx

@@ -172,7 +172,10 @@ function documentTextFontSize(
 }
 
 function documentTextSizePt(geometry: Extract<FloorplanGeometry, { kind: 'text' }>): number {
-  switch (readFloorplanGeometryMetadata(geometry).annotationRole) {
+  const metadata = readFloorplanGeometryMetadata(geometry)
+  // an explicit paper size wins over the role's (a sheet's room tag sets its own)
+  if (typeof metadata.textSizePt === 'number' && metadata.textSizePt > 0) return metadata.textSizePt
+  switch (metadata.annotationRole) {
     case 'room-label':
       if (geometry.fontSize >= 0.18) return DOCUMENT_ROOM_NAME_TEXT_SIZE_PT
       if (geometry.fontSize >= 0.145) return DOCUMENT_ROOM_NUMBER_TEXT_SIZE_PT

package/src/components/editor-2d/renderers/floorplan-registry-layer.test.ts

@@ -15,6 +15,7 @@ import {
   FLOORPLAN_NODE_EXTENSION_KEY,
   floorplanGeometryMetadata,
 } from '../../../lib/floorplan/floorplan-extension'
+import type { SessionWrites } from '../../../lib/session-writes'
 import {
   buildFloorplanEntryGeometry,
   cancelFloorplanAffordanceDrag,
@@ -23,11 +24,14 @@ import {
   collectFloorplanLinkedLevelNodes,
   computeAffectedSiblingIds,
   floorplanAffordanceReshapeScope,
+  floorplanEntryYieldsToTool,
   floorplanHandleDoubleClickAffordance,
   InteractiveGeometry,
+  isFloorplanHierarchyVisible,
   isFloorplanOpeningPlacementState,
   resolveFloorplanHandleUnitsPerPixel,
   siteToFloorplanTransform,
+  splitFloorplanHandles,
   splitFloorplanOverlay,
   subscribeFloorplanAffordanceToolCancel,
 } from './floorplan-registry-layer'
@@ -383,7 +387,13 @@ describe('floorplan affordance cancellation', () => {
       canCommit: () => true,
       commit,
     }
-    const snapshots = [{ id: 'wall_a' as AnyNodeId, data: { width: 1 } }]
+    const revert = mock(() => {})
+    const writes = {
+      record: (run: () => unknown) => run(),
+      revert,
+      changes: () => ({ create: [], update: [], delete: [] }),
+      size: 0,
+    } as unknown as SessionWrites
     const drag = {
       pointerId: 7,
       captureTarget: {
@@ -392,12 +402,11 @@ describe('floorplan affordance cancellation', () => {
       } as unknown as Element,
       handleId: 'wall_a:endpoint',
       session,
-      snapshots,
+      writes,
       historyPaused: true,
       lastPlanPoint: [0, 0] as [number, number],
     }
     const dragRef = { current: drag }
-    const restoreSnapshots = mock(() => {})
     const resumeHistory = mock(() => {})
     const clearPreview = mock(() => {})
     const clearSnapFeedback = mock(() => {})
@@ -408,7 +417,6 @@ describe('floorplan affordance cancellation', () => {
     const unsubscribe = subscribeFloorplanAffordanceToolCancel(
       () =>
         cancelFloorplanAffordanceDrag(dragRef, {
-          restoreSnapshots,
           resumeHistory,
           clearPreview,
           clearSnapFeedback,
@@ -427,7 +435,7 @@ describe('floorplan affordance cancellation', () => {
 
     expect(dragRef.current).toBeNull()
     expect(releasePointerCapture).toHaveBeenCalledWith(7)
-    expect(restoreSnapshots).toHaveBeenCalledWith(snapshots)
+    expect(revert).toHaveBeenCalledTimes(1)
     expect(resumeHistory).toHaveBeenCalledTimes(1)
     expect(clearPreview).toHaveBeenCalledTimes(2)
     expect(clearPreview).toHaveBeenNthCalledWith(1, 'wall_a')
@@ -448,7 +456,6 @@ describe('floorplan opening placement interaction routing', () => {
   test('passes entries through only while an opening tool or moving opening is active', () => {
     expect(
       isFloorplanOpeningPlacementState({
-        phase: 'structure',
         mode: 'build',
         tool: 'window',
         movingNodeHasWallOpeningPlacement: false,
@@ -456,7 +463,6 @@ describe('floorplan opening placement interaction routing', () => {
     ).toBe(true)
     expect(
       isFloorplanOpeningPlacementState({
-        phase: 'structure',
         mode: 'select',
         tool: null,
         movingNodeHasWallOpeningPlacement: true,
@@ -464,7 +470,6 @@ describe('floorplan opening placement interaction routing', () => {
     ).toBe(true)
     expect(
       isFloorplanOpeningPlacementState({
-        phase: 'structure',
         mode: 'select',
         tool: null,
         movingNodeHasWallOpeningPlacement: false,
@@ -780,3 +785,77 @@ describe('collectFloorplanLinkedLevelNodes', () => {
     ).toEqual([])
   })
 })
+
+describe('floorplan entry routing while a tool is active', () => {
+  test('build tools get presses on entries, as in 3D; select and delete keep selecting', () => {
+    expect(floorplanEntryYieldsToTool({ mode: 'build', openingPlacement: false })).toBe(true)
+    expect(floorplanEntryYieldsToTool({ mode: 'select', openingPlacement: true })).toBe(true)
+    expect(floorplanEntryYieldsToTool({ mode: 'select', openingPlacement: false })).toBe(false)
+    expect(floorplanEntryYieldsToTool({ mode: 'delete', openingPlacement: false })).toBe(false)
+  })
+})
+
+describe('isFloorplanHierarchyVisible', () => {
+  const node = (id: string, type: string, parentId: string | null, visible = true) =>
+    ({ object: 'node', id, type, parentId, visible, metadata: {} }) as unknown as AnyNode
+  const noOverrides = new Map<string, LiveNodeOverrides>()
+  const visibleUnder = (nodes: Record<string, AnyNode>, rootId: string, id: string) =>
+    isFloorplanHierarchyVisible(nodes[id]!, nodes, noOverrides, rootId as AnyNodeId)
+
+  test('a hidden Site root keeps the nodes on it, linked or detached', () => {
+    const nodes: Record<string, AnyNode> = {
+      site_a: node('site_a', 'site', null, false),
+      building_a: node('building_a', 'building', 'site_a'),
+      level_a: node('level_a', 'level', 'building_a'),
+      wall_a: node('wall_a', 'wall', 'level_a'),
+      wall_b: node('wall_b', 'wall', 'level_a', false),
+      tree_a: node('tree_a', 'trees:tree', null),
+    }
+    expect(visibleUnder(nodes, 'site_a', 'wall_a')).toBe(true)
+    expect(visibleUnder(nodes, 'site_a', 'tree_a')).toBe(true)
+    expect(visibleUnder(nodes, 'site_a', 'wall_b')).toBe(false)
+    expect(visibleUnder(nodes, 'site_a', 'site_a')).toBe(false)
+  })
+
+  test('a hidden building or level root still hides what it hosts', () => {
+    const nodes: Record<string, AnyNode> = {
+      site_a: node('site_a', 'site', null),
+      building_a: node('building_a', 'building', 'site_a', false),
+      level_a: node('level_a', 'level', 'building_a'),
+      wall_a: node('wall_a', 'wall', 'level_a'),
+      elevator_a: node('elevator_a', 'elevator', null),
+    }
+    expect(visibleUnder(nodes, 'site_a', 'wall_a')).toBe(false)
+    expect(visibleUnder(nodes, 'building_a', 'elevator_a')).toBe(false)
+    // A level plan is scoped to its level: the walk stops at the root and
+    // never consults the building above it.
+    expect(visibleUnder(nodes, 'level_a', 'wall_a')).toBe(true)
+  })
+})
+
+describe('the handles pass', () => {
+  test('grabbable handles leave the overlay for a pass of their own, under the same transform', () => {
+    const label = { kind: 'text', x: 0, y: 0, text: 'Wall 1' } as FloorplanGeometry
+    const corner = {
+      kind: 'endpoint-handle',
+      point: [1, 0],
+      state: 'idle',
+      affordance: 'move-endpoint',
+      payload: { wallId: 'wall_a', endpoint: 'end' },
+    } as FloorplanGeometry
+    const tree = {
+      kind: 'group',
+      transform: 'rotate(30)',
+      children: [label, { kind: 'group', children: [corner] }],
+    } as FloorplanGeometry
+    expect(splitFloorplanHandles(tree)).toEqual({
+      rest: { kind: 'group', transform: 'rotate(30)', children: [label] },
+      handles: {
+        kind: 'group',
+        transform: 'rotate(30)',
+        children: [{ kind: 'group', children: [corner] }],
+      },
+    } as never)
+    expect(splitFloorplanHandles(label)).toEqual({ rest: label, handles: null })
+  })
+})