@vidispine/vdt-materialui 23.2.0-pre.2 → 23.2.0

package/dist/es/item/player/ItemVideoPlayer.js

@@ -0,0 +1,100 @@
+import { jsx as e } from "react/jsx-runtime";
+import { useRef as W, useMemo as P } from "react";
+import g from "clsx";
+import { withStyles as D, Box as n } from "@material-ui/core";
+import { item as T } from "@vidispine/vdt-api";
+import { metadataTypeToWebVtt as L, createTimeBase as N, formatTimeCodeSeconds as U } from "@vidispine/vdt-js";
+import { VideoPlayer as Y } from "@vidispine/vdt-videojs-react";
+const F = ["video/mp4"], $ = (t) => ({
+  root: {
+    "& .video-js.controls-below-player:not(.vjs-fullscreen) .vjs-control-bar .vdt-timecode:not(.vjs-menu-item-text)": {
+      color: t.palette.text.primary
+    },
+    "& .video-js.controls-below-player:not(.vjs-fullscreen) .vjs-control-bar .vjs-button:not(.vjs-menu-item-text)": {
+      color: t.palette.text.primary
+    },
+    "& .video-js.controls-below-player:not(.vjs-fullscreen) .vjs-control-bar .vjs-volume-level": {
+      backgroundColor: t.palette.text.primary,
+      color: t.palette.text.primary
+    },
+    "& .video-js .vjs-play-progress.vjs-slider-bar": {
+      backgroundColor: t.palette.secondary.main
+    }
+  }
+});
+function z({
+  className: t,
+  classes: h,
+  itemType: V,
+  videoEl: a,
+  subtitleGroup: i = "stl_subtitle",
+  subtitleField: m = "stl_text",
+  subtitleLanguage: c = "en",
+  subtitleLanguageLabel: d = "English",
+  sampleRate: o = "PAL",
+  onReady: w,
+  onCinema: I,
+  onScreenshot: B,
+  onScreenshotSuccess: p,
+  onScreenshotError: y,
+  width: C = "100%",
+  sourceTag: f = "original",
+  videoPlayerProps: _ = {},
+  previewSources: E = []
+}) {
+  let u = W();
+  a && (u = a);
+  const {
+    thumbnails: { uri: M = [] } = {},
+    metadata: v,
+    id: j
+  } = V, r = P(
+    () => L(v, {
+      subtitleGroup: i,
+      subtitleField: m,
+      sampleRate: o
+    }),
+    [v, i, m, o]
+  ), S = P(() => {
+    if (r)
+      return [
+        {
+          src: new Blob([r], { type: "text/plain" }),
+          lang: c,
+          label: d
+        }
+      ];
+  }, [r, c, d]), [k] = M, s = N(o), q = (A) => {
+    const b = U(A, { timeBase: s }).toText(), x = "HIGHEST", H = b, O = b;
+    Promise.all([
+      T.createThumbnail({ itemId: j, queryParams: { createThumbnails: H, priority: x, sourceTag: f } }),
+      T.createThumbnail({ itemId: j, queryParams: { createPosters: O, priority: x, sourceTag: f } })
+    ]).then((l) => {
+      p && p(l);
+    }).catch((l) => {
+      y && y(l);
+    });
+  };
+  return /* @__PURE__ */ e(n, { className: g(h.root, "VdtItemVideoPlayer-root", t), children: /* @__PURE__ */ e(n, { width: "100%", display: "flex", justifyContent: "center", children: /* @__PURE__ */ e(n, { width: "100%", children: /* @__PURE__ */ e(
+    Y,
+    {
+      controls: !0,
+      sources: E,
+      subtitles: S,
+      posterUrl: k,
+      ref: u,
+      frameRate: s.denominator / s.numerator,
+      timecode: !0,
+      width: C,
+      onScreenshot: B || q,
+      onReady: w,
+      onCinema: I,
+      ..._
+    }
+  ) }) }) });
+}
+const tt = D($, { name: "VdtItemVideoPlayer" })(z);
+export {
+  F as ALLOWED_MIME_TYPES,
+  tt as default
+};

package/dist/es/job/JobCard.js

@@ -0,0 +1,148 @@
+import { jsxs as i, jsx as e, Fragment as g } from "react/jsx-runtime";
+import { useState as v } from "react";
+import k from "clsx";
+import t from "prop-types";
+import { withStyles as S, Card as E, CardHeader as P, Collapse as R, CardContent as x, IconButton as D, ButtonBase as O, Menu as w, MenuItem as C, ListItemIcon as y, ListItemText as j } from "@material-ui/core";
+import { Delete as B, Block as F, Replay as H, MoreVert as V } from "@material-ui/icons";
+import { Alert as _ } from "@material-ui/lab";
+import { job as A } from "@vidispine/vdt-api";
+import { ROLE_NAMES as L } from "@vidispine/vdt-js";
+import { HasRole as q } from "@vidispine/vdt-react";
+import { INACTIVE_STATES as z, RUNNING_STATES as G } from "./const.js";
+import U from "./JobDataTable.js";
+import W from "./JobTaskTable.js";
+function $({ jobType: b, onAbort: n, onDelete: s, onDuplicate: r, IconComponent: l = V }) {
+  const { status: d } = b, [u, m] = v(null), f = (h) => {
+    m(h.currentTarget);
+  }, p = () => {
+    m(null);
+  };
+  return /* @__PURE__ */ i(g, { children: [
+    /* @__PURE__ */ e(D, { component: O, onClick: f, disableRipple: !0, children: /* @__PURE__ */ e(l, {}) }),
+    /* @__PURE__ */ i(
+      w,
+      {
+        onClick: p,
+        anchorEl: u,
+        keepMounted: !0,
+        open: !!u,
+        onClose: p,
+        elevation: 1,
+        PaperProps: { square: !0 },
+        getContentAnchorEl: null,
+        anchorOrigin: {
+          vertical: "bottom",
+          horizontal: "right"
+        },
+        transformOrigin: {
+          vertical: "top",
+          horizontal: "right"
+        },
+        children: [
+          /* @__PURE__ */ i(C, { disabled: !z.includes(d), onClick: s, children: [
+            /* @__PURE__ */ e(y, { children: /* @__PURE__ */ e(B, {}) }),
+            /* @__PURE__ */ e(j, { primary: "Delete job" })
+          ] }),
+          /* @__PURE__ */ i(C, { disabled: !G.includes(d), onClick: n, children: [
+            /* @__PURE__ */ e(y, { children: /* @__PURE__ */ e(F, {}) }),
+            /* @__PURE__ */ e(j, { primary: "Abort job" })
+          ] }),
+          /* @__PURE__ */ i(C, { onClick: r, children: [
+            /* @__PURE__ */ e(y, { children: /* @__PURE__ */ e(H, {}) }),
+            /* @__PURE__ */ e(j, { primary: "Duplicate job" })
+          ] })
+        ]
+      }
+    )
+  ] });
+}
+const K = {
+  root: {},
+  CardContent: {
+    height: "calc(100% - 70px)",
+    overflow: "auto"
+  },
+  Alert: {},
+  CardHeader: {},
+  Collapse: {}
+};
+function T({
+  className: b,
+  classes: n,
+  jobType: s,
+  onSuccess: r,
+  onError: l,
+  JobMenuComponent: d,
+  JobMenuProps: u
+}) {
+  const [m, f] = v({}), [p, h] = v(!1), a = (o) => {
+    h(!0), f(o);
+  }, J = () => h(!1);
+  if (!s)
+    return null;
+  const { jobId: c } = s, M = () => A.abortJob({ jobId: c }).then((o) => {
+    a({ severity: "success", children: "Successfully aborted job" }), r && r(o);
+  }).catch((o) => {
+    a({ severity: "error", children: "Failed to abort job" }), l && l(o);
+  }), N = () => A.deleteJob({ queryParams: { id: c } }).then((o) => {
+    a({ severity: "success", children: "Successfully deleted job" }), r && r(o);
+  }).catch((o) => {
+    a({ severity: "error", children: "Failed to deleted job" }), l && l(o);
+  }), I = () => A.duplicateJob({ jobId: c }).then((o) => {
+    a({ severity: "success", children: "Successfully duplicated job" }), r && r(o);
+  }).catch((o) => {
+    a({ severity: "error", children: "Failed to duplicate job" }), l && l(o);
+  });
+  return /* @__PURE__ */ i(E, { elevation: 0, className: k(b, n.root, "VdtJobCard-root"), children: [
+    /* @__PURE__ */ e(
+      P,
+      {
+        className: n.CardHeader,
+        title: c,
+        action: /* @__PURE__ */ e(
+          q,
+          {
+            roleName: [L.ITEM_WRITE],
+            allow: /* @__PURE__ */ e(
+              d,
+              {
+                jobType: s,
+                onAbort: M,
+                onDelete: N,
+                onDuplicate: I,
+                ...u
+              }
+            )
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ e(R, { className: n.Collapse, in: p, children: /* @__PURE__ */ e(_, { className: n.Alert, onClose: J, ...m }) }),
+    /* @__PURE__ */ i(x, { className: n.CardContent, children: [
+      /* @__PURE__ */ e(U, { jobId: c }),
+      /* @__PURE__ */ e(W, { jobId: c, autoRefresh: !0 })
+    ] })
+  ] });
+}
+T.propTypes = {
+  className: t.string,
+  classes: t.objectOf(t.string),
+  jobType: t.objectOf(t.any),
+  onSuccess: t.func,
+  onError: t.func,
+  JobMenuComponent: t.elementType,
+  JobMenuProps: t.objectOf(t.any)
+};
+T.defaultProps = {
+  className: void 0,
+  classes: {},
+  jobType: void 0,
+  onSuccess: void 0,
+  onError: void 0,
+  JobMenuComponent: $,
+  JobMenuProps: {}
+};
+const se = S(K, { name: "VdtJobCard" })(T);
+export {
+  se as default
+};

package/dist/es/job/JobDataTable.js

@@ -0,0 +1,68 @@
+import { jsx as v } from "react/jsx-runtime";
+import { useEffect as g } from "react";
+import a from "prop-types";
+import { withStyles as D } from "@material-ui/core";
+import { job as J } from "@vidispine/vdt-api";
+import { useApi as P } from "@vidispine/vdt-react";
+import V from "../item/ItemMetadataTable.js";
+const I = (e = []) => {
+  const t = (r, { key: s, value: o }) => ({ ...r, [s]: o });
+  return e.reduce(t, {});
+}, h = (e, t) => {
+  const { request: r, data: s = {}, reset: o } = P(J.getJob), n = t.map((l) => typeof l == "string" ? { label: l, value: l } : l);
+  g(() => {
+    const l = {
+      metadata: !0,
+      field: t.map((u) => u.value ? u.value : u)
+    };
+    return r({ jobId: e, queryParams: l }), o;
+  }, [e, r, o, t]);
+  const { data: p = [], user: b, type: d, status: m, started: c, finished: f, priority: y } = s, T = {
+    ...I(p),
+    user: b,
+    type: d,
+    status: m,
+    started: c,
+    finished: f,
+    priority: y,
+    jobId: e
+  };
+  return { fields: n, values: T };
+};
+function i({ jobId: e, fields: t, TableComponent: r, TableProps: s }) {
+  const { fields: o, values: n } = h(e, t);
+  return /* @__PURE__ */ v(r, { fields: o, ...s, ...n });
+}
+i.propTypes = {
+  jobId: a.string.isRequired,
+  fields: a.arrayOf(
+    a.oneOfType([
+      a.string,
+      a.shape({
+        label: a.string,
+        value: a.string,
+        formatValue: a.func
+      })
+    ])
+  ),
+  TableComponent: a.elementType,
+  TableProps: a.objectOf(a.any)
+};
+i.defaultProps = {
+  fields: [
+    { label: "Job ID", value: "jobId" },
+    { label: "Resource ID", value: "vidinetResourceId" },
+    { label: "User", value: "user" },
+    { label: "Type", value: "type" },
+    { label: "Priority", value: "priority" },
+    { label: "Started", value: "started", formatValue: (e) => new Date(e).toLocaleString() },
+    { label: "Finished", value: "finished", formatValue: (e) => new Date(e).toLocaleString() },
+    { label: "Vidinet ID", value: "vidinetJobId" }
+  ],
+  TableComponent: V,
+  TableProps: {}
+};
+const k = D({}, { name: "VdtJobDataTable" })(i);
+export {
+  k as default
+};

package/dist/es/job/JobFooter.js

@@ -0,0 +1,84 @@
+import { jsx as e, jsxs as i, Fragment as C } from "react/jsx-runtime";
+import { useState as E, useCallback as b, useEffect as p } from "react";
+import { AppBar as N, Accordion as P, AccordionSummary as D, CircularProgress as k, Typography as M, Divider as R, Select as _, MenuItem as B, AccordionDetails as H, Button as O } from "@material-ui/core";
+import { ExpandLess as q } from "@material-ui/icons";
+import z from "../hooks/useExpand.js";
+import { ALL_STATES as s, RUNNING_STATES as F, INACTIVE_STATES as G } from "./const.js";
+import J from "./JobTable.js";
+const U = [
+  { label: "All", value: s },
+  { label: "Running", value: F },
+  { label: "Inactive", value: G }
+];
+function X({
+  defaultExpanded: f = !1,
+  jobs: r,
+  isLoading: h,
+  hasLoaded: g,
+  onListJob: c,
+  refreshInterval: u = 15e3,
+  startTimeFromMinutes: m = 10,
+  JobTableComponent: x = J,
+  showJobList: T,
+  setShowJobList: l
+}) {
+  const { expanded: d, onToggle: v, onClose: A } = z(f), [n, y] = E({
+    first: 1,
+    number: 5,
+    sort: "startTime desc",
+    state: s
+  }), I = ({ target: { value: t } }) => {
+    y({ ...n, state: t });
+  }, a = b(() => {
+    const t = /* @__PURE__ */ new Date();
+    t.setMinutes(t.getMinutes() - m);
+    const o = { "starttime-from": t.toISOString() };
+    c({ matrixParams: n, queryParams: o });
+  }, [n, c, m]);
+  p(() => {
+    a();
+    const t = setInterval(a, u);
+    return () => clearInterval(t);
+  }, [a, u]);
+  const S = () => {
+    A(), l(!1);
+  };
+  return p(() => {
+    l(!0);
+  }, [r.length, l]), !g || !T || n.state === s && r.length === 0 ? null : /* @__PURE__ */ e(
+    N,
+    {
+      color: "inherit",
+      position: "fixed",
+      style: {
+        bottom: 8,
+        left: 8,
+        top: "auto",
+        width: "32em"
+      },
+      children: /* @__PURE__ */ i(P, { TransitionProps: { unmountOnExit: !0 }, expanded: d, children: [
+        /* @__PURE__ */ i(
+          D,
+          {
+            expandIcon: h ? /* @__PURE__ */ e(k, { size: 20 }) : /* @__PURE__ */ e(q, {}),
+            onClick: v,
+            children: [
+              /* @__PURE__ */ e(M, { variant: "button", style: { display: "flex", alignItems: "center" }, children: "Jobs" }),
+              d && /* @__PURE__ */ i(C, { children: [
+                /* @__PURE__ */ e(R, { orientation: "vertical", style: { margin: "0 25px", height: 30 } }),
+                /* @__PURE__ */ e(_, { value: n.state, onChange: I, fullWidth: !0, children: U.map(({ label: t, value: o }) => /* @__PURE__ */ e(B, { value: o, children: t }, o)) })
+              ] })
+            ]
+          }
+        ),
+        /* @__PURE__ */ i(H, { style: { flexDirection: "column" }, children: [
+          r.length > 0 ? /* @__PURE__ */ e(x, { jobs: r, hideHeader: !0 }) : /* @__PURE__ */ e("span", { children: "No jobs found" }),
+          /* @__PURE__ */ e(O, { onClick: S, children: "Close" })
+        ] })
+      ] })
+    }
+  );
+}
+export {
+  X as default
+};

package/dist/es/job/JobFooterContext.js

@@ -0,0 +1,114 @@
+import { jsxs as Q, jsx as R } from "react/jsx-runtime";
+import { createContext as w, useState as b, useCallback as r, useMemo as A } from "react";
+import { job as a } from "@vidispine/vdt-api";
+import { useApi as n } from "@vidispine/vdt-react";
+import S from "./JobFooter.js";
+const T = w({
+  jobs: [],
+  hits: 0,
+  abortJob: null,
+  transcode: null,
+  isLoading: !1,
+  hasLoaded: !1,
+  onRefresh: null,
+  deleteJob: null,
+  shapeTags: null,
+  restartJob: null,
+  queryParams: null,
+  matrixParams: null,
+  setQueryParams: null,
+  setMatrixParams: null
+}), k = {}, D = {
+  first: 1,
+  number: 5,
+  sort: "startTime desc"
+};
+function H({
+  queryParams: y = {},
+  matrixParams: L = {},
+  JobFooterProps: j = {},
+  JobFooterComponent: C = S,
+  children: M
+}) {
+  const [e, g] = b({
+    ...k,
+    ...y
+  }), [s, v] = b({
+    ...D,
+    ...L
+  }), [l, c] = b(!0), {
+    request: t,
+    data: { hits: d = 0, job: u = [] } = {},
+    isLoading: i,
+    hasLoaded: m
+  } = n(a.listJob), J = n(a.abortJob), P = n(a.duplicateJob), f = n(a.deleteJob), x = r(
+    () => t({ queryParams: e, matrixParams: s }),
+    [s, t, e]
+  ), h = r(
+    ({ jobId: o }) => {
+      J.request({ jobId: o });
+    },
+    [J]
+  ), p = r(
+    ({ jobId: o }) => {
+      P.request({ jobId: o });
+    },
+    [P]
+  ), q = r(
+    ({ jobId: o }) => {
+      f.request({ queryParams: { id: o } });
+    },
+    [f]
+  ), F = A(
+    () => ({
+      jobs: u,
+      hits: d,
+      abortJob: h,
+      onRefresh: x,
+      onListJob: t,
+      isLoading: i,
+      hasLoaded: m,
+      deleteJob: q,
+      restartJob: p,
+      queryParams: e,
+      matrixParams: s,
+      setQueryParams: g,
+      setMatrixParams: v,
+      showJobList: l,
+      setShowJobList: c
+    }),
+    [
+      h,
+      q,
+      m,
+      d,
+      i,
+      u,
+      s,
+      t,
+      x,
+      e,
+      p,
+      l
+    ]
+  );
+  return /* @__PURE__ */ Q(T.Provider, { value: F, children: [
+    M,
+    /* @__PURE__ */ R(
+      C,
+      {
+        jobs: u,
+        isLoading: i,
+        hasLoaded: m,
+        onListJob: t,
+        showJobList: l,
+        setShowJobList: c,
+        ...j
+      }
+    )
+  ] });
+}
+export {
+  T as JobFooterContext,
+  H as JobFooterContextProvider
+};

package/dist/es/job/JobList.js

@@ -0,0 +1,189 @@
+import { jsxs as n, jsx as e } from "react/jsx-runtime";
+import { useEffect as g } from "react";
+import I from "moment";
+import { withStyles as z, Box as o, Chip as H, Grid as m } from "@material-ui/core";
+import { job as d, taskdefinition as K } from "@vidispine/vdt-api";
+import { useApi as l } from "@vidispine/vdt-react";
+import C from "../search/Pagination.js";
+import Q from "../search/SearchInputFieldSelect.js";
+import X from "../search/Sort/index.js";
+import { JOB_STATES as Z, JOB_PRIORITIES as j } from "./const.js";
+import s from "./JobSelectForm.js";
+import tt, { DEFAULT_COLUMNS as et } from "./JobTable.js";
+const J = I().subtract(1, "days").format("YYYY-MM-DD"), D = I().subtract(7, "days").format("YYYY-MM-DD"), it = [
+  {
+    value: "jobId"
+  },
+  {
+    value: "status"
+  },
+  ...et
+], rt = ["jobId", "type", "state", "user", "startTime", "priority"], ot = {
+  jobId: "Job ID",
+  type: "Type",
+  state: "State",
+  user: "Created By",
+  startTime: "Started",
+  priority: "Priority",
+  status: "Status",
+  started: "Started",
+  finished: "Finished",
+  yesterday: "Yesterday",
+  thisWeek: "This Week",
+  allTime: "All Time"
+};
+function st({
+  page: x,
+  jobs: { job: E = [], hits: O = 0 } = {},
+  jobMetadata: p = [],
+  rowsPerPage: Y,
+  onChangeSort: A,
+  onChangePage: _,
+  onChangeType: v,
+  onChangeState: B,
+  onChangePriority: q,
+  onChangeStarttime: F,
+  onChangeFinishtime: M,
+  onChangeRowsPerPage: k,
+  onChangeJobmetadata: f,
+  onRefresh: w,
+  matrixParams: c,
+  jobColumnLabels: i = ot,
+  JobTableProps: R = {}
+}) {
+  const u = l(d.abortJob), h = l(d.duplicateJob), y = l(d.deleteJob), { request: T, data: U = {} } = l(K.listJobType), W = ({ jobId: t }) => {
+    u.request({ jobId: t });
+  }, N = ({ jobId: t }) => {
+    h.request({ jobId: t });
+  }, P = ({ jobId: t }) => {
+    y.request({ queryParams: { id: t } });
+  }, { uri: $ = [] } = U;
+  g(() => {
+    T();
+  }, [T]), g(() => {
+    w();
+  }, [u.isLoading, h.isLoading, y.isLoading]);
+  const G = ({ query: t, field: r }) => {
+    f([...p, { key: r, value: t }]);
+  }, L = (t) => {
+    const r = [...p];
+    r.splice(t, 1), f(r);
+  };
+  let S;
+  const b = rt.map((t) => ({ value: t, label: i[t] }));
+  if (c && c.sort) {
+    const [t, r = "asc"] = c.sort.split(" "), a = b.find(({ value: V }) => V === t);
+    a && (S = { option: a, direction: r });
+  }
+  return /* @__PURE__ */ n(o, { display: "flex", flexDirection: "column", height: "100%", width: "100%", children: [
+    /* @__PURE__ */ n(o, { height: 40, display: "flex", justifyContent: "flex-end", alignItems: "center", children: [
+      /* @__PURE__ */ e(Q, { onSubmit: G, flexGrow: 1, py: 0.5, px: 1 }),
+      /* @__PURE__ */ e(o, { children: p.map(({ key: t, value: r }, a) => /* @__PURE__ */ e(
+        H,
+        {
+          size: "small",
+          clickable: !0,
+          label: `${t}: ${r}`,
+          onDelete: () => L(a)
+        },
+        t + r
+      )) }),
+      /* @__PURE__ */ e(
+        X,
+        {
+          options: b,
+          initialSort: S,
+          onChange: A,
+          sortAsc: "asc",
+          sortDesc: "desc"
+        }
+      ),
+      /* @__PURE__ */ e(
+        C,
+        {
+          page: x,
+          count: O,
+          rowsPerPage: Y,
+          onChangePage: _,
+          onChangeRowsPerPage: k
+        }
+      )
+    ] }),
+    /* @__PURE__ */ e(o, { width: "100%", py: 2, children: /* @__PURE__ */ n(m, { container: !0, alignItems: "flex-start", children: [
+      /* @__PURE__ */ e(m, { item: !0, lg: 2, md: 3, sm: 4, xs: 12, children: /* @__PURE__ */ n(o, { mr: 4, children: [
+        /* @__PURE__ */ e(
+          s,
+          {
+            options: $.map((t) => ({ value: t, label: t })),
+            label: i.type,
+            name: "type",
+            multiple: !0,
+            onChange: v
+          }
+        ),
+        /* @__PURE__ */ e(
+          s,
+          {
+            options: Z.map((t) => ({ value: t, label: t })),
+            label: i.state,
+            name: "state",
+            multiple: !0,
+            onChange: B
+          }
+        ),
+        /* @__PURE__ */ e(
+          s,
+          {
+            options: j.map((t) => ({ value: t, label: t })),
+            label: i.priority,
+            name: "priority",
+            multiple: !0,
+            onChange: q
+          }
+        ),
+        /* @__PURE__ */ e(
+          s,
+          {
+            options: [
+              { value: J, label: i.yesterday },
+              { value: D, label: i.thisWeek },
+              { value: 0, label: i.allTime }
+            ],
+            label: i.started,
+            name: "starttime-from",
+            onChange: F
+          }
+        ),
+        /* @__PURE__ */ e(
+          s,
+          {
+            options: [
+              { value: J, label: i.yesterday },
+              { value: D, label: i.thisWeek },
+              { value: 0, label: i.allTime }
+            ],
+            label: i.finished,
+            name: "finishtime-from",
+            onChange: M
+          }
+        )
+      ] }) }),
+      /* @__PURE__ */ e(m, { item: !0, lg: 10, md: 9, sm: 8, xs: 12, children: /* @__PURE__ */ e(
+        tt,
+        {
+          jobs: E,
+          columns: it,
+          abortJob: W,
+          deleteJob: P,
+          restartJob: N,
+          jobColumnLabels: i,
+          ...R
+        }
+      ) })
+    ] }) })
+  ] });
+}
+const St = z({}, { name: "VdtJobList" })(st);
+export {
+  St as default
+};