@pascal-app/editor 1.0.3 → 1.0.5

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,71 @@
+import { describe, expect, test } from 'bun:test'
+import { type AnyNode, registerNode } from '@pascal-app/core'
+import {
+  placementNoticeOf,
+  previewPlacementNoticeOf,
+  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()
+  })
+})
+
+test('ephemeral preview notices see their context without inserting a draft into the scene', () => {
+  const kind = registerKind((node: AnyNode, ctx: { nodes: Record<string, AnyNode> }) => ({
+    line: `${node.id}:${ctx.nodes.child?.name}`,
+  }))
+  const nodes = {}
+  const draft = nodeOf('preview', kind)
+  expect(
+    previewPlacementNoticeOf(nodes, {
+      node: draft,
+      parentNode: null,
+      contextNodes: [{ ...nodeOf('child', kind), name: 'draft child' }],
+    }),
+  ).toEqual({ line: 'preview:draft child' })
+  expect(nodes).toEqual({})
+  expect(
+    previewPlacementNoticeOf(nodes, { node: null, parentNode: null, contextNodes: [] }),
+  ).toBeNull()
+})

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

@@ -0,0 +1,73 @@
+import {
+  type AnyNode,
+  type AnyNodeId,
+  type LiveTransformLike,
+  nodeRegistry,
+  type PlacementNotice,
+  useLiveTransforms,
+  useScene,
+} from '@pascal-app/core'
+import { useMemo } from 'react'
+import { useShallow } from 'zustand/react/shallow'
+import usePlacementPreview from '../store/use-placement-preview'
+
+/** 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 })
+}
+
+export function previewPlacementNoticeOf(
+  nodes: Readonly<Record<string, AnyNode>>,
+  draft: Pick<
+    ReturnType<typeof usePlacementPreview.getState>,
+    'node' | 'parentNode' | 'contextNodes'
+  >,
+): PlacementNotice | null {
+  if (!draft.node) return null
+  const context = {
+    ...nodes,
+    ...Object.fromEntries(draft.contextNodes.map((node) => [node.id, node])),
+    ...(draft.parentNode ? { [draft.parentNode.id]: draft.parentNode } : {}),
+    [draft.node.id]: draft.node,
+  }
+  return placementNoticeOf(context, draft.node.id)
+}
+
+/**
+ * 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,
+  preview = false,
+): PlacementNotice | null {
+  const draft = usePlacementPreview(
+    useShallow((state) =>
+      preview
+        ? { node: state.node, parentNode: state.parentNode, contextNodes: state.contextNodes }
+        : null,
+    ),
+  )
+  const nodes = useScene((state) => (nodeId || draft?.node ? state.nodes : null))
+  const live = useLiveTransforms((state) => (nodeId ? state.get(nodeId) : undefined))
+  return useMemo(() => {
+    if (!nodes) return null
+    if (nodeId) return placementNoticeOf(nodes, nodeId, live)
+    if (!draft?.node) return null
+    return previewPlacementNoticeOf(nodes, draft)
+  }, [nodes, live, nodeId, draft])
+}
+
+/** 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 }