@pascal-app/editor 1.0.3 → 1.0.5

package/src/lib/wall-polygon-draft.test.ts

@@ -0,0 +1,262 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNode,
+  type AnyNodeId,
+  clearSceneHistory,
+  emitter,
+  GROUND_SUPPORT_ID,
+  LevelNode,
+  subscribeSceneCommits,
+  useScene,
+  WallNode,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import useEditor from '../store/use-editor'
+import { useFloorplanDraftPreview } from '../store/use-floorplan-draft-preview'
+import { sceneLayout, visibleScene } from '../store/view-layout'
+import { runUndo } from './history'
+import { sfxEmitter } from './sfx-bus'
+import {
+  addWallPolygonDraftCorner,
+  commitWallPolygonDraft,
+  discardWallPolygonDraft,
+  isWallPolygonDraftOpen,
+  startWallPolygonDraft,
+  wallPolygonDraftWalls,
+} from './wall-polygon-draft'
+
+// Node updates batch their dirty marks on the next frame.
+;(
+  globalThis as { requestAnimationFrame?: (callback: () => void) => number }
+).requestAnimationFrame ??= (callback) => {
+  callback()
+  return 0
+}
+;(globalThis as { cancelAnimationFrame?: (id: number) => void }).cancelAnimationFrame ??= () => {}
+
+const level = LevelNode.parse({ id: 'level_polygon', children: ['wall_existing'] })
+const existing = WallNode.parse({
+  id: 'wall_existing',
+  parentId: level.id,
+  start: [10, 0],
+  end: [14, 0],
+})
+const levelId = level.id as AnyNodeId
+
+const history = () => {
+  const { pastStates, futureStates } = useScene.temporal.getState()
+  return { past: pastStates.length, future: futureStates.length }
+}
+const walls = () =>
+  Object.values(useScene.getState().nodes).filter((node): node is WallNode => node.type === 'wall')
+
+let commits = 0
+let sceneWrites = 0
+let stopCommits = () => {}
+let stopWrites = () => {}
+
+beforeEach(() => {
+  useScene.setState({
+    nodes: { [level.id]: level, [existing.id]: existing } as Record<AnyNodeId, AnyNode>,
+    rootNodeIds: [levelId],
+    collections: {},
+    materials: {},
+    readOnly: false,
+  })
+  clearSceneHistory()
+  useViewer.getState().setSelection({ levelId: level.id })
+  commits = 0
+  sceneWrites = 0
+  stopCommits = subscribeSceneCommits(() => {
+    commits += 1
+  })
+  stopWrites = useScene.subscribe((state, previous) => {
+    if (state.nodes !== previous.nodes) sceneWrites += 1
+  })
+})
+
+afterEach(() => {
+  discardWallPolygonDraft()
+  stopCommits()
+  stopWrites()
+})
+
+/** Three placed sides of an open rectangle room, not closed yet. */
+function drawThreeSides() {
+  startWallPolygonDraft(levelId, [0, 0])
+  expect(addWallPolygonDraftCorner([4, 0])).toBe('open')
+  expect(addWallPolygonDraftCorner([4, 3])).toBe('open')
+  expect(addWallPolygonDraftCorner([0, 3])).toBe('open')
+}
+
+describe('Polygon room draft', () => {
+  test('an open polygon writes nothing: no scene change, history, commit or autosave trigger', () => {
+    const before = useScene.getState().nodes
+    drawThreeSides()
+    expect(useScene.getState().nodes).toBe(before)
+    expect(sceneWrites).toBe(0)
+    expect(commits).toBe(0)
+    expect(history()).toEqual({ past: 0, future: 0 })
+    // It exists only as draft corners, drawn as ghosts and used as snap targets.
+    expect(useFloorplanDraftPreview.getState().wallPolygonDraftPoints).toHaveLength(4)
+    expect(wallPolygonDraftWalls()).toHaveLength(3)
+  })
+
+  test('each placed corner plays the start tick; closing plays the build cue once', () => {
+    const played: string[] = []
+    const listen = (name: string) => () => played.push(name)
+    const onStart = listen('start')
+    const onBuild = listen('build')
+    sfxEmitter.on('sfx:structure-build-start', onStart)
+    sfxEmitter.on('sfx:structure-build', onBuild)
+    try {
+      drawThreeSides()
+      expect(played).toEqual(['start', 'start', 'start'])
+      expect(addWallPolygonDraftCorner([0.05, 0.05])).toBe('closed')
+      commitWallPolygonDraft()
+      expect(played).toEqual(['start', 'start', 'start', 'build'])
+    } finally {
+      sfxEmitter.off('sfx:structure-build-start', onStart)
+      sfxEmitter.off('sfx:structure-build', onBuild)
+    }
+  })
+
+  test('Esc just drops the draft', () => {
+    const before = useScene.getState().nodes
+    drawThreeSides()
+    discardWallPolygonDraft()
+    expect(isWallPolygonDraftOpen()).toBe(false)
+    expect(useFloorplanDraftPreview.getState().wallPolygonDraftPoints).toEqual([])
+    expect(useScene.getState().nodes).toBe(before)
+    expect({ sceneWrites, commits, ...history() }).toEqual({
+      sceneWrites: 0,
+      commits: 0,
+      past: 0,
+      future: 0,
+    })
+  })
+
+  test('closing on the first corner writes every wall as one undo step and one commit', () => {
+    const before = useScene.getState().nodes
+    drawThreeSides()
+    expect(addWallPolygonDraftCorner([0.05, 0.05])).toBe('closed')
+    const created = commitWallPolygonDraft()
+
+    expect(created).toHaveLength(4)
+    expect(walls()).toHaveLength(5)
+    expect(history()).toEqual({ past: 1, future: 0 })
+    expect(commits).toBe(1)
+    // The closing side ends exactly on the first corner.
+    expect(created.some((wall) => wall.end[0] === 0 && wall.end[1] === 0)).toBe(true)
+
+    runUndo()
+    expect(useScene.getState().nodes).toEqual(before)
+  })
+
+  test('a corner that tees into an existing wall ends the polygon and splits that wall', () => {
+    startWallPolygonDraft(levelId, [12, 3])
+    expect(addWallPolygonDraftCorner([12, 0])).toBe('joined')
+    commitWallPolygonDraft()
+    // The existing wall is split at the tee; one new wall joins it.
+    expect(walls()).toHaveLength(3)
+    expect(history()).toEqual({ past: 1, future: 0 })
+    expect(commits).toBe(1)
+  })
+
+  test('a double-click keeps an open polygon as drawn', () => {
+    drawThreeSides()
+    expect(commitWallPolygonDraft()).toHaveLength(3)
+    expect(walls()).toHaveLength(4)
+    expect(history()).toEqual({ past: 1, future: 0 })
+  })
+
+  test("a collaborator's edit during the draft survives Esc and survives the commit", () => {
+    drawThreeSides()
+    // Stands in for a remote patch landing mid-draft.
+    useScene.getState().updateNode(existing.id, { name: 'Renamed remotely' })
+    discardWallPolygonDraft()
+    expect(useScene.getState().nodes[existing.id]?.name).toBe('Renamed remotely')
+
+    drawThreeSides()
+    useScene.getState().updateNode(existing.id, { name: 'Renamed again' })
+    addWallPolygonDraftCorner([0, 0])
+    commitWallPolygonDraft()
+    expect(useScene.getState().nodes[existing.id]?.name).toBe('Renamed again')
+    expect(walls()).toHaveLength(5)
+  })
+
+  test('a level change drops the polygon and resets the drafting tool', () => {
+    let toolCancels = 0
+    const onCancel = () => {
+      toolCancels += 1
+    }
+    emitter.on('tool:cancel', onCancel)
+    try {
+      drawThreeSides()
+      useViewer.getState().setSelection({ levelId: 'level_other' })
+      expect(isWallPolygonDraftOpen()).toBe(false)
+      expect(toolCancels).toBe(1)
+      expect(sceneWrites).toBe(0)
+    } finally {
+      emitter.off('tool:cancel', onCancel)
+    }
+  })
+
+  test('a view switch drops the polygon: its owning view changes, so ownership starts over', () => {
+    let toolCancels = 0
+    const onCancel = () => {
+      toolCancels += 1
+    }
+    emitter.on('tool:cancel', onCancel)
+    const layout = useEditor.getState().viewLayouts.edit
+    try {
+      drawThreeSides()
+      useEditor
+        .getState()
+        .setViewLayout(sceneLayout(visibleScene(useEditor.getState()) === '2d' ? '3d' : '2d'))
+      expect(isWallPolygonDraftOpen()).toBe(false)
+      expect(toolCancels).toBe(1)
+      // The other view's click after that finds no polygon and ends its chain
+      // instead of drafting on as if one were open.
+      expect(addWallPolygonDraftCorner([6, 6])).toBe('ended')
+      expect(sceneWrites).toBe(0)
+    } finally {
+      emitter.off('tool:cancel', onCancel)
+      useEditor.setState({ viewLayouts: layout ? { edit: layout } : {} })
+    }
+  })
+
+  test('sides split by a later crossing side keep the polygon construction settings', () => {
+    // A raised ground draft: the construction plane sets each wall's height
+    // and support offset.
+    startWallPolygonDraft(levelId, [0, 0], {
+      preferredSupportSlabId: GROUND_SUPPORT_ID,
+      flatConstructionBase: true,
+      constructionElevation: 2,
+      constructionHeight: 2,
+    })
+    addWallPolygonDraftCorner([4, 0])
+    addWallPolygonDraftCorner([4, 3])
+    // Crosses the first side at (3, 0): that side splits into two pieces.
+    addWallPolygonDraftCorner([2, -1])
+    const created = commitWallPolygonDraft()
+    const drawn = walls().filter((wall) => wall.id !== existing.id)
+    expect(drawn.length).toBeGreaterThan(3)
+    expect(new Set(created.map((wall) => wall.id))).toEqual(new Set(drawn.map((wall) => wall.id)))
+    for (const wall of drawn) {
+      expect(wall.height).toBe(2)
+      expect(wall.supportOffset).toBe(2)
+    }
+  })
+
+  test('commit and discard are no-ops without an open draft', () => {
+    expect(commitWallPolygonDraft()).toEqual([])
+    discardWallPolygonDraft()
+    expect({ sceneWrites, commits, ...history() }).toEqual({
+      sceneWrites: 0,
+      commits: 0,
+      past: 0,
+      future: 0,
+    })
+  })
+})

package/src/lib/wall-polygon-draft.ts

@@ -0,0 +1,286 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  emitter,
+  planWallInsertion,
+  resolveWallConstruction,
+  runAsSingleSceneHistoryStep,
+  useScene,
+  type WallConstructionOptions,
+  type WallNode,
+  wallClosesRoom,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import {
+  chainEndJoinsExistingWall,
+  WALL_CONNECT_SNAP_RADIUS,
+  WALL_JOIN_SNAP_RADIUS,
+  type WallPlanPoint,
+} from '../components/tools/wall/wall-snap-geometry'
+import useEditor, { isMagneticSnapActive } from '../store/use-editor'
+import { useFloorplanDraftPreview } from '../store/use-floorplan-draft-preview'
+import { visibleScene } from '../store/view-layout'
+import { sfxEmitter } from './sfx-bus'
+
+/**
+ * A Polygon room is draft state until it completes: its corners live in
+ * `useFloorplanDraftPreview.wallPolygonDraftPoints` (drawn by the 3D tool and
+ * the plan as ghosts) and no wall is written. Completing it — closing on the
+ * first corner, sealing or teeing into existing walls, or a double-click —
+ * writes every wall in one `applyNodeChanges` batch: one undo step, one scene
+ * commit, and room detection derives the floor and ceiling from it. Esc, a
+ * tool / shape / level change or a history command just drops the draft; the
+ * scene, history, autosave and collaboration never saw it.
+ *
+ * One draft at a time: the 3D wall tool owns it, or the plan in 2D-only view.
+ */
+
+type Draft = {
+  levelId: AnyNodeId
+  construction?: WallConstructionOptions
+  stopGuards: () => void
+}
+
+let draft: Draft | null = null
+
+const points = () => useFloorplanDraftPreview.getState().wallPolygonDraftPoints
+const setPoints = (next: readonly WallPlanPoint[]) =>
+  useFloorplanDraftPreview.getState().setWallPolygonDraftPoints(next)
+
+export function isWallPolygonDraftOpen(): boolean {
+  return draft !== null
+}
+
+/** Starts a Polygon room at its first corner, replacing any open one. */
+export function startWallPolygonDraft(
+  levelId: AnyNodeId,
+  start: WallPlanPoint,
+  construction?: WallConstructionOptions,
+): void {
+  discardWallPolygonDraft()
+  const abandon = () => {
+    discardWallPolygonDraft()
+    emitter.emit('tool:cancel')
+  }
+  // The corners are in this level's frame, and the view that started the
+  // polygon owns its clicks (the 3D tool, or the plan in 2D-only view — a
+  // hidden canvas keeps listening). A level or view switch abandons it and
+  // tells the drafting tools to reset their chain, so ownership starts over.
+  const scene = visibleScene(useEditor.getState())
+  const stops = [
+    useViewer.subscribe((state) => {
+      if (state.selection.levelId !== levelId) abandon()
+    }),
+    useEditor.subscribe((state) => {
+      if (visibleScene(state) !== scene) abandon()
+    }),
+  ]
+  draft = {
+    levelId,
+    construction,
+    stopGuards: () => {
+      for (const stop of stops) stop()
+    },
+  }
+  setPoints([start])
+}
+
+/** Drops the open polygon; nothing was written, so nothing is restored. */
+export function discardWallPolygonDraft(): void {
+  const current = draft
+  draft = null
+  current?.stopGuards()
+  if (points().length) setPoints([])
+}
+
+const levelWallsOf = (nodes: Record<string, AnyNode>, levelId: AnyNodeId) =>
+  Object.values(nodes).filter(
+    (node): node is WallNode => node.type === 'wall' && node.parentId === levelId,
+  )
+
+/** Whether `point` lies on the straight segment `wall` (within 1 mm). */
+function liesOnWall(point: WallPlanPoint, wall: WallNode): boolean {
+  const [ax, az] = wall.start
+  const [bx, bz] = wall.end
+  const dx = bx - ax
+  const dz = bz - az
+  const lengthSquared = dx * dx + dz * dz
+  if (lengthSquared === 0) return false
+  const t = ((point[0] - ax) * dx + (point[1] - az) * dz) / lengthSquared
+  if (t < -1e-6 || t > 1 + 1e-6) return false
+  return Math.hypot(ax + t * dx - point[0], az + t * dz - point[1]) <= 1e-3
+}
+
+/**
+ * The polygon's walls planned against a scratch copy of the scene, the way
+ * the chain used to write them one by one: each side joins the previous one,
+ * splits the walls it tees into and skips what existing walls already cover.
+ * `draftWalls` are every surviving piece of the polygon's own sides — a later
+ * side that crosses an earlier one splits it into new walls, and those pieces
+ * are still the polygon's (they take its construction settings); `last` is
+ * the final side, for the tee / seal checks.
+ */
+function planPolygon(
+  nodes: Record<AnyNodeId, AnyNode>,
+  levelId: AnyNodeId,
+  corners: WallPlanPoint[],
+) {
+  const virtual = { ...nodes }
+  const draftIds = new Set<AnyNodeId>()
+  let last: WallNode | undefined
+  const joinRadius = isMagneticSnapActive() ? WALL_JOIN_SNAP_RADIUS : WALL_CONNECT_SNAP_RADIUS
+  const wallDefaults = useEditor.getState().toolDefaults.wall ?? {}
+  for (let index = 0; index < corners.length - 1; index++) {
+    const result = planWallInsertion(virtual, {
+      levelId,
+      start: corners[index]!,
+      end: corners[index + 1]!,
+      joinRadius,
+      wallDefaults,
+    })
+    if (!result.ok) continue
+    const draftBefore = [...draftIds].flatMap((id) => {
+      const node = virtual[id]
+      return node?.type === 'wall' ? [node] : []
+    })
+    for (const id of result.plan.changes.delete) delete virtual[id]
+    for (const { node, parentId } of result.plan.changes.create) {
+      virtual[node.id] = { ...node, ...(parentId ? { parentId } : {}) } as AnyNode
+    }
+    for (const { id, data } of result.plan.changes.update) {
+      if (virtual[id]) virtual[id] = { ...virtual[id], ...data } as AnyNode
+    }
+    for (const id of result.plan.changes.delete) draftIds.delete(id)
+    const insertedIds = new Set(result.plan.insertedWalls.map((wall) => wall.id))
+    for (const { node } of result.plan.changes.create) {
+      if (node.type !== 'wall') continue
+      const descends =
+        insertedIds.has(node.id) ||
+        draftBefore.some((side) => liesOnWall(node.start, side) && liesOnWall(node.end, side))
+      if (descends) draftIds.add(node.id as AnyNodeId)
+    }
+    const final = result.plan.insertedWalls.at(-1)
+    if (final) last = virtual[final.id] as WallNode | undefined
+  }
+  const draftWalls = [...draftIds].flatMap((id) => {
+    const node = virtual[id]
+    return node?.type === 'wall' ? [node] : []
+  })
+  return { virtual, draftWalls, last }
+}
+
+/**
+ * The open polygon's sides as wall-shaped values — snap targets for the draft
+ * (so the last click can land exactly on the first corner) and the ghosts.
+ * Never written to the scene.
+ */
+export function wallPolygonDraftWalls(): WallNode[] {
+  const current = draft
+  if (!current) return []
+  const corners = points()
+  return corners.slice(1).map((end, index) => ({
+    object: 'node',
+    id: `wall_polygon_draft_${index}` as WallNode['id'],
+    type: 'wall',
+    name: 'Draft wall',
+    parentId: current.levelId,
+    visible: true,
+    metadata: {},
+    children: [],
+    start: corners[index]!,
+    end,
+    frontSide: 'unknown',
+    backSide: 'unknown',
+  }))
+}
+
+/**
+ * How a corner left the polygon: still open, closed on its first corner,
+ * ended on existing walls, or `ended` — there was no open polygon to add to
+ * (it was committed or abandoned elsewhere), so the caller's chain ends too.
+ */
+export type WallPolygonCornerResult = 'open' | 'closed' | 'joined' | 'ended'
+
+/**
+ * Adds a corner. A corner within the join radius of the first one closes the
+ * polygon (snapped exactly onto it); a corner that tees into an existing wall
+ * or seals a room against the wall network ends it, as the chain did.
+ */
+export function addWallPolygonDraftCorner(corner: WallPlanPoint): WallPolygonCornerResult {
+  const current = draft
+  const corners = points()
+  const first = corners[0]
+  if (!(current && first)) return 'ended'
+  const closes =
+    corners.length >= 3 &&
+    (corner[0] - first[0]) ** 2 + (corner[1] - first[1]) ** 2 <=
+      WALL_JOIN_SNAP_RADIUS * WALL_JOIN_SNAP_RADIUS
+  const next = [...corners, closes ? first : corner]
+  setPoints(next)
+  if (closes) return 'closed'
+
+  const { virtual, draftWalls, last } = planPolygon(
+    useScene.getState().nodes,
+    current.levelId,
+    next,
+  )
+  const levelWalls = last ? levelWallsOf(virtual, current.levelId) : []
+  const joins =
+    !!last &&
+    (chainEndJoinsExistingWall(
+      corner,
+      levelWalls,
+      draftWalls.map((wall) => wall.id),
+    ) ||
+      wallClosesRoom(levelWalls, last))
+  // Each placed corner ticks like the Zone tool's; a close or a join is
+  // answered by the build cue of the commit that follows.
+  if (!joins) sfxEmitter.emit('sfx:structure-build-start')
+  return joins ? 'joined' : 'open'
+}
+
+/**
+ * Writes the polygon — one history step, one scene commit — and closes the
+ * draft. Returns the walls it created (none for a draft without a side).
+ */
+export function commitWallPolygonDraft(): WallNode[] {
+  const current = draft
+  if (!current) return []
+  const corners = points()
+  discardWallPolygonDraft()
+  if (corners.length < 2) return []
+
+  const scene = useScene.getState()
+  if (scene.readOnly) return []
+  const { virtual, draftWalls } = planPolygon(scene.nodes, current.levelId, corners)
+  if (!draftWalls.length) return []
+  const construction = resolveWallConstruction(
+    scene.nodes,
+    current.levelId,
+    draftWalls,
+    current.construction,
+  )
+  const finalized = new Map(construction.walls.map((wall) => [wall.id, wall]))
+  const created = Object.values(virtual).filter((node) => !scene.nodes[node.id])
+  const update = Object.values(virtual)
+    .filter((node) => scene.nodes[node.id] && node !== scene.nodes[node.id])
+    .map((node) => ({ id: node.id, data: node as Partial<AnyNode> }))
+  const source = construction.sourceSupportUpdate
+  if (source) {
+    const existing = update.find((operation) => operation.id === source.id)
+    if (existing) existing.data = { ...existing.data, ...source.data }
+    else update.push(source)
+  }
+  runAsSingleSceneHistoryStep(useScene, () =>
+    scene.applyNodeChanges({
+      create: created.map((node) => ({
+        node: finalized.get(node.id as WallNode['id']) ?? node,
+        parentId: node.parentId as AnyNodeId,
+      })),
+      update,
+      delete: Object.keys(scene.nodes).filter((id) => !virtual[id as AnyNodeId]) as AnyNodeId[],
+    }),
+  )
+  sfxEmitter.emit('sfx:structure-build')
+  return construction.walls
+}