@pascal-app/editor 1.0.1 → 1.0.4

package/src/hooks/use-open-wall-ends.test.ts

@@ -0,0 +1,99 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, DoorNode, type OpenWallEnd, WallNode } from '@pascal-app/core'
+import { analyseOpenWallEnds } from './use-open-wall-ends'
+
+const wall = (id: string, start: [number, number], end: [number, number]) =>
+  ({
+    id,
+    type: 'wall',
+    object: 'node',
+    parentId: 'level_a',
+    visible: true,
+    children: [],
+    metadata: {},
+    start,
+    end,
+    thickness: 0.1,
+  }) as unknown as WallNode
+
+// A 4 x 4 room whose last corner is left 4 cm open (bodies are 0.1 thick).
+const walls = () => [
+  wall('wall_1', [0, 0], [4, 0]),
+  wall('wall_2', [4, 0], [4, 4]),
+  wall('wall_3', [4, 4], [0, 4]),
+  wall('wall_4', [0, 4], [0, 0.09]),
+]
+
+describe('open wall end analysis shared by the floor plan and 3D view', () => {
+  test('finds the open corner', () => {
+    const ends = analyseOpenWallEnds('level_a', walls())
+    expect(ends.some((end) => end.wallId === 'wall_4' && end.end === 'end')).toBe(true)
+  })
+
+  test('two views reading the same walls get one result', () => {
+    const shared = walls()
+    const first = analyseOpenWallEnds('level_a', [...shared])
+    expect(analyseOpenWallEnds('level_a', [...shared])).toBe(first)
+  })
+
+  test('a changed wall is analysed again', () => {
+    const shared = walls()
+    const first = analyseOpenWallEnds('level_a', shared)
+    const closed = [...shared.slice(0, 3), wall('wall_4', [0, 4], [0, 0])]
+    const next = analyseOpenWallEnds('level_a', closed)
+    expect(next).not.toBe(first)
+    expect(next.some((end) => end.wallId === 'wall_4')).toBe(false)
+  })
+})
+
+describe('the open-end preview reads what the walls host', () => {
+  // An 88° near-miss T: the source wall stops 9 cm short of the long target wall.
+  const level = 'level_t'
+  const tWall = (id: string, start: [number, number], end: [number, number], thickness = 0.1) =>
+    WallNode.parse({ id, parentId: level, start, end, thickness })
+  const scene = () => {
+    const tip: [number, number] = [2 + (3 - 0.09) / Math.tan((88 * Math.PI) / 180), 0.09]
+    const source = tWall('wall_source', [2, 3], tip, 0.01)
+    return {
+      source,
+      walls: [
+        source,
+        tWall('wall_target', [-20, 0], [30, 0], 0.01),
+        tWall('wall_anchor', [2, 3], [-20, 3]),
+        tWall('wall_left', [-20, 3], [-20, 0]),
+      ],
+    }
+  }
+  const sourceEnd = (ends: OpenWallEnd[]) =>
+    ends.find((end) => end.wallId === 'wall_source' && end.end === 'end')
+
+  test('without an opening the preview squares the corner', () => {
+    const point = sourceEnd(analyseOpenWallEnds(level, scene().walls))?.candidate?.point
+    expect(point?.[0]).toBeCloseTo(2, 6)
+    expect(point?.[1]).toBeCloseTo(0, 6)
+  })
+
+  test('a door flush with the anchored end keeps the join straight, and only the door changing re-runs it', () => {
+    const { source, walls } = scene()
+    const door = DoorNode.parse({
+      id: 'door_source',
+      parentId: source.id,
+      wallId: source.id,
+      position: [0.4, 1.05, 0],
+      width: 0.8,
+    })
+    const hosted: AnyNode[] = [
+      { ...source, children: [door.id] } as AnyNode,
+      ...walls.slice(1),
+      door as AnyNode,
+    ]
+    const first = analyseOpenWallEnds(level, hosted)
+    const point = sourceEnd(first)?.candidate?.point
+    expect(point?.[0]).toBeCloseTo(2 + 3 / Math.tan((88 * Math.PI) / 180), 6)
+    expect(point?.[1]).toBeCloseTo(0, 6)
+
+    const narrower = { ...door, width: 0.6 } as AnyNode
+    const next = analyseOpenWallEnds(level, [...hosted.slice(0, -1), narrower])
+    expect(next).not.toBe(first)
+  })
+})

package/src/hooks/use-open-wall-ends.ts

@@ -0,0 +1,238 @@
+'use client'
+
+import { type AnyNode, findOpenWallEnds, type OpenWallEnd, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { useEffect, useMemo, useRef, useState } from 'react'
+import { useShallow } from 'zustand/react/shallow'
+import {
+  collapseMutualOpenWallEnds,
+  joinOpenWallEnd,
+  openWallEndKey,
+  visibleOpenWallEnds,
+} from '../lib/floorplan/open-wall-ends'
+import { sfxEmitter } from '../lib/sfx-bus'
+import useEditor from '../store/use-editor'
+import { useFloorplanDraftPreview } from '../store/use-floorplan-draft-preview'
+import useInteractionScope from '../store/use-interaction-scope'
+
+type Boundary = Extract<AnyNode, { type: 'wall' | 'separator' }>
+
+const NO_ENDS: OpenWallEnd[] = []
+
+const isBoundary = (node: AnyNode): node is Boundary =>
+  node.type === 'wall' || node.type === 'separator'
+
+let lastAnalysis: {
+  levelId: string
+  nodes: readonly AnyNode[]
+  ends: OpenWallEnd[]
+} | null = null
+
+/**
+ * The room-graph pass behind the open-end markers, shared by the floor plan
+ * and the 3D view: split view mounts both, and they must not pay for it twice.
+ * `nodes` is the level's walls and separators plus what the walls host: an
+ * opening can stop core squaring a corner, and the preview must land where
+ * Join walls will. Recomputed only when one of those nodes changes (compared
+ * by reference), never per frame or on unrelated edits.
+ */
+export function analyseOpenWallEnds(levelId: string, nodes: readonly AnyNode[]): OpenWallEnd[] {
+  const last = lastAnalysis
+  if (
+    last &&
+    last.levelId === levelId &&
+    last.nodes.length === nodes.length &&
+    last.nodes.every((node, index) => node === nodes[index])
+  ) {
+    return last.ends
+  }
+  const ends = findOpenWallEnds(Object.fromEntries(nodes.map((node) => [node.id, node])), levelId)
+  lastAnalysis = { levelId, nodes, ends }
+  return ends
+}
+
+/** Moving, placing, reshaping or dragging a handle: the markers step aside. */
+export function useOpenWallEndsSuppressed(): boolean {
+  return useInteractionScope(
+    (state) =>
+      state.scope.kind === 'moving' ||
+      state.scope.kind === 'placing' ||
+      state.scope.kind === 'reshaping' ||
+      state.scope.kind === 'handle-drag',
+  )
+}
+
+export type OpenWallEndsState = {
+  /** The wall tool (any variant) or Divide is active. */
+  drawing: boolean
+  /** A wall or divide segment is mid-draft: markers stay visible but out of the way. */
+  drafting: boolean
+  /** Ends to mark, mutual pairs collapsed to the end that slides straight. */
+  ends: OpenWallEnd[]
+  /** Walls on the active level that bound no room. */
+  roomlessWallIds: string[]
+  /** Whether the overlay is up at all (drawing, or a near miss to show). */
+  shown: boolean
+}
+
+/**
+ * Open wall ends on the active level and when to show them. On while walls or
+ * rooms are being drawn; otherwise only when a wall that bounds no room has a
+ * near miss.
+ */
+export function useOpenWallEnds(): OpenWallEndsState {
+  const levelId = useViewer((state) => state.selection.levelId)
+  const mode = useEditor((state) => state.mode)
+  const tool = useEditor((state) => state.tool)
+  const spaces = useEditor(
+    useShallow((state) => Object.values(state.spaces).filter((space) => space.levelId === levelId)),
+  )
+  const isDividing = useInteractionScope((state) => state.scope.kind === 'room-divide')
+  const dividingDraft = useInteractionScope(
+    (state) => state.scope.kind === 'room-divide' && state.scope.points.length > 0,
+  )
+  const wallDrafting = useFloorplanDraftPreview(
+    (state) =>
+      state.wallDraftStart !== null ||
+      state.wallRectangleDraftStart !== null ||
+      state.wallPolygonDraftPoints.length > 0,
+  )
+  // Walls and separators first, then every node a wall hosts — one flat list,
+  // so a door moving re-runs the analysis but an unrelated item edit does not.
+  const analysisNodes = useScene(
+    useShallow((state) => {
+      const level = levelId ? state.nodes[levelId as AnyNode['id']] : undefined
+      if (level?.type !== 'level') return [] as AnyNode[]
+      const boundaries = level.children
+        .map((id) => state.nodes[id])
+        .filter((node): node is Boundary => !!node && isBoundary(node))
+      const hosted = boundaries.flatMap((node) =>
+        node.type === 'wall'
+          ? node.children
+              .map((id) => state.nodes[id])
+              .filter((child): child is AnyNode => child !== undefined)
+          : [],
+      )
+      return [...boundaries, ...hosted]
+    }),
+  )
+  const boundaries = useMemo(() => analysisNodes.filter(isBoundary), [analysisNodes])
+
+  const drawing = (mode === 'build' && tool === 'wall') || isDividing
+  const roomWallIds = useMemo(() => {
+    const ids = new Set<string>()
+    for (const space of spaces) for (const wallId of space.wallIds) ids.add(wallId)
+    return ids
+  }, [spaces])
+  const roomlessWallIds = useMemo(
+    () =>
+      boundaries
+        .filter((node) => node.type === 'wall' && !roomWallIds.has(node.id))
+        .map((node) => node.id as string),
+    [boundaries, roomWallIds],
+  )
+  const hasWalls = boundaries.some((node) => node.type === 'wall')
+  const shouldAnalyse = !!levelId && hasWalls && (drawing || roomlessWallIds.length > 0)
+  const openEnds = useMemo(
+    () => (shouldAnalyse && levelId ? analyseOpenWallEnds(levelId, analysisNodes) : NO_ENDS),
+    [shouldAnalyse, levelId, analysisNodes],
+  )
+  const ends = useMemo(() => {
+    const walls = new Map(boundaries.map((node) => [node.id as string, node]))
+    return collapseMutualOpenWallEnds(
+      visibleOpenWallEnds(openEnds, roomWallIds, drawing),
+      (wallId) => {
+        const wall = walls.get(wallId)
+        return wall?.type === 'wall'
+          ? [wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]]
+          : null
+      },
+    )
+  }, [openEnds, roomWallIds, drawing, boundaries])
+
+  return {
+    drawing,
+    drafting: wallDrafting || dividingDraft,
+    ends,
+    roomlessWallIds,
+    shown: drawing || ends.length > 0,
+  }
+}
+
+const HOVER_RELEASE_MS = 250
+
+function clearReleaseTimer(timer: { current: ReturnType<typeof setTimeout> | null }) {
+  if (timer.current) clearTimeout(timer.current)
+  timer.current = null
+}
+
+/**
+ * Hover / pin / join for one view's markers — the floor plan and the 3D view
+ * each keep their own, so hovering a dot in one does not pop a pill in the
+ * other. A pinned pill closes on Escape or a press outside any
+ * `[data-open-wall-end]` element.
+ */
+export function useOpenWallEndFocus(ends: readonly OpenWallEnd[], drafting: boolean) {
+  const [hoveredKey, setHoveredKey] = useState<string | null>(null)
+  const [pinnedKey, setPinnedKey] = useState<string | null>(null)
+  const [refusal, setRefusal] = useState<{ key: string; message: string } | null>(null)
+  const releaseTimer = useRef<ReturnType<typeof setTimeout> | null>(null)
+
+  const clearTimer = () => clearReleaseTimer(releaseTimer)
+  useEffect(() => () => clearReleaseTimer(releaseTimer), [])
+
+  const activeKey = pinnedKey ?? hoveredKey
+  const activeEnd = drafting
+    ? null
+    : (ends.find((end) => end.candidate && openWallEndKey(end) === activeKey) ?? null)
+
+  useEffect(() => {
+    if (!pinnedKey) return
+    const onPointerDown = (event: PointerEvent) => {
+      const target = event.target instanceof Element ? event.target : null
+      if (target?.closest('[data-open-wall-end]')) return
+      setPinnedKey(null)
+    }
+    window.addEventListener('pointerdown', onPointerDown, true)
+    return () => window.removeEventListener('pointerdown', onPointerDown, true)
+  }, [pinnedKey])
+
+  useEffect(() => {
+    if (!activeEnd) return
+    const onKeyDown = (event: KeyboardEvent) => {
+      if (event.key !== 'Escape') return
+      event.stopPropagation()
+      clearReleaseTimer(releaseTimer)
+      setPinnedKey(null)
+      setHoveredKey(null)
+      setRefusal(null)
+    }
+    window.addEventListener('keydown', onKeyDown, true)
+    return () => window.removeEventListener('keydown', onKeyDown, true)
+  }, [activeEnd])
+
+  return {
+    activeKey,
+    activeEnd,
+    refusal: activeEnd && refusal?.key === openWallEndKey(activeEnd) ? refusal.message : null,
+    keepHover: (key: string) => {
+      clearTimer()
+      setHoveredKey(key)
+    },
+    releaseHover: () => {
+      clearTimer()
+      releaseTimer.current = setTimeout(() => setHoveredKey(null), HOVER_RELEASE_MS)
+    },
+    togglePin: (key: string) => setPinnedKey((current) => (current === key ? null : key)),
+    pin: (key: string) => setPinnedKey(key),
+    join: (end: OpenWallEnd) => {
+      const key = openWallEndKey(end)
+      const message = joinOpenWallEnd(end)
+      setRefusal(message ? { key, message } : null)
+      if (message) return
+      sfxEmitter.emit('sfx:structure-build')
+      setPinnedKey(null)
+      setHoveredKey(null)
+    },
+  }
+}

package/src/hooks/use-placement-notice.test.ts

@@ -0,0 +1,48 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, registerNode } from '@pascal-app/core'
+import { placementNoticeOf, transientDraftId } from './use-placement-notice'
+
+// The editor asks a node's definition for its placement notice; it names no kind.
+function registerKind(placementNotice?: unknown): string {
+  const kind = `test:notice-${crypto.randomUUID()}`
+  registerNode({
+    kind,
+    schemaVersion: 1,
+    category: 'furnish',
+    defaults: () => ({}),
+    capabilities: {},
+    ...(placementNotice ? { placementNotice } : {}),
+  } as never)
+  return kind
+}
+
+const nodeOf = (id: string, type: string, metadata?: Record<string, unknown>) =>
+  ({ id, type, parentId: 'level_a', metadata: metadata ?? {} }) as unknown as AnyNode
+
+describe('the placement notice of the node in hand', () => {
+  test("comes from the node's definition, at its live pose", () => {
+    const kind = registerKind((node: AnyNode, ctx: { live?: { position: number[] } }) => ({
+      line: `${node.id} at ${ctx.live?.position.join(',') ?? 'rest'}`,
+    }))
+    const nodes = { a: nodeOf('a', kind) }
+    expect(placementNoticeOf(nodes, 'a')).toEqual({ line: 'a at rest' })
+    expect(placementNoticeOf(nodes, 'a', { position: [1, 0, 2], rotation: 0 })).toEqual({
+      line: 'a at 1,0,2',
+    })
+  })
+
+  test('is null for a kind that declares none, and for a node not in the scene', () => {
+    const nodes = { b: nodeOf('b', registerKind()) }
+    expect(placementNoticeOf(nodes, 'b')).toBeNull()
+    expect(placementNoticeOf(nodes, 'missing')).toBeNull()
+  })
+
+  test("a tool's transient draft is found whatever its kind", () => {
+    const nodes = {
+      kept: nodeOf('kept', registerKind()),
+      draft: nodeOf('draft', registerKind(), { isTransient: true }),
+    }
+    expect(transientDraftId(nodes) as string | null).toBe('draft')
+    expect(transientDraftId({ kept: nodes.kept })).toBeNull()
+  })
+})

package/src/hooks/use-placement-notice.ts

@@ -0,0 +1,42 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  type LiveTransformLike,
+  nodeRegistry,
+  type PlacementNotice,
+  useLiveTransforms,
+  useScene,
+} from '@pascal-app/core'
+import { useMemo } from 'react'
+
+/** The notice `nodeId`'s kind gives for where it stands (`placementNotice`), if it declares one. */
+export function placementNoticeOf(
+  nodes: Readonly<Record<string, AnyNode>>,
+  nodeId: string,
+  live?: LiveTransformLike,
+): PlacementNotice | null {
+  const node = nodes[nodeId as AnyNodeId]
+  const notice = node ? nodeRegistry.get(node.type)?.placementNotice : undefined
+  if (!(node && notice)) return null
+  return notice(node as never, live ? { nodes, live } : { nodes })
+}
+
+/**
+ * What the node in hand, or the selected node, says about where it stands, read at its live pose
+ * while it is placed or moved. Subscribes to the scene only while a node is given, so an
+ * always-mounted caller doesn't re-render on every write.
+ */
+export function usePlacementNotice(nodeId: string | null | undefined): PlacementNotice | null {
+  const nodes = useScene((state) => (nodeId ? state.nodes : null))
+  const live = useLiveTransforms((state) => (nodeId ? state.get(nodeId) : undefined))
+  return useMemo(
+    () => (nodeId && nodes ? placementNoticeOf(nodes, nodeId, live) : null),
+    [nodes, live, nodeId],
+  )
+}
+
+/** The node a construction tool is placing: its transient draft. */
+export const transientDraftId = (nodes: Readonly<Record<string, AnyNode>>) =>
+  Object.values(nodes).find(
+    (node) => !!(node.metadata as { isTransient?: boolean } | null)?.isTransient,
+  )?.id ?? null

package/src/hooks/use-selected-room.ts

@@ -0,0 +1,143 @@
+'use client'
+
+import { type AnyNode, type AnyNodeId, useScene } from '@pascal-app/core'
+import { useViewer } from '@pascal-app/viewer'
+import { useCallback, useSyncExternalStore } from 'react'
+import { selectionEnabled } from '../lib/interaction/scope'
+import {
+  type RoomKey,
+  RoomSelectionIndex,
+  type RoomSelectionRecord,
+  resolveRoomHit,
+} from '../lib/room-selection'
+import { shouldInterceptRoom } from '../lib/room-selection-commands'
+import { type SelectionModifierKeys, selectionModifiersFromEvent } from '../lib/selection-routing'
+import useEditor from '../store/use-editor'
+import useInteractionScope from '../store/use-interaction-scope'
+
+const indexes = new Map<string, RoomSelectionIndex>()
+const subscriptions = new Map<string, { listeners: Set<() => void>; dispose: () => void }>()
+const EMPTY: RoomSelectionRecord[] = []
+
+export function getRoomSelectionIndex(levelId: string) {
+  let index = indexes.get(levelId)
+  if (!index) {
+    index = new RoomSelectionIndex(levelId)
+    indexes.set(levelId, index)
+  }
+  index.update(useScene.getState().nodes)
+  return index
+}
+
+function subscribeLevel(levelId: string | null, listener: () => void) {
+  if (!levelId) return () => {}
+  let subscription = subscriptions.get(levelId)
+  if (!subscription) {
+    const listeners = new Set<() => void>()
+    const dispose = useScene.subscribe((state, previous) => {
+      if (state.nodes === previous.nodes) return
+      const rooms = getRoomSelectionIndex(levelId).update(state.nodes)
+      const editor = useEditor.getState()
+      if (
+        editor.room?.levelId === levelId &&
+        !rooms.some((room) => room.key.zoneId === editor.room?.zoneId)
+      )
+        editor.clearRoom()
+      for (const notify of listeners) notify()
+    })
+    subscription = { listeners, dispose }
+    subscriptions.set(levelId, subscription)
+  }
+  subscription.listeners.add(listener)
+  return () => {
+    subscription.listeners.delete(listener)
+    if (!subscription.listeners.size) {
+      subscription.dispose()
+      subscriptions.delete(levelId)
+      indexes.delete(levelId)
+    }
+  }
+}
+
+export function useRoomRecords(levelId: string | null) {
+  const subscribe = useCallback((notify: () => void) => subscribeLevel(levelId, notify), [levelId])
+  const snapshot = useCallback(
+    () => (levelId ? getRoomSelectionIndex(levelId).update(useScene.getState().nodes) : EMPTY),
+    [levelId],
+  )
+  return useSyncExternalStore(subscribe, snapshot, snapshot)
+}
+
+export function useSelectedRoom() {
+  const key = useEditor((state) => state.room)
+  const rooms = useRoomRecords(key?.levelId ?? null)
+  return rooms.find((room) => room.key.zoneId === key?.zoneId) ?? null
+}
+
+/**
+ * The room a selected zone is, for the room panel: its record when the room
+ * index knows it, `{ record: null }` for a room the walls do not close, null
+ * for anything that is not a room.
+ */
+export function useZoneRoom(zoneId: string | null): { record: RoomSelectionRecord | null } | null {
+  const levelId = useScene((state) => {
+    const zone = zoneId ? state.nodes[zoneId as AnyNodeId] : undefined
+    return zone?.type === 'zone' && zone.spaceRole === 'room' ? (zone.parentId ?? null) : null
+  })
+  const rooms = useRoomRecords(levelId)
+  if (!(zoneId && levelId)) return null
+  return { record: rooms.find((room) => room.key.zoneId === zoneId) ?? null }
+}
+
+export function useHighlightedRoom() {
+  const key = useEditor((state) => state.hoveredRoom ?? state.room)
+  const rooms = useRoomRecords(key?.levelId ?? null)
+  return rooms.find((room) => room.key.zoneId === key?.zoneId) ?? null
+}
+
+const hitPoint: [number, number] = [0, 0]
+
+export function resolveEditorRoomHit(
+  node: AnyNode | null,
+  levelId: string,
+  point: readonly [number, number],
+  view: '2d' | '3d',
+) {
+  if (node && node.type !== 'wall' && node.type !== 'slab' && node.type !== 'ceiling') return null
+  const index = getRoomSelectionIndex(levelId)
+  hitPoint[0] = point[0]
+  hitPoint[1] = point[1]
+  const room = resolveRoomHit(index, levelId, node, hitPoint, view)
+  return room?.key ?? null
+}
+
+/** Rooms pick inside the building; from site a click picks the whole building. */
+export function roomPickingEnabled() {
+  const editor = useEditor.getState()
+  return (
+    editor.phase !== 'site' &&
+    editor.mode === 'select' &&
+    !useViewer.getState().focusedUnitId &&
+    selectionEnabled(useInteractionScope.getState().scope)
+  )
+}
+
+export function hoverRoomFromHit(
+  hit: RoomKey | null,
+  modifiers: SelectionModifierKeys,
+  nodeId: string | null,
+) {
+  const editor = useEditor.getState()
+  const room = shouldInterceptRoom(hit, modifiers, nodeId) ? hit : null
+  editor.setHoveredRoom(room)
+  if (room) useViewer.getState().setHoveredId(null)
+  return !!room
+}
+
+export function resolvePlanRoomHit(nodeId: string | null, point: readonly [number, number]) {
+  const node = nodeId ? useScene.getState().nodes[nodeId as AnyNodeId] : null
+  const levelId = node?.parentId ?? useViewer.getState().selection.levelId
+  return levelId ? resolveEditorRoomHit(node ?? null, levelId, point, '2d') : null
+}
+
+export { selectionModifiersFromEvent }