@pascal-app/editor 1.0.3 → 1.0.5

package/src/store/use-construction-reveal.test.ts

@@ -0,0 +1,173 @@
+import { afterAll, afterEach, beforeAll, describe, expect, test } from 'bun:test'
+import type { AnyNodeDefinition } from '@pascal-app/core'
+import { BaseNode, loadPlugin, nodeRegistry, nodeType, objectId, useScene } from '@pascal-app/core'
+import { ANIMATION_SPEEDS } from '@pascal-app/viewer'
+import { createJSONStorage } from 'zustand/middleware'
+import useConstructionReveal, {
+  CONSTRUCTION_REVEAL_LEVELS,
+  CONSTRUCTION_REVEAL_STORAGE_KEY,
+  FRAMING_KIND,
+  getConstructionRevealLevel,
+  isFramingAvailable,
+  resolveConstructionLevel,
+} from './use-construction-reveal'
+
+function memoryStorage() {
+  const items = new Map<string, string>()
+  return {
+    items,
+    storage: createJSONStorage(() => ({
+      getItem: (key: string) => items.get(key) ?? null,
+      setItem: (key: string, value: string) => void items.set(key, value),
+      removeItem: (key: string) => void items.delete(key),
+    })),
+  }
+}
+
+afterEach(() => {
+  useConstructionReveal.setState({ level: 'full', chosen: false, speed: 1 })
+})
+
+describe('the construction animation preference', () => {
+  test('starts at full, with no choice of the person’s own, and offers four levels', () => {
+    expect(useConstructionReveal.getState().level).toBe('full')
+    expect(useConstructionReveal.getState().chosen).toBe(false)
+    expect(CONSTRUCTION_REVEAL_LEVELS).toEqual(['off', 'simple', 'full', 'framing'])
+  })
+
+  test('persists the chosen level and the speed under its own key', () => {
+    const { items, storage } = memoryStorage()
+    useConstructionReveal.persist.setOptions({ storage })
+    useConstructionReveal.getState().setLevel('simple')
+    expect(JSON.parse(items.get(CONSTRUCTION_REVEAL_STORAGE_KEY)!).state).toEqual({
+      level: 'simple',
+      chosen: true,
+      speed: 1,
+    })
+    expect(CONSTRUCTION_REVEAL_STORAGE_KEY).not.toBe('pascal-audio-settings')
+  })
+
+  test('restores a saved level, and an unknown one falls back to full', async () => {
+    const { items, storage } = memoryStorage()
+    useConstructionReveal.persist.setOptions({ storage })
+    items.set(CONSTRUCTION_REVEAL_STORAGE_KEY, JSON.stringify({ state: { level: 'off' } }))
+    await useConstructionReveal.persist.rehydrate()
+    expect(useConstructionReveal.getState().level).toBe('off')
+
+    items.set(CONSTRUCTION_REVEAL_STORAGE_KEY, JSON.stringify({ state: { level: 'cinematic' } }))
+    await useConstructionReveal.persist.rehydrate()
+    expect(useConstructionReveal.getState().level).toBe('full')
+  })
+})
+
+describe('the animation speed preference', () => {
+  test('starts at ×1', () => {
+    expect(useConstructionReveal.getState().speed).toBe(1)
+  })
+
+  test.each([...ANIMATION_SPEEDS])('×%d persists and reloads', async (speed) => {
+    const { items, storage } = memoryStorage()
+    useConstructionReveal.persist.setOptions({ storage })
+    useConstructionReveal.getState().setSpeed(speed)
+    const saved = items.get(CONSTRUCTION_REVEAL_STORAGE_KEY)!
+    expect(JSON.parse(saved).state.speed).toBe(speed)
+    // A new page: the store starts from its defaults and reads what was saved.
+    useConstructionReveal.setState({ speed: 1 })
+    items.set(CONSTRUCTION_REVEAL_STORAGE_KEY, saved)
+    await useConstructionReveal.persist.rehydrate()
+    expect(useConstructionReveal.getState().speed).toBe(speed)
+  })
+
+  test('a person saved before the setting is at ×1, and a stray value snaps to a step', async () => {
+    const { items, storage } = memoryStorage()
+    useConstructionReveal.persist.setOptions({ storage })
+    items.set(CONSTRUCTION_REVEAL_STORAGE_KEY, JSON.stringify({ state: { level: 'full' } }))
+    await useConstructionReveal.persist.rehydrate()
+    expect(useConstructionReveal.getState().speed).toBe(1)
+    items.set(CONSTRUCTION_REVEAL_STORAGE_KEY, JSON.stringify({ state: { speed: 1.6 } }))
+    await useConstructionReveal.persist.rehydrate()
+    expect(useConstructionReveal.getState().speed).toBe(1.5)
+    items.set(CONSTRUCTION_REVEAL_STORAGE_KEY, JSON.stringify({ state: { speed: 'fast' } }))
+    await useConstructionReveal.persist.rehydrate()
+    expect(useConstructionReveal.getState().speed).toBe(1)
+  })
+})
+
+describe('the level that plays follows the project', () => {
+  const none = { level: 'full', chosen: false } as const
+
+  test('with no choice of the person’s own: Framing with the framing plugin, Full without', () => {
+    expect(resolveConstructionLevel(none, true)).toBe('framing')
+    expect(resolveConstructionLevel(none, false)).toBe('full')
+  })
+
+  test('a choice is kept while the plugin stays installed', () => {
+    for (const level of CONSTRUCTION_REVEAL_LEVELS)
+      expect(resolveConstructionLevel({ level, chosen: true }, true)).toBe(level)
+  })
+
+  test('without the plugin Framing falls back to Full; every other choice stays', () => {
+    expect(resolveConstructionLevel({ level: 'framing', chosen: true }, false)).toBe('full')
+    expect(resolveConstructionLevel({ level: 'off', chosen: true }, false)).toBe('off')
+    expect(resolveConstructionLevel({ level: 'simple', chosen: true }, false)).toBe('simple')
+    // The saved choice is not erased: the plugin coming back brings Framing back.
+    expect(resolveConstructionLevel({ level: 'framing', chosen: true }, true)).toBe('framing')
+  })
+
+  test('a level saved before the default followed the project is a choice', async () => {
+    const { items, storage } = memoryStorage()
+    useConstructionReveal.persist.setOptions({ storage })
+    items.set(CONSTRUCTION_REVEAL_STORAGE_KEY, JSON.stringify({ state: { level: 'full' } }))
+    await useConstructionReveal.persist.rehydrate()
+    expect(useConstructionReveal.getState().chosen).toBe(true)
+    items.set(CONSTRUCTION_REVEAL_STORAGE_KEY, JSON.stringify({ state: {} }))
+    await useConstructionReveal.persist.rehydrate()
+    expect(useConstructionReveal.getState().chosen).toBe(false)
+  })
+})
+
+describe('the framing plugin of a project', () => {
+  const framing = {
+    kind: FRAMING_KIND,
+    schemaVersion: 1,
+    schema: BaseNode.extend({ id: objectId('framing'), type: nodeType(FRAMING_KIND) }),
+    category: 'structure',
+    defaults: () => ({}),
+    capabilities: {},
+    geometry: () => null,
+  } as unknown as AnyNodeDefinition
+  let restore: () => void = () => {}
+  const wasInstalled = useScene.getState().installedPlugins
+
+  beforeAll(async () => {
+    restore = nodeRegistry._snapshot()
+    nodeRegistry._reset()
+    await loadPlugin({ id: 'fixture:framing', apiVersion: 1, nodes: [framing] })
+  })
+  afterAll(() => {
+    restore()
+    useScene.setState({ installedPlugins: wasInstalled })
+  })
+
+  test('is available where the plugin that carries the kind is installed', () => {
+    expect(isFramingAvailable([])).toBe(false)
+    expect(isFramingAvailable(['fixture:other'])).toBe(false)
+    expect(isFramingAvailable(['fixture:framing'])).toBe(true)
+  })
+
+  test('is not available where no loaded plugin carries the kind at all', () => {
+    const snapshot = nodeRegistry._snapshot()
+    nodeRegistry._reset()
+    expect(isFramingAvailable(['fixture:framing'])).toBe(false)
+    snapshot()
+  })
+
+  test('the level that plays is read from the open project', () => {
+    useScene.setState({ installedPlugins: [] })
+    expect(getConstructionRevealLevel()).toBe('full')
+    useScene.setState({ installedPlugins: ['fixture:framing'] })
+    expect(getConstructionRevealLevel()).toBe('framing')
+    useConstructionReveal.getState().setLevel('full')
+    expect(getConstructionRevealLevel()).toBe('full')
+  })
+})

package/src/store/use-construction-reveal.ts

@@ -0,0 +1,145 @@
+'use client'
+
+import { isNodeKindEnabled, nodeRegistry, useRegistryVersion, useScene } from '@pascal-app/core'
+import {
+  type AnimationSpeed,
+  type ConstructionRevealLevel,
+  DEFAULT_ANIMATION_SPEED,
+  normalizeAnimationSpeed,
+} from '@pascal-app/viewer'
+import { create } from 'zustand'
+import { createJSONStorage, persist } from 'zustand/middleware'
+
+export const CONSTRUCTION_REVEAL_LEVELS: readonly ConstructionRevealLevel[] = [
+  'off',
+  'simple',
+  'full',
+  'framing',
+]
+
+export const CONSTRUCTION_REVEAL_STORAGE_KEY = 'pascal-construction-reveal'
+
+/**
+ * The kind the Framing level draws: it plays only in a project where this kind is registered and
+ * its plugin is installed. Read through the kind, not a plugin id, so it holds wherever the framing
+ * kinds live (the Bones plugin, or the procedural plugin that carries them).
+ */
+export const FRAMING_KIND = 'bones:framing'
+
+const DEFAULT_LEVEL: ConstructionRevealLevel = 'full'
+
+function normalizeLevel(value: unknown): ConstructionRevealLevel {
+  return CONSTRUCTION_REVEAL_LEVELS.includes(value as ConstructionRevealLevel)
+    ? (value as ConstructionRevealLevel)
+    : DEFAULT_LEVEL
+}
+
+/** Reads `localStorage` on each call, so a page without it (a test, a sandbox) still has the store's persist API. */
+const browserStorage = createJSONStorage(() => ({
+  getItem: (key: string) => globalThis.localStorage?.getItem(key) ?? null,
+  setItem: (key: string, value: string) => globalThis.localStorage?.setItem(key, value),
+  removeItem: (key: string) => globalThis.localStorage?.removeItem(key),
+}))
+
+type ConstructionRevealState = {
+  /**
+   * The level the person last chose (see `chosen`). Hosts read the level that plays through
+   * `useConstructionRevealLevel`, which also knows whether the framing plugin is installed.
+   */
+  level: ConstructionRevealLevel
+  /** Whether the person has chosen a level themselves; until then the default follows the project. */
+  chosen: boolean
+  setLevel: (level: ConstructionRevealLevel) => void
+  /**
+   * How fast builds play, a multiple of the shipped pace (×0.5 to ×2, higher is faster); the host
+   * passes it to `ConstructionReveal`. A change applies to the next build, never to one playing.
+   */
+  speed: AnimationSpeed
+  setSpeed: (speed: AnimationSpeed) => void
+}
+
+/** The person's construction-animation preferences (level and speed), kept across sessions. */
+const useConstructionReveal = create<ConstructionRevealState>()(
+  persist(
+    (set) => ({
+      level: DEFAULT_LEVEL,
+      chosen: false,
+      setLevel: (level) => set({ level, chosen: true }),
+      speed: DEFAULT_ANIMATION_SPEED,
+      setSpeed: (speed) => set({ speed: normalizeAnimationSpeed(speed) }),
+    }),
+    {
+      name: CONSTRUCTION_REVEAL_STORAGE_KEY,
+      storage: browserStorage,
+      partialize: (state) => ({ level: state.level, chosen: state.chosen, speed: state.speed }),
+      merge: (persisted, current) => {
+        const saved = persisted as
+          | { level?: unknown; chosen?: unknown; speed?: unknown }
+          | undefined
+        return {
+          ...current,
+          level: normalizeLevel(saved?.level),
+          // A level saved before the default followed the project was the person's own choice.
+          chosen: typeof saved?.chosen === 'boolean' ? saved.chosen : saved?.level !== undefined,
+          // A person saved before the setting existed is at ×1; a stray value snaps to a step.
+          speed: normalizeAnimationSpeed(saved?.speed),
+        }
+      },
+    },
+  ),
+)
+
+/**
+ * The level that plays. With no choice of the person's own it is Framing where the framing plugin
+ * is available in the project and Full where it is not; a choice is kept, except that Framing falls
+ * back to Full while the plugin is missing (the choice comes back with the plugin).
+ */
+export function resolveConstructionLevel(
+  saved: Pick<ConstructionRevealState, 'level' | 'chosen'>,
+  framingInstalled: boolean,
+): ConstructionRevealLevel {
+  if (!saved.chosen) return framingInstalled ? 'framing' : 'full'
+  return saved.level === 'framing' && !framingInstalled ? 'full' : saved.level
+}
+
+/**
+ * A click on a level in the control. The level that plays is not always the saved one (a saved Framing
+ * plays as Full while the plugin is gone), and a click on that pressed level is not a choice: it keeps
+ * the saved one, so it plays again with the plugin.
+ */
+export function chooseConstructionLevel(
+  level: ConstructionRevealLevel,
+  framingInstalled: boolean,
+): void {
+  const state = useConstructionReveal.getState()
+  if (state.chosen && resolveConstructionLevel(state, framingInstalled) === level) return
+  state.setLevel(level)
+}
+
+/** Whether the project has what draws the framing: the kind is registered and its plugin installed. */
+export function isFramingAvailable(installedPlugins: readonly string[]): boolean {
+  return nodeRegistry.has(FRAMING_KIND) && isNodeKindEnabled(FRAMING_KIND, installedPlugins)
+}
+
+/** The same, for a component: it re-reads when a plugin registers after the first render. */
+export function useFramingAvailable(): boolean {
+  useRegistryVersion()
+  return useScene((state) => isFramingAvailable(state.installedPlugins))
+}
+
+/** The level that plays now, for a component: the person's choice or the project's default. */
+export function useConstructionRevealLevel(): ConstructionRevealLevel {
+  const level = useConstructionReveal((state) => state.level)
+  const chosen = useConstructionReveal((state) => state.chosen)
+  return resolveConstructionLevel({ level, chosen }, useFramingAvailable())
+}
+
+/** The level that plays now, read once (a tool's executor, not a component). */
+export function getConstructionRevealLevel(): ConstructionRevealLevel {
+  return resolveConstructionLevel(
+    useConstructionReveal.getState(),
+    isFramingAvailable(useScene.getState().installedPlugins),
+  )
+}
+
+export default useConstructionReveal

package/src/store/use-corner-snap-hint.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, test } from 'bun:test'
+import { CORNER_BLOCK_NOTES, cornerHintRows } from './use-corner-snap-hint'
+
+// The HUD near a wall end: what a click does where a window can join, and why not where it cannot,
+// in one wording for the placement HUD and the move HUD.
+describe('cornerHintRows', () => {
+  test('says nothing away from a wall end', () => {
+    expect(cornerHintRows(null)).toEqual([])
+  })
+
+  test('says what a click does where the window can join, and how to skip it with Alt', () => {
+    for (const hint of ['join', 'new'] as const)
+      expect(cornerHintRows(hint).map((row) => row.keys)).toEqual([['Left click'], ['Alt']])
+    expect(cornerHintRows('join')[0]?.label).not.toBe(cornerHintRows('new')[0]?.label)
+  })
+
+  test('gives each reason its own sentence where the end is no corner, and offers no click', () => {
+    const reasons = Object.keys(CORNER_BLOCK_NOTES) as (keyof typeof CORNER_BLOCK_NOTES)[]
+    const rows = reasons.map((reason) => cornerHintRows(reason))
+
+    expect(new Set(rows.map((row) => row[0]?.label)).size).toBe(reasons.length)
+    expect(rows.flat().every((row) => !row.keys.includes('Left click'))).toBe(true)
+  })
+})

package/src/store/use-corner-snap-hint.ts

@@ -0,0 +1,47 @@
+import type { CornerBlockReason } from '@pascal-app/core'
+import { create } from 'zustand'
+
+/**
+ * What the window being placed or dragged near a wall end says: `join` when a window already waits
+ * on the other wall, `new` when one would be created, the reason when the end is not a corner a
+ * window can wrap, null away from a wall end. The tools write it; the HUD reads it, so the hint is
+ * there only inside the zone.
+ */
+export type CornerSnapHint = 'join' | 'new' | CornerBlockReason | null
+
+export const useCornerSnapHint = create<{
+  hint: CornerSnapHint
+  setHint: (hint: CornerSnapHint) => void
+}>((set) => ({
+  hint: null,
+  setHint: (hint) => set((state) => (state.hint === hint ? state : { hint })),
+}))
+
+/** One line each, in the HUD's voice: what is in the way, not what to do about it. */
+export const CORNER_BLOCK_NOTES: Record<CornerBlockReason, string> = {
+  free_end: 'No wall meets here',
+  several_walls: 'Three or more walls meet here',
+  angle: 'The walls meet at too sharp or too flat an angle',
+  curved: 'A curved wall takes no corner window',
+  curtain: 'A curtain wall takes no corner window',
+  no_room: 'No room for the matching window on the other wall',
+  in_the_way: 'Another opening is in the way at the corner',
+  too_tall: 'The window waiting there is taller than this wall',
+}
+
+export type CornerHintRow = { keys: string[]; label: string }
+
+/** The HUD rows for a hint, shared by the placement tool and the move HUD. */
+export function cornerHintRows(hint: CornerSnapHint): CornerHintRow[] {
+  if (!hint) return []
+  if (hint === 'join' || hint === 'new')
+    return [
+      {
+        keys: ['Left click'],
+        label: hint === 'join' ? 'Join as a corner window' : 'Corner window',
+      },
+      { keys: ['Alt'], label: 'Place without the corner snap' },
+    ]
+  // The HUD's notice row, as for a placement that does not fit: a note, not a key to press.
+  return [{ keys: ['!'], label: CORNER_BLOCK_NOTES[hint] }]
+}

package/src/store/use-delete-confirmation.ts

@@ -1,6 +1,33 @@
+import type { DeleteZonePayload } from '@pascal-app/core'
 import { create } from 'zustand'
 
-type DeleteConfirmationRequest = {
+/** Changing one of a room's construction parts, with what it takes along. */
+export type RoomConstructionChange = {
+  part: 'floor' | 'walls' | 'ceiling'
+  /** Walls can be confirmed on the way in too; everything else asks on removal. */
+  action?: 'add' | 'remove'
+  roomName: string
+  /**
+   * Walls: hosted openings and objects removed with them. Ceiling: items
+   * hanging from it. Floor: items standing on it.
+   */
+  hostedIds: string[]
+  /** Walls turned into separators, or built on them. */
+  wallCount?: number
+  sharedWalls?: boolean
+  /** Walls added: clear floor area the room gives up to them, m². */
+  areaLoss?: number
+  /** Ceiling: names of the hand-drawn ceilings removed ('' when unnamed). */
+  manualCeilings?: string[]
+  /** Ceiling: other rooms those hand-drawn ceilings also cover. */
+  alsoCovers?: string[]
+}
+
+export type DeleteConfirmationRequest = {
+  room?: DeleteZonePayload
+  construction?: RoomConstructionChange
+  conflict?: string
+  onKeepContents?: () => void
   count: number
   onConfirm: () => void
 }

package/src/store/use-drawing-view.test.ts

@@ -1,10 +1,31 @@
 import { describe, expect, test } from 'bun:test'
-import useDrawingView, { normalizeAnnotationLayoutOverrides } from './use-drawing-view'
+import useDrawingView, {
+  EDITOR_DRAWING_TYPE_OPTIONS,
+  normalizeAnnotationLayoutOverrides,
+  normalizeEditorDrawingType,
+} from './use-drawing-view'
 
 describe('drawing type', () => {
-  test('keeps the workspace on the floor plan', () => {
+  test('starts on the floor plan', () => {
     expect(useDrawingView.getState().drawingType).toBe('floor-plan')
-    expect('setDrawingType' in useDrawingView.getState()).toBe(false)
+  })
+
+  test('switches between the drawing types the editor can render', () => {
+    useDrawingView.getState().setDrawingType('site-plan')
+    expect(useDrawingView.getState().drawingType).toBe('site-plan')
+    useDrawingView.getState().setDrawingType('floor-plan')
+    expect(useDrawingView.getState().drawingType).toBe('floor-plan')
+  })
+
+  test('only offers the two types that have a renderer', () => {
+    expect(EDITOR_DRAWING_TYPE_OPTIONS.map((o) => o.id)).toEqual(['floor-plan', 'site-plan'])
+  })
+
+  test('a persisted value the editor cannot render falls back to the floor plan', () => {
+    expect(normalizeEditorDrawingType('site-plan')).toBe('site-plan')
+    expect(normalizeEditorDrawingType('roof-plan')).toBe('floor-plan')
+    expect(normalizeEditorDrawingType(undefined)).toBe('floor-plan')
+    expect(normalizeEditorDrawingType(42)).toBe('floor-plan')
   })
 })
 

package/src/store/use-drawing-view.ts

@@ -20,8 +20,24 @@ export type DrawingAnnotationLayoutOverride = {
 
 export type DrawingAnnotationLayoutOverrides = Record<string, DrawingAnnotationLayoutOverride>
 
+/**
+ * Drawing types the 2D editor can actually render today. `floor-plan` is the
+ * default; `site-plan` renders through
+ * `lib/floorplan/site-plan/buildSitePlanDrawing`. The remaining
+ * `ConstructionDrawingType` members exist on annotations (they gate dimension
+ * visibility) but have no editor renderer yet, so the switch does not offer
+ * them — widen this union as each one lands.
+ */
+export type EditorDrawingType = Extract<ConstructionDrawingType, 'floor-plan' | 'site-plan'>
+
+export const EDITOR_DRAWING_TYPE_OPTIONS = [
+  { id: 'floor-plan', label: 'Floor plan' },
+  { id: 'site-plan', label: 'Site plan' },
+] as const satisfies readonly { id: EditorDrawingType; label: string }[]
+
 type DrawingViewState = {
-  drawingType: Extract<ConstructionDrawingType, 'floor-plan'>
+  drawingType: EditorDrawingType
+  setDrawingType: (drawingType: EditorDrawingType) => void
   annotationLayoutOverrides: DrawingAnnotationLayoutOverrides
   setAnnotationLayoutOverride: (
     id: string,
@@ -52,10 +68,18 @@ export function normalizeAnnotationLayoutOverrides(
   return out
 }
 
+/** Persisted value → a drawing type the editor can render. Unknown → floor-plan. */
+export function normalizeEditorDrawingType(value: unknown): EditorDrawingType {
+  return EDITOR_DRAWING_TYPE_OPTIONS.some((o) => o.id === value)
+    ? (value as EditorDrawingType)
+    : 'floor-plan'
+}
+
 const useDrawingView = create<DrawingViewState>()(
   persist(
     (set) => ({
       drawingType: 'floor-plan',
+      setDrawingType: (drawingType) => set({ drawingType }),
       annotationLayoutOverrides: {},
       setAnnotationLayoutOverride: (id, override) =>
         set((state) => {
@@ -69,12 +93,16 @@ const useDrawingView = create<DrawingViewState>()(
       name: 'pascal-floorplan-drawing-view',
       merge: (persistedState, currentState) => ({
         ...currentState,
+        drawingType: normalizeEditorDrawingType(
+          (persistedState as { drawingType?: unknown } | undefined)?.drawingType,
+        ),
         annotationLayoutOverrides: normalizeAnnotationLayoutOverrides(
           (persistedState as { annotationLayoutOverrides?: unknown } | undefined)
             ?.annotationLayoutOverrides,
         ),
       }),
       partialize: (state) => ({
+        drawingType: state.drawingType,
         annotationLayoutOverrides: state.annotationLayoutOverrides,
       }),
     },