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

package/src/components/tools/wall/wall-drafting.test.ts

@@ -1,14 +1,22 @@
-import { beforeEach, describe, expect, test } from 'bun:test'
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
 import {
   type AnyNode,
   type AnyNodeId,
   applyHeightPatch,
+  BlockNode,
+  CeilingNode,
   createTerrainField,
   DoorNode as DoorSchema,
   encodeTerrainField,
   flattenPatch,
   GROUND_SUPPORT_ID,
+  getFloorPlacedElevation,
+  initSpaceDetectionSync,
+  nodeRegistry,
+  registerNode,
+  resolveTerrainWallConstructionOptions,
   runAsSingleSceneHistoryStep,
+  SlabNode,
   spatialGridManager,
   useScene,
   type WallNode,
@@ -20,7 +28,6 @@ import useInteractionScope from '../../../store/use-interaction-scope'
 import {
   createWallOnCurrentLevel,
   resolveEndpointWallSplit,
-  resolveTerrainWallConstructionOptions,
   snapWallDraftPointDetailed,
 } from './wall-drafting'
 import type { WallPlanPoint } from './wall-snap-geometry'
@@ -56,7 +63,7 @@ function seedLevel(walls: WallNode[], extraNodes: AnyNode[] = []) {
           parentId: null,
           visible: true,
           metadata: {},
-          children: walls.map((wall) => wall.id),
+          children: [...walls.map((wall) => wall.id), ...extraNodes.map((node) => node.id)],
           level: 0,
         } as AnyNode,
       ],
@@ -69,6 +76,66 @@ function seedLevel(walls: WallNode[], extraNodes: AnyNode[] = []) {
   } as never)
 }
 
+// Seeds a site/building/level chain whose terrain field carries a sculpted
+// patch raised to `liftTo` in the far corner — enough for ground drafts to be
+// terrain chains, while the walls under test stand where the ground is 0.
+function seedTerrainLevel(walls: WallNode[], liftTo: number) {
+  const field = createTerrainField({ cols: 9, rows: 9, spacing: 1, origin: [-4, -4] })
+  const patch = flattenPatch(field, { maxX: -2, maxZ: -2, minX: -4, minZ: -4 }, liftTo)
+  if (!patch) throw new Error('Expected terrain patch')
+  const terrain = applyHeightPatch(field, patch)
+  useScene.setState({
+    nodes: Object.fromEntries([
+      [
+        'site_test',
+        {
+          id: 'site_test',
+          type: 'site',
+          object: 'node',
+          parentId: null,
+          visible: true,
+          metadata: {},
+          children: ['building_test'],
+          terrain: encodeTerrainField(terrain),
+        } as unknown as AnyNode,
+      ],
+      [
+        'building_test',
+        {
+          id: 'building_test',
+          type: 'building',
+          object: 'node',
+          parentId: 'site_test',
+          visible: true,
+          metadata: {},
+          children: [LEVEL_ID],
+          position: [0, 0, 0],
+          rotation: [0, 0, 0],
+        } as AnyNode,
+      ],
+      [
+        LEVEL_ID,
+        {
+          id: LEVEL_ID,
+          type: 'level',
+          object: 'node',
+          parentId: 'building_test',
+          visible: true,
+          metadata: {},
+          children: walls.map((wall) => wall.id),
+          level: 0,
+          baseElevation: 0,
+          height: 2.5,
+        } as AnyNode,
+      ],
+      ...walls.map((wall) => [wall.id, wall] as const),
+    ]),
+    rootNodeIds: ['site_test' as AnyNodeId],
+    dirtyNodes: new Set(),
+    collections: {},
+  } as never)
+}
+
 function levelWalls(): WallNode[] {
   return Object.values(useScene.getState().nodes).filter(
     (node): node is WallNode => node?.type === 'wall',
@@ -76,6 +143,15 @@ function levelWalls(): WallNode[] {
 }
 
 describe('createWallOnCurrentLevel', () => {
+  // Set by tests that mutate the process-wide node registry; restored here
+  // so the mutation can't leak into later test files (order-dependent flakes).
+  let restoreRegistry: (() => void) | undefined
+
+  afterEach(() => {
+    restoreRegistry?.()
+    restoreRegistry = undefined
+  })
+
   beforeEach(() => {
     useViewer.setState({
       selection: {
@@ -109,7 +185,9 @@ describe('createWallOnCurrentLevel', () => {
     expect(levelWalls()).toHaveLength(2)
   })
 
-  test('committed wall preserves the ghost construction elevation on ground', () => {
+  test('committed wall preserves the ghost construction elevation on terrain', () => {
+    seedTerrainLevel([makeWall([0, 0], [4, 0], 'wall_a')], 1.75)
+
     const created = createWallOnCurrentLevel([2, 2], [3, 2], {
       supportCap: 1.75,
       preferredSupportSlabId: GROUND_SUPPORT_ID,
@@ -133,6 +211,374 @@ describe('createWallOnCurrentLevel', () => {
     expect(support.elevation).toBe(1.75)
   })
 
+  test('never exposes a raised wall at floor elevation during commit', () => {
+    const observed: WallNode[] = []
+    const unsubscribe = useScene.subscribe((state) => {
+      const wall = Object.values(state.nodes).find(
+        (node): node is WallNode => node?.type === 'wall' && node.id !== 'wall_a',
+      )
+      if (wall) observed.push(wall)
+    })
+
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 1.75,
+      preferredSupportSlabId: GROUND_SUPPORT_ID,
+      constructionElevation: 1.75,
+      constructionHeight: 2.5,
+      flatConstructionBase: true,
+    })
+    unsubscribe()
+
+    expect(created).not.toBeNull()
+    expect(observed.length).toBeGreaterThan(0)
+    expect(observed.every((wall) => wall.supportSlabId === GROUND_SUPPORT_ID)).toBe(true)
+    expect(observed.every((wall) => wall.supportOffset === 1.75)).toBe(true)
+  })
+
+  test('keeps a node-top room plane flat across changing terrain', () => {
+    const field = createTerrainField({ cols: 5, rows: 5, spacing: 1, origin: [0, 0] })
+    const patch = flattenPatch(field, { minX: 3.5, minZ: 0, maxX: 4, maxZ: 4 }, 1)
+    if (!patch) throw new Error('Expected terrain patch')
+    const terrain = applyHeightPatch(field, patch)
+    const site = {
+      id: 'site_test',
+      type: 'site',
+      object: 'node',
+      parentId: null,
+      visible: true,
+      metadata: {},
+      children: ['building_test'],
+      terrain: encodeTerrainField(terrain),
+    } as unknown as AnyNode
+    const building = {
+      id: 'building_test',
+      type: 'building',
+      object: 'node',
+      parentId: site.id,
+      visible: true,
+      metadata: {},
+      children: [LEVEL_ID],
+      position: [0, 0, 0],
+      rotation: [0, 0, 0],
+    } as AnyNode
+    const level = {
+      id: LEVEL_ID,
+      type: 'level',
+      object: 'node',
+      parentId: building.id,
+      visible: true,
+      metadata: {},
+      children: [],
+      level: 0,
+      baseElevation: 0,
+      height: 3,
+    } as AnyNode
+    useScene.setState({
+      nodes: Object.fromEntries([site, building, level].map((node) => [node.id, node])),
+      rootNodeIds: [site.id],
+      dirtyNodes: new Set(),
+    } as never)
+
+    const lowTerrainWall = createWallOnCurrentLevel([0, 0], [1, 0], {
+      constructionElevation: 3,
+      constructionHeight: 2.5,
+      flatConstructionBase: true,
+      supportCap: 3,
+    })
+    const highTerrainWall = createWallOnCurrentLevel([4, 0], [4, 1], {
+      constructionElevation: 3,
+      constructionHeight: 2.5,
+      flatConstructionBase: true,
+      supportCap: 3,
+    })
+
+    expect(lowTerrainWall?.supportSlabId).toBe(GROUND_SUPPORT_ID)
+    expect(highTerrainWall?.supportSlabId).toBe(GROUND_SUPPORT_ID)
+    expect(lowTerrainWall?.supportOffset).toBeCloseTo(3)
+    expect(highTerrainWall?.supportOffset).toBeCloseTo(2)
+    expect(
+      spatialGridManager.getSlabSupportForWall(
+        LEVEL_ID,
+        lowTerrainWall!.start,
+        lowTerrainWall!.end,
+        lowTerrainWall!.curveOffset,
+        lowTerrainWall!.thickness,
+        lowTerrainWall!.supportSlabId,
+        undefined,
+        lowTerrainWall!.supportOffset,
+      ).elevation,
+    ).toBeCloseTo(3)
+    expect(
+      spatialGridManager.getSlabSupportForWall(
+        LEVEL_ID,
+        highTerrainWall!.start,
+        highTerrainWall!.end,
+        highTerrainWall!.curveOffset,
+        highTerrainWall!.thickness,
+        highTerrainWall!.supportSlabId,
+        undefined,
+        highTerrainWall!.supportOffset,
+      ).elevation,
+    ).toBeCloseTo(3)
+  })
+
+  test('pins an existing construction source before a generated room slab can lift it', () => {
+    // The reset + throwaway `block` registration is scoped to this test —
+    // the registry is a process-wide singleton, so leaking it would leave
+    // later test FILES with a stripped registry (order-dependent flakes).
+    restoreRegistry = nodeRegistry._snapshot()
+    nodeRegistry._reset()
+    spatialGridManager.clear()
+    registerNode({
+      kind: 'block',
+      schemaVersion: 2,
+      schema: BlockNode,
+      category: 'structure',
+      defaults: () => BlockNode.parse({ name: 'Block' }),
+      capabilities: {
+        floorPlaced: {
+          footprint: () => ({ dimensions: [4, 2.4, 4], rotation: [0, 0, 0] }),
+        },
+      },
+    } as never)
+
+    const slope = BlockNode.parse({
+      name: 'Existing slope',
+      parentId: LEVEL_ID,
+      position: [0, 0, 0],
+    })
+    seedLevel([makeWall([0, 0], [4, 0], 'wall_a')], [slope as AnyNode])
+
+    createWallOnCurrentLevel([0, 1], [1, 1], {
+      constructionElevation: 2.4,
+      constructionHeight: 2.5,
+      constructionSourceNodeId: slope.id,
+      flatConstructionBase: true,
+      supportCap: 2.4,
+    })
+
+    const pinnedSlope = useScene.getState().nodes[slope.id] as BlockNode
+    expect(pinnedSlope.supportSlabId).toBe(GROUND_SUPPORT_ID)
+
+    const generatedSlab = SlabNode.parse({
+      polygon: [
+        [-2, -2],
+        [2, -2],
+        [2, 2],
+        [-2, 2],
+      ],
+      elevation: 2.45,
+      autoFromWalls: true,
+      parentId: LEVEL_ID,
+    })
+    spatialGridManager.handleNodeCreated(generatedSlab as AnyNode, LEVEL_ID)
+
+    expect(
+      getFloorPlacedElevation({
+        node: pinnedSlope,
+        nodes: {
+          ...useScene.getState().nodes,
+          [generatedSlab.id]: generatedSlab as AnyNode,
+        },
+        position: pinnedSlope.position,
+        rotation: [0, pinnedSlope.rotation, 0],
+      }),
+    ).toBe(0)
+  })
+
+  test('a flat-ground draft (no sculpted terrain) commits plane-bound', () => {
+    // Pointing at bare ground freezes a GROUND construction plane at 0. With
+    // no terrain field in the scene that plane is just the backdrop — none of
+    // the draft options may reach the committed node: no stamped height, no
+    // persisted ground host (a slab drawn later must lift the wall), no
+    // election cap.
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 0,
+      preferredSupportSlabId: GROUND_SUPPORT_ID,
+      constructionElevation: 0,
+      constructionHeight: 2.5,
+    })
+
+    expect(created).not.toBeNull()
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+    expect(created?.supportSlabId).toBeUndefined()
+  })
+
+  test('a wall started on a slab stays plane-bound (no stamped height or offset)', () => {
+    const slab = SlabNode.parse({
+      id: 'slab_floor',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-1, -1],
+        [5, -1],
+        [5, 5],
+        [-1, 5],
+      ],
+      elevation: 0.05,
+      thickness: 0.05,
+    })
+    seedLevel([makeWall([0, 0], [4, 0], 'wall_a')], [slab])
+
+    // Mirrors the 3D tool's first click on the slab top: frozen plane at the
+    // slab elevation, ghost drawn at the level height. None of it may reach
+    // the committed node — plane-bound is the default.
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 0.05,
+      preferredSupportSlabId: slab.id,
+      constructionElevation: 0.05,
+      constructionHeight: 2.55,
+    })
+
+    expect(created).not.toBeNull()
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+    expect(created?.supportSlabId).not.toBe(GROUND_SUPPORT_ID)
+  })
+
+  test('a fresh-scene wall started on a slab node-top elects that slab plane-bound', () => {
+    const slab = SlabNode.parse({
+      id: 'slab_fresh_floor',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-1, -1],
+        [5, -1],
+        [5, 5],
+        [-1, 5],
+      ],
+      elevation: 0.05,
+      thickness: 0.05,
+    })
+    seedLevel([], [slab])
+    spatialGridManager.clear()
+    spatialGridManager.handleNodeCreated(slab as AnyNode, LEVEL_ID)
+
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 0.05,
+      preferredSupportSlabId: null,
+      constructionElevation: 0.05,
+      constructionHeight: 2.5,
+      constructionSourceNodeId: slab.id,
+      flatConstructionBase: true,
+    })
+
+    expect(created).not.toBeNull()
+    expect(created?.supportSlabId).toBeUndefined()
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+    const support = spatialGridManager.getSlabSupportForWall(
+      LEVEL_ID,
+      created!.start,
+      created!.end,
+      created!.curveOffset,
+      created!.thickness,
+      created!.supportSlabId,
+    )
+    expect(support.electedSlabId).toBe(slab.id)
+    expect(support.elevation).toBeCloseTo(0.05)
+  })
+
+  test('a direct slab source does not pin a cross-slab wall away from the higher majority support', () => {
+    const sourceSlab = SlabNode.parse({
+      id: 'slab_source_low',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-0.1, -1],
+        [0.1, -1],
+        [0.1, 1],
+        [-0.1, 1],
+      ],
+      elevation: 0.1,
+      thickness: 0.05,
+    })
+    const majoritySlab = SlabNode.parse({
+      id: 'slab_majority_high',
+      parentId: LEVEL_ID,
+      polygon: [
+        [0.1, -1],
+        [4.1, -1],
+        [4.1, 1],
+        [0.1, 1],
+      ],
+      elevation: 0.6,
+      thickness: 0.1,
+    })
+    seedLevel([], [sourceSlab, majoritySlab])
+    spatialGridManager.clear()
+    spatialGridManager.handleNodeCreated(sourceSlab as AnyNode, LEVEL_ID)
+    spatialGridManager.handleNodeCreated(majoritySlab as AnyNode, LEVEL_ID)
+
+    const created = createWallOnCurrentLevel([0, 0], [4, 0], {
+      supportCap: 0.6,
+      preferredSupportSlabId: null,
+      constructionElevation: 0.1,
+      constructionHeight: 2.5,
+      constructionSourceNodeId: sourceSlab.id,
+      flatConstructionBase: true,
+    })
+
+    expect(created?.supportSlabId).toBe(majoritySlab.id)
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+  })
+
+  test('a grazing direct slab source does not override the commit elevation cap', () => {
+    const sourceSlab = SlabNode.parse({
+      id: 'slab_source_high',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-0.1, -1],
+        [0.1, -1],
+        [0.1, 1],
+        [-0.1, 1],
+      ],
+      elevation: 0.6,
+      thickness: 0.1,
+    })
+    const cappedSlab = SlabNode.parse({
+      id: 'slab_capped_low',
+      parentId: LEVEL_ID,
+      polygon: [
+        [-0.1, -1],
+        [4.1, -1],
+        [4.1, 1],
+        [-0.1, 1],
+      ],
+      elevation: 0.1,
+      thickness: 0.05,
+    })
+    seedLevel([], [sourceSlab, cappedSlab])
+    spatialGridManager.clear()
+    spatialGridManager.handleNodeCreated(sourceSlab as AnyNode, LEVEL_ID)
+    spatialGridManager.handleNodeCreated(cappedSlab as AnyNode, LEVEL_ID)
+
+    const created = createWallOnCurrentLevel([0, 0], [4, 0], {
+      supportCap: 0.1,
+      preferredSupportSlabId: null,
+      constructionElevation: 0.6,
+      constructionHeight: 2.5,
+      constructionSourceNodeId: sourceSlab.id,
+      flatConstructionBase: true,
+    })
+
+    expect(created?.supportSlabId).toBe(cappedSlab.id)
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+  })
+
+  test('a non-ground draft never freezes the ghost height, even at a raised plane', () => {
+    const created = createWallOnCurrentLevel([2, 2], [3, 2], {
+      supportCap: 1.2,
+      preferredSupportSlabId: null,
+      constructionElevation: 1.2,
+      constructionHeight: 2.5,
+    })
+
+    expect(created).not.toBeNull()
+    expect(created?.height).toBeUndefined()
+    expect(created?.supportOffset).toBeUndefined()
+  })
+
   test('2D terrain construction options freeze the first-point elevation and wall height', () => {
     const field = createTerrainField({ cols: 5, rows: 5, spacing: 1, origin: [-2, -2] })
     const patch = flattenPatch(field, { minX: -2, minZ: -2, maxX: 2, maxZ: 2 }, 1.5)
@@ -168,6 +614,7 @@ describe('createWallOnCurrentLevel', () => {
       metadata: {},
       children: [],
       level: 0,
+      baseElevation: 0,
       height: 3,
     } as AnyNode
     const nodes = Object.fromEntries([site, building, level].map((node) => [node.id, node]))
@@ -261,6 +708,82 @@ describe('createWallOnCurrentLevel', () => {
     expect(created).not.toBeNull()
     expect(useScene.temporal.getState().pastStates.length - before).toBe(1)
   })
+
+  test('a crossing splits both the host and the inserted wall in one undo step', () => {
+    const before = useScene.temporal.getState().pastStates.length
+
+    const created = createWallOnCurrentLevel([2, -2], [2, 2])
+
+    expect(created?.start).toEqual([2, 0])
+    expect(created?.end).toEqual([2, 2])
+    expect(useScene.getState().nodes['wall_a' as AnyNodeId]).toBeUndefined()
+    expect(levelWalls()).toHaveLength(4)
+    expect(useScene.temporal.getState().pastStates.length - before).toBe(1)
+  })
+
+  test('a room divider splits customized auto slabs and ceilings', () => {
+    const walls = [
+      makeWall([0, 0], [8, 0], 'wall_bottom'),
+      makeWall([8, 0], [8, 6], 'wall_right'),
+      makeWall([8, 6], [0, 6], 'wall_top'),
+      makeWall([0, 6], [0, 0], 'wall_left'),
+    ]
+    const slab = SlabNode.parse({
+      id: 'slab_auto',
+      parentId: LEVEL_ID,
+      polygon: [
+        [0, 0],
+        [8, 0],
+        [8, 6],
+        [0, 6],
+      ],
+      elevation: 0.18,
+      thickness: 0.32,
+      autoFromWalls: true,
+    })
+    const ceiling = CeilingNode.parse({
+      id: 'ceiling_auto',
+      parentId: LEVEL_ID,
+      polygon: slab.polygon,
+      autoFromWalls: true,
+    })
+    seedLevel(walls, [slab, ceiling])
+    const stopDetection = initSpaceDetectionSync(useScene, useEditor)
+
+    try {
+      expect(createWallOnCurrentLevel([4, 0], [4, 6])).not.toBeNull()
+
+      const nodes = Object.values(useScene.getState().nodes)
+      const slabs = nodes.filter((node) => node.type === 'slab')
+      const ceilings = nodes.filter((node) => node.type === 'ceiling')
+      expect(slabs).toHaveLength(2)
+      expect(ceilings).toHaveLength(2)
+      expect(
+        slabs.every(
+          (node) => node.autoFromWalls && node.elevation === 0.18 && node.thickness === 0.32,
+        ),
+      ).toBe(true)
+      expect(ceilings.every((node) => node.autoFromWalls)).toBe(true)
+    } finally {
+      stopDetection()
+    }
+  })
+
+  test('close crossings reject the whole insertion without mutating the scene', () => {
+    seedLevel([
+      makeWall([2, -2], [2, 2], 'wall_close_a'),
+      makeWall([2.0055, -2], [2.0055, 2], 'wall_close_b'),
+    ])
+    useScene.temporal.getState().clear()
+    const beforeNodes = useScene.getState().nodes
+
+    const created = createWallOnCurrentLevel([0, 0], [4, 0])
+
+    expect(created).toBeNull()
+    expect(useScene.getState().nodes).toBe(beforeNodes)
+    expect(levelWalls()).toHaveLength(2)
+    expect(useScene.temporal.getState().pastStates).toHaveLength(0)
+  })
 })
 
 describe('resolveEndpointWallSplit', () => {