@pascal-app/editor 1.0.5 → 1.0.7

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

@@ -24,11 +24,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 +53,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'
@@ -296,6 +297,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)
@@ -749,16 +751,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 +795,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 +804,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 +812,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 +827,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 +840,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/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  ')
+})