editor: fix roof and placement previews

apps/editor/lib/build-tab-state.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from 'bun:test'
+import {
+  getActiveRoofFeatureId,
+  getRoofFootprintSource,
+  getRoofFootprintSources,
+  ROOF_TYPE_OPTIONS,
+  type RoofFeatureIdentity,
+} from './build-tab-state'
+
+const FEATURES: RoofFeatureIdentity[] = [
+  { id: 'lean-to-extension', kind: 'lean-to-extension' },
+  { id: 'skylight', kind: 'skylight' },
+]
+
+describe('roof feature selection', () => {
+  test('does not select every accessory for the plain roof tool', () => {
+    expect(getActiveRoofFeatureId(FEATURES, 'roof')).toBeNull()
+  })
+
+  test('selects exactly the matching accessory', () => {
+    expect(getActiveRoofFeatureId(FEATURES, 'lean-to-extension')).toBe('lean-to-extension')
+  })
+
+  test('ignores missing tool identities', () => {
+    const malformed = FEATURES.map(({ id }) => ({ id }))
+    expect(getActiveRoofFeatureId(malformed, undefined)).toBeNull()
+    expect(getActiveRoofFeatureId(malformed, 'skylight')).toBeNull()
+  })
+})
+
+test('roof creation exposes every supported roof type', () => {
+  expect(ROOF_TYPE_OPTIONS.map((option) => option.value)).toEqual([
+    'hip',
+    'gable',
+    'shed',
+    'flat',
+    'gambrel',
+    'dutch',
+    'mansard',
+    'conical',
+  ])
+})
+
+test('conical roofs expose wall and draw footprint sources', () => {
+  expect(getRoofFootprintSources('conical').map((source) => source.value)).toEqual([
+    'walls',
+    'draw',
+  ])
+  expect(getRoofFootprintSource('conical', 'room')).toBe('walls')
+  expect(getRoofFootprintSource('conical', 'draw')).toBe('draw')
+})
+
+test('non-conical roofs expose room and draw footprint sources', () => {
+  expect(getRoofFootprintSources('hip').map((source) => source.value)).toEqual(['room', 'draw'])
+  expect(getRoofFootprintSource('hip', 'walls')).toBe('room')
+  expect(getRoofFootprintSource('hip', 'draw')).toBe('draw')
+})

apps/editor/lib/build-tab-state.ts

@@ -0,0 +1,54 @@
+import type { RoofType } from '@pascal-app/core'
+
+export type RoofFeatureIdentity = {
+  id: string
+  kind?: string
+}
+
+const ROOF_FOOTPRINT_SOURCES = [
+  { label: 'Room', value: 'room' },
+  { label: 'Wall', value: 'walls' },
+  { label: 'Draw', value: 'draw' },
+] as const
+
+export type RoofFootprintSource = (typeof ROOF_FOOTPRINT_SOURCES)[number]['value']
+
+const CONICAL_ROOF_FOOTPRINT_SOURCES = [
+  ROOF_FOOTPRINT_SOURCES[1],
+  ROOF_FOOTPRINT_SOURCES[2],
+] as const
+
+const STANDARD_ROOF_FOOTPRINT_SOURCES = [
+  ROOF_FOOTPRINT_SOURCES[0],
+  ROOF_FOOTPRINT_SOURCES[2],
+] as const
+
+export function getRoofFootprintSources(roofType: RoofType) {
+  return roofType === 'conical' ? CONICAL_ROOF_FOOTPRINT_SOURCES : STANDARD_ROOF_FOOTPRINT_SOURCES
+}
+
+export function getRoofFootprintSource(roofType: RoofType, value: unknown): RoofFootprintSource {
+  const sources = getRoofFootprintSources(roofType)
+  return sources.some((source) => source.value === value)
+    ? (value as RoofFootprintSource)
+    : sources[0].value
+}
+
+export const ROOF_TYPE_OPTIONS: ReadonlyArray<{ label: string; value: RoofType }> = [
+  { label: 'Hip', value: 'hip' },
+  { label: 'Gable', value: 'gable' },
+  { label: 'Shed', value: 'shed' },
+  { label: 'Flat', value: 'flat' },
+  { label: 'Gambrel', value: 'gambrel' },
+  { label: 'Dutch', value: 'dutch' },
+  { label: 'Mansard', value: 'mansard' },
+  { label: 'Conical', value: 'conical' },
+]
+
+export function getActiveRoofFeatureId(
+  features: readonly RoofFeatureIdentity[],
+  activeTool: string | null | undefined,
+): string | null {
+  if (!activeTool) return null
+  return features.find((feature) => feature.kind === activeTool)?.id ?? null
+}

package.json

@@ -9,6 +9,7 @@
     "format": "biome format --write",
     "format:check": "biome format",
     "check": "biome check",
+    "checks": "bun run check && bun run check-types",
     "check:fix": "biome check --write",
     "check-types": "turbo run check-types",
     "test": "turbo run test",

packages/core/src/index.ts

@@ -94,6 +94,15 @@ export {
 } from './hooks/spatial-grid/support-host-patch'
 export { useSpatialQuery } from './hooks/spatial-grid/use-spatial-query'
 export { loadAssetUrl, saveAsset } from './lib/asset-storage'
+export {
+  type ConicalRoofInvalidPlacement,
+  type ConicalRoofLevelPlacement,
+  type ConicalRoofPlacement,
+  type ConicalRoofSurfacePlacement,
+  type ResolveConicalRoofPlacementInput,
+  type RoofPlacementMode,
+  resolveConicalRoofPlacement,
+} from './lib/conical-roof-placement'
 export {
   clampDoorOperationState,
   getDoorRenderOpenAmount,
@@ -144,6 +153,7 @@ export {
   type RoofPlanSegment,
   roofOverlapEntryOwns,
   roofPlanBoundsOverlap,
+  roofPlanOverlapEntryOwns,
 } from './lib/roof-overlap'
 export { resolveSelectionProxyId, selectionProxyIdFromMetadata } from './lib/selection-proxy'
 export {

packages/core/src/lib/conical-roof-placement.test.ts

@@ -0,0 +1,138 @@
+// @ts-expect-error - bun:test is provided by the Bun runtime; core does not depend on @types/bun.
+import { describe, expect, test } from 'bun:test'
+import { LevelNode, RoofNode, RoofSegmentNode } from '../schema'
+import { resolveConicalRoofPlacement } from './conical-roof-placement'
+
+function sceneWithHost() {
+  const level = LevelNode.parse({
+    id: 'level_host',
+    children: ['roof_host'],
+  })
+  const roof = RoofNode.parse({
+    id: 'roof_host',
+    parentId: level.id,
+    position: [2, 1, 3],
+    children: ['rseg_host'],
+  })
+  const segment = RoofSegmentNode.parse({
+    id: 'rseg_host',
+    parentId: roof.id,
+    roofType: 'gable',
+    width: 10,
+    depth: 8,
+    wallHeight: 2,
+    pitch: 45,
+  })
+  return {
+    level,
+    roof,
+    segment,
+    nodes: {
+      [level.id]: level,
+      [roof.id]: roof,
+      [segment.id]: segment,
+    },
+  }
+}
+
+describe('conical roof placement', () => {
+  test('ground mode creates a level-supported roof at the drawn center', () => {
+    const { level, nodes } = sceneWithHost()
+    const placement = resolveConicalRoofPlacement({
+      nodes,
+      levelId: level.id,
+      center: [2, 3],
+      radius: 1,
+      curbHeight: 0.5,
+      mode: 'ground',
+    })
+
+    expect(placement).toEqual({
+      valid: true,
+      kind: 'level',
+      position: [2, 0, 3],
+      wallHeight: 0.5,
+      support: { kind: 'level' },
+    })
+  })
+
+  test('auto mode mounts a fully contained circle on the highest roof surface', () => {
+    const { level, roof, segment, nodes } = sceneWithHost()
+    const placement = resolveConicalRoofPlacement({
+      nodes,
+      levelId: level.id,
+      center: [2, 3],
+      radius: 1,
+      curbHeight: 0.5,
+      mode: 'auto',
+    })
+
+    expect(placement.valid).toBe(true)
+    if (!(placement.valid && placement.kind === 'roof')) throw new Error('expected roof placement')
+    expect(placement.hostRoofId).toBe(roof.id)
+    expect(placement.position[0]).toBe(2)
+    expect(placement.position[2]).toBe(3)
+    expect(placement.wallHeight).toBeGreaterThan(0.5)
+    expect(placement.support).toEqual({
+      kind: 'roof',
+      roofSegmentId: segment.id,
+      localPosition: [0, 0],
+      curbHeight: 0.5,
+    })
+  })
+
+  test('roof mode rejects a circle that has no complete roof support', () => {
+    const { level, nodes } = sceneWithHost()
+    const placement = resolveConicalRoofPlacement({
+      nodes,
+      levelId: level.id,
+      center: [20, 20],
+      radius: 1,
+      curbHeight: 0.5,
+      mode: 'roof',
+    })
+
+    expect(placement).toEqual({ valid: false, reason: 'no-roof-support' })
+  })
+
+  test('auto mode falls back to the level when no roof supports the circle', () => {
+    const { level, nodes } = sceneWithHost()
+    const placement = resolveConicalRoofPlacement({
+      nodes,
+      levelId: level.id,
+      center: [20, 20],
+      radius: 1,
+      curbHeight: 0.75,
+      mode: 'auto',
+    })
+
+    expect(placement).toEqual({
+      valid: true,
+      kind: 'level',
+      position: [20, 0, 20],
+      wallHeight: 0.75,
+      support: { kind: 'level' },
+    })
+  })
+
+  test('roof schema preserves the optional surface attachment and parses legacy roofs', () => {
+    const legacy = RoofNode.parse({ id: 'roof_legacy' })
+    expect(legacy.support).toEqual({ kind: 'level' })
+
+    const mounted = RoofNode.parse({
+      id: 'roof_mounted',
+      support: {
+        kind: 'roof',
+        roofSegmentId: 'rseg_host',
+        localPosition: [1.25, -0.5],
+        curbHeight: 0.4,
+      },
+    })
+    expect(mounted.support).toEqual({
+      kind: 'roof',
+      roofSegmentId: 'rseg_host',
+      localPosition: [1.25, -0.5],
+      curbHeight: 0.4,
+    })
+  })
+})