@pascal-app/editor 1.0.6 → 1.1.0

package/src/hooks/use-keyboard.ts

@@ -1,6 +1,7 @@
 import {
   type AnyNode,
   type AnyNodeId,
+  doorPositionForFacing,
   emitter,
   nodeRegistry,
   pauseSpaceDetection,
@@ -34,12 +35,15 @@ import { isActive } from '../lib/interaction/scope'
 import { paintRegionModeActive } from '../lib/paint-region-mode'
 import { popRoomSelection } from '../lib/room-selection-commands'
 import { copySelectedNodesToEditorClipboard } from '../lib/scene-clipboard'
+import { cycleSelectionAtPointer, trackSelectionCyclePointer } from '../lib/selection-cycle'
 import { sfxEmitter } from '../lib/sfx-bus'
 import { openSidebarPanel } from '../lib/sidebar-panel'
 import { activeSiteNode, clampBrushRadius } from '../lib/terrain-sculpt'
+import { armToolShortcut, toolShortcutForKey } from '../lib/tool-shortcuts'
 import { isTypingTarget } from '../lib/typing-target'
 import { leaveUnitFocus } from '../lib/units'
-import { selectWallDrawVariant } from '../lib/wall-draw-variant'
+import { subscribeWallKindReset } from '../lib/wall-draw-variant'
+import { isWallNudgeKey, nudgeSelectedWall } from '../lib/wall-nudge'
 import useDeleteConfirmation from '../store/use-delete-confirmation'
 import useEditor, { getActiveContinuationContext, getActiveSnapContext } from '../store/use-editor'
 import useInteractionScope, {
@@ -49,6 +53,14 @@ import useInteractionScope, {
 import { groupCurrentSelection, ungroupCurrentSelection } from '../store/use-session-groups'
 import { activeViewLayout } from '../store/view-layout'
 
+const pickKeyFields = (e: KeyboardEvent) => ({
+  code: e.code,
+  shiftKey: e.shiftKey,
+  metaKey: e.metaKey,
+  ctrlKey: e.ctrlKey,
+  altKey: e.altKey,
+})
+
 export function hasSceneKeyboardFocus(): boolean {
   const layout = activeViewLayout(useEditor.getState())
   return isSceneView(layout.panes[layout.focus])
@@ -208,13 +220,12 @@ export const runHistoryShortcut = (direction: 'undo' | 'redo') => {
 }
 
 /**
- * B: the wall tool on Rectangle — the quickest room — with the Build panel
- * showing, so the lit tile says what is in hand. The panel's tiles still pick
- * another shape for the session. The panel opens before the tool is armed: a
- * host may drop the armed tool when the panel changes.
+ * B: the wall tool on the Rooms shape picked last (Rectangle, Polygon or Walls,
+ * kept with the editor preferences; Rectangle until one is picked), with the
+ * Build panel showing, so the lit tile says what is in hand. The panel opens
+ * before the tool is armed: a host may drop the armed tool when the panel changes.
  */
 export const armWallToolFromShortcut = () => {
-  selectWallDrawVariant('rectangle')
   openSidebarPanel(['build'])
   useEditor.getState().armToolMode({ mode: 'build', tool: 'wall' })
 }
@@ -257,6 +268,8 @@ export const isToolOwnedRotation = () => {
     (editor.tool === 'door' ||
       editor.tool === 'window' ||
       editor.tool === 'roof' ||
+      editor.tool === 'stair' ||
+      editor.tool === 'elevator' ||
       // The item tool is mounted for the build mode, but it only owns R/T
       // when a catalog item is actually selected and a placement draft can
       // exist. Without this check, selecting an existing item in the 2D plan
@@ -312,6 +325,7 @@ export const useKeyboard = ({
     if (disabled) {
       return
     }
+    trackSelectionCyclePointer()
 
     // True while an active placement tool owns R/T. Door/window tools flip the
     // draft, item / lean-to placement rotates its draft, and the roof tool turns
@@ -467,6 +481,18 @@ export const useKeyboard = ({
         }
       }
 
+      // Drafting tools on Shift with D / W / S / R, where the bare key pans or
+      // rotates (lib/tool-shortcuts). An armed placement keeps Shift+R as its own R.
+      const toolShortcut = isVersionPreviewMode
+        ? null
+        : toolShortcutForKey({ ...pickKeyFields(e), repeat: false })
+      if (toolShortcut && !(toolShortcut === 'roof' && isToolOwnedRotation())) {
+        e.preventDefault()
+        // A held chord repeats: arm once, and never let a repeat fall through to bare R.
+        if (!e.repeat) armToolShortcut(toolShortcut)
+        return
+      }
+
       if (e.key === 'Escape') {
         e.preventDefault()
 
@@ -585,6 +611,31 @@ export const useKeyboard = ({
             }
           }
         }
+      } else if (isWallNudgeKey(e.key) && !e.metaKey && !e.ctrlKey && !e.altKey && !e.shiftKey) {
+        // Bare arrows nudge a selected wall an inch in the floor plan.
+        const editor = useEditor.getState()
+        if (
+          isVersionPreviewMode ||
+          editor.mode !== 'select' ||
+          useInteractionScope.getState().scope.kind !== 'idle' ||
+          editor.isFirstPersonMode
+        ) {
+          return
+        }
+        if (nudgeSelectedWall(e.key)) e.preventDefault()
+      } else if (e.key === 'Tab' && !e.metaKey && !e.ctrlKey && !e.altKey) {
+        // Tab steps the selection to the next object under the pointer in the
+        // floor plan (Shift+Tab back): a wall hidden under another is reachable.
+        const editor = useEditor.getState()
+        if (
+          isVersionPreviewMode ||
+          editor.mode !== 'select' ||
+          useInteractionScope.getState().scope.kind !== 'idle' ||
+          editor.isFirstPersonMode
+        ) {
+          return
+        }
+        if (cycleSelectionAtPointer(e.shiftKey)) e.preventDefault()
       } else if (
         (e.key === 'r' || e.key === 'R') &&
         !e.metaKey &&
@@ -600,7 +651,7 @@ export const useKeyboard = ({
         // open/close toggle lives on E. Windows still use R to toggle
         // their open/closed state.
         //
-        // Skipped while an item, door, window, or roof placement owns rotation.
+        // Skipped while a placement tool (item, door, window, roof, stair…) owns rotation.
         // The user can still have a node selected during placement; without this
         // guard both the draft and the selection would rotate.
         //
@@ -637,6 +688,11 @@ export const useKeyboard = ({
             useScene.getState().updateNode(node.id, {
               side: node.side === 'front' ? 'back' : 'front',
               rotation: [node.rotation[0], node.rotation[1] + Math.PI, node.rotation[2]],
+              position: doorPositionForFacing(node, [
+                node.rotation[0],
+                node.rotation[1] + Math.PI,
+                node.rotation[2],
+              ]),
             })
             if (node.parentId) {
               useScene.getState().dirtyNodes.add(node.parentId as AnyNodeId)
@@ -847,7 +903,9 @@ export const useKeyboard = ({
     window.addEventListener('keydown', handleSessionGroupKeyDown, true)
     window.addEventListener('keydown', handleKeyDown)
     window.addEventListener('keyup', handleKeyUp)
+    const unsubscribeWallKind = subscribeWallKindReset()
     return () => {
+      unsubscribeWallKind()
       window.removeEventListener('keydown', handleSessionGroupKeyDown, true)
       window.removeEventListener('keydown', handleKeyDown)
       window.removeEventListener('keyup', handleKeyUp)

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

@@ -1,8 +1,9 @@
 'use client'
 
-import { type AnyNode, type AnyNodeId, useScene } from '@pascal-app/core'
+import { type AnyNode, type AnyNodeId, nodeRegistry, useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
 import { useCallback, useSyncExternalStore } from 'react'
+import { getFloorplanNodeExtension } from '../lib/floorplan/floorplan-extension'
 import { selectionEnabled } from '../lib/interaction/scope'
 import {
   type RoomKey,
@@ -134,8 +135,18 @@ export function hoverRoomFromHit(
   return !!room
 }
 
+/**
+ * The room a plan hit picks first. A kind whose plan extension declares
+ * `planHitSelectsNode` (a wall: a thin band between two rooms whose interiors
+ * are clickable in their own right) keeps the hit: picking a room by which
+ * half of the band the pointer landed on made thin partitions take several
+ * clicks. 3D keeps them room-first, where a room's floor is often hidden
+ * behind its walls.
+ */
 export function resolvePlanRoomHit(nodeId: string | null, point: readonly [number, number]) {
   const node = nodeId ? useScene.getState().nodes[nodeId as AnyNodeId] : null
+  if (node && getFloorplanNodeExtension(nodeRegistry.get(node.type))?.planHitSelectsNode)
+    return null
   const levelId = node?.parentId ?? useViewer.getState().selection.levelId
   return levelId ? resolveEditorRoomHit(node ?? null, levelId, point, '2d') : null
 }

package/src/i18n/floor-footprint-name.ts

@@ -0,0 +1,30 @@
+import {
+  type AnyNode,
+  floorFootprintNaming,
+  type PascalI18n,
+  type SlabNode,
+} from '@pascal-app/core'
+import { displayRoomName } from '../lib/room-name-messages'
+
+/** `floorFootprintName` in the UI language; MCP and agents keep core's English. */
+export function localizedFloorFootprintName(
+  nodes: Readonly<Record<string, AnyNode>>,
+  plate: SlabNode,
+  i18n: PascalI18n,
+): string {
+  const naming = floorFootprintNaming(nodes, plate)
+  switch (naming.kind) {
+    case 'named':
+      return naming.name
+    case 'room':
+      return i18n._({
+        id: 'editor.floorFootprint.room',
+        message: '{room} floor',
+        values: { room: displayRoomName(naming.room, i18n) },
+      })
+    case 'shared':
+      return i18n._({ id: 'editor.floorFootprint.shared', message: 'Shared floor' })
+    case 'area':
+      return i18n._({ id: 'editor.floorFootprint.area', message: 'Floor area' })
+  }
+}

package/src/i18n/level-name.ts

@@ -0,0 +1,39 @@
+import { getDefaultLevelName, levelDisplayNumber, type PascalI18n } from '@pascal-app/core'
+
+type DisplayLevel = {
+  level?: number
+  name?: string
+}
+
+/** The level's own name, or undefined while it carries a generated default. */
+export function authoredLevelName(level: DisplayLevel): string | undefined {
+  const levelNumber = level.level ?? 0
+  const name = level.name?.trim()
+  return name && name !== `Level ${levelNumber}` && name !== getDefaultLevelName(levelNumber)
+    ? name
+    : undefined
+}
+
+export function localizedLevelName(level: DisplayLevel, i18n: PascalI18n, locale: string): string {
+  const levelNumber = level.level ?? 0
+  const authoredName = authoredLevelName(level)
+  if (authoredName) return authoredName
+  if (levelNumber === 0) {
+    return i18n._({ id: 'core.level.groundFloor', message: 'Ground floor' })
+  }
+  if (levelNumber === -1) {
+    return i18n._({ id: 'core.level.basement', message: 'Basement' })
+  }
+  if (levelNumber < -1) {
+    return i18n._({
+      id: 'core.level.basementNumber',
+      message: 'Basement {number}',
+      values: { number: -levelNumber },
+    })
+  }
+  return i18n._({
+    id: 'core.level.floorNumber',
+    message: 'Floor {number}',
+    values: { number: levelDisplayNumber(levelNumber, locale) },
+  })
+}