@pascal-app/editor 1.1.0 → 1.1.2

package/src/components/viewer/viewer-rooms.tsx

@@ -1,248 +0,0 @@
-'use client'
-
-import {
-  type AnyNode,
-  buildUnitReport,
-  polygonInteriorPoint,
-  roomFloorElevation,
-  sceneRegistry,
-  useLocale,
-  usePascalI18n,
-  useScene,
-  type ZoneNode,
-} from '@pascal-app/core'
-import { SelectionCallout, useViewer } from '@pascal-app/viewer'
-import { useCallback, useEffect, useMemo } from 'react'
-import { Vector3 } from 'three'
-import { useShallow } from 'zustand/react/shallow'
-import { resolveRoomAssemblyHeights } from '../../lib/room-assembly-overlay'
-import { describeZoneOutline, type RoomSelectionRecord } from '../../lib/room-selection'
-import {
-  selectViewerRoom,
-  type ViewerSource,
-  viewerRooms,
-  zoneLabel,
-} from '../../lib/viewer-selection'
-import { RoomAssemblyMesh } from '../editor/room-highlight'
-import {
-  formatRoomArea,
-  RoomLabelAnchor3D,
-  type RoomLabelEntry,
-  RoomPillChip,
-  RoomPillDetail,
-  RoomPillsLayer3D,
-  roomLabelEntries,
-  roomLabelsVisible,
-  useFadePresence,
-} from '../editor/room-labels'
-
-/**
- * Rooms on every viewer surface, as the editor shows them: the editor's pills
- * on the current floor while nothing but the floor is selected, and the
- * editor's room highlight on the selected or hovered room (or a focused
- * unit's rooms). Zones draw no tinted volume here, and their meshes are not
- * mounted at all, so they never catch a click.
- */
-export function ViewerRooms({ source }: { source: ViewerSource }) {
-  const i18n = usePascalI18n()
-  useEffect(() => {
-    const before = useViewer.getState().showZones
-    useViewer.getState().setShowZones(false)
-    return () => useViewer.getState().setShowZones(before)
-  }, [])
-  const { levelId, zoneId, selectedIds } = useViewer(
-    useShallow((s) => ({
-      levelId: s.selection.levelId,
-      zoneId: s.selection.zoneId,
-      selectedIds: s.selection.selectedIds,
-    })),
-  )
-  const focusedUnitId = useViewer((s) => s.focusedUnitId)
-  const hoveredId = useViewer((s) => s.hoveredId)
-  const walkthrough = useViewer((s) => s.walkthroughMode)
-  const { nodes } = source
-
-  const pillsShown =
-    !!levelId &&
-    !walkthrough &&
-    roomLabelsVisible({
-      phase: 'building',
-      mode: 'select',
-      scopeIdle: true,
-      room: null,
-      zoneId,
-      focusedUnitId,
-      isCaptureMode: false,
-      isThumbnailCapture: false,
-      selectedTypes: selectedIds.map((id) => nodes[id]?.type),
-    })
-
-  // The layer stays mounted through its fade-out, like the editor's.
-  const pillsPresent = useFadePresence(pillsShown)
-
-  const rooms = useMemo(() => (levelId ? viewerRooms(levelId, nodes) : []), [levelId, nodes])
-  const entries = useMemo(() => {
-    if (!levelId) return []
-    const zones = Object.values(nodes).filter(
-      (node): node is ZoneNode =>
-        node.type === 'zone' && node.parentId === levelId && node.visible !== false,
-    )
-    return roomLabelEntries(
-      rooms.filter((room) => nodes[room.zoneId]?.visible !== false),
-      zones,
-    )
-  }, [levelId, nodes, rooms])
-
-  const highlighted = useMemo(() => {
-    if (walkthrough) return []
-    const ids = new Set<string>()
-    if (zoneId) ids.add(zoneId)
-    if (hoveredId && nodes[hoveredId]?.type === 'zone') ids.add(hoveredId)
-    const unit = focusedUnitId ? nodes[focusedUnitId] : undefined
-    if (unit?.type === 'unit') {
-      for (const member of buildUnitReport(unit, nodes).members)
-        if (member.levelId === levelId) ids.add(member.zoneId)
-    }
-    return [...ids].flatMap((id): RoomSelectionRecord[] => {
-      const zone = nodes[id]
-      if (zone?.type !== 'zone' || !zone.parentId) return []
-      const detected = viewerRooms(zone.parentId, nodes).find((room) => room.zoneId === id)
-      return [detected ?? describeZoneOutline(zone.parentId, zone)]
-    })
-  }, [focusedUnitId, hoveredId, levelId, nodes, walkthrough, zoneId])
-
-  return (
-    <>
-      {pillsPresent && levelId ? (
-        <RoomPillsLayer3D
-          entries={entries}
-          // A level of its own: nothing open or placed on one floor carries to the next.
-          key={levelId}
-          levelObject={() => source.objectFor(levelId)}
-          renderDetail={(entry) => {
-            const zone = nodes[entry.zoneId]
-            if (zone?.type !== 'zone') return null
-            return (
-              <RoomPillDetail
-                areaM2={entry.area}
-                color={zone.color}
-                name={zoneLabel(zone, i18n)}
-                view="3d"
-                zoneId={zone.id}
-              />
-            )
-          }}
-          renderLabel={(entry, anchors, elements) => {
-            const zone = nodes[entry.zoneId]
-            if (zone?.type !== 'zone') return null
-            return (
-              <RoomLabelAnchor3D
-                anchors={anchors}
-                entry={entry}
-                floorY={roomFloorElevation(nodes as Record<string, AnyNode>, entry.zoneId)}
-              >
-                <RoomPillChip
-                  areaM2={entry.area}
-                  color={zone.color}
-                  elements={elements}
-                  name={zoneLabel(zone, i18n)}
-                  onClick={() => selectViewerRoom(zone.id, source)}
-                  onHover={() => useViewer.getState().setHoveredId(zone.id)}
-                  onLeave={() => {
-                    if (useViewer.getState().hoveredId === zone.id)
-                      useViewer.getState().setHoveredId(null)
-                  }}
-                  view="3d"
-                  zoneId={zone.id}
-                />
-              </RoomLabelAnchor3D>
-            )
-          }}
-          shown={pillsShown}
-        />
-      ) : null}
-      {highlighted.map((room) => (
-        <ViewerRoomHighlight key={room.zoneId} room={room} source={source} />
-      ))}
-      {zoneId && levelId && !walkthrough && selectedIds.length === 0
-        ? (() => {
-            const entry = entries.find((candidate) => candidate.zoneId === zoneId)
-            const zone = nodes[zoneId]
-            const level = source.objectFor(levelId)
-            return entry && zone?.type === 'zone' && level ? (
-              <ViewerRoomCallout
-                entry={entry}
-                floorY={roomFloorElevation(nodes as Record<string, AnyNode>, zoneId)}
-                key={zoneId}
-                level={level}
-                name={zoneLabel(zone, i18n)}
-              />
-            ) : null
-          })()
-        : null}
-    </>
-  )
-}
-
-/** The selected room's callout: its name and area at a point inside it, and the close button. */
-function ViewerRoomCallout({
-  entry,
-  floorY,
-  level,
-  name,
-}: {
-  entry: RoomLabelEntry
-  floorY: number
-  level: NonNullable<ReturnType<ViewerSource['objectFor']>>
-  name: string
-}) {
-  const unit = useViewer((s) => s.unit)
-  const locale = useLocale()
-  const anchor = useMemo(() => {
-    const [x, z] = polygonInteriorPoint({ polygon: entry.polygon, holes: entry.holes })
-    return new Vector3(x, floorY + 0.05, z)
-  }, [entry.polygon, entry.holes, floorY])
-  const dismiss = useCallback(() => {
-    const { selection, setSelection } = useViewer.getState()
-    if (selection.zoneId === entry.zoneId) setSelection({ zoneId: null })
-  }, [entry.zoneId])
-  return (
-    <SelectionCallout
-      actions={[]}
-      anchor={anchor}
-      object={level}
-      onDismiss={dismiss}
-      subtitle={formatRoomArea(entry.area, unit, locale)}
-      title={name}
-    />
-  )
-}
-
-const parametricObject = (id: string) => sceneRegistry.nodes.get(id)
-
-/** `ViewerRooms` over the parametric scene store. */
-export function ParametricViewerRooms() {
-  const nodes = useScene((s) => s.nodes)
-  const source = useMemo<ViewerSource>(() => ({ nodes, objectFor: parametricObject }), [nodes])
-  return <ViewerRooms source={source} />
-}
-
-function ViewerRoomHighlight({
-  room,
-  source,
-}: {
-  room: RoomSelectionRecord
-  source: ViewerSource
-}) {
-  const heights = useMemo(
-    () => resolveRoomAssemblyHeights(room, source.nodes as Record<string, AnyNode>),
-    [room, source.nodes],
-  )
-  return (
-    <RoomAssemblyMesh
-      heights={heights}
-      levelObject={() => source.objectFor(room.key.levelId)}
-      room={room}
-    />
-  )
-}

package/src/components/viewer/viewer-scene-header.tsx

@@ -1,286 +0,0 @@
-'use client'
-
-import {
-  type LevelNode,
-  type PascalI18n,
-  sceneRegistry,
-  useLocale,
-  usePascalI18n,
-  useScene,
-} from '@pascal-app/core'
-import { markPerfAction, useViewer } from '@pascal-app/viewer'
-import { ArrowLeft, ChevronRight, Layers } from 'lucide-react'
-import Link from 'next/link'
-import { type ReactNode, useMemo } from 'react'
-import { localizedLevelName } from '../../i18n/level-name'
-import { cn } from '../../lib/utils'
-import {
-  applyViewerClick,
-  frameViewerNode,
-  roomOfObject,
-  selectViewerBuilding,
-  selectViewerLevel,
-  selectViewerRoom,
-  selectViewerUnit,
-  type ViewerCrumb,
-  type ViewerSidebarSection,
-  type ViewerSource,
-  viewerBreadcrumb,
-  viewerSidebarSections,
-} from '../../lib/viewer-selection'
-import { formatRoomArea } from '../editor/room-labels'
-
-export type ViewerSceneHeaderProps = {
-  projectName?: string | null
-  owner?: { username?: string | null } | null
-  onBack?: () => void
-  /** Fallback destination when no `onBack` handler is supplied. Must already be
-   *  sanitized by the caller. `null` shows no back arrow (an embedded viewer with
-   *  nowhere to go back to). */
-  backHref?: string | null
-  /** Extra row under the project info (e.g. like and duplicate actions). */
-  stats?: ReactNode
-  /** The scene the header navigates; the parametric scene store by default. */
-  source?: ViewerSource
-}
-
-function sectionTitle(kind: ViewerSidebarSection['kind'], i18n: PascalI18n): string {
-  if (kind === 'units') return i18n._({ id: 'viewer.header.units', message: 'Units' })
-  if (kind === 'rooms') return i18n._({ id: 'viewer.header.rooms', message: 'Rooms' })
-  return i18n._({ id: 'viewer.header.zones', message: 'Zones' })
-}
-
-const parametricObject = (id: string) => sceneRegistry.nodes.get(id)
-
-/**
- * The navigation of every viewer surface: the project card, the bar (building
- * › floor › room › element) and the floor list with, under the current floor,
- * its units, rooms and zones. A row or a crumb selects and frames; the canvas
- * selects in place (`lib/viewer-selection.ts`).
- */
-export const ViewerSceneHeader = ({
-  projectName,
-  owner,
-  onBack,
-  backHref = '/',
-  stats,
-  source: sourceProp,
-}: ViewerSceneHeaderProps) => {
-  const i18n = usePascalI18n()
-  const catalogVersion = i18n.getVersion()
-  const locale = useLocale()
-  const sceneNodes = useScene((s) => s.nodes)
-  const source = useMemo<ViewerSource>(
-    () => sourceProp ?? { nodes: sceneNodes, objectFor: parametricObject },
-    [sourceProp, sceneNodes],
-  )
-  const { nodes } = source
-  const selection = useViewer((s) => s.selection)
-  const focusedUnitId = useViewer((s) => s.focusedUnitId)
-  const unit = useViewer((s) => s.unit)
-
-  const crumbs = useMemo(
-    () =>
-      viewerBreadcrumb(selection, focusedUnitId, nodes, i18n, (nodeId, levelId) =>
-        roomOfObject(nodeId, levelId, source),
-      ),
-    [selection, focusedUnitId, nodes, source, i18n, locale, catalogVersion],
-  )
-  const buildingId = crumbs.find((crumb) => crumb.kind === 'building')?.id ?? null
-  // Highest first so the list reads top-down like a building section.
-  const levels = useMemo(() => {
-    const building = buildingId ? nodes[buildingId] : undefined
-    if (building?.type !== 'building') return []
-    return building.children
-      .map((id) => nodes[id])
-      .filter((node): node is LevelNode => node?.type === 'level')
-      .sort((a, b) => b.level - a.level)
-  }, [buildingId, nodes])
-  const sections = useMemo(
-    () => (selection.levelId ? viewerSidebarSections(selection.levelId, nodes, i18n) : []),
-    [selection.levelId, nodes, i18n, locale, catalogVersion],
-  )
-
-  const handleCrumb = (crumb: ViewerCrumb) => {
-    switch (crumb.kind) {
-      case 'building':
-        return selectViewerBuilding(source)
-      case 'level':
-        return selectViewerLevel(crumb.id, source)
-      case 'unit':
-        return selectViewerUnit(crumb.id, source)
-      case 'room':
-        return selectViewerRoom(crumb.id, source)
-      case 'node':
-        applyViewerClick({ nodeId: crumb.id, point: null }, nodes)
-        return frameViewerNode(crumb.id, source)
-    }
-  }
-
-  return (
-    <div className="dark absolute top-4 left-4 z-20 flex max-h-[calc(100%-7rem)] flex-col gap-3 text-foreground">
-      <div className="corner-smooth pointer-events-auto flex min-w-[200px] max-w-[min(28rem,calc(100vw-2rem))] flex-col overflow-hidden rounded-2xl border border-border/40 bg-background/95 shadow-elevation-4 backdrop-blur-xl transition-colors duration-200 ease-out">
-        {/* Project info + back */}
-        <div className="flex items-center gap-3 px-3 py-2.5">
-          {onBack ? (
-            <button
-              aria-label={i18n._({ id: 'viewer.header.back', message: 'Back' })}
-              className="flex h-7 w-7 shrink-0 items-center justify-center rounded-md transition-colors hover:bg-white/10"
-              onClick={onBack}
-              type="button"
-            >
-              <ArrowLeft className="h-4 w-4 text-muted-foreground" />
-            </button>
-          ) : backHref === null ? null : (
-            <Link
-              aria-label={i18n._({ id: 'viewer.header.back', message: 'Back' })}
-              className="flex h-7 w-7 shrink-0 items-center justify-center rounded-md transition-colors hover:bg-white/10"
-              href={backHref}
-              prefetch={false}
-            >
-              <ArrowLeft className="h-4 w-4 text-muted-foreground" />
-            </Link>
-          )}
-          <div className="min-w-0 flex-1">
-            <div className="truncate font-medium text-foreground text-sm">
-              {projectName || i18n._({ id: 'viewer.header.untitled', message: 'Untitled' })}
-            </div>
-            {owner?.username && (
-              <Link
-                className="text-muted-foreground text-xs transition-colors hover:text-foreground"
-                href={`/u/${owner.username}`}
-              >
-                @{owner.username}
-              </Link>
-            )}
-          </div>
-        </div>
-
-        {stats && (
-          <div className="flex items-center gap-1 border-border/40 border-t px-3 py-2">{stats}</div>
-        )}
-
-        {crumbs.length > 0 && (
-          <nav
-            aria-label={i18n._({ id: 'viewer.header.selection', message: 'Selection' })}
-            className="flex flex-wrap items-center gap-x-1.5 gap-y-1 border-border/40 border-t px-3 py-2 text-xs"
-            data-testid="viewer-breadcrumb"
-          >
-            {crumbs.map((crumb, index) => {
-              const isLast = index === crumbs.length - 1
-              return (
-                <span
-                  className="flex min-w-0 items-center gap-1.5"
-                  key={`${crumb.kind}:${crumb.id}`}
-                >
-                  {index > 0 && <ChevronRight className="h-3 w-3 text-muted-foreground/50" />}
-                  <button
-                    className={cn(
-                      'truncate transition-colors',
-                      isLast
-                        ? 'font-medium text-foreground'
-                        : 'text-muted-foreground hover:text-foreground',
-                    )}
-                    data-crumb={crumb.kind}
-                    onClick={() => handleCrumb(crumb)}
-                    type="button"
-                  >
-                    {crumb.label}
-                  </button>
-                </span>
-              )
-            })}
-          </nav>
-        )}
-      </div>
-
-      {levels.length > 0 && (
-        <div className="corner-smooth pointer-events-auto flex min-h-0 w-56 flex-col overflow-hidden rounded-2xl border border-border/40 bg-background/95 py-1 shadow-elevation-4 backdrop-blur-xl transition-colors duration-200 ease-out">
-          <span className="px-3 py-2 font-medium text-[10px] text-muted-foreground uppercase tracking-wider">
-            {i18n._({ id: 'viewer.header.levels', message: 'Levels' })}
-          </span>
-          <div className="flex min-h-0 flex-col overflow-y-auto">
-            {levels.map((lvl) => {
-              const isSelected = lvl.id === selection.levelId
-              return (
-                <div key={lvl.id}>
-                  <button
-                    className={cn(
-                      'group/row relative flex h-8 w-full cursor-pointer select-none items-center border-border/50 border-r border-r-transparent border-b px-3 text-sm transition-all duration-200',
-                      isSelected
-                        ? 'border-r-3 border-r-white bg-accent/50 text-foreground'
-                        : 'text-muted-foreground hover:bg-accent/30 hover:text-foreground',
-                    )}
-                    onClick={() => {
-                      if (!isSelected) markPerfAction('level-switch', lvl.id)
-                      selectViewerLevel(lvl.id, source)
-                    }}
-                    type="button"
-                  >
-                    <div className="flex min-w-0 flex-1 items-center gap-2">
-                      <span
-                        className={cn(
-                          'flex h-4 w-4 shrink-0 items-center justify-center transition-all duration-200',
-                          !isSelected && 'opacity-60 grayscale',
-                        )}
-                      >
-                        <Layers className="h-3.5 w-3.5" />
-                      </span>
-                      <div className="min-w-0 flex-1 truncate text-left">
-                        {localizedLevelName(lvl, i18n, locale)}
-                      </div>
-                    </div>
-                  </button>
-                  {isSelected &&
-                    sections.map((section) => (
-                      <div
-                        className="border-border/50 border-b pb-1"
-                        data-viewer-section={section.kind}
-                        key={section.kind}
-                      >
-                        <span className="block px-3 pt-2 pb-1 pl-9 font-medium text-[10px] text-muted-foreground uppercase tracking-wider">
-                          {sectionTitle(section.kind, i18n)}
-                        </span>
-                        {section.rows.map((row) => {
-                          const active =
-                            section.kind === 'units'
-                              ? row.id === focusedUnitId
-                              : row.id === selection.zoneId
-                          return (
-                            <button
-                              className={cn(
-                                'flex h-7 w-full cursor-pointer select-none items-center gap-2 pr-3 pl-9 text-left text-sm transition-colors',
-                                active
-                                  ? 'bg-accent/50 text-foreground'
-                                  : 'text-muted-foreground hover:bg-accent/30 hover:text-foreground',
-                              )}
-                              key={row.id}
-                              onClick={() =>
-                                section.kind === 'units'
-                                  ? selectViewerUnit(row.id, source)
-                                  : selectViewerRoom(row.id, source)
-                              }
-                              type="button"
-                            >
-                              <span
-                                className="h-2 w-2 shrink-0 rounded-full"
-                                style={{ backgroundColor: row.color }}
-                              />
-                              <span className="min-w-0 flex-1 truncate">{row.label}</span>
-                              <span className="shrink-0 font-mono text-[11px] text-muted-foreground tabular-nums">
-                                {formatRoomArea(row.areaM2, unit, locale)}
-                              </span>
-                            </button>
-                          )
-                        })}
-                      </div>
-                    ))}
-                </div>
-              )
-            })}
-          </div>
-        </div>
-      )}
-    </div>
-  )
-}

package/src/components/viewer/viewer-selection-manager.tsx

@@ -1,124 +0,0 @@
-'use client'
-
-import { type AnyNodeId, emitter, type NodeEvent, sceneRegistry, useScene } from '@pascal-app/core'
-import { useViewer } from '@pascal-app/viewer'
-import { useThree } from '@react-three/fiber'
-import { useEffect } from 'react'
-import { selectionModifiersFromEvent } from '../../lib/selection-routing'
-import {
-  applyViewerClick,
-  applyViewerHover,
-  viewerPickFromNodeEvent,
-} from '../../lib/viewer-selection'
-
-/**
- * Selection for a parametric viewer surface (the published viewer's fallback,
- * its embed, the editor's Preview): free-form and room-first, through the same
- * rules as the baked viewer. Mount it with `<Viewer selectionManager="custom">`.
- */
-export function ViewerSelectionManager() {
-  const gl = useThree((state) => state.gl)
-
-  useEffect(() => {
-    let clickHandled = false
-    let hoveredFrom: string | null = null
-    const pendingClicks = new Set<number>()
-
-    const onMove = (event: NodeEvent) => {
-      if (useViewer.getState().walkthroughMode) return
-      const pick = viewerPickFromNodeEvent(event, useScene.getState().nodes)
-      if (!pick) return
-      event.stopPropagation()
-      hoveredFrom = event.node.id
-      applyViewerHover(pick, useScene.getState().nodes)
-    }
-    const onLeave = (event: NodeEvent) => {
-      if (event.node.id !== hoveredFrom) return
-      hoveredFrom = null
-      useViewer.getState().setHoveredId(null)
-    }
-    const onClick = (event: NodeEvent) => {
-      if (useViewer.getState().walkthroughMode) return
-      const pick = viewerPickFromNodeEvent(event, useScene.getState().nodes)
-      if (!pick) return
-      event.stopPropagation()
-      clickHandled = true
-      applyViewerClick(
-        pick,
-        useScene.getState().nodes,
-        selectionModifiersFromEvent(event.nativeEvent),
-      )
-    }
-    // A click on nothing selectable clears the room and the element.
-    const onCanvasClick = (event: MouseEvent) => {
-      const viewer = useViewer.getState()
-      if (event.button !== 0 || viewer.walkthroughMode) return
-      if (viewer.cameraDragging || viewer.inputDragging) return
-      const frame = requestAnimationFrame(() => {
-        pendingClicks.delete(frame)
-        if (useViewer.getState().walkthroughMode) return
-        if (clickHandled) {
-          clickHandled = false
-          return
-        }
-        applyViewerClick(null, useScene.getState().nodes)
-      })
-      pendingClicks.add(frame)
-    }
-
-    emitter.on('node:move', onMove)
-    emitter.on('node:enter', onMove)
-    emitter.on('node:leave', onLeave)
-    emitter.on('node:click', onClick)
-    const canvas = gl.domElement
-    canvas.addEventListener('click', onCanvasClick)
-    return () => {
-      emitter.off('node:move', onMove)
-      emitter.off('node:enter', onMove)
-      emitter.off('node:leave', onLeave)
-      emitter.off('node:click', onClick)
-      canvas.removeEventListener('click', onCanvasClick)
-      for (const frame of pendingClicks) cancelAnimationFrame(frame)
-      useViewer.getState().setHoveredId(null)
-    }
-  }, [gl])
-
-  return <ViewerOutlineSync />
-}
-
-/** The selected elements and the hovered one, outlined (rooms highlight instead). */
-function ViewerOutlineSync() {
-  const selectedIds = useViewer((s) => s.selection.selectedIds)
-  const externalSelectedIds = useViewer((s) => s.externalSelectedIds)
-  const hoveredId = useViewer((s) => s.hoveredId)
-  const outliner = useViewer((s) => s.outliner)
-  const geometryRevision = useViewer((s) => s.geometryRevision)
-  const walkthrough = useViewer((s) => s.walkthroughMode)
-  const nodes = useScene((s) => s.nodes)
-
-  useEffect(() => {
-    void geometryRevision
-    outliner.selectedObjects.length = 0
-    outliner.hoveredObjects.length = 0
-    if (walkthrough) return
-    for (const id of new Set([...selectedIds, ...externalSelectedIds])) {
-      const object = sceneRegistry.nodes.get(id)
-      if (object) outliner.selectedObjects.push(object)
-    }
-    const hovered = hoveredId ? nodes[hoveredId as AnyNodeId] : undefined
-    if (hovered && hovered.type !== 'zone') {
-      const object = sceneRegistry.nodes.get(hovered.id)
-      if (object) outliner.hoveredObjects.push(object)
-    }
-  }, [selectedIds, externalSelectedIds, hoveredId, outliner, nodes, geometryRevision, walkthrough])
-
-  useEffect(
-    () => () => {
-      outliner.selectedObjects.length = 0
-      outliner.hoveredObjects.length = 0
-    },
-    [outliner],
-  )
-
-  return null
-}

package/src/components/viewer/viewer-stage-modes.test.ts

@@ -1,38 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import {
-  normalizeViewerStageModes,
-  resolveMobileViewerStageMode,
-  resolveViewerStageMode,
-  viewerStageIncludes3D,
-} from './viewer-stage-modes'
-
-describe('viewer stage modes', () => {
-  test('supports every ordered combination without duplicates', () => {
-    expect(normalizeViewerStageModes(['split', '3d', 'split'])).toEqual(['3d', 'split'])
-    expect(normalizeViewerStageModes(['2d'])).toEqual(['2d'])
-    expect(normalizeViewerStageModes([])).toEqual(['3d'])
-  })
-
-  test('reuses normalized combinations across inline prop arrays', () => {
-    expect(normalizeViewerStageModes(['split', '3d'])).toBe(
-      normalizeViewerStageModes(['3d', 'split']),
-    )
-  })
-
-  test('falls back to the first enabled mode', () => {
-    expect(resolveViewerStageMode('split', ['3d', '2d'])).toBe('3d')
-    expect(resolveViewerStageMode(undefined, ['2d', 'split'])).toBe('2d')
-  })
-
-  test('uses an enabled single-pane mode on mobile but preserves split-only embeds', () => {
-    expect(resolveMobileViewerStageMode('split', ['3d', 'split'])).toBe('3d')
-    expect(resolveMobileViewerStageMode('split', ['2d', 'split'])).toBe('2d')
-    expect(resolveMobileViewerStageMode('split', ['split'])).toBe('split')
-  })
-
-  test('does not require a GPU canvas for a 2D-only embed', () => {
-    expect(viewerStageIncludes3D(['2d'])).toBe(false)
-    expect(viewerStageIncludes3D(['split'])).toBe(true)
-    expect(viewerStageIncludes3D(['3d', '2d'])).toBe(true)
-  })
-})