@pascal-app/editor 1.0.6 → 1.1.0

package/src/components/editor/fit-scene-framing.ts

@@ -0,0 +1,142 @@
+export type FitSceneBounds = {
+  center: [number, number]
+  size: [number, number]
+} | null
+
+export type FitSceneLookAt = {
+  eyeX: number
+  eyeY: number
+  eyeZ: number
+  targetX: number
+  targetY: number
+  targetZ: number
+  /** The eye's height above `targetY`, before any keep-over-ground lift. */
+  eyeHeight: number
+  /**
+   * What an orthographic camera fits its zoom to: `setLookAt` leaves the
+   * previous project's zoom in place. Centred on the target, so fitting it
+   * does not move the pivot.
+   */
+  fitSphere: { center: [number, number, number]; radius: number }
+}
+
+// The empty-editor pose shows the default ±15 m site.
+const DEFAULT_FIT_RADIUS = 15
+// Margin around the footprint, as the frame-node path uses for orthographic fits.
+const FIT_SPHERE_MARGIN = 1.3
+// Keeps a lone wall from filling the viewport, like the perspective 15 m floor.
+const MIN_FIT_RADIUS = 5
+
+export type PendingFitScene = {
+  bounds: FitSceneBounds
+}
+
+export type FitSceneEventPlan =
+  | { action: 'ignore' }
+  | { action: 'apply'; lookAt: FitSceneLookAt }
+  | { action: 'queue'; pending: PendingFitScene }
+
+export type FitSceneResumePlan = { action: 'noop' } | { action: 'apply'; lookAt: FitSceneLookAt }
+
+/**
+ * Compute the orbit look-at used by `camera-controls:fit-scene`, resting the
+ * pivot at `groundY` (the selected level's orbit height).
+ * Null bounds restore the empty-editor default pose.
+ */
+export function computeFitSceneLookAt(bounds: FitSceneBounds, groundY = 0): FitSceneLookAt {
+  if (!bounds) {
+    return {
+      eyeX: 20,
+      eyeY: 20 + groundY,
+      eyeZ: 20,
+      targetX: 0,
+      targetY: groundY,
+      targetZ: 0,
+      eyeHeight: 20,
+      fitSphere: { center: [0, groundY, 0], radius: DEFAULT_FIT_RADIUS },
+    }
+  }
+
+  const [cx, cz] = bounds.center
+  const [w, d] = bounds.size
+  // Use the longer horizontal extent to size the orbit radius so the whole
+  // footprint sits in view regardless of aspect ratio.
+  const maxExtent = Math.max(w, d)
+  const distance = Math.max(maxExtent * 1.4, 15)
+  const height = Math.max(maxExtent * 0.8, 10)
+  return {
+    eyeX: cx + distance * 0.7,
+    eyeY: height + groundY,
+    eyeZ: cz + distance * 0.7,
+    targetX: cx,
+    targetY: groundY,
+    targetZ: cz,
+    eyeHeight: height,
+    fitSphere: {
+      center: [cx, groundY, cz],
+      radius: Math.max((Math.hypot(w, d) / 2) * FIT_SPHERE_MARGIN, MIN_FIT_RADIUS),
+    },
+  }
+}
+
+/**
+ * Decide what to do when a fit-scene event arrives.
+ * First-person (and briefly-unmounted orbit controls) must queue the frame
+ * so it can apply once orbit is back.
+ */
+export function planFitSceneOnEvent(input: {
+  isPreviewMode: boolean
+  isFirstPersonMode: boolean
+  hasControls: boolean
+  bounds: FitSceneBounds
+  groundY?: number
+}): FitSceneEventPlan {
+  if (input.isPreviewMode) return { action: 'ignore' }
+
+  const pending: PendingFitScene = { bounds: input.bounds }
+  if (input.isFirstPersonMode || !input.hasControls) {
+    return { action: 'queue', pending }
+  }
+
+  return { action: 'apply', lookAt: computeFitSceneLookAt(input.bounds, input.groundY) }
+}
+
+/**
+ * Flush a queued load frame once orbit controls can apply it. The ground is
+ * read at flush time: the selected level may have changed while it waited.
+ */
+export function planFitSceneOnOrbitResume(input: {
+  isPreviewMode: boolean
+  isFirstPersonMode: boolean
+  hasControls: boolean
+  pending: PendingFitScene | null
+  groundY?: number
+}): FitSceneResumePlan {
+  if (!input.pending || input.isPreviewMode || input.isFirstPersonMode || !input.hasControls) {
+    return { action: 'noop' }
+  }
+
+  return { action: 'apply', lookAt: computeFitSceneLookAt(input.pending.bounds, input.groundY) }
+}
+
+export type LevelFollowPlan = 'none' | 'default-pose' | 'rest-pivot'
+
+/**
+ * What the level-follow effect does with the orbit pivot.
+ *
+ * Only a scene-less first run takes the default pose. A first run over a
+ * loaded scene is a fresh controls instance (mount, leaving XR, error-boundary
+ * recovery) whose pivot sits at the origin, so it is rested on the level like
+ * a camera change; on a real load the later scene-ready fit still wins.
+ * Afterwards the pivot follows level, level-mode and camera changes only.
+ */
+export function planLevelFollow(input: {
+  firstLoad: boolean
+  sceneEmpty: boolean
+  levelChanged: boolean
+  modeChanged: boolean
+  cameraChanged: boolean
+}): LevelFollowPlan {
+  if (input.firstLoad) return input.sceneEmpty ? 'default-pose' : 'rest-pivot'
+  return input.levelChanged || input.modeChanged || input.cameraChanged ? 'rest-pivot' : 'none'
+}

package/src/components/editor/floating-action-menu.tsx

@@ -14,6 +14,7 @@ import {
   getWallThickness,
   isCurvedWall,
   isDerivedNode,
+  isNodeDuplicable,
   isRegistryMovable,
   isRegistrySelectable,
   isSplineFence,
@@ -24,11 +25,11 @@ import {
   sceneRegistry,
   summarizeSystemFor,
   useLiveNodeOverrides,
+  usePascalI18n,
   useScene,
   type WallNode,
 } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { Html } from '@react-three/drei'
 import { useFrame } from '@react-three/fiber'
 import { useCallback, useMemo, useRef } from 'react'
 import * as THREE from 'three'
@@ -53,6 +54,7 @@ import useInteractionScope, {
 } from '../../store/use-interaction-scope'
 import { IconRefGlyph } from '../ui/icon-ref'
 import { duplicateNodeAndPickUp } from './duplicate-node'
+import { Html } from './localized-html'
 import { formatMeasurement, MeasurementPill } from './measurement-pill'
 import { NodeActionMenu } from './node-action-menu'
 import { startZoneRoomTransform } from './room-controls'
@@ -283,7 +285,7 @@ function getHeightPillDimensions(node: WallNode | FenceNode): {
 } {
   if (node.type === 'wall') {
     return {
-      height: getWallEffectiveHeightForNodes(node, useScene.getState().nodes),
+      height: getWallEffectiveHeightForNodes(node, useScene.getState().nodes, 0),
       length: getWallCurveLength(node),
       thickness: getWallThickness(node),
     }
@@ -296,6 +298,7 @@ function getHeightPillDimensions(node: WallNode | FenceNode): {
 }
 
 export function FloatingActionMenu() {
+  const i18n = usePascalI18n()
   const reducedMotion = useReducedMotion()
   const selectedIds = useViewer((s) => s.selection.selectedIds)
   const updateNode = useScene((s) => s.updateNode)
@@ -421,7 +424,7 @@ export function FloatingActionMenu() {
         | undefined
       const fallbackHeight =
         node.type === 'wall'
-          ? getWallEffectiveHeightForNodes(node, useScene.getState().nodes)
+          ? getWallEffectiveHeightForNodes(node, useScene.getState().nodes, 0)
           : FENCE_DEFAULT_HEIGHT
       const liveHeight = override?.height ?? node.height ?? fallbackHeight
       pillHeightRef.current.textContent = `H ${formatMeasurement(liveHeight, unit, metricNotation)}`
@@ -679,6 +682,7 @@ export function FloatingActionMenu() {
                 onDelete={handleDelete}
                 onDuplicate={
                   node &&
+                  isNodeDuplicable(node as AnyNode) &&
                   node.type !== 'spawn' &&
                   !DELETE_ONLY_TYPES.includes(node.type) &&
                   !HOLE_TYPES.includes(node.type)
@@ -749,16 +753,21 @@ export function FloatingActionMenu() {
                 {hasAxisCycling(node.type) ? (
                   <div className="flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur">
                     <span className="font-medium text-foreground">
-                      Axis {rotationAxis.toUpperCase()}
+                      {i18n._({ id: 'editor.floatingActionMenu.axis', message: 'Axis' })}{' '}
+                      {rotationAxis.toUpperCase()}
                     </span>
                     <span aria-hidden className="text-muted-foreground">
                       ·
                     </span>
-                    <span className="text-muted-foreground">R/T rotate</span>
+                    <span className="text-muted-foreground">
+                      {i18n._({ id: 'editor.floatingActionMenu.rTRotate', message: 'R/T rotate' })}
+                    </span>
                     <span aria-hidden className="text-muted-foreground">
                       ·
                     </span>
-                    <span className="text-muted-foreground">⌥ axis</span>
+                    <span className="text-muted-foreground">
+                      {i18n._({ id: 'editor.floatingActionMenu.axis2', message: '⌥ axis' })}
+                    </span>
                   </div>
                 ) : null}
               </div>
@@ -788,6 +797,7 @@ function SystemSummaryPill({
   nodeId: AnyNodeId
   unit: 'metric' | 'imperial'
 }) {
+  const i18n = usePascalI18n()
   const allNodes = useScene((s) => s.nodes)
   const summary = useMemo(() => summarizeSystemFor(nodeId, allNodes), [nodeId, allNodes])
   if (!summary) return null
@@ -796,7 +806,7 @@ function SystemSummaryPill({
       <span className="font-medium text-foreground">
         {summary.systems.length > 0
           ? summary.systems.map((sys) => sys[0]!.toUpperCase() + sys.slice(1)).join(' + ')
-          : 'System'}
+          : i18n._({ id: 'editor.floatingActionMenu.system', message: 'System' })}
       </span>
       {summary.runCount > 0 ? (
         <>
@@ -804,8 +814,12 @@ function SystemSummaryPill({
             ·
           </span>
           <span className="text-muted-foreground">
-            {formatMeasurement(summary.runLengthM, unit, metricNotation)} · {summary.runCount}{' '}
-            {summary.runCount === 1 ? 'run' : 'runs'}
+            {formatMeasurement(summary.runLengthM, unit, metricNotation)} ·{' '}
+            {i18n._({
+              id: 'editor.floatingActionMenu.runCount',
+              message: '{count, plural, one {{number} run} other {{number} runs}}',
+              values: { count: summary.runCount, number: String(summary.runCount) },
+            })}
           </span>
         </>
       ) : null}
@@ -815,7 +829,11 @@ function SystemSummaryPill({
             ·
           </span>
           <span className="text-muted-foreground">
-            {summary.terminalCount} {summary.terminalCount === 1 ? 'register' : 'registers'}
+            {i18n._({
+              id: 'editor.floatingActionMenu.registerCount',
+              message: '{count, plural, one {# register} other {# registers}}',
+              values: { count: summary.terminalCount },
+            })}
           </span>
         </>
       ) : null}
@@ -824,7 +842,9 @@ function SystemSummaryPill({
           <span aria-hidden className="text-muted-foreground">
             ·
           </span>
-          <span className="font-medium text-amber-500">⚠ no equipment</span>
+          <span className="font-medium text-amber-500">
+            {i18n._({ id: 'editor.floatingActionMenu.noEquipment', message: '⚠ no equipment' })}
+          </span>
         </>
       )}
     </div>

package/src/components/editor/floating-building-action-menu.tsx

@@ -2,12 +2,12 @@
 
 import { type BuildingNode, sceneRegistry, useScene } from '@pascal-app/core'
 import { useViewer } from '@pascal-app/viewer'
-import { Html } from '@react-three/drei'
 import { useFrame } from '@react-three/fiber'
 import { useCallback, useRef } from 'react'
 import * as THREE from 'three'
 import { sfxEmitter } from '../../lib/sfx-bus'
 import useEditor from '../../store/use-editor'
+import { Html } from './localized-html'
 import { NodeActionMenu } from './node-action-menu'
 
 export function FloatingBuildingActionMenu() {

package/src/components/editor/floor-openings-overlay.tsx

@@ -5,6 +5,7 @@ import {
   type AnyNodeId,
   type FloorOpeningNode,
   resolveCeilingHeight,
+  roomFloorElevation,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
@@ -24,7 +25,6 @@ import { useCeilingEditSession } from '../../lib/ceiling-edit-session'
 import { EDITOR_LAYER } from '../../lib/constants'
 import { openingRoom, roomSurfaceOpenings, useFloorEditSession } from '../../lib/floor-edit-session'
 import { useOpeningDraft } from '../../lib/floor-opening-draft'
-import { roomFloorElevation } from '../../lib/room-handle-drag'
 import { PolygonEditor } from '../tools/shared/polygon-editor'
 
 // The openings of the room being edited ("Edit floor", "Edit ceiling", or a

package/src/components/editor/floor-region-controls.tsx

@@ -3,8 +3,10 @@
 import {
   containsPoint,
   emitter,
+  formatAreaLabel,
   type MultiPolygon,
   resolveCeilingHeight,
+  roomFloorElevation,
   sceneRegistry,
   useScene,
 } from '@pascal-app/core'
@@ -60,14 +62,12 @@ import {
 } from '../../lib/floor-region-session'
 import { type FloorRegionPoint, snapFloorRegionPoint } from '../../lib/floor-region-snap'
 import { clientToPlan } from '../../lib/floorplan/plan-coords'
-import { formatAreaLabel } from '../../lib/measurements'
 import {
   cancelMezzanineDraft,
   mezzanineDraftActive,
   useMezzanineDraft,
 } from '../../lib/mezzanine-draft'
 import { usePaintRegionMode } from '../../lib/paint-region-mode'
-import { roomFloorElevation } from '../../lib/room-handle-drag'
 import {
   cancelTerraceDraft,
   terraceDraftActive,

package/src/components/editor/floorplan-panel.test.ts

@@ -0,0 +1,220 @@
+import { expect, test } from 'bun:test'
+import { GuideScaleReference } from '@pascal-app/core'
+import { z } from 'zod'
+import { createGuideScaleReference, formatReferenceScaleLabel } from '../../lib/reference-scale'
+import {
+  formatFloorplanNumber,
+  getReferenceScaleInputError,
+  parseReferenceScaleLength,
+} from './floorplan-panel'
+
+const Core106GuideScaleReference = z.object({
+  start: z.tuple([z.number(), z.number()]),
+  end: z.tuple([z.number(), z.number()]),
+  realLengthMeters: z.number().positive(),
+  measuredLengthUnits: z.number().positive(),
+  metersPerUnit: z.number().positive(),
+  label: z.string(),
+})
+
+function runtimeScaleReference(overrides: Record<string, unknown> = {}): GuideScaleReference {
+  return {
+    start: [0, 0],
+    end: [1, 0],
+    realLengthMeters: 2.75,
+    measuredLengthUnits: 1,
+    metersPerUnit: 2.75,
+    label: '2.75 m',
+    ...overrides,
+  } as unknown as GuideScaleReference
+}
+
+test('floor-plan reference scales parse with the scoped locale', () => {
+  expect(parseReferenceScaleLength('1,000', 'meters', 'fr')).toBe(1)
+  expect(parseReferenceScaleLength('1,000', 'meters', 'en')).toBe(1000)
+})
+
+test('floor-plan reference scales display with the scoped locale', () => {
+  expect(formatFloorplanNumber(2.75, 'fr')).toBe('2,75')
+  expect(formatFloorplanNumber(2.75, 'en')).toBe('2.75')
+})
+
+test('reference-scale scenes remain compatible and format numeric and legacy labels', () => {
+  const reference = createGuideScaleReference(
+    {
+      start: [0, 0],
+      end: [1, 0],
+      realLengthMeters: 2.75,
+      measuredLengthUnits: 1,
+      metersPerUnit: 2.75,
+    },
+    2.75,
+    'meters',
+  )
+
+  expect(reference).toEqual({
+    start: [0, 0],
+    end: [1, 0],
+    realLengthMeters: 2.75,
+    measuredLengthUnits: 1,
+    metersPerUnit: 2.75,
+    displayLength: 2.75,
+    displayUnit: 'meters',
+    label: '2.75 m',
+  })
+  expect(Core106GuideScaleReference.safeParse(reference).success).toBe(true)
+  expect(formatReferenceScaleLabel(reference, 'fr')).toBe('2,75 m')
+  expect(formatReferenceScaleLabel(reference, 'en')).toBe('2.75 m')
+  const legacyFrenchReference = GuideScaleReference.parse({
+    start: [0, 0],
+    end: [1, 0],
+    realLengthMeters: 2.75,
+    measuredLengthUnits: 1,
+    metersPerUnit: 2.75,
+    label: '2,75 m',
+  })
+  expect(formatReferenceScaleLabel(legacyFrenchReference, 'en')).toBe('2.75 m')
+  expect(
+    formatReferenceScaleLabel(
+      GuideScaleReference.parse({
+        ...legacyFrenchReference,
+        label: '2.75 m',
+      }),
+      'fr',
+    ),
+  ).toBe('2,75 m')
+  expect(
+    formatReferenceScaleLabel(
+      GuideScaleReference.parse({
+        ...legacyFrenchReference,
+        label: 'Known span',
+      }),
+      'fr',
+    ),
+  ).toBe('Known span')
+})
+
+test('oversized legacy reference labels bypass parsing within the input budget', () => {
+  const label = `${'1, '.repeat(34_000)}?`
+  const reference = runtimeScaleReference({ label })
+  const startedAt = performance.now()
+  const formatted = formatReferenceScaleLabel(reference, 'en')
+  const elapsed = performance.now() - startedAt
+
+  expect(formatted).toBe(label)
+  expect(elapsed).toBeLessThan(50)
+})
+
+test('reference-scale labels tolerate malformed persisted values', () => {
+  expect(formatReferenceScaleLabel(runtimeScaleReference({ label: 42 }), 'en')).toBe('42')
+  expect(formatReferenceScaleLabel(runtimeScaleReference({ label: null }), 'en')).toBe('')
+  expect(
+    formatReferenceScaleLabel(runtimeScaleReference({ label: { toString: null } }), 'en'),
+  ).toBe('')
+  expect(
+    formatReferenceScaleLabel(runtimeScaleReference({ label: Object.create(null) }), 'en'),
+  ).toBe('')
+  expect(formatReferenceScaleLabel(runtimeScaleReference({ label: Symbol('x') }), 'en')).toBe('')
+  expect(formatReferenceScaleLabel(runtimeScaleReference({ label: ['1 m'] }), 'en')).toBe('')
+  expect(
+    formatReferenceScaleLabel(
+      runtimeScaleReference({
+        displayLength: 2.75,
+        displayUnit: '__proto__',
+        label: 'fallback',
+      }),
+      'en',
+    ),
+  ).toBe('fallback')
+  expect(
+    formatReferenceScaleLabel(
+      runtimeScaleReference({
+        displayLength: 2.75,
+        displayUnit: 'constructor',
+        label: 'fallback',
+      }),
+      'en',
+    ),
+  ).toBe('fallback')
+  expect(
+    formatReferenceScaleLabel(
+      runtimeScaleReference({
+        displayLength: Number.POSITIVE_INFINITY,
+        displayUnit: 'meters',
+        label: 'fallback',
+      }),
+      'en',
+    ),
+  ).toBe('fallback')
+  expect(
+    formatReferenceScaleLabel(
+      runtimeScaleReference({
+        displayLength: Number.NaN,
+        displayUnit: 'meters',
+        label: 'fallback',
+      }),
+      'en',
+    ),
+  ).toBe('fallback')
+})
+
+test('reference-scale schema caps persisted display lengths', () => {
+  expect(
+    GuideScaleReference.safeParse(
+      runtimeScaleReference({
+        displayLength: 1_000_000,
+        displayUnit: 'meters',
+      }),
+    ).success,
+  ).toBe(true)
+  expect(
+    GuideScaleReference.safeParse(
+      runtimeScaleReference({
+        displayLength: 1_000_001,
+        displayUnit: 'meters',
+      }),
+    ).success,
+  ).toBe(false)
+})
+
+test('reference-scale calibration rejects lengths the schema would not accept', () => {
+  expect(getReferenceScaleInputError('1000000', 'meters', 'en')).toBeNull()
+  expect(getReferenceScaleInputError('2.75', 'feet', 'en')).toBeNull()
+  expect(getReferenceScaleInputError('1000001', 'meters', 'en')).toBe(
+    'Length must be at most 1000000 m.',
+  )
+  expect(getReferenceScaleInputError('1e9', 'centimeters', 'en')).toBe(
+    'Length must be at most 1000000 cm.',
+  )
+  expect(getReferenceScaleInputError('0', 'meters', 'en')).toBe('Length must be greater than 0.')
+  expect(getReferenceScaleInputError('', 'meters', 'en')).toBe('Enter the real length of the line.')
+})
+
+test('reference-scale creation drops display fields outside the schema range', () => {
+  const base = {
+    start: [0, 0] as [number, number],
+    end: [1, 0] as [number, number],
+    realLengthMeters: 2_000_000,
+    measuredLengthUnits: 1,
+    metersPerUnit: 2_000_000,
+  }
+  const oversized = createGuideScaleReference(base, 2_000_000, 'meters')
+  expect(oversized.displayLength).toBeUndefined()
+  expect(oversized.displayUnit).toBeUndefined()
+  expect(oversized.label).toBe('2000000 m')
+  expect(GuideScaleReference.safeParse(oversized).success).toBe(true)
+
+  const atCap = createGuideScaleReference(base, 1_000_000, 'meters')
+  expect(atCap.displayLength).toBe(1_000_000)
+  expect(GuideScaleReference.safeParse(atCap).success).toBe(true)
+})
+
+test('legacy reference-scale labels accept whitespace runs between digit groups', () => {
+  const label = (value: string) =>
+    formatReferenceScaleLabel(runtimeScaleReference({ label: value }), 'en')
+  expect(label('1  234,5 m')).toBe('1234.5 m')
+  expect(label('1 \u00a0234 cm')).toBe('1234 cm')
+  expect(label('12\u202f345\t\t678 ft')).toBe('12345678 ft')
+  expect(label('1 234 m')).toBe('1234 m')
+  expect(label('1  234  ')).toBe('1  234  ')
+})