@pascal-app/editor 1.1.0 → 1.1.1

package/src/lib/below-grade.ts

@@ -1,133 +0,0 @@
-import {
-  type AnyNode,
-  type AnyNodeId,
-  buildingGroundBox,
-  type GroundBox,
-  type LevelGradeStanding,
-  levelGradeStanding,
-  levelGroundBox,
-  useScene,
-} from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
-import { useEffect } from 'react'
-
-type LevelDisplay = {
-  hideLevelsAboveSelection: boolean
-  selection: { levelId: string | null; buildingId?: string | null }
-}
-
-/**
- * The shown level's standing against the ground: the storeys above the selected level are
- * hidden and that level's floor lies under the ground — all of it, or the part of it a
- * hillside stands over — which is then veiled over it.
- */
-export function gradeStandingShown(
-  viewer: LevelDisplay,
-  nodes: Record<AnyNodeId, AnyNode>,
-): LevelGradeStanding {
-  const { levelId } = viewer.selection
-  if (!viewer.hideLevelsAboveSelection || levelId === null) return 'at-grade'
-  return levelGradeStanding(nodes, levelId)
-}
-
-/** Whether the level shown lies below grade, on all of its footprint or part of it. */
-export function belowGradeShown(viewer: LevelDisplay, nodes: Record<AnyNodeId, AnyNode>): boolean {
-  return gradeStandingShown(viewer, nodes) !== 'at-grade'
-}
-
-/**
- * Keeps the viewer's `belowGrade` and `gradeStanding` on the shown level while the
- * selection, the level display and the scene change. The returned function stops, and the
- * ground stands solid again.
- */
-export function followBelowGrade(): () => void {
-  const update = () => {
-    const gradeStanding = gradeStandingShown(useViewer.getState(), useScene.getState().nodes)
-    const viewer = useViewer.getState()
-    if (
-      viewer.gradeStanding !== gradeStanding ||
-      viewer.belowGrade !== (gradeStanding !== 'at-grade')
-    )
-      useViewer.setState({ gradeStanding, belowGrade: gradeStanding !== 'at-grade' })
-  }
-  update()
-  // The flag itself is watched too: the other host's level display, handing over, resets it.
-  const stopViewer = useViewer.subscribe((state, previous) => {
-    if (
-      state.selection.levelId !== previous.selection.levelId ||
-      state.hideLevelsAboveSelection !== previous.hideLevelsAboveSelection ||
-      state.belowGrade !== previous.belowGrade ||
-      state.gradeStanding !== previous.gradeStanding
-    )
-      update()
-  })
-  const stopScene = useScene.subscribe((state, previous) => {
-    if (state.nodes !== previous.nodes) update()
-  })
-  return () => {
-    stopViewer()
-    stopScene()
-    useViewer.setState({ belowGrade: false, gradeStanding: 'at-grade' })
-  }
-}
-
-/** A host's level display marks a level below grade as shown while `active`. */
-export function useBelowGrade(active: boolean) {
-  useEffect(() => (active ? followBelowGrade() : undefined), [active])
-}
-
-/**
- * The box the ground window opens for: the shown level while the editor's level display
- * hides what is above it, the whole building when it stands whole (Preview).
- */
-export function groundWindowBoxShown(
-  viewer: LevelDisplay,
-  nodes: Record<AnyNodeId, AnyNode>,
-): GroundBox | null {
-  const { levelId, buildingId } = viewer.selection
-  if (viewer.hideLevelsAboveSelection && levelId !== null) return levelGroundBox(nodes, levelId)
-  return buildingGroundBox(nodes, buildingId ?? null)
-}
-
-function sameBox(a: GroundBox | null, b: GroundBox | null): boolean {
-  if (a === null || b === null) return a === b
-  return (
-    a.min.every((value, axis) => value === b.min[axis]) &&
-    a.max.every((value, axis) => value === b.max[axis])
-  )
-}
-
-/**
- * Keeps the viewer's `groundWindowBox` on {@link groundWindowBoxShown} while the selection,
- * the level display and the scene change. The returned function stops, and the window closes.
- */
-export function followGroundWindowBox(): () => void {
-  const update = () => {
-    const box = groundWindowBoxShown(useViewer.getState(), useScene.getState().nodes)
-    if (!sameBox(useViewer.getState().groundWindowBox, box))
-      useViewer.setState({ groundWindowBox: box })
-  }
-  update()
-  const stopViewer = useViewer.subscribe((state, previous) => {
-    if (
-      state.selection.levelId !== previous.selection.levelId ||
-      state.selection.buildingId !== previous.selection.buildingId ||
-      state.hideLevelsAboveSelection !== previous.hideLevelsAboveSelection ||
-      state.groundWindowBox !== previous.groundWindowBox
-    )
-      update()
-  })
-  const stopScene = useScene.subscribe((state, previous) => {
-    if (state.nodes !== previous.nodes) update()
-  })
-  return () => {
-    stopViewer()
-    stopScene()
-    useViewer.setState({ groundWindowBox: null })
-  }
-}
-
-/** The ground window follows the shown level or building while `active` (not on the site). */
-export function useGroundWindowBox(active: boolean) {
-  useEffect(() => (active ? followGroundWindowBox() : undefined), [active])
-}

package/src/lib/camera-pose.test.ts

@@ -1,237 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import {
-  normalizeCameraPose,
-  planCameraPoseApplication,
-  publishInitialCameraPose,
-  releaseCameraPoseEventSuppression,
-  stepCameraPoseInterpolation,
-  withCameraPoseDistance,
-} from './camera-pose'
-
-describe('camera pose', () => {
-  test('normalizes a finite pose without retaining input tuples', () => {
-    const position: [number, number, number] = [1, 2, 3]
-    const target: [number, number, number] = [4, 5, 6]
-    const pose = normalizeCameraPose({
-      position,
-      target,
-      projection: 'perspective',
-      fov: 50,
-      viewWidth: 12,
-    })
-
-    expect(pose).toEqual({
-      fov: 50,
-      position,
-      projection: 'perspective',
-      target,
-      viewWidth: 12,
-    })
-    expect(pose?.position).not.toBe(position)
-    expect(pose?.target).not.toBe(target)
-  })
-
-  test('rejects non-finite, malformed, and unknown camera poses', () => {
-    expect(normalizeCameraPose(null)).toBeNull()
-    expect(
-      normalizeCameraPose({
-        position: [1, 2],
-        target: [4, 5, 6],
-        projection: 'perspective',
-      }),
-    ).toBeNull()
-    expect(
-      normalizeCameraPose({
-        position: [1, Number.NaN, 3],
-        target: [4, 5, 6],
-        projection: 'perspective',
-      }),
-    ).toBeNull()
-    expect(
-      normalizeCameraPose({
-        position: [1, 2, 3],
-        target: [4, 5, Number.POSITIVE_INFINITY],
-        projection: 'perspective',
-      }),
-    ).toBeNull()
-    expect(
-      normalizeCameraPose({
-        position: [1, 2, 3],
-        target: [4, 5, 6],
-        projection: 'panoramic',
-      }),
-    ).toBeNull()
-    expect(
-      normalizeCameraPose({
-        position: [1, 2, 3],
-        target: [4, 5, 6],
-        projection: 'perspective',
-        fov: Number.NaN,
-      }),
-    ).toBeNull()
-    expect(
-      normalizeCameraPose({
-        position: [1, 2, 3],
-        target: [4, 5, 6],
-        projection: 'orthographic',
-        viewWidth: 0,
-      }),
-    ).toBeNull()
-    expect(
-      normalizeCameraPose({
-        position: [1, 2, 3],
-        target: [4, 5, 6],
-        projection: 'orthographic',
-        viewWidth: Number.POSITIVE_INFINITY,
-      }),
-    ).toBeNull()
-  })
-
-  test('plans only perspective fov application and clamps it to a safe range', () => {
-    expect(
-      planCameraPoseApplication({
-        position: [1, 2, 3],
-        target: [4, 5, 6],
-        projection: 'perspective',
-        fov: 0,
-      })?.perspectiveFov,
-    ).toBe(1)
-    expect(
-      planCameraPoseApplication({
-        position: [1, 2, 3],
-        target: [4, 5, 6],
-        projection: 'perspective',
-        fov: 200,
-      })?.perspectiveFov,
-    ).toBe(179)
-    expect(
-      planCameraPoseApplication({
-        position: [1, 2, 3],
-        target: [4, 5, 6],
-        projection: 'orthographic',
-        fov: 70,
-      })?.perspectiveFov,
-    ).toBeNull()
-  })
-
-  test('interpolates toward the latest pose and converges exactly', () => {
-    const destination = {
-      position: [12, 6, -4] as [number, number, number],
-      target: [2, 1, 3] as [number, number, number],
-      projection: 'perspective' as const,
-    }
-    const first = stepCameraPoseInterpolation([0, 0, 0], [0, 0, 0], destination, 0.016)
-    expect(first.settled).toBe(false)
-    expect(first.position[0]).toBeGreaterThan(0)
-    expect(first.position[0]).toBeLessThan(destination.position[0])
-
-    let position = first.position
-    let target = first.target
-    let settled = first.settled
-    for (let frame = 0; frame < 240 && !settled; frame += 1) {
-      const step = stepCameraPoseInterpolation(position, target, destination, 0.016)
-      position = step.position
-      target = step.target
-      settled = step.settled
-    }
-
-    expect(settled).toBe(true)
-    expect(position).toEqual(destination.position)
-    expect(target).toEqual(destination.target)
-  })
-
-  test('settles an already-current pose without advancing on an invalid delta', () => {
-    const destination = {
-      position: [1, 2, 3] as [number, number, number],
-      target: [4, 5, 6] as [number, number, number],
-      projection: 'orthographic' as const,
-    }
-    expect(
-      stepCameraPoseInterpolation(
-        destination.position,
-        destination.target,
-        destination,
-        Number.NaN,
-      ),
-    ).toEqual({
-      position: destination.position,
-      settled: true,
-      target: destination.target,
-    })
-    expect(stepCameraPoseInterpolation([0, 0, 0], [0, 0, 0], destination, Number.NaN)).toEqual({
-      position: [0, 0, 0],
-      settled: false,
-      target: [0, 0, 0],
-    })
-  })
-
-  test('publishes the initial pose before any camera control update event', () => {
-    let publishCount = 0
-
-    publishInitialCameraPose(() => {
-      publishCount += 1
-    })
-
-    expect(publishCount).toBe(1)
-  })
-
-  test('publishes the settled pose when programmatic interpolation releases suppression', () => {
-    const suppression = { current: true }
-    let publishCount = 0
-
-    releaseCameraPoseEventSuppression(suppression, () => {
-      publishCount += 1
-    })
-
-    expect(suppression.current).toBe(false)
-    expect(publishCount).toBe(1)
-  })
-
-  test('retargets the bounded interpolation owner to the latest pose', () => {
-    const first = stepCameraPoseInterpolation(
-      [0, 0, 0],
-      [0, 0, 0],
-      {
-        position: [10, 0, 0],
-        target: [5, 0, 0],
-        projection: 'perspective',
-      },
-      0.016,
-    )
-    const retargeted = stepCameraPoseInterpolation(
-      first.position,
-      first.target,
-      {
-        position: [-10, 0, 0],
-        target: [-5, 0, 0],
-        projection: 'perspective',
-      },
-      0.1,
-    )
-
-    expect(retargeted.position[0]).toBeLessThan(first.position[0])
-    expect(retargeted.target[0]).toBeLessThan(first.target[0])
-  })
-
-  test('preserves view direction while adapting distance to the local viewport', () => {
-    const pose = {
-      position: [4, 6, 12] as [number, number, number],
-      target: [1, 2, 3] as [number, number, number],
-      projection: 'perspective' as const,
-      viewWidth: 20,
-    }
-    const adapted = withCameraPoseDistance(pose, 5)
-    const sourceDirection = pose.position.map((value, index) => value - pose.target[index]!)
-    const adaptedDirection = adapted.position.map((value, index) => value - adapted.target[index]!)
-    const sourceLength = Math.hypot(...sourceDirection)
-
-    expect(Math.hypot(...adaptedDirection)).toBeCloseTo(5)
-    const expectedDirection = sourceDirection.map((component) => component * (5 / sourceLength))
-    expect(adaptedDirection[0]).toBeCloseTo(expectedDirection[0]!)
-    expect(adaptedDirection[1]).toBeCloseTo(expectedDirection[1]!)
-    expect(adaptedDirection[2]).toBeCloseTo(expectedDirection[2]!)
-    expect(adapted.target).toEqual(pose.target)
-    expect(adapted.target).not.toBe(pose.target)
-    expect(pose.position).toEqual([4, 6, 12])
-  })
-})

package/src/lib/camera-pose.ts

@@ -1,172 +0,0 @@
-import type { CameraPose } from '@pascal-app/core'
-
-const MIN_PERSPECTIVE_FOV = 1
-const MAX_PERSPECTIVE_FOV = 179
-const INTERPOLATION_TIME_CONSTANT_SECONDS = 0.08
-const MAX_INTERPOLATION_DELTA_SECONDS = 0.1
-const INTERPOLATION_SETTLE_DISTANCE = 0.001
-
-export type CameraPoseApplicationPlan = {
-  pose: CameraPose
-  perspectiveFov: number | null
-}
-
-export type CameraPoseInterpolationStep = {
-  position: [number, number, number]
-  settled: boolean
-  target: [number, number, number]
-}
-
-export function publishInitialCameraPose(publishCurrentPose: () => void): void {
-  publishCurrentPose()
-}
-
-export function releaseCameraPoseEventSuppression(
-  suppression: { current: boolean },
-  publishCurrentPose: () => void,
-): void {
-  suppression.current = false
-  publishCurrentPose()
-}
-
-function finiteVectorTuple(value: unknown): [number, number, number] | null {
-  if (
-    !(
-      Array.isArray(value) &&
-      value.length === 3 &&
-      value.every((component) => typeof component === 'number' && Number.isFinite(component))
-    )
-  ) {
-    return null
-  }
-
-  return [value[0], value[1], value[2]]
-}
-
-export function normalizeCameraPose(value: unknown): CameraPose | null {
-  if (!(typeof value === 'object' && value !== null)) {
-    return null
-  }
-
-  const candidate = value as Partial<CameraPose>
-  const position = finiteVectorTuple(candidate.position)
-  const target = finiteVectorTuple(candidate.target)
-  if (
-    !(
-      position &&
-      target &&
-      (candidate.projection === 'perspective' || candidate.projection === 'orthographic')
-    )
-  ) {
-    return null
-  }
-
-  if (
-    candidate.fov !== undefined &&
-    !(typeof candidate.fov === 'number' && Number.isFinite(candidate.fov))
-  ) {
-    return null
-  }
-
-  if (
-    candidate.viewWidth !== undefined &&
-    !(
-      typeof candidate.viewWidth === 'number' &&
-      Number.isFinite(candidate.viewWidth) &&
-      candidate.viewWidth > 0
-    )
-  ) {
-    return null
-  }
-
-  return {
-    ...(candidate.fov === undefined ? {} : { fov: candidate.fov }),
-    position,
-    projection: candidate.projection,
-    target,
-    ...(candidate.viewWidth === undefined ? {} : { viewWidth: candidate.viewWidth }),
-  }
-}
-
-export function planCameraPoseApplication(value: unknown): CameraPoseApplicationPlan | null {
-  const pose = normalizeCameraPose(value)
-  if (!pose) {
-    return null
-  }
-
-  return {
-    pose,
-    perspectiveFov:
-      pose.projection === 'perspective' && pose.fov !== undefined
-        ? Math.min(Math.max(pose.fov, MIN_PERSPECTIVE_FOV), MAX_PERSPECTIVE_FOV)
-        : null,
-  }
-}
-
-function interpolateVectorTuple(
-  current: [number, number, number],
-  destination: [number, number, number],
-  alpha: number,
-): { settled: boolean; value: [number, number, number] } {
-  const dx = destination[0] - current[0]
-  const dy = destination[1] - current[1]
-  const dz = destination[2] - current[2]
-  const settleDistanceSquared = INTERPOLATION_SETTLE_DISTANCE ** 2
-  if (dx * dx + dy * dy + dz * dz <= settleDistanceSquared) {
-    return { settled: true, value: [...destination] }
-  }
-
-  const value: [number, number, number] = [
-    current[0] + dx * alpha,
-    current[1] + dy * alpha,
-    current[2] + dz * alpha,
-  ]
-  const remainingX = destination[0] - value[0]
-  const remainingY = destination[1] - value[1]
-  const remainingZ = destination[2] - value[2]
-  const settled =
-    remainingX * remainingX + remainingY * remainingY + remainingZ * remainingZ <=
-    settleDistanceSquared
-
-  return { settled, value: settled ? [...destination] : value }
-}
-
-export function withCameraPoseDistance(pose: CameraPose, distance: number): CameraPose {
-  const dx = pose.position[0] - pose.target[0]
-  const dy = pose.position[1] - pose.target[1]
-  const dz = pose.position[2] - pose.target[2]
-  const currentDistance = Math.hypot(dx, dy, dz)
-  if (!(Number.isFinite(distance) && distance > 0 && currentDistance > 0)) {
-    return { ...pose, position: [...pose.position], target: [...pose.target] }
-  }
-
-  const scale = distance / currentDistance
-  return {
-    ...pose,
-    position: [
-      pose.target[0] + dx * scale,
-      pose.target[1] + dy * scale,
-      pose.target[2] + dz * scale,
-    ],
-    target: [...pose.target],
-  }
-}
-
-export function stepCameraPoseInterpolation(
-  currentPosition: [number, number, number],
-  currentTarget: [number, number, number],
-  destination: CameraPose,
-  deltaSeconds: number,
-): CameraPoseInterpolationStep {
-  const finiteDelta = Number.isFinite(deltaSeconds) ? deltaSeconds : 0
-  const elapsed = Math.min(Math.max(finiteDelta, 0), MAX_INTERPOLATION_DELTA_SECONDS)
-  const alpha = 1 - Math.exp(-elapsed / INTERPOLATION_TIME_CONSTANT_SECONDS)
-  const position = interpolateVectorTuple(currentPosition, destination.position, alpha)
-  const target = interpolateVectorTuple(currentTarget, destination.target, alpha)
-
-  return {
-    position: position.value,
-    settled: position.settled && target.settled,
-    target: target.value,
-  }
-}

package/src/lib/floorplan/floorplan-extension.test.ts

@@ -1,42 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { GeometryContext } from '@pascal-app/core'
-import {
-  createFloorplanContextExtensions,
-  normalizeFloorplanWallDimensionFaces,
-  readFloorplanContext,
-} from './floorplan-extension'
-
-function context(extensions?: Readonly<Record<string, unknown>>): GeometryContext {
-  return {
-    resolve: () => undefined,
-    children: [],
-    siblings: [],
-    parent: null,
-    extensions,
-  }
-}
-
-describe('floor-plan context extensions', () => {
-  test('measures walls to both faces by default', () => {
-    expect(readFloorplanContext(context()).wallDimensionFaces).toBe('both')
-  })
-
-  test('carries the Measure walls choice', () => {
-    for (const wallDimensionFaces of ['interior', 'exterior', 'both'] as const) {
-      const extensions = createFloorplanContextExtensions({ wallDimensionFaces })
-      expect(readFloorplanContext(context(extensions)).wallDimensionFaces).toBe(wallDimensionFaces)
-    }
-  })
-
-  test('normalizes stale persisted values, including the retired references, to Both', () => {
-    for (const stale of ['finished-faces', 'centerline', 'stud-faces', 'unknown', null]) {
-      expect(normalizeFloorplanWallDimensionFaces(stale)).toBe('both')
-    }
-  })
-
-  test('lets presentation code suppress automatic annotation construction', () => {
-    expect(readFloorplanContext(context()).automaticDimensions).toBe(true)
-    const extensions = createFloorplanContextExtensions({ automaticDimensions: false })
-    expect(readFloorplanContext(context(extensions)).automaticDimensions).toBe(false)
-  })
-})

package/src/lib/floorplan/floorplan-readonly.test.ts

@@ -1,47 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { LevelNode, WallNode } from '@pascal-app/core/schema'
-import { buildFloorplanContext } from './floorplan-readonly'
-
-const viewState = {
-  selected: false,
-  unit: 'metric' as const,
-  highlighted: false,
-  hovered: false,
-  moving: false,
-  palette: undefined,
-}
-
-describe('read-only floorplan context', () => {
-  test('does not invent siblings for parentless nodes', () => {
-    const first = LevelNode.parse({ id: 'level_first', type: 'level' })
-    const second = LevelNode.parse({ id: 'level_second', type: 'level' })
-    const nodes = { [first.id]: first, [second.id]: second }
-
-    expect(buildFloorplanContext(first, nodes, viewState).siblings).toEqual([])
-  })
-
-  test('resolves same-kind siblings from the parent child order', () => {
-    const first = WallNode.parse({
-      id: 'wall_first',
-      type: 'wall',
-      parentId: 'level_ground',
-      start: [0, 0],
-      end: [1, 0],
-    })
-    const second = WallNode.parse({
-      id: 'wall_second',
-      type: 'wall',
-      parentId: 'level_ground',
-      start: [1, 0],
-      end: [2, 0],
-    })
-    const level = LevelNode.parse({
-      id: 'level_ground',
-      type: 'level',
-      children: [first.id, second.id],
-    })
-    const nodes = { [level.id]: level, [first.id]: first, [second.id]: second }
-
-    expect(buildFloorplanContext(first, nodes, viewState).siblings).toEqual([second])
-  })
-})