@wandelbots/wandelbots-js-react-components 3.4.0-pr.feat-yaskawa-gp200s.437.5d50e5b → 3.4.0-pr.feat-add-yaskawa-gp200s.438.0503e4b

package/dist/wandelscript.cjs.js

@@ -1,2 +0,0 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./WandelscriptEditor-Dj7TBCkF.cjs");exports.WandelscriptEditor=t.WandelscriptEditor;
-//# sourceMappingURL=wandelscript.cjs.js.map

package/dist/wandelscript.cjs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wandelscript.cjs.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/wandelscript.d.ts

@@ -1,2 +0,0 @@
-export * from "./components/wandelscript-editor/WandelscriptEditor";
-//# sourceMappingURL=wandelscript.d.ts.map

package/dist/wandelscript.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wandelscript.d.ts","sourceRoot":"","sources":["../src/wandelscript.ts"],"names":[],"mappings":"AACA,cAAc,qDAAqD,CAAA"}

package/dist/wandelscript.es.js

@@ -1,5 +0,0 @@
-import { W as t } from "./WandelscriptEditor-DnJvITTA.js";
-export {
-  t as WandelscriptEditor
-};
-//# sourceMappingURL=wandelscript.es.js.map

package/dist/wandelscript.es.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"wandelscript.es.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/src/3d.ts

@@ -1,15 +0,0 @@
-// 3D viewport and Three.js-based components
-export { default as CollisionSceneRenderer } from "./components/3d-viewport/collider/CollisionSceneRenderer"
-export * from "./components/3d-viewport/PresetEnvironment"
-export * from "./components/3d-viewport/SafetyZonesRenderer"
-export * from "./components/3d-viewport/TrajectoryRenderer"
-export * from "./components/RobotCard"
-export * from "./components/robots/AxisConfig"
-export {
-  MANUFACTURER_HOME_CONFIGS,
-  extractManufacturer,
-  getDefaultHomeConfig,
-} from "./components/robots/manufacturerHomePositions"
-export * from "./components/robots/Robot"
-export { defaultGetModel } from "./components/robots/robotModelLogic"
-export * from "./components/robots/SupportedRobot"

package/src/components/jogging/JoggingBlocked.tsx

@@ -1,37 +0,0 @@
-import { Alert, AlertTitle, Backdrop, Button, Stack } from "@mui/material"
-import { observer } from "mobx-react-lite"
-import { useTranslation } from "react-i18next"
-import { type JoggingStore } from "./JoggingStore"
-
-export const JoggingBlocked = observer(({ store }: { store: JoggingStore }) => {
-  const { t } = useTranslation()
-
-  return (
-    <Backdrop
-      open={true}
-      sx={{
-        position: "absolute",
-        zIndex: (theme) => theme.zIndex.drawer + 1,
-        color: "#fff",
-        background: "rgba(15, 15, 15, 0.88)",
-        justifyContent: "flex-start",
-        alignItems: "flex-start",
-      }}
-    >
-      <Stack sx={{ m: 2, width: "100%" }}>
-        <Alert severity="error" sx={{ mb: 2 }}>
-          <AlertTitle>{t("Jogging.Blocked.ti")}</AlertTitle>
-          {t("Jogging.Blocked.lb")}
-        </Alert>
-
-        <Button
-          variant="contained"
-          color="secondary"
-          onClick={() => store.unblock()}
-        >
-          {t("Jogging.Blocked.Reenable.bt")}
-        </Button>
-      </Stack>
-    </Backdrop>
-  )
-})

package/src/components/utils/errorHandling.test.ts

@@ -1,41 +0,0 @@
-import axios, { AxiosError, AxiosHeaders } from "axios"
-import { expect, test } from "vitest"
-import { makeErrorMessage } from "./errorHandling"
-
-test("making useful error messages", async () => {
-  // Error objects take the message
-  const someCustomError = new Error("some custom error")
-  expect(makeErrorMessage(someCustomError)).toEqual("some custom error")
-
-  // Strings go through prefixed
-  expect(makeErrorMessage("some string")).toEqual(
-    'Unexpected error: "some string"',
-  )
-
-  // Random objects get serialized
-  expect(makeErrorMessage({ some: "object" })).toEqual(
-    'Unexpected error: {"some":"object"}',
-  )
-
-  // Axios errors with a response should include the response code
-  // and url - but not for 404, we use a friendly message for that
-  try {
-    await axios.get("http://example.com/doesnt-exist")
-    expect(true).toBe(false)
-  } catch (err) {
-    expect(makeErrorMessage(err)).toMatch(
-      "Failed to connect to the server. Please check your internet connection.",
-    )
-  }
-
-  // Not sure how to reproduce CORS errors naturally in vitest environment
-  // so let's create it manually
-  const networkError = new AxiosError("Network Error", "ERR_NETWORK", {
-    url: "http://example.com/some-cors-thing",
-    method: "post",
-    headers: new AxiosHeaders(),
-  })
-  expect(makeErrorMessage(networkError)).toEqual(
-    "Failed to connect to the server. Please check your internet connection.",
-  )
-})

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/JoggingJointRotationControl"
-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/lib/ConnectedMotionGroup.ts

@@ -1,444 +0,0 @@
-import {
-  tryParseJson,
-  type AutoReconnectingWebsocket,
-} from "@wandelbots/nova-js"
-import type {
-  DHParameter,
-  MotionGroupDescription,
-  MotionGroupState,
-  NovaClient,
-  OperationMode,
-  RobotControllerState,
-  SafetyStateType,
-} from "@wandelbots/nova-js/v2"
-import { makeAutoObservable, runInAction } from "mobx"
-import * as THREE from "three"
-import type { Vector3Simple } from "./JoggerConnection"
-import { jointValuesEqual, tcpMotionEqual } from "./motionStateUpdate"
-
-const MOTION_DELTA_THRESHOLD = 0.0001
-
-export type RobotTcpLike = {
-  id: string
-  readable_name: string
-  position: Vector3Simple
-  orientation: Vector3Simple
-}
-
-export type MotionGroupOption = {
-  selectionId: string
-}
-
-const EMPTY_DH_PARAMETER: DHParameter = {
-  a: 0,
-  d: 0,
-  alpha: 0,
-  theta: 0,
-  reverse_rotation_direction: false,
-}
-
-/**
- * Store representing the current state of a connected motion group.
- * API v2 version, not used yet in the components.
- */
-export class ConnectedMotionGroup {
-  static async connectMultiple(nova: NovaClient, motionGroupIds: string[]) {
-    return Promise.all(
-      motionGroupIds.map((motionGroupId) =>
-        ConnectedMotionGroup.connect(nova, motionGroupId),
-      ),
-    )
-  }
-
-  static async connect(nova: NovaClient, motionGroupId: string) {
-    const [_motionGroupIndex, controllerId] = motionGroupId.split("@") as [
-      string,
-      string,
-    ]
-
-    const controller =
-      await nova.api.controller.getCurrentRobotControllerState(controllerId)
-    const motionGroup = controller?.motion_groups.find(
-      (mg) => mg.motion_group === motionGroupId,
-    )
-    if (!controller || !motionGroup) {
-      throw new Error(
-        `Controller ${controllerId} or motion group ${motionGroupId} not found`,
-      )
-    }
-
-    const motionStateSocket = nova.openReconnectingWebsocket(
-      `/controllers/${controllerId}/motion-groups/${motionGroupId}/state-stream`,
-    )
-
-    // Wait for the first message to get the initial state
-    const firstMessage = await motionStateSocket.firstMessage()
-    const initialMotionState = tryParseJson(firstMessage.data)
-      ?.result as MotionGroupState
-
-    if (!initialMotionState) {
-      throw new Error(
-        `Unable to parse initial motion state message ${firstMessage.data}`,
-      )
-    }
-
-    console.log(
-      `Connected motion state websocket to motion group ${motionGroup.motion_group}. Initial state:\n  `,
-      initialMotionState,
-    )
-
-    // Check if robot is virtual or physical
-    const config = await nova.api.controller.getRobotController(
-      controller.controller,
-    )
-    const isVirtual = config.configuration.kind === "VirtualController"
-
-    // If there's a configured mounting, we need it to show the right
-    // position of the robot model
-    const description = await nova.api.motionGroup.getMotionGroupDescription(
-      controllerId,
-      motionGroup.motion_group,
-    )
-
-    // Find out what TCPs this motion group has (we need it for jogging)
-    // There are converted into a RobotTcpLike for easier use in the UI
-    const tcps: RobotTcpLike[] = Object.entries(description.tcps || {}).map(
-      ([id, tcp]) => ({
-        id,
-        readable_name: tcp.name,
-        position: tcp.pose.position as Vector3Simple,
-        orientation: tcp.pose.orientation as Vector3Simple,
-      }),
-    )
-
-    // Open the websocket to monitor controller state for e.g. e-stop
-    const controllerStateSocket = nova.openReconnectingWebsocket(
-      `/controllers/${controller.controller}/state-stream?response_rate=1000`,
-    )
-
-    // Wait for the first message to get the initial state
-    const firstControllerMessage = await controllerStateSocket.firstMessage()
-    const initialControllerState = tryParseJson(firstControllerMessage.data)
-      ?.result as RobotControllerState
-
-    if (!initialControllerState) {
-      throw new Error(
-        `Unable to parse initial controller state message ${firstControllerMessage.data}`,
-      )
-    }
-
-    console.log(
-      `Connected controller state websocket to controller ${controller.controller}. Initial state:\n  `,
-      initialControllerState,
-    )
-
-    return new ConnectedMotionGroup(
-      nova,
-      controller,
-      motionGroup,
-      initialMotionState,
-      motionStateSocket,
-      isVirtual,
-      tcps,
-      description,
-      initialControllerState,
-      controllerStateSocket,
-    )
-  }
-
-  connectedJoggingSocket: WebSocket | null = null
-  // biome-ignore lint/suspicious/noExplicitAny: legacy code
-  planData: any | null // tmp
-  joggingVelocity: number = 10
-
-  // Not mobx-observable as this changes very fast; should be observed
-  // using animation frames
-  rapidlyChangingMotionState: MotionGroupState
-
-  // Response rate on the websocket should be a bit slower on this one since
-  // we don't use the motion data
-  controllerState: RobotControllerState
-
-  /**
-   * Reflects activation state of the motion group / robot servos. The
-   * movement controls in the UI should only be enabled in the "active" state
-   */
-  activationState: "inactive" | "activating" | "deactivating" | "active" =
-    "inactive"
-
-  constructor(
-    readonly nova: NovaClient,
-    readonly controller: RobotControllerState,
-    readonly motionGroup: MotionGroupState,
-    readonly initialMotionState: MotionGroupState,
-    readonly motionStateSocket: AutoReconnectingWebsocket,
-    readonly isVirtual: boolean,
-    readonly tcps: RobotTcpLike[],
-    readonly description: MotionGroupDescription,
-    readonly initialControllerState: RobotControllerState,
-    readonly controllerStateSocket: AutoReconnectingWebsocket,
-  ) {
-    this.rapidlyChangingMotionState = initialMotionState
-    this.controllerState = initialControllerState
-
-    // Track controller state updates (e.g. safety state and operation mode)
-    controllerStateSocket.addEventListener("message", (event) => {
-      const data = tryParseJson(event.data)?.result
-
-      if (!data) {
-        return
-      }
-
-      runInAction(() => {
-        this.controllerState = data
-      })
-    })
-
-    motionStateSocket.addEventListener("message", (event) => {
-      const latestMotionState = tryParseJson(event.data)?.result as
-        | MotionGroupState
-        | undefined
-
-      if (!latestMotionState) {
-        throw new Error(
-          `Failed to get motion state for ${this.motionGroupId}: ${event.data}`,
-        )
-      }
-
-      // handle joint position changes
-      if (
-        !jointValuesEqual(
-          this.rapidlyChangingMotionState.joint_position,
-          latestMotionState.joint_position,
-          MOTION_DELTA_THRESHOLD,
-        )
-      ) {
-        runInAction(() => {
-          this.rapidlyChangingMotionState.joint_position =
-            latestMotionState.joint_position
-        })
-      }
-
-      // handle tcp pose changes
-      if (
-        !tcpMotionEqual(
-          this.rapidlyChangingMotionState,
-          latestMotionState,
-          MOTION_DELTA_THRESHOLD,
-        )
-      ) {
-        runInAction(() => {
-          this.rapidlyChangingMotionState.tcp_pose = latestMotionState.tcp_pose
-        })
-      }
-
-      // handle standstill changes
-      if (
-        this.rapidlyChangingMotionState.standstill !==
-        latestMotionState.standstill
-      ) {
-        runInAction(() => {
-          this.rapidlyChangingMotionState.standstill =
-            latestMotionState.standstill
-        })
-      }
-    })
-    makeAutoObservable(this)
-  }
-
-  get motionGroupId() {
-    return this.motionGroup.motion_group
-  }
-
-  get controllerId() {
-    return this.controller.controller
-  }
-
-  get modelFromController() {
-    return this.description.motion_group_model
-  }
-
-  get wandelscriptIdentifier() {
-    const num = this.motionGroupId.split("@")[0]
-    return `${this.controllerId.replace(/-/g, "_")}_${num}`
-  }
-
-  /** Jogging velocity in radians for rotation and joint movement */
-  get joggingVelocityRads() {
-    return (this.joggingVelocity * Math.PI) / 180
-  }
-
-  get joints() {
-    return this.initialMotionState.joint_position.map((_, i) => {
-      return {
-        index: i,
-      }
-    })
-  }
-
-  // Please note that API v2 omits 0 values
-  get dhParameters() {
-    if (this.description.dh_parameters === undefined) {
-      return undefined
-    }
-
-    return this.description.dh_parameters.map((dh_param) => ({
-      ...EMPTY_DH_PARAMETER,
-      ...dh_param,
-    }))
-  }
-
-  get safetyZones() {
-    return this.description.safety_zones
-  }
-
-  /** Gets the robot mounting position offset in 3D viz coordinates */
-  get mountingPosition(): [number, number, number] {
-    if (!this.description.mounting) {
-      return [0, 0, 0]
-    }
-
-    return [
-      (this.description.mounting.position?.[0] || 0) / 1000,
-      (this.description.mounting.position?.[1] || 0) / 1000,
-      (this.description.mounting.position?.[2] || 0) / 1000,
-    ]
-  }
-
-  /** Gets the robot mounting position rotation in 3D viz coordinates */
-  get mountingQuaternion() {
-    const rotationVector = new THREE.Vector3(
-      this.description.mounting?.orientation?.[0] || 0,
-      this.description.mounting?.orientation?.[1] || 0,
-      this.description.mounting?.orientation?.[2] || 0,
-    )
-
-    const magnitude = rotationVector.length()
-    const axis = rotationVector.normalize()
-
-    return new THREE.Quaternion().setFromAxisAngle(axis, magnitude)
-  }
-
-  /**
-   * Whether the controller is currently in a safety state
-   * corresponding to an emergency stop
-   */
-  get isEstopActive() {
-    const estopStates: SafetyStateType[] = [
-      "SAFETY_STATE_ROBOT_EMERGENCY_STOP",
-      "SAFETY_STATE_DEVICE_EMERGENCY_STOP",
-    ]
-
-    return estopStates.includes(this.controllerState.safety_state)
-  }
-
-  /**
-   * Whether the controller is in a safety state
-   * that may be non-functional for robot pad purposes
-   */
-  get isMoveableSafetyState() {
-    const goodSafetyStates: SafetyStateType[] = [
-      "SAFETY_STATE_NORMAL",
-      "SAFETY_STATE_REDUCED",
-    ]
-
-    return goodSafetyStates.includes(this.controllerState.safety_state)
-  }
-
-  /**
-   * Whether the controller is in an operation mode that allows movement
-   */
-  get isMoveableOperationMode() {
-    const goodOperationModes: OperationMode[] = [
-      "OPERATION_MODE_AUTO",
-      "OPERATION_MODE_MANUAL",
-      "OPERATION_MODE_MANUAL_T1",
-      "OPERATION_MODE_MANUAL_T2",
-    ]
-
-    return goodOperationModes.includes(this.controllerState.operation_mode)
-  }
-
-  /**
-   * Whether the robot is currently active and can be moved, based on the
-   * safety state, operation mode and servo toggle activation state.
-   */
-  get canBeMoved() {
-    return (
-      this.isMoveableSafetyState &&
-      this.isMoveableOperationMode &&
-      this.activationState === "active"
-    )
-  }
-
-  async deactivate() {
-    if (this.activationState !== "active") {
-      console.error("Tried to deactivate while already deactivating")
-      return
-    }
-
-    runInAction(() => {
-      this.activationState = "deactivating"
-    })
-
-    try {
-      await this.nova.api.controller.setDefaultMode(
-        this.controllerId,
-        "ROBOT_SYSTEM_MODE_MONITOR",
-      )
-
-      runInAction(() => {
-        this.activationState = "inactive"
-      })
-    } catch (err) {
-      runInAction(() => {
-        this.activationState = "active"
-      })
-      throw err
-    }
-  }
-
-  async activate() {
-    if (this.activationState !== "inactive") {
-      console.error("Tried to activate while already activating")
-      return
-    }
-
-    runInAction(() => {
-      this.activationState = "activating"
-    })
-
-    try {
-      await this.nova.api.controller.setDefaultMode(
-        this.controllerId,
-        "ROBOT_SYSTEM_MODE_CONTROL",
-      )
-
-      runInAction(() => {
-        this.activationState = "active"
-      })
-    } catch (err) {
-      runInAction(() => {
-        this.activationState = "inactive"
-      })
-      throw err
-    }
-  }
-
-  toggleActivation() {
-    if (this.activationState === "inactive") {
-      this.activate()
-    } else if (this.activationState === "active") {
-      this.deactivate()
-    }
-  }
-
-  dispose() {
-    this.motionStateSocket.close()
-    if (this.connectedJoggingSocket) this.connectedJoggingSocket.close()
-  }
-
-  setJoggingVelocity(velocity: number) {
-    this.joggingVelocity = velocity
-  }
-}