@wandelbots/wandelbots-js-react-components 2.44.0-pr.feature-seperate-timer.383.59e079b → 2.44.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wandelbots/wandelbots-js-react-components",
-  "version": "2.44.0-pr.feature-seperate-timer.383.59e079b",
+  "version": "2.44.0",
   "description": "React UI toolkit for building applications on top of the Wandelbots platform",
   "type": "module",
   "sideEffects": false,
@@ -59,8 +59,8 @@
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.1.2",
-    "@storybook/addon-docs": "^9.1.6",
-    "@storybook/react-vite": "^9.1.6",
+    "@storybook/addon-docs": "^9.1.3",
+    "@storybook/react-vite": "^9.1.3",
     "@storybook/test-runner": "^0.23.0",
     "@svgr/rollup": "^8.1.0",
     "@testing-library/jest-dom": "^6.6.3",
@@ -72,7 +72,7 @@
     "@vitejs/plugin-react": "^4.3.4",
     "@wandelbots/nova-js": "^2.1.0",
     "add": "^2.0.6",
-    "eslint-plugin-storybook": "^9.1.6",
+    "eslint-plugin-storybook": "^9.1.3",
     "glob": "^11.0.1",
     "http-server": "^14.1.1",
     "husky": "^9.1.7",
@@ -95,7 +95,7 @@
     "rollup-plugin-peer-deps-external": "^2.2.4",
     "rollup-plugin-postcss": "^4.0.2",
     "semantic-release": "^24.2.3",
-    "storybook": "^9.1.6",
+    "storybook": "^9.1.3",
     "storybook-preset-inline-svg": "^1.0.1",
     "three": "^0.174.0",
     "three-stdlib": "^2.35.14",

package/src/components/CycleTimer/DefaultVariant.tsx

@@ -114,6 +114,7 @@ export const DefaultVariant = ({
               showLabels &&
               !hasError &&
               currentState !== "idle" &&
+              currentState !== "countup" &&
               currentState !== "success"
             }
             timeout={300}
@@ -276,6 +277,7 @@ export const DefaultVariant = ({
               showLabels &&
               !hasError &&
               currentState !== "idle" &&
+              currentState !== "countup" &&
               currentState !== "success"
             }
             timeout={300}

package/src/components/CycleTimer/SmallVariant.tsx

@@ -31,7 +31,7 @@ export const SmallVariant = ({
   } = animationState
 
   // Simple text-only mode for compact variant in certain states
-  if (compact && currentState === "idle") {
+  if (compact && (currentState === "countup" || currentState === "idle")) {
     return (
       <Box
         className={className}
@@ -72,7 +72,10 @@ export const SmallVariant = ({
       }}
     >
       {/* Animated progress ring icon */}
-      {!(currentState === "idle" && compact) && (
+      {!(
+        currentState === "countup" ||
+        (currentState === "idle" && compact)
+      ) && (
         <Box
           sx={{
             width: 20,

package/src/components/CycleTimer/index.tsx

@@ -8,18 +8,19 @@ import { useAnimations } from "./useAnimations"
 import { useTimerLogic } from "./useTimerLogic"
 
 /**
- * A circular gauge timer component for cycle-specific timing operations
+ * A circular gauge timer component that shows the remaining time of a cycle or counts up
  *
  * Features:
  * - Custom SVG circular gauge with 264px diameter and 40px thickness
- * - Multiple states: idle, measuring, measured, countdown, success
+ * - Multiple states: idle, measuring, measured, countdown, countup, success
  * - Idle state: shows "Waiting for program cycle" with transparent inner circle
  * - Measuring state: counts up with "Cycle Time" / "measuring..." labels
  * - Measured state: shows final time with "Cycle Time" / "determined" labels in pulsating green
  * - Countdown mode: shows remaining time prominently, counts down to zero
+ * - Count-up mode: shows elapsed time without special labels
  * - Success state: brief green flash after cycle completion
  * - Displays appropriate labels based on state
- * - Automatically counts down and triggers callback when reaching zero
+ * - Automatically counts down/up and triggers callback when reaching zero (countdown only)
  * - Full timer control: start, pause, resume functionality
  * - Support for starting with elapsed time (resume mid-cycle)
  * - Error state support: pauses timer and shows error styling (red color)
@@ -27,7 +28,7 @@ import { useTimerLogic } from "./useTimerLogic"
  * - Pulsating text animation for completed measuring state
  * - Fully localized with i18next
  * - Material-UI theming integration
- * - Small variant with animated progress icon (gauge border only) next to text
+ * - Small variant with animated progress icon (gauge border only) next to text or simple text-only mode
  */
 export const CycleTimer = externalizeComponent(
   observer(

package/src/components/CycleTimer/types.ts

@@ -3,11 +3,13 @@ export type CycleTimerState =
   | "measuring" // Counting up without max time, showing "Cycle Time" / "measuring..."
   | "measured" // Completed measuring state showing "Cycle Time" / "determined" with pulsating green text
   | "countdown" // Counting down with max time
+  | "countup" // Simple count up without special text
   | "success" // Brief success state after cycle completion
 
 export interface CycleTimerControls {
-  startNewCycle: (maxTimeSeconds: number, elapsedSeconds?: number) => void
+  startNewCycle: (maxTimeSeconds?: number, elapsedSeconds?: number) => void
   startMeasuring: (elapsedSeconds?: number) => void
+  startCountUp: (elapsedSeconds?: number) => void
   setIdle: () => void
   completeMeasuring: () => void
   pause: () => void

package/src/components/CycleTimer/useTimerLogic.ts

@@ -88,66 +88,114 @@ export const useTimerLogic = ({
     [autoStart, progressInterpolator],
   )
 
-  const startNewCycle = useCallback(
-    (maxTimeSeconds: number, elapsedSeconds: number = 0) => {
-      // Stop any running timer first to prevent conflicts
-      setTimerState((prev) => ({ ...prev, isRunning: false }))
-      startTimeRef.current = null
-
+  const startCountUp = useCallback(
+    (elapsedSeconds: number = 0) => {
+      const initialProgress = ((elapsedSeconds / 60) % 1) * 100
       setTimerState((prev) => ({
         ...prev,
-        currentState: "countdown",
-        maxTime: maxTimeSeconds,
+        currentState: "countup",
+        maxTime: null,
+        remainingTime: elapsedSeconds,
         isPausedState: false,
+        currentProgress: initialProgress, // Immediately set progress
       }))
       pausedTimeRef.current = 0
 
-      // Count-down mode
-      const remainingSeconds = Math.max(0, maxTimeSeconds - elapsedSeconds)
-      const initialProgress =
-        elapsedSeconds > 0 ? (elapsedSeconds / maxTimeSeconds) * 100 : 0
+      progressInterpolator.setImmediate([initialProgress]) // Use setImmediate for instant reset
 
+      if (autoStart) {
+        startTimeRef.current = Date.now() - elapsedSeconds * 1000
+        setTimerState((prev) => ({ ...prev, isRunning: true }))
+      } else {
+        startTimeRef.current = null
+      }
+    },
+    [autoStart, progressInterpolator],
+  )
+
+  const startNewCycle = useCallback(
+    (maxTimeSeconds?: number, elapsedSeconds: number = 0) => {
+      // Stop any running timer first to prevent conflicts
+      setTimerState((prev) => ({ ...prev, isRunning: false }))
+      startTimeRef.current = null
+
+      const newState = maxTimeSeconds !== undefined ? "countdown" : "countup"
       setTimerState((prev) => ({
         ...prev,
-        remainingTime: remainingSeconds,
-        currentProgress: initialProgress, // Immediately set progress
+        currentState: newState,
+        maxTime: maxTimeSeconds ?? null,
+        isPausedState: false,
       }))
+      pausedTimeRef.current = 0
 
-      progressInterpolator.setImmediate([initialProgress]) // Use setImmediate for instant reset
-
-      if (remainingSeconds === 0) {
-        setTimerState((prev) => ({ ...prev, isRunning: false }))
-        startTimeRef.current = null
-        if (onCycleEnd) {
-          queueMicrotask(() => onCycleEnd())
+      if (maxTimeSeconds !== undefined) {
+        // Count-down mode
+        const remainingSeconds = Math.max(0, maxTimeSeconds - elapsedSeconds)
+        const initialProgress =
+          elapsedSeconds > 0 ? (elapsedSeconds / maxTimeSeconds) * 100 : 0
+
+        setTimerState((prev) => ({
+          ...prev,
+          remainingTime: remainingSeconds,
+          currentProgress: initialProgress, // Immediately set progress
+        }))
+
+        progressInterpolator.setImmediate([initialProgress]) // Use setImmediate for instant reset
+
+        if (remainingSeconds === 0) {
+          setTimerState((prev) => ({ ...prev, isRunning: false }))
+          startTimeRef.current = null
+          if (onCycleEnd) {
+            queueMicrotask(() => onCycleEnd())
+          }
+        } else if (autoStart) {
+          setTimeout(() => {
+            startTimeRef.current = Date.now() - elapsedSeconds * 1000
+            setTimerState((prev) => ({ ...prev, isRunning: true }))
+          }, 0)
+        } else {
+          startTimeRef.current = null
         }
-      } else if (autoStart) {
-        setTimeout(() => {
-          startTimeRef.current = Date.now() - elapsedSeconds * 1000
-          setTimerState((prev) => ({ ...prev, isRunning: true }))
-        }, 0)
       } else {
-        startTimeRef.current = null
+        // Count-up mode
+        const initialProgress = ((elapsedSeconds / 60) % 1) * 100
+        setTimerState((prev) => ({
+          ...prev,
+          remainingTime: elapsedSeconds,
+          currentProgress: initialProgress, // Immediately set progress
+        }))
+
+        progressInterpolator.setImmediate([initialProgress]) // Use setImmediate for instant reset
+
+        if (autoStart) {
+          setTimeout(() => {
+            startTimeRef.current = Date.now() - elapsedSeconds * 1000
+            setTimerState((prev) => ({ ...prev, isRunning: true }))
+          }, 0)
+        } else {
+          startTimeRef.current = null
+        }
       }
     },
     [autoStart, onCycleEnd, progressInterpolator],
   )
 
   const completeMeasuring = useCallback(() => {
-    // Always trigger completion regardless of current state
-    setTimerState((prev) => ({
-      ...prev,
-      isRunning: false,
-      currentState: "measured",
-    }))
-    startTimeRef.current = null
+    if (timerState.currentState === "measuring") {
+      setTimerState((prev) => ({
+        ...prev,
+        isRunning: false,
+        currentState: "measured",
+      }))
+      startTimeRef.current = null
 
-    onStartPulsating(() => {
-      if (onMeasuringComplete) {
-        onMeasuringComplete()
-      }
-    })
-  }, [onStartPulsating, onMeasuringComplete])
+      onStartPulsating(() => {
+        if (onMeasuringComplete) {
+          onMeasuringComplete()
+        }
+      })
+    }
+  }, [timerState.currentState, onStartPulsating, onMeasuringComplete])
 
   const pause = useCallback(() => {
     if (startTimeRef.current && timerState.isRunning) {
@@ -268,6 +316,13 @@ export const useTimerLogic = ({
             }))
             const progress = ((elapsed / 60) % 1) * 100
             progressInterpolator.setTarget([progress])
+          } else if (timerState.currentState === "countup") {
+            setTimerState((prev) => ({
+              ...prev,
+              remainingTime: Math.floor(elapsed),
+            }))
+            const progress = ((elapsed / 60) % 1) * 100
+            progressInterpolator.setTarget([progress])
           }
 
           if (timerState.isRunning) {
@@ -320,6 +375,7 @@ export const useTimerLogic = ({
     controls: {
       startNewCycle,
       startMeasuring,
+      startCountUp,
       setIdle,
       completeMeasuring,
       pause,

package/src/components/CycleTimer/utils.ts

@@ -25,8 +25,8 @@ export const calculateProgress = (
     return Math.min(100, (elapsed / maxTime) * 100)
   }
 
-  if (currentState === "measuring") {
-    // Measuring mode: progress based on minute steps (0-100% per minute)
+  if (currentState === "measuring" || currentState === "countup") {
+    // Count-up modes: progress based on minute steps (0-100% per minute)
     return ((remainingTime / 60) % 1) * 100
   }
 
@@ -45,7 +45,7 @@ export const calculateExactProgress = (
     return Math.min(100, (totalElapsed / maxTime) * 100)
   }
 
-  if (currentState === "measuring") {
+  if (currentState === "measuring" || currentState === "countup") {
     return ((totalElapsed / 60) % 1) * 100
   }
 

package/src/components/ProgramControl.tsx

@@ -6,15 +6,9 @@ import { externalizeComponent } from "../externalizeComponent"
 
 export enum ProgramState {
   IDLE = "idle",
-  PREPARING = "preparing",
-  STARTING = "starting",
   RUNNING = "running",
-  PAUSING = "pausing",
   PAUSED = "paused",
   STOPPING = "stopping",
-  COMPLETED = "completed",
-  FAILED = "failed",
-  STOPPED = "stopped",
   ERROR = "error",
 }
 
@@ -58,7 +52,7 @@ interface ButtonConfig {
  * A control component for program execution with run, pause, and stop functionality.
  *
  * Features:
- * - State machine with idle, preparing, starting, running, pausing, paused, stopping, completed, failed, stopped, and error states
+ * - State machine with idle, running, paused, stopping, and error states
  * - Two variants: with_pause (3 buttons) and without_pause (2 buttons)
  * - Optional manual reset functionality
  * - Responsive design with 110px circular buttons
@@ -84,15 +78,12 @@ export const ProgramControl = externalizeComponent(
           run: {
             enabled:
               state === ProgramState.IDLE ||
-              state === ProgramState.STOPPED ||
               state === ProgramState.PAUSED ||
-              state === ProgramState.COMPLETED ||
-              state === ProgramState.FAILED ||
               state === ProgramState.ERROR,
             label:
               state === ProgramState.PAUSED
                 ? t("ProgramControl.Resume.bt")
-                : state === ProgramState.ERROR || state === ProgramState.FAILED
+                : state === ProgramState.ERROR
                   ? t("ProgramControl.Retry.bt")
                   : t("ProgramControl.Start.bt"),
             color: theme.palette.success.main,
@@ -106,11 +97,7 @@ export const ProgramControl = externalizeComponent(
           },
           stop: {
             enabled:
-              state === ProgramState.PREPARING ||
-              state === ProgramState.STARTING ||
-              state === ProgramState.RUNNING ||
-              state === ProgramState.PAUSING ||
-              state === ProgramState.PAUSED,
+              state === ProgramState.RUNNING || state === ProgramState.PAUSED,
             label: t("ProgramControl.Stop.bt"),
             color: theme.palette.error.main,
             onClick: onStop,
@@ -182,9 +169,6 @@ export const ProgramControl = externalizeComponent(
                   variant="contained"
                   disabled={
                     !config.enabled ||
-                    state === ProgramState.PREPARING ||
-                    state === ProgramState.STARTING ||
-                    state === ProgramState.PAUSING ||
                     (state === ProgramState.STOPPING && !requiresManualReset)
                   }
                   onClick={config.onClick}
@@ -195,9 +179,6 @@ export const ProgramControl = externalizeComponent(
                     backgroundColor: config.color,
                     opacity:
                       config.enabled &&
-                      state !== ProgramState.PREPARING &&
-                      state !== ProgramState.STARTING &&
-                      state !== ProgramState.PAUSING &&
                       !(state === ProgramState.STOPPING && !requiresManualReset)
                         ? 1
                         : 0.3,
@@ -205,9 +186,6 @@ export const ProgramControl = externalizeComponent(
                       backgroundColor: config.color,
                       opacity:
                         config.enabled &&
-                        state !== ProgramState.PREPARING &&
-                        state !== ProgramState.STARTING &&
-                        state !== ProgramState.PAUSING &&
                         !(
                           state === ProgramState.STOPPING &&
                           !requiresManualReset
@@ -231,18 +209,12 @@ export const ProgramControl = externalizeComponent(
                   sx={{
                     color:
                       config.enabled &&
-                      state !== ProgramState.PREPARING &&
-                      state !== ProgramState.STARTING &&
-                      state !== ProgramState.PAUSING &&
                       !(state === ProgramState.STOPPING && !requiresManualReset)
                         ? config.color
                         : theme.palette.text.disabled,
                     textAlign: "center",
                     opacity:
                       config.enabled &&
-                      state !== ProgramState.PREPARING &&
-                      state !== ProgramState.STARTING &&
-                      state !== ProgramState.PAUSING &&
                       !(state === ProgramState.STOPPING && !requiresManualReset)
                         ? 1
                         : 0.3,

package/src/components/ProgramStateIndicator.tsx

@@ -77,50 +77,20 @@ export const ProgramStateIndicator = externalizeComponent(
         // For normal safety states, check program state
         if (safetyState === "SAFETY_STATE_NORMAL") {
           switch (programState) {
-            case ProgramState.PREPARING:
-              return {
-                label: t("ProgramStateIndicator.Preparing.lb"),
-                color: theme.palette.warning.main,
-              }
-            case ProgramState.STARTING:
-              return {
-                label: t("ProgramStateIndicator.Starting.lb"),
-                color: theme.palette.warning.main,
-              }
             case ProgramState.RUNNING:
               return {
                 label: t("ProgramStateIndicator.Running.lb"),
                 color: theme.palette.success.main,
               }
-            case ProgramState.PAUSING:
-              return {
-                label: t("ProgramStateIndicator.Pausing.lb"),
-                color: theme.palette.warning.main,
-              }
             case ProgramState.PAUSED:
               return {
                 label: t("ProgramStateIndicator.Paused.lb"),
                 color: theme.palette.grey[600],
               }
             case ProgramState.STOPPING:
-              return {
-                label: t("ProgramStateIndicator.Stopping.lb"),
-                color: theme.palette.warning.main,
-              }
-            case ProgramState.COMPLETED:
-              return {
-                label: t("ProgramStateIndicator.Completed.lb"),
-                color: theme.palette.success.main,
-              }
-            case ProgramState.FAILED:
-              return {
-                label: t("ProgramStateIndicator.Failed.lb"),
-                color: theme.palette.error.main,
-              }
-            case ProgramState.STOPPED:
               return {
                 label: t("ProgramStateIndicator.Stopped.lb"),
-                color: theme.palette.grey[600],
+                color: theme.palette.error.main,
               }
             case ProgramState.ERROR:
               return {

package/src/components/jogging/PoseCartesianValues.tsx

@@ -1,41 +1,102 @@
-import { Button, Stack } from "@mui/material"
+import { Button, Stack, Typography } from "@mui/material"
 import { poseToWandelscriptString } from "@wandelbots/nova-js"
-import type { TcpPose } from "@wandelbots/nova-js/v1"
+import type {
+  ConnectedMotionGroup,
+  MotionGroupStateResponse,
+  MotionStreamConnection,
+} from "@wandelbots/nova-js/v1"
 import { observer } from "mobx-react-lite"
-import { useState } from "react"
-import { externalizeComponent } from "../../externalizeComponent"
+import { useRef, useState } from "react"
 import { CopyableText } from "../CopyableText"
+import { useAnimationFrame } from "../utils/hooks"
+
+/** Minimal interface for what PoseCartesianValues needs from motion stream */
+type MotionStateProvider = {
+  rapidlyChangingMotionState: MotionGroupStateResponse
+}
+
+/** Creates a motion state provider from either a MotionStreamConnection or ConnectedMotionGroup */
+function createMotionStateProvider(
+  motionStream?: MotionStreamConnection,
+  connectedMotionGroup?: ConnectedMotionGroup,
+): MotionStateProvider | undefined {
+  if (motionStream) {
+    return motionStream
+  }
+  if (connectedMotionGroup) {
+    return {
+      rapidlyChangingMotionState:
+        connectedMotionGroup.rapidlyChangingMotionState,
+    }
+  }
+  return undefined
+}
 
 export type PoseCartesianValuesProps = {
-  tcpPose: TcpPose
+  /** Either a MotionStreamConnection or ConnectedMotionGroup */
+  motionStream?: MotionStreamConnection
+  connectedMotionGroup?: ConnectedMotionGroup
   showCopyButton?: boolean
 }
 
-export const PoseCartesianValues = externalizeComponent(
-  observer(({ tcpPose, showCopyButton = false }: PoseCartesianValuesProps) => {
-    const [copyMessage, setCopyMessage] = useState<string | null>(null)
-    const poseString = poseToWandelscriptString(tcpPose)
+export const PoseCartesianValues = observer(
+  ({
+    motionStream,
+    connectedMotionGroup,
+    showCopyButton = false,
+  }: PoseCartesianValuesProps) => {
+    const poseHolderRef = useRef<HTMLDivElement>(null)
+    const [copyMessage, setCopyMessage] = useState("")
+
+    const activeMotionStream = createMotionStateProvider(
+      motionStream,
+      connectedMotionGroup,
+    )
+
+    if (!activeMotionStream) {
+      throw new Error(
+        "PoseCartesianValues requires either motionStream or connectedMotionGroup prop",
+      )
+    }
+
+    function getCurrentPoseString() {
+      if (!activeMotionStream) return ""
+      const tcpPose = activeMotionStream.rapidlyChangingMotionState.tcp_pose
+      if (!tcpPose) return ""
+      return poseToWandelscriptString(tcpPose)
+    }
 
     const handleCopy = async () => {
       try {
-        await navigator.clipboard.writeText(poseString)
+        await navigator.clipboard.writeText(getCurrentPoseString())
         setCopyMessage("Copied!")
-        setTimeout(() => setCopyMessage(null), 2000)
+        setTimeout(() => setCopyMessage(""), 2000)
       } catch {
         setCopyMessage("Copy failed")
-        setTimeout(() => setCopyMessage(null), 2000)
+        setTimeout(() => setCopyMessage(""), 2000)
       }
     }
 
+    useAnimationFrame(() => {
+      if (!poseHolderRef.current) {
+        return
+      }
+      const newPoseContent = getCurrentPoseString()
+      if (poseHolderRef.current.textContent === newPoseContent) {
+        return
+      }
+
+      poseHolderRef.current.textContent = newPoseContent
+    })
+
     return (
       <Stack
         direction="row"
         alignItems="center"
         spacing={1}
         sx={{ flexGrow: 1, minWidth: 0, overflow: "hidden" }}
-        data-testid="pose-cartesian-values"
       >
-        <CopyableText value={poseString} />
+        <CopyableText value={getCurrentPoseString()} ref={poseHolderRef} />
         {showCopyButton && (
           <Button
             variant="contained"
@@ -44,10 +105,15 @@ export const PoseCartesianValues = externalizeComponent(
             onClick={handleCopy}
             sx={{ flexShrink: 0 }}
           >
-            { copyMessage ? copyMessage : "Copy"}
+            Copy
           </Button>
         )}
+        {copyMessage && (
+          <Typography variant="caption" color="success.main">
+            {copyMessage}
+          </Typography>
+        )}
       </Stack>
     )
-  }),
+  },
 )