@wandelbots/nova-js 2.1.4 → 3.0.0-pr.bugfix-compatible-with-non-dom-envs.115.33da73d

package/src/lib/v2/MotionStreamConnection.ts

@@ -1,201 +0,0 @@
-import type {
-  Controller,
-  MotionGroupPhysical,
-  MotionGroupState,
-} from "@wandelbots/nova-api/v2"
-import { makeAutoObservable, runInAction } from "mobx"
-import * as THREE from "three"
-import type { AutoReconnectingWebsocket } from "../AutoReconnectingWebsocket"
-import { tryParseJson } from "../converters"
-import { jointValuesEqual, tcpPoseEqual } from "./motionStateUpdate"
-import type { NovaClient } from "./NovaClient"
-import { Vector3d, vector3ToArray } from "./vectorUtils"
-
-const MOTION_DELTA_THRESHOLD = 0.0001
-
-function unwrapRotationVector(
-  newRotationVectorApi: Vector3d,
-  currentRotationVectorApi: Vector3d,
-): Vector3d {
-  const currentRotationVector = new THREE.Vector3(
-    currentRotationVectorApi[0],
-    currentRotationVectorApi[1],
-    currentRotationVectorApi[2],
-  )
-
-  const newRotationVector = new THREE.Vector3(
-    newRotationVectorApi[0],
-    newRotationVectorApi[1],
-    newRotationVectorApi[2],
-  )
-
-  const currentAngle = currentRotationVector.length()
-  const currentAxis = currentRotationVector.normalize()
-
-  let newAngle = newRotationVector.length()
-  let newAxis = newRotationVector.normalize()
-
-  // Align rotation axes
-  if (newAxis.dot(currentAxis) < 0) {
-    newAngle = -newAngle
-    newAxis = newAxis.multiplyScalar(-1.0)
-  }
-
-  // Shift rotation angle close to previous one to extend domain of rotation angles beyond [0, pi]
-  // - this simplifies interpolation and prevents abruptly changing signs of the rotation angles
-  let angleDifference = newAngle - currentAngle
-  angleDifference -=
-    2.0 * Math.PI * Math.floor((angleDifference + Math.PI) / (2.0 * Math.PI))
-
-  newAngle = currentAngle + angleDifference
-
-  return vector3ToArray(newAxis.multiplyScalar(newAngle))
-}
-
-/**
- * Store representing the current state of a connected motion group.
- */
-export class MotionStreamConnection {
-  static async open(nova: NovaClient, motionGroupId: string) {
-    const { controllers: controllers } =
-      await nova.api.controller.listControllers()
-
-    const [_motionGroupIndex, controllerId] = motionGroupId.split("@") as [
-      string,
-      string,
-    ]
-    const controller = controllers.find((c) => c.controller === 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(
-      `/motion-groups/${motionGroupId}/state-stream`,
-    )
-
-    // Wait for the first message to get the initial state
-    const firstMessage = await motionStateSocket.firstMessage()
-    console.log("got first message", 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,
-    )
-
-    return new MotionStreamConnection(
-      nova,
-      controller,
-      motionGroup,
-      initialMotionState,
-      motionStateSocket,
-    )
-  }
-
-  // Not mobx-observable as this changes very fast; should be observed
-  // using animation frames
-  rapidlyChangingMotionState: MotionGroupState
-
-  constructor(
-    readonly nova: NovaClient,
-    readonly controller: Controller,
-    readonly motionGroup: MotionGroupPhysical,
-    readonly initialMotionState: MotionGroupState,
-    readonly motionStateSocket: AutoReconnectingWebsocket,
-  ) {
-    this.rapidlyChangingMotionState = initialMotionState
-
-    motionStateSocket.addEventListener("message", (event) => {
-      const motionState = tryParseJson(event.data)?.result as
-        | MotionGroupState
-        | undefined
-
-      if (!motionState) {
-        throw new Error(
-          `Failed to get motion state for ${this.motionGroupId}: ${event.data}`,
-        )
-      }
-
-      // handle motionState message
-      if (
-        !jointValuesEqual(
-          this.rapidlyChangingMotionState.joint_position.joints,
-          motionState.joint_position.joints,
-          MOTION_DELTA_THRESHOLD,
-        )
-      ) {
-        runInAction(() => {
-          this.rapidlyChangingMotionState = motionState
-        })
-      }
-
-      // handle tcpPose message
-      if (
-        !tcpPoseEqual(
-          this.rapidlyChangingMotionState.tcp_pose,
-          motionState.tcp_pose,
-          MOTION_DELTA_THRESHOLD,
-        )
-      ) {
-        runInAction(() => {
-          if (this.rapidlyChangingMotionState.tcp_pose == undefined) {
-            this.rapidlyChangingMotionState.tcp_pose = motionState.tcp_pose
-          } else {
-            this.rapidlyChangingMotionState.tcp_pose = {
-              position: motionState.tcp_pose!.position,
-              orientation: unwrapRotationVector(
-                motionState.tcp_pose!.orientation as Vector3d,
-                this.rapidlyChangingMotionState.tcp_pose!
-                  .orientation as Vector3d,
-              ),
-              tcp: motionState.tcp_pose!.tcp,
-              coordinate_system: motionState.tcp_pose!.coordinate_system,
-            }
-          }
-        })
-      }
-    })
-    makeAutoObservable(this)
-  }
-
-  get motionGroupId() {
-    return this.motionGroup.motion_group
-  }
-
-  get controllerId() {
-    return this.controller.controller
-  }
-
-  get modelFromController() {
-    return this.motionGroup.model_from_controller
-  }
-
-  get wandelscriptIdentifier() {
-    const num = this.motionGroupId.split("@")[0]
-    return `${this.controllerId.replaceAll("-", "_")}_${num}`
-  }
-
-  get joints() {
-    return this.initialMotionState.joint_position.joints.map((_, i) => {
-      return {
-        index: i,
-      }
-    })
-  }
-
-  dispose() {
-    this.motionStateSocket.close()
-  }
-}

package/src/lib/v2/ProgramStateConnection.ts

@@ -1,249 +0,0 @@
-import { AxiosError } from "axios"
-import { makeAutoObservable, runInAction } from "mobx"
-import { AutoReconnectingWebsocket } from "../AutoReconnectingWebsocket"
-import { tryParseJson } from "../converters"
-import type { MotionStreamConnection } from "./MotionStreamConnection"
-import type { NovaClient } from "./NovaClient"
-
-export type ProgramRunnerLogEntry = {
-  timestamp: number
-  message: string
-  level?: "warn" | "error"
-}
-
-export enum ProgramState {
-  NotStarted = "not started",
-  Running = "running",
-  Stopped = "stopped",
-  Failed = "failed",
-  Completed = "completed",
-}
-
-export type CurrentProgram = {
-  id?: string
-  wandelscript?: string
-  state?: ProgramState
-}
-
-type ProgramStateMessage = {
-  type: string
-  runner: {
-    id: string
-    state: ProgramState
-    start_time?: number | null
-    execution_time?: number | null
-  }
-}
-
-/**
- * Interface for running Wandelscript programs on the Nova instance and
- * tracking their progress and output
- */
-export class ProgramStateConnection {
-  currentProgram: CurrentProgram = {}
-  logs: ProgramRunnerLogEntry[] = []
-
-  executionState = "idle" as "idle" | "starting" | "executing" | "stopping"
-  currentlyExecutingProgramRunnerId = null as string | null
-
-  programStateSocket: AutoReconnectingWebsocket
-
-  constructor(readonly nova: NovaClient) {
-    makeAutoObservable(this, {}, { autoBind: true })
-
-    this.programStateSocket = nova.openReconnectingWebsocket(`/programs/state`)
-
-    this.programStateSocket.addEventListener("message", (ev) => {
-      const msg = tryParseJson(ev.data)
-
-      if (!msg) {
-        console.error("Failed to parse program state message", ev.data)
-        return
-      }
-      if (msg.type === "update") {
-        this.handleProgramStateMessage(msg)
-      }
-    })
-  }
-
-  /** Handle a program state update from the backend */
-  async handleProgramStateMessage(msg: ProgramStateMessage) {
-    const { runner } = msg
-
-    // Ignoring other programs for now
-    // TODO - show if execution state is busy from another source
-    if (runner.id !== this.currentlyExecutingProgramRunnerId) return
-
-    if (runner.state === ProgramState.Failed) {
-      try {
-        const runnerState = await this.nova.api.program.getProgramRun(runner.id)
-
-        // TODO - wandelengine should send print statements in real time over
-        // websocket as well, rather than at the end
-        const stdout = (runnerState as any).stdout
-        if (stdout) {
-          this.log(stdout)
-        }
-        this.logError(
-          `Program runner ${runner.id} failed with error: ${runnerState.error}\n${runnerState.traceback}`,
-        )
-      } catch (err) {
-        this.logError(
-          `Failed to retrieve results for program ${runner.id}: ${err}`,
-        )
-      }
-
-      this.currentProgram.state = ProgramState.Failed
-
-      this.gotoIdleState()
-    } else if (runner.state === ProgramState.Stopped) {
-      try {
-        const runnerState = await this.nova.api.program.getProgramRun(runner.id)
-
-        const stdout = (runnerState as any).stdout
-        if (stdout) {
-          this.log(stdout)
-        }
-
-        this.currentProgram.state = ProgramState.Stopped
-        this.log(`Program runner ${runner.id} stopped`)
-      } catch (err) {
-        this.logError(
-          `Failed to retrieve results for program ${runner.id}: ${err}`,
-        )
-      }
-
-      this.gotoIdleState()
-    } else if (runner.state === ProgramState.Completed) {
-      try {
-        const runnerState = await this.nova.api.program.getProgramRun(runner.id)
-
-        const stdout = (runnerState as any).stdout
-        if (stdout) {
-          this.log(stdout)
-        }
-        this.log(
-          `Program runner ${runner.id} finished successfully in ${runner.execution_time?.toFixed(2)} seconds`,
-        )
-
-        this.currentProgram.state = ProgramState.Completed
-      } catch (err) {
-        this.logError(
-          `Failed to retrieve results for program ${runner.id}: ${err}`,
-        )
-      }
-
-      this.gotoIdleState()
-    } else if (runner.state === ProgramState.Running) {
-      this.currentProgram.state = ProgramState.Running
-      this.log(`Program runner ${runner.id} now running`)
-    } else if (runner.state !== ProgramState.NotStarted) {
-      console.error(runner)
-      this.logError(
-        `Program runner ${runner.id} entered unexpected state: ${runner.state}`,
-      )
-      this.currentProgram.state = ProgramState.NotStarted
-      this.gotoIdleState()
-    }
-  }
-
-  /** Call when a program is no longer executing */
-  gotoIdleState() {
-    runInAction(() => {
-      this.executionState = "idle"
-    })
-    this.currentlyExecutingProgramRunnerId = null
-  }
-
-  async executeProgram(
-    wandelscript: string,
-    initial_state?: Object,
-    activeRobot?: MotionStreamConnection,
-  ) {
-    this.currentProgram = {
-      wandelscript: wandelscript,
-      state: ProgramState.NotStarted,
-    }
-
-    const { currentProgram: openProgram } = this
-    if (!openProgram) return
-    runInAction(() => {
-      this.executionState = "starting"
-    })
-
-    // WOS-1539: Wandelengine parser currently breaks if there are empty lines with indentation
-    const trimmedCode = openProgram.wandelscript!.replaceAll(/^\s*$/gm, "")
-
-    try {
-      const programRunnerRef = await this.nova.api.program.createProgramRun(
-        {
-          code: trimmedCode,
-          initial_state: initial_state,
-          default_robot: activeRobot?.wandelscriptIdentifier,
-        } as any,
-        {
-          headers: {
-            "Content-Type": "application/json",
-          },
-        },
-      )
-
-      this.log(`Created program runner ${programRunnerRef.id}"`)
-      runInAction(() => {
-        this.executionState = "executing"
-      })
-      this.currentlyExecutingProgramRunnerId = programRunnerRef.id
-    } catch (error) {
-      if (error instanceof AxiosError && error.response && error.request) {
-        this.logError(
-          `${error.response.status} ${error.response.statusText} from ${error.response.config.url} ${JSON.stringify(error.response.data)}`,
-        )
-      } else {
-        this.logError(JSON.stringify(error))
-      }
-      runInAction(() => {
-        this.executionState = "idle"
-      })
-    }
-  }
-
-  async stopProgram() {
-    if (!this.currentlyExecutingProgramRunnerId) return
-    runInAction(() => {
-      this.executionState = "stopping"
-    })
-
-    try {
-      await this.nova.api.program.stopProgramRun(
-        this.currentlyExecutingProgramRunnerId,
-      )
-    } catch (err) {
-      // Reactivate the stop button so user can try again
-      runInAction(() => {
-        this.executionState = "executing"
-      })
-      throw err
-    }
-  }
-
-  reset() {
-    this.currentProgram = {}
-  }
-
-  log(message: string) {
-    console.log(message)
-    this.logs.push({
-      timestamp: Date.now(),
-      message,
-    })
-  }
-
-  logError(message: string) {
-    console.log(message)
-    this.logs.push({
-      timestamp: Date.now(),
-      message,
-      level: "error",
-    })
-  }
-}

package/src/lib/v2/motionStateUpdate.ts

@@ -1,55 +0,0 @@
-import type { TcpPose } from "@wandelbots/nova-api/v2"
-
-export function jointValuesEqual(
-  oldJointValues: number[],
-  newJointValues: number[],
-  changeDeltaThreshold: number,
-): boolean {
-  if (newJointValues.length !== oldJointValues.length) {
-    return true
-  }
-
-  for (let jointIndex = 0; jointIndex < newJointValues.length; jointIndex++) {
-    if (
-      Math.abs(newJointValues[jointIndex]! - oldJointValues[jointIndex]!) >
-      changeDeltaThreshold
-    ) {
-      return false
-    }
-  }
-
-  return true
-}
-
-export function tcpPoseEqual(
-  oldTcp: TcpPose | undefined,
-  newTcp: TcpPose | undefined,
-  changeDeltaThreshold: number,
-): boolean {
-  // undefined -> defined (+reverse) transition
-  if ((oldTcp === undefined && newTcp) || (oldTcp && newTcp === undefined)) {
-    return false
-  }
-
-  // the typechecker cannot resolve states to "!= undefined" if "&&" is used
-  if (oldTcp === undefined || newTcp === undefined) {
-    return true
-  }
-
-  let changedDelta = 0
-  changedDelta += Math.abs(oldTcp.orientation[0] - newTcp.orientation[0])
-  changedDelta += Math.abs(oldTcp.orientation[1] - newTcp.orientation[1])
-  changedDelta += Math.abs(oldTcp.orientation[2] - newTcp.orientation[2])
-  changedDelta += Math.abs(oldTcp.position[0] - newTcp.position[0])
-  changedDelta += Math.abs(oldTcp.position[1] - newTcp.position[1])
-  changedDelta += Math.abs(oldTcp.position[2] - newTcp.position[2])
-
-  if (changedDelta > changeDeltaThreshold) {
-    return false
-  }
-
-  return (
-    oldTcp.coordinate_system === newTcp.coordinate_system &&
-    oldTcp.tcp === newTcp.tcp
-  )
-}