@pascal-app/editor 1.0.7 → 1.1.1

package/src/components/ui/primitives/popover.tsx

@@ -1,42 +0,0 @@
-'use client'
-
-import * as PopoverPrimitive from '@radix-ui/react-popover'
-import type * as React from 'react'
-
-import { cn } from '../../../lib/utils'
-
-function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>) {
-  return <PopoverPrimitive.Root data-slot="popover" {...props} />
-}
-
-function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>) {
-  return <PopoverPrimitive.Trigger data-slot="popover-trigger" {...props} />
-}
-
-function PopoverContent({
-  className,
-  align = 'center',
-  sideOffset = 4,
-  ...props
-}: React.ComponentProps<typeof PopoverPrimitive.Content>) {
-  return (
-    <PopoverPrimitive.Portal>
-      <PopoverPrimitive.Content
-        align={align}
-        className={cn(
-          'data-[state=closed]:fade-out-0 data-[state=open]:fade-in-0 data-[state=closed]:zoom-out-95 data-[state=open]:zoom-in-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-72 origin-(--radix-popover-content-transform-origin) rounded-md border bg-popover p-4 text-popover-foreground shadow-md outline-hidden data-[state=closed]:animate-out data-[state=open]:animate-in',
-          className,
-        )}
-        data-slot="popover-content"
-        sideOffset={sideOffset}
-        {...props}
-      />
-    </PopoverPrimitive.Portal>
-  )
-}
-
-function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>) {
-  return <PopoverPrimitive.Anchor data-slot="popover-anchor" {...props} />
-}
-
-export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor }

package/src/components/ui/primitives/switch.tsx

@@ -1,29 +0,0 @@
-'use client'
-
-import * as SwitchPrimitives from '@radix-ui/react-switch'
-import * as React from 'react'
-
-import { cn } from './../../../lib/utils'
-
-const Switch = React.forwardRef<
-  React.ElementRef<typeof SwitchPrimitives.Root>,
-  React.ComponentPropsWithoutRef<typeof SwitchPrimitives.Root>
->(({ className, ...props }, ref) => (
-  <SwitchPrimitives.Root
-    className={cn(
-      'peer inline-flex h-5 w-9 shrink-0 cursor-pointer items-center rounded-full border-2 border-transparent shadow-xs transition-colors focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 focus-visible:ring-offset-background disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=unchecked]:bg-input',
-      className,
-    )}
-    {...props}
-    ref={ref}
-  >
-    <SwitchPrimitives.Thumb
-      className={cn(
-        'pointer-events-none block h-4 w-4 rounded-full bg-background shadow-lg ring-0 transition-transform data-[state=checked]:translate-x-4 data-[state=unchecked]:translate-x-0',
-      )}
-    />
-  </SwitchPrimitives.Root>
-))
-Switch.displayName = SwitchPrimitives.Root.displayName
-
-export { Switch }

package/src/components/ui/primitives/tooltip.tsx

@@ -1,57 +0,0 @@
-'use client'
-
-import * as TooltipPrimitive from '@radix-ui/react-tooltip'
-import type * as React from 'react'
-
-import { cn } from '../../../lib/utils'
-
-function TooltipProvider({
-  delayDuration = 0,
-  ...props
-}: React.ComponentProps<typeof TooltipPrimitive.Provider>) {
-  return (
-    <TooltipPrimitive.Provider
-      data-slot="tooltip-provider"
-      delayDuration={delayDuration}
-      {...props}
-    />
-  )
-}
-
-function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>) {
-  return (
-    <TooltipProvider>
-      <TooltipPrimitive.Root data-slot="tooltip" {...props} />
-    </TooltipProvider>
-  )
-}
-
-function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>) {
-  return <TooltipPrimitive.Trigger data-slot="tooltip-trigger" {...props} />
-}
-
-function TooltipContent({
-  className,
-  sideOffset = 0,
-  children,
-  ...props
-}: React.ComponentProps<typeof TooltipPrimitive.Content>) {
-  return (
-    <TooltipPrimitive.Portal>
-      <TooltipPrimitive.Content
-        className={cn(
-          'fade-in-0 zoom-in-95 data-[state=closed]:fade-out-0 data-[state=closed]:zoom-out-95 data-[side=bottom]:slide-in-from-top-2 data-[side=left]:slide-in-from-right-2 data-[side=right]:slide-in-from-left-2 data-[side=top]:slide-in-from-bottom-2 z-50 w-fit origin-(--radix-tooltip-content-transform-origin) animate-in text-balance rounded-md bg-foreground px-3 py-1.5 font-barlow text-background text-xs data-[state=closed]:animate-out',
-          className,
-        )}
-        data-slot="tooltip-content"
-        sideOffset={sideOffset}
-        {...props}
-      >
-        {children}
-        <TooltipPrimitive.Arrow className="z-50 size-2.5 translate-y-[calc(-50%_-_2px)] rotate-45 rounded-[2px] bg-foreground fill-foreground" />
-      </TooltipPrimitive.Content>
-    </TooltipPrimitive.Portal>
-  )
-}
-
-export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider }

package/src/components/ui/scene-loader.tsx

@@ -1,73 +0,0 @@
-'use client'
-
-import { useEffect, useState } from 'react'
-import { cn } from '../../lib/utils'
-import { Button } from './primitives/button'
-
-const LOADERS = [
-  'pascal-loader-1',
-  'pascal-loader-2',
-  'pascal-loader-3',
-  'pascal-loader-4',
-  'pascal-loader-5',
-]
-
-interface SceneLoaderProps {
-  className?: string
-  fullScreen?: boolean
-}
-
-export function SceneLoader({ className, fullScreen = false }: SceneLoaderProps) {
-  const [loaderClass, setLoaderClass] = useState(LOADERS[0]!)
-
-  useEffect(() => {
-    // Pick a random loader on mount
-    setLoaderClass(LOADERS[Math.floor(Math.random() * LOADERS.length)] ?? LOADERS[0]!)
-  }, [])
-
-  return (
-    <div
-      className={cn(
-        'z-100 flex items-center justify-center bg-background/80 backdrop-blur-md transition-opacity duration-300',
-        fullScreen ? 'fixed inset-0' : 'absolute inset-0',
-        className,
-      )}
-    >
-      <div className={cn(loaderClass, 'text-foreground opacity-80')} />
-    </div>
-  )
-}
-
-interface SceneLoadFailedProps {
-  className?: string
-  onRetry: () => void
-}
-
-/**
- * Replaces the loader when the host could not deliver the scene. Rendered
- * INSTEAD of falling back to an empty default scene: a session that shows
- * scaffold nodes after a failed load autosaves that scaffold over the real
- * project (prod scene-wipe class, 2026-09-02).
- */
-export function SceneLoadFailed({ className, onRetry }: SceneLoadFailedProps) {
-  return (
-    <div
-      className={cn(
-        'z-100 flex flex-col items-center justify-center gap-4 bg-background/90 px-6 text-center backdrop-blur-md',
-        'absolute inset-0',
-        className,
-      )}
-      role="alert"
-    >
-      <div className="flex flex-col gap-1">
-        <p className="font-medium text-foreground text-sm">This project couldn't be loaded</p>
-        <p className="text-muted-foreground text-sm">
-          Nothing was changed. Check your connection and try again.
-        </p>
-      </div>
-      <Button className="rounded-full" onClick={onRetry} size="sm" type="button">
-        Try again
-      </Button>
-    </div>
-  )
-}

package/src/components/viewer/floorplan-compass-button.tsx

@@ -1,67 +0,0 @@
-'use client'
-
-import { usePascalI18n } from '@pascal-app/core'
-import type React from 'react'
-import { cn } from '../../lib/utils'
-import { Tooltip, TooltipContent, TooltipTrigger } from '../ui/primitives/tooltip'
-import { SKY_COMPASS_BOTTOM, useSkyPanel } from './sky-control'
-
-export type FloorplanCompassButtonProps = {
-  northRotationDeg: number
-  onAlignNorth: () => void
-  needleRef?: React.RefObject<SVGSVGElement | null>
-  /** Horizontal anchor; defaults to the bottom-left corner. */
-  style?: React.CSSProperties
-}
-
-export function FloorplanCompassButton({
-  northRotationDeg,
-  onAlignNorth,
-  needleRef,
-  style,
-}: FloorplanCompassButtonProps) {
-  const i18n = usePascalI18n()
-  // Beside the sky chip (not when moved to the plan's right corner), centre on the docks' row.
-  const besideSky = useSkyPanel((s) => s.hosts > 0) && style?.right === undefined
-  const label = i18n._({
-    id: 'viewer.floorplan.alignNorth',
-    message: 'Align view to north',
-  })
-  return (
-    <Tooltip>
-      <TooltipTrigger asChild>
-        <button
-          aria-label={label}
-          className={cn(
-            'group pointer-events-auto absolute bottom-3 z-30 flex h-8 w-8 items-center justify-center rounded-full border border-black/10 bg-white/85 shadow-sm backdrop-blur-md transition hover:bg-white hover:shadow-md dark:border-white/10 dark:bg-neutral-900/85 dark:hover:bg-neutral-900',
-            !style && 'left-3',
-          )}
-          style={besideSky ? { bottom: SKY_COMPASS_BOTTOM, ...style } : style}
-          onClick={(event) => {
-            event.preventDefault()
-            event.stopPropagation()
-            onAlignNorth()
-          }}
-          onPointerDown={(event) => {
-            event.stopPropagation()
-          }}
-          type="button"
-        >
-          <span className="relative flex h-6 w-6 items-center justify-center rounded-full bg-[#b8b8b8] shadow-inner dark:bg-neutral-700">
-            <svg
-              aria-hidden="true"
-              className="h-6 w-6"
-              ref={needleRef}
-              style={{ transform: `rotate(${northRotationDeg}deg)` }}
-              viewBox="0 0 48 48"
-            >
-              <path d="M24 4.5 31.5 25 24 21.5 16.5 25Z" fill="#f15b5b" />
-              <path d="M24 43.5 16.5 23 24 26.5 31.5 23Z" fill="#ffffff" />
-            </svg>
-          </span>
-        </button>
-      </TooltipTrigger>
-      <TooltipContent side="right">{label}</TooltipContent>
-    </Tooltip>
-  )
-}

package/src/components/viewer/floorplan-preview-geometry.test.ts

@@ -1,107 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import type { FloorplanGeometry } from '@pascal-app/core'
-import {
-  clientToFloorplanPoint,
-  getFloorplanBounds,
-  padFloorplanBounds,
-  panFloorplanViewBox,
-  scaleFloorplanViewBox,
-  scaleFloorplanViewBoxBetweenClients,
-} from './floorplan-preview-geometry'
-
-describe('floorplan preview bounds', () => {
-  test('composes nested translation and rotation', () => {
-    const geometry: FloorplanGeometry = {
-      kind: 'group',
-      transform: { translate: [10, 5], rotate: Math.PI / 2 },
-      children: [
-        {
-          kind: 'rect',
-          x: 0,
-          y: 0,
-          width: 4,
-          height: 2,
-        },
-      ],
-    }
-
-    expect(getFloorplanBounds([geometry])).toEqual({
-      minX: 8,
-      minY: 5,
-      maxX: 10,
-      maxY: 9,
-    })
-  })
-
-  test('includes image rotation and dimension baselines', () => {
-    const geometries: FloorplanGeometry[] = [
-      {
-        kind: 'image',
-        url: '/symbol.png',
-        center: [2, 3],
-        width: 4,
-        height: 2,
-        rotation: Math.PI / 2,
-      },
-      {
-        kind: 'dimension',
-        start: [-3, -2],
-        end: [3, -2],
-        dimensionStart: [-4, -1],
-        dimensionEnd: [4, -1],
-        offsetNormal: [0, -1],
-        offsetDistance: 1,
-        extensionOvershoot: 0.2,
-        text: '8 m',
-      },
-    ]
-
-    expect(getFloorplanBounds(geometries)).toEqual({
-      minX: -4,
-      minY: -2,
-      maxX: 4,
-      maxY: 5,
-    })
-  })
-
-  test('pads narrow plans by a usable minimum', () => {
-    expect(padFloorplanBounds({ minX: 0, minY: 0, maxX: 0, maxY: 0 })).toEqual({
-      minX: -0.75,
-      minY: -0.75,
-      maxX: 0.75,
-      maxY: 0.75,
-    })
-  })
-
-  test('maps clients through letterboxed SVG content', () => {
-    const viewBox = { x: 0, y: 0, width: 10, height: 10 }
-    const viewport = { left: 0, top: 0, width: 1000, height: 500 }
-
-    expect(clientToFloorplanPoint(viewBox, viewport, 250, 0)).toEqual([0, 0])
-    expect(clientToFloorplanPoint(viewBox, viewport, 750, 500)).toEqual([10, 10])
-    expect(panFloorplanViewBox(viewBox, viewport, [500, 250], [550, 250])).toEqual({
-      x: -1,
-      y: 0,
-      width: 10,
-      height: 10,
-    })
-  })
-
-  test('keeps the plan point beneath a moving pinch midpoint', () => {
-    const viewBox = { x: 0, y: 0, width: 10, height: 10 }
-    const viewport = { left: 0, top: 0, width: 1000, height: 500 }
-    const next = scaleFloorplanViewBoxBetweenClients(viewBox, 0.5, viewport, [500, 250], [600, 250])
-
-    expect(next).toEqual({ x: 1.5, y: 2.5, width: 5, height: 5 })
-    expect(clientToFloorplanPoint(next, viewport, 600, 250)).toEqual([5, 5])
-  })
-
-  test('clamps zoom without changing the view box aspect ratio', () => {
-    expect(scaleFloorplanViewBox({ x: 0, y: 0, width: 100, height: 1 }, 0.01)).toEqual({
-      x: 37.5,
-      y: 0.375,
-      width: 25,
-      height: 0.25,
-    })
-  })
-})

package/src/components/viewer/floorplan-preview-geometry.ts

@@ -1,281 +0,0 @@
-import type { FloorplanGeometry, FloorplanPoint } from '@pascal-app/core'
-
-export type FloorplanBounds = {
-  minX: number
-  minY: number
-  maxX: number
-  maxY: number
-}
-
-export type FloorplanViewBox = { x: number; y: number; width: number; height: number }
-
-export type FloorplanViewport = {
-  left: number
-  top: number
-  width: number
-  height: number
-}
-
-type PlanTransform = { tx: number; ty: number; rotation: number }
-
-const IDENTITY: PlanTransform = { tx: 0, ty: 0, rotation: 0 }
-const MIN_VIEWBOX_SIZE = 0.25
-const MAX_VIEWBOX_SIZE = 500
-
-function clientToViewBoxFraction(
-  viewBox: FloorplanViewBox,
-  viewport: FloorplanViewport,
-  clientX: number,
-  clientY: number,
-): FloorplanPoint {
-  const viewportWidth = Math.max(viewport.width, 1)
-  const viewportHeight = Math.max(viewport.height, 1)
-  const scale = Math.min(viewportWidth / viewBox.width, viewportHeight / viewBox.height)
-  const renderedWidth = viewBox.width * scale
-  const renderedHeight = viewBox.height * scale
-  const renderedLeft = viewport.left + (viewportWidth - renderedWidth) / 2
-  const renderedTop = viewport.top + (viewportHeight - renderedHeight) / 2
-  return [(clientX - renderedLeft) / renderedWidth, (clientY - renderedTop) / renderedHeight]
-}
-
-export function clientToFloorplanPoint(
-  viewBox: FloorplanViewBox,
-  viewport: FloorplanViewport,
-  clientX: number,
-  clientY: number,
-): FloorplanPoint {
-  const [fractionX, fractionY] = clientToViewBoxFraction(viewBox, viewport, clientX, clientY)
-  return [viewBox.x + fractionX * viewBox.width, viewBox.y + fractionY * viewBox.height]
-}
-
-export function scaleFloorplanViewBox(
-  viewBox: FloorplanViewBox,
-  factor: number,
-  anchorX = 0.5,
-  anchorY = 0.5,
-): FloorplanViewBox {
-  const minFactor = Math.max(MIN_VIEWBOX_SIZE / viewBox.width, MIN_VIEWBOX_SIZE / viewBox.height)
-  const maxFactor = Math.min(MAX_VIEWBOX_SIZE / viewBox.width, MAX_VIEWBOX_SIZE / viewBox.height)
-  const clampedFactor = Math.min(Math.max(factor, minFactor), maxFactor)
-  const width = viewBox.width * clampedFactor
-  const height = viewBox.height * clampedFactor
-  return {
-    x: viewBox.x + (viewBox.width - width) * anchorX,
-    y: viewBox.y + (viewBox.height - height) * anchorY,
-    width,
-    height,
-  }
-}
-
-export function scaleFloorplanViewBoxBetweenClients(
-  viewBox: FloorplanViewBox,
-  factor: number,
-  viewport: FloorplanViewport,
-  sourceClient: FloorplanPoint,
-  targetClient: FloorplanPoint,
-): FloorplanViewBox {
-  const sourcePoint = clientToFloorplanPoint(viewBox, viewport, sourceClient[0], sourceClient[1])
-  const [targetX, targetY] = clientToViewBoxFraction(
-    viewBox,
-    viewport,
-    targetClient[0],
-    targetClient[1],
-  )
-  const scaled = scaleFloorplanViewBox(viewBox, factor, 0, 0)
-  return {
-    ...scaled,
-    x: sourcePoint[0] - targetX * scaled.width,
-    y: sourcePoint[1] - targetY * scaled.height,
-  }
-}
-
-export function panFloorplanViewBox(
-  viewBox: FloorplanViewBox,
-  viewport: FloorplanViewport,
-  sourceClient: FloorplanPoint,
-  targetClient: FloorplanPoint,
-): FloorplanViewBox {
-  const sourcePoint = clientToFloorplanPoint(viewBox, viewport, sourceClient[0], sourceClient[1])
-  const targetPoint = clientToFloorplanPoint(viewBox, viewport, targetClient[0], targetClient[1])
-  return {
-    ...viewBox,
-    x: viewBox.x + sourcePoint[0] - targetPoint[0],
-    y: viewBox.y + sourcePoint[1] - targetPoint[1],
-  }
-}
-
-function applyTransform(point: FloorplanPoint, transform: PlanTransform): FloorplanPoint {
-  const cos = Math.cos(transform.rotation)
-  const sin = Math.sin(transform.rotation)
-  return [
-    point[0] * cos - point[1] * sin + transform.tx,
-    point[0] * sin + point[1] * cos + transform.ty,
-  ]
-}
-
-function composeTransform(
-  parent: PlanTransform,
-  child: NonNullable<Extract<FloorplanGeometry, { kind: 'group' }>['transform']>,
-): PlanTransform {
-  const translated = applyTransform(child.translate ?? [0, 0], parent)
-  return {
-    tx: translated[0],
-    ty: translated[1],
-    rotation: parent.rotation + (child.rotate ?? 0),
-  }
-}
-
-function includePoint(bounds: FloorplanBounds | null, point: FloorplanPoint): FloorplanBounds {
-  if (!bounds) return { minX: point[0], minY: point[1], maxX: point[0], maxY: point[1] }
-  return {
-    minX: Math.min(bounds.minX, point[0]),
-    minY: Math.min(bounds.minY, point[1]),
-    maxX: Math.max(bounds.maxX, point[0]),
-    maxY: Math.max(bounds.maxY, point[1]),
-  }
-}
-
-function includePoints(
-  bounds: FloorplanBounds | null,
-  points: readonly FloorplanPoint[],
-  transform: PlanTransform,
-): FloorplanBounds | null {
-  let next = bounds
-  for (const point of points) next = includePoint(next, applyTransform(point, transform))
-  return next
-}
-
-function geometryBounds(
-  geometry: FloorplanGeometry,
-  transform: PlanTransform,
-  bounds: FloorplanBounds | null,
-): FloorplanBounds | null {
-  switch (geometry.kind) {
-    case 'group': {
-      const nextTransform = geometry.transform
-        ? composeTransform(transform, geometry.transform)
-        : transform
-      return geometry.children.reduce(
-        (next, child) => geometryBounds(child, nextTransform, next),
-        bounds,
-      )
-    }
-    case 'polygon':
-    case 'polyline':
-    case 'hatch':
-      return includePoints(bounds, geometry.points, transform)
-    case 'rect':
-      return includePoints(
-        bounds,
-        [
-          [geometry.x, geometry.y],
-          [geometry.x + geometry.width, geometry.y],
-          [geometry.x + geometry.width, geometry.y + geometry.height],
-          [geometry.x, geometry.y + geometry.height],
-        ],
-        transform,
-      )
-    case 'circle': {
-      const center = applyTransform([geometry.cx, geometry.cy], transform)
-      return includePoints(
-        bounds,
-        [
-          [center[0] - geometry.r, center[1] - geometry.r],
-          [center[0] + geometry.r, center[1] + geometry.r],
-        ],
-        IDENTITY,
-      )
-    }
-    case 'line':
-    case 'hit-line':
-    case 'edge-handle':
-      return includePoints(
-        bounds,
-        [
-          [geometry.x1, geometry.y1],
-          [geometry.x2, geometry.y2],
-        ],
-        transform,
-      )
-    case 'text':
-      return includePoint(bounds, applyTransform([geometry.x, geometry.y], transform))
-    case 'image': {
-      const halfWidth = geometry.width / 2
-      const halfHeight = geometry.height / 2
-      const imageTransform = composeTransform(transform, {
-        translate: geometry.center,
-        rotate: geometry.rotation,
-      })
-      return includePoints(
-        bounds,
-        [
-          [-halfWidth, -halfHeight],
-          [halfWidth, -halfHeight],
-          [halfWidth, halfHeight],
-          [-halfWidth, halfHeight],
-        ],
-        imageTransform,
-      )
-    }
-    case 'endpoint-handle':
-    case 'midpoint-handle':
-    case 'move-handle':
-    case 'move-arrow':
-    case 'rotate-arrow':
-    case 'equal-spacing-badge':
-      return includePoint(bounds, applyTransform(geometry.point, transform))
-    case 'dimension-label':
-      return includePoint(bounds, applyTransform([geometry.cx, geometry.cy], transform))
-    case 'dimension':
-      return includePoints(
-        bounds,
-        [
-          geometry.start,
-          geometry.end,
-          geometry.dimensionStart ?? geometry.start,
-          geometry.dimensionEnd ?? geometry.end,
-        ],
-        transform,
-      )
-    case 'dimension-string':
-      return geometry.segments.reduce(
-        (next, segment) =>
-          includePoints(
-            next,
-            [
-              segment.start,
-              segment.end,
-              segment.dimensionStart ?? segment.start,
-              segment.dimensionEnd ?? segment.end,
-            ],
-            transform,
-          ),
-        bounds,
-      )
-    case 'path':
-      return bounds
-    default:
-      return bounds
-  }
-}
-
-export function getFloorplanBounds(
-  geometries: readonly FloorplanGeometry[],
-): FloorplanBounds | null {
-  return geometries.reduce(
-    (bounds, geometry) => geometryBounds(geometry, IDENTITY, bounds),
-    null as FloorplanBounds | null,
-  )
-}
-
-export function padFloorplanBounds(bounds: FloorplanBounds, ratio = 0.12): FloorplanBounds {
-  const width = Math.max(bounds.maxX - bounds.minX, 1)
-  const height = Math.max(bounds.maxY - bounds.minY, 1)
-  const padding = Math.max(Math.max(width, height) * ratio, 0.75)
-  return {
-    minX: bounds.minX - padding,
-    minY: bounds.minY - padding,
-    maxX: bounds.maxX + padding,
-    maxY: bounds.maxY + padding,
-  }
-}

package/src/components/viewer/floorplan-preview-navigation.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import {
-  cameraAzimuthFromFloorplanRotation,
-  floorplanRotationFromCameraAzimuth,
-  floorplanViewBoxFromNavigationPose,
-  nearestEquivalentDegrees,
-  visibleFloorplanViewWidth,
-} from './floorplan-preview-navigation'
-
-describe('floorplan preview navigation', () => {
-  test('keeps continuous compass rotations across the angle seam', () => {
-    expect(nearestEquivalentDegrees(-179, 179)).toBe(181)
-    expect(floorplanRotationFromCameraAzimuth((-179 * Math.PI) / 180, 179)).toBeCloseTo(181)
-  })
-
-  test('uses the same north-up azimuth convention as the editor', () => {
-    expect(cameraAzimuthFromFloorplanRotation(0)).toBe(0)
-    expect(cameraAzimuthFromFloorplanRotation(90)).toBeCloseTo(Math.PI / 2)
-  })
-
-  test('maps a camera pose to an aspect-correct centered view box', () => {
-    expect(
-      floorplanViewBoxFromNavigationPose(
-        {
-          source: '3d',
-          revision: 1,
-          target: [0, 0, 0],
-          azimuth: 0,
-          viewWidth: 20,
-        },
-        { x: 4, y: 3 },
-        0,
-        { width: 1000, height: 500 },
-      ),
-    ).toEqual({ x: -6, y: -2, width: 20, height: 10 })
-  })
-
-  test('reports the actual horizontal span for meet-preserved SVG view boxes', () => {
-    expect(
-      visibleFloorplanViewWidth({ x: 0, y: 0, width: 10, height: 10 }, { width: 200, height: 100 }),
-    ).toBe(20)
-  })
-})