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

package/dist/es/analyze/BatonAnalysisDialog.js

@@ -0,0 +1,256 @@
+import { jsxs as v, jsx as a, Fragment as w } from "react/jsx-runtime";
+import { useEffect as D, useMemo as F, useState as E } from "react";
+import J from "clsx";
+import e from "prop-types";
+import { Form as N, FormSpy as R } from "react-final-form";
+import { withStyles as k, DialogTitle as Q, Typography as T, Divider as q, DialogContent as H, LinearProgress as M, DialogActions as W, Button as G } from "@material-ui/core";
+import { analyzepreset as K, resource as U, item as X, component as $, shape as z, vidinet as Y } from "@vidispine/vdt-api";
+import { useApi as A } from "@vidispine/vdt-react";
+import Z from "./BatonAnalysisForm.js";
+const _ = () => {
+  const {
+    request: t,
+    data: { preset: o = [] } = {},
+    isLoading: s
+  } = A(K.listAnalyzePreset);
+  return D(() => {
+    t();
+  }, [t]), {
+    presetOptions: F(
+      () => o.map(({ name: n }) => ({
+        label: n,
+        value: n
+      })),
+      [o]
+    ),
+    isLoading: s
+  };
+}, ee = () => {
+  const {
+    request: t,
+    data: { resource: o = [] } = {},
+    isLoading: s
+  } = A(U.listResourceType);
+  return D(() => {
+    t({ resourceType: "vidinet" });
+  }, [t]), {
+    resourceOptions: F(
+      () => o.map(({ id: n, vidinet: r }) => ({
+        label: r.name || n,
+        value: n
+      })),
+      [o]
+    ),
+    isLoading: s
+  };
+}, te = (t) => {
+  const { request: o, data: { shape: s = [] } = {} } = A(X.getItem);
+  return D(() => {
+    o({
+      itemId: t,
+      queryParams: {
+        p: [
+          "shape.id",
+          "shape.tag",
+          "shape.containerComponent.id",
+          "shape.videoComponent.id",
+          "shape.audioComponent.id",
+          "shape.binaryComponent.id",
+          "shape.subtitleComponent.id",
+          "shape.descriptorComponent.id"
+        ]
+      }
+    });
+  }, [o, t]), {
+    shapeComponentOptions: F(() => s.filter(({ tag: [r] }) => {
+      const l = r.toLowerCase();
+      return !l.includes("pdf") && !l.includes("xml");
+    }).map(
+      ({
+        id: r,
+        tag: [l],
+        containerComponent: m = {},
+        videoComponent: b = [],
+        audioComponent: y = [],
+        binaryComponent: f = [],
+        subtitleComponent: C = [],
+        descriptorComponent: P = []
+      }) => {
+        const u = (i, h) => i.map(({ id: c }) => ({ value: c, label: `${h} component (${c})` })), d = [
+          m.id && {
+            value: m.id,
+            label: `container component (${m.id})`
+          },
+          ...u(b, "video"),
+          ...u(y, "audio"),
+          ...u(f, "binary"),
+          ...u(C, "subtitle"),
+          ...u(P, "descriptor")
+        ];
+        return { value: r, tag: l, label: `${l} (${r})`, components: d };
+      }
+    ), [s])
+  };
+}, oe = (t) => ({
+  startBatonJob: (s, p, n) => p ? $.createComponentAnalyze({
+    itemId: t,
+    shapeId: s,
+    componentId: p,
+    queryParams: n
+  }) : z.createShapeAnalyze({
+    itemId: t,
+    shapeId: s,
+    queryParams: n
+  })
+});
+function se({
+  itemId: t,
+  FormComponent: o,
+  FormComponentProps: s,
+  handleSubmit: p,
+  submitText: n,
+  costEstimate: r,
+  ...l
+}) {
+  const [{ value: m, error: b }, y] = E({}), [f, C] = E(!1), P = async (d) => {
+    const { data: i = {} } = await Y.getCostEstimate({ costEstimateId: d }), { state: h, service: c = [] } = i;
+    if (h !== "FINISHED")
+      return setTimeout(() => P(d), 1e3);
+    const [{ cost: g }] = c;
+    return C(!1), y(g);
+  }, u = ({ values: d = {} }) => {
+    y({});
+    const { shapeId: i, componentId: h, resourceId: c, preset: g } = d;
+    if (!i || !c || !g)
+      return;
+    (h ? $.createComponentAnalyze({
+      itemId: t,
+      shapeId: i,
+      componentId: h,
+      queryParams: { resourceId: c, preset: g },
+      costEstimate: !0
+    }) : z.createShapeAnalyze({
+      itemId: t,
+      shapeId: i,
+      queryParams: { resourceId: c, preset: g },
+      costEstimate: !0
+    })).then(({ data: { id: O } = {} }) => {
+      C(!0), P(O);
+    }).catch(
+      () => y({
+        error: "Couldn't get cost estimate, please choose another resource"
+      })
+    );
+  };
+  return /* @__PURE__ */ v(w, { children: [
+    /* @__PURE__ */ v(H, { children: [
+      /* @__PURE__ */ a(o, { ...l, ...s }),
+      r && /* @__PURE__ */ a(R, { subscription: { values: !0 }, onChange: u })
+    ] }),
+    f ? /* @__PURE__ */ a(M, {}) : /* @__PURE__ */ a(q, { light: !0 }),
+    /* @__PURE__ */ v(W, { children: [
+      m && /* @__PURE__ */ a(T, { variant: "caption", children: `Estimated cost: ${m}` }),
+      b && /* @__PURE__ */ a(T, { variant: "caption", color: "error", children: b }),
+      /* @__PURE__ */ a(
+        G,
+        {
+          disabled: r && (f || !m),
+          onClick: p,
+          color: "primary",
+          variant: "contained",
+          children: n
+        }
+      )
+    ] })
+  ] });
+}
+function B({
+  classes: t,
+  className: o,
+  titleText: s,
+  submitText: p,
+  errorText: n,
+  itemId: r,
+  onClose: l,
+  onSuccess: m,
+  onFailure: b,
+  InitialFormValues: y,
+  FormComponent: f,
+  FormComponentProps: C,
+  costEstimate: P,
+  showDynamicParams: u
+}) {
+  const { startBatonJob: d } = oe(r), { presetOptions: i, isLoading: h } = _(), { shapeComponentOptions: c } = te(r), { resourceOptions: g } = ee(), x = (O) => {
+    const { preset: I, shapeId: V, componentId: j, resourceId: L, batonDynamicParams: S } = O;
+    d(V, j, {
+      preset: I,
+      resourceId: L,
+      jobmetadata: S && [{ key: "batonDynamicParams", value: S }]
+    }).then(m).catch(b);
+  };
+  return /* @__PURE__ */ v("div", { className: J(t.root, "VdtBatonAnalysisDialog-root", o), children: [
+    /* @__PURE__ */ v(Q, { disableTypography: !0, children: [
+      /* @__PURE__ */ a(T, { variant: "h6", children: s }),
+      !h && !i.length && /* @__PURE__ */ a(T, { variant: "subtitle1", color: "error", children: n })
+    ] }),
+    /* @__PURE__ */ a(q, {}),
+    /* @__PURE__ */ a(
+      N,
+      {
+        itemId: r,
+        FormComponent: f,
+        FormComponentProps: C,
+        initialValues: y,
+        onSubmit: x,
+        render: se,
+        resources: g,
+        testplans: i,
+        onClose: l,
+        shapes: c,
+        submitText: p,
+        subscription: { submitting: !0, pristine: !0 },
+        costEstimate: P,
+        showDynamicParams: u
+      }
+    )
+  ] });
+}
+B.propTypes = {
+  classes: e.objectOf(e.any),
+  className: e.string,
+  itemId: e.string.isRequired,
+  onClose: e.func,
+  onSuccess: e.func,
+  onFailure: e.func,
+  titleText: e.string,
+  errorText: e.string,
+  submitText: e.string,
+  costEstimate: e.bool,
+  showDynamicParams: e.bool,
+  InitialFormValues: e.objectOf(e.any),
+  FormComponent: e.oneOfType([e.element, e.elementType]),
+  FormComponentProps: e.objectOf(e.any)
+};
+B.defaultProps = {
+  classes: {},
+  className: "VdtBatonAnalysisDialog",
+  onClose: () => {
+  },
+  onSuccess: () => {
+  },
+  onFailure: () => {
+  },
+  titleText: "Baton QC",
+  errorText: "Please configure testplans",
+  submitText: "Start QC",
+  costEstimate: !0,
+  showDynamicParams: !1,
+  InitialFormValues: { preset: null, shapeId: "", componentId: "" },
+  FormComponent: Z,
+  FormComponentProps: {}
+};
+const he = k({}, { name: "VdtBatonAnalysisDialog" })(B);
+export {
+  B as BatonAnalysisDialog,
+  he as default
+};

package/dist/es/analyze/BatonAnalysisForm.js

@@ -0,0 +1,164 @@
+import { jsxs as N, jsx as o } from "react/jsx-runtime";
+import { useMemo as j } from "react";
+import w from "clsx";
+import e from "prop-types";
+import { useFormState as A, Field as a } from "react-final-form";
+import { withStyles as B } from "@material-ui/core";
+import "../fields/CheckboxField.js";
+import "../fields/CheckboxGroupField.js";
+import "../fields/RadioField.js";
+import i from "../fields/SelectField.js";
+import C from "../fields/TextField.js";
+import "../fields/SliderField.js";
+import "../fields/TagField.js";
+import "../fields/DateField.js";
+import "../fields/SwitchField.js";
+import D from "../fields/AutocompleteField.js";
+import "../fields/AutocompleteConstraintField.js";
+function p({
+  classes: s,
+  className: d,
+  testplans: u,
+  testplansLabel: f,
+  noTestplansText: b,
+  resources: g,
+  resourcesLabel: h,
+  shapes: r,
+  shapesLabel: y,
+  componentsLabel: L,
+  dynamicParamsLabel: v,
+  validation: c,
+  showDynamicParams: x,
+  FieldProps: n,
+  form: F
+}) {
+  const {
+    // eslint-disable-next-line no-unused-vars
+    values: { shapeId: l, componentId: O }
+  } = A(), S = j(() => {
+    const t = r.find(({ value: m }) => m === l);
+    return (t == null ? void 0 : t.components) || [];
+  }, [l, r]), T = () => {
+    O && F.change("componentId", "");
+  };
+  return /* @__PURE__ */ N("form", { className: w(s.root, "VdtBatonAnalysisForm-root", d), children: [
+    /* @__PURE__ */ o(a, { name: "shapeId", children: ({ input: { name: t, value: m, onChange: P } }) => /* @__PURE__ */ o(
+      i,
+      {
+        name: t,
+        label: y,
+        value: m,
+        options: r,
+        onChange: (I) => {
+          T(), P(I);
+        }
+      }
+    ) }),
+    /* @__PURE__ */ o(
+      a,
+      {
+        validate: c,
+        allowNull: !0,
+        name: "componentId",
+        component: i,
+        options: S,
+        label: L,
+        disabled: !l,
+        ...n
+      }
+    ),
+    /* @__PURE__ */ o(
+      a,
+      {
+        validate: c,
+        allowNull: !0,
+        name: "preset",
+        component: D,
+        label: f,
+        options: u,
+        noOptionsText: b,
+        helperText: "",
+        ...n
+      }
+    ),
+    /* @__PURE__ */ o(
+      a,
+      {
+        name: "resourceId",
+        component: i,
+        label: h,
+        options: g,
+        ...n
+      }
+    ),
+    x && /* @__PURE__ */ o(
+      a,
+      {
+        name: "batonDynamicParams",
+        component: C,
+        label: v,
+        multiline: !0,
+        ...n
+      }
+    )
+  ] });
+}
+p.propTypes = {
+  classes: e.objectOf(e.any),
+  form: e.objectOf(e.any),
+  className: e.string,
+  testplans: e.arrayOf(
+    e.shape({
+      label: e.string,
+      value: e.string
+    })
+  ),
+  testplansLabel: e.string,
+  noTestplansText: e.string,
+  resources: e.arrayOf(
+    e.shape({
+      label: e.string,
+      value: e.string
+    })
+  ),
+  resourcesLabel: e.string,
+  shapes: e.arrayOf(
+    e.shape({
+      label: e.string,
+      value: e.string,
+      components: e.arrayOf(
+        e.shape({
+          label: e.string,
+          value: e.string
+        })
+      )
+    })
+  ),
+  shapesLabel: e.string,
+  componentsLabel: e.string,
+  dynamicParamsLabel: e.string,
+  validation: e.func,
+  showDynamicParams: e.bool,
+  FieldProps: e.objectOf(e.any)
+};
+p.defaultProps = {
+  classes: {},
+  form: {},
+  className: "VdtBatonAnalysisDialog",
+  testplans: [],
+  testplansLabel: "Select testplan",
+  noTestplansText: "No matching testplans",
+  resources: [],
+  resourcesLabel: "Select resource",
+  shapes: [],
+  shapesLabel: "Select shape",
+  componentsLabel: "Select component (optional)",
+  dynamicParamsLabel: "Dynamic parameters",
+  validation: (s) => s ? void 0 : "Required",
+  showDynamicParams: !1,
+  FieldProps: { FormControlProps: { margin: "normal" } }
+};
+const _ = B({}, { name: "VdtBatonAnalysisForm" })(p);
+export {
+  _ as default
+};

package/dist/es/collection/AddToCollectionDialog/AddToCollectionDialog.js

@@ -0,0 +1,186 @@
+import { jsx as o, jsxs as C } from "react/jsx-runtime";
+import { useState as h } from "react";
+import R from "clsx";
+import e from "prop-types";
+import { withStyles as B, TextField as W, DialogTitle as G, DialogContent as L, Tabs as H, Tab as y, DialogActions as J, Button as T } from "@material-ui/core";
+import { CreateNewFolder as K, Search as Q } from "@material-ui/icons";
+import { collection as b } from "@vidispine/vdt-api";
+import { parseMetadataType as U, createMetadataType as X } from "@vidispine/vdt-js";
+import Y from "../CollectionSearchPicker/index.js";
+function x(t, n) {
+  const r = t.map((l, a) => a % 100 === 0 ? t.slice(a, a + 100) : null).filter((l) => l);
+  return Promise.all(
+    r.flatMap(
+      (l) => n.map(
+        (a) => b.updateCollection({
+          collectionId: a,
+          collectionDocument: {
+            content: l.map(({ id: i, type: s, metadata: p }) => ({
+              id: i,
+              mode: "add",
+              type: s.toLowerCase(),
+              metadata: p
+            }))
+          },
+          queryParams: {
+            clear: !1
+          }
+        })
+      )
+    )
+  );
+}
+function Z(t, n) {
+  return b.createCollection({
+    collectionDocument: {
+      ...n
+    }
+  }).then((c) => {
+    const r = new Array(c.data.id);
+    x(t, r);
+  });
+}
+const _ = B(
+  {},
+  { name: "VdtCreateCollection" }
+)(({ collectionDocument: t, onChange: n, collectionNameText: c = "New Collection" }) => {
+  const { title: r = "" } = t.metadata ? U(t.metadata, { flat: !0, joinValue: "," }) : {}, l = (i) => ({
+    metadata: X({ title: i })
+  });
+  return /* @__PURE__ */ o(
+    W,
+    {
+      value: r,
+      required: !0,
+      autoFocus: !0,
+      margin: "dense",
+      label: c,
+      type: "text",
+      fullWidth: !0,
+      onChange: (i = {}) => {
+        const { target: { value: s } = {} } = i;
+        return n(s ? l(s) : {});
+      }
+    }
+  );
+}), ie = {
+  root: {}
+};
+function S({
+  classes: t,
+  className: n,
+  entities: c,
+  onClose: r,
+  onSubmit: l,
+  onCreate: a,
+  onSuccess: i,
+  onError: s,
+  CollectionPickerComponent: p,
+  CollectionPickerProps: P,
+  CreateCollectionComponent: v,
+  CreateCollectionProps: D,
+  defaultView: w,
+  titleText: j,
+  submitText: k,
+  searchText: I,
+  createdText: O,
+  cancelText: A,
+  CreateCollectionIcon: q,
+  SearchCollectionIcon: N
+}) {
+  const [d, V] = h(w), [u, z] = h([]), [f, E] = h({}), F = () => {
+    Promise.resolve(
+      d === "create" ? a(c, f) : l(c, u)
+    ).then((...m) => i(u, ...m)).catch((m) => s(u, m)).finally(() => r());
+  }, M = d === "search" ? u.length === 0 : Object.keys(f).length === 0;
+  return /* @__PURE__ */ C("div", { className: R(t.root, "VdtAddToCollectionDialog-root", n), children: [
+    /* @__PURE__ */ o(G, { children: j }),
+    /* @__PURE__ */ C(L, { children: [
+      /* @__PURE__ */ C(
+        H,
+        {
+          value: d,
+          onChange: (m, g) => g && V(g),
+          variant: "fullWidth",
+          textColor: "primary",
+          indicatorColor: "primary",
+          style: { marginBottom: "10px" },
+          children: [
+            /* @__PURE__ */ o(y, { value: "search", label: I, icon: /* @__PURE__ */ o(N, {}) }),
+            /* @__PURE__ */ o(y, { value: "create", label: O, icon: /* @__PURE__ */ o(q, {}) })
+          ]
+        }
+      ),
+      {
+        search: /* @__PURE__ */ o(p, { onChange: z, ...P }),
+        create: /* @__PURE__ */ o(
+          v,
+          {
+            collectionDocument: f,
+            onChange: E,
+            ...D
+          }
+        )
+      }[d]
+    ] }),
+    /* @__PURE__ */ C(J, { children: [
+      /* @__PURE__ */ o(T, { onClick: r, variant: "outlined", children: A }),
+      /* @__PURE__ */ o(T, { onClick: F, color: "primary", variant: "contained", disabled: M, children: k })
+    ] })
+  ] });
+}
+S.propTypes = {
+  classes: e.objectOf(e.string),
+  className: e.string,
+  entities: e.arrayOf(
+    e.shape({
+      id: e.string.isRequired,
+      type: e.string.isRequired
+    })
+  ).isRequired,
+  onClose: e.func,
+  onSubmit: e.func,
+  onCreate: e.func,
+  onSuccess: e.func,
+  onError: e.func,
+  CollectionPickerComponent: e.elementType,
+  CollectionPickerProps: e.objectOf(e.any),
+  CreateCollectionComponent: e.elementType,
+  CreateCollectionProps: e.objectOf(e.any),
+  defaultView: e.string,
+  titleText: e.string,
+  submitText: e.string,
+  searchText: e.string,
+  createdText: e.string,
+  cancelText: e.string,
+  CreateCollectionIcon: e.elementType,
+  SearchCollectionIcon: e.elementType
+};
+S.defaultProps = {
+  classes: {},
+  className: void 0,
+  CollectionPickerComponent: Y,
+  CreateCollectionComponent: _,
+  onClose: () => {
+  },
+  onSubmit: x,
+  onCreate: Z,
+  onSuccess: () => {
+  },
+  // eslint-disable-next-line no-console
+  onError: (t) => console.error(t),
+  CollectionPickerProps: {},
+  CreateCollectionProps: {},
+  defaultView: "search",
+  titleText: "Add to Collection",
+  submitText: "Add",
+  searchText: "Search",
+  createdText: "Create",
+  cancelText: "Cancel",
+  CreateCollectionIcon: K,
+  SearchCollectionIcon: Q
+};
+export {
+  S as default,
+  ie as styles
+};

package/dist/es/collection/AddToCollectionDialog/index.js

@@ -0,0 +1,7 @@
+import { withStyles as o } from "@material-ui/core";
+import l, { styles as t } from "./AddToCollectionDialog.js";
+const e = o(t, { name: "VdtAddToCollectionDialog" })(l);
+e.displayName = "AddToCollectionDialog";
+export {
+  e as default
+};

package/dist/es/collection/CollectionAccessTab.js

@@ -0,0 +1,56 @@
+import { jsxs as u, Fragment as A, jsx as t } from "react/jsx-runtime";
+import { useState as C, useEffect as b } from "react";
+import { withStyles as h, Box as T, FormControlLabel as g, Switch as x } from "@material-ui/core";
+import { useEntityAccess as S } from "@vidispine/vdt-react";
+import E from "../entity/EntityAccessAdd.js";
+import j from "../entity/EntityAccessTable.js";
+function v({
+  collectionId: o,
+  toggleAddLabelText: i = (e) => e ? "Cancel" : "Add permission",
+  showAddAccess: c = !0,
+  EntityAccessTableProps: l = {}
+}) {
+  const [e, s] = C(!1), r = () => s(!e), { accessControlList: a, onList: n, onRemove: m, onAdd: d } = S({
+    entityId: o,
+    entityType: "collection"
+  });
+  b(() => {
+    n();
+  }, [n]);
+  const f = (p) => m(p).then(n), y = () => {
+    n(), s(!1);
+  };
+  return /* @__PURE__ */ u(A, { children: [
+    c && /* @__PURE__ */ t(T, { display: "flex", justifyContent: "flex-end", children: /* @__PURE__ */ t(
+      g,
+      {
+        control: /* @__PURE__ */ t(x, { checked: e, onChange: r }),
+        label: i(e),
+        labelPlacement: "start"
+      }
+    ) }),
+    c && e ? /* @__PURE__ */ t(
+      E,
+      {
+        entityType: "collection",
+        entityId: o,
+        onSuccess: y,
+        onCancel: () => s(!1),
+        onSubmit: d
+      }
+    ) : /* @__PURE__ */ t(
+      j,
+      {
+        entityType: "collection",
+        entityId: o,
+        accessControlList: a,
+        onRemove: f,
+        ...l
+      }
+    )
+  ] });
+}
+const B = h({}, { name: "VdtCollectionAccessTab" })(v);
+export {
+  B as default
+};