@vidispine/vdt-react 23.2.0-pre.1 → 23.2.0

package/dist/index.js

@@ -1,61 +1,3630 @@
-export { handleAddEntity, handleMoveEntity, handleRemoveEntity } from './moveEntity.js';
-export { default as DropArea } from './DropArea.js';
-export { default as useApi } from './hooks/useApi.js';
-export { default as useSearch } from './hooks/useSearch.js';
-export { default as useAutocomplete } from './hooks/useAutocomplete.js';
-export { default as useInterval } from './hooks/useInterval.js';
-export { default as useThumbnailScrub } from './hooks/useThumbnailScrub.js';
-export { default as useJobSearch } from './hooks/useJobSearch.js';
-export { default as useUploadFiles } from './hooks/useUploadFiles.js';
-export { default as useQueryInitialState } from './hooks/useQueryInitialState.js';
-export { default as useUpdateQueryState } from './hooks/useUpdateQueryState.js';
-export { default as useSavedSearch } from './hooks/useSavedSearch.js';
-export { default as useSearchItem } from './hooks/useSearchItem.js';
-export { default as useGetCollection } from './hooks/useGetCollection.js';
-export { default as useGetCollectionItem } from './hooks/useGetCollectionItem.js';
-export { default as useUser } from './hooks/useUser.js';
-export { default as useSearchUser } from './hooks/useSearchUser.js';
-export { default as useSearchGroup } from './hooks/useSearchGroup.js';
-export { default as useGroup } from './hooks/useGroup.js';
-export { default as useGetItem } from './hooks/useGetItem.js';
-export { useHoverScrub } from './hooks/useHoverScrub.js';
-export { default as useDocSearchAutocomplete } from './hooks/useDocSearchAutocomplete.js';
-export { default as useGetFieldMetadataDataset } from './hooks/useGetFieldMetadataDataset.js';
-export { default as useGetSavedSearchFolders } from './hooks/useGetSavedSearchFolders.js';
-export { default as useCompoundMetadata } from './hooks/useCompoundMetadata.js';
-export { default as useGetEntityMetadata } from './hooks/useGetEntityMetadata.js';
-export { default as useGetFieldGroup } from './hooks/useGetFieldGroup.js';
-export { default as MetadataType } from './wrappers/MetadataType.js';
-export { default as SearchCollection } from './wrappers/SearchCollection.js';
-export { default as SearchItem } from './wrappers/SearchItem.js';
-export { default as SearchItemCollection } from './wrappers/SearchItemCollection.js';
-export { default as GetItem } from './wrappers/GetItem.js';
-export { default as GetCollection } from './wrappers/GetCollection.js';
-export { default as GetJobs } from './wrappers/GetJobs.js';
-export { default as ListEntityAccess } from './wrappers/ListEntityAccess.js';
-export { default as Auth } from './wrappers/Auth.js';
-export { default as GetFieldGroup } from './wrappers/GetFieldGroup.js';
-export { default as HasRole } from './wrappers/HasRole.js';
-export { default as ComposeProviders } from './wrappers/ComposeProviders.js';
-export { default as GetEntityMetadata } from './wrappers/GetEntityMetadata.js';
-export { default as useSelected } from './hooks/useSelected.js';
-export { default as useTab } from './hooks/useTab.js';
-export { default as useLocalStorage } from './hooks/useLocalStorage.js';
-export { default as useUpdateEffect } from './hooks/useUpdateEffect.js';
-export { default as useEntityAccess } from './hooks/useEntityAccess.js';
-export { default as useAddMetadataFieldAttributes } from './hooks/useAddMetadataFieldAttributes.js';
-export { default as useMouseDownPosition } from './hooks/useMouseDownPosition.js';
-export { default as useGetEntity } from './hooks/useGetEntity.js';
-export { default as useListGroup } from './hooks/useListGroup.js';
-export { default as useListUser } from './hooks/useListUser.js';
-export { default as useCollectionAutoPlay } from './hooks/useCollectionAutoPlay.js';
-export { default as useRepresentativeItems } from './hooks/useRepresentativeItems.js';
-export { default as useCsvDownload } from './hooks/useCsvDownload.js';
-export { default as VidispineApi } from './wrappers/VidispineApi.js';
-export { default as ErrorBoundary } from './wrappers/ErrorBoundary.js';
-export { default as withErrorBoundary } from './hoc/withErrorBoundary.js';
-export { default as compose } from './hoc/compose.js';
-export { BinContext, BinProvider } from './context/BinContext.js';
-export { RolesProvider, useRoles } from './context/RolesContext.js';
-export { SettingsProvider, useSettings, useSettingsActions } from './context/SettingsContext.js';
-export { AuthContext, AuthProvider, useAuthContext } from './context/AuthContext.js';
+import { useRef as z, useReducer as fe, useCallback as P, useEffect as $, useState as M, useMemo as he, Children as oe, cloneElement as se, Component as Je, createContext as Ee, useContext as Ie, isValidElement as _e } from "react";
+import { utils as J, search as Xe, vsimport as xe, collection as V, ChunkedTransferManager as Rt, ChunkedUpload as Pt, access as Pe, metadatafield as ze, fieldgroup as Ke, item as ue, library as ge, user as X, group as te, storage as Nt, job as Ze, file as It, metadata as Ne, noauth as et } from "@vidispine/vdt-api";
+import { createMetadataType as de, formatTimeCodeText as _t, formatTimeCodeSeconds as Gt, parseMetadataType as tt, ROLE_NAMES as bt } from "@vidispine/vdt-js";
+import { compressToEncodedURIComponent as wt, decompressFromEncodedURIComponent as Dt } from "lz-string";
+import Z from "use-deep-compare-effect";
+import rt from "lodash.debounce";
+import { jsx as B, jsxs as Ot } from "react/jsx-runtime";
+import { useCookies as nt } from "react-cookie";
+import ot from "react-is";
+const Ht = ({
+  hasLoaded: e = !1,
+  isLoading: t = !0,
+  isError: n = !1,
+  response: r = void 0,
+  data: o = void 0
+} = {}, s = void 0) => ({
+  isLoading: t,
+  hasLoaded: e,
+  isError: n,
+  response: r,
+  data: s && s.current ? s.current : o
+}), Lt = (e, t) => {
+  switch (t.type) {
+    case "START":
+      return {
+        ...e,
+        isLoading: !0,
+        isError: !1
+      };
+    case "SUCCESS": {
+      const { responseType: n } = t.response, r = {
+        isLoading: !1,
+        isError: !1,
+        hasLoaded: !0,
+        response: t.response,
+        data: t.response.data
+      };
+      return n && (r[n] = t.response[n]), r;
+    }
+    case "ERROR":
+      return {
+        isLoading: !1,
+        isError: !0,
+        hasLoaded: !0,
+        response: t.response,
+        data: t.response.data
+      };
+    case "CANCEL":
+      return {
+        ...e,
+        isLoading: !1,
+        isError: !1,
+        hasLoaded: !0
+      };
+    case "RESET":
+      return {
+        ...t.initialState
+      };
+    default:
+      return e;
+  }
+};
+function k(e, t, n) {
+  const r = z(() => null), o = Ht(t, n), s = z(o), [a, i] = fe(Lt, o), l = P(
+    (p) => (i({ type: "START" }), new Promise((m, d) => {
+      e({
+        cancelToken: new J.CancelToken((h) => {
+          r.current = h;
+        }),
+        ...p
+      }).then((h) => {
+        m(h), i({ type: "SUCCESS", response: h }), n && (n.current = h.data);
+      }).catch((h) => {
+        h.__CANCEL__ ? i({ type: "CANCEL" }) : (d(h), i({ type: "ERROR", response: h }));
+      });
+    })),
+    [e, n]
+  ), u = P(
+    () => i({ type: "RESET", initialState: s.current }),
+    []
+  ), c = P(() => r.current(), []);
+  return $(
+    () => () => {
+      c(), u();
+    },
+    [c, u]
+  ), {
+    request: l,
+    reset: u,
+    cancel: c,
+    ...a
+  };
+}
+const Ut = "CHANGE_PAGE", xt = "CHANGE_ROWS", Mt = "CHANGE_SORT", Ft = "CHANGE_SEARCHTEXT", qt = "CHANGE_SEARCHFIELD", $t = "CHANGE_SEARCHFIELDFACET", jt = "CHANGE_SEARCHFILTER", Wt = "CHANGE_SEARCHFILTERFACET", Vt = "CHANGE_PARENT_COLLECTION", kt = "CHANGE_FACET", Yt = "CHANGE_ITEMSEARCHDOCUMENT", Bt = "CHANGE_QUERYPARAMS", Qt = "CHANGE_MATRIXPARAMS", Jt = "CHANGE_SUGGESTION", x = {
+  CHANGE_PAGE: Ut,
+  CHANGE_ROWS: xt,
+  CHANGE_SORT: Mt,
+  CHANGE_SEARCHTEXT: Ft,
+  CHANGE_SEARCHFIELD: qt,
+  CHANGE_SEARCHFIELDFACET: $t,
+  CHANGE_SEARCHFILTER: jt,
+  CHANGE_SEARCHFILTERFACET: Wt,
+  CHANGE_PARENT_COLLECTION: Vt,
+  CHANGE_FACET: kt,
+  CHANGE_ITEMSEARCHDOCUMENT: Yt,
+  CHANGE_QUERYPARAMS: Bt,
+  CHANGE_MATRIXPARAMS: Qt,
+  CHANGE_SUGGESTION: Jt
+}, Xt = ({
+  queryParams: e = {},
+  matrixParams: t = {},
+  itemSearchDocument: n = {},
+  rowsPerPage: r = 10,
+  page: o = 0,
+  ...s
+} = {}) => ({
+  ...s,
+  queryParams: {
+    content: "metadata",
+    interval: "generic",
+    ...e
+  },
+  matrixParams: {
+    first: o * r + 1,
+    number: r,
+    ...t
+  },
+  itemSearchDocument: {
+    intervals: "generic",
+    filter: [],
+    ...n
+  },
+  rowsPerPage: r,
+  page: o
+}), zt = (e, t) => {
+  switch (t.type) {
+    case x.CHANGE_ITEMSEARCHDOCUMENT:
+      return {
+        ...e,
+        page: Number.isInteger(t.page) ? t.page : e.page,
+        itemSearchDocument: t.itemSearchDocument,
+        matrixParams: {
+          ...e.matrixParams,
+          first: Number.isInteger(t.page) ? t.page * e.rowsPerPage + 1 : e.matrixParams.first
+        }
+      };
+    case x.CHANGE_QUERYPARAMS:
+      return {
+        ...e,
+        queryParams: t.queryParams
+      };
+    case x.CHANGE_MATRIXPARAMS:
+      return {
+        ...e,
+        matrixParams: t.matrixParams
+      };
+    case x.CHANGE_PAGE:
+      return {
+        ...e,
+        page: t.page,
+        matrixParams: {
+          ...e.matrixParams,
+          first: t.page * e.rowsPerPage + 1
+        }
+      };
+    case x.CHANGE_ROWS:
+      return {
+        ...e,
+        rowsPerPage: t.rowsPerPage,
+        page: 0,
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1,
+          number: t.rowsPerPage
+        }
+      };
+    case x.CHANGE_SORT:
+      return {
+        ...e,
+        page: 0,
+        searchText: t.value,
+        sort: t.value,
+        itemSearchDocument: {
+          ...e.itemSearchDocument,
+          sort: t.field ? [
+            {
+              field: t.field,
+              order: t.order || "descending"
+            }
+          ] : []
+        },
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1
+        }
+      };
+    case x.CHANGE_SEARCHTEXT:
+      return {
+        ...e,
+        page: 0,
+        searchText: t.value,
+        itemSearchDocument: t.value ? {
+          ...e.itemSearchDocument,
+          text: [{ value: `${t.value}` }]
+        } : {
+          ...e.itemSearchDocument,
+          text: []
+        },
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1
+        }
+      };
+    case x.CHANGE_SEARCHFIELD:
+      return {
+        ...e,
+        page: 0,
+        field: t.field,
+        itemSearchDocument: t.field ? {
+          ...e.itemSearchDocument,
+          field: t.field
+        } : {
+          ...e.itemSearchDocument,
+          field: []
+        },
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1
+        }
+      };
+    case x.CHANGE_SEARCHFIELDFACET:
+      return {
+        ...e,
+        page: 0,
+        field: t.field,
+        facet: t.facet,
+        itemSearchDocument: t.field ? {
+          ...e.itemSearchDocument,
+          field: t.field,
+          facet: t.facet
+        } : {
+          ...e.itemSearchDocument,
+          field: [],
+          facet: []
+        },
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1
+        }
+      };
+    case x.CHANGE_SEARCHFILTER:
+      return {
+        ...e,
+        page: 0,
+        filter: t.filter,
+        itemSearchDocument: t.filter ? {
+          ...e.itemSearchDocument,
+          filter: t.filter
+        } : {
+          ...e.itemSearchDocument,
+          filter: []
+        },
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1
+        }
+      };
+    case x.CHANGE_SEARCHFILTERFACET:
+      return {
+        ...e,
+        page: 0,
+        filter: t.filter,
+        itemSearchDocument: t.filter ? {
+          ...e.itemSearchDocument,
+          filter: t.filter,
+          facet: t.facet
+        } : {
+          ...e.itemSearchDocument,
+          filter: [],
+          facet: []
+        },
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1
+        }
+      };
+    case x.CHANGE_FACET:
+      return {
+        ...e,
+        page: 0,
+        facet: t.facet,
+        itemSearchDocument: t.facet ? {
+          ...e.itemSearchDocument,
+          facet: t.facet
+        } : {
+          ...e.itemSearchDocument,
+          facet: []
+        },
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1
+        }
+      };
+    case x.CHANGE_PARENT_COLLECTION:
+      return {
+        ...e,
+        page: 0,
+        parentCollection: t.value,
+        itemSearchDocument: t.value ? {
+          ...e.itemSearchDocument,
+          operator: {
+            field: [
+              { name: "__parent_collection", value: [{ value: `${t.value}` }] },
+              { name: "__collection", value: [{ value: `${t.value}` }] }
+            ],
+            operation: "OR"
+          }
+        } : {
+          ...e.itemSearchDocument,
+          operator: void 0
+        },
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1
+        }
+      };
+    case x.CHANGE_SUGGESTION:
+      return {
+        ...e,
+        itemSearchDocument: {
+          ...e.itemSearchDocument,
+          suggestion: t.suggestion
+        }
+      };
+    default:
+      return e;
+  }
+};
+function Kt(e) {
+  const t = Xt(e), [n, r] = fe(zt, t), o = ({ target: { value: g } } = {}) => r({
+    type: x.CHANGE_ROWS,
+    rowsPerPage: g
+  }), s = ({ page: g }) => r({
+    type: x.CHANGE_PAGE,
+    page: g
+  }), a = (g, y, S) => r({
+    type: x.CHANGE_SORT,
+    field: y,
+    order: S
+  }), i = P(
+    (g) => r({
+      type: x.CHANGE_SEARCHTEXT,
+      value: g
+    }),
+    []
+  ), l = P(
+    (g, y) => r({
+      type: x.CHANGE_ITEMSEARCHDOCUMENT,
+      itemSearchDocument: g,
+      page: y
+    }),
+    []
+  ), u = P(
+    (g) => r({
+      type: x.CHANGE_QUERYPARAMS,
+      queryParams: g
+    }),
+    []
+  ), c = P(
+    (g) => r({
+      type: x.CHANGE_MATRIXPARAMS,
+      matrixParams: g
+    }),
+    []
+  ), p = P(
+    (g) => r({
+      type: x.CHANGE_SEARCHFIELD,
+      field: g
+    }),
+    []
+  ), m = P((g) => {
+    const y = g.map(({ name: S }) => ({ field: S, count: !0 }));
+    r({ type: x.CHANGE_SEARCHFIELDFACET, field: g, facet: y });
+  }, []), d = P(
+    (g) => r({
+      type: x.CHANGE_SEARCHFILTER,
+      filter: g
+    }),
+    []
+  ), h = P(
+    (g) => {
+      const S = g.reduce((R, { field: A = [] }) => R.concat(A), []).map(({ name: R }) => ({
+        name: R,
+        field: R,
+        count: !0,
+        exclude: [R]
+      }));
+      r({ type: x.CHANGE_SEARCHFILTERFACET, filter: g, facet: S });
+    },
+    [r]
+  ), f = P(
+    (g) => {
+      r({ type: x.CHANGE_FACET, facet: g });
+    },
+    [r]
+  ), C = P(
+    (g) => r({
+      type: x.CHANGE_PARENT_COLLECTION,
+      value: g
+    }),
+    []
+  ), v = P((g) => {
+    r({ type: x.CHANGE_SUGGESTION, suggestion: g });
+  }, []);
+  return {
+    state: n,
+    onChangeRowsPerPage: o,
+    onChangePage: s,
+    onChangeSort: a,
+    setSearchText: i,
+    setSearchField: p,
+    setSearchFieldFacet: m,
+    setSearchFilter: d,
+    setSearchFilterFacet: h,
+    setFacet: f,
+    setItemSearchDocument: l,
+    setQueryParams: u,
+    setMatrixParams: c,
+    setParentCollection: C,
+    setSuggestion: v
+  };
+}
+function st(e, t) {
+  const n = z(!1);
+  $(() => {
+    n.current ? e() : n.current = !0;
+  }, t);
+}
+const Zt = ({
+  field: e = void 0,
+  text: t = "",
+  maximumSuggestions: n = 10
+} = {}) => ({
+  field: e,
+  text: t,
+  maximumSuggestions: n
+});
+function Un(e) {
+  const t = Zt(e), [n, r] = M(t), o = P((u, c = "") => {
+    r((p) => ({ ...p, field: u, text: c }));
+  }, []), s = P((u) => {
+    r((c) => ({ ...c, text: u }));
+  }, []), a = P((u) => {
+    r((c) => ({ ...c, maximumSuggestions: u }));
+  }, []), { request: i, data: { suggestion: l = [] } = {} } = k(
+    Xe.searchAutoComplete
+  );
+  return st(() => {
+    i({ autocompleteRequestDocument: n });
+  }, [n]), {
+    suggestions: l,
+    setAutocompleteField: o,
+    setAutocompleteText: s,
+    setAutocompleteMaxSuggestions: a
+  };
+}
+const xn = (e = "id", t = []) => {
+  const [n, r] = M(t);
+  return {
+    selected: n,
+    onSelect: (i, l, u) => {
+      const c = u[e], p = n.findIndex((m) => m[e] === c);
+      if (p === -1 && l === !0)
+        l === !0 && r([...n, u]);
+      else if (p > -1 && l === !1) {
+        const m = [...n];
+        m.splice(p, 1), r(m);
+      }
+    },
+    onClear: () => r([]),
+    isSelected: (i) => {
+      const l = i[e];
+      return n.findIndex((c) => c[e] === l) > -1;
+    }
+  };
+}, Mn = (e) => {
+  const [t, n] = M(e);
+  return { activeTab: t, changeTab: (o, s) => n(s) };
+};
+function Fn(e, t) {
+  const n = z();
+  $(() => {
+    n.current = e;
+  }, [e]), $(() => {
+    const o = setInterval(() => n.current(), t);
+    return () => clearInterval(o);
+  }, [t]);
+}
+function qn(e = []) {
+  const t = z(), n = he(() => Math.floor(e.length / 2), [e]), [r, o] = M(), s = z(r);
+  if ($(() => () => t.current && clearInterval(t.current), []), e.length === 0)
+    return { width: 0 };
+  s.current = r;
+  const a = () => {
+    const p = () => {
+      s.current === void 0 ? o(0) : s.current === e.length - 1 ? clearInterval(t.current) : o(s.current + 1);
+    };
+    t.current = setInterval(p, 500);
+  }, i = () => {
+    o(), clearInterval(t.current);
+  }, l = e[r === void 0 ? n : r], u = r === void 0 ? 0 : `${Math.floor(r / (e.length - 1) * 100)}%`;
+  return {
+    imageSrc: l,
+    onMouseEnter: a,
+    onMouseLeave: i,
+    width: u
+  };
+}
+const er = "CHANGE_PAGE", tr = "CHANGE_ROWS", rr = "CHANGE_SORT", nr = "CHANGE_TYPE", or = "CHANGE_STATE", sr = "CHANGE_PRIORITY", ar = "CHANGE_STARTTIME", ir = "CHANGE_FINISHTIME", Y = {
+  CHANGE_PAGE: er,
+  CHANGE_ROWS: tr,
+  CHANGE_SORT: rr,
+  CHANGE_TYPE: nr,
+  CHANGE_STATE: or,
+  CHANGE_PRIORITY: sr,
+  CHANGE_STARTTIME: ar,
+  CHANGE_FINISHTIME: ir
+}, cr = ({ queryParams: e = {}, matrixParams: t = {} } = {}) => ({
+  queryParams: e,
+  matrixParams: {
+    first: 1,
+    number: 10,
+    ...t
+  },
+  rowsPerPage: 10,
+  page: 0,
+  jobMetadata: []
+}), ur = (e, t) => {
+  const { type: n, ...r } = t;
+  switch (n) {
+    case Y.CHANGE_PAGE: {
+      const { page: o = 0 } = t, { rowsPerPage: s = 10 } = e;
+      return {
+        ...e,
+        page: o,
+        matrixParams: {
+          ...e.matrixParams,
+          first: o * s + 1
+        }
+      };
+    }
+    case Y.CHANGE_ROWS: {
+      const { rowsPerPage: o } = t;
+      return {
+        ...e,
+        rowsPerPage: o,
+        page: 0,
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1,
+          number: o
+        }
+      };
+    }
+    case Y.CHANGE_SORT: {
+      const { field: o, order: s = "desc" } = t;
+      return {
+        ...e,
+        page: 0,
+        matrixParams: {
+          ...e.matrixParams,
+          first: 1,
+          sort: `${o} ${s}`
+        }
+      };
+    }
+    case Y.CHANGE_TYPE:
+    case Y.CHANGE_STATE:
+    case Y.CHANGE_PRIORITY: {
+      const { field: o, value: s = [] } = r;
+      let a;
+      if (s)
+        a = {
+          ...e.matrixParams,
+          first: 1,
+          [o]: Array.isArray(s) ? s.join(",") : s
+        };
+      else {
+        const { [o]: i, ...l } = e.matrixParams;
+        a = { ...l, first: 1 };
+      }
+      return {
+        ...e,
+        page: 0,
+        matrixParams: a
+      };
+    }
+    case Y.CHANGE_STARTTIME:
+    case Y.CHANGE_FINISHTIME: {
+      const { field: o, value: s = [] } = r;
+      let a;
+      if (s)
+        a = {
+          ...e.queryParams,
+          first: 1,
+          [o]: s
+        };
+      else {
+        const { [o]: i, ...l } = e.queryParams;
+        a = { ...l, first: 1 };
+      }
+      return {
+        ...e,
+        page: 0,
+        queryParams: a
+      };
+    }
+    case Y.CHANGE_JOBMETADATA: {
+      const { field: o, value: s = [] } = r;
+      let a;
+      if (s.length)
+        a = {
+          ...e.queryParams,
+          first: 1,
+          [o]: s
+        };
+      else {
+        const { [o]: i, ...l } = e.queryParams;
+        a = { ...l, first: 1 };
+      }
+      return {
+        ...e,
+        page: 0,
+        queryParams: a,
+        jobMetadata: s
+      };
+    }
+    default:
+      return e;
+  }
+};
+function $n(e) {
+  const t = cr(e), [n, r] = fe(ur, t);
+  return {
+    state: n,
+    onChangePage: ({ page: d }) => r({
+      type: Y.CHANGE_PAGE,
+      page: d
+    }),
+    onChangeSort: (d, h, f) => {
+      const C = typeof h == "object" ? h.value : h;
+      r({
+        type: Y.CHANGE_SORT,
+        field: C,
+        order: f
+      });
+    },
+    onChangeType: ({ field: d = [] }) => {
+      const [{ name: h = "type", value: f = [] }] = d;
+      r({
+        type: Y.CHANGE_TYPE,
+        field: h,
+        value: f.length ? f[0].value : null
+      });
+    },
+    onChangeState: ({ field: d = [] }) => {
+      const [{ name: h = "state", value: f = [] }] = d;
+      r({
+        type: Y.CHANGE_STATE,
+        field: h,
+        value: f.length ? f[0].value : null
+      });
+    },
+    onChangePriority: ({ field: d = [] }) => {
+      const [{ name: h = "priority", value: f = [] }] = d;
+      r({
+        type: Y.CHANGE_PRIORITY,
+        field: h,
+        value: f.length ? f[0].value : null
+      });
+    },
+    onChangeStarttime: ({ field: d = [] }) => {
+      const [{ name: h = "starttime-from", value: f = [] }] = d;
+      r({
+        type: Y.CHANGE_STARTTIME,
+        field: h,
+        value: f.length ? f[0].value : null
+      });
+    },
+    onChangeFinishtime: ({ field: d = [] }) => {
+      const [{ name: h = "finishtime-from", value: f = [] }] = d;
+      r({
+        type: Y.CHANGE_FINISHTIME,
+        field: h,
+        value: f.length ? f[0].value : null
+      });
+    },
+    onChangeRowsPerPage: ({ target: { value: d } } = {}) => r({
+      type: Y.CHANGE_ROWS,
+      rowsPerPage: d
+    }),
+    onChangeJobmetadata: (d) => {
+      r({
+        type: Y.CHANGE_JOBMETADATA,
+        field: "jobmetadata",
+        value: d
+      });
+    }
+  };
+}
+const jn = (e, t) => {
+  const [n, r] = M(
+    JSON.parse(window.localStorage.getItem(e) || JSON.stringify(t))
+  );
+  return $(() => {
+    window.localStorage.setItem(e, JSON.stringify(n));
+  }, [e, n]), [n, r, () => JSON.parse(window.localStorage.getItem(e))];
+};
+function at() {
+  return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(
+    /[018]/g,
+    (e) => (
+      // eslint-disable-next-line
+      (e ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> e / 4).toString(16)
+    )
+  );
+}
+function lr(e) {
+  return wt(e);
+}
+function dr(e) {
+  return e.slice(-1) === "=" ? decodeURIComponent(
+    atob(e).split("").map((t) => `%${`00${t.charCodeAt(0).toString(16)}`.slice(-2)}`).join("")
+  ) : Dt(e);
+}
+const fr = ["__mp3_160k"], mr = ["__mp4"], pr = ["__png"], hr = "audio", Er = "video", gr = "image", yr = ["application/mxf"], Ar = [], Cr = [], Sr = (e) => {
+  if (!e || !e.type)
+    return [];
+  const t = e.type.toLowerCase();
+  return t.startsWith(hr) || Cr.includes(t) ? fr : t.startsWith(Er) || yr.includes(t) ? mr : t.startsWith(gr) || Ar.includes(t) ? pr : [];
+}, vr = (e, t = {}) => new Promise((n, r) => {
+  const o = new Rt(), s = new Pt(e, {
+    onFail: (a) => r(a),
+    onComplete: (a) => n(a),
+    ...t
+  });
+  o.addChunkedUpload(s), o.upload();
+}), Tr = ({
+  file: e,
+  collectionId: t,
+  onProgress: n,
+  metadata: r = {},
+  placeholderParams: o = {},
+  importParams: s = {},
+  chunkedUploadProps: a = {},
+  generateTransferId: i = at,
+  getShapeTags: l = Sr
+}) => new Promise((u, c) => {
+  try {
+    let p;
+    n({});
+    const m = l(e), d = e.name, h = e.type, [f] = h.split("/"), C = {
+      originalFilename: d,
+      mimeType: h,
+      mediaType: f,
+      ...r
+    }, v = de(C);
+    xe.createImportPlaceholder({
+      metadataDocument: v,
+      queryParams: {
+        container: 1,
+        ...o
+      }
+    }).then(({ data: g }) => {
+      if (p = g.id, !t)
+        return Promise.resolve();
+      const y = Array.isArray(t) ? t : [t];
+      return Promise.all(
+        y.map(
+          (S) => V.addCollectionEntity({
+            collectionId: S,
+            entityId: p
+          })
+        )
+      );
+    }).then(() => {
+      const g = i(), y = {
+        filename: d,
+        transferId: g,
+        tag: m,
+        ...s
+      };
+      return vr(e, {
+        api: {
+          method: xe.createImportComponentRaw,
+          props: {
+            itemId: p,
+            component: "container",
+            queryParams: y
+          }
+        },
+        onProgress: n,
+        ...a
+      });
+    }).then((g) => {
+      u({ ...g, itemId: p, collectionId: t });
+    }).catch((g) => c(g));
+  } catch (p) {
+    console.error(p), c(p);
+  }
+});
+function Wn({
+  onUploadFile: e = Tr,
+  initialMetadata: t = {},
+  ...n
+}) {
+  const [r, o] = M([]);
+  $(
+    () => () => {
+      r.forEach((m) => URL.revokeObjectURL(m.preview));
+    },
+    [r]
+  );
+  const s = P(
+    (m = []) => {
+      const d = m.map((h) => ({
+        file: h,
+        metadata: { title: h.name, ...t }
+      }));
+      o((h) => d.concat(h));
+    },
+    [t]
+  ), a = P(
+    (m, d = {}) => {
+      o((h) => {
+        const f = h[m], { metadata: C, progress: v } = d, { metadata: g = {}, progress: y = {} } = f, S = [...h], R = { ...f };
+        return C && (R.metadata = { ...g, ...C }), v && (R.progress = { ...y, ...v }), S[m] = R, S;
+      });
+    },
+    [o]
+  ), i = P(
+    (m) => (d = {}) => {
+      a(m, { progress: d });
+    },
+    [a]
+  ), l = P(
+    (m) => (d = {}) => {
+      a(m, { metadata: d });
+    },
+    [a]
+  ), u = P(
+    (m) => r.reduce(
+      (d, h, f) => d.then((C) => h.progress ? d : e({
+        file: h.file,
+        onProgress: i(f),
+        metadata: h.metadata,
+        ...m,
+        ...n
+      }).then((v) => [...C, v])),
+      Promise.resolve([])
+    ),
+    [r, e, i, n]
+  ), c = P(
+    (m) => () => {
+      o([...r].filter((d, h) => h !== m));
+    },
+    [o, r]
+  ), p = P(
+    (m) => () => {
+      o([...r].filter((d, h) => !m.includes(h)));
+    },
+    [o, r]
+  );
+  return {
+    onAddFiles: s,
+    onChangeFile: a,
+    onChangeMetadata: l,
+    onUpload: u,
+    onRemoveFile: c,
+    onRemoveFiles: p,
+    files: r,
+    setFiles: o
+  };
+}
+function Vn({
+  history: e,
+  navigate: t,
+  location: n,
+  queryName: r = "q",
+  defaultState: o = void 0
+}) {
+  const s = z(o);
+  return { queryInitialState: he(() => {
+    const { location: i = n } = e || {}, u = new URLSearchParams(i.search).get(r);
+    if (!u)
+      return s.current;
+    try {
+      const c = dr(u);
+      return JSON.parse(c);
+    } catch {
+      e ? e.replace({ pathName: e.location.pathName, search: "" }) : t && t(i.pathName, { replace: !0 });
+    }
+  }, [e, t, n, r]) };
+}
+function kn({
+  history: e,
+  navigate: t,
+  location: n,
+  state: r,
+  queryName: o = "q"
+}) {
+  const s = P(() => {
+    const { location: a = n } = e || {}, i = lr(JSON.stringify(r));
+    e ? e.replace({
+      pathName: a.pathName,
+      search: `?${o}=${i}`
+    }) : t && t(`${a.pathName}?${o}=${i}`, { replace: !0 });
+  }, [e, t, n, o, r]);
+  st(() => {
+    s(r);
+  }, [s, r]);
+}
+const Yn = ({ entityId: e, entityType: t }) => {
+  const {
+    request: n,
+    data: r = {},
+    isLoading: o
+  } = k(Pe.listEntityAccess), s = P(
+    (l = {}) => n({
+      entityId: e,
+      entityType: t,
+      ...l
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [e, t]
+  ), a = P(
+    ({ accessId: l, ...u }) => Pe.removeEntityAccess({
+      accessId: l,
+      entityId: e,
+      entityType: t,
+      ...u
+    }),
+    [e, t]
+  ), i = P(
+    ({ accessControlDocument: l, ...u }) => Pe.createEntityAccess({
+      entityType: t,
+      entityId: e,
+      accessControlDocument: l,
+      ...u
+    }),
+    [e, t]
+  );
+  return {
+    accessControlList: r,
+    isLoading: o,
+    onList: s,
+    onRemove: a,
+    onAdd: i
+  };
+}, it = ({ data: e = [] } = {}, t = void 0) => {
+  if (!t)
+    return;
+  const { value: n } = e.find((r) => r.key === t) || {};
+  return n;
+}, Rr = (e, t) => Object.assign(
+  {},
+  ...t.map((n) => ({
+    [n]: it(e, n)
+  }))
+), Pr = ({ values: { field: e } = {} } = {}) => e ? e.map((t) => ({ value: t.value, label: t.key || t.value })) : void 0, Nr = (e) => {
+  const n = new DOMParser().parseFromString(e, "application/xml").getElementsByTagName("field");
+  if (!n.length)
+    return;
+  const r = { field: [] };
+  for (let o = 0; o < n.length; o += 1) {
+    const [s, a] = n[o].childNodes;
+    r.field.push({
+      [s.nodeName]: s.firstChild.nodeValue,
+      [a.nodeName]: a.firstChild.nodeValue
+    });
+  }
+  return r;
+}, Bn = ({
+  fields: e,
+  groups: t,
+  getDataAttributes: n = Rr,
+  fieldDataToInclude: r = "label,displayType,required",
+  groupDataToInclude: o = "label,order",
+  fieldQueryParams: s = {},
+  groupQueryParams: a = {},
+  getAttributes: i = !0
+}) => {
+  const [l, u] = M(!1), [c, p] = M(e), [m, d] = M(t);
+  return Z(() => {
+    let h = !1;
+    if (i === !1)
+      return () => {
+        h = !0;
+      };
+    const f = (g = [], y = {}) => g.map(({ name: S, ...R }) => {
+      const A = y[S] || {}, { label: N, ..._ } = n(
+        A,
+        r.split(",")
+      );
+      return {
+        name: S,
+        label: N || S,
+        type: A.type,
+        constraint: A.constraint,
+        options: Pr(A),
+        ..._,
+        ...R
+      };
+    }), C = (g = [], y = {}, S = {}) => g.map(({ name: R, field: A, group: N, ..._ }) => {
+      const G = y[R] || {}, j = A || G && G.field, W = N || G && G.group, { label: Q, ...re } = n(
+        G,
+        o.split(",")
+      );
+      return {
+        name: R,
+        label: Q || R,
+        order: it(G, "order"),
+        fields: f(j, S),
+        groups: C(W, y, S),
+        ...re,
+        ..._
+      };
+    });
+    async function v() {
+      u(!0);
+      const g = {}, y = {};
+      let S = [];
+      if (e) {
+        const A = { ...s, data: r };
+        S = e.map(async ({ name: N }) => {
+          try {
+            const { data: _ } = await ze.getMetadataField({
+              fieldName: N,
+              queryParams: A
+            });
+            g[N] = _;
+          } catch {
+            console.warn(`Could not retrieve attributes for ${N}`);
+          }
+        });
+      }
+      let R = [];
+      if (t) {
+        const A = [...t], N = { ...a, data: o };
+        R = A.map(async ({ name: _ }) => {
+          try {
+            const { data: G } = await Ke.getFieldGroup({
+              groupName: _,
+              queryParams: N
+            }), { field: j = [], group: W = [] } = G;
+            j.forEach((Q) => {
+              const re = Q.data && Q.data.find((ne) => ne.key === "__values");
+              if (re) {
+                const ne = Nr(re.value);
+                g[Q.name] = { ...Q, values: ne };
+              }
+            }), W.forEach((Q) => {
+              A.push(Q);
+            }), y[_] = G;
+          } catch {
+            console.warn(`Could not retrieve attributes for ${_}`);
+          }
+        });
+      }
+      await Promise.all([...S, ...R]), h || (Object.values(g).some((A) => A) && p(() => f(e, g)), Object.values(y).some((A) => A) && d(() => {
+        const A = C(
+          t,
+          y,
+          g
+        );
+        return A.forEach((N) => {
+          const { order: _ } = N;
+          _ && N.fields.sort((G, j) => _.indexOf(G.name) - _.indexOf(j.name));
+        }), A;
+      }), u(!1));
+    }
+    return v(), () => {
+      h = !0;
+    };
+  }, [
+    e,
+    t,
+    r,
+    o,
+    s,
+    a,
+    i
+  ]), { fieldsWithAttributes: c, groupsWithAttributes: m, isLoading: l };
+}, Ir = 1e3, _r = "TRANSIENT";
+function Gr({ metadata: e, markerField: t, markerValue: n, itemSearchDocument: r }) {
+  return ue.searchItem({
+    queryParams: {
+      result: "library",
+      updateMode: _r,
+      updateFrequency: Ir
+    },
+    itemSearchDocument: r
+  }).then(
+    ({ data: { library: o } }) => V.createCollection({
+      collectionDocument: {
+        metadata: t ? de({
+          [t]: n || o,
+          ...e
+        }) : e,
+        content: [
+          {
+            id: o,
+            type: "library"
+          }
+        ]
+      }
+    })
+  );
+}
+const ct = ({ collectionId: e }) => new Promise((t, n) => {
+  V.getCollection({ collectionId: e, queryParams: { children: "library" } }).then(
+    ({ data: r }) => {
+      const { content: o = [] } = r, [s] = o;
+      s || n(new Error("No Libraries")), t(s);
+    }
+  );
+}), br = ({ collectionId: e }) => ct({ collectionId: e }).then(
+  ({ id: t }) => Promise.all([
+    ge.removeLibrary({ libraryId: t }),
+    V.removeCollection({ collectionId: e })
+  ])
+);
+function wr({ libraryId: e }) {
+  return new Promise((t) => {
+    ge.getLibrarySettings({ libraryId: e }).then(({ data: { query: n } }) => {
+      t(n);
+    });
+  });
+}
+const Dr = ({ collectionId: e }) => new Promise((t) => {
+  ct({ collectionId: e }).then(({ id: n }) => wr({ libraryId: n })).then(t);
+});
+function Qn({
+  markerField: e,
+  markerValue: t,
+  initialSearchState: n,
+  onSaveSearch: r = Gr,
+  onDeleteSearch: o = br,
+  onUpdateSearchMetadata: s = V.updateCollectionMetadata,
+  onGetSavedSearchSettings: a = Dr
+}) {
+  const i = P(
+    ({ metadata: m, itemSearchDocument: d }) => r({
+      metadata: m,
+      markerField: e,
+      markerValue: t,
+      itemSearchDocument: d
+    }),
+    [e, t, r]
+  ), l = (m = {}) => ({
+    ...m,
+    operator: {
+      field: [
+        {
+          name: e,
+          value: [{ value: t || "*" }]
+        }
+      ],
+      operator: m.operator ? [m.operator] : [],
+      operation: "AND"
+    }
+  }), u = Kt({
+    ...n,
+    itemSearchDocument: l()
+  }), { setItemSearchDocument: c, ...p } = u;
+  return {
+    onSaveSearch: i,
+    onDeleteSearch: o,
+    onUpdateSearchMetadata: s,
+    onGetSavedSearchSettings: a,
+    searchProps: {
+      setItemSearchDocument: (m) => c(l(m)),
+      ...p
+    }
+  };
+}
+function Or({ itemSearchDocument: e, queryParams: t, matrixParams: n }) {
+  const {
+    request: r,
+    data: o = {},
+    isLoading: s,
+    isError: a,
+    cancel: i
+  } = k(ue.searchItem), l = () => r({ itemSearchDocument: e, queryParams: t, matrixParams: n });
+  return Z(() => {
+    l();
+  }, [e, t, n]), {
+    itemListType: o,
+    isLoading: s,
+    isError: a,
+    onRefresh: l,
+    cancel: i
+  };
+}
+const Jn = () => {
+  const [e, t] = M({ x: 0, y: 0 });
+  return $(() => {
+    const n = (r) => t({ x: r.clientX, y: r.clientY });
+    return window.addEventListener("mousedown", n), () => {
+      window.removeEventListener("mousedown", n);
+    };
+  }, []), e;
+};
+function Hr({
+  collectionId: e,
+  queryParams: t = {},
+  refreshOnMount: n = !0
+}) {
+  const {
+    request: r,
+    data: o = {},
+    isLoading: s,
+    isError: a
+  } = k(V.getCollection), i = () => r({ collectionId: e, queryParams: t });
+  return Z(() => {
+    n && i();
+  }, [e, t]), {
+    collectionType: o,
+    isLoading: s,
+    isError: a,
+    onRefresh: i
+  };
+}
+function Xn({
+  collectionId: e,
+  queryParams: t = {},
+  refreshOnMount: n = !0
+}) {
+  const { request: r, data: o = {} } = k(V.getCollectionItem), s = () => r({ collectionId: e, queryParams: t });
+  return Z(() => {
+    n && s();
+  }, [e, t]), {
+    itemListType: o,
+    onRefresh: s
+  };
+}
+const zn = ({ entityId: e, entityType: t }) => {
+  let n, r, o;
+  switch (t) {
+    case "collection":
+      n = "collectionType", o = "collectionId", r = V.getCollection;
+      break;
+    case "library":
+      n = "libraryType", o = "libraryId", r = ge.getLibrary;
+      break;
+    case "item":
+      n = "itemType", o = "itemId", r = ue.getItem;
+      break;
+    default:
+      throw new Error("unknown entityType");
+  }
+  const { request: s, data: a, ...i } = k(r), l = P(
+    (u) => s({ [o]: e, ...u }),
+    [e, o, s]
+  );
+  return {
+    [n]: a,
+    [o]: e,
+    onGetEntity: l,
+    ...i
+  };
+};
+function Kn(e) {
+  const { data: t, request: n } = k(X.getUser, { data: e }), { userName: r } = t || {}, o = P(() => n({ userName: r }), [n, r]);
+  $(() => {
+    r && o();
+  }, [o, r]);
+  const s = P(
+    ({ userDocument: m }) => X.updateUser({
+      userName: r,
+      userDocument: m
+    }).then(() => n({ userName: m.userName })),
+    [n, r]
+  ), a = P(
+    ({ groups: m = [] }) => X.updateUserGroup({
+      userName: r,
+      groupListDocument: {
+        group: m.map((d) => ({ groupName: d }))
+      }
+    }).then(o),
+    [o, r]
+  ), i = P(
+    (m) => te.removeGroupUser({
+      groupName: m,
+      userName: r
+    }).then(o),
+    [o, r]
+  ), l = P(
+    (m) => X.updateUser({
+      userName: r,
+      userDocument: {
+        password: m
+      },
+      queryParams: {
+        passwordType: "raw"
+      }
+    }),
+    [r]
+  );
+  return {
+    userType: t,
+    getUser: o,
+    updateUser: s,
+    updateUserGroups: a,
+    removeUserFromGroup: i,
+    disableUser: (m) => X.disableUser({ userName: r, ...m }).then(o),
+    enableUser: (m) => X.enableUser({ userName: r, ...m }).then(o),
+    deleteUser: ({ queryParams: m = {} } = {}) => X.disableUser({ userName: r, queryParams: { hard: !0, ...m } }),
+    changePassword: l
+  };
+}
+const Lr = "CHANGE_PAGE", Ur = "CHANGE_ROWS", xr = "CHANGE_SORT", Mr = "CHANGE_QUERY", ce = {
+  CHANGE_PAGE: Lr,
+  CHANGE_ROWS: Ur,
+  CHANGE_SORT: xr,
+  CHANGE_QUERY: Mr
+}, Fr = ({ queryParams: e = {}, rowsPerPage: t = 10, page: n = 0 } = {}) => ({
+  queryParams: {
+    first: n * t + 1,
+    number: t,
+    ...e
+  },
+  rowsPerPage: t,
+  page: n,
+  userSearchDocument: {
+    sort: [
+      {
+        field: "username",
+        order: "ascending"
+      }
+    ]
+  }
+}), qr = (e, t) => {
+  const { type: n } = t;
+  switch (n) {
+    case ce.CHANGE_PAGE: {
+      const { page: r } = t;
+      return {
+        ...e,
+        page: r,
+        queryParams: {
+          ...e.queryParams,
+          first: r * e.rowsPerPage + 1
+        }
+      };
+    }
+    case ce.CHANGE_ROWS: {
+      const { rowsPerPage: r } = t;
+      return {
+        ...e,
+        rowsPerPage: r,
+        page: 0,
+        queryParams: {
+          ...e.queryParams,
+          first: 1,
+          number: r
+        }
+      };
+    }
+    case ce.CHANGE_QUERY:
+      return {
+        ...e,
+        page: 0,
+        userSearchDocument: {
+          ...e.userSearchDocument,
+          field: [
+            {
+              name: t.field || "username",
+              value: t.query || ""
+            }
+          ]
+        },
+        queryParams: {
+          ...e.queryParams,
+          first: 1
+        }
+      };
+    default:
+      return e;
+  }
+};
+function Zn(e) {
+  const t = Fr(e), [n, r] = fe(qr, t), {
+    data: o,
+    request: s,
+    hasLoaded: a,
+    isError: i
+  } = k(X.searchUser), l = () => s({
+    userSearchDocument: n.userSearchDocument,
+    queryParams: n.queryParams
+  });
+  return $(() => {
+    l();
+  }, [n.queryParams, n.userSearchDocument]), {
+    ...n,
+    hasLoaded: a,
+    isError: i,
+    userListDocument: o,
+    onSearchUser: l,
+    onChangePage: ({ page: d }) => r({
+      type: ce.CHANGE_PAGE,
+      page: d
+    }),
+    onChangeSort: (d, h, f) => {
+      const C = typeof h == "object" ? h.value : h;
+      r({
+        type: ce.CHANGE_SORT,
+        field: C,
+        order: f
+      });
+    },
+    onChangeRowsPerPage: ({ target: { value: d } } = {}) => r({
+      type: ce.CHANGE_ROWS,
+      rowsPerPage: d
+    }),
+    onChangeQuery: (d, h) => {
+      r({
+        type: ce.CHANGE_QUERY,
+        field: d,
+        query: h
+      });
+    }
+  };
+}
+const eo = (e) => {
+  const { request: t, data: n = {}, isLoading: r } = k(te.listGroup), o = () => t(e);
+  return $(() => {
+    o();
+  }, [e]), {
+    onRefresh: o,
+    groupListType: n,
+    isLoading: r
+  };
+}, to = (e) => {
+  const { request: t, data: n = {}, isLoading: r } = k(X.listUser), o = () => t(e);
+  return $(() => {
+    o();
+  }, [e]), {
+    onRefresh: o,
+    userListType: n,
+    isLoading: r
+  };
+}, $r = "CHANGE_PAGE", jr = "CHANGE_ROWS", Wr = "CHANGE_SORT", Vr = "CHANGE_QUERY", kr = "HIDE_ROLES", ae = {
+  CHANGE_PAGE: $r,
+  CHANGE_ROWS: jr,
+  CHANGE_SORT: Wr,
+  CHANGE_QUERY: Vr,
+  HIDE_ROLES: kr
+}, Yr = ({ queryParams: e = {}, rowsPerPage: t = 10, page: n = 0 } = {}) => ({
+  queryParams: {
+    first: n * t + 1,
+    number: t,
+    ...e
+  },
+  rowsPerPage: t,
+  page: n,
+  groupSearchDocument: {}
+}), Br = (e, t) => {
+  const { type: n } = t;
+  switch (n) {
+    case ae.CHANGE_PAGE: {
+      const { page: r } = t;
+      return {
+        ...e,
+        page: r,
+        queryParams: {
+          ...e.queryParams,
+          first: r * e.rowsPerPage + 1
+        }
+      };
+    }
+    case ae.CHANGE_ROWS: {
+      const { rowsPerPage: r } = t;
+      return {
+        ...e,
+        rowsPerPage: r,
+        page: 0,
+        queryParams: {
+          ...e.queryParams,
+          first: 1,
+          number: r
+        }
+      };
+    }
+    case ae.HIDE_ROLES: {
+      const { hideRoles: r } = t, o = r === !0 ? !1 : void 0;
+      return {
+        ...e,
+        page: 0,
+        queryParams: {
+          ...e.queryParams,
+          first: 1,
+          role: o
+        }
+      };
+    }
+    case ae.CHANGE_QUERY:
+      return {
+        ...e,
+        page: 0,
+        groupSearchDocument: {
+          ...e.groupSearchDocument,
+          field: [
+            {
+              name: t.field || "groupname",
+              value: t.query || ""
+            }
+          ]
+        },
+        queryParams: {
+          ...e.queryParams,
+          first: 1
+        }
+      };
+    default:
+      return e;
+  }
+};
+function ro(e) {
+  const t = Yr(e), [n, r] = fe(Br, t), {
+    data: o,
+    request: s,
+    hasLoaded: a,
+    isError: i
+  } = k(te.searchGroup), l = () => s({
+    groupSearchDocument: n.groupSearchDocument,
+    queryParams: n.queryParams
+  });
+  return $(() => {
+    l();
+  }, [n.queryParams, n.groupSearchDocument]), {
+    ...n,
+    hasLoaded: a,
+    isError: i,
+    groupListDocument: o,
+    onSearchGroup: l,
+    onChangePage: ({ page: h }) => r({
+      type: ae.CHANGE_PAGE,
+      page: h
+    }),
+    onChangeSort: (h, f, C) => {
+      const v = typeof f == "object" ? f.value : f;
+      r({
+        type: ae.CHANGE_SORT,
+        field: v,
+        order: C
+      });
+    },
+    onChangeRowsPerPage: ({ target: { value: h } } = {}) => r({
+      type: ae.CHANGE_ROWS,
+      rowsPerPage: h
+    }),
+    onChangeQuery: (h, f) => {
+      r({
+        type: ae.CHANGE_QUERY,
+        field: h,
+        query: f
+      });
+    },
+    onHideRoles: ({ hideRoles: h }) => r({
+      type: ae.HIDE_ROLES,
+      hideRoles: h
+    })
+  };
+}
+function no(e) {
+  const { data: t, request: n } = k(te.getGroup, { data: e }), { groupName: r } = t || {}, o = P(() => n({ groupName: r }), [n, r]);
+  $(() => {
+    r && o();
+  }, [o, r]);
+  const s = P(
+    ({ groupDocument: d }) => te.updateGroup({
+      groupName: r,
+      groupDocument: d
+    }).then(o),
+    [o, r]
+  ), a = P(
+    ({ groups: d }) => te.updateGroup({
+      groupName: r,
+      groupDocument: {
+        childGroupList: {
+          group: d.map((h) => ({ groupName: h }))
+        }
+      }
+    }).then(o),
+    [o, r]
+  ), i = P(
+    ({ groups: d }) => te.updateGroup({
+      groupName: r,
+      groupDocument: {
+        parentGroupList: {
+          group: d.map((h) => ({ groupName: h }))
+        }
+      }
+    }).then(o),
+    [o, r]
+  ), l = P(
+    ({ users: d }) => te.updateGroup({
+      groupName: r,
+      groupDocument: {
+        userList: {
+          user: d.map((h) => ({ userName: h }))
+        }
+      }
+    }).then(o),
+    [o, r]
+  ), u = P(
+    (d) => te.removeGroupUser({
+      groupName: r,
+      userName: d
+    }).then(o),
+    [o, r]
+  ), c = P(
+    (d) => te.removeGroupChildren({
+      groupName: r,
+      childGroupName: d
+    }).then(o),
+    [o, r]
+  ), p = P(
+    (d) => te.removeGroupChildren({
+      groupName: d,
+      childGroupName: r
+    }).then(o),
+    [o, r]
+  ), m = P(() => te.removeGroup({ groupName: r }), [r]);
+  return {
+    groupType: t,
+    getGroup: o,
+    updateGroup: s,
+    removeGroup: m,
+    addChildGroups: a,
+    addParentGroups: i,
+    addUsersToGroup: l,
+    removeUserFromGroup: u,
+    removeChildGroup: c,
+    removeFromParentGroup: p
+  };
+}
+function Qr({ itemId: e, queryParams: t = {}, refreshOnMount: n = !0 }) {
+  const { request: r, data: o = {}, isLoading: s, isError: a } = k(ue.getItem), i = () => r({ itemId: e, queryParams: t });
+  return Z(() => {
+    n && i();
+  }, [e, t]), {
+    itemType: o,
+    isLoading: s,
+    isError: a,
+    onRefresh: i
+  };
+}
+const oo = ({ collectionId: e, defaultEnabled: t = !0 }) => {
+  const [n, r] = M(), [o, s] = M(t), a = (p) => s((m) => p !== void 0 ? p : !m), i = z(), l = z(), u = z(), c = P(
+    ({ itemId: p }) => {
+      if (o === !1)
+        return;
+      const m = {
+        field: [
+          {
+            name: "mediaType",
+            value: [{ value: "video" }, { value: "audio" }]
+          }
+        ]
+      }, d = ({ first: h, number: f } = {}) => {
+        const { current: C } = i, { current: v } = l;
+        if (!Array.isArray(C)) {
+          Promise.all([
+            V.getCollection({
+              collectionId: e,
+              queryParams: { children: "item" }
+            }),
+            V.searchCollectionItem({
+              collectionId: e,
+              searchDocument: m,
+              queryParams: { first: h, number: f }
+            })
+          ]).then(([{ data: A }, { data: N }]) => {
+            const { hits: _, item: G = [] } = N;
+            i.current = G.map(({ id: W }) => W), u.current = _;
+            const { content: j } = A;
+            l.current = j, d({ first: 1, number: 100 });
+          });
+          return;
+        }
+        const { current: g } = u, y = v.findIndex(({ id: A }) => A === p);
+        if (y + 1 === v.length) {
+          r();
+          return;
+        }
+        if (y === -1 && g > C.length) {
+          V.searchCollectionItem({
+            collectionId: e,
+            searchDocument: m,
+            queryParams: { first: h + f, number: f }
+          }).then(({ data: A }) => {
+            const { item: N = [] } = A;
+            i.current.push(...N.map(({ id: _ }) => _)), d({ first: h + f, number: f });
+          });
+          return;
+        }
+        const R = v.slice(y + 1).find(({ id: A }) => C.includes(A));
+        r(R);
+      };
+      d();
+    },
+    [e, o]
+  );
+  return {
+    isAutoPlayEnabled: o,
+    toggleAutoPlay: a,
+    setNextPlaying: r,
+    nextPlaying: n,
+    onNext: c
+  };
+}, Jr = (e) => {
+  const t = [];
+  for (let n = 0; n < e.length; n += 1) {
+    const r = e[n];
+    if (r && typeof r == "string")
+      try {
+        const o = r.split("version")[1].split("/")[1].split("?")[0], s = _t(o);
+        t.push(s);
+      } catch {
+      }
+  }
+  return t;
+};
+function so(e = [], t = 0, n = void 0, r = Jr) {
+  const [o, s] = M(0), [a, i] = M(0), [l, u] = M(!1), [c, p] = M([]), [m, d] = M(), [h, f] = M(0), C = z(
+    rt((A) => {
+      i(A);
+    }, 10)
+  ).current, v = (A) => {
+    try {
+      return Math.round(A.getBoundingClientRect().left);
+    } catch {
+      return 0;
+    }
+  }, g = P(
+    (A) => {
+      const N = A.clientX - v(A.currentTarget) - t, _ = A.currentTarget.offsetWidth;
+      return N < 0 ? 0 : N > _ ? _ : N;
+    },
+    [t]
+  ), y = (A, N) => {
+    let _ = N[0], G = Math.abs(A - _), j = 0;
+    for (let W = 0; W < N.length; W += 1) {
+      const Q = Math.abs(A - N[W]), re = A - N[W] > 0;
+      Q < G && re && (G = Q, _ = N[W], j = W);
+    }
+    return j;
+  }, S = (A) => {
+    if (n) {
+      const N = g(A);
+      s(N - 1), h !== A.currentTarget.offsetWidth && f(A.currentTarget.offsetWidth);
+      const _ = N / (A.currentTarget.offsetWidth / +n);
+      d(Gt(_));
+      const G = y(
+        _,
+        c.map((j) => j.toSeconds().toFixed(0))
+      );
+      G !== a && C(G);
+    }
+  };
+  return Z(() => {
+    const A = r(e);
+    p(A);
+  }, [e]), {
+    thumbnailIndex: a,
+    thumbnailTimeCode: m,
+    thumbnailWidth: h,
+    showScrub: l,
+    scrubPosition: o,
+    handleShowScrub: (A) => () => {
+      n > 0 && u(A);
+    },
+    onMouseMove: S
+  };
+}
+function ao({
+  searchDoc: e,
+  queryParams: t,
+  debounceTime: n,
+  suggestionSettings: r = { maximumSuggestions: 10, accuracy: 1 },
+  triggerLength: o = 1,
+  apiCall: s = ue.searchItem
+}) {
+  const [a, i] = M(""), l = z(rt(i, n)).current, { data: { autocomplete: u = [] } = {}, request: c } = k(s), { suggestion: p = [] } = u[0] || {};
+  return Z(() => {
+    e && a && a.length >= o && c({
+      body: {
+        ...e,
+        suggestion: r,
+        autocomplete: [
+          {
+            text: a
+          }
+        ],
+        text: [{ value: a }]
+      },
+      queryParams: { count: !1, number: 0, ...t }
+    });
+  }, [c, a, t, o]), {
+    suggestion: p,
+    handleAutocompleteChange: l
+  };
+}
+function io() {
+  const {
+    request: e,
+    data: { value: t = [] } = {},
+    isLoading: n
+  } = k(ze.getMetadataFieldAllowedValues);
+  return {
+    getMetadataDataset: (o, s, a) => {
+      o && e({
+        fieldName: o,
+        metadataFieldValueConstraintListDocument: {
+          constraint: s ? [{ field: a, value: s }] : []
+        }
+      });
+    },
+    dataset: t,
+    isLoading: n
+  };
+}
+const Xr = 1e3, zr = "TRANSIENT", Me = (e) => e.find((t) => t.name === "title").value[0].value;
+function co({
+  childFolders: e = [],
+  queryParams: t = { content: ["metadata"] },
+  markerProps: n = {
+    markerValue: "savedSearch",
+    markerField: "eidr_referentType"
+  },
+  expand: r
+}) {
+  const [o, s] = M(e), [a, i] = M([]), [l, u] = M(), c = P(() => {
+    Promise.all(
+      o.map(async (f) => {
+        const {
+          data: { content: C, metadata: v = {} }
+        } = await V.getCollection({
+          collectionId: f,
+          queryParams: t
+        }), { field: g } = v.timespan[0];
+        return C && C[0].type === "library" ? {
+          id: f,
+          libraryId: C[0].id,
+          title: Me(g),
+          type: "query",
+          metadata: v
+        } : {
+          id: f,
+          title: Me(g),
+          subFolders: C && C.map((y) => y.id),
+          type: "folder",
+          metadata: v
+        };
+      })
+    ).then((f) => {
+      i((C) => [...f, ...C]);
+    }).catch((f) => {
+      u(f);
+    });
+  }, [o, t]), p = (f, C, v, g, y) => {
+    V.createCollection({
+      collectionDocument: {
+        metadata: de({
+          [C]: v,
+          title: g
+        })
+      }
+    }).then(({ data: { id: S } }) => f ? V.updateCollection({
+      collectionId: f,
+      collectionDocument: {
+        content: [
+          {
+            id: S,
+            mode: "add",
+            type: "collection"
+          }
+        ]
+      }
+    }).then(({ data: { content: R } }) => {
+      R && (s(
+        R.filter((A) => A.id === S).map((A) => A.id)
+      ), y && y());
+    }).catch((R) => {
+      u(R);
+    }) : null).catch((S) => {
+      u(S);
+    });
+  }, m = (f, C, v, g) => {
+    try {
+      ue.searchItem({
+        queryParams: {
+          result: "library",
+          updateMode: zr,
+          updateFrequency: Xr
+        },
+        itemSearchDocument: v
+      }).then(
+        ({ data: { library: y } }) => V.createCollection({
+          collectionDocument: {
+            metadata: de({
+              [n.markerField]: n.markerValue,
+              title: C
+            }),
+            content: [
+              {
+                id: y,
+                type: "library"
+              }
+            ]
+          }
+        })
+      ).then(
+        ({ data: { id: y } }) => V.updateCollection({
+          collectionId: f,
+          collectionDocument: {
+            content: [
+              {
+                id: y,
+                mode: "add",
+                type: "collection"
+              }
+            ]
+          }
+        }).then(({ data: { content: S } }) => {
+          S && (s(
+            S.filter((R) => R.id === y).map((R) => R.id)
+          ), g && g());
+        }).catch((S) => {
+          u(S);
+        })
+      ).catch((y) => {
+        u(y);
+      });
+    } catch (y) {
+      u(y);
+    }
+  }, d = (f) => V.removeCollection({ collectionId: f }).catch((C) => {
+    u(C);
+  }), h = (f) => {
+    i((C) => C.filter((v) => v.id !== f));
+  };
+  return Z(() => {
+    o.length > 0 && r && c();
+  }, [o, r]), $(() => {
+    !r && typeof r == "boolean" && (s(() => a.map((f) => f.id)), i([]));
+  }, [r]), {
+    createFolder: p,
+    saveSearch: m,
+    getSubFolders: c,
+    deleteFolder: d,
+    removeItem: h,
+    subFolders: a,
+    setSubFolders: i,
+    setCurrentFolders: s,
+    errors: l
+  };
+}
+const uo = ({ collectionId: e, onError: t }) => {
+  const [n, r] = M([]), s = async () => {
+    try {
+      if (!e)
+        throw Error("Missing collectionId");
+      const { data: u = {} } = await V.getCollectionMetadata({
+        collectionId: e,
+        queryParams: {
+          content: "metadata",
+          field: "representativeItems"
+        }
+      }).catch((p) => {
+        t && t(p);
+      }), { representativeItems: c = [] } = tt(u, {
+        flat: !0,
+        includeValueAttributes: !0
+      });
+      r(() => c);
+    } catch (u) {
+      t && t(u);
+    }
+  }, a = async (u) => {
+    try {
+      const c = de({
+        representativeItems: Array.isArray(u) ? u : [u]
+      }), p = await V.updateCollectionMetadata({
+        collectionId: e,
+        metadataDocument: c
+      });
+      return s(), p;
+    } catch (c) {
+      t && t(c);
+      return;
+    }
+  }, i = (u) => a({ value: u, mode: "add" }), l = (u) => {
+    try {
+      const c = n.filter((p) => p.value === u).map((p) => p.uuid);
+      return c.length ? a(
+        c.map((p) => ({ uuid: p, mode: "remove" }))
+      ) : void 0;
+    } catch (c) {
+      t && t(c);
+      return;
+    }
+  };
+  return $(() => {
+    s();
+  }, [e]), {
+    representativeItems: n,
+    onRefresh: s,
+    onAdd: i,
+    onRemove: l
+  };
+};
+function Kr() {
+  return Nt.listStorage().then((t) => ({
+    id: t.data.storage[0].id,
+    uri: t.data.storage[0].method[0].uri
+  }));
+}
+function Zr(e) {
+  return ge.createLibrary({
+    itemListDocument: {
+      item: [
+        ...e.item.map(({ id: t }) => ({
+          id: t
+        }))
+      ]
+    }
+  });
+}
+function en(e, t, n) {
+  const { fileName: r = "output", outputFormat: o = "csv" } = n, { uri: s } = t, { data: { uri: [a] = [] } = {} } = e, l = encodeURIComponent((() => {
+    if (s.includes("s3")) {
+      const [u, c] = s.split("?region");
+      return `${u}${r}.${o}?region${c}`;
+    }
+    return `${s}${r}.${o}`;
+  })());
+  return ge.getLibraryBatch({
+    libraryId: a,
+    queryParams: { destinationUri: l, ...n }
+  });
+}
+const tn = ["FINISHED", "FINISHED_WARNING"], rn = ["FINISHED", "FINISHED_WARNING", "FAILED_TOTAL", "ABORTED"];
+function ut(e, t, n, r) {
+  const { data: { jobId: o } = {} } = e, { id: s } = t, { fileName: a = "output", outputFormat: i = "csv" } = n, l = `${a}.${i}`;
+  Ze.getJob({ jobId: o }).then(({ data: { status: u } = {} } = {}) => {
+    if (tn.includes(u))
+      try {
+        It.listFileStorage({
+          storageId: s,
+          queryParams: {
+            path: l,
+            methodMetadata: [
+              { key: "format", value: "SIGNED-AUTO" },
+              { key: "contentDisposition", value: `attachment;+filename=${l}` }
+            ],
+            "noauth-url": !0
+          }
+        }).then((c) => window.open(c.data.file[0].uri[0]));
+      } catch (c) {
+        console.error(`Download error:
+${c}`), r({ message: "Download failed" });
+      }
+    else
+      rn.includes(u) ? r({ message: "Download failed" }) : setTimeout(() => {
+        ut(e, t, n, r);
+      }, 1e3);
+  });
+}
+const lo = ({
+  itemListType: e,
+  queryParams: t,
+  onSuccess: n,
+  onError: r = ({ message: l, error: u }) => console.error(`${l}
+${u}`),
+  onGetFile: o = ut,
+  onCreateList: s = Zr,
+  onList: a = en,
+  onGetStorage: i = Kr
+}) => ({ onDownload: () => i().then(
+  (u) => Promise.all([
+    s(e).then((c) => a(c, u, t)).then(n()).then((c) => o(c, u, t, r))
+  ])
+) });
+function fo(e, t, n, r, o, s, a, i) {
+  const l = n[0].fields.map((d) => d), [u, c] = M(r), p = (d, h, f, C) => {
+    const { value: v } = d.target, y = r.map((S) => S).map((S, R) => f === R ? { ...h, [C]: v } : S);
+    o(y), c(y);
+  }, m = async (d, h) => {
+    const f = de(d), { timespan: C } = f, v = [];
+    C.forEach((R, A) => {
+      const N = {
+        field: [],
+        name: "V3_sport_Team",
+        mode: "add"
+      };
+      R.field.forEach((_) => {
+        N.field.push(_);
+      }), h.includes(A) && v.push(N);
+    });
+    const g = {
+      timespan: [
+        {
+          start: "-INF",
+          end: "+INF",
+          field: [],
+          group: v
+        }
+      ]
+    }, y = [...new Set(h)], S = [];
+    y.forEach((R) => {
+      const A = t.itemType.metadata.timespan[0].group.find(
+        (N, _) => R === _
+      );
+      S.push(A.uuid);
+    });
+    try {
+      await S.forEach((R) => setTimeout(Ne.removeMetadata({ metadataUuid: R }), 500)), await ue.updateItemMetadata({
+        itemId: e,
+        metadataDocument: g
+      }), await s(), o(u), a();
+    } catch (R) {
+      i(R);
+    }
+  };
+  return Z(() => {
+    o(t.group);
+  }, [t]), {
+    tableColumns: l,
+    onChange: p,
+    onSubmit: m
+  };
+}
+function nn({
+  entity: e,
+  entityId: t,
+  queryParams: n = {},
+  refreshOnMount: r = !0
+}) {
+  const {
+    request: o,
+    data: s = {},
+    isLoading: a,
+    isError: i
+  } = k(Ne.getEntityMetadata), l = () => o({ entity: e, entityId: t, queryParams: n });
+  return Z(() => {
+    r && l();
+  }, [e, t, n]), {
+    metadataType: s,
+    isLoading: a,
+    isError: i,
+    onRefresh: l
+  };
+}
+function on({ groupName: e, queryParams: t = {}, refreshOnMount: n = !0 }) {
+  const {
+    request: r,
+    data: o = {},
+    isLoading: s,
+    isError: a
+  } = k(Ke.getFieldGroup), i = () => r({ groupName: e, queryParams: t });
+  return Z(() => {
+    n && i();
+  }, [e, t]), {
+    metadataFieldGroupType: o,
+    isLoading: s,
+    isError: a,
+    onRefresh: i
+  };
+}
+function mo({
+  itemType: e,
+  collectionType: t,
+  metadataType: n,
+  joinValue: r = ",",
+  flat: o = !0,
+  groupAsList: s = !0,
+  children: a,
+  ...i
+}) {
+  let l = n;
+  if (e || t) {
+    const m = e || t || {};
+    l = m == null ? void 0 : m.metadata;
+  }
+  const u = he(
+    () => tt(l, { joinValue: r, flat: o, groupAsList: s }),
+    [o, s, r, l]
+  ), c = {
+    ...i,
+    ...u,
+    itemType: e
+  }, p = (m) => se(m, c);
+  return oe.map(a, p);
+}
+function po({
+  itemSearchDocument: e,
+  queryParams: t,
+  matrixParams: n,
+  responseRef: r,
+  initialState: o,
+  children: s
+}) {
+  const {
+    request: a,
+    data: i = {},
+    isLoading: l,
+    isError: u
+  } = k(V.searchCollection, o, r), c = () => a({ itemSearchDocument: e, queryParams: t, matrixParams: n });
+  Z(() => {
+    c();
+  }, [e, t, n]);
+  const p = {
+    itemSearchDocument: e,
+    matrixParams: n,
+    queryParams: t,
+    collectionListType: i,
+    onRefresh: c,
+    isLoading: l,
+    isError: u
+  }, m = (d) => se(d, p);
+  return oe.map(s, m);
+}
+function ho({ itemSearchDocument: e, queryParams: t, matrixParams: n, children: r }) {
+  const { itemListType: o, onRefresh: s, isLoading: a, isError: i } = Or({
+    itemSearchDocument: e,
+    queryParams: t,
+    matrixParams: n
+  }), l = {
+    itemSearchDocument: e,
+    matrixParams: n,
+    queryParams: t,
+    itemListType: o,
+    onRefresh: s,
+    isLoading: a,
+    isError: i
+  }, u = (c) => se(c, l);
+  return oe.map(r, u);
+}
+function Eo({
+  itemSearchDocument: e,
+  queryParams: t,
+  matrixParams: n,
+  children: r
+}) {
+  const {
+    request: o,
+    data: s = {},
+    isLoading: a,
+    isError: i
+  } = k(Xe.searchItemCollection), l = () => o({ itemSearchDocument: e, queryParams: t, matrixParams: n });
+  Z(() => {
+    l();
+  }, [e, t, n]);
+  const u = {
+    itemSearchDocument: e,
+    matrixParams: n,
+    queryParams: t,
+    searchResultType: s,
+    onRefresh: l,
+    isLoading: a,
+    isError: i
+  }, c = (p) => se(p, u);
+  return oe.map(r, c);
+}
+function go({ itemId: e, queryParams: t, refreshOnMount: n, children: r }) {
+  const { itemType: o, onRefresh: s, isLoading: a, isError: i } = Qr({
+    itemId: e,
+    queryParams: t,
+    refreshOnMount: n
+  }), l = {
+    itemId: e,
+    queryParams: t,
+    itemType: o,
+    onRefresh: s,
+    isLoading: a,
+    isError: i
+  }, u = (c) => se(c, l);
+  return oe.map(r, u);
+}
+function yo({
+  collectionId: e,
+  queryParams: t,
+  refreshOnMount: n,
+  children: r
+}) {
+  const { collectionType: o, onRefresh: s, isLoading: a, isError: i } = Hr({
+    collectionId: e,
+    queryParams: t,
+    refreshOnMount: n
+  }), l = {
+    collectionId: e,
+    queryParams: t,
+    collectionType: o,
+    onRefresh: s,
+    isLoading: a,
+    isError: i
+  }, u = (c) => se(c, l);
+  return oe.map(r, u);
+}
+function Ao({ matrixParams: e, queryParams: t, children: n }) {
+  const { request: r, data: o = {}, isLoading: s, isError: a } = k(Ze.listJob), i = () => r({ matrixParams: e, queryParams: t });
+  Z(() => {
+    i();
+  }, [e, t]);
+  const l = {
+    matrixParams: e,
+    queryParams: t,
+    onRefresh: i,
+    isLoading: s,
+    isError: a,
+    jobs: o
+  }, u = (c) => se(c, l);
+  return oe.map(n, u);
+}
+function Co({ entityId: e, entityType: t, queryParams: n, children: r }) {
+  const { request: o, data: s = {}, isLoading: a } = k(Pe.listEntityAccess), i = () => o({ entityId: e, entityType: t, queryParams: n });
+  $(() => {
+    i();
+  }, [e, t, n]);
+  const l = {
+    entityId: e,
+    entityType: t,
+    queryParams: n,
+    accessControlList: s,
+    onRefresh: i,
+    isLoading: a
+  }, u = (c) => se(c, l);
+  return oe.map(r, u);
+}
+class lt extends Je {
+  constructor(t) {
+    super(t);
+    const { serverUrl: n, token: r, username: o, password: s, runAs: a } = t;
+    n && (J.defaultClient.defaults.baseURL = n), r ? J.defaultClient.defaults.headers.Authorization = `token ${r}` : J.defaultClient.defaults.auth = { username: o, password: s }, a && (J.defaultClient.defaults.headers.RunAs = a);
+  }
+  componentDidUpdate(t) {
+    const { serverUrl: n, token: r, username: o, password: s, runAs: a } = this.props;
+    t.serverUrl !== n && (n ? J.defaultClient.defaults.baseURL = n : delete J.defaultClient.defaults.baseURL), t.token !== r && (r ? J.defaultClient.defaults.headers.Authorization = `token ${r}` : delete J.defaultClient.defaults.headers.Authorization), !r && (t.username !== o || t.password !== s) && (J.defaultClient.defaults.auth = { username: o, password: s }), t.runAs !== a && (a ? J.defaultClient.defaults.headers.RunAs = a : delete J.defaultClient.defaults.headers.RunAs);
+  }
+  render() {
+    const { children: t, username: n, serverUrl: r } = this.props, o = { username: n, serverUrl: r }, s = (a) => se(a, o);
+    return oe.map(t, s);
+  }
+}
+const ye = "VIDISPINE-TOKEN", Ae = "VIDISPINE-USERNAME", Ce = "VIDISPINE-SERVER-URL", Se = "VIDISPINE-REMEMBER-ME", sn = ({ userName: e, password: t, serverUrl: n }) => {
+  n && (J.defaultClient.defaults.baseURL = n);
+  const r = { seconds: 2592e3, autoRefresh: "true" }, o = { password: t, username: e };
+  try {
+    X.getToken({ queryParams: r, headers: o }).then(({ data: s }) => s).catch(({ response: s = {}, message: a = "Unknown error." }) => {
+      let i = a;
+      throw s.status === 401 && (i = "Incorrect Username/Password"), i;
+    });
+  } catch {
+    throw "Incorrect Username/Password";
+  }
+};
+function So({
+  LoginComponent: e,
+  LoginProps: t = {},
+  AppComponent: n,
+  AppProps: r = {},
+  onGetToken: o = sn,
+  onSuccess: s,
+  onError: a,
+  cookieOptions: i = {
+    maxAge: 604800,
+    path: "/"
+  },
+  ...l
+}) {
+  const [u, c, p] = nt([
+    ye,
+    Ae,
+    Ce,
+    Se
+  ]), {
+    [ye]: m,
+    [Ae]: d,
+    [Ce]: h
+  } = u, f = u[Se] === "true";
+  return m ? /* @__PURE__ */ B(lt, { token: m, username: d, serverUrl: h, children: /* @__PURE__ */ B(n, { onLogout: () => {
+    p(ye, i), f || (p(Ae, i), p(Ce, i), p(Se, i));
+  }, ...l, ...r }) }) : /* @__PURE__ */ B(
+    e,
+    {
+      onLogin: (g) => {
+        let y;
+        try {
+          o(g).then((S) => {
+            const {
+              userName: R,
+              serverUrl: A,
+              rememberMe: N
+            } = g;
+            R && c(Ae, R, i), A && c(Ce, A, i), N && c(Se, N, i), S && c(ye, S, i), s && s(g);
+          }).catch((S) => {
+            if (y = S, a)
+              return a(y);
+            throw y;
+          });
+        } catch (S) {
+          if (y = S, a)
+            return a(y);
+        }
+        return y;
+      },
+      userName: d,
+      serverUrl: h,
+      rememberMe: f,
+      ...l,
+      ...t
+    }
+  );
+}
+function an({ error: e, info: t }) {
+  return /* @__PURE__ */ Ot(
+    "div",
+    {
+      style: {
+        height: "100%",
+        maxHeight: "100vh",
+        width: "100%",
+        maxWidth: "100vw",
+        backgroundColor: "red",
+        color: "white"
+      },
+      children: [
+        e && /* @__PURE__ */ B("div", { children: e.toString() }),
+        t && /* @__PURE__ */ B("div", { children: t.componentStack })
+      ]
+    }
+  );
+}
+class cn extends Je {
+  constructor(t) {
+    super(t), this.state = { hasError: !1 };
+  }
+  static getDerivedStateFromError(t) {
+    return { error: t, hasError: !0 };
+  }
+  shouldComponentUpdate(t, n) {
+    const { hasError: r, info: o } = this.state, { info: s } = n;
+    return !(o === s && r === !0);
+  }
+  componentDidCatch(t, n) {
+    const { onError: r } = this.props;
+    if (typeof r == "function")
+      try {
+        r(t, n);
+      } catch {
+        return;
+      }
+    this.setState({ info: n });
+  }
+  render() {
+    const { children: t } = this.props, { hasError: n, error: r, info: o } = this.state;
+    return n ? /* @__PURE__ */ B(an, { info: o, error: r }) : t;
+  }
+}
+function vo({ groupName: e, queryParams: t, refreshOnMount: n, children: r }) {
+  const { metadataFieldGroupType: o, onRefresh: s, isLoading: a, isError: i } = on({
+    groupName: e,
+    queryParams: t,
+    refreshOnMount: n
+  }), l = {
+    groupName: e,
+    queryParams: t,
+    metadataFieldGroupType: o,
+    onRefresh: s,
+    isLoading: a,
+    isError: i
+  }, u = (c) => se(c, l);
+  return oe.map(r, u);
+}
+const dt = Ee();
+function To({ intialState: e = {}, onRefresh: t, userName: n, children: r }) {
+  const [o, s] = M(e);
+  return $(() => {
+    if (n)
+      X.getUserRole({ userName: n }).then(({ data: i }) => {
+        s(i), t && t(i);
+      });
+    else {
+      let i;
+      X.whoAmI().then(({ data: l }) => (i = l, X.getUserRole({ userName: l }))).then(({ data: l }) => {
+        s(l), t && t(l, i);
+      });
+    }
+  }, [n]), /* @__PURE__ */ B(dt.Provider, { value: o, children: r });
+}
+function un() {
+  const e = Ie(dt);
+  if (e === void 0)
+    throw new Error("useRoles must be used within RolesContext");
+  return { hasRole: (n) => {
+    if (n === void 0)
+      throw new Error("roleName is undefined");
+    const { group: r } = e;
+    if (!Array.isArray(r))
+      return null;
+    const o = r.map(({ groupName: s }) => s);
+    return o.includes(bt.SUPER_ACCESS_USER) ? !0 : Array.isArray(n) ? n.findIndex((s) => o.includes(s)) > -1 : o.includes(n);
+  }, groupListType: e };
+}
+function Ro({ roleName: e, allow: t, deny: n, loading: r }) {
+  if (e === void 0)
+    throw new Error("roleName is undefined");
+  const { hasRole: o } = un(), s = o(e);
+  return _e(t) && s === !0 ? t : _e(n) && s === !1 ? n : _e(r) && s === null ? r : null;
+}
+function Po({ providers: e = [], children: t, ...n }) {
+  return e.reduceRight((r, o) => {
+    if (typeof o == "function")
+      return /* @__PURE__ */ B(o, { ...n, children: r });
+    const { provider: s, ...a } = o;
+    return /* @__PURE__ */ B(s, { ...n, ...a, children: r });
+  }, t);
+}
+function No({
+  entity: e,
+  entityId: t,
+  queryParams: n,
+  refreshOnMount: r,
+  children: o
+}) {
+  const { metadataType: s, onRefresh: a, isLoading: i, isError: l } = nn({
+    entity: e,
+    entityId: t,
+    queryParams: n,
+    refreshOnMount: r
+  }), u = {
+    entity: e,
+    entityId: t,
+    queryParams: n,
+    metadataType: s,
+    onRefresh: a,
+    isLoading: i,
+    isError: l
+  };
+  e === "collection" ? u.collectionId = t : e === "item" && (u.itemId = t);
+  const c = (p) => se(p, u);
+  return oe.map(o, c);
+}
+const Io = (e, t = {}) => (n) => /* @__PURE__ */ B(cn, { ...t, children: /* @__PURE__ */ B(e, { ...n }) }), _o = (...e) => e.reduce(
+  (t, n) => (...r) => t(n(...r)),
+  (t) => t
+), ln = Ee(), dn = (e, { entityId: t, entityType: n, entityTimespan: { start: r, end: o, field: [{ name: s } = {}] = [] } = {} }) => {
+  const a = e.some(
+    (l) => l.entity.id === t && l.entityType === n
+  );
+  let i = !1;
+  return a && e.filter(
+    (u) => u.entity.id === t && u.entityType === n
+  ).forEach(
+    ({
+      entityTimespan: { start: u, end: c, field: [{ name: p } = {}] = [] } = {}
+    }) => {
+      r === u && o === c && s === p && (i = !0);
+    }
+  ), !a || !i;
+};
+function Go({
+  onChange: e,
+  children: t,
+  initialState: n = [],
+  allowDuplicates: r = !1,
+  isUniqueBinItem: o = dn
+}) {
+  const [s, a] = M(n), [i, l] = M(r), u = P(
+    (f) => {
+      if (!f || !["string", "number"].includes(typeof f)) {
+        console.error("BinProvider onDelete called without a binId of the entity to delete");
+        return;
+      }
+      a((C) => {
+        const v = C.filter((g) => g.binId !== f);
+        return e && e(v), v;
+      });
+    },
+    [e]
+  ), c = P(() => {
+    a([]), e && e([]);
+  }, [e]), p = (f) => {
+    const [C] = at().split("-");
+    return { binId: C, ...f };
+  }, m = P(
+    ({ dragInfo: f = {} } = {}) => {
+      const { entityId: C, entityType: v, entity: g } = f;
+      if (!C || !v || !g)
+        throw new Error("Dragged element needs to have entityId, entityType and entity props");
+      a((y = []) => {
+        if (o(y, f) || i) {
+          const S = [...y, p(f)];
+          return e && e(S), S;
+        }
+        return y;
+      });
+    },
+    [i, o, e]
+  ), d = P(
+    ({ dragId: f, hoverId: C, originalDragIndex: v }) => {
+      f === void 0 || C === void 0 && v === void 0 || a((g) => {
+        const y = [...g], S = s.findIndex((N) => N.binId === f), R = s.findIndex((N) => N.binId === C), A = R > -1 ? R : v;
+        return [y[A], y[S]] = [
+          y[S],
+          y[A]
+        ], e && e(y), y;
+      });
+    },
+    [s, e]
+  ), h = he(
+    () => ({
+      setBin: a,
+      bin: s,
+      allowDuplicates: i,
+      setAllowDuplicates: l,
+      onDrop: m,
+      onSort: d,
+      onFind: () => null,
+      onEmptyBin: c,
+      onDelete: u
+    }),
+    [i, s, m, d, u, c]
+  );
+  return /* @__PURE__ */ B(ln.Provider, { value: h, children: t });
+}
+var q = {}, Fe = {
+  get exports() {
+    return q;
+  },
+  set exports(e) {
+    q = e;
+  }
+};
+/*
+object-assign
+(c) Sindre Sorhus
+@license MIT
+*/
+var Ge, qe;
+function fn() {
+  if (qe)
+    return Ge;
+  qe = 1;
+  var e = Object.getOwnPropertySymbols, t = Object.prototype.hasOwnProperty, n = Object.prototype.propertyIsEnumerable;
+  function r(s) {
+    if (s == null)
+      throw new TypeError("Object.assign cannot be called with null or undefined");
+    return Object(s);
+  }
+  function o() {
+    try {
+      if (!Object.assign)
+        return !1;
+      var s = new String("abc");
+      if (s[5] = "de", Object.getOwnPropertyNames(s)[0] === "5")
+        return !1;
+      for (var a = {}, i = 0; i < 10; i++)
+        a["_" + String.fromCharCode(i)] = i;
+      var l = Object.getOwnPropertyNames(a).map(function(c) {
+        return a[c];
+      });
+      if (l.join("") !== "0123456789")
+        return !1;
+      var u = {};
+      return "abcdefghijklmnopqrst".split("").forEach(function(c) {
+        u[c] = c;
+      }), Object.keys(Object.assign({}, u)).join("") === "abcdefghijklmnopqrst";
+    } catch {
+      return !1;
+    }
+  }
+  return Ge = o() ? Object.assign : function(s, a) {
+    for (var i, l = r(s), u, c = 1; c < arguments.length; c++) {
+      i = Object(arguments[c]);
+      for (var p in i)
+        t.call(i, p) && (l[p] = i[p]);
+      if (e) {
+        u = e(i);
+        for (var m = 0; m < u.length; m++)
+          n.call(i, u[m]) && (l[u[m]] = i[u[m]]);
+      }
+    }
+    return l;
+  }, Ge;
+}
+var be, $e;
+function Le() {
+  if ($e)
+    return be;
+  $e = 1;
+  var e = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return be = e, be;
+}
+var we, je;
+function ft() {
+  return je || (je = 1, we = Function.call.bind(Object.prototype.hasOwnProperty)), we;
+}
+var De, We;
+function mn() {
+  if (We)
+    return De;
+  We = 1;
+  var e = function() {
+  };
+  if (process.env.NODE_ENV !== "production") {
+    var t = Le(), n = {}, r = ft();
+    e = function(s) {
+      var a = "Warning: " + s;
+      typeof console < "u" && console.error(a);
+      try {
+        throw new Error(a);
+      } catch {
+      }
+    };
+  }
+  function o(s, a, i, l, u) {
+    if (process.env.NODE_ENV !== "production") {
+      for (var c in s)
+        if (r(s, c)) {
+          var p;
+          try {
+            if (typeof s[c] != "function") {
+              var m = Error(
+                (l || "React class") + ": " + i + " type `" + c + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof s[c] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`."
+              );
+              throw m.name = "Invariant Violation", m;
+            }
+            p = s[c](a, c, l, i, null, t);
+          } catch (h) {
+            p = h;
+          }
+          if (p && !(p instanceof Error) && e(
+            (l || "React class") + ": type specification of " + i + " `" + c + "` is invalid; the type checker function must return `null` or an `Error` but returned a " + typeof p + ". You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument)."
+          ), p instanceof Error && !(p.message in n)) {
+            n[p.message] = !0;
+            var d = u ? u() : "";
+            e(
+              "Failed " + i + " type: " + p.message + (d ?? "")
+            );
+          }
+        }
+    }
+  }
+  return o.resetWarningCache = function() {
+    process.env.NODE_ENV !== "production" && (n = {});
+  }, De = o, De;
+}
+var Oe, Ve;
+function pn() {
+  if (Ve)
+    return Oe;
+  Ve = 1;
+  var e = ot, t = fn(), n = Le(), r = ft(), o = mn(), s = function() {
+  };
+  process.env.NODE_ENV !== "production" && (s = function(i) {
+    var l = "Warning: " + i;
+    typeof console < "u" && console.error(l);
+    try {
+      throw new Error(l);
+    } catch {
+    }
+  });
+  function a() {
+    return null;
+  }
+  return Oe = function(i, l) {
+    var u = typeof Symbol == "function" && Symbol.iterator, c = "@@iterator";
+    function p(E) {
+      var T = E && (u && E[u] || E[c]);
+      if (typeof T == "function")
+        return T;
+    }
+    var m = "<<anonymous>>", d = {
+      array: v("array"),
+      bigint: v("bigint"),
+      bool: v("boolean"),
+      func: v("function"),
+      number: v("number"),
+      object: v("object"),
+      string: v("string"),
+      symbol: v("symbol"),
+      any: g(),
+      arrayOf: y,
+      element: S(),
+      elementType: R(),
+      instanceOf: A,
+      node: j(),
+      objectOf: _,
+      oneOf: N,
+      oneOfType: G,
+      shape: Q,
+      exact: re
+    };
+    function h(E, T) {
+      return E === T ? E !== 0 || 1 / E === 1 / T : E !== E && T !== T;
+    }
+    function f(E, T) {
+      this.message = E, this.data = T && typeof T == "object" ? T : {}, this.stack = "";
+    }
+    f.prototype = Error.prototype;
+    function C(E) {
+      if (process.env.NODE_ENV !== "production")
+        var T = {}, O = 0;
+      function w(H, b, D, L, F, U, ee) {
+        if (L = L || m, U = U || D, ee !== n) {
+          if (l) {
+            var K = new Error(
+              "Calling PropTypes validators directly is not supported by the `prop-types` package. Use `PropTypes.checkPropTypes()` to call them. Read more at http://fb.me/use-check-prop-types"
+            );
+            throw K.name = "Invariant Violation", K;
+          } else if (process.env.NODE_ENV !== "production" && typeof console < "u") {
+            var le = L + ":" + D;
+            !T[le] && // Avoid spamming the console because they are often not actionable except for lib authors
+            O < 3 && (s(
+              "You are manually calling a React.PropTypes validation function for the `" + U + "` prop on `" + L + "`. This is deprecated and will throw in the standalone `prop-types` package. You may be seeing this warning due to a third-party PropTypes library. See https://fb.me/react-warning-dont-call-proptypes for details."
+            ), T[le] = !0, O++);
+          }
+        }
+        return b[D] == null ? H ? b[D] === null ? new f("The " + F + " `" + U + "` is marked as required " + ("in `" + L + "`, but its value is `null`.")) : new f("The " + F + " `" + U + "` is marked as required in " + ("`" + L + "`, but its value is `undefined`.")) : null : E(b, D, L, F, U);
+      }
+      var I = w.bind(null, !1);
+      return I.isRequired = w.bind(null, !0), I;
+    }
+    function v(E) {
+      function T(O, w, I, H, b, D) {
+        var L = O[w], F = ie(L);
+        if (F !== E) {
+          var U = me(L);
+          return new f(
+            "Invalid " + H + " `" + b + "` of type " + ("`" + U + "` supplied to `" + I + "`, expected ") + ("`" + E + "`."),
+            { expectedType: E }
+          );
+        }
+        return null;
+      }
+      return C(T);
+    }
+    function g() {
+      return C(a);
+    }
+    function y(E) {
+      function T(O, w, I, H, b) {
+        if (typeof E != "function")
+          return new f("Property `" + b + "` of component `" + I + "` has invalid PropType notation inside arrayOf.");
+        var D = O[w];
+        if (!Array.isArray(D)) {
+          var L = ie(D);
+          return new f("Invalid " + H + " `" + b + "` of type " + ("`" + L + "` supplied to `" + I + "`, expected an array."));
+        }
+        for (var F = 0; F < D.length; F++) {
+          var U = E(D, F, I, H, b + "[" + F + "]", n);
+          if (U instanceof Error)
+            return U;
+        }
+        return null;
+      }
+      return C(T);
+    }
+    function S() {
+      function E(T, O, w, I, H) {
+        var b = T[O];
+        if (!i(b)) {
+          var D = ie(b);
+          return new f("Invalid " + I + " `" + H + "` of type " + ("`" + D + "` supplied to `" + w + "`, expected a single ReactElement."));
+        }
+        return null;
+      }
+      return C(E);
+    }
+    function R() {
+      function E(T, O, w, I, H) {
+        var b = T[O];
+        if (!e.isValidElementType(b)) {
+          var D = ie(b);
+          return new f("Invalid " + I + " `" + H + "` of type " + ("`" + D + "` supplied to `" + w + "`, expected a single ReactElement type."));
+        }
+        return null;
+      }
+      return C(E);
+    }
+    function A(E) {
+      function T(O, w, I, H, b) {
+        if (!(O[w] instanceof E)) {
+          var D = E.name || m, L = Tt(O[w]);
+          return new f("Invalid " + H + " `" + b + "` of type " + ("`" + L + "` supplied to `" + I + "`, expected ") + ("instance of `" + D + "`."));
+        }
+        return null;
+      }
+      return C(T);
+    }
+    function N(E) {
+      if (!Array.isArray(E))
+        return process.env.NODE_ENV !== "production" && (arguments.length > 1 ? s(
+          "Invalid arguments supplied to oneOf, expected an array, got " + arguments.length + " arguments. A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z])."
+        ) : s("Invalid argument supplied to oneOf, expected an array.")), a;
+      function T(O, w, I, H, b) {
+        for (var D = O[w], L = 0; L < E.length; L++)
+          if (h(D, E[L]))
+            return null;
+        var F = JSON.stringify(E, function(ee, K) {
+          var le = me(K);
+          return le === "symbol" ? String(K) : K;
+        });
+        return new f("Invalid " + H + " `" + b + "` of value `" + String(D) + "` " + ("supplied to `" + I + "`, expected one of " + F + "."));
+      }
+      return C(T);
+    }
+    function _(E) {
+      function T(O, w, I, H, b) {
+        if (typeof E != "function")
+          return new f("Property `" + b + "` of component `" + I + "` has invalid PropType notation inside objectOf.");
+        var D = O[w], L = ie(D);
+        if (L !== "object")
+          return new f("Invalid " + H + " `" + b + "` of type " + ("`" + L + "` supplied to `" + I + "`, expected an object."));
+        for (var F in D)
+          if (r(D, F)) {
+            var U = E(D, F, I, H, b + "." + F, n);
+            if (U instanceof Error)
+              return U;
+          }
+        return null;
+      }
+      return C(T);
+    }
+    function G(E) {
+      if (!Array.isArray(E))
+        return process.env.NODE_ENV !== "production" && s("Invalid argument supplied to oneOfType, expected an instance of array."), a;
+      for (var T = 0; T < E.length; T++) {
+        var O = E[T];
+        if (typeof O != "function")
+          return s(
+            "Invalid argument supplied to oneOfType. Expected an array of check functions, but received " + vt(O) + " at index " + T + "."
+          ), a;
+      }
+      function w(I, H, b, D, L) {
+        for (var F = [], U = 0; U < E.length; U++) {
+          var ee = E[U], K = ee(I, H, b, D, L, n);
+          if (K == null)
+            return null;
+          K.data && r(K.data, "expectedType") && F.push(K.data.expectedType);
+        }
+        var le = F.length > 0 ? ", expected one of type [" + F.join(", ") + "]" : "";
+        return new f("Invalid " + D + " `" + L + "` supplied to " + ("`" + b + "`" + le + "."));
+      }
+      return C(w);
+    }
+    function j() {
+      function E(T, O, w, I, H) {
+        return ne(T[O]) ? null : new f("Invalid " + I + " `" + H + "` supplied to " + ("`" + w + "`, expected a ReactNode."));
+      }
+      return C(E);
+    }
+    function W(E, T, O, w, I) {
+      return new f(
+        (E || "React class") + ": " + T + " type `" + O + "." + w + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + I + "`."
+      );
+    }
+    function Q(E) {
+      function T(O, w, I, H, b) {
+        var D = O[w], L = ie(D);
+        if (L !== "object")
+          return new f("Invalid " + H + " `" + b + "` of type `" + L + "` " + ("supplied to `" + I + "`, expected `object`."));
+        for (var F in E) {
+          var U = E[F];
+          if (typeof U != "function")
+            return W(I, H, b, F, me(U));
+          var ee = U(D, F, I, H, b + "." + F, n);
+          if (ee)
+            return ee;
+        }
+        return null;
+      }
+      return C(T);
+    }
+    function re(E) {
+      function T(O, w, I, H, b) {
+        var D = O[w], L = ie(D);
+        if (L !== "object")
+          return new f("Invalid " + H + " `" + b + "` of type `" + L + "` " + ("supplied to `" + I + "`, expected `object`."));
+        var F = t({}, O[w], E);
+        for (var U in F) {
+          var ee = E[U];
+          if (r(E, U) && typeof ee != "function")
+            return W(I, H, b, U, me(ee));
+          if (!ee)
+            return new f(
+              "Invalid " + H + " `" + b + "` key `" + U + "` supplied to `" + I + "`.\nBad object: " + JSON.stringify(O[w], null, "  ") + `
+Valid keys: ` + JSON.stringify(Object.keys(E), null, "  ")
+            );
+          var K = ee(D, U, I, H, b + "." + U, n);
+          if (K)
+            return K;
+        }
+        return null;
+      }
+      return C(T);
+    }
+    function ne(E) {
+      switch (typeof E) {
+        case "number":
+        case "string":
+        case "undefined":
+          return !0;
+        case "boolean":
+          return !E;
+        case "object":
+          if (Array.isArray(E))
+            return E.every(ne);
+          if (E === null || i(E))
+            return !0;
+          var T = p(E);
+          if (T) {
+            var O = T.call(E), w;
+            if (T !== E.entries) {
+              for (; !(w = O.next()).done; )
+                if (!ne(w.value))
+                  return !1;
+            } else
+              for (; !(w = O.next()).done; ) {
+                var I = w.value;
+                if (I && !ne(I[1]))
+                  return !1;
+              }
+          } else
+            return !1;
+          return !0;
+        default:
+          return !1;
+      }
+    }
+    function St(E, T) {
+      return E === "symbol" ? !0 : T ? T["@@toStringTag"] === "Symbol" || typeof Symbol == "function" && T instanceof Symbol : !1;
+    }
+    function ie(E) {
+      var T = typeof E;
+      return Array.isArray(E) ? "array" : E instanceof RegExp ? "object" : St(T, E) ? "symbol" : T;
+    }
+    function me(E) {
+      if (typeof E > "u" || E === null)
+        return "" + E;
+      var T = ie(E);
+      if (T === "object") {
+        if (E instanceof Date)
+          return "date";
+        if (E instanceof RegExp)
+          return "regexp";
+      }
+      return T;
+    }
+    function vt(E) {
+      var T = me(E);
+      switch (T) {
+        case "array":
+        case "object":
+          return "an " + T;
+        case "boolean":
+        case "date":
+        case "regexp":
+          return "a " + T;
+        default:
+          return T;
+      }
+    }
+    function Tt(E) {
+      return !E.constructor || !E.constructor.name ? m : E.constructor.name;
+    }
+    return d.checkPropTypes = o, d.resetWarningCache = o.resetWarningCache, d.PropTypes = d, d;
+  }, Oe;
+}
+var He, ke;
+function hn() {
+  if (ke)
+    return He;
+  ke = 1;
+  var e = Le();
+  function t() {
+  }
+  function n() {
+  }
+  return n.resetWarningCache = t, He = function() {
+    function r(a, i, l, u, c, p) {
+      if (p !== e) {
+        var m = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw m.name = "Invariant Violation", m;
+      }
+    }
+    r.isRequired = r;
+    function o() {
+      return r;
+    }
+    var s = {
+      array: r,
+      bigint: r,
+      bool: r,
+      func: r,
+      number: r,
+      object: r,
+      string: r,
+      symbol: r,
+      any: r,
+      arrayOf: o,
+      element: r,
+      elementType: r,
+      instanceOf: o,
+      node: r,
+      objectOf: o,
+      oneOf: o,
+      oneOfType: o,
+      shape: o,
+      exact: o,
+      checkPropTypes: n,
+      resetWarningCache: t
+    };
+    return s.PropTypes = s, s;
+  }, He;
+}
+if (process.env.NODE_ENV !== "production") {
+  var En = ot, gn = !0;
+  Fe.exports = pn()(En.isElement, gn);
+} else
+  Fe.exports = hn()();
+const mt = Ee(), pt = Ee(), Ue = "UPDATE_ALL_SETTINGS", ht = "UPDATE_SETTING", Et = "UPDATE_USERNAME", gt = "REMOVE_SETTING", yn = (e, t) => {
+  switch (t.type) {
+    case Et:
+      return { ...e, userName: t.userName };
+    case Ue:
+      return { ...e, settings: t.settings };
+    case ht: {
+      const n = { ...e.settings, ...t.setting };
+      return { ...e, settings: n };
+    }
+    case gt: {
+      const n = { ...e.settings };
+      return delete n[t.key], { ...e, settings: n };
+    }
+    default:
+      return e;
+  }
+};
+function yt({
+  userName: e,
+  settingsKey: t,
+  children: n,
+  initialSettings: r,
+  onChange: o,
+  getSettingsApi: s,
+  updateSettingsApi: a
+}) {
+  const [i, l] = fe(yn, {
+    settings: r,
+    userName: e
+  }), u = z();
+  return $(() => {
+    const { userName: c } = i;
+    !s || !c || s({
+      entityType: "user",
+      entityId: c,
+      key: t
+    }).then(({ data: p }) => {
+      l({
+        type: Ue,
+        settings: p,
+        userName: c,
+        settingsKey: t
+      }), u.current = JSON.stringify(p);
+    }).catch((p) => {
+      const { response: m } = p;
+      if (m.status !== 404)
+        throw new Error(p);
+    });
+  }, [i.userName]), $(() => {
+    o && o(i.settings);
+    const { userName: c } = i;
+    if (!a || !c)
+      return;
+    const p = JSON.stringify(i.settings), m = u.current;
+    !m || p === m || (a({
+      entityType: "user",
+      entityId: c,
+      key: t,
+      value: p
+    }), u.current = p);
+  }, [i.settings]), /* @__PURE__ */ B(pt.Provider, { value: i, children: /* @__PURE__ */ B(mt.Provider, { value: l, children: n }) });
+}
+const An = () => {
+  const e = Ie(pt);
+  if (!e)
+    throw new Error("useSettingsState must be used within SettingsStateContext");
+  return e;
+}, Cn = () => {
+  const e = Ie(mt);
+  if (!e)
+    throw new Error("useSettingsDispatch must be used within SettingsDispatchContext");
+  return e;
+}, Sn = () => {
+  const e = Cn(), t = P(
+    (s) => e({ type: Ue, settings: s }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  ), n = P(
+    (s) => e({ type: ht, setting: s }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  ), r = P(
+    (s) => e({ type: Et, userName: s }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []
+  ), o = P((s) => e({ type: gt, key: s }), []);
+  return {
+    updateAllSettings: t,
+    updateSetting: n,
+    updateUsername: r,
+    removeSetting: o
+  };
+}, bo = () => {
+  const { settings: e = {} } = An();
+  return {
+    ...Sn(),
+    settings: e
+  };
+};
+yt.propTypes = {
+  userName: q.string,
+  settingsKey: q.string,
+  children: q.objectOf(q.any),
+  initialSettings: q.objectOf(q.any),
+  onChange: q.func,
+  getSettingsApi: q.func,
+  updateSettingsApi: q.func
+};
+yt.defaultProps = {
+  userName: void 0,
+  settingsKey: void 0,
+  children: null,
+  initialSettings: {},
+  onChange: null,
+  getSettingsApi: Ne.getSimpleMetadataKey,
+  updateSettingsApi: Ne.updateSimpleMetadataKey
+};
+const ve = "VIDISPINE-TOKEN", pe = "VIDISPINE-USERNAME", Te = "VIDISPINE-SERVER-URL", Re = "VIDISPINE-REMEMBER-ME", vn = "Incorrect username or password", Ye = "Offline or CORS not configured", Be = "Session expired", Tn = "VIDISPINE_URL mismatch", Qe = (e) => {
+  try {
+    return et.getSelfTest({ baseURL: e }).then(() => vn).catch(() => Ye);
+  } catch {
+    return Promise.resolve(Ye);
+  }
+}, Rn = ({ maxAge: e = 60, userName: t, password: n, serverUrl: r }) => {
+  try {
+    return X.getToken({
+      queryParams: { seconds: e, autoRefresh: "true" },
+      headers: { password: n, username: t },
+      baseURL: r
+    }).then(({ data: o }) => o).catch(
+      () => Qe(r).then((o) => {
+        throw Error(o);
+      })
+    );
+  } catch {
+    return Qe(r).then((s) => {
+      throw Error(s);
+    });
+  }
+}, At = Ee({
+  serverUrl: null,
+  token: null,
+  userType: null,
+  userName: null,
+  onLogin: () => null,
+  onLogout: () => null
+});
+function Ct({
+  cookieOptions: e,
+  LoginComponent: t,
+  LoginProps: n,
+  onGetToken: r,
+  onSuccess: o,
+  onError: s,
+  serverUrl: a,
+  userName: i,
+  token: l,
+  children: u
+}) {
+  const { data: c, request: p } = k(X.getUser), [m, d, h] = nt([
+    ve,
+    pe,
+    Te,
+    Re
+  ]), {
+    [ve]: f = l,
+    [pe]: C = i,
+    [Te]: v = a
+  } = m, g = m[Re] === "true", { maxAge: y } = e, S = P(
+    (G) => {
+      let j;
+      try {
+        return r({ maxAge: y, ...G }).then((W) => {
+          const {
+            userName: Q,
+            serverUrl: re,
+            rememberMe: ne
+          } = G;
+          Q && d(pe, Q, e), re && d(Te, re, e), ne && d(Re, ne, e), W && d(ve, W, e), p({ userName: Q }), o && o(G);
+        }).catch((W) => {
+          j = W, s && s(j);
+        });
+      } catch (W) {
+        j = W, s && s(j);
+      }
+      return j;
+    },
+    [e, y, s, r, o, p, d]
+  ), R = P(() => {
+    h(ve, e), g || (h(pe, e), h(Te, e), h(Re, e));
+  }, [e, g, h]), A = z(), N = z();
+  $(() => (f && (A.current && J.defaultClient.interceptors.response.eject(A.current), A.current = J.defaultClient.interceptors.response.use(
+    (G) => G,
+    (G) => {
+      if (G.response)
+        G.response.status === 401 && (R(), s && s(Error(Be)));
+      else {
+        const { config: { baseURL: j } = {} } = G;
+        N.current !== !0 && (N.current = !0, et.getSelfTest({ baseURL: j }).then(() => {
+          N.current = void 0, R(), s && s(Error(Be));
+        }).catch(() => (N.current = void 0, null)));
+      }
+      return Promise.reject(G);
+    }
+  )), () => {
+    A.current && J.defaultClient.interceptors.response.eject(A.current);
+  }), [R, s, f]), $(() => {
+    f && C === void 0 && X.whoAmI().then(
+      ({ data: G }) => d(pe, G, e)
+    );
+  }, [C, f]), $(() => {
+    f && v && a && v !== a && (R(), s && s(Error(Tn)));
+  }, [f, v, a, R, s]);
+  const _ = he(
+    () => ({
+      serverUrl: v,
+      token: f,
+      userType: c,
+      userName: C,
+      onLogin: S,
+      onLogout: R
+    }),
+    [S, R, v, f, C, c]
+  );
+  return f ? /* @__PURE__ */ B(lt, { token: f, username: C, serverUrl: v, children: /* @__PURE__ */ B(At.Provider, { value: _, children: u }) }) : /* @__PURE__ */ B(
+    t,
+    {
+      onLogin: S,
+      userName: C,
+      serverUrl: v,
+      rememberMe: g,
+      ...n
+    }
+  );
+}
+Ct.propTypes = {
+  cookieOptions: q.shape({
+    maxAge: q.number,
+    path: q.string
+  }),
+  LoginComponent: q.elementType.isRequired,
+  LoginProps: q.objectOf(q.any),
+  onGetToken: q.func,
+  children: q.oneOfType([q.arrayOf(q.element), q.element]),
+  onSuccess: q.func,
+  onError: q.func,
+  serverUrl: q.string.isRequired,
+  userName: q.string,
+  token: q.string
+};
+Ct.defaultProps = {
+  cookieOptions: {
+    maxAge: 604800,
+    path: "/"
+  },
+  LoginProps: {},
+  onGetToken: Rn,
+  children: null,
+  onSuccess: null,
+  onError: null,
+  userName: null,
+  token: null
+};
+const wo = () => {
+  const e = Ie(At);
+  if (e === void 0)
+    throw new Error("useAuth must be used within an AuthContext");
+  return e;
+}, Pn = ({ entityId: e, entityType: t, collectionId: n, rootParentId: r, onError: o }) => {
+  if (n && n !== r)
+    try {
+      return V.addCollectionEntity({
+        collectionId: n,
+        entityId: e,
+        queryParams: {
+          type: t.toLowerCase()
+        }
+      });
+    } catch (s) {
+      o({
+        message: `Could not add ${e} to collection ${n}`,
+        error: s
+      });
+    }
+}, Nn = ({
+  entityId: e,
+  entityType: t,
+  collectionId: n,
+  rootParentId: r,
+  onError: o
+}) => {
+  if (n && n !== r)
+    try {
+      return V.removeCollectionEntity({
+        collectionId: n,
+        entityId: e,
+        queryParams: {
+          type: t.toLowerCase()
+        }
+      });
+    } catch (s) {
+      o({
+        message: `Could not remove ${e} from collection ${n}`,
+        error: s
+      });
+    }
+}, Do = ({
+  entityId: e,
+  entityType: t,
+  addToCollectionId: n,
+  removeFromCollectionId: r,
+  rootParentId: o,
+  onAddEntity: s = Pn,
+  onRemoveEntity: a = Nn,
+  onMoved: i = () => null,
+  onAdded: l = () => null,
+  onRemoved: u = () => null,
+  // eslint-disable-next-line no-console
+  onError: c = ({ message: p, error: m }) => console.error(`${p}
+${m}`)
+}) => {
+  if (!n) {
+    c({ message: "Missing the collection id to add entity to", error: "" });
+    return;
+  }
+  if (!r) {
+    c({ message: "Missing the collection id to remove entity from", error: "" });
+    return;
+  }
+  try {
+    const p = s({
+      entityId: e,
+      entityType: t,
+      rootParentId: o,
+      collectionId: n,
+      onError: c
+    }), m = a({
+      entityId: e,
+      entityType: t,
+      rootParentId: o,
+      collectionId: r,
+      onError: c
+    }), d = [p, m].filter((h) => h !== void 0);
+    Promise.allSettled(d).then((h) => {
+      const f = h.filter((y) => y.status !== "fulfilled"), C = f.length === 0, v = f.length === d.length, g = f.length === 1;
+      if (C)
+        i(), l(), u();
+      else if (v)
+        c({
+          message: `Could not move ${e} from ${r} to ${n}`,
+          error: f.map((y) => y.reason).join(`
+`)
+        });
+      else if (g) {
+        const y = f[0].reason.config.method, S = y === "delete", R = y === "put";
+        c({
+          message: S ? `Could not remove ${e} from collection ${r}` : `Could not add ${e} to collection ${n}`,
+          error: f[0].reason
+        });
+        let A;
+        S ? A = a({
+          entityId: e,
+          entityType: t,
+          collectionId: n,
+          onError: c
+        }) : R && (A = s({
+          entityId: e,
+          entityType: t,
+          collectionId: r,
+          onError: c
+        })), A && A.then(() => {
+          console.info(
+            `Rollbacked moving ${e} from ${r} to ${n}`
+          );
+        }).catch((N) => {
+          c({ message: "Could not rollback after moving entity", error: N });
+        });
+      }
+    }).catch((h) => {
+      c({
+        message: `Could not add ${e} to collection ${n}`,
+        error: h
+      });
+    });
+  } catch (p) {
+    c({
+      message: `Could not move ${e} from ${r} to collection ${n}`,
+      error: p
+    });
+  }
+};
+function Oo({
+  children: e,
+  setDrag: t,
+  onDrop: n,
+  onDragEnter: r,
+  onDragOver: o,
+  onDragLeave: s,
+  style: a
+}) {
+  const [i, l] = M(0), u = (d) => {
+    d.preventDefault(), d.stopPropagation(), t(!1), n && n(d);
+  }, c = (d) => {
+    d.preventDefault(), d.stopPropagation(), l(i + 1), i === 0 && t(!0), r && r(d);
+  }, p = (d) => {
+    d.preventDefault(), d.stopPropagation(), o && o(d);
+  }, m = (d) => {
+    d.preventDefault(), d.stopPropagation(), l(i - 1), i === 1 && t(!1), s && s(d);
+  };
+  return /* @__PURE__ */ B(
+    "div",
+    {
+      onDragEnter: (d) => c(d),
+      onDragOver: (d) => p(d),
+      onDrop: (d) => u(d),
+      onDragLeave: (d) => m(d),
+      style: a,
+      children: e
+    }
+  );
+}
+export {
+  So as Auth,
+  At as AuthContext,
+  Ct as AuthProvider,
+  ln as BinContext,
+  Go as BinProvider,
+  Po as ComposeProviders,
+  Oo as DropArea,
+  cn as ErrorBoundary,
+  yo as GetCollection,
+  No as GetEntityMetadata,
+  vo as GetFieldGroup,
+  go as GetItem,
+  Ao as GetJobs,
+  Ro as HasRole,
+  Co as ListEntityAccess,
+  mo as MetadataType,
+  To as RolesProvider,
+  po as SearchCollection,
+  ho as SearchItem,
+  Eo as SearchItemCollection,
+  yt as SettingsProvider,
+  lt as VidispineApi,
+  _o as compose,
+  Pn as handleAddEntity,
+  Do as handleMoveEntity,
+  Nn as handleRemoveEntity,
+  Bn as useAddMetadataFieldAttributes,
+  k as useApi,
+  wo as useAuthContext,
+  Un as useAutocomplete,
+  oo as useCollectionAutoPlay,
+  fo as useCompoundMetadata,
+  lo as useCsvDownload,
+  ao as useDocSearchAutocomplete,
+  Yn as useEntityAccess,
+  Hr as useGetCollection,
+  Xn as useGetCollectionItem,
+  zn as useGetEntity,
+  nn as useGetEntityMetadata,
+  on as useGetFieldGroup,
+  io as useGetFieldMetadataDataset,
+  Qr as useGetItem,
+  co as useGetSavedSearchFolders,
+  no as useGroup,
+  so as useHoverScrub,
+  Fn as useInterval,
+  $n as useJobSearch,
+  eo as useListGroup,
+  to as useListUser,
+  jn as useLocalStorage,
+  Jn as useMouseDownPosition,
+  Vn as useQueryInitialState,
+  uo as useRepresentativeItems,
+  un as useRoles,
+  Qn as useSavedSearch,
+  Kt as useSearch,
+  ro as useSearchGroup,
+  Or as useSearchItem,
+  Zn as useSearchUser,
+  xn as useSelected,
+  bo as useSettings,
+  Sn as useSettingsActions,
+  Mn as useTab,
+  qn as useThumbnailScrub,
+  st as useUpdateEffect,
+  kn as useUpdateQueryState,
+  Wn as useUploadFiles,
+  Kn as useUser,
+  Io as withErrorBoundary
+};