@pascal-app/editor 1.1.0 → 1.1.1

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

@@ -1,49 +0,0 @@
-export const VIEWER_STAGE_MODES = ['3d', '2d', 'split'] as const
-
-export type ViewerStageMode = (typeof VIEWER_STAGE_MODES)[number]
-
-const THREE_D_MODES = ['3d'] as const
-const TWO_D_MODES = ['2d'] as const
-const SPLIT_MODES = ['split'] as const
-const THREE_D_TWO_D_MODES = ['3d', '2d'] as const
-const THREE_D_SPLIT_MODES = ['3d', 'split'] as const
-const TWO_D_SPLIT_MODES = ['2d', 'split'] as const
-
-export function normalizeViewerStageModes(
-  modes: readonly ViewerStageMode[] | undefined,
-): readonly ViewerStageMode[] {
-  if (!modes) return VIEWER_STAGE_MODES
-
-  const has3D = modes.includes('3d')
-  const has2D = modes.includes('2d')
-  const hasSplit = modes.includes('split')
-
-  if (has3D && has2D && hasSplit) return VIEWER_STAGE_MODES
-  if (has3D && has2D) return THREE_D_TWO_D_MODES
-  if (has3D && hasSplit) return THREE_D_SPLIT_MODES
-  if (has2D && hasSplit) return TWO_D_SPLIT_MODES
-  if (has2D) return TWO_D_MODES
-  if (hasSplit) return SPLIT_MODES
-  return THREE_D_MODES
-}
-
-export function resolveViewerStageMode(
-  mode: ViewerStageMode | undefined,
-  modes: readonly ViewerStageMode[],
-): ViewerStageMode {
-  return mode && modes.includes(mode) ? mode : (modes[0] ?? '3d')
-}
-
-export function resolveMobileViewerStageMode(
-  mode: ViewerStageMode,
-  modes: readonly ViewerStageMode[],
-): ViewerStageMode {
-  if (mode !== 'split') return mode
-  if (modes.includes('2d')) return '2d'
-  if (modes.includes('3d')) return '3d'
-  return 'split'
-}
-
-export function viewerStageIncludes3D(modes: readonly ViewerStageMode[]) {
-  return modes.includes('3d') || modes.includes('split')
-}

package/src/components/viewer/viewer-stage-switcher.tsx

@@ -1,97 +0,0 @@
-'use client'
-
-import { usePascalI18n } from '@pascal-app/core'
-import { Box, Columns2, Map as MapIcon } from 'lucide-react'
-import type { ReactNode } from 'react'
-import { cn } from '../../lib/utils'
-import { normalizeViewerStageModes, type ViewerStageMode } from './viewer-stage-modes'
-
-export type { ViewerStageMode } from './viewer-stage-modes'
-
-export type ViewerStageSwitcherProps = {
-  className?: string
-  hideSplitOnMobile?: boolean
-  mode: ViewerStageMode
-  modes?: readonly ViewerStageMode[]
-  onChange: (mode: ViewerStageMode) => void
-}
-
-export function ViewerStageSwitcher({
-  className,
-  hideSplitOnMobile = true,
-  mode,
-  modes,
-  onChange,
-}: ViewerStageSwitcherProps) {
-  const i18n = usePascalI18n()
-  const enabledModes = normalizeViewerStageModes(modes)
-
-  return (
-    <div
-      aria-label={i18n._({ id: 'viewer.stage.layout', message: 'Viewer layout' })}
-      className={cn(
-        'dark absolute top-4 left-1/2 z-30 flex -translate-x-1/2 items-center gap-1 rounded-full border border-white/10 bg-neutral-950/82 p-1 text-white shadow-elevation-4 backdrop-blur-xl',
-        className,
-      )}
-      role="group"
-    >
-      {enabledModes.includes('3d') ? (
-        <StageButton
-          active={mode === '3d'}
-          icon={<Box />}
-          label="3D"
-          onClick={() => onChange('3d')}
-        />
-      ) : null}
-      {enabledModes.includes('2d') ? (
-        <StageButton
-          active={mode === '2d'}
-          icon={<MapIcon />}
-          label="2D"
-          onClick={() => onChange('2d')}
-        />
-      ) : null}
-      {enabledModes.includes('split') ? (
-        <StageButton
-          active={mode === 'split'}
-          className={hideSplitOnMobile && enabledModes.length > 1 ? 'hidden md:flex' : undefined}
-          icon={<Columns2 />}
-          label={i18n._({ id: 'viewer.stage.split', message: 'Split' })}
-          onClick={() => onChange('split')}
-        />
-      ) : null}
-    </div>
-  )
-}
-
-function StageButton({
-  active,
-  className,
-  icon,
-  label,
-  onClick,
-}: {
-  active: boolean
-  className?: string
-  icon: ReactNode
-  label: string
-  onClick: () => void
-}) {
-  return (
-    <button
-      aria-pressed={active}
-      className={cn(
-        'flex h-8 items-center gap-1.5 rounded-full px-3 font-medium text-xs',
-        active
-          ? 'bg-white text-neutral-950 shadow-sm'
-          : 'text-neutral-300 transition-colors hover:bg-white/10 hover:text-white',
-        className,
-      )}
-      onClick={onClick}
-      type="button"
-    >
-      <span className="[&>svg]:size-3.5">{icon}</span>
-      {label}
-    </button>
-  )
-}

package/src/components/viewer/viewer-stage.test.tsx

@@ -1,47 +0,0 @@
-import { describe, expect, test } from 'bun:test'
-import { LevelNode } from '@pascal-app/core/schema'
-import { renderToStaticMarkup } from 'react-dom/server'
-import type { FloorplanPreviewScene } from './floorplan-preview'
-import { ViewerStage } from './viewer-stage'
-
-const level = LevelNode.parse({ id: 'level_ground', type: 'level' })
-const scene: FloorplanPreviewScene = { nodes: { [level.id]: level } }
-
-describe('ViewerStage', () => {
-  test('owns synchronized 2D and 3D composition by default', () => {
-    const markup = renderToStaticMarkup(
-      <ViewerStage mode="split" scene={scene} showLevelSelector={false}>
-        <div data-test-viewer-content="" />
-      </ViewerStage>,
-    )
-
-    expect(markup).toContain('data-pascal-viewer-stage="split"')
-    expect(markup).toContain('data-pascal-navigation-sync="on"')
-    expect(markup).toContain('data-pascal-viewer-3d="true"')
-    expect(markup).toContain('data-floorplan-preview=""')
-    expect(markup).toContain('viewBox="0 0 48 48"')
-  })
-
-  test('keeps a 2D-only embed free of a 3D canvas mount', () => {
-    const markup = renderToStaticMarkup(
-      <ViewerStage mode="2d" modes={['2d']} scene={scene} showLevelSelector={false} />,
-    )
-
-    expect(markup).toContain('data-pascal-viewer-stage="2d"')
-    expect(markup).not.toContain('data-pascal-viewer-3d')
-    expect(markup).toContain('data-floorplan-preview=""')
-  })
-
-  test('supports an explicit navigation synchronization opt-out', () => {
-    const markup = renderToStaticMarkup(
-      <ViewerStage
-        mode="split"
-        scene={scene}
-        showLevelSelector={false}
-        synchronizeNavigation={false}
-      />,
-    )
-
-    expect(markup).toContain('data-pascal-navigation-sync="off"')
-  })
-})

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

@@ -1,221 +0,0 @@
-'use client'
-
-import { type AnyNode, type AnyNodeId, useScene } from '@pascal-app/core'
-import { markPerfAction, useViewer } from '@pascal-app/viewer'
-import type { ReactNode } from 'react'
-import { useCallback, useEffect, useMemo, useState } from 'react'
-import { useShallow } from 'zustand/react/shallow'
-import { cn } from '../../lib/utils'
-import { FloorplanPreview, type FloorplanPreviewScene } from './floorplan-preview'
-import {
-  normalizeViewerStageModes,
-  resolveMobileViewerStageMode,
-  resolveViewerStageMode,
-  type ViewerStageMode,
-  viewerStageIncludes3D,
-} from './viewer-stage-modes'
-import { ViewerStageSwitcher } from './viewer-stage-switcher'
-
-export type ViewerStageProps = {
-  children?: ReactNode
-  className?: string
-  collapseSplitOnMobile?: boolean
-  compassHost?: Element | null
-  defaultMode?: ViewerStageMode
-  floorplanClassName?: string
-  levelId?: string | null
-  mode?: ViewerStageMode
-  modes?: readonly ViewerStageMode[]
-  onLevelChange?: (levelId: string) => void
-  onModeChange?: (mode: ViewerStageMode) => void
-  scene?: FloorplanPreviewScene | null
-  showCompass?: boolean
-  showLevelSelector?: boolean
-  showSwitcher?: boolean
-  switcherClassName?: string
-  synchronizeNavigation?: boolean
-  threeDClassName?: string
-}
-
-const EMPTY_LEVEL_IDS: string[] = []
-
-function levelNodeIds(nodes: Record<string, AnyNode>) {
-  return Object.values(nodes)
-    .filter((node) => node.type === 'level')
-    .sort(
-      (left, right) =>
-        ((left as { level?: number }).level ?? 0) - ((right as { level?: number }).level ?? 0),
-    )
-    .map((node) => node.id)
-}
-
-function selectViewerLevel(nodes: Record<string, AnyNode>, levelId: string) {
-  const level = nodes[levelId as AnyNodeId]
-  if (level?.type !== 'level') return
-  const building = level.parentId ? nodes[level.parentId as AnyNodeId] : null
-  const viewer = useViewer.getState()
-  viewer.setSelection({
-    buildingId: building?.type === 'building' ? building.id : null,
-    levelId: level.id,
-    selectedIds: [],
-    zoneId: null,
-  })
-}
-
-export function ViewerStage({
-  children,
-  className,
-  collapseSplitOnMobile = true,
-  compassHost,
-  defaultMode,
-  floorplanClassName,
-  levelId,
-  mode: controlledMode,
-  modes,
-  onLevelChange,
-  onModeChange,
-  scene,
-  showCompass = true,
-  showLevelSelector = true,
-  showSwitcher = true,
-  switcherClassName,
-  synchronizeNavigation = true,
-  threeDClassName,
-}: ViewerStageProps) {
-  const enabledModes = normalizeViewerStageModes(modes)
-  const [internalMode, setInternalMode] = useState(() =>
-    resolveViewerStageMode(defaultMode, enabledModes),
-  )
-  const activeMode = resolveViewerStageMode(controlledMode ?? internalMode, enabledModes)
-  const storeLevelIds = useScene(
-    useShallow((state) => (scene ? EMPTY_LEVEL_IDS : levelNodeIds(state.nodes))),
-  )
-  const externalLevelIds = useMemo(() => (scene ? levelNodeIds(scene.nodes) : null), [scene])
-  const levelIds = externalLevelIds ?? storeLevelIds
-  const selectedLevelId = useViewer((state) => state.selection.levelId)
-  const [internalLevelId, setInternalLevelId] = useState<string | null>(null)
-  const [internalCompassHost, setInternalCompassHost] = useState<HTMLDivElement | null>(null)
-  const resolvedCompassHost = compassHost ?? internalCompassHost
-  const floorplanEnabled = enabledModes.includes('2d') || enabledModes.includes('split')
-  const threeDEnabled = viewerStageIncludes3D(enabledModes)
-  const mountFloorplan = floorplanEnabled || showCompass
-
-  const requestMode = useCallback(
-    (nextMode: ViewerStageMode) => {
-      if (!enabledModes.includes(nextMode)) return
-      if (controlledMode === undefined) setInternalMode(nextMode)
-      onModeChange?.(nextMode)
-    },
-    [controlledMode, enabledModes, onModeChange],
-  )
-
-  useEffect(() => {
-    if (controlledMode !== undefined) {
-      if (controlledMode !== activeMode) onModeChange?.(activeMode)
-      return
-    }
-    if (internalMode !== activeMode) setInternalMode(activeMode)
-  }, [activeMode, controlledMode, internalMode, onModeChange])
-
-  useEffect(() => {
-    if (!collapseSplitOnMobile) return
-    const mediaQuery = window.matchMedia('(max-width: 767px)')
-    const resolveMode = () => {
-      if (!mediaQuery.matches) return
-      const nextMode = resolveMobileViewerStageMode(activeMode, enabledModes)
-      if (nextMode !== activeMode) requestMode(nextMode)
-    }
-    resolveMode()
-    mediaQuery.addEventListener('change', resolveMode)
-    return () => mediaQuery.removeEventListener('change', resolveMode)
-  }, [activeMode, collapseSplitOnMobile, enabledModes, requestMode])
-
-  const chooseLevel = useCallback(
-    (nextLevelId: string, notify = true) => {
-      setInternalLevelId(nextLevelId)
-      if (notify && nextLevelId !== useViewer.getState().selection.levelId) {
-        markPerfAction('level-switch', nextLevelId)
-      }
-      if (nextLevelId !== useViewer.getState().selection.levelId)
-        selectViewerLevel(scene?.nodes ?? useScene.getState().nodes, nextLevelId)
-      if (notify) onLevelChange?.(nextLevelId)
-    },
-    [onLevelChange, scene],
-  )
-
-  useEffect(() => {
-    if (activeMode === '3d' || levelIds.length === 0) return
-    const nextLevelId =
-      (levelId && levelIds.includes(levelId) ? levelId : null) ??
-      (selectedLevelId && levelIds.includes(selectedLevelId) ? selectedLevelId : null) ??
-      (internalLevelId && levelIds.includes(internalLevelId) ? internalLevelId : null) ??
-      levelIds[0] ??
-      null
-    if (nextLevelId) chooseLevel(nextLevelId, false)
-  }, [activeMode, chooseLevel, internalLevelId, levelId, levelIds, selectedLevelId])
-
-  return (
-    <div
-      className={cn('relative h-full w-full overflow-hidden bg-neutral-100', className)}
-      data-pascal-navigation-sync={synchronizeNavigation ? 'on' : 'off'}
-      data-pascal-viewer-stage={activeMode}
-    >
-      {showCompass && compassHost === undefined ? (
-        <div className="pointer-events-none absolute inset-0 z-30" ref={setInternalCompassHost} />
-      ) : null}
-
-      {showSwitcher && enabledModes.length > 1 ? (
-        <ViewerStageSwitcher
-          className={switcherClassName}
-          hideSplitOnMobile={collapseSplitOnMobile}
-          mode={activeMode}
-          modes={enabledModes}
-          onChange={requestMode}
-        />
-      ) : null}
-
-      <div
-        className={
-          activeMode === 'split'
-            ? 'absolute inset-0 grid grid-rows-2 md:grid-cols-2 md:grid-rows-1'
-            : 'absolute inset-0'
-        }
-      >
-        {threeDEnabled ? (
-          <div
-            className={cn(
-              activeMode === '2d'
-                ? 'pointer-events-none invisible absolute inset-0 h-full w-full'
-                : 'relative h-full min-h-0 w-full min-w-0',
-              threeDClassName,
-            )}
-            data-pascal-viewer-3d
-          >
-            {children}
-          </div>
-        ) : null}
-
-        {mountFloorplan ? (
-          <FloorplanPreview
-            className={cn(
-              activeMode === '3d'
-                ? 'hidden'
-                : activeMode === 'split'
-                  ? 'min-h-0 min-w-0 border-border border-t md:border-t-0 md:border-l'
-                  : 'h-full w-full',
-              floorplanClassName,
-            )}
-            compassHost={resolvedCompassHost}
-            levelId={levelId ?? internalLevelId}
-            navigationVisible={activeMode !== '3d'}
-            onLevelChange={chooseLevel}
-            scene={scene}
-            showCompass={showCompass}
-            showLevelSelector={showLevelSelector}
-            synchronizeNavigation={synchronizeNavigation}
-          />
-        ) : null}
-      </div>
-    </div>
-  )
-}

package/src/components/walkthrough-hud.tsx

@@ -1,193 +0,0 @@
-'use client'
-
-import { usePascalI18n } from '@pascal-app/core'
-import { type ReactNode, useMemo } from 'react'
-import { displayRoomName } from '../lib/room-name-messages'
-import { cn } from '../lib/utils'
-import type { WalkthroughInteract } from '../store/use-first-person-hud'
-
-export type { WalkthroughInteract } from '../store/use-first-person-hud'
-
-/** A control shown in the HUD's key strip: its keys (as printed on the keycaps) and what they do. */
-export type WalkthroughHint = { keys: readonly string[]; action: string }
-
-export type WalkthroughHudProps = {
-  floorLabel?: string | null
-  zoneLabel?: string | null
-  interact?: WalkthroughInteract
-  /** Movement controls listed before the cursor and exit pills. */
-  hints?: readonly WalkthroughHint[]
-  /** Pointer lock temporarily released (OS screenshot) — the pill flips to
-   *  "Click to resume" and lets clicks fall through to the canvas. */
-  suspended?: boolean
-  onExit?: () => void
-  children?: ReactNode
-}
-
-/** The centered walkthrough pointer: a dot that grows into a green ring over
- *  an interactable (door / window / elevator). Also mounted by the snapshot
- *  capture overlay so walk / drone framing keeps the same E-to-open pointer. */
-export function WalkthroughCrosshair({ interact }: { interact: WalkthroughInteract }) {
-  return (
-    <div className="pointer-events-none absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2">
-      <div
-        className={cn(
-          'rounded-full transition-all duration-150',
-          interact
-            ? 'h-4 w-4 border-2 border-emerald-400 bg-emerald-400/10'
-            : 'h-1.5 w-1.5 bg-white/80 shadow-[0_0_2px_rgba(0,0,0,0.6)]',
-        )}
-      />
-    </div>
-  )
-}
-
-export function WalkthroughHud({
-  floorLabel,
-  zoneLabel,
-  interact = null,
-  hints,
-  suspended = false,
-  onExit,
-  children,
-}: WalkthroughHudProps) {
-  const kbdClass = 'rounded border border-border/60 bg-white/10 px-1.5 py-0.5 font-mono text-[10px]'
-  const pillClass =
-    'flex items-center gap-1.5 rounded-full border border-border/40 bg-background/70 px-3 py-1 text-muted-foreground text-xs backdrop-blur-xl'
-  const exitContent = (
-    <>
-      <kbd className={kbdClass}>Esc</kbd>
-      to exit
-    </>
-  )
-
-  return (
-    <div className="dark pointer-events-none absolute inset-0 z-30 text-foreground">
-      <div className="absolute top-6 left-1/2 flex -translate-x-1/2 flex-col items-center gap-1.5">
-        {floorLabel && (
-          <div className="font-medium text-[10px] text-muted-foreground uppercase tracking-wider">
-            {floorLabel}
-          </div>
-        )}
-        {zoneLabel && (
-          <div className="corner-smooth rounded-full border border-border/40 bg-background/80 px-3 py-1 font-medium text-sm shadow-elevation-3 backdrop-blur-xl">
-            <WalkthroughZoneName name={zoneLabel} />
-          </div>
-        )}
-        {children}
-      </div>
-
-      <WalkthroughCrosshair interact={interact} />
-
-      <div className="absolute bottom-6 left-1/2 flex -translate-x-1/2 items-center gap-2">
-        {suspended ? (
-          <div className={pillClass}>
-            <span className="font-medium text-foreground">Click</span>
-            <span>or</span>
-            <kbd className={kbdClass}>P</kbd>
-            <span>to resume</span>
-            <span className="text-muted-foreground/60">·</span>
-            {exitContent}
-          </div>
-        ) : (
-          <>
-            {hints && hints.length > 0 ? (
-              <div className={pillClass}>
-                {hints.map(({ keys, action }, index) => (
-                  <span className="flex items-center gap-1.5" key={action}>
-                    {index > 0 && <span className="text-muted-foreground/60">·</span>}
-                    {keys.map((key, keyIndex) => (
-                      <span className="flex items-center gap-1" key={key}>
-                        {keyIndex > 0 && <span className="text-muted-foreground/60">/</span>}
-                        <kbd className={kbdClass}>{key}</kbd>
-                      </span>
-                    ))}
-                    {action}
-                  </span>
-                ))}
-              </div>
-            ) : null}
-            <div className={pillClass}>
-              <kbd className={kbdClass}>P</kbd>
-              free cursor
-            </div>
-            {onExit ? (
-              <button
-                className={cn(pillClass, 'pointer-events-auto')}
-                onClick={onExit}
-                type="button"
-              >
-                {exitContent}
-              </button>
-            ) : (
-              <div className={pillClass}>{exitContent}</div>
-            )}
-          </>
-        )}
-      </div>
-
-      {interact && (
-        <div className="absolute top-1/2 left-1/2 mt-7 -translate-x-1/2 whitespace-nowrap">
-          <div className="corner-smooth flex items-center gap-1.5 rounded-full border border-border/40 bg-background/80 px-3 py-1 text-xs shadow-elevation-3 backdrop-blur-xl">
-            <kbd className="rounded border border-border/60 bg-white/10 px-1.5 py-0.5 font-mono text-[10px]">
-              E
-            </kbd>
-            <span className="text-muted-foreground">or click to</span>
-            <span className="font-medium">
-              {interact.verb} {interact.label}
-            </span>
-          </div>
-        </div>
-      )}
-    </div>
-  )
-}
-
-/** The drone's key strip: the movement controls of the viewer's `DroneController`. */
-function useDroneHints(): readonly WalkthroughHint[] {
-  const i18n = usePascalI18n()
-  return useMemo(
-    () => [
-      {
-        keys: ['WASD'],
-        action: i18n._({ id: 'editor.walkthroughHud.drone.move', message: 'move' }),
-      },
-      {
-        keys: ['Space', 'E'],
-        action: i18n._({ id: 'editor.walkthroughHud.drone.up', message: 'up' }),
-      },
-      {
-        keys: ['Q'],
-        action: i18n._({ id: 'editor.walkthroughHud.drone.down', message: 'down' }),
-      },
-      {
-        keys: ['Shift'],
-        action: i18n._({ id: 'editor.walkthroughHud.drone.boost', message: 'boost' }),
-      },
-      {
-        keys: ['Alt'],
-        action: i18n._({ id: 'editor.walkthroughHud.drone.slow', message: 'slow' }),
-      },
-    ],
-    [i18n],
-  )
-}
-
-/** The walkthrough HUD for the drone: the plain pointer dot and the flight keys, no room or door prompts. */
-export function DroneHud({
-  suspended,
-  onExit,
-  children,
-}: Pick<WalkthroughHudProps, 'suspended' | 'onExit' | 'children'>) {
-  return (
-    <WalkthroughHud hints={useDroneHints()} onExit={onExit} suspended={suspended}>
-      {children}
-    </WalkthroughHud>
-  )
-}
-
-/** The room the walker is in, in the UI language (the scene keeps its stored name). */
-function WalkthroughZoneName({ name }: { name: string }) {
-  const i18n = usePascalI18n()
-  return displayRoomName(name, i18n)
-}

package/src/hooks/use-mobile.ts

@@ -1,19 +0,0 @@
-import * as React from 'react'
-
-const MOBILE_BREAKPOINT = 768
-
-const subscribe = (callback: () => void): (() => void) => {
-  const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`)
-  mql.addEventListener('change', callback)
-  return () => mql.removeEventListener('change', callback)
-}
-
-const getClientSnapshot = (): boolean => window.innerWidth < MOBILE_BREAKPOINT
-
-// Server can't know the viewport — assume desktop. React's useSyncExternalStore
-// reconciles the SSR / client snapshots without a hydration mismatch warning.
-const getServerSnapshot = (): boolean => false
-
-export function useIsMobile(): boolean {
-  return React.useSyncExternalStore(subscribe, getClientSnapshot, getServerSnapshot)
-}

package/src/i18n/level-name.ts

@@ -1,39 +0,0 @@
-import { getDefaultLevelName, levelDisplayNumber, type PascalI18n } from '@pascal-app/core'
-
-type DisplayLevel = {
-  level?: number
-  name?: string
-}
-
-/** The level's own name, or undefined while it carries a generated default. */
-export function authoredLevelName(level: DisplayLevel): string | undefined {
-  const levelNumber = level.level ?? 0
-  const name = level.name?.trim()
-  return name && name !== `Level ${levelNumber}` && name !== getDefaultLevelName(levelNumber)
-    ? name
-    : undefined
-}
-
-export function localizedLevelName(level: DisplayLevel, i18n: PascalI18n, locale: string): string {
-  const levelNumber = level.level ?? 0
-  const authoredName = authoredLevelName(level)
-  if (authoredName) return authoredName
-  if (levelNumber === 0) {
-    return i18n._({ id: 'core.level.groundFloor', message: 'Ground floor' })
-  }
-  if (levelNumber === -1) {
-    return i18n._({ id: 'core.level.basement', message: 'Basement' })
-  }
-  if (levelNumber < -1) {
-    return i18n._({
-      id: 'core.level.basementNumber',
-      message: 'Basement {number}',
-      values: { number: -levelNumber },
-    })
-  }
-  return i18n._({
-    id: 'core.level.floorNumber',
-    message: 'Floor {number}',
-    values: { number: levelDisplayNumber(levelNumber, locale) },
-  })
-}

package/src/i18n/scene-theme-name.ts

@@ -1,16 +0,0 @@
-import type { PascalI18n } from '@pascal-app/core'
-
-/** Display name of a built-in scene theme; unknown (plugin) themes keep their own name. */
-export function sceneThemeName(id: string, fallback: string, i18n: PascalI18n): string {
-  if (id === 'studio') return i18n._({ id: 'viewer.theme.studio', message: 'Studio' })
-  if (id === 'paper') return i18n._({ id: 'viewer.theme.paper', message: 'Paper' })
-  if (id === 'sunset') return i18n._({ id: 'viewer.theme.sunset', message: 'Sunset' })
-  if (id === 'overcast') return i18n._({ id: 'viewer.theme.overcast', message: 'Overcast' })
-  if (id === 'blueprint') return i18n._({ id: 'viewer.theme.blueprint', message: 'Blueprint' })
-  if (id === 'mediterranean')
-    return i18n._({ id: 'viewer.theme.mediterranean', message: 'Mediterranean' })
-  if (id === 'twilight') return i18n._({ id: 'viewer.theme.twilight', message: 'Twilight' })
-  if (id === 'night') return i18n._({ id: 'viewer.theme.night', message: 'Night' })
-  if (id === 'verdant') return i18n._({ id: 'viewer.theme.verdant', message: 'Verdant' })
-  return fallback
-}