@pascal-app/editor 1.0.1 → 1.0.4

package/src/lib/room-zone-routing.test.ts

@@ -0,0 +1,294 @@
+import { afterEach, beforeEach, describe, expect, test } from 'bun:test'
+import {
+  type AnyNodeId,
+  BuildingNode,
+  clearSceneHistory,
+  createZone,
+  divideZone,
+  generateId,
+  initSpaceDetectionSync,
+  LevelNode,
+  UnitNode,
+  useScene,
+  type ZoneNode,
+  ZoneNode as ZoneNodeSchema,
+} from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { deleteSelection } from '../components/editor/group-actions'
+import { getRoomSelectionIndex } from '../hooks/use-selected-room'
+import useEditor from '../store/use-editor'
+import { installImmediateAnimationFrames } from '../test-utils/immediate-animation-frames'
+import { exitCeilingEditToRoom, startCeilingEdit } from './ceiling-edit-session'
+import { applyRoomPlan } from './room-structure-commands'
+import {
+  captureElementActionOrigin,
+  clickZoneArea,
+  completeElementAction,
+  hoverZoneArea,
+  leaveZoneArea,
+  roomKeyForZone,
+  selectZoneOrRoom,
+  zoneKindLabel,
+} from './room-zone-routing'
+import { addZoneToNewUnit, assignZoneToUnit, zoneUnits } from './units'
+
+const LEVEL = 'level_zone_routing'
+const BUILDING = 'building_zone_routing'
+let zoneId: string
+let stop = () => {}
+let restoreFrames = () => {}
+
+const nodes = () => useScene.getState().nodes
+const zones = () => Object.values(nodes()).filter((n): n is ZoneNode => n.type === 'zone')
+const roomWalls = (id: string) =>
+  getRoomSelectionIndex(LEVEL)
+    .update(nodes())
+    .find((room) => room.key.zoneId === id)!.boundaryWallIds
+
+beforeEach(() => {
+  restoreFrames = installImmediateAnimationFrames()
+  const building = BuildingNode.parse({ id: BUILDING, children: [LEVEL] })
+  const level = LevelNode.parse({ id: LEVEL, parentId: building.id })
+  useScene.setState({
+    nodes: { [building.id]: building, [level.id]: level },
+    rootNodeIds: [building.id],
+    dirtyNodes: new Set(),
+    materials: {},
+    collections: {},
+    readOnly: false,
+  })
+  useScene.temporal.getState().resume()
+  stop = initSpaceDetectionSync(useScene, { getState: () => ({ spaces: {}, setSpaces: () => {} }) })
+  const plan = createZone(nodes(), {
+    levelId: LEVEL,
+    polygon: [
+      [0, 0],
+      [8, 0],
+      [8, 4],
+      [0, 4],
+    ],
+    enclose: true,
+    mintId: generateId,
+  })
+  applyRoomPlan(plan)
+  zoneId = plan.zoneId
+  useViewer.getState().setFocusedUnit(null)
+  useViewer
+    .getState()
+    .setSelection({ buildingId: building.id, levelId: level.id, selectedIds: [], zoneId: null })
+  useEditor.setState({ phase: 'building', mode: 'select', room: null, hoveredRoom: null })
+  clearSceneHistory()
+})
+afterEach(() => {
+  stop()
+  restoreFrames()
+})
+
+describe('a room is the room from every route (point 1)', () => {
+  test('an enclosed room selected from a list or label becomes the room selection', () => {
+    expect(selectZoneOrRoom(zoneId)).toBe('room')
+    expect(useEditor.getState().room).toEqual({ levelId: LEVEL, zoneId })
+    expect(useViewer.getState().selection.zoneId).toBeNull()
+  })
+
+  test('a generic zone and an open room stay zones', () => {
+    const lawn = ZoneNodeSchema.parse({
+      parentId: LEVEL,
+      name: 'Lawn',
+      polygon: [
+        [20, 0],
+        [24, 0],
+        [24, 4],
+      ],
+    })
+    const open = ZoneNodeSchema.parse({
+      parentId: LEVEL,
+      name: 'Porch',
+      spaceRole: 'room',
+      enclosureStatus: 'open',
+      polygon: [
+        [30, 0],
+        [34, 0],
+        [34, 4],
+      ],
+    })
+    useScene.getState().createNodes([
+      { node: lawn, parentId: LEVEL as AnyNodeId },
+      { node: open, parentId: LEVEL as AnyNodeId },
+    ])
+    for (const zone of [lawn, open]) {
+      useEditor.getState().selectRoom({ levelId: LEVEL, zoneId })
+      expect(roomKeyForZone(zone.id)).toBeNull()
+      expect(selectZoneOrRoom(zone.id)).toBe('zone')
+      expect(useViewer.getState().selection.zoneId).toBe(zone.id)
+      expect(useEditor.getState().room).toBeNull()
+    }
+    expect(zoneKindLabel(lawn)).toBe('Zone')
+    expect(zoneKindLabel(open)).toBe('Room')
+  })
+
+  test('while a unit is focused, a room stays a zone so arranging the unit keeps working', () => {
+    const unit = UnitNode.parse({ name: 'Flat A' })
+    useScene.getState().createNode(unit, BUILDING as AnyNodeId)
+    useViewer.getState().setFocusedUnit(unit.id)
+    expect(selectZoneOrRoom(zoneId)).toBe('zone')
+    expect(useEditor.getState().room).toBeNull()
+  })
+
+  test('the room panel unit row reads, changes and clears membership (§13 Q7)', () => {
+    expect(zoneUnits(nodes(), zoneId)).toMatchObject({ buildingId: BUILDING, current: null })
+    const created = addZoneToNewUnit(zoneId as ZoneNode['id'])!
+    expect(useScene.temporal.getState().pastStates).toHaveLength(1)
+    expect(zoneUnits(nodes(), zoneId).current?.id).toBe(created)
+    expect(zoneUnits(nodes(), zoneId).current?.name).toBe('Unit 1')
+    const other = UnitNode.parse({ name: 'Flat B' })
+    useScene.getState().createNode(other, BUILDING as AnyNodeId)
+    assignZoneToUnit(zoneId as ZoneNode['id'], other.id)
+    expect(zoneUnits(nodes(), zoneId).current?.id).toBe(other.id)
+    expect(zoneUnits(nodes(), zoneId).units.map((u) => u.id)).toEqual([created, other.id])
+    assignZoneToUnit(zoneId as ZoneNode['id'], null)
+    expect(zoneUnits(nodes(), zoneId).current).toBeNull()
+  })
+})
+
+describe('finishing an action on a piece of a room returns to the room (point 3)', () => {
+  test('only pieces of the selected room carry it as the origin', () => {
+    const wallId = roomWalls(zoneId)[0]!
+    expect(captureElementActionOrigin([wallId])).toBeNull()
+    useEditor.getState().selectRoom({ levelId: LEVEL, zoneId })
+    expect(captureElementActionOrigin([wallId])?.room).toEqual({ levelId: LEVEL, zoneId })
+    expect(captureElementActionOrigin([wallId, 'wall_elsewhere'])).toBeNull()
+  })
+
+  test('completing lands on the origin room with nothing drilled', () => {
+    useEditor.getState().selectRoom({ levelId: LEVEL, zoneId })
+    const wallId = roomWalls(zoneId)[0]!
+    useViewer.getState().setSelection({ selectedIds: [wallId as AnyNodeId] })
+    const origin = captureElementActionOrigin([wallId])
+    expect(completeElementAction(origin)).toBe(true)
+    expect(useViewer.getState().selection.selectedIds).toEqual([])
+    expect(useEditor.getState().room).toEqual({ levelId: LEVEL, zoneId })
+  })
+
+  test('without a room context the action keeps its own selection', () => {
+    const wallId = roomWalls(zoneId)[0]!
+    useViewer.getState().setSelection({ selectedIds: [wallId as AnyNodeId] })
+    expect(completeElementAction(captureElementActionOrigin([wallId]))).toBe(false)
+    expect(useViewer.getState().selection.selectedIds).toEqual([wallId])
+  })
+
+  test('a room that is gone hands over to the room now standing there, else to nothing', () => {
+    const gone = { levelId: LEVEL, zoneId: 'zone_gone' }
+    useEditor.getState().selectRoom(gone)
+    expect(completeElementAction({ room: gone, point: [4, 2] })).toBe(true)
+    expect(useEditor.getState().room).toEqual({ levelId: LEVEL, zoneId })
+    useEditor.getState().selectRoom(gone)
+    expect(completeElementAction({ room: gone, point: [40, 2] })).toBe(false)
+    expect(useEditor.getState().room).toBeNull()
+    expect(useViewer.getState().selection.selectedIds).toEqual([])
+  })
+
+  test('deleting a separator drilled from one side lands on the merged room', () => {
+    const plan = divideZone(nodes(), {
+      zoneId,
+      cut: [
+        [2, 0],
+        [2, 4],
+      ],
+      mintId: generateId,
+    })
+    applyRoomPlan(plan)
+    const sides = zones().map((z) => z.id as string)
+    expect(sides).toHaveLength(2)
+    // Drilled from the side Divide made, which merges back into the first room.
+    const origin = sides.find((id) => id !== zoneId) ?? zoneId
+    useEditor.getState().selectRoom({ levelId: LEVEL, zoneId: origin })
+    useViewer.getState().setSelection({ selectedIds: [plan.separatorId as AnyNodeId] })
+    expect(deleteSelection()).toBe(true)
+    const [merged] = zones()
+    expect(zones()).toHaveLength(1)
+    expect(useEditor.getState().room).toEqual({ levelId: LEVEL, zoneId: merged!.id })
+    expect(useViewer.getState().selection.selectedIds).toEqual([])
+  })
+
+  test('deleting a drilled wall lands back on its room (its edge stays open)', () => {
+    useEditor.getState().selectRoom({ levelId: LEVEL, zoneId })
+    const wallId = roomWalls(zoneId)[0]!
+    useViewer.getState().setSelection({ selectedIds: [wallId as AnyNodeId] })
+    expect(deleteSelection()).toBe(true)
+    expect(nodes()[wallId as AnyNodeId]).toBeUndefined()
+    expect(useEditor.getState().room).toEqual({ levelId: LEVEL, zoneId })
+    expect(useViewer.getState().selection.selectedIds).toEqual([])
+  })
+
+  test('leaving Edit ceiling lands on the ceiling’s room', () => {
+    useEditor.getState().selectRoom({ levelId: LEVEL, zoneId })
+    expect(startCeilingEdit(zoneId)).not.toBe(false)
+    expect(exitCeilingEditToRoom()).toBe(true)
+    expect(useEditor.getState().room).toEqual({ levelId: LEVEL, zoneId })
+    expect(useViewer.getState().selection.selectedIds).toEqual([])
+  })
+})
+
+describe('a zone area (plan fill, label, pill): hover shows what the click selects', () => {
+  const plain = { meta: false, ctrl: false, shift: false, alt: false }
+  const shown = () => ({
+    room: useEditor.getState().hoveredRoom?.zoneId ?? null,
+    zone: useViewer.getState().hoveredId,
+  })
+  const picked = () => ({
+    room: useEditor.getState().room?.zoneId ?? null,
+    zone: useViewer.getState().selection.selectedIds[0] ?? null,
+  })
+  const drawn = () => {
+    const zone = ZoneNodeSchema.parse({
+      name: 'Reading nook',
+      polygon: [
+        [20, 20],
+        [22, 20],
+        [22, 22],
+        [20, 22],
+      ],
+    })
+    useScene.getState().createNode(zone, LEVEL as AnyNodeId)
+    return zone.id
+  }
+
+  test('a room hovers and selects as the room; a modifier reaches the zone itself', () => {
+    for (const modifiers of [
+      plain,
+      { ...plain, alt: true },
+      { ...plain, shift: true },
+      { ...plain, ctrl: true },
+      { ...plain, meta: true },
+    ]) {
+      useEditor.getState().clearRoom()
+      useViewer.getState().setSelection({ selectedIds: [], zoneId: null })
+      hoverZoneArea(zoneId, modifiers)
+      const hover = shown()
+      clickZoneArea(zoneId, modifiers)
+      leaveZoneArea(zoneId)
+      expect(picked()).toEqual(hover)
+      expect(shown()).toEqual({ room: null, zone: null })
+    }
+    expect(roomKeyForZone(zoneId)).not.toBeNull()
+  })
+
+  test('a drawn zone that bounds no room hovers and selects as itself, and Shift adds to it', () => {
+    const nook = drawn()
+    hoverZoneArea(nook, plain)
+    expect(shown()).toEqual({ room: null, zone: nook })
+    clickZoneArea(nook, plain)
+    expect(picked()).toEqual({ room: null, zone: nook })
+    clickZoneArea(zoneId, { ...plain, shift: true })
+    expect(useViewer.getState().selection.selectedIds).toEqual([nook, zoneId])
+  })
+
+  test('hovering an already selected room area still shows the room its click keeps', () => {
+    clickZoneArea(zoneId, plain)
+    hoverZoneArea(zoneId, plain)
+    expect(shown()).toEqual({ room: zoneId, zone: null })
+    clickZoneArea(zoneId, plain)
+    expect(picked()).toEqual({ room: zoneId, zone: null })
+  })
+})

package/src/lib/room-zone-routing.ts

@@ -0,0 +1,197 @@
+import { type AnyNode, type AnyNodeId, useScene, type ZoneNode } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { getRoomSelectionIndex, hoverRoomFromHit } from '../hooks/use-selected-room'
+import useEditor from '../store/use-editor'
+import { expandSessionSelectionForNode } from '../store/use-session-groups'
+import { type RoomKey, sameRoom } from './room-selection'
+import { selectRoom } from './room-selection-commands'
+import { resolveSelectedIdsForNodeClick, type SelectionModifierKeys } from './selection-routing'
+
+// A room is one thing to the user whichever way they reach it: the canvas, the
+// Rooms list, the plan's fill or its label. Rooms the room index knows (closed,
+// or a mezzanine) are selected as rooms; everything else stays a zone.
+
+export function isRoomZone(node: AnyNode | undefined): node is ZoneNode {
+  return node?.type === 'zone' && node.spaceRole === 'room'
+}
+
+/** The room key of a zone that is a selectable room, else null. */
+export function roomKeyForZone(
+  zoneId: string,
+  nodes: Record<string, AnyNode> = useScene.getState().nodes,
+): RoomKey | null {
+  const zone = nodes[zoneId]
+  if (!isRoomZone(zone) || !zone.parentId) return null
+  const records = getRoomSelectionIndex(zone.parentId).update(
+    nodes as ReturnType<typeof useScene.getState>['nodes'],
+  )
+  return records.some((room) => room.key.zoneId === zoneId)
+    ? { levelId: zone.parentId, zoneId }
+    : null
+}
+
+/**
+ * Selects a zone the way the user means it: an enclosed room as the room (its
+ * panel, its pill, Escape back out), anything else as the zone. While a unit
+ * is focused a zone stays a zone — arranging a unit works on zones.
+ */
+export function selectZoneOrRoom(zoneId: string): 'room' | 'zone' {
+  const room = useViewer.getState().focusedUnitId ? null : roomKeyForZone(zoneId)
+  if (room) {
+    selectRoom(room)
+    return 'room'
+  }
+  useEditor.getState().clearRoom()
+  useViewer.getState().setSelection({ zoneId: zoneId as ZoneNode['id'] })
+  return 'zone'
+}
+
+/**
+ * The hover a pointer on a zone's area shows — its fill or label in the plan,
+ * or its pill in either view. A room hovers room-first through the same rule
+ * as its floor on the canvas (`hoverRoomFromHit`); held modifiers, or a zone
+ * that bounds no room, hover the zone itself (its outline).
+ */
+export function hoverZoneArea(zoneId: string, modifiers: SelectionModifierKeys): void {
+  const room = roomKeyForZone(zoneId)
+  if (
+    room &&
+    sameRoom(useEditor.getState().room, room) &&
+    !(modifiers.alt || modifiers.shift || modifiers.ctrl || modifiers.meta)
+  ) {
+    useEditor.getState().setHoveredRoom(room)
+    useViewer.getState().setHoveredId(null)
+    return
+  }
+  if (room && hoverRoomFromHit(room, modifiers, null)) return
+  useEditor.getState().setHoveredRoom(null)
+  if (useViewer.getState().hoveredId !== zoneId) useViewer.getState().setHoveredId(zoneId as never)
+}
+
+/** Ends a `hoverZoneArea` hover, leaving any other hover alone. */
+export function leaveZoneArea(zoneId: string): void {
+  const room = roomKeyForZone(zoneId)
+  if (room && sameRoom(useEditor.getState().hoveredRoom, room))
+    useEditor.getState().setHoveredRoom(null)
+  if (useViewer.getState().hoveredId === zoneId) useViewer.getState().setHoveredId(null)
+}
+
+/**
+ * The selection a click on a zone's area makes, whichever surface took it.
+ * A plain click on a room selects the room (keeping it when it already is);
+ * Shift/Ctrl/Meta toggle and Alt isolate the zone itself, as on any canvas
+ * element. A zone that bounds no room selects as itself, which opens its panel
+ * and its outline editor.
+ */
+export function clickZoneArea(zoneId: string, modifiers: SelectionModifierKeys): void {
+  const room = roomKeyForZone(zoneId)
+  const bypass = modifiers.alt || modifiers.shift || modifiers.ctrl || modifiers.meta
+  if (room && !bypass) {
+    if (!sameRoom(useEditor.getState().room, room)) selectRoom(room)
+    return
+  }
+  useEditor.getState().clearRoom()
+  const { selection, setSelection } = useViewer.getState()
+  setSelection({
+    zoneId: null,
+    selectedIds: resolveSelectedIdsForNodeClick({
+      currentSelectedIds: selection.selectedIds,
+      modifierKeys: modifiers,
+      nodeId: zoneId,
+      expandIdsForNode: expandSessionSelectionForNode,
+    }),
+  })
+}
+
+/** Whether a zone's row is the selection, whichever store holds it. */
+export function useZoneSelected(zoneId: string): boolean {
+  const asRoom = useEditor((state) => state.room?.zoneId === zoneId)
+  const asZone = useViewer(
+    (state) =>
+      state.selection.zoneId === zoneId ||
+      (state.selection.selectedIds.length === 1 && state.selection.selectedIds[0] === zoneId),
+  )
+  return asRoom || asZone
+}
+
+/** The user word for a zone: rooms are "Room", every other area stays "Zone". */
+export function zoneKindLabel(zone: Pick<ZoneNode, 'spaceRole'> | undefined): 'Room' | 'Zone' {
+  return zone?.spaceRole === 'room' ? 'Room' : 'Zone'
+}
+
+/** Where a one-shot action on a drilled element started: its room, and a point inside it. */
+export type ElementActionOrigin = { room: RoomKey; point: [number, number] | null }
+
+/**
+ * The room to come back to once an action on `elementIds` completes: the
+ * selected room, when every element is part of it (its walls, separators,
+ * floor or ceiling). Null when there is no room context (an Alt-selected
+ * element, walls of another room), so the action keeps its own selection.
+ */
+export function captureElementActionOrigin(
+  elementIds: readonly string[],
+): ElementActionOrigin | null {
+  const room = useEditor.getState().room
+  if (!room) return null
+  const nodes = useScene.getState().nodes
+  const record = getRoomSelectionIndex(room.levelId)
+    .update(nodes)
+    .find((candidate) => candidate.key.zoneId === room.zoneId)
+  if (!record) return null
+  const parts = new Set<string>([
+    ...record.spans.map((span) => span.boundaryId),
+    ...(record.slabId ? [record.slabId] : []),
+    ...(record.ceilingId ? [record.ceilingId] : []),
+  ])
+  if (!elementIds.every((id) => parts.has(id))) return null
+  const zone = nodes[room.zoneId as AnyNodeId]
+  const seed = zone?.type === 'zone' ? zone.seed : undefined
+  return { room, point: seed ? [seed[0], seed[1]] : interiorPoint(record.clearPolygon) }
+}
+
+function interiorPoint(
+  polygon: readonly { outer: readonly (readonly [number, number])[] }[],
+): [number, number] | null {
+  const ring = polygon[0]?.outer
+  if (!ring?.length) return null
+  let x = 0
+  let z = 0
+  for (const [px, pz] of ring) {
+    x += px
+    z += pz
+  }
+  return [x / ring.length, z / ring.length]
+}
+
+/**
+ * Finishing a one-shot action on a piece of a room (Split, Merge, Delete, a
+ * hole's Done) puts the user back on the room: the origin room when it is
+ * still a room, else the room it became part of (`survivorZoneId`, or the room
+ * now standing where it was), else nothing. Called at successful commits only —
+ * a cancelled action keeps its element. Returns whether a room was selected.
+ */
+export function completeElementAction(
+  origin: ElementActionOrigin | null,
+  result: { survivorZoneId?: string } = {},
+): boolean {
+  if (!origin) return false
+  const { levelId } = origin.room
+  const index = getRoomSelectionIndex(levelId)
+  const records = index.update(useScene.getState().nodes)
+  const known = (zoneId: string | undefined) =>
+    !!zoneId && records.some((room) => room.key.zoneId === zoneId)
+  const zoneId = known(origin.room.zoneId)
+    ? origin.room.zoneId
+    : known(result.survivorZoneId)
+      ? result.survivorZoneId!
+      : origin.point
+        ? (index.roomAtPoint(levelId, origin.point)?.key.zoneId ?? null)
+        : null
+  if (!zoneId) {
+    useViewer.getState().setSelection({ selectedIds: [] })
+    useEditor.getState().clearRoom()
+    return false
+  }
+  selectRoom({ levelId, zoneId })
+  return true
+}