@pascal-app/editor 0.9.2 → 1.0.0-beta.1

package/src/components/editor-2d/renderers/floorplan-label-angle.ts

@@ -12,3 +12,95 @@ export function resolveFloorplanLabelAngle(
   else if (screenAngleDeg <= -90) localAngleDeg += 180
   return ((((localAngleDeg + 180) % 360) + 360) % 360) - 180
 }
+
+export function shouldUpdateFloorplanLabelRotation(
+  previousRotationDeg: number | null,
+  nextRotationDeg: number,
+  minimumDeltaDeg = 1,
+): boolean {
+  if (previousRotationDeg === null) return true
+  const deltaDeg = ((((nextRotationDeg - previousRotationDeg + 180) % 360) + 360) % 360) - 180
+  return Math.abs(deltaDeg) >= minimumDeltaDeg
+}
+
+export function resolveFloorplanAnnotationUpdate({
+  layoutInputsChanged,
+  previousRotationDeg,
+  nextRotationDeg,
+}: {
+  layoutInputsChanged: boolean
+  previousRotationDeg: number | null
+  nextRotationDeg: number
+}): {
+  resolveCollisions: boolean
+  updateLabelPresentation: boolean
+} {
+  return {
+    resolveCollisions: layoutInputsChanged,
+    updateLabelPresentation:
+      layoutInputsChanged ||
+      shouldUpdateFloorplanLabelRotation(previousRotationDeg, nextRotationDeg),
+  }
+}
+
+export function resolveFloorplanAnnotationLabelTransform({
+  angleRadians,
+  sceneRotationDeg,
+  screenUpright,
+  beforeRotation,
+  afterRotation,
+  layoutDx = 0,
+  layoutDy = 0,
+}: {
+  angleRadians: number
+  sceneRotationDeg: number
+  screenUpright: boolean
+  beforeRotation: string
+  afterRotation: string
+  layoutDx?: number
+  layoutDy?: number
+}): {
+  defaultTransform: string
+  transform: string
+} {
+  const degrees = resolveFloorplanLabelAngle(angleRadians, sceneRotationDeg, screenUpright)
+  const defaultTransform = [beforeRotation, `rotate(${degrees})`, afterRotation]
+    .filter(Boolean)
+    .join(' ')
+  return {
+    defaultTransform,
+    transform:
+      layoutDx === 0 && layoutDy === 0
+        ? defaultTransform
+        : `${defaultTransform} translate(${layoutDx} ${layoutDy})`,
+  }
+}
+
+export function updateSvgFloorplanLabelOrientations(
+  labels: Iterable<SVGGElement>,
+  sceneRotationDeg: number,
+): number {
+  let updated = 0
+
+  for (const label of labels) {
+    const angleRadians = Number(label.dataset.floorplanAnnotationAngleRadians)
+    if (!Number.isFinite(angleRadians)) continue
+
+    const { defaultTransform, transform } = resolveFloorplanAnnotationLabelTransform({
+      angleRadians,
+      sceneRotationDeg,
+      screenUpright: label.dataset.floorplanAnnotationScreenUpright === 'true',
+      beforeRotation: label.dataset.floorplanAnnotationTransformBeforeRotation ?? '',
+      afterRotation: label.dataset.floorplanAnnotationTransformAfterRotation ?? '',
+      layoutDx: Number(label.dataset.floorplanAnnotationLayoutDx ?? 0),
+      layoutDy: Number(label.dataset.floorplanAnnotationLayoutDy ?? 0),
+    })
+    if (label.getAttribute('transform') === transform) continue
+
+    label.dataset.floorplanAnnotationDefaultTransform = defaultTransform
+    label.setAttribute('transform', transform)
+    updated += 1
+  }
+
+  return updated
+}

package/src/components/editor-2d/renderers/floorplan-placement-preview-layer.tsx

@@ -8,10 +8,98 @@ import {
   nodeRegistry,
   useScene,
 } from '@pascal-app/core'
-import { memo } from 'react'
+import { useViewer } from '@pascal-app/viewer'
+import { memo, useMemo } from 'react'
 import usePlacementPreview from '../../../store/use-placement-preview'
+import { useFloorplanRender } from '../floorplan-render-context'
 import { FloorplanGeometryRenderer } from './floorplan-geometry-renderer'
 
+export interface FloorplanNodePreviewProps {
+  node: AnyNode
+  parentNode?: AnyNode | null
+  opacity?: number
+  className?: string
+  selected?: boolean
+  highlighted?: boolean
+  hovered?: boolean
+  moving?: boolean
+}
+
+/**
+ * Stateless floor-plan ghost for an already-positioned node. Hosts can use
+ * this to render host-owned placement previews without publishing transient
+ * state into the editor's local placement-preview store.
+ */
+export const FloorplanNodePreview = memo(function FloorplanNodePreview({
+  node,
+  parentNode = null,
+  opacity = 0.5,
+  className,
+  selected = false,
+  highlighted = false,
+  hovered = false,
+  moving = false,
+}: FloorplanNodePreviewProps) {
+  const nodes = useScene((state) => state.nodes)
+  const unit = useViewer((state) => state.unit)
+  const renderContext = useFloorplanRender()
+
+  const geometry = useMemo(() => {
+    const definition = nodeRegistry.get(node.type)
+    const builder = definition?.floorplan
+    if (!builder) return null
+
+    const contextNodes: Record<string, AnyNode> = {
+      ...(nodes as Record<string, AnyNode>),
+      [node.id]: node,
+    }
+    if (parentNode) contextNodes[parentNode.id] = parentNode
+    const resolvedParent =
+      parentNode ?? (node.parentId ? (contextNodes[node.parentId] ?? null) : null)
+    const childIds = (node as AnyNode & { children?: AnyNodeId[] }).children ?? []
+    const children = childIds.flatMap((id) => {
+      const child = contextNodes[id]
+      return child ? [child] : []
+    })
+    const siblings = Object.values(contextNodes).filter(
+      (candidate) =>
+        candidate.id !== node.id &&
+        candidate.type === node.type &&
+        candidate.parentId === node.parentId,
+    )
+    const levelData = definition.computeFloorplanLevelData?.({
+      siblings: [node, ...siblings],
+      nodes: contextNodes,
+    })
+    const ctx: GeometryContext = {
+      resolve: <N = AnyNode>(id: AnyNodeId) => contextNodes[id] as N | undefined,
+      children,
+      siblings,
+      parent: resolvedParent,
+      levelData,
+      viewState: renderContext
+        ? {
+            selected,
+            unit,
+            highlighted,
+            hovered,
+            moving,
+            palette: renderContext.palette,
+          }
+        : undefined,
+    }
+
+    return (builder as (n: AnyNode, c: GeometryContext) => FloorplanGeometry | null)(node, ctx)
+  }, [highlighted, hovered, moving, node, nodes, parentNode, renderContext, selected, unit])
+  if (!geometry) return null
+
+  return (
+    <g className={className} opacity={opacity} pointerEvents="none">
+      <FloorplanGeometryRenderer geometry={geometry} pointerEventsOverride="none" />
+    </g>
+  )
+})
+
 /**
  * Renders a faint, non-interactive ghost of the node being placed by a
  * registry placement tool (e.g. column), following the cursor in the floor
@@ -20,7 +108,8 @@ import { FloorplanGeometryRenderer } from './floorplan-geometry-renderer'
  * cursor dot + alignment guides — no sense of the footprint they were about
  * to drop. The placement tool publishes a transient, already-positioned +
  * aligned node to `usePlacementPreview`; we build its `def.floorplan`
- * footprint with a minimal (unselected) context and render it.
+ * footprint with active sibling, level-data, and theme context so kind-specific
+ * shapes match the committed renderer.
  *
  * Mounted inside the floor-plan scene `<g>` so the geometry's level-local
  * meters get the same world→SVG transform every other entry does.
@@ -30,33 +119,9 @@ export const FloorplanPlacementPreviewLayer = memo(function FloorplanPlacementPr
   const parentNode = usePlacementPreview((s) => s.parentNode)
   if (!node) return null
 
-  const builder = nodeRegistry.get(node.type)?.floorplan
-  if (!builder) return null
-
-  // Minimal, unselected context — preview never shows selection chrome
-  // (move handles / resize arrows / hatch live behind `viewState.selected`).
-  // `resolve` reads the scene lazily (a builder rarely calls it for a ghost,
-  // and `parent: null` short-circuits the elevator's level walk) so the layer
-  // never subscribes to / bulk-reads the nodes map during render.
-  // `parentNode` is the synthetic wall for an off-wall door/window ghost so
-  // its builder draws the real swing-arc / pane symbol (see use-placement-preview).
-  const ctx = {
-    resolve: (id: AnyNodeId) => useScene.getState().nodes[id],
-    children: [],
-    siblings: [],
-    parent: parentNode ?? null,
-    viewState: undefined,
-  } as unknown as GeometryContext
-
-  const geometry = (builder as (n: AnyNode, c: GeometryContext) => FloorplanGeometry | null)(
-    node,
-    ctx,
-  )
-  if (!geometry) return null
-
   return (
-    <g data-floorplan-placement-preview opacity={0.5} pointerEvents="none">
-      <FloorplanGeometryRenderer geometry={geometry} />
+    <g data-floorplan-placement-preview>
+      <FloorplanNodePreview node={node} parentNode={parentNode} />
     </g>
   )
 })

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

@@ -3,18 +3,100 @@ import type {
   AnyNode,
   AnyNodeId,
   FloorplanAffordanceSession,
+  FloorplanGeometry,
+  FloorplanPalette,
   LiveNodeOverrides,
 } from '@pascal-app/core'
 import { type AnyNodeDefinition, emitter, nodeRegistry, registerNode } from '@pascal-app/core'
+import { createElement } from 'react'
+import { renderToStaticMarkup } from 'react-dom/server'
 import { z } from 'zod'
+import {
+  FLOORPLAN_NODE_EXTENSION_KEY,
+  floorplanGeometryMetadata,
+} from '../../../lib/floorplan/floorplan-extension'
 import {
   cancelFloorplanAffordanceDrag,
   collectFloorplanDependencyNodes,
+  collectFloorplanLinkedLevelNodes,
   computeAffectedSiblingIds,
+  floorplanAffordanceReshapeScope,
   floorplanHandleDoubleClickAffordance,
+  InteractiveGeometry,
+  isFloorplanOpeningPlacementState,
+  resolveFloorplanHandleUnitsPerPixel,
+  splitFloorplanOverlay,
   subscribeFloorplanAffordanceToolCancel,
 } from './floorplan-registry-layer'
 
+describe('floorplan selection handle sizing', () => {
+  test('caps visual handle growth at extreme zoom-out', () => {
+    expect(resolveFloorplanHandleUnitsPerPixel(0.01)).toBe(0.01)
+    expect(resolveFloorplanHandleUnitsPerPixel(0.1)).toBe(0.015)
+
+    const palette = {
+      selectedStroke: '#111111',
+      selectedFill: '#ffffff',
+      selectedHatch: '#111111',
+      wallHoverStroke: '#111111',
+      endpointHandleFill: '#ffffff',
+      endpointHandleStroke: '#111111',
+      endpointHandleHoverStroke: '#222222',
+      endpointHandleActiveFill: '#333333',
+      endpointHandleActiveStroke: '#444444',
+      curveHandleFill: '#ffffff',
+      curveHandleStroke: '#008080',
+      curveHandleHoverStroke: '#00aaaa',
+      measurementStroke: '#111111',
+      measurementLabelBackground: '#ffffff',
+      measurementLabelText: '#111111',
+    } satisfies FloorplanPalette
+    const noop = () => {}
+    const markup = renderToStaticMarkup(
+      createElement(
+        'svg',
+        null,
+        createElement(InteractiveGeometry, {
+          activeDragId: null,
+          activeRotateNodeId: null,
+          geometry: {
+            kind: 'endpoint-handle',
+            point: [0, 0],
+            state: 'idle',
+            affordance: 'move-endpoint',
+            payload: { endpoint: 'start' },
+          },
+          hatchPatternId: undefined,
+          hoveredHandleId: null,
+          isMarqueeSelectionActive: false,
+          nodeId: 'wall_test' as AnyNodeId,
+          onHandleDoubleClick: noop,
+          onHandleHoverChange: noop,
+          onHandlePointerDown: noop,
+          onMoveHandlePointerDown: noop,
+          palette,
+          sceneRotationDeg: 0,
+          unitsPerPixel: 0.1,
+        }),
+      ),
+    )
+
+    expect(markup).toContain('r="0.12"')
+    expect(markup).not.toContain('r="0.8"')
+  })
+})
+
+describe('floorplan affordance ownership', () => {
+  test('keeps the wall center curve drag owned by the floorplan dispatcher', () => {
+    expect(floorplanAffordanceReshapeScope('wall-curve', 'wall_1', undefined)).toEqual({
+      kind: 'reshaping',
+      nodeId: 'wall_1',
+      reshape: 'curve',
+      driver: 'floorplan',
+    })
+  })
+})
+
 function cabinetRun(id: string, children: string[] = [], parentId: string | null = 'level_test') {
   return {
     id,
@@ -185,6 +267,35 @@ describe('floorplan affordance cancellation', () => {
   })
 })
 
+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,
+      }),
+    ).toBe(true)
+    expect(
+      isFloorplanOpeningPlacementState({
+        phase: 'structure',
+        mode: 'select',
+        tool: null,
+        movingNodeHasWallOpeningPlacement: true,
+      }),
+    ).toBe(true)
+    expect(
+      isFloorplanOpeningPlacementState({
+        phase: 'structure',
+        mode: 'select',
+        tool: null,
+        movingNodeHasWallOpeningPlacement: false,
+      }),
+    ).toBe(false)
+  })
+})
+
 describe('floorplan vertex double-click routing', () => {
   test('routes polygon vertex handles to the kind-owned delete affordance', () => {
     expect(
@@ -209,6 +320,132 @@ describe('floorplan vertex double-click routing', () => {
   })
 })
 
+describe('floorplan annotation overlay routing', () => {
+  test('keeps explicitly layered selection chrome above selected body fills', () => {
+    const selectionHatch = {
+      kind: 'line',
+      x1: 0,
+      y1: 0,
+      x2: 0.2,
+      y2: 0.2,
+      stroke: '#3b82f6',
+      metadata: floorplanGeometryMetadata({ renderPass: 'overlay' }),
+    } satisfies FloorplanGeometry
+
+    expect(splitFloorplanOverlay(selectionHatch)).toEqual({
+      base: null,
+      overlay: selectionHatch,
+    })
+  })
+
+  test('registers upright zone labels for rotation-only presentation updates', () => {
+    const noop = () => {}
+    const markup = renderToStaticMarkup(
+      createElement(
+        'svg',
+        null,
+        createElement(InteractiveGeometry, {
+          activeDragId: null,
+          activeRotateNodeId: null,
+          geometry: {
+            kind: 'text',
+            x: 4,
+            y: 6,
+            text: 'Kitchen',
+            fontSize: 0.2,
+            upright: true,
+          },
+          hatchPatternId: undefined,
+          hoveredHandleId: null,
+          isMarqueeSelectionActive: false,
+          nodeId: 'zone_test' as AnyNodeId,
+          onHandleDoubleClick: noop,
+          onHandleHoverChange: noop,
+          onHandlePointerDown: noop,
+          onMoveHandlePointerDown: noop,
+          palette: undefined,
+          sceneRotationDeg: 180,
+          unitsPerPixel: 0.01,
+        }),
+      ),
+    )
+
+    expect(markup).not.toContain('data-floorplan-annotation-label=""')
+    expect(markup).toContain('data-floorplan-annotation-angle-radians="0"')
+    expect(markup).toContain('data-floorplan-annotation-screen-upright="true"')
+    expect(markup).toContain('data-floorplan-annotation-transform-before-rotation="translate(4 6)"')
+    expect(markup).toContain('transform="translate(4 6) rotate(-180)"')
+  })
+
+  test('keeps automatic dimension strings left-to-right and top-to-bottom after rotation', () => {
+    const noop = () => {}
+    const renderAt180Degrees = (geometry: FloorplanGeometry) =>
+      renderToStaticMarkup(
+        createElement(
+          'svg',
+          null,
+          createElement(InteractiveGeometry, {
+            activeDragId: null,
+            activeRotateNodeId: null,
+            geometry,
+            hatchPatternId: undefined,
+            hoveredHandleId: null,
+            isMarqueeSelectionActive: false,
+            nodeId: 'wall_test' as AnyNodeId,
+            onHandleDoubleClick: noop,
+            onHandleHoverChange: noop,
+            onHandlePointerDown: noop,
+            onMoveHandlePointerDown: noop,
+            palette: undefined,
+            sceneRotationDeg: 180,
+            unitsPerPixel: 0.01,
+          }),
+        ),
+      )
+    const dimensionString = (
+      end: readonly [number, number],
+      offsetNormal: readonly [number, number],
+    ): FloorplanGeometry => ({
+      kind: 'dimension-string',
+      segments: [{ start: [0, 0], end, text: '2m' }],
+      offsetNormal,
+      offsetDistance: 0.55,
+      extensionOvershoot: 0.12,
+      textPosition: 'above',
+    })
+
+    expect(renderAt180Degrees(dimensionString([2, 0], [0, 1]))).toContain('rotate(-180)')
+    expect(renderAt180Degrees(dimensionString([0, 2], [1, 0]))).toContain('rotate(-90)')
+  })
+
+  test('keeps a fixed mark pill together in the overlay pass', () => {
+    const mark = {
+      kind: 'group',
+      metadata: floorplanGeometryMetadata({ annotationRole: 'opening-mark' }),
+      children: [
+        { kind: 'line', x1: 0, y1: 0, x2: 0, y2: 0.4 },
+        { kind: 'rect', x: -0.2, y: 0.4, width: 0.4, height: 0.32 },
+        { kind: 'text', x: 0, y: 0.56, text: '107', fontSize: 0.15, upright: true },
+      ],
+    } satisfies FloorplanGeometry
+
+    expect(splitFloorplanOverlay(mark)).toEqual({ base: null, overlay: mark })
+  })
+
+  test('keeps fixed annotation symbols in the overlay pass for collision layout', () => {
+    const columnCenter = {
+      kind: 'line',
+      x1: 0,
+      y1: 0,
+      x2: 1,
+      y2: 0,
+      metadata: floorplanGeometryMetadata({ annotationRole: 'column-center' }),
+    } satisfies FloorplanGeometry
+
+    expect(splitFloorplanOverlay(columnCenter)).toEqual({ base: null, overlay: columnCenter })
+  })
+})
+
 describe('computeAffectedSiblingIds', () => {
   beforeEach(() => {
     nodeRegistry._reset()
@@ -306,3 +543,45 @@ describe('collectFloorplanDependencyNodes', () => {
     ])
   })
 })
+
+describe('collectFloorplanLinkedLevelNodes', () => {
+  test('projects a node onto a linked destination level with its real children', () => {
+    nodeRegistry._reset()
+    registerNode({
+      kind: 'linked-floorplan-test',
+      schemaVersion: 1,
+      schema: z.object({ type: z.literal('linked-floorplan-test') }) as never,
+      category: 'structure',
+      defaults: () => ({}) as never,
+      floorplan: () => null,
+      extensions: {
+        [FLOORPLAN_NODE_EXTENSION_KEY]: {
+          linkedLevelIds: () => ['level_upper' as AnyNodeId],
+        },
+      },
+    } as unknown as AnyNodeDefinition)
+    const child = {
+      id: 'linked_child',
+      type: 'linked-child',
+      parentId: 'linked_parent',
+    } as unknown as AnyNode
+    const parent = {
+      id: 'linked_parent',
+      type: 'linked-floorplan-test',
+      parentId: 'level_lower',
+      children: [child.id],
+    } as unknown as AnyNode
+    const nodes = { [parent.id]: parent, [child.id]: child }
+
+    expect(collectFloorplanLinkedLevelNodes(nodes, 'level_upper' as AnyNodeId)).toEqual([
+      { id: parent.id, node: parent, children: [child] },
+    ])
+    expect(
+      collectFloorplanLinkedLevelNodes(
+        nodes,
+        'level_upper' as AnyNodeId,
+        new Set([parent.id as AnyNodeId]),
+      ),
+    ).toEqual([])
+  })
+})