@pascal-app/editor 1.1.0 → 1.1.1

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)
-  })
-})

package/src/store/use-audio.tsx

@@ -1,169 +0,0 @@
-'use client'
-
-import { create } from 'zustand'
-import { createJSONStorage, persist } from 'zustand/middleware'
-
-export const AUDIO_SETTINGS_STORAGE_KEY = 'pascal-audio-settings'
-/**
- * Mute is each tab's own, so someone working in two projects can silence one and hear the other.
- * Under this key `sessionStorage` holds this tab's mute (kept across its reloads) and
- * `localStorage` the last choice made in any tab, which a new tab starts from.
- */
-export const AUDIO_MUTED_STORAGE_KEY = 'pascal-audio-muted'
-
-interface AudioState {
-  masterVolume: number
-  sfxVolume: number
-  radioVolume: number
-  isRadioPlaying: boolean
-  /** This tab's mute; the volumes are every tab's. */
-  muted: boolean
-  autoplay: boolean
-  setMasterVolume: (v: number) => void
-  setSfxVolume: (v: number) => void
-  setRadioVolume: (v: number) => void
-  setRadioPlaying: (v: boolean) => void
-  toggleRadioPlaying: () => void
-  setMuted: (muted: boolean) => void
-  toggleMute: () => void
-  setAutoplay: (v: boolean) => void
-}
-
-type StoredSettings = Pick<
-  AudioState,
-  'masterVolume' | 'sfxVolume' | 'radioVolume' | 'isRadioPlaying' | 'autoplay'
->
-
-type BrowserStorage = 'localStorage' | 'sessionStorage'
-
-// Storage can be missing (a test, a server render) or refuse access (site data blocked): the page
-// then keeps its choices in memory only.
-function readStored(storage: BrowserStorage, key: string) {
-  try {
-    return globalThis[storage]?.getItem(key) ?? null
-  } catch {
-    return null
-  }
-}
-
-function writeStored(storage: BrowserStorage, key: string, value: string) {
-  try {
-    globalThis[storage]?.setItem(key, value)
-  } catch {}
-}
-
-/** This tab's mute. A tab without one takes the last choice made in any tab, and keeps it. */
-function tabMuted(): boolean {
-  const own = readStored('sessionStorage', AUDIO_MUTED_STORAGE_KEY)
-  if (own !== null) return own === 'true'
-  const muted = readStored('localStorage', AUDIO_MUTED_STORAGE_KEY) === 'true'
-  writeStored('sessionStorage', AUDIO_MUTED_STORAGE_KEY, String(muted))
-  return muted
-}
-
-/** A mute chosen in this tab: this tab's, and where the next new tab starts. Open tabs keep theirs. */
-function chooseMuted(muted: boolean) {
-  writeStored('sessionStorage', AUDIO_MUTED_STORAGE_KEY, String(muted))
-  writeStored('localStorage', AUDIO_MUTED_STORAGE_KEY, String(muted))
-  return { muted }
-}
-
-// The settings as this tab last read, wrote or took from another tab. A save carries every
-// setting, so a save that changes none (a mute, which is this tab's own) is skipped.
-let heldSettings: string | null = null
-// Set while this tab takes another tab's volumes: that is no choice of its own to save back.
-let adopting = false
-
-const settingsStorage = createJSONStorage<StoredSettings>(() => ({
-  getItem: (key) => {
-    heldSettings = readStored('localStorage', key)
-    return heldSettings
-  },
-  setItem: (key, value) => {
-    if (value === heldSettings) return
-    heldSettings = value
-    if (!adopting) writeStored('localStorage', key, value)
-  },
-  removeItem: (key) => {
-    try {
-      globalThis.localStorage?.removeItem(key)
-    } catch {}
-  },
-}))
-
-const useAudio = create<AudioState>()(
-  persist(
-    (set) => ({
-      masterVolume: 70,
-      sfxVolume: 50,
-      radioVolume: 25,
-      isRadioPlaying: false,
-      muted: false,
-      autoplay: true,
-      setMasterVolume: (v) => set({ masterVolume: v }),
-      setSfxVolume: (v) => set({ sfxVolume: v }),
-      setRadioVolume: (v) => set({ radioVolume: v }),
-      setRadioPlaying: (v) => set({ isRadioPlaying: v }),
-      toggleRadioPlaying: () => set((state) => ({ isRadioPlaying: !state.isRadioPlaying })),
-      setMuted: (muted) => set(chooseMuted(muted)),
-      toggleMute: () => set((state) => chooseMuted(!state.muted)),
-      setAutoplay: (v) => set({ autoplay: v }),
-    }),
-    {
-      name: AUDIO_SETTINGS_STORAGE_KEY,
-      storage: settingsStorage,
-      partialize: ({ masterVolume, sfxVolume, radioVolume, isRadioPlaying, autoplay }) => ({
-        masterVolume,
-        sfxVolume,
-        radioVolume,
-        isRadioPlaying,
-        autoplay,
-      }),
-      // The settings once held one mute for every tab: whoever had muted stays muted, unless a tab
-      // has chosen since (a tab still on that build can write it again). The format is unchanged,
-      // so that build reads these settings back with only the mute gone.
-      merge: (persisted, current) => {
-        const { muted, ...settings } = (persisted ?? {}) as Partial<StoredSettings> & {
-          muted?: unknown
-        }
-        if (
-          typeof muted === 'boolean' &&
-          readStored('localStorage', AUDIO_MUTED_STORAGE_KEY) === null
-        ) {
-          writeStored('localStorage', AUDIO_MUTED_STORAGE_KEY, String(muted))
-        }
-        return { ...current, ...settings, muted: tabMuted() }
-      },
-    },
-  ),
-)
-
-/**
- * Another tab saved the settings: the volumes are every tab's, so this tab takes them at once, and
- * a later save of its own carries them. Its mute and whether its radio plays stay its own.
- */
-function adoptOtherTabSettings(event: StorageEvent) {
-  if (event.key !== AUDIO_SETTINGS_STORAGE_KEY || event.newValue === null) return
-  let stored: Partial<Record<keyof StoredSettings, unknown>> | undefined
-  try {
-    stored = JSON.parse(event.newValue)?.state
-  } catch {
-    return
-  }
-  const shared: Partial<StoredSettings> = {}
-  for (const key of ['masterVolume', 'sfxVolume', 'radioVolume'] as const) {
-    const value = stored?.[key]
-    if (typeof value === 'number') shared[key] = value
-  }
-  if (typeof stored?.autoplay === 'boolean') shared.autoplay = stored.autoplay
-  adopting = true
-  try {
-    useAudio.setState(shared)
-  } finally {
-    adopting = false
-  }
-}
-
-globalThis.addEventListener?.('storage', adoptOtherTabSettings)
-
-export default useAudio

package/src/store/use-first-person-hud.ts

@@ -1,40 +0,0 @@
-import { create } from 'zustand'
-
-export type WalkthroughInteract = { label: string; verb: string } | null
-
-export type FirstPersonHudState = {
-  floorLabel: string | null
-  zoneLabel: string | null
-  interact: WalkthroughInteract
-  setHud: (hud: Partial<Pick<FirstPersonHudState, 'floorLabel' | 'zoneLabel' | 'interact'>>) => void
-  reset: () => void
-}
-
-export const useFirstPersonHud = create<FirstPersonHudState>((set) => ({
-  floorLabel: null,
-  zoneLabel: null,
-  interact: null,
-  setHud: (hud) =>
-    set((state) => {
-      const floorLabel = hud.floorLabel === undefined ? state.floorLabel : hud.floorLabel
-      const zoneLabel = hud.zoneLabel === undefined ? state.zoneLabel : hud.zoneLabel
-      const interact = hud.interact === undefined ? state.interact : hud.interact
-
-      if (
-        floorLabel === state.floorLabel &&
-        zoneLabel === state.zoneLabel &&
-        interact?.label === state.interact?.label &&
-        interact?.verb === state.interact?.verb
-      ) {
-        return state
-      }
-
-      return { floorLabel, zoneLabel, interact }
-    }),
-  reset: () =>
-    set((state) =>
-      state.floorLabel === null && state.zoneLabel === null && state.interact === null
-        ? state
-        : { floorLabel: null, zoneLabel: null, interact: null },
-    ),
-}))

package/src/store/use-follow-pascal.test.ts

@@ -1,62 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test'
-import { FOLLOW_PASCAL_STORAGE_KEY, useFollowPascal } from './use-follow-pascal'
-
-// Follow Pascal's switch and its pause: touching the camera pauses it and offers "Resume following";
-// a new build starts it again; the switch itself is the person's, kept across sessions.
-beforeEach(() => {
-  useFollowPascal.setState({ on: true, paused: false, building: false })
-})
-
-describe('Follow Pascal', () => {
-  test('is on until the person turns it off, and turning it off clears a pause', () => {
-    expect(useFollowPascal.getState().on).toBe(true)
-    useFollowPascal.getState().pause()
-    expect(useFollowPascal.getState().paused).toBe(true)
-    useFollowPascal.getState().setOn(false)
-    expect(useFollowPascal.getState()).toMatchObject({ on: false, paused: false })
-  })
-
-  test('a pause waits for the person, and only matters while it is on', () => {
-    useFollowPascal.setState({ on: false })
-    useFollowPascal.getState().pause()
-    expect(useFollowPascal.getState().paused).toBe(false)
-    useFollowPascal.setState({ on: true })
-    useFollowPascal.getState().pause()
-    expect(useFollowPascal.getState().paused).toBe(true)
-    useFollowPascal.getState().resume()
-    expect(useFollowPascal.getState().paused).toBe(false)
-  })
-
-  test('a build that begins takes the camera again, even after a pause', () => {
-    useFollowPascal.getState().pause()
-    useFollowPascal.getState().beginBuild()
-    expect(useFollowPascal.getState()).toMatchObject({ paused: false, building: true })
-    useFollowPascal.getState().endBuild()
-    expect(useFollowPascal.getState().building).toBe(false)
-  })
-
-  test('only the switch is kept across sessions', () => {
-    const persisted = (
-      useFollowPascal as unknown as {
-        persist: { getOptions(): { partialize?: (state: unknown) => unknown; name?: string } }
-      }
-    ).persist.getOptions()
-    expect(persisted.name).toBe(FOLLOW_PASCAL_STORAGE_KEY)
-    expect(persisted.partialize?.({ on: false, paused: true, building: true })).toEqual({
-      on: false,
-    })
-  })
-
-  test('the pill offers itself only to a paused follower during a build', () => {
-    const shows = () => {
-      const { on, paused, building } = useFollowPascal.getState()
-      return on && paused && building
-    }
-    useFollowPascal.getState().beginBuild()
-    expect(shows()).toBe(false)
-    useFollowPascal.getState().pause()
-    expect(shows()).toBe(true)
-    useFollowPascal.getState().endBuild()
-    expect(shows()).toBe(false)
-  })
-})