@wandelbots/wandelbots-js-react-components 5.5.1 → 5.5.2

package/src/components/utils/interpolation.ts

@@ -1,380 +0,0 @@
-import React from "react"
-
-/**
- * Smooth value interpolation utility using spring physics with tension and friction.
- * Designed for React Three Fiber applications with smooth, natural animations.
- *
- * Features:
- * - Spring physics with configurable tension and friction
- * - Frame-rate independent using delta timing
- * - Handles irregular frame timing and rapid target updates
- * - Manual update() calls for useFrame integration (no automatic RAF loop)
- * - Direct mutation for performance
- *
- * @example
- * ```tsx
- * // Basic spring animation
- * const interpolator = new ValueInterpolator([0, 0, 0], {
- *   tension: 120, // Higher = faster, stiffer spring (default: 120)
- *   friction: 20, // Higher = more damping, less oscillation (default: 20)
- *   onChange: (values) => {
- *     robot.joints.forEach((joint, i) => {
- *       joint.rotation.y = values[i]
- *     })
- *   }
- * })
- *
- * interpolator.setTarget([1.5, -0.8, 2.1])
- *
- * // React Three Fiber usage
- * function MyComponent() {
- *   const [interpolator] = useInterpolation([0, 0, 0])
- *
- *   useFrame((state, delta) => {
- *     interpolator.update(delta)
- *   })
- *
- *   useEffect(() => {
- *     interpolator.setTarget([1, 2, 3])
- *   }, [])
- *
- *   return <mesh position={interpolator.getCurrentValues()} />
- * }
- * ```
- */
-
-export interface InterpolationOptions {
-  /** Spring tension (higher = faster, stiffer spring) - default: 120 */
-  tension?: number
-  /** Spring friction (higher = more damping, less oscillation) - default: 20 */
-  friction?: number
-  /** Minimum threshold to consider interpolation complete - default: 0.001 */
-  threshold?: number
-  /** Callback when values change during interpolation */
-  onChange?: (values: number[]) => void
-  /** Callback when interpolation reaches target values */
-  onComplete?: (values: number[]) => void
-}
-
-export class ValueInterpolator {
-  private currentValues: number[] = []
-  private targetValues: number[] = []
-  private previousTargetValues: number[] = []
-  private targetUpdateTime: number = 0
-  private animationId: number | null = null
-  private options: Required<InterpolationOptions>
-  private updateCount: number = 0 // Track how many updates have occurred
-
-  // Spring physics state
-  private velocities: number[] = []
-
-  constructor(
-    initialValues: number[] = [],
-    options: InterpolationOptions = {},
-  ) {
-    this.options = {
-      tension: 120,
-      friction: 20,
-      threshold: 0.001,
-      onChange: () => {},
-      onComplete: () => {},
-      ...options,
-    }
-
-    this.currentValues = [...initialValues]
-    this.targetValues = [...initialValues]
-    this.previousTargetValues = [...initialValues]
-    this.velocities = new Array(initialValues.length).fill(0)
-    this.targetUpdateTime = performance.now()
-    this.updateCount = 0
-  }
-
-  /**
-   * Update interpolation using spring physics
-   *
-   * Call this method every frame for smooth animation. In React Three Fiber,
-   * call from within useFrame callback with the provided delta time.
-   *
-   * @param delta - Time elapsed since last update in seconds (e.g., 1/60 ≈ 0.0167 for 60fps)
-   * @returns true when interpolation is complete (all values reached their targets)
-   */
-  update(delta: number = 1 / 60): boolean {
-    let hasChanges = false
-    let isComplete = true
-
-    // Increment update counter for initialization smoothing
-    this.updateCount++
-
-    // Limit delta to prevent physics instability during large frame drops
-    const clampedDelta = Math.min(delta, 1 / 15) // Maximum 66ms frame time allowed
-
-    // Apply gentle ramp-up for the first few frames to prevent initial jumpiness
-    // Only apply reduced force for the very first frame to prevent jarring starts
-    const initializationFactor =
-      this.updateCount === 1
-        ? 0.7 // Slightly reduced force only on the very first frame
-        : 1
-
-    for (let i = 0; i < this.currentValues.length; i++) {
-      const current = this.currentValues[i]
-      const target = this.targetValues[i]
-      const velocity = this.velocities[i]
-
-      // Calculate spring physics forces
-      const displacement = target - current
-      const springForce =
-        displacement * this.options.tension * initializationFactor
-      const dampingForce = velocity * this.options.friction
-
-      // Calculate acceleration from net force (F = ma, assuming mass = 1)
-      const acceleration = springForce - dampingForce
-
-      // Integrate physics using Verlet method for numerical stability
-      const newVelocity = velocity + acceleration * clampedDelta
-      const newValue = current + newVelocity * clampedDelta
-
-      // Determine if this value has settled (close to target with low velocity)
-      const isValueComplete =
-        Math.abs(displacement) < this.options.threshold &&
-        Math.abs(newVelocity) < this.options.threshold * 10
-
-      if (!isValueComplete) {
-        isComplete = false
-        // Continue spring animation
-        this.currentValues[i] = newValue
-        this.velocities[i] = newVelocity
-        hasChanges = true
-      } else {
-        // Snap exactly to target when close enough (prevents endless micro-movements)
-        if (this.currentValues[i] !== target) {
-          this.currentValues[i] = target
-          this.velocities[i] = 0
-          hasChanges = true
-        }
-      }
-    }
-
-    if (hasChanges) {
-      this.options.onChange(this.currentValues)
-    }
-
-    if (isComplete) {
-      this.options.onComplete(this.currentValues)
-    }
-
-    return isComplete
-  }
-
-  /**
-   * Set new target values for the interpolation to move towards
-   *
-   * Includes smart blending for very rapid target updates (faster than 120fps)
-   * to prevent jarring movements when targets change frequently.
-   */
-  setTarget(newValues: number[]): void {
-    const now = performance.now()
-    const timeSinceLastUpdate = now - this.targetUpdateTime
-
-    // Store previous target for smooth transitions
-    this.previousTargetValues = [...this.targetValues]
-    this.targetValues = [...newValues]
-    this.targetUpdateTime = now
-
-    // Reset update counter for smooth initialization when target changes
-    this.updateCount = 0
-
-    // Apply target blending for extremely rapid updates to prevent jarring jumps
-    // Only activates when targets change faster than 120fps (< 8ms between updates)
-    // AND this is not the first target being set (avoid blending initial target with initial values)
-    const isInitialTargetSet = this.previousTargetValues.every(
-      (val, i) => val === this.currentValues[i],
-    )
-
-    if (
-      timeSinceLastUpdate < 8 &&
-      timeSinceLastUpdate > 0 &&
-      this.previousTargetValues.length > 0 &&
-      !isInitialTargetSet // Don't blend if this is the first meaningful target change
-    ) {
-      // Blend between previous and new target based on time elapsed
-      const blendFactor = Math.min(timeSinceLastUpdate / 8, 1) // 0 to 1 over 8ms
-
-      for (let i = 0; i < this.targetValues.length; i++) {
-        const prev = this.previousTargetValues[i] || 0
-        const next = newValues[i] || 0
-
-        // Only blend significant changes to avoid unnecessary smoothing
-        const change = Math.abs(next - prev)
-        if (change > 0.1) {
-          this.targetValues[i] = prev + (next - prev) * blendFactor
-        }
-      }
-    }
-
-    // Ensure value and velocity arrays have matching lengths
-    while (this.currentValues.length < newValues.length) {
-      this.currentValues.push(newValues[this.currentValues.length])
-      this.velocities.push(0) // New values start with zero velocity
-    }
-    if (this.currentValues.length > newValues.length) {
-      this.currentValues = this.currentValues.slice(0, newValues.length)
-      this.velocities = this.velocities.slice(0, newValues.length)
-    }
-
-    // Does not start automatic interpolation - requires manual update() calls
-    // This design prevents conflicts when using with React Three Fiber's useFrame
-  }
-
-  /**
-   * Get a copy of all current interpolated values
-   */
-  getCurrentValues(): number[] {
-    return [...this.currentValues]
-  }
-
-  /**
-   * Get a single interpolated value by its array index
-   */
-  getValue(index: number): number {
-    return this.currentValues[index] ?? 0
-  }
-
-  /**
-   * Check if automatic interpolation is currently running
-   *
-   * This only tracks auto-interpolation started with startAutoInterpolation().
-   * Manual update() calls are not tracked by this method.
-   */
-  isInterpolating(): boolean {
-    return this.animationId !== null
-  }
-
-  /**
-   * Stop automatic interpolation if it's running
-   *
-   * This cancels the internal animation frame loop but does not affect
-   * manual update() calls.
-   */
-  stop(): void {
-    if (this.animationId !== null) {
-      cancelAnimationFrame(this.animationId)
-      this.animationId = null
-    }
-  }
-
-  /**
-   * Instantly set values without interpolation
-   */
-  setImmediate(values: number[]): void {
-    this.stop()
-    this.currentValues = [...values]
-    this.targetValues = [...values]
-    this.previousTargetValues = [...values]
-    this.velocities = new Array(values.length).fill(0) // Reset velocities
-    this.targetUpdateTime = performance.now()
-    this.updateCount = 0 // Reset update counter
-    this.options.onChange(this.currentValues)
-  }
-
-  /**
-   * Update interpolation options
-   */
-  updateOptions(newOptions: Partial<InterpolationOptions>): void {
-    this.options = { ...this.options, ...newOptions }
-  }
-
-  /**
-   * Start automatic interpolation with an animation loop
-   *
-   * This begins a requestAnimationFrame loop that calls update() automatically.
-   * For React Three Fiber components, prefer using manual update() calls
-   * within useFrame hooks instead.
-   */
-  startAutoInterpolation(): void {
-    this.startInterpolation()
-  }
-
-  /**
-   * Clean up all resources and stop any running animations
-   *
-   * This cancels any active animation frames and resets internal state.
-   * Call this when the component unmounts or is no longer needed.
-   */
-  destroy(): void {
-    this.stop()
-  }
-
-  private startInterpolation(): void {
-    if (this.animationId !== null) {
-      return // Already interpolating
-    }
-
-    this.animate()
-  }
-
-  private animate = (): void => {
-    // Use delta timing with a fallback for consistent automatic animations
-    const isComplete = this.update(1 / 60) // Simulate 60fps for auto-interpolation
-
-    if (!isComplete) {
-      this.animationId = requestAnimationFrame(this.animate)
-    } else {
-      this.animationId = null
-    }
-  }
-}
-
-/**
- * React hook for using the ValueInterpolator with useFrame
- *
- * This hook creates a ValueInterpolator that uses spring physics for smooth,
- * natural animations. Call interpolator.update(delta) in your useFrame callback.
- *
- * @example
- * ```tsx
- * function AnimatedMesh() {
- *   const [interpolator] = useInterpolation([0, 0, 0], {
- *     tension: 120, // Higher = faster spring
- *     friction: 20  // Higher = more damping
- *   })
- *   const meshRef = useRef()
- *
- *   useFrame((state, delta) => {
- *     if (interpolator.update(delta)) {
- *       // Animation complete
- *     }
- *     // Apply current values directly to mesh
- *     const [x, y, z] = interpolator.getCurrentValues()
- *     meshRef.current.position.set(x, y, z)
- *   })
- *
- *   return <mesh ref={meshRef} />
- * }
- * ```
- */
-export function useInterpolation(
-  initialValues: number[] = [],
-  options: InterpolationOptions = {},
-): [ValueInterpolator] {
-  const interpolatorRef = React.useRef<ValueInterpolator | null>(null)
-
-  // Initialize interpolator
-  if (!interpolatorRef.current) {
-    interpolatorRef.current = new ValueInterpolator(initialValues, options)
-  }
-
-  // Update options when they change
-  React.useEffect(() => {
-    interpolatorRef.current?.updateOptions(options)
-  }, [options])
-
-  // Cleanup on unmount
-  React.useEffect(() => {
-    return () => {
-      interpolatorRef.current?.destroy()
-    }
-  }, [])
-
-  // biome-ignore lint/style/noNonNullAssertion: pre-biome code
-  return [interpolatorRef.current!]
-}

package/src/core.ts

@@ -1,33 +0,0 @@
-// Core components without heavy dependencies (Three.js, Monaco, MUI X)
-export * from "./components/AppHeader"
-export * from "./components/CycleTimer"
-export * from "./components/DataGrid"
-export * from "./components/jogging/JoggingCartesianAxisControl"
-export * from "./components/jogging/JoggingJointValueControl"
-export * from "./components/jogging/JoggingPanel"
-export { JoggingStore } from "./components/jogging/JoggingStore"
-export * from "./components/jogging/PoseCartesianValues"
-export * from "./components/jogging/PoseJointValues"
-export * from "./components/LoadingCover"
-export * from "./components/LogPanel"
-export { LogStore } from "./components/LogStore"
-export * from "./components/LogViewer"
-export * from "./components/modal/NoMotionGroupModal"
-export * from "./components/ProgramControl"
-export * from "./components/ProgramStateIndicator"
-export * from "./components/RobotListItem"
-export * from "./components/RobotSetupReadinessIndicator"
-export * from "./components/safetyBar/SafetyBar"
-export * from "./components/SelectableFab"
-export * from "./components/TabBar"
-export * from "./components/Timer"
-export * from "./components/utils/hooks"
-export * from "./components/utils/interpolation"
-export * from "./components/VelocitySlider"
-export * from "./i18n/config"
-export * from "./lib/ConnectedMotionGroup"
-export * from "./lib/JoggerConnection"
-export * from "./lib/motionStateUpdate"
-export * from "./lib/MotionStreamConnection"
-export * from "./themes/themeTypes"
-export { createNovaMuiTheme } from "./themes/theming"

package/src/declarations.d.ts

@@ -1,10 +0,0 @@
-declare module "*.glb" {
-  const content: string
-  export default content
-}
-
-// Type for svg imports handled by vite config
-declare module "*.svg" {
-  const content: React.FunctionComponent<React.SVGAttributes<SVGElement>>
-  export default content
-}

package/src/env.d.ts

@@ -1,3 +0,0 @@
-/// <reference types="vite/client" />
-
-// Ensure ImportMeta.env types from Vite are available to TypeScript.

package/src/externalizeComponent.tsx

@@ -1,28 +0,0 @@
-/* biome-ignore-all lint/suspicious/noExplicitAny: pre-biome code */
-
-import type { FC } from "react"
-import { I18nextProvider } from "react-i18next"
-import { i18n } from "./i18n/config"
-
-/**
- * Our components require a certain context that may or may not
- * be provided by the user application; this wrapper ensures
- * they can be used either way.
- */
-export function externalizeComponent<T extends React.JSX.ElementType>(
-  Component: T,
-): T {
-  const WrappedComponent = ((props: T) => (
-    <NovaComponentsProvider>
-      <Component {...(props as any)} />
-    </NovaComponentsProvider>
-  )) as any
-
-  return WrappedComponent
-}
-
-const NovaComponentsProvider: FC<{ children: React.ReactNode }> = ({
-  children,
-}) => {
-  return <I18nextProvider i18n={i18n}>{children}</I18nextProvider>
-}

package/src/i18n/config.ts

@@ -1,26 +0,0 @@
-import type { i18n as I18NInstance } from "i18next"
-import i18next from "i18next"
-import LanguageDetector from "i18next-browser-languagedetector"
-import deJSON from "./locales/de/translations.json"
-import enJSON from "./locales/en/translations.json"
-
-const i18n: I18NInstance = i18next.createInstance()
-
-i18n.use(LanguageDetector).init({
-  supportedLngs: ["en", "de"],
-  resources: {
-    en: {
-      translations: enJSON,
-    },
-    de: {
-      translations: deJSON,
-    },
-  },
-  ns: ["translations"],
-  defaultNS: "translations",
-  detection: {
-    order: ["navigator", "htmlTag"],
-  },
-})
-
-export { i18n }

package/src/i18n/locales/de/translations.json

@@ -1,89 +0,0 @@
-{
-  "Jogging.Cartesian.Translation.velocityMmPerSec.lb": "{{amount}} mm/s",
-  "Jogging.Cartesian.Rotation.velocityDegPerSec.lb": "{{amount}}°/s",
-  "Jogging.Velocity.lb": "Geschwindigkeit",
-  "General.degree.variable": "{{amount}}°",
-  "General.mm.variable": "{{amount}} mm",
-  "Jogging.Blocked.ti": "Verbindung blockiert",
-  "Jogging.Blocked.lb": "Ein anderer Client kontrolliert das Jogging.",
-  "Jogging.Blocked.Reenable.bt": "Neu verbinden",
-  "Jogging.Cartesian.MotionType.lb": "Bewegungstyp",
-  "Jogging.Cartesian.Translation.bt": "Translation",
-  "Jogging.Cartesian.Rotation.bt": "Rotation",
-  "Jogging.Joints.JointValues.lb": "Gelenkwerte",
-  "Jogging.Increment.Continuous.dd": "Fortlaufend",
-  "Jogging.Cartesian.Orientation.lb": "Orientierung",
-  "Jogging.JointLimitsReached.lb": "Gelenkgrenzen für Gelenk {{jointNumbers}} erreicht",
-  "Jogging.Orientation.coordsys": "Roboterbasis",
-  "Jogging.Orientation.tool": "Werkzeug",
-  "SafetyBar.ActivationToggle.Activate.bt": "Aktivieren",
-  "SafetyBar.ActivationToggle.Activated.bt": "Aktiviert",
-  "SafetyBar.ActivationToggle.Activating.bt": "Wird aktiviert…",
-  "SafetyBar.ActivationToggle.Deactivating.bt": "Wird deaktiviert…",
-  "SafetyBar.ControllerType.Physical.lb": "Physisch",
-  "SafetyBar.ControllerType.Virtual.lb": "Virtuell",
-  "SafetyBar.MotionGroup.Physical.Explanation.lb": "<code>{{motionGroupId}}</code> ist ein physische Robotersteuerung. Für die Bewegung dieses Roboters sind <strong>Sicherheitsmaßnahmen</strong> aktiv.",
-  "SafetyBar.MotionGroup.Virtual.Explanation.lb": "<1>{{motionGroupId}}</1> ist eine virtuelle Robotersteuerung ohne physisches Gegenstück. Der Roboter kann ohne Sicherheitsmaßnahmen bewegt werden.",
-  "SafetyBar.OperationMode.Auto.Explanation.lb": "Automatischer Betriebsmodus der Robotersteuerung aktiv. Automatisierte Bewegung ohne manuelle Bestätigung freigegeben.",
-  "SafetyBar.OperationMode.Automatic.ti": "Automatisch",
-  "SafetyBar.OperationMode.Error.Explanation.lb": "Fehler beim Abrufen des Betriebsmodus. Originalhandbediengerät des Roboters verwenden, um Fehler zu lösen.",
-  "SafetyBar.OperationMode.Error.lb": "Fehler",
-  "SafetyBar.OperationMode.Manual.Explanation.lb": "Die Robotersteuerung befindet sich im manuellen Betriebsmodus. \nBei einem physischen Roboter bedeutet dies im Allgemeinen, dass ein Freigabeschalter gedrückt werden muss, damit sich der Roboter erfolgreich bewegen kann.",
-  "SafetyBar.OperationMode.Manual.lb": "Manuell",
-  "SafetyBar.OperationMode.ti": "Betriebsmodus",
-  "SafetyBar.SafetyState.Error.Explanation.lb": "Die Robotersteuerung ist in einen unerwarteten Sicherheitszustand eingetreten.",
-  "SafetyBar.SafetyState.Error.lb": "Fehler",
-  "SafetyBar.SafetyState.Estop.lb": "NOT-AUS",
-  "SafetyBar.SafetyState.ManualActionRequired.Explanation.lb": "Die Robotersteuerung ist in einen Sicherheitszustand eingetreten, der manuelle Maßnahmen zur Behebung erfordert.",
-  "SafetyBar.SafetyState.ManualActionRequired.lb": "Aktion erforderlich",
-  "SafetyBar.SafetyState.Normal.Explanation.lb": "Die Robotersteuerung befindet sich in einem sicheren Zustand. Roboterbewegungen sind möglich.",
-  "SafetyBar.SafetyState.Normal.lb": "Sicher",
-  "SafetyBar.SafetyState.Stop.Explanation.lb": "Die Robotersteuerung ist in einen Stoppzustand übergegangen. Bis der Stoppzustand aufgelöst ist, ist keine Bewegung mehr möglich.",
-  "SafetyBar.SafetyState.Stop.lb": "Stopp",
-  "SafetyBar.SafetyState.ti": "Sicherheitszustand",
-  "SafetyBar.StopState.Estop.Explanation.lb": "NOT-AUS aktiviert. NOT-AUS freischalten, um Roboter zu bewegen.",
-  "Jogging.Increment.hlb": "Schrittgröße",
-  "Jogging.CoordinateSystem.hlb": "Koordinatensystem",
-  "Jogging.Cartesian.bt": "Kartesisch",
-  "Jogging.Joints.bt": "Gelenke",
-  "Jogging.Velocity.bt": "Geschwindigkeit",
-  "CycleTimer.RemainingTime.lb": "Verbleibende Zeit",
-  "CycleTimer.OfTime.lb": "von {{time}}",
-  "CycleTimer.Time.lb": "{{time}}",
-  "CycleTimer.Error.lb": "Fehler",
-  "CycleTimer.WaitingForCycle.lb": "Warten auf Programmzyklus",
-  "CycleTimer.CycleTime.lb": "Zykluszeit",
-  "CycleTimer.Measuring.lb": "wird gemessen...",
-  "CycleTimer.Determined.lb": "bestimmt",
-  "Timer.error": "Fehler",
-  "ProgramControl.Start.bt": "Start",
-  "ProgramControl.Resume.bt": "Weiter",
-  "ProgramControl.Retry.bt": "Wiederholen",
-  "ProgramControl.Pause.bt": "Pause",
-  "ProgramControl.Stop.bt": "Stopp",
-  "ProgramStateIndicator.Preparing.lb": "Vorbereitung",
-  "ProgramStateIndicator.Starting.lb": "Startet",
-  "ProgramStateIndicator.Running.lb": "In Betrieb",
-  "ProgramStateIndicator.Pausing.lb": "Pausiert",
-  "ProgramStateIndicator.Stopping.lb": "Stoppt",
-  "ProgramStateIndicator.Completed.lb": "Abgeschlossen",
-  "ProgramStateIndicator.Failed.lb": "Fehlgeschlagen",
-  "ProgramStateIndicator.Error.lb": "Fehler",
-  "ProgramStateIndicator.EStop.lb": "Not-Aus",
-  "ProgramStateIndicator.Idle.lb": "Leerlauf",
-  "ProgramStateIndicator.Paused.lb": "Pausiert",
-  "ProgramStateIndicator.Ready.lb": "Bereit",
-  "ProgramStateIndicator.Stopped.lb": "Gestoppt",
-  "ProgramStateIndicator.Auto.lb": "Auto",
-  "ProgramStateIndicator.Manual.lb": "Manuell",
-  "ProgramStateIndicator.ManualT1.lb": "Manuell T1",
-  "ProgramStateIndicator.ManualT2.lb": "Manuell T2",
-  "RobotSetupReadinessIndicator.Ready.lb": "Bereit",
-  "RobotSetupReadinessIndicator.RobotDisconnected.lb": "Roboter getrennt",
-  "RobotSetupReadinessIndicator.CellOpen.lb": "Zelle offen",
-  "RobotSetupReadinessIndicator.EStop.lb": "Not-Stopp",
-  "RobotSetupReadinessIndicator.ManualMode.lb": "Manueller Modus",
-  "RobotSetupReadinessIndicator.PreconditionNotFulfilled.lb": "Voraussetzung nicht erfüllt",
-  "RobotCard.Runtime.lb": "Laufzeit",
-  "RobotCard.DriveToHome.bt": "Zur Home-Position fahren"
-}

package/src/i18n/locales/en/translations.json

@@ -1,90 +0,0 @@
-{
-  "Jogging.Cartesian.Translation.velocityMmPerSec.lb": "{{amount}} mm/s",
-  "Jogging.Cartesian.Rotation.velocityDegPerSec.lb": "{{amount}}°/s",
-  "Jogging.Velocity.lb": "Velocity",
-  "General.degree.variable": "{{amount}}°",
-  "General.mm.variable": "{{amount}} mm",
-  "Jogging.Blocked.ti": "Connection blocked",
-  "Jogging.Blocked.lb": "Another client is currently controlling the jogging.",
-  "Jogging.Blocked.Reenable.bt": "Reconnect",
-  "Jogging.Cartesian.MotionType.lb": "Motion type",
-  "Jogging.Cartesian.Translation.bt": "Translation",
-  "Jogging.Cartesian.Rotation.bt": "Rotation",
-  "Jogging.Joints.JointValues.lb": "Joint values",
-  "Jogging.Increment.Continuous.dd": "Continuous",
-  "Jogging.Cartesian.Orientation.lb": "Orientation",
-  "Jogging.Activating.lb": "Activating jogging",
-  "Jogging.JointLimitsReached.lb": "Joint limit reached for joint {{jointNumbers}}",
-  "Jogging.Orientation.coordsys": "Robot base",
-  "Jogging.Orientation.tool": "Tool",
-  "SafetyBar.ActivationToggle.Activate.bt": "Activate",
-  "SafetyBar.ActivationToggle.Activated.bt": "Activated",
-  "SafetyBar.ActivationToggle.Activating.bt": "Activating",
-  "SafetyBar.ActivationToggle.Deactivating.bt": "Deactivating",
-  "SafetyBar.ControllerType.Physical.lb": "Physical",
-  "SafetyBar.ControllerType.Virtual.lb": "Virtual",
-  "SafetyBar.MotionGroup.Physical.Explanation.lb": "<code>{{motionGroupId}}</code> is a physical robot controller. <strong>Safety precautions</strong> are active for the movement of this robot.",
-  "SafetyBar.MotionGroup.Virtual.Explanation.lb": "<1>{{motionGroupId}}</1> is a virtual robot controller with no physical counterpart. It can be freely manipulated without safety precautions.",
-  "SafetyBar.OperationMode.Auto.Explanation.lb": "Automatic operation mode active. Automated movement without manual confirmation enabled.",
-  "SafetyBar.OperationMode.Automatic.ti": "Automatic",
-  "SafetyBar.OperationMode.Error.Explanation.lb": "Failed to get operation mode. Use the original control panel to resolve the error.",
-  "SafetyBar.OperationMode.Error.lb": "Error",
-  "SafetyBar.OperationMode.Manual.Explanation.lb": "The robot controller is in manual operation mode. On a physical robot, this generally indicates that an enabling switch must be held for the robot to move successfully.",
-  "SafetyBar.OperationMode.Manual.lb": "Manual",
-  "SafetyBar.OperationMode.ti": "Operation mode",
-  "SafetyBar.SafetyState.Error.Explanation.lb": "The robot controller has entered an unexpected safety state.",
-  "SafetyBar.SafetyState.Error.lb": "Error",
-  "SafetyBar.SafetyState.Estop.lb": "E-Stop",
-  "SafetyBar.SafetyState.ManualActionRequired.Explanation.lb": "The robot controller has entered a safety state requiring manual action to resolve.",
-  "SafetyBar.SafetyState.ManualActionRequired.lb": "Action required",
-  "SafetyBar.SafetyState.Normal.Explanation.lb": "The robot controller is in a safe state. Robot movement is enabled.",
-  "SafetyBar.SafetyState.Normal.lb": "Safe",
-  "SafetyBar.SafetyState.Stop.Explanation.lb": "The robot controller has entered a stop state. Movement is no longer possible until the stop state is resolved.",
-  "SafetyBar.SafetyState.Stop.lb": "Stop",
-  "SafetyBar.SafetyState.ti": "Safety state",
-  "SafetyBar.StopState.Estop.Explanation.lb": "An emergency stop of the robot controller has been triggered. Movement of the robot is no longer possible until the estop is released.",
-  "Jogging.Increment.hlb": "Increment",
-  "Jogging.CoordinateSystem.hlb": "Coordinate system",
-  "Jogging.Cartesian.bt": "Cartesian",
-  "Jogging.Joints.bt": "Joints",
-  "Jogging.Velocity.bt": "Velocity",
-  "CycleTimer.RemainingTime.lb": "Time remaining",
-  "CycleTimer.OfTime.lb": "of {{time}}",
-  "CycleTimer.Time.lb": "{{time}}",
-  "CycleTimer.Error.lb": "Error",
-  "CycleTimer.WaitingForCycle.lb": "Waiting for program cycle",
-  "CycleTimer.CycleTime.lb": "Cycle Time",
-  "CycleTimer.Measuring.lb": "measuring...",
-  "CycleTimer.Determined.lb": "determined",
-  "Timer.error": "Error",
-  "ProgramControl.Start.bt": "Start",
-  "ProgramControl.Resume.bt": "Resume",
-  "ProgramControl.Retry.bt": "Retry",
-  "ProgramControl.Pause.bt": "Pause",
-  "ProgramControl.Stop.bt": "Stop",
-  "ProgramStateIndicator.Preparing.lb": "Preparing",
-  "ProgramStateIndicator.Starting.lb": "Starting",
-  "ProgramStateIndicator.Running.lb": "Running",
-  "ProgramStateIndicator.Pausing.lb": "Pausing",
-  "ProgramStateIndicator.Stopping.lb": "Stopping",
-  "ProgramStateIndicator.Completed.lb": "Completed",
-  "ProgramStateIndicator.Failed.lb": "Failed",
-  "ProgramStateIndicator.Error.lb": "Error",
-  "ProgramStateIndicator.EStop.lb": "E-Stop",
-  "ProgramStateIndicator.Idle.lb": "Idle",
-  "ProgramStateIndicator.Paused.lb": "Paused",
-  "ProgramStateIndicator.Ready.lb": "Ready",
-  "ProgramStateIndicator.Stopped.lb": "Stopped",
-  "ProgramStateIndicator.Auto.lb": "Auto",
-  "ProgramStateIndicator.Manual.lb": "Manual",
-  "ProgramStateIndicator.ManualT1.lb": "Manual T1",
-  "ProgramStateIndicator.ManualT2.lb": "Manual T2",
-  "RobotSetupReadinessIndicator.Ready.lb": "Ready",
-  "RobotSetupReadinessIndicator.RobotDisconnected.lb": "Robot disconnected",
-  "RobotSetupReadinessIndicator.CellOpen.lb": "Cell open",
-  "RobotSetupReadinessIndicator.EStop.lb": "E-Stop",
-  "RobotSetupReadinessIndicator.ManualMode.lb": "Manual mode",
-  "RobotSetupReadinessIndicator.PreconditionNotFulfilled.lb": "Precondition not fulfilled",
-  "RobotCard.Runtime.lb": "Runtime",
-  "RobotCard.DriveToHome.bt": "Drive to Home"
-}

package/src/icons/DropdownArrowIcon.tsx

@@ -1,12 +0,0 @@
-import SvgIcon, { type SvgIconProps } from "@mui/material/SvgIcon"
-export const DropdownArrowIcon = (props: SvgIconProps) => {
-  return (
-    <SvgIcon {...props} viewBox="0 0 10 8">
-      <path
-        d="M8.825 0.9125L5 4.72917L1.175 0.9125L0 2.0875L5 7.0875L10 2.0875L8.825 0.9125Z"
-        fill="currentColor"
-        fillOpacity="0.56"
-      />
-    </SvgIcon>
-  )
-}