@pascal-app/editor 1.0.6 → 1.1.0

package/src/store/use-floorplan-annotation-visibility.ts

@@ -9,49 +9,74 @@ import {
   normalizeFloorplanAnnotationVisibility,
 } from '../lib/floorplan/annotation-visibility'
 import {
-  DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
-  type FloorplanWallDimensionReference,
-  normalizeFloorplanWallDimensionReference,
+  DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES,
+  type FloorplanWallDimensionFaces,
+  normalizeFloorplanWallDimensionFaces,
 } from '../lib/floorplan/floorplan-extension'
 
-type FloorplanAnnotationVisibilityState = {
+type PersistedFloorplanAnnotationState = {
   visibility: FloorplanAnnotationVisibility
-  wallDimensionReference: FloorplanWallDimensionReference
+  showDimensions: boolean
+  wallDimensionFaces: FloorplanWallDimensionFaces
+}
+
+type FloorplanAnnotationVisibilityState = PersistedFloorplanAnnotationState & {
   setCategory: (category: FloorplanAnnotationCategory, visible: boolean) => void
-  setWallDimensionReference: (reference: FloorplanWallDimensionReference) => void
+  setShowDimensions: (shown: boolean) => void
+  setWallDimensionFaces: (faces: FloorplanWallDimensionFaces) => void
   reset: () => void
 }
 
+const defaultState = (): PersistedFloorplanAnnotationState => ({
+  visibility: { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY },
+  showDimensions: true,
+  wallDimensionFaces: DEFAULT_FLOORPLAN_WALL_DIMENSION_FACES,
+})
+
+/**
+ * The persisted part of the store, read back from storage. Anything stale or
+ * unknown (an older shape, a retired `wallDimensionReference`) falls back to
+ * the default.
+ */
+function normalizeFloorplanAnnotationState(persisted: unknown): PersistedFloorplanAnnotationState {
+  const record = (persisted && typeof persisted === 'object' ? persisted : {}) as Record<
+    string,
+    unknown
+  >
+  return {
+    visibility: normalizeFloorplanAnnotationVisibility(record.visibility),
+    showDimensions: record.showDimensions !== false,
+    wallDimensionFaces: normalizeFloorplanWallDimensionFaces(record.wallDimensionFaces),
+  }
+}
+
+/**
+ * Display preferences for dimensions and annotations, kept per browser:
+ * Display → Dimensions (`showDimensions`) and Measure walls
+ * (`wallDimensionFaces`) apply to the plan and the 3D view; `visibility` is
+ * the Expert plan's annotation categories.
+ */
 const useFloorplanAnnotationVisibility = create<FloorplanAnnotationVisibilityState>()(
   persist(
     (set) => ({
-      visibility: { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY },
-      wallDimensionReference: DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
+      ...defaultState(),
       setCategory: (category, visible) =>
         set((state) => ({ visibility: { ...state.visibility, [category]: visible } })),
-      setWallDimensionReference: (wallDimensionReference) => set({ wallDimensionReference }),
-      reset: () =>
-        set({
-          visibility: { ...DEFAULT_FLOORPLAN_ANNOTATION_VISIBILITY },
-          wallDimensionReference: DEFAULT_FLOORPLAN_WALL_DIMENSION_REFERENCE,
-        }),
+      setShowDimensions: (showDimensions) => set({ showDimensions }),
+      setWallDimensionFaces: (wallDimensionFaces) => set({ wallDimensionFaces }),
+      reset: () => set(defaultState()),
     }),
     {
       name: 'pascal-floorplan-annotation-visibility',
       merge: (persistedState, currentState) => ({
         ...currentState,
-        visibility: normalizeFloorplanAnnotationVisibility(
-          (persistedState as { visibility?: unknown } | undefined)?.visibility,
-        ),
-        wallDimensionReference: normalizeFloorplanWallDimensionReference(
-          (persistedState as { wallDimensionReference?: unknown } | undefined)
-            ?.wallDimensionReference,
-        ),
+        ...normalizeFloorplanAnnotationState(persistedState),
       }),
       partialize: (state) =>
         ({
           visibility: state.visibility,
-          wallDimensionReference: state.wallDimensionReference,
+          showDimensions: state.showDimensions,
+          wallDimensionFaces: state.wallDimensionFaces,
         }) as FloorplanAnnotationVisibilityState,
     },
   ),

package/src/store/use-placement-typing.test.ts

@@ -0,0 +1,165 @@
+import { beforeEach, describe, expect, test } from 'bun:test'
+import {
+  isPlacementTypingKey,
+  PLACEMENT_TYPING_DISTANCE_OFFSET,
+  PLACEMENT_TYPING_LENGTH_ANGLE,
+  routePlacementTypingKey,
+  usePlacementTyping,
+} from './use-placement-typing'
+
+const key = (
+  k: string,
+  mods: Partial<Pick<KeyboardEvent, 'metaKey' | 'ctrlKey' | 'altKey'>> = {},
+) => ({
+  key: k,
+  metaKey: false,
+  ctrlKey: false,
+  altKey: false,
+  ...mods,
+})
+
+const beginTwoFields = (activeField: 0 | 1) => {
+  usePlacementTyping.getState().begin({ labels: PLACEMENT_TYPING_DISTANCE_OFFSET, activeField })
+  return true
+}
+
+describe('usePlacementTyping', () => {
+  beforeEach(() => {
+    usePlacementTyping.getState().clear()
+  })
+
+  test('keeps two independent field buffers and toggles the active field', () => {
+    const typing = usePlacementTyping.getState()
+    typing.begin({ labels: PLACEMENT_TYPING_DISTANCE_OFFSET, fieldDefaults: ['1.2', '0'] })
+    typing.append('2')
+    typing.toggleField()
+    typing.append('-')
+    typing.append('4')
+
+    expect(usePlacementTyping.getState().fields).toEqual(['2', '-4'])
+    expect(usePlacementTyping.getState().fieldDefaults).toEqual(['1.2', '0'])
+    expect(usePlacementTyping.getState().activeField).toBe(1)
+  })
+
+  test('backspace only changes the active field', () => {
+    const typing = usePlacementTyping.getState()
+    typing.begin({ labels: PLACEMENT_TYPING_DISTANCE_OFFSET })
+    typing.append('25')
+    typing.toggleField()
+    typing.append('3')
+    typing.backspace()
+
+    expect(usePlacementTyping.getState().fields).toEqual(['25', ''])
+  })
+
+  test('publishes projection and an enter request without clearing input', () => {
+    const typing = usePlacementTyping.getState()
+    typing.begin({ labels: PLACEMENT_TYPING_DISTANCE_OFFSET })
+    typing.append('2')
+    typing.setProjectedPosition([2, 0, 1])
+    typing.requestCommit()
+
+    expect(usePlacementTyping.getState().projectedPosition).toEqual([2, 0, 1])
+    expect(usePlacementTyping.getState().submitRevision).toBe(1)
+    expect(usePlacementTyping.getState().isActive).toBe(true)
+  })
+
+  test('clear ends the session and forgets its labels', () => {
+    usePlacementTyping.getState().begin({ labels: PLACEMENT_TYPING_LENGTH_ANGLE })
+    usePlacementTyping.getState().append('3')
+    usePlacementTyping.getState().clear()
+    const state = usePlacementTyping.getState()
+    expect(state.isActive).toBe(false)
+    expect(state.fields).toEqual(['', ''])
+    expect(state.labels).toEqual([])
+  })
+})
+
+describe('routePlacementTypingKey', () => {
+  beforeEach(() => {
+    usePlacementTyping.getState().clear()
+  })
+
+  test('a digit or a leading dot opens a session on the first field', () => {
+    expect(routePlacementTypingKey(key('5'), { begin: beginTwoFields })).toBe('edit')
+    expect(usePlacementTyping.getState().fields).toEqual(['5', ''])
+    usePlacementTyping.getState().clear()
+    expect(routePlacementTypingKey(key('.'), { begin: beginTwoFields })).toBe('edit')
+    expect(usePlacementTyping.getState().fields).toEqual(['.', ''])
+  })
+
+  test('letters, signs and separators leave tool shortcuts alone until a session opens', () => {
+    for (const k of ['c', 'm', 't', 'f', '-', ' ', ',']) {
+      expect(routePlacementTypingKey(key(k), { begin: beginTwoFields })).toBeNull()
+    }
+    expect(usePlacementTyping.getState().isActive).toBe(false)
+  })
+
+  test('no session opens when the tool refuses or offers no begin', () => {
+    expect(routePlacementTypingKey(key('5'), { begin: () => false })).toBeNull()
+    expect(routePlacementTypingKey(key('5'))).toBeNull()
+    expect(usePlacementTyping.getState().isActive).toBe(false)
+  })
+
+  test('Tab opens a session on the second field only when the tool asks for it', () => {
+    expect(routePlacementTypingKey(key('Tab'), { begin: beginTwoFields })).toBeNull()
+    expect(routePlacementTypingKey(key('Tab'), { begin: beginTwoFields, tabBegins: true })).toBe(
+      'edit',
+    )
+    expect(usePlacementTyping.getState().activeField).toBe(1)
+  })
+
+  test('inside a session: unit letters extend, Tab and comma switch, Enter commits', () => {
+    routePlacementTypingKey(key('1'), { begin: beginTwoFields })
+    for (const k of ['8', '0', 'c', 'm']) routePlacementTypingKey(key(k))
+    expect(routePlacementTypingKey(key('Tab'))).toBe('edit')
+    routePlacementTypingKey(key('-'))
+    routePlacementTypingKey(key('2'))
+    expect(routePlacementTypingKey(key(','))).toBe('edit')
+    expect(usePlacementTyping.getState().fields).toEqual(['180cm', '-2'])
+    expect(usePlacementTyping.getState().activeField).toBe(0)
+    expect(routePlacementTypingKey(key('Enter'))).toBe('commit')
+    expect(usePlacementTyping.getState().isActive).toBe(true)
+  })
+
+  test('Backspace edits, Delete empties the active field', () => {
+    routePlacementTypingKey(key('4'), { begin: beginTwoFields })
+    routePlacementTypingKey(key('2'))
+    routePlacementTypingKey(key('Backspace'))
+    expect(usePlacementTyping.getState().fields[0]).toBe('4')
+    routePlacementTypingKey(key('Delete'))
+    expect(usePlacementTyping.getState().fields[0]).toBe('')
+    expect(usePlacementTyping.getState().isActive).toBe(true)
+  })
+
+  test('the first Escape only ends the session', () => {
+    routePlacementTypingKey(key('3'), { begin: beginTwoFields })
+    expect(routePlacementTypingKey(key('Escape'))).toBe('clear')
+    expect(usePlacementTyping.getState().isActive).toBe(false)
+    expect(routePlacementTypingKey(key('Escape'))).toBeNull()
+  })
+
+  test('chords are never consumed', () => {
+    expect(
+      routePlacementTypingKey(key('5', { metaKey: true }), { begin: beginTwoFields }),
+    ).toBeNull()
+    routePlacementTypingKey(key('5'), { begin: beginTwoFields })
+    expect(routePlacementTypingKey(key('z', { ctrlKey: true }))).toBeNull()
+    expect(routePlacementTypingKey(key('Enter', { altKey: true }))).toBeNull()
+    expect(usePlacementTyping.getState().fields[0]).toBe('5')
+  })
+})
+
+describe('isPlacementTypingKey', () => {
+  test('accepts the measurement grammar', () => {
+    for (const k of ['0', '9', 'm', 'c', '.', "'", '"', '-', '+', ' ', '/']) {
+      expect(isPlacementTypingKey(k)).toBe(true)
+    }
+  })
+
+  test('rejects control keys and the field separator', () => {
+    for (const k of ['Enter', 'Escape', 'Tab', 'Shift', '', 'F1', ',']) {
+      expect(isPlacementTypingKey(k)).toBe(false)
+    }
+  })
+})

package/src/store/use-placement-typing.ts

@@ -0,0 +1,186 @@
+import type { MessageDescriptor } from '@pascal-app/core'
+import { create } from 'zustand'
+
+/**
+ * Typed coordinate entry shared by the placement tools: a drafted wall's
+ * length/angle and a cabinet's distance/offset along its wall. One session at
+ * a time; the active tool owns what the two fields mean and reads them on
+ * every change, the HUD (`PlacementCoordinateInput`) only displays them.
+ */
+export type PlacementTypingField = 0 | 1
+export type PlacementTypingValues = [string, string]
+export type PlacementTypingProjection = [number, number, number]
+
+export const PLACEMENT_TYPING_DISTANCE_OFFSET: readonly MessageDescriptor[] = [
+  /* i18n */ { id: 'editor.placementTyping.distance', message: 'Distance' },
+  /* i18n */ { id: 'editor.placementTyping.offset', message: 'Offset' },
+]
+
+export const PLACEMENT_TYPING_LENGTH_ANGLE: readonly MessageDescriptor[] = [
+  /* i18n */ { id: 'editor.placementTyping.length', message: 'Length' },
+  /* i18n */ { id: 'editor.placementTyping.angle', message: 'Angle' },
+]
+
+export type PlacementTypingSession = {
+  /** What each field means, in field order; the HUD shows one box per label. */
+  labels: readonly MessageDescriptor[]
+  fieldDefaults?: PlacementTypingValues
+  activeField?: PlacementTypingField
+}
+
+export type PlacementTypingState = {
+  isActive: boolean
+  labels: readonly MessageDescriptor[]
+  fields: PlacementTypingValues
+  /** What an empty field stands for, shown as its placeholder. */
+  fieldDefaults: PlacementTypingValues
+  activeField: PlacementTypingField
+  projectedPosition: PlacementTypingProjection | null
+  submitRevision: number
+  begin: (session: PlacementTypingSession) => void
+  append: (value: string) => void
+  backspace: () => void
+  setField: (field: PlacementTypingField, value: string) => void
+  setActiveField: (field: PlacementTypingField) => void
+  toggleField: () => void
+  setProjectedPosition: (position: PlacementTypingProjection | null) => void
+  requestCommit: () => void
+  clear: () => void
+}
+
+const EMPTY_VALUES: PlacementTypingValues = ['', '']
+
+export const usePlacementTyping = create<PlacementTypingState>((set) => ({
+  isActive: false,
+  labels: [],
+  fields: [...EMPTY_VALUES],
+  fieldDefaults: [...EMPTY_VALUES],
+  activeField: 0,
+  projectedPosition: null,
+  submitRevision: 0,
+  begin: ({ labels, fieldDefaults = EMPTY_VALUES, activeField = 0 }) =>
+    set({
+      isActive: true,
+      labels,
+      fields: [...EMPTY_VALUES],
+      fieldDefaults: [...fieldDefaults],
+      activeField,
+      projectedPosition: null,
+    }),
+  append: (value) =>
+    set((state) => {
+      const fields: PlacementTypingValues = [...state.fields]
+      fields[state.activeField] += value
+      return { isActive: true, fields }
+    }),
+  backspace: () =>
+    set((state) => {
+      const fields: PlacementTypingValues = [...state.fields]
+      fields[state.activeField] = fields[state.activeField].slice(0, -1)
+      return { fields }
+    }),
+  setField: (field, value) =>
+    set((state) => {
+      const fields: PlacementTypingValues = [...state.fields]
+      fields[field] = value
+      return { isActive: true, fields }
+    }),
+  setActiveField: (activeField) => set({ activeField }),
+  toggleField: () => set((state) => ({ activeField: state.activeField === 0 ? 1 : 0 })),
+  setProjectedPosition: (projectedPosition) => set({ projectedPosition }),
+  requestCommit: () =>
+    set((state: PlacementTypingState) => ({ submitRevision: state.submitRevision + 1 })),
+  clear: () =>
+    set({
+      isActive: false,
+      labels: [],
+      fields: [...EMPTY_VALUES],
+      fieldDefaults: [...EMPTY_VALUES],
+      activeField: 0,
+      projectedPosition: null,
+    }),
+}))
+
+/** Keys that extend a field: digits, unit letters, separators, signs, fractions. */
+export function isPlacementTypingKey(key: string): boolean {
+  return key.length === 1 && /^[0-9a-zA-Z.'"+\-/ ]$/.test(key)
+}
+
+/**
+ * Keys that may open a session. Letters only ever continue a field, so a
+ * tool's single-letter shortcuts keep working until a number is typed.
+ */
+export function isPlacementTypingStartKey(key: string): boolean {
+  return key.length === 1 && /^[0-9.]$/.test(key)
+}
+
+export type PlacementTypingKeyOutcome = 'edit' | 'commit' | 'clear'
+
+export type PlacementTypingKeyOptions = {
+  /**
+   * Opens a session for a start key (or Tab, with `tabBegins`) when none is
+   * active. Returns false when the tool cannot take typed entry right now.
+   */
+  begin?: (activeField: PlacementTypingField) => boolean
+  /** Tab with no session opens one on the second field. */
+  tabBegins?: boolean
+}
+
+/**
+ * The one keyboard convention for typed entry. Tab or comma switches field,
+ * Enter asks the tool to commit, Escape clears the session (the tool's next
+ * Escape cancels its draft), Backspace edits and Delete empties the active
+ * field. Chords with Cmd/Ctrl/Alt are never consumed. Returns null when the
+ * key is not part of typed entry; the caller prevents default and stops
+ * propagation for every other outcome.
+ */
+export function routePlacementTypingKey(
+  event: Pick<KeyboardEvent, 'key' | 'metaKey' | 'ctrlKey' | 'altKey'>,
+  options: PlacementTypingKeyOptions = {},
+): PlacementTypingKeyOutcome | null {
+  if (event.metaKey || event.ctrlKey || event.altKey) return null
+  const typing = usePlacementTyping.getState()
+  const { key } = event
+  if (!typing.isActive) {
+    if (isPlacementTypingStartKey(key)) {
+      if (!options.begin?.(0)) return null
+      usePlacementTyping.getState().append(key)
+      return 'edit'
+    }
+    if (key === 'Tab' && options.tabBegins && options.begin?.(1)) return 'edit'
+    return null
+  }
+  if (key === 'Tab' || key === ',') {
+    typing.toggleField()
+    return 'edit'
+  }
+  if (key === 'Enter') return 'commit'
+  if (key === 'Escape') {
+    typing.clear()
+    return 'clear'
+  }
+  if (key === 'Backspace') {
+    typing.backspace()
+    return 'edit'
+  }
+  if (key === 'Delete') {
+    typing.setField(typing.activeField, '')
+    return 'edit'
+  }
+  if (isPlacementTypingKey(key)) {
+    typing.append(key)
+    return 'edit'
+  }
+  return null
+}
+
+/** Parse options for a typed length: a bare number is read in the display unit. */
+export function placementTypingLengthOptions(
+  unit: 'metric' | 'imperial',
+  metricNotation: 'meters' | 'millimeters',
+) {
+  return {
+    bareUnit: unit === 'imperial' ? 'in' : metricNotation === 'millimeters' ? 'mm' : 'm',
+    system: unit === 'imperial' ? ('imperial' as const) : ('metric' as const),
+  }
+}

package/src/store/use-wall-snap-indicator.ts

@@ -7,8 +7,19 @@
 
 import { create } from 'zustand'
 
-/** Which kind of wall geometry the draft point snapped to. */
-export type WallSnapKind = 'endpoint' | 'midpoint' | 'intersection' | 'wall'
+/**
+ * Which kind of geometry the draft point snapped to. A pulled wall also lands
+ * square on a wall (`perpendicular`), on a projection guide (`alignment`), or
+ * at a grid length (`grid`).
+ */
+export type WallSnapKind =
+  | 'endpoint'
+  | 'midpoint'
+  | 'intersection'
+  | 'wall'
+  | 'perpendicular'
+  | 'alignment'
+  | 'grid'
 
 export type WallSnapPoint = {
   /** Building-local plan coordinates (XZ meters). */
@@ -17,6 +28,8 @@ export type WallSnapPoint = {
   kind: WallSnapKind
   /** Optional wall ids whose geometry produced this snap. */
   wallIds?: string[]
+  /** Words the marker shows beside its glyph ("Endpoint", "On wall"); none when absent. */
+  label?: string
 }
 
 type WallSnapIndicatorState = {

package/src/components/tools/elevator/elevator-defaults.ts

@@ -1,8 +0,0 @@
-export const DEFAULT_ELEVATOR_WIDTH = 1.84
-export const DEFAULT_ELEVATOR_DEPTH = 1.84
-export const DEFAULT_ELEVATOR_CAB_HEIGHT = 2.35
-export const DEFAULT_ELEVATOR_DOOR_WIDTH = 0.95
-export const DEFAULT_ELEVATOR_DOOR_HEIGHT = 2.1
-export const DEFAULT_ELEVATOR_SPEED = 2.2
-export const DEFAULT_ELEVATOR_DOOR_DURATION_MS = 900
-export const DEFAULT_ELEVATOR_DWELL_MS = 1400