@wandelbots/wandelbots-js-react-components 3.7.2 → 3.7.4-pr.feat-add-linear-axis-support.509.8e469ba

package/dist/SupportedLinearAxis-DAK0IyqZ.js

@@ -0,0 +1,1228 @@
+import { j as t, e as z } from "./externalizeComponent-Dc3fViZA.js";
+import * as x from "three";
+import { Matrix4 as w, Vector3 as T, Quaternion as U } from "three";
+import { ConvexGeometry as te } from "three-stdlib";
+import { useThree as ne, useFrame as re, Canvas as N } from "@react-three/fiber";
+import { Environment as je, Lightformer as V, Line as O, useGLTF as we, Bounds as Y } from "@react-three/drei";
+import { useTheme as be, Card as Re, Box as b, Typography as q, Divider as X, Button as K } from "@mui/material";
+import { observer as ve } from "mobx-react-lite";
+import Me, { useRef as R, useEffect as G, useCallback as _, useState as L, Suspense as oe } from "react";
+import { useTranslation as _e } from "react-i18next";
+import { N as Ge, V as se, c as ie, b as Z, M as v } from "./interpolation-baUmFLkh.js";
+import { ErrorBoundary as ae } from "react-error-boundary";
+function Te(e) {
+  switch (e.shape_type) {
+    case "convex_hull":
+      return new te(
+        e.vertices.map(
+          (n) => new x.Vector3(
+            n[0] / 1e3,
+            n[1] / 1e3,
+            n[2] / 1e3
+          )
+        )
+      );
+    case "box":
+      return new x.BoxGeometry(
+        e.size_x / 1e3,
+        e.size_y / 1e3,
+        e.size_z / 1e3
+      );
+    case "sphere":
+      return new x.SphereGeometry(e.radius / 1e3);
+    case "capsule":
+      return new x.CapsuleGeometry(
+        e.radius / 1e3,
+        e.cylinder_height / 1e3
+      );
+    case "cylinder":
+      return new x.CylinderGeometry(
+        e.radius / 1e3,
+        e.radius / 1e3,
+        e.height / 1e3
+      );
+    case "rectangle":
+      return new x.BoxGeometry(e.size_x / 1e3, e.size_y / 1e3, 0);
+    default:
+      return console.warn(`${e.shape_type} is not supported`), new x.BufferGeometry();
+  }
+}
+function Ve({
+  name: e,
+  collider: r,
+  children: n
+}) {
+  var u, c;
+  const a = ((u = r.pose) == null ? void 0 : u.position) ?? [0, 0, 0], s = ((c = r.pose) == null ? void 0 : c.orientation) ?? [0, 0, 0];
+  return r.margin && console.warn(`${e} margin is not supported`), /* @__PURE__ */ t.jsx(
+    "mesh",
+    {
+      name: e,
+      position: new x.Vector3(
+        a[0],
+        a[1],
+        a[2]
+      ).divideScalar(1e3),
+      rotation: new x.Euler(s[0], s[1], s[2], "XYZ"),
+      geometry: Te(r.shape),
+      children: n
+    }
+  );
+}
+function Le({
+  name: e,
+  colliders: r,
+  meshChildrenProvider: n,
+  ...a
+}) {
+  return /* @__PURE__ */ t.jsx("group", { name: e, ...a, children: Object.entries(r).map(([s, u]) => /* @__PURE__ */ t.jsx(
+    Ve,
+    {
+      name: s,
+      collider: u,
+      children: n(s, u)
+    },
+    s
+  )) });
+}
+function tt({
+  scene: e,
+  meshChildrenProvider: r
+}) {
+  const n = e.colliders;
+  return /* @__PURE__ */ t.jsx("group", { children: n && /* @__PURE__ */ t.jsx(
+    Le,
+    {
+      meshChildrenProvider: r,
+      colliders: n
+    }
+  ) });
+}
+function Q() {
+  return /* @__PURE__ */ t.jsx(je, { children: /* @__PURE__ */ t.jsx(ke, {}) });
+}
+function ke({ positions: e = [2, 0, 2, 0, 2, 0, 2, 0] }) {
+  return /* @__PURE__ */ t.jsxs(t.Fragment, { children: [
+    /* @__PURE__ */ t.jsx(
+      V,
+      {
+        intensity: 5,
+        "rotation-x": Math.PI / 2,
+        position: [0, 5, -9],
+        scale: [10, 10, 1]
+      }
+    ),
+    /* @__PURE__ */ t.jsx("group", { rotation: [0, 0.5, 0], children: /* @__PURE__ */ t.jsx("group", { children: e.map((r, n) => /* @__PURE__ */ t.jsx(
+      V,
+      {
+        form: "circle",
+        intensity: 5,
+        rotation: [Math.PI / 2, 0, 0],
+        position: [r, 4, n * 4],
+        scale: [3, 1, 1]
+      },
+      n
+    )) }) }),
+    /* @__PURE__ */ t.jsx(
+      V,
+      {
+        intensity: 40,
+        "rotation-y": Math.PI / 2,
+        position: [-5, 1, -1],
+        scale: [20, 0.1, 1]
+      }
+    ),
+    /* @__PURE__ */ t.jsx(
+      V,
+      {
+        intensity: 20,
+        "rotation-y": -Math.PI,
+        position: [-5, -2, -1],
+        scale: [20, 0.1, 1]
+      }
+    ),
+    /* @__PURE__ */ t.jsx(
+      V,
+      {
+        "rotation-y": Math.PI / 2,
+        position: [-5, -1, -1],
+        scale: [20, 0.5, 1],
+        intensity: 5
+      }
+    ),
+    /* @__PURE__ */ t.jsx(
+      V,
+      {
+        "rotation-y": -Math.PI / 2,
+        position: [10, 1, 0],
+        scale: [20, 1, 1],
+        intensity: 10
+      }
+    ),
+    /* @__PURE__ */ t.jsx(
+      V,
+      {
+        form: "ring",
+        color: "white",
+        intensity: 5,
+        scale: 10,
+        position: [-15, 4, -18],
+        target: [0, 0, 0]
+      }
+    )
+  ] });
+}
+function Fe(e) {
+  if (e.length < 3)
+    return console.log("Not enough vertices to define a plane"), { isCoplanar: !1 };
+  const r = new x.Vector3(e[0].x, e[0].y, e[0].z), n = new x.Vector3(e[1].x, e[1].y, e[1].z), a = new x.Vector3(e[2].x, e[2].y, e[2].z), s = new x.Vector3().subVectors(n, r), u = new x.Vector3().subVectors(a, r), c = new x.Vector3().crossVectors(s, u).normalize();
+  for (let f = 3; f < e.length; f++) {
+    const l = new x.Vector3(e[f].x, e[f].y, e[f].z), m = new x.Vector3().subVectors(l, r), d = c.dot(m);
+    if (Math.abs(d) > 1e-6)
+      return console.log("Vertices are not on the same plane"), { isCoplanar: !1 };
+  }
+  return { isCoplanar: !0, normal: c };
+}
+function nt({
+  safetyZones: e,
+  ...r
+}) {
+  return /* @__PURE__ */ t.jsx("group", { ...r, children: e.map((n, a) => {
+    let s = [];
+    return n.geometry && (n.geometry.compound ? s = n.geometry.compound.child_geometries : n.geometry.convex_hull && (s = [n.geometry])), s.map((u, c) => {
+      if (!u.convex_hull) return null;
+      const f = u.convex_hull.vertices.map(
+        (d) => new x.Vector3(d.x / 1e3, d.y / 1e3, d.z / 1e3)
+      ), l = Fe(f);
+      if (l.isCoplanar && l.normal) {
+        const o = new x.Vector3().addVectors(
+          f[0],
+          l.normal.multiplyScalar(1e-4)
+        );
+        f.push(o);
+      }
+      let m;
+      try {
+        m = new te(f);
+      } catch (d) {
+        return console.log("Error creating ConvexGeometry:", d), null;
+      }
+      return /* @__PURE__ */ t.jsx("mesh", { geometry: m, children: /* @__PURE__ */ t.jsx(
+        "meshStandardMaterial",
+        {
+          attach: "material",
+          color: "#009f4d",
+          opacity: 0.2,
+          depthTest: !1,
+          depthWrite: !1,
+          transparent: !0,
+          polygonOffset: !0,
+          polygonOffsetFactor: -c
+        },
+        a
+      ) }, `${a}-${c}`);
+    });
+  }) });
+}
+function rt({
+  trajectory: e,
+  ...r
+}) {
+  var a;
+  const n = ((a = e.trajectory) == null ? void 0 : a.map((s) => s.tcp_pose ? new x.Vector3(
+    s.tcp_pose.position.x / 1e3,
+    s.tcp_pose.position.z / 1e3,
+    -s.tcp_pose.position.y / 1e3
+  ) : null).filter((s) => s !== null)) || [];
+  return /* @__PURE__ */ t.jsx("group", { ...r, children: n.length > 0 && /* @__PURE__ */ t.jsx(
+    O,
+    {
+      points: n,
+      lineWidth: 3,
+      polygonOffset: !0,
+      polygonOffsetFactor: 10,
+      polygonOffsetUnits: 10
+    }
+  ) });
+}
+const P = /* @__PURE__ */ new Map();
+async function C(e) {
+  if (P.has(e))
+    return P.get(e);
+  const r = (async () => {
+    var u;
+    const a = new Ge({ instanceUrl: "" }), s = a.api.motionGroupModels;
+    (u = s.axios) != null && u.interceptors && s.axios.interceptors.request.use((c) => {
+      var f;
+      return (f = c.url) != null && f.includes("/glb") && (c.responseType = "blob"), c;
+    });
+    try {
+      const c = await a.api.motionGroupModels.getMotionGroupGlbModel(e);
+      return URL.createObjectURL(c);
+    } catch (c) {
+      throw console.error("Failed to fetch model:", c), c;
+    }
+  })();
+  return P.set(e, r), r;
+}
+function ce(e) {
+  function r(n) {
+    return n.children.length === 0 ? [n] : [n, ...n.children.flatMap((a) => r(a))];
+  }
+  return r(e).filter((n) => ue(n));
+}
+function le(e) {
+  return e.name.endsWith("_FLG");
+}
+function ue(e) {
+  return /_J[0-9]+$/.test(e.name);
+}
+function Ie(e, r) {
+  let n;
+  function a(s) {
+    if (le(s)) {
+      if (n)
+        throw Error(
+          `Found multiple flange groups in robot model ${r}; first ${n.name} then ${s.name}. Only one _FLG group is allowed.`
+        );
+      n = s;
+    }
+    ue(s), s.children.map(a);
+  }
+  if (a(e.scene), !n)
+    throw Error(
+      `No flange group found in robot model ${r}. Flange must be identified with a name ending in _FLG.`
+    );
+  return { gltf: e };
+}
+function fe({
+  rapidlyChangingMotionState: e,
+  dhParameters: r,
+  onRotationChanged: n,
+  children: a
+}) {
+  const s = R([]), u = R([]), c = R(null), { invalidate: f } = ne();
+  G(() => {
+    const o = e.joint_position.filter(
+      (i) => i !== void 0
+    );
+    return c.current = new se(o, {
+      tension: 120,
+      // Controls spring stiffness - higher values create faster, more responsive motion
+      friction: 20,
+      // Controls damping - higher values reduce oscillation and create smoother settling
+      threshold: 1e-3
+    }), () => {
+      var i;
+      (i = c.current) == null || i.destroy();
+    };
+  }, []), re((o, i) => {
+    if (c.current) {
+      const p = c.current.update(i);
+      m(), p || f();
+    }
+  });
+  function l(o) {
+    o && (u.current = ce(o), m(), f());
+  }
+  function m() {
+    var i;
+    const o = ((i = c.current) == null ? void 0 : i.getCurrentValues()) || [];
+    if (n)
+      n(u.current, o);
+    else
+      for (const [p, y] of u.current.entries()) {
+        const h = r[p], j = h.theta || 0, g = h.reverse_rotation_direction ? -1 : 1;
+        y.rotation.y = g * (o[p] || 0) + j;
+      }
+  }
+  const d = _(() => {
+    const o = e.joint_position.filter(
+      (i) => i !== void 0
+    );
+    requestAnimationFrame(() => {
+      var i;
+      s.current = o, (i = c.current) == null || i.setTarget(o);
+    });
+  }, [e]);
+  return G(() => {
+    d();
+  }, [e, d]), ie(() => {
+    d();
+  }), /* @__PURE__ */ t.jsx("group", { ref: l, children: a });
+}
+const Ae = "line", Se = "mesh";
+function De({
+  rapidlyChangingMotionState: e,
+  dhParameters: r,
+  ...n
+}) {
+  const a = new w(), s = R([]), u = R([]);
+  Me.useEffect(() => {
+    s.current = new Array(r.length).fill(null), u.current = new Array(r.length).fill(null);
+  }, [r.length]);
+  function c(m, d) {
+    const o = new T(), i = new U(), p = new T();
+    a.decompose(o, i, p);
+    const y = o.clone(), h = new w().makeRotationY(
+      m.theta + d * (m.reverse_rotation_direction ? -1 : 1)
+    ).multiply(new w().makeTranslation(0, m.d / 1e3, 0)).multiply(new w().makeTranslation(m.a / 1e3, 0, 0)).multiply(new w().makeRotationX(m.alpha));
+    return a.multiply(h), a.decompose(o, i, p), { a: y, b: o };
+  }
+  function f(m, d, o, i) {
+    if (!r)
+      return;
+    const p = r[m];
+    if (!p)
+      return;
+    const { a: y, b: h } = c(p, i);
+    d.geometry.setPositions([y.toArray(), h.toArray()].flat()), o.position.set(h.x, h.y, h.z);
+  }
+  function l(m, d) {
+    a.identity();
+    for (let o = 0; o < Math.min(m.length, d.length); o++) {
+      const i = s.current[o], p = u.current[o];
+      i && p && f(o, i, p, d[o]);
+    }
+  }
+  return /* @__PURE__ */ t.jsx(t.Fragment, { children: /* @__PURE__ */ t.jsx(
+    fe,
+    {
+      rapidlyChangingMotionState: e,
+      dhParameters: r,
+      onRotationChanged: l,
+      children: /* @__PURE__ */ t.jsxs("group", { ...n, name: "Scene", children: [
+        /* @__PURE__ */ t.jsxs("mesh", { children: [
+          /* @__PURE__ */ t.jsx("sphereGeometry", { args: [0.01, 32, 32] }),
+          /* @__PURE__ */ t.jsx("meshStandardMaterial", { color: "black", depthTest: !0 })
+        ] }),
+        r.map((m, d) => {
+          const { a: o, b: i } = c(
+            m,
+            e.joint_position[d] ?? 0
+          ), p = `dhrobot_J0${d}`;
+          return /* @__PURE__ */ t.jsxs("group", { name: p, children: [
+            /* @__PURE__ */ t.jsx(
+              O,
+              {
+                ref: (y) => {
+                  s.current[d] = y;
+                },
+                name: Ae,
+                points: [o, i],
+                color: "white",
+                lineWidth: 5
+              }
+            ),
+            /* @__PURE__ */ t.jsxs(
+              "mesh",
+              {
+                ref: (y) => {
+                  u.current[d] = y;
+                },
+                name: Se,
+                position: i,
+                children: [
+                  /* @__PURE__ */ t.jsx("sphereGeometry", { args: [0.01, 32, 32] }),
+                  /* @__PURE__ */ t.jsx("meshStandardMaterial", { color: "black", depthTest: !0 })
+                ]
+              },
+              "mesh_" + d
+            )
+          ] }, p);
+        })
+      ] })
+    }
+  ) });
+}
+const Pe = console.warn;
+function de() {
+  return G(() => {
+    console.warn = (e) => {
+      e !== "Cannot call the manual advancement of rafz whilst frameLoop is not set as demand" && Pe(e);
+    };
+  }, []), /* @__PURE__ */ t.jsx(t.Fragment, {});
+}
+function Ue(e) {
+  return e.type === "Mesh";
+}
+function ze({
+  url: e,
+  flangeRef: r,
+  postModelRender: n,
+  ...a
+}) {
+  const s = we(e);
+  let u;
+  try {
+    u = Ie(s, "robot.glb").gltf;
+  } catch (l) {
+    throw l;
+  }
+  const c = _(
+    (l) => {
+      l && n && n();
+    },
+    [n]
+  );
+  function f(l) {
+    try {
+      return Ue(l) ? l.geometry ? /* @__PURE__ */ t.jsx(
+        "mesh",
+        {
+          name: l.name,
+          geometry: l.geometry,
+          material: l.material,
+          position: l.position,
+          rotation: l.rotation
+        },
+        l.uuid
+      ) : /* @__PURE__ */ t.jsx("group", { name: l.name, position: l.position, rotation: l.rotation }, l.uuid) : /* @__PURE__ */ t.jsx(
+        "group",
+        {
+          name: l.name,
+          position: l.position,
+          rotation: l.rotation,
+          ref: le(l) ? r : void 0,
+          children: l.children.map(f)
+        },
+        l.uuid
+      );
+    } catch (m) {
+      return console.warn("Error rendering node", l.name, m), null;
+    }
+  }
+  return /* @__PURE__ */ t.jsx("group", { ...a, dispose: null, ref: c, children: f(u.scene) });
+}
+function me({
+  modelURL: e,
+  flangeRef: r,
+  postModelRender: n,
+  ...a
+}) {
+  const [s, u] = L(null);
+  return G(() => {
+    (async () => {
+      try {
+        if (typeof e == "string")
+          u(e);
+        else {
+          const f = await e;
+          u(f);
+        }
+      } catch (f) {
+        console.error("Failed to resolve model URL:", f);
+      }
+    })();
+  }, [e]), s ? /* @__PURE__ */ t.jsx(
+    ze,
+    {
+      url: s,
+      flangeRef: r,
+      postModelRender: n,
+      ...a
+    }
+  ) : null;
+}
+const pe = (e, r) => {
+  e.userData.isGhost || (e.traverse((n) => {
+    if (n instanceof x.Mesh) {
+      n.material instanceof x.Material && (n.material.colorWrite = !1);
+      const a = n.clone(), s = n.clone();
+      a.material = new x.MeshStandardMaterial({
+        depthTest: !0,
+        depthWrite: !0,
+        colorWrite: !1,
+        polygonOffset: !0,
+        polygonOffsetFactor: -1,
+        side: x.DoubleSide
+      }), a.userData.isGhost = !0, s.material = new x.MeshStandardMaterial({
+        color: r,
+        opacity: 0.3,
+        depthTest: !0,
+        depthWrite: !1,
+        transparent: !0,
+        polygonOffset: !0,
+        polygonOffsetFactor: -2,
+        side: x.DoubleSide
+      }), s.userData.isGhost = !0, n.parent && (n.parent.add(a), n.parent.add(s));
+    }
+  }), e.userData.isGhost = !0);
+}, he = (e) => {
+  if (!e.userData.isGhost) return;
+  const r = [];
+  e.traverse((n) => {
+    var a;
+    n instanceof x.Mesh && ((a = n.userData) != null && a.isGhost ? r.push(n) : n.material instanceof x.Material && (n.material.colorWrite = !0));
+  }), r.forEach((n) => {
+    n.parent && n.parent.remove(n);
+  }), e.userData.isGhost = !1;
+}, Oe = z(
+  ({
+    rapidlyChangingMotionState: e,
+    modelFromController: r,
+    dhParameters: n,
+    getModel: a = C,
+    flangeRef: s,
+    postModelRender: u,
+    transparentColor: c,
+    ...f
+  }) => {
+    const [l, m] = L(null), d = _((i) => {
+      m(i);
+    }, []);
+    G(() => {
+      l && (c ? pe(l, c) : he(l));
+    }, [l, c]);
+    const o = /* @__PURE__ */ t.jsx(
+      De,
+      {
+        rapidlyChangingMotionState: e,
+        dhParameters: n,
+        ...f
+      }
+    );
+    return /* @__PURE__ */ t.jsxs(
+      ae,
+      {
+        fallback: o,
+        onError: (i) => {
+          console.warn(i);
+        },
+        children: [
+          /* @__PURE__ */ t.jsx(oe, { fallback: o, children: /* @__PURE__ */ t.jsx("group", { ref: d, children: /* @__PURE__ */ t.jsx(
+            fe,
+            {
+              rapidlyChangingMotionState: e,
+              dhParameters: n,
+              children: /* @__PURE__ */ t.jsx(
+                me,
+                {
+                  modelURL: (() => {
+                    const i = a(r);
+                    if (!i) {
+                      const p = new Blob([], { type: "model/gltf-binary" }), y = new File([p], `${r}.glb`, { type: "model/gltf-binary" });
+                      return Promise.resolve(URL.createObjectURL(y));
+                    }
+                    return i;
+                  })(),
+                  postModelRender: u,
+                  flangeRef: s,
+                  ...f
+                }
+              )
+            }
+          ) }) }),
+          /* @__PURE__ */ t.jsx(de, {})
+        ]
+      }
+    );
+  }
+);
+function Ce({
+  connectedMotionGroup: e,
+  getModel: r = C,
+  flangeRef: n,
+  transparentColor: a,
+  postModelRender: s,
+  ...u
+}) {
+  return e.dhParameters ? /* @__PURE__ */ t.jsx(
+    Oe,
+    {
+      rapidlyChangingMotionState: e.rapidlyChangingMotionState,
+      modelFromController: e.modelFromController || "",
+      dhParameters: e.dhParameters,
+      getModel: r,
+      flangeRef: n,
+      transparentColor: a,
+      postModelRender: s,
+      ...u
+    }
+  ) : null;
+}
+const ot = z(
+  ve(
+    ({
+      robotName: e,
+      programState: r,
+      safetyState: n,
+      operationMode: a,
+      driveToHomeEnabled: s = !1,
+      onDriveToHomePress: u,
+      onDriveToHomeRelease: c,
+      connectedMotionGroup: f,
+      robotComponent: l = Ce,
+      customContentComponent: m,
+      className: d
+    }) => {
+      var W;
+      const o = be(), { t: i } = _e(), [p, y] = L(!1), h = R(null), j = R(null), [g, D] = L(!1), [k, ye] = L({ width: 400, height: 600 }), [We, ge] = L(0);
+      G(() => {
+        const S = () => {
+          if (j.current) {
+            const { offsetWidth: $, offsetHeight: H } = j.current;
+            D($ > H), ye({ width: $, height: H });
+          }
+        };
+        S();
+        const J = new ResizeObserver(S);
+        return j.current && J.observe(j.current), () => {
+          J.disconnect();
+        };
+      }, []);
+      const E = _(() => {
+        ge((S) => S + 1);
+      }, []), F = _(() => {
+        !s || !u || (y(!0), u());
+      }, [s, u]), I = _(() => {
+        !s || !c || (y(!1), c());
+      }, [s, c]), B = _(() => {
+        p && c && (y(!1), c());
+      }, [p, c]), M = g ? k.width < 350 : k.height < 200, A = g ? k.height < 310 : k.height < 450;
+      return /* @__PURE__ */ t.jsx(
+        Re,
+        {
+          ref: j,
+          className: d,
+          sx: {
+            width: "100%",
+            height: "100%",
+            display: "flex",
+            flexDirection: g ? "row" : "column",
+            position: "relative",
+            overflow: "hidden",
+            minWidth: { xs: 180, sm: 220, md: 250 },
+            minHeight: g ? { xs: 200, sm: 240, md: 260 } : { xs: 150, sm: 180, md: 220 },
+            // Allow progressive hiding in portrait mode
+            border: `1px solid ${o.palette.divider}`,
+            borderRadius: "18px",
+            boxShadow: "none",
+            backgroundColor: ((W = o.palette.backgroundPaperElevation) == null ? void 0 : W[8]) || "#2A2A3F",
+            backgroundImage: "none"
+            // Override any gradient from elevation
+          },
+          children: g ? /* @__PURE__ */ t.jsxs(t.Fragment, { children: [
+            /* @__PURE__ */ t.jsx(
+              b,
+              {
+                sx: {
+                  flex: "0 0 50%",
+                  position: "relative",
+                  height: "100%",
+                  minHeight: "100%",
+                  maxHeight: "100%",
+                  borderRadius: 1,
+                  m: { xs: 1.5, sm: 2, md: 3 },
+                  mr: { xs: 0.75, sm: 1, md: 1.5 },
+                  overflow: "hidden",
+                  // Prevent content from affecting container size
+                  display: M ? "none" : "block"
+                },
+                children: !M && /* @__PURE__ */ t.jsxs(
+                  N,
+                  {
+                    orthographic: !0,
+                    camera: {
+                      position: [3, 2, 3],
+                      zoom: 1
+                    },
+                    shadows: !0,
+                    frameloop: "demand",
+                    style: {
+                      borderRadius: o.shape.borderRadius,
+                      width: "100%",
+                      height: "100%",
+                      background: "transparent",
+                      position: "absolute",
+                      top: 0,
+                      left: 0
+                    },
+                    dpr: [1, 2],
+                    gl: { alpha: !0, antialias: !0 },
+                    children: [
+                      /* @__PURE__ */ t.jsx(Q, {}),
+                      /* @__PURE__ */ t.jsx(Y, { fit: !0, observe: !0, margin: 1, maxDuration: 1, children: /* @__PURE__ */ t.jsx(
+                        l,
+                        {
+                          connectedMotionGroup: f,
+                          postModelRender: E
+                        }
+                      ) })
+                    ]
+                  }
+                )
+              }
+            ),
+            /* @__PURE__ */ t.jsxs(
+              b,
+              {
+                sx: {
+                  flex: "1",
+                  display: "flex",
+                  flexDirection: "column",
+                  justifyContent: "flex-start",
+                  width: M ? "100%" : "50%"
+                },
+                children: [
+                  /* @__PURE__ */ t.jsxs(
+                    b,
+                    {
+                      sx: {
+                        p: { xs: 1.5, sm: 2, md: 3 },
+                        pb: { xs: 1, sm: 1.5, md: 2 },
+                        textAlign: "left"
+                      },
+                      children: [
+                        /* @__PURE__ */ t.jsx(q, { variant: "h6", component: "h2", sx: { mb: 1 }, children: e }),
+                        /* @__PURE__ */ t.jsx(
+                          Z,
+                          {
+                            programState: r,
+                            safetyState: n,
+                            operationMode: a
+                          }
+                        )
+                      ]
+                    }
+                  ),
+                  /* @__PURE__ */ t.jsxs(
+                    b,
+                    {
+                      sx: {
+                        p: { xs: 1.5, sm: 2, md: 3 },
+                        pt: 0,
+                        flex: "1",
+                        display: "flex",
+                        flexDirection: "column",
+                        justifyContent: "space-between"
+                      },
+                      children: [
+                        !A && m && /* @__PURE__ */ t.jsxs(b, { children: [
+                          /* @__PURE__ */ t.jsx(m, {}),
+                          /* @__PURE__ */ t.jsx(
+                            X,
+                            {
+                              sx: {
+                                mt: 1,
+                                mb: 0,
+                                borderColor: o.palette.divider,
+                                opacity: 0.5
+                              }
+                            }
+                          )
+                        ] }),
+                        /* @__PURE__ */ t.jsx(
+                          b,
+                          {
+                            sx: {
+                              mt: !A && m ? "auto" : 0
+                            },
+                            children: /* @__PURE__ */ t.jsx(
+                              b,
+                              {
+                                sx: {
+                                  display: "flex",
+                                  justifyContent: "flex-start",
+                                  mt: { xs: 1, sm: 1.5, md: 2 },
+                                  mb: { xs: 0.5, sm: 0.75, md: 1 }
+                                },
+                                children: /* @__PURE__ */ t.jsx(
+                                  K,
+                                  {
+                                    ref: h,
+                                    variant: "contained",
+                                    color: "secondary",
+                                    size: "small",
+                                    disabled: !s,
+                                    onMouseDown: F,
+                                    onMouseUp: I,
+                                    onMouseLeave: B,
+                                    onTouchStart: F,
+                                    onTouchEnd: I,
+                                    sx: {
+                                      textTransform: "none",
+                                      px: 1.5,
+                                      py: 0.5
+                                    },
+                                    children: i("RobotCard.DriveToHome.bt")
+                                  }
+                                )
+                              }
+                            )
+                          }
+                        )
+                      ]
+                    }
+                  )
+                ]
+              }
+            )
+          ] }) : /* @__PURE__ */ t.jsx(t.Fragment, { children: /* @__PURE__ */ t.jsxs(
+            b,
+            {
+              sx: {
+                p: 3,
+                height: "100%",
+                display: "flex",
+                flexDirection: "column"
+              },
+              children: [
+                /* @__PURE__ */ t.jsxs(b, { children: [
+                  /* @__PURE__ */ t.jsx(q, { variant: "h6", component: "h2", sx: { mb: 1 }, children: e }),
+                  /* @__PURE__ */ t.jsx(
+                    Z,
+                    {
+                      programState: r,
+                      safetyState: n,
+                      operationMode: a
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ t.jsx(
+                  b,
+                  {
+                    sx: {
+                      flex: M ? 0 : 1,
+                      position: "relative",
+                      minHeight: M ? 0 : { xs: 120, sm: 150, md: 200 },
+                      height: M ? 0 : "auto",
+                      borderRadius: 1,
+                      overflow: "hidden",
+                      display: M ? "none" : "block"
+                    },
+                    children: !M && /* @__PURE__ */ t.jsxs(
+                      N,
+                      {
+                        orthographic: !0,
+                        camera: {
+                          position: [3, 2, 3],
+                          zoom: 1
+                        },
+                        shadows: !0,
+                        frameloop: "demand",
+                        style: {
+                          borderRadius: o.shape.borderRadius,
+                          width: "100%",
+                          height: "100%",
+                          background: "transparent",
+                          position: "absolute"
+                        },
+                        dpr: [1, 2],
+                        gl: { alpha: !0, antialias: !0 },
+                        children: [
+                          /* @__PURE__ */ t.jsx(Q, {}),
+                          /* @__PURE__ */ t.jsx(Y, { fit: !0, clip: !0, observe: !0, margin: 1, maxDuration: 1, children: /* @__PURE__ */ t.jsx(
+                            l,
+                            {
+                              connectedMotionGroup: f,
+                              postModelRender: E
+                            }
+                          ) })
+                        ]
+                      }
+                    )
+                  }
+                ),
+                /* @__PURE__ */ t.jsxs(b, { children: [
+                  !A && m && /* @__PURE__ */ t.jsxs(t.Fragment, { children: [
+                    /* @__PURE__ */ t.jsx(m, {}),
+                    /* @__PURE__ */ t.jsx(
+                      X,
+                      {
+                        sx: {
+                          mt: 1,
+                          mb: 0,
+                          borderColor: o.palette.divider,
+                          opacity: 0.5
+                        }
+                      }
+                    )
+                  ] }),
+                  /* @__PURE__ */ t.jsx(
+                    b,
+                    {
+                      sx: {
+                        display: "flex",
+                        justifyContent: "flex-start",
+                        mt: !A && m ? { xs: 1, sm: 2, md: 5 } : { xs: 0.5, sm: 1, md: 2 },
+                        mb: { xs: 0.5, sm: 0.75, md: 1 }
+                      },
+                      children: /* @__PURE__ */ t.jsx(
+                        K,
+                        {
+                          ref: h,
+                          variant: "contained",
+                          color: "secondary",
+                          size: "small",
+                          disabled: !s,
+                          onMouseDown: F,
+                          onMouseUp: I,
+                          onMouseLeave: B,
+                          onTouchStart: F,
+                          onTouchEnd: I,
+                          sx: {
+                            textTransform: "none",
+                            px: 1.5,
+                            py: 0.5
+                          },
+                          children: i("RobotCard.DriveToHome.bt")
+                        }
+                      )
+                    }
+                  )
+                ] })
+              ]
+            }
+          ) })
+        }
+      );
+    }
+  )
+), st = Array(6).fill(2 * Math.PI), ee = {
+  [v.Abb]: [0, 0, 0, 0, Math.PI / 2, 0, 0],
+  [v.Fanuc]: [0, 0, 0, 0, -Math.PI / 2, 0, 0],
+  [v.Yaskawa]: [0, 0, 0, 0, -Math.PI / 2, 0, 0],
+  [v.Kuka]: [
+    0,
+    -Math.PI / 2,
+    Math.PI / 2,
+    0,
+    Math.PI / 2,
+    0,
+    0
+  ],
+  [v.Universalrobots]: [
+    0,
+    -Math.PI / 2,
+    -Math.PI / 2,
+    -Math.PI / 2,
+    Math.PI / 2,
+    -Math.PI / 2,
+    0
+  ]
+};
+function Ee(e) {
+  const [r] = e.split("_");
+  switch (r) {
+    case "ABB":
+      return v.Abb;
+    case "FANUC":
+      return v.Fanuc;
+    case "YASKAWA":
+      return v.Yaskawa;
+    case "KUKA":
+      return v.Kuka;
+    case "UniversalRobots":
+      return v.Universalrobots;
+    default:
+      return null;
+  }
+}
+function it(e, r) {
+  const n = Ee(e);
+  return n && n in ee ? ee[n] : r || null;
+}
+function xe({
+  rapidlyChangingMotionState: e,
+  dhParameters: r,
+  onTranslationChanged: n,
+  children: a
+}) {
+  const s = R([]), u = R([]), c = R(null), { invalidate: f } = ne();
+  G(() => {
+    const o = e.joint_position.filter(
+      (i) => i !== void 0
+    );
+    return c.current = new se(o, {
+      tension: 120,
+      // Controls spring stiffness - higher values create faster, more responsive motion
+      friction: 20,
+      // Controls damping - higher values reduce oscillation and create smoother settling
+      threshold: 1e-3
+    }), () => {
+      var i;
+      (i = c.current) == null || i.destroy();
+    };
+  }, []), re((o, i) => {
+    if (c.current) {
+      const p = c.current.update(i);
+      m(), p || f();
+    }
+  });
+  function l(o) {
+    o && (u.current = ce(o), m(), f());
+  }
+  function m() {
+    var i;
+    const o = ((i = c.current) == null ? void 0 : i.getCurrentValues()) || [];
+    if (n)
+      n(u.current, o);
+    else
+      for (const [p, y] of u.current.entries()) {
+        const j = r[p].reverse_rotation_direction ? -1 : 1;
+        y.position.y = j * (o[p] || 0) / 1e3;
+      }
+  }
+  const d = _(() => {
+    const o = e.joint_position.filter(
+      (i) => i !== void 0
+    );
+    requestAnimationFrame(() => {
+      var i;
+      s.current = o, (i = c.current) == null || i.setTarget(o);
+    });
+  }, [e]);
+  return G(() => {
+    d();
+  }, [e, d]), ie(() => {
+    d();
+  }), /* @__PURE__ */ t.jsx("group", { ref: l, children: a });
+}
+function Be({
+  rapidlyChangingMotionState: e,
+  dhParameters: r,
+  ...n
+}) {
+  const a = new w(), s = R(null), u = R(null);
+  function c(m) {
+    const d = new w();
+    for (let y = 0; y < r.length; y++) {
+      const h = r[y], j = m[y] ?? 0, g = new w().makeRotationY(h.theta).multiply(
+        new w().makeTranslation(
+          h.a / 1e3,
+          (h.d + j * (h.reverse_rotation_direction ? -1 : 1)) / 1e3,
+          0
+        )
+      ).multiply(new w().makeRotationX(h.alpha));
+      d.multiply(g);
+    }
+    const o = new T(), i = new U(), p = new T();
+    return d.decompose(o, i, p), o;
+  }
+  const f = c(e.joint_position);
+  function l(m, d) {
+    a.identity();
+    let o = new T();
+    for (let h = 0; h < r.length; h++) {
+      const j = d[h] ?? 0, g = r[h], D = new w().makeRotationY(g.theta).multiply(
+        new w().makeTranslation(
+          g.a / 1e3,
+          (g.d + j * (g.reverse_rotation_direction ? -1 : 1)) / 1e3,
+          0
+        )
+      ).multiply(new w().makeRotationX(g.alpha));
+      a.multiply(D);
+    }
+    const i = new T(), p = new U(), y = new T();
+    if (a.decompose(i, p, y), o = i, s.current && s.current.position.set(o.x, o.y, o.z), u.current) {
+      const h = u.current.geometry;
+      h && h.setPositions && h.setPositions([0, 0, 0, o.x, o.y, o.z]);
+    }
+  }
+  return /* @__PURE__ */ t.jsx(t.Fragment, { children: /* @__PURE__ */ t.jsx(
+    xe,
+    {
+      rapidlyChangingMotionState: e,
+      dhParameters: r,
+      onTranslationChanged: l,
+      children: /* @__PURE__ */ t.jsxs("group", { ...n, name: "Scene", children: [
+        /* @__PURE__ */ t.jsxs("mesh", { name: "Base", position: [0, 0, 0], children: [
+          /* @__PURE__ */ t.jsx("sphereGeometry", { args: [0.02, 32, 32] }),
+          /* @__PURE__ */ t.jsx("meshStandardMaterial", { color: "green", depthTest: !0 })
+        ] }),
+        /* @__PURE__ */ t.jsx(
+          O,
+          {
+            ref: u,
+            points: [new T(0, 0, 0), f],
+            color: "White",
+            lineWidth: 5
+          }
+        ),
+        /* @__PURE__ */ t.jsxs("mesh", { ref: s, name: "TCP", position: f, children: [
+          /* @__PURE__ */ t.jsx("sphereGeometry", { args: [0.025, 32, 32] }),
+          /* @__PURE__ */ t.jsx("meshStandardMaterial", { color: "red", depthTest: !0 })
+        ] })
+      ] })
+    }
+  ) });
+}
+const at = z(
+  ({
+    rapidlyChangingMotionState: e,
+    modelFromController: r,
+    dhParameters: n,
+    getModel: a = C,
+    flangeRef: s,
+    postModelRender: u,
+    transparentColor: c,
+    ...f
+  }) => {
+    const [l, m] = L(null), d = _((i) => {
+      m(i);
+    }, []);
+    G(() => {
+      l && (c ? pe(l, c) : he(l));
+    }, [l, c]);
+    const o = /* @__PURE__ */ t.jsx(
+      Be,
+      {
+        rapidlyChangingMotionState: e,
+        dhParameters: n,
+        ...f
+      }
+    );
+    return /* @__PURE__ */ t.jsxs(
+      ae,
+      {
+        fallback: o,
+        onError: (i) => {
+          console.warn(i);
+        },
+        children: [
+          /* @__PURE__ */ t.jsx(oe, { fallback: o, children: /* @__PURE__ */ t.jsx("group", { ref: d, children: /* @__PURE__ */ t.jsx(
+            xe,
+            {
+              rapidlyChangingMotionState: e,
+              dhParameters: n,
+              children: /* @__PURE__ */ t.jsx(
+                me,
+                {
+                  modelURL: (() => {
+                    const i = a(r);
+                    if (!i) {
+                      const p = new Blob([], { type: "model/gltf-binary" }), y = new File([p], `${r}.glb`, { type: "model/gltf-binary" });
+                      return Promise.resolve(URL.createObjectURL(y));
+                    }
+                    return i;
+                  })(),
+                  postModelRender: u,
+                  flangeRef: s,
+                  ...f
+                }
+              )
+            }
+          ) }) }),
+          /* @__PURE__ */ t.jsx(de, {})
+        ]
+      }
+    );
+  }
+);
+export {
+  tt as C,
+  ee as M,
+  Q as P,
+  Ce as R,
+  nt as S,
+  rt as T,
+  ot as a,
+  at as b,
+  Oe as c,
+  st as d,
+  C as e,
+  Ee as f,
+  it as g
+};
+//# sourceMappingURL=SupportedLinearAxis-DAK0IyqZ.js.map