@pascal-app/editor 1.0.7 → 1.1.1

package/src/lib/window-interaction.ts

@@ -1,142 +0,0 @@
-import {
-  type AnyNodeId,
-  type InteractiveState,
-  useInteractive,
-  useScene,
-  type WindowInteractiveState,
-} from '@pascal-app/core'
-
-export const WINDOW_TOGGLE_ANIMATION_MS = 520
-
-export type WindowOpenAnimationOptions = {
-  persist?: boolean
-}
-
-export function isOperableWindowType(windowType: string | undefined) {
-  return (
-    windowType === 'sliding' ||
-    windowType === 'casement' ||
-    windowType === 'awning' ||
-    windowType === 'hopper' ||
-    windowType === 'tilt-turn' ||
-    windowType === 'single-hung' ||
-    windowType === 'double-hung' ||
-    windowType === 'louvered'
-  )
-}
-
-export function getDisplayedWindowValue(
-  windowId: AnyNodeId,
-  nodeValue: number | undefined,
-  field: keyof WindowInteractiveState = 'operationState',
-  interactive: InteractiveState = useInteractive.getState(),
-) {
-  const runtimeValue = interactive.windows[windowId]?.[field]
-  if (runtimeValue !== undefined) return runtimeValue
-
-  const queuedValue = interactive.windowAnimations[windowId]?.[field]?.from
-  if (queuedValue !== undefined) return queuedValue
-
-  return nodeValue ?? 0
-}
-
-function startWindowOpenAnimation(
-  windowId: AnyNodeId,
-  field: keyof WindowInteractiveState,
-  from: number,
-  to: number,
-  options?: WindowOpenAnimationOptions,
-) {
-  useInteractive.getState().startWindowAnimation(windowId, {
-    field,
-    from,
-    to,
-    startedAt: null,
-    durationMs: WINDOW_TOGGLE_ANIMATION_MS,
-    persist: options?.persist ?? true,
-  })
-}
-
-export function toggleWindowOpenState(windowId: AnyNodeId, options?: WindowOpenAnimationOptions) {
-  const node = useScene.getState().nodes[windowId]
-  if (
-    node?.type !== 'window' ||
-    node.openingKind === 'opening' ||
-    !isOperableWindowType(node.windowType)
-  ) {
-    return
-  }
-
-  const currentOpenAmount = getDisplayedWindowValue(windowId, node.operationState)
-  startWindowOpenAnimation(
-    windowId,
-    'operationState',
-    currentOpenAmount,
-    currentOpenAmount >= 0.5 ? 0 : 1,
-    options,
-  )
-}
-
-export function closeWindowOpenState(windowId: AnyNodeId, options?: WindowOpenAnimationOptions) {
-  const node = useScene.getState().nodes[windowId]
-  if (
-    node?.type !== 'window' ||
-    node.openingKind === 'opening' ||
-    !isOperableWindowType(node.windowType)
-  ) {
-    return
-  }
-
-  const currentOpenAmount = getDisplayedWindowValue(windowId, node.operationState)
-  startWindowOpenAnimation(windowId, 'operationState', currentOpenAmount, 0, options)
-}
-
-export function openWindowOpenState(windowId: AnyNodeId, options?: WindowOpenAnimationOptions) {
-  const node = useScene.getState().nodes[windowId]
-  if (
-    node?.type !== 'window' ||
-    node.openingKind === 'opening' ||
-    !isOperableWindowType(node.windowType)
-  ) {
-    return
-  }
-
-  const currentOpenAmount = getDisplayedWindowValue(windowId, node.operationState)
-  startWindowOpenAnimation(windowId, 'operationState', currentOpenAmount, 1, options)
-}
-
-export type WindowShutterField = 'shutterOpen' | 'rollerShutterOpen'
-
-export function getDisplayedWindowShutterValue(
-  windowId: AnyNodeId,
-  field: WindowShutterField,
-  nodeValue: number | undefined,
-  state: InteractiveState = useInteractive.getState(),
-): number {
-  return getDisplayedWindowValue(windowId, nodeValue ?? 1, field, state)
-}
-
-/** Preview both shutter styles together, independently of the sash. */
-export function setWindowShuttersOpenState(
-  windowId: AnyNodeId,
-  on: boolean,
-  options?: WindowOpenAnimationOptions,
-): void {
-  const node = useScene.getState().nodes[windowId]
-  if (node?.type !== 'window' || node.source) return
-  const fields: WindowShutterField[] = []
-  if (node.shutters && node.shutters !== 'none') fields.push('shutterOpen')
-  if (node.rollerShutter === 'box' || node.rollerShutter === 'concealed')
-    fields.push('rollerShutterOpen')
-  if (!fields.length) return
-  useInteractive.getState().setMechanismPart(windowId, 'shutters', on)
-  for (const field of fields) {
-    startWindowOpenAnimation(
-      windowId,
-      field,
-      getDisplayedWindowShutterValue(windowId, field, node[field]),
-      on ? 1 : 0,
-      options,
-    )
-  }
-}

package/src/lib/zone-content.ts

@@ -1,133 +0,0 @@
-import {
-  type AnyNode,
-  type AnyNodeId,
-  type CeilingNode,
-  type ItemNode,
-  pointInPolygon2D,
-  pointOnSegment,
-  type SlabNode,
-  type WallNode,
-  type ZoneNode,
-} from '@pascal-app/core'
-
-type Point2D = [number, number]
-
-const POINT_TOLERANCE = 0.5
-const COLLINEAR_TOLERANCE = 1e-6
-const SURFACE_POLYGON_TOLERANCE = 0.15
-
-function getPointToSegmentDistance(point: Point2D, start: Point2D, end: Point2D): number {
-  const dx = end[0] - start[0]
-  const dz = end[1] - start[1]
-  const lengthSq = dx * dx + dz * dz
-  if (lengthSq === 0) return Math.hypot(point[0] - start[0], point[1] - start[1])
-
-  const rawT = ((point[0] - start[0]) * dx + (point[1] - start[1]) * dz) / lengthSq
-  const t = Math.max(0, Math.min(1, rawT))
-  const projected: Point2D = [start[0] + t * dx, start[1] + t * dz]
-  return Math.hypot(point[0] - projected[0], point[1] - projected[1])
-}
-
-function pointInPolygonWithTolerance(point: Point2D, polygon: Point2D[]): boolean {
-  if (pointInPolygon2D(point, polygon, { includeBoundary: true })) return true
-  return polygon.some((start, index) => {
-    const end = polygon[(index + 1) % polygon.length]
-    return end ? getPointToSegmentDistance(point, start, end) <= POINT_TOLERANCE : false
-  })
-}
-
-function polygonContainsWithTolerance(
-  outer: Point2D[],
-  inner: Point2D[],
-  tolerance: number,
-): boolean {
-  return inner.every((point) => {
-    if (pointInPolygon2D(point, outer, { includeBoundary: true })) return true
-    return outer.some((start, index) => {
-      const end = outer[(index + 1) % outer.length]
-      return end ? getPointToSegmentDistance(point, start, end) <= tolerance : false
-    })
-  })
-}
-
-export function polygonMatchesZoneFootprint(
-  surfacePolygon: Point2D[],
-  footprint: Point2D[],
-): boolean {
-  if (surfacePolygon.length < 3) return false
-  return (
-    polygonContainsWithTolerance(footprint, surfacePolygon, SURFACE_POLYGON_TOLERANCE) &&
-    polygonContainsWithTolerance(surfacePolygon, footprint, SURFACE_POLYGON_TOLERANCE)
-  )
-}
-
-function areSegmentsCollinear(a: Point2D, b: Point2D, c: Point2D, d: Point2D): boolean {
-  const abx = b[0] - a[0]
-  const abz = b[1] - a[1]
-  const acx = c[0] - a[0]
-  const acz = c[1] - a[1]
-  const adx = d[0] - a[0]
-  const adz = d[1] - a[1]
-  const crossC = abx * acz - abz * acx
-  const crossD = abx * adz - abz * adx
-  return Math.abs(crossC) <= COLLINEAR_TOLERANCE && Math.abs(crossD) <= COLLINEAR_TOLERANCE
-}
-
-function segmentsOverlap(a: Point2D, b: Point2D, c: Point2D, d: Point2D): boolean {
-  const useX = Math.abs(b[0] - a[0]) >= Math.abs(b[1] - a[1])
-  const a0 = useX ? a[0] : a[1]
-  const a1 = useX ? b[0] : b[1]
-  const c0 = useX ? c[0] : c[1]
-  const c1 = useX ? d[0] : d[1]
-  const minA = Math.min(a0, a1)
-  const maxA = Math.max(a0, a1)
-  const minC = Math.min(c0, c1)
-  const maxC = Math.max(c0, c1)
-  return Math.max(minA, minC) <= Math.min(maxA, maxC) + COLLINEAR_TOLERANCE
-}
-
-function wallLiesOnZoneBoundary(wall: WallNode, polygon: Point2D[]): boolean {
-  return polygon.some((start, index) => {
-    const end = polygon[(index + 1) % polygon.length]
-    if (!end) return false
-    return (
-      areSegmentsCollinear(wall.start, wall.end, start, end) &&
-      segmentsOverlap(wall.start, wall.end, start, end) &&
-      pointOnSegment(wall.start, start, end, POINT_TOLERANCE) &&
-      pointOnSegment(wall.end, start, end, POINT_TOLERANCE)
-    )
-  })
-}
-
-export function collectZoneContentIds(
-  nodes: Readonly<Record<AnyNodeId, AnyNode>>,
-  zone: ZoneNode,
-): AnyNodeId[] {
-  const levelId = zone.parentId
-  if (!levelId) return []
-
-  const footprint = zone.polygon.map((point) => [point[0], point[1]] as Point2D)
-  const boundaryWalls = Object.values(nodes)
-    .filter((node): node is WallNode => node.type === 'wall' && node.parentId === levelId)
-    .filter((wall) => wallLiesOnZoneBoundary(wall, footprint))
-  const surfaces = Object.values(nodes)
-    .filter(
-      (node): node is SlabNode | CeilingNode =>
-        (node.type === 'slab' || node.type === 'ceiling') && node.parentId === levelId,
-    )
-    .filter((surface) => {
-      const polygon = surface.polygon.map((point) => [point[0], point[1]] as Point2D)
-      return polygonMatchesZoneFootprint(polygon, footprint)
-    })
-  const floorItems = Object.values(nodes)
-    .filter((node): node is ItemNode => node.type === 'item' && node.parentId === levelId)
-    .filter((item) => pointInPolygonWithTolerance([item.position[0], item.position[2]], footprint))
-
-  return Array.from(
-    new Set<AnyNodeId>([
-      ...boundaryWalls.map((wall) => wall.id as AnyNodeId),
-      ...surfaces.map((surface) => surface.id as AnyNodeId),
-      ...floorItems.map((item) => item.id as AnyNodeId),
-    ]),
-  )
-}

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

@@ -1,29 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import type { CameraPose } from '@pascal-app/core'
-import { cameraPoseStore, publishCameraPose, subscribeCameraPose } from './camera-pose-store'
-
-const pose: CameraPose = {
-  position: [3, 4, 5],
-  projection: 'perspective',
-  target: [0, 1, 0],
-  viewWidth: 12,
-}
-
-afterEach(() => {
-  cameraPoseStore.setState({ pose: null })
-})
-
-describe('camera pose store', () => {
-  test('replays the latest pose and streams later poses to focused subscribers', () => {
-    publishCameraPose(pose)
-    const received: CameraPose[] = []
-    const unsubscribe = subscribeCameraPose((nextPose) => received.push(nextPose))
-    const nextPose = { ...pose, viewWidth: 8 }
-
-    publishCameraPose(nextPose)
-    unsubscribe()
-    publishCameraPose({ ...pose, viewWidth: 4 })
-
-    expect(received).toEqual([pose, nextPose])
-  })
-})

package/src/store/camera-pose-store.ts

@@ -1,27 +0,0 @@
-import type { CameraPose } from '@pascal-app/core'
-import { subscribeWithSelector } from 'zustand/middleware'
-import { createStore } from 'zustand/vanilla'
-
-type CameraPoseState = {
-  pose: CameraPose | null
-}
-
-export const cameraPoseStore = createStore<CameraPoseState>()(
-  subscribeWithSelector<CameraPoseState>(() => ({ pose: null })),
-)
-
-export function publishCameraPose(pose: CameraPose) {
-  cameraPoseStore.setState({ pose })
-}
-
-export function subscribeCameraPose(listener: (pose: CameraPose) => void) {
-  const currentPose = cameraPoseStore.getState().pose
-  if (currentPose) listener(currentPose)
-
-  return cameraPoseStore.subscribe(
-    (state) => state.pose,
-    (pose) => {
-      if (pose) listener(pose)
-    },
-  )
-}

package/src/store/navigation-sync-pose-store.test.ts

@@ -1,34 +0,0 @@
-import { afterEach, describe, expect, test } from 'bun:test'
-import {
-  navigationSyncPoseStore,
-  publishNavigationSyncPoseToStore,
-  subscribeNavigationSyncPose,
-} from './navigation-sync-pose-store'
-import type { NavigationSyncPose } from './use-editor'
-
-const pose = {
-  source: '2d' as const,
-  revision: 1,
-  target: [1, 2, 3] as [number, number, number],
-  azimuth: 0.5,
-  viewWidth: 12,
-}
-
-afterEach(() => {
-  navigationSyncPoseStore.setState({ pose: null })
-})
-
-describe('navigation sync pose store', () => {
-  test('replays the latest pose and streams only later pose writes', () => {
-    publishNavigationSyncPoseToStore(pose)
-    const received: NavigationSyncPose[] = []
-    const unsubscribe = subscribeNavigationSyncPose((nextPose) => received.push(nextPose))
-    const nextPose = { ...pose, revision: 2, viewWidth: 8 }
-
-    publishNavigationSyncPoseToStore(nextPose)
-    unsubscribe()
-    publishNavigationSyncPoseToStore({ ...pose, revision: 3 })
-
-    expect(received).toEqual([pose, nextPose])
-  })
-})

package/src/store/navigation-sync-pose-store.ts

@@ -1,27 +0,0 @@
-import { subscribeWithSelector } from 'zustand/middleware'
-import { createStore } from 'zustand/vanilla'
-import type { NavigationSyncPose } from './use-editor'
-
-type NavigationSyncPoseState = {
-  pose: NavigationSyncPose | null
-}
-
-export const navigationSyncPoseStore = createStore<NavigationSyncPoseState>()(
-  subscribeWithSelector<NavigationSyncPoseState>(() => ({ pose: null })),
-)
-
-export function publishNavigationSyncPoseToStore(pose: NavigationSyncPose) {
-  navigationSyncPoseStore.setState({ pose })
-}
-
-export function subscribeNavigationSyncPose(listener: (pose: NavigationSyncPose) => void) {
-  const currentPose = navigationSyncPoseStore.getState().pose
-  if (currentPose) listener(currentPose)
-
-  return navigationSyncPoseStore.subscribe(
-    (state) => state.pose,
-    (pose) => {
-      if (pose) listener(pose)
-    },
-  )
-}

package/src/store/use-audio.test.ts

@@ -1,146 +0,0 @@
-import { afterAll, beforeEach, describe, expect, test } from 'bun:test'
-import useAudio, { AUDIO_MUTED_STORAGE_KEY, AUDIO_SETTINGS_STORAGE_KEY } from './use-audio'
-
-function memoryStorage() {
-  const items = new Map<string, string>()
-  return {
-    items,
-    getItem: (key: string) => items.get(key) ?? null,
-    setItem: (key: string, value: string) => void items.set(key, value),
-    removeItem: (key: string) => void items.delete(key),
-  }
-}
-
-const originals = {
-  localStorage: Object.getOwnPropertyDescriptor(globalThis, 'localStorage'),
-  sessionStorage: Object.getOwnPropertyDescriptor(globalThis, 'sessionStorage'),
-}
-
-function use(name: 'localStorage' | 'sessionStorage', storage: ReturnType<typeof memoryStorage>) {
-  Object.defineProperty(globalThis, name, { configurable: true, value: storage })
-}
-
-/** One browser profile: its tabs share `localStorage`, each has its own `sessionStorage`. */
-let browser = memoryStorage()
-
-/** Another tab of the profile saves the settings: the browser stores them and tells this tab. */
-function savedInAnotherTab(state: Record<string, unknown>) {
-  const value = JSON.stringify({ state, version: 0 })
-  browser.setItem(AUDIO_SETTINGS_STORAGE_KEY, value)
-  globalThis.dispatchEvent(
-    Object.assign(new Event('storage'), { key: AUDIO_SETTINGS_STORAGE_KEY, newValue: value }),
-  )
-}
-
-/** The editor loading in a tab: a new one, or the same one reloaded (its session kept). */
-async function loadIn(tab: ReturnType<typeof memoryStorage>) {
-  use('sessionStorage', tab)
-  await useAudio.persist.rehydrate()
-  return useAudio.getState()
-}
-
-beforeEach(() => {
-  browser = memoryStorage()
-  use('localStorage', browser)
-})
-
-afterAll(() => {
-  for (const [name, descriptor] of Object.entries(originals)) {
-    if (descriptor) Object.defineProperty(globalThis, name, descriptor)
-    else Reflect.deleteProperty(globalThis, name)
-  }
-})
-
-describe('muting a tab', () => {
-  test('a tab keeps its own mute across reloads, and a new tab starts from the last choice', async () => {
-    const first = memoryStorage()
-    const second = memoryStorage()
-
-    expect((await loadIn(first)).muted).toBe(false)
-    useAudio.getState().toggleMute()
-
-    expect((await loadIn(second)).muted).toBe(true)
-    useAudio.getState().setMuted(false)
-
-    expect((await loadIn(first)).muted).toBe(true)
-    expect((await loadIn(memoryStorage())).muted).toBe(false)
-  })
-
-  test("another tab's choice does not change a tab that never chose", async () => {
-    const quiet = memoryStorage()
-    expect((await loadIn(quiet)).muted).toBe(false)
-
-    await loadIn(memoryStorage())
-    useAudio.getState().setMuted(true)
-
-    expect((await loadIn(quiet)).muted).toBe(false)
-  })
-
-  test("volumes are every tab's and never carry a mute", async () => {
-    const muting = memoryStorage()
-    await loadIn(muting)
-    useAudio.getState().setMuted(true)
-
-    await loadIn(memoryStorage())
-    useAudio.getState().setMuted(false)
-    await loadIn(muting)
-    useAudio.getState().setSfxVolume(20)
-
-    expect(JSON.parse(browser.getItem(AUDIO_SETTINGS_STORAGE_KEY)!).state).not.toHaveProperty(
-      'muted',
-    )
-    expect(browser.getItem(AUDIO_MUTED_STORAGE_KEY)).toBe('false')
-    const next = await loadIn(memoryStorage())
-    expect(next.sfxVolume).toBe(20)
-    expect(next.muted).toBe(false)
-  })
-
-  test("a volume another tab sets reaches this one at once, and this tab's saves carry it", async () => {
-    await loadIn(memoryStorage())
-    useAudio.getState().setSfxVolume(30)
-    useAudio.getState().setRadioPlaying(true)
-    const stored = JSON.parse(browser.getItem(AUDIO_SETTINGS_STORAGE_KEY)!)
-
-    savedInAnotherTab({ ...stored.state, isRadioPlaying: false, muted: true, sfxVolume: 80 })
-
-    expect(useAudio.getState()).toMatchObject({ isRadioPlaying: true, muted: false, sfxVolume: 80 })
-    const setElsewhere = browser.getItem(AUDIO_SETTINGS_STORAGE_KEY)
-    useAudio.getState().setMuted(true)
-    expect(browser.getItem(AUDIO_SETTINGS_STORAGE_KEY)).toBe(setElsewhere)
-    // The radio pausing as the tab is hidden saves every setting: the other tab's volume stays.
-    useAudio.getState().setRadioPlaying(false)
-    useAudio.getState().setMasterVolume(60)
-    expect(JSON.parse(browser.getItem(AUDIO_SETTINGS_STORAGE_KEY)!).state).toMatchObject({
-      masterVolume: 60,
-      sfxVolume: 80,
-    })
-  })
-
-  test("a mute saved when it was every tab's still holds, in settings the old build still reads", async () => {
-    browser.setItem(
-      AUDIO_SETTINGS_STORAGE_KEY,
-      JSON.stringify({ state: { masterVolume: 40, muted: true, sfxVolume: 50 }, version: 0 }),
-    )
-
-    const state = await loadIn(memoryStorage())
-
-    expect(state.muted).toBe(true)
-    expect(state.masterVolume).toBe(40)
-    expect((await loadIn(memoryStorage())).muted).toBe(true)
-    useAudio.getState().setSfxVolume(45)
-    const saved = JSON.parse(browser.getItem(AUDIO_SETTINGS_STORAGE_KEY)!)
-    expect(saved).toMatchObject({ state: { masterVolume: 40, sfxVolume: 45 }, version: 0 })
-    expect(saved.state).not.toHaveProperty('muted')
-  })
-
-  test('a tab still on the old settings does not undo a choice made since', async () => {
-    await loadIn(memoryStorage())
-    useAudio.getState().setMuted(false)
-    browser.setItem(
-      AUDIO_SETTINGS_STORAGE_KEY,
-      JSON.stringify({ state: { muted: true, sfxVolume: 50 }, version: 0 }),
-    )
-
-    expect((await loadIn(memoryStorage())).muted).toBe(false)
-  })
-})