@ynput/ayon-frontend-shared 0.4.7 → 0.5.0

package/dist/Slicer.es.js

@@ -1,6 +1,7 @@
-import { S as K, b as V, d as $, u as j, a as z, c as B } from "./chunks/Slicer.es.js";
-import { S as Q, a as U, u as X, b as Z, c as N, d as tt } from "./chunks/entityDefinitions.es.js";
-import { useMemo as E, useState as p, useEffect as k } from "react";
+import { S as Z, a as ee, b as te, c as se, d as re, e as oe, f as ie, g as ne, r as de, u as le, h as ce, i as ae, j as ue, k as pe } from "./chunks/Slicer.es.js";
+import { u as k } from "./chunks/entityDefinitions.es.js";
+import { S as Ie, a as Se, b as ye, c as he, d as Ee, e as me } from "./chunks/entityDefinitions.es.js";
+import { useMemo as h, useState as y, useEffect as P } from "react";
 import "./chunks/ProjectContext.es.js";
 import "./chunks/GlobalContext.es.js";
 import "./chunks/MetaWidget.es.js";
@@ -8,135 +9,139 @@ import "lodash";
 import "primereact/confirmdialog";
 import "react-toastify";
 import "uuid";
-import { ay as I, aq as v } from "./chunks/searchTerms.es.js";
+import { ay as m, aq as _ } from "./chunks/searchTerms.es.js";
 import "./chunks/getUris.es.js";
-import { useDispatch as g } from "react-redux";
-import { S as et, a as rt, u as ot } from "./chunks/useSlicerSplitter.es.js";
-const D = ({
-  sliceFilter: t,
-  persistedHierarchySelection: s,
-  filters: e,
-  merge: n = !0
-}) => E(() => {
-  const r = (a) => ({
+import { useDispatch as R } from "react-redux";
+import { u as F } from "./chunks/useLocalStorage.es.js";
+const B = ({
+  sliceFilter: e,
+  persistedHierarchySelection: t,
+  filters: r,
+  merge: d = !0
+}) => h(() => {
+  const i = (n) => ({
     id: "hierarchy",
     label: "Folder",
     type: "list_of_strings",
-    values: Object.keys(a).filter((i) => a[i]).map((i) => ({ id: i, label: i })),
+    values: Object.keys(n).filter((l) => n[l]).map((l) => ({ id: l, label: l })),
     isCustom: !0,
     singleSelect: !0,
     fieldType: "folder",
     operator: "OR",
     isReadonly: !0
   });
-  return t && s ? n ? [r(s), ...e] : [r(s)] : e;
-}, [t, s, e]), w = async (t, s, e) => {
-  const n = new Set(t.folderIds), d = new Set(t.taskIds), r = new Set(t.versionIds), a = new Set(t.productIds), i = [];
-  return t.taskIds.length && i.push(
-    e(
-      I.endpoints.GetTasksList.initiate({
-        projectName: s,
-        taskIds: t.taskIds,
-        first: t.taskIds.length
+  return e && t ? d ? [i(t), ...r] : [i(t)] : r;
+}, [e, t, r]), C = async (e, t, r) => {
+  const d = new Set(e.folderIds), o = new Set(e.taskIds), i = new Set(e.versionIds), n = new Set(e.productIds), l = {}, a = {}, I = {}, p = [];
+  return e.taskIds.length && p.push(
+    r(
+      m.endpoints.GetTasksList.initiate({
+        projectName: t,
+        taskIds: e.taskIds,
+        first: e.taskIds.length
       })
-    ).unwrap().then((c) => {
-      for (const o of c.tasks)
-        o.folderId && n.add(o.folderId);
+    ).unwrap().then((u) => {
+      for (const s of u.tasks)
+        s.folderId && (d.add(s.folderId), l[s.id] = s.folderId);
     })
-  ), t.versionIds.length && i.push(
-    e(
-      I.endpoints.GetVersions.initiate({
-        projectName: s,
-        versionIds: t.versionIds,
-        first: t.versionIds.length
+  ), e.versionIds.length && p.push(
+    r(
+      m.endpoints.GetVersions.initiate({
+        projectName: t,
+        versionIds: e.versionIds,
+        first: e.versionIds.length
       })
-    ).unwrap().then((c) => {
-      for (const o of c.versions)
-        o.task?.id && d.add(o.task.id), o.product?.id && a.add(o.product.id), o.product?.folder?.id && n.add(o.product.folder.id);
+    ).unwrap().then((u) => {
+      for (const s of u.versions)
+        s.task?.id && o.add(s.task.id), s.product?.id && n.add(s.product.id), s.product?.folder?.id && (d.add(s.product.folder.id), a[s.id] = s.product.folder.id, s.product?.id && (I[s.product.id] = s.product.folder.id));
     })
-  ), t.productIds.length && i.push(
-    e(
-      I.endpoints.GetProducts.initiate({
-        projectName: s,
-        productIds: t.productIds,
-        first: t.productIds.length
+  ), e.productIds.length && p.push(
+    r(
+      m.endpoints.GetProducts.initiate({
+        projectName: t,
+        productIds: e.productIds,
+        first: e.productIds.length
       })
-    ).unwrap().then((c) => {
-      for (const o of c.products)
-        o.folderId && n.add(o.folderId);
+    ).unwrap().then((u) => {
+      for (const s of u.products)
+        s.folderId && (d.add(s.folderId), I[s.id] = s.folderId);
     })
-  ), await Promise.all(i), {
-    folderIds: [...n],
-    taskIds: [...d],
-    versionIds: [...r],
-    productIds: [...a]
+  ), await Promise.all(p), {
+    folderIds: [...d],
+    taskIds: [...o],
+    versionIds: [...i],
+    productIds: [...n],
+    parentMaps: { taskFolderIds: l, versionFolderIds: a, productFolderIds: I }
   };
-}, l = {
+}, f = {
   folderIds: [],
   taskIds: [],
   versionIds: [],
   productIds: []
-}, T = (t) => {
-  const s = {
+}, g = {
+  taskFolderIds: {},
+  versionFolderIds: {},
+  productFolderIds: {}
+}, b = (e) => {
+  const t = {
     folder: /* @__PURE__ */ new Set(),
     task: /* @__PURE__ */ new Set(),
     version: /* @__PURE__ */ new Set(),
     product: /* @__PURE__ */ new Set()
   };
-  for (const { entityType: e, entityIds: n } of t) {
-    const d = s[e];
-    if (d)
-      for (const r of n)
-        d.add(r);
+  for (const { entityType: r, entityIds: d } of e) {
+    const o = t[r];
+    if (o)
+      for (const i of d)
+        o.add(i);
   }
   return {
-    folderIds: [...s.folder],
-    taskIds: [...s.task],
-    versionIds: [...s.version],
-    productIds: [...s.product]
+    folderIds: [...t.folder],
+    taskIds: [...t.task],
+    versionIds: [...t.version],
+    productIds: [...t.product]
   };
-}, M = ({
-  rowSelection: t,
-  sliceType: s,
-  projectName: e
+}, J = ({
+  slices: e,
+  projectName: t
 }) => {
-  const n = g(), [d, r] = p(l), [a, i] = p(l), [c, o] = p(!1);
-  return k(() => {
-    if (s !== "entityList" || !e) {
-      r(l), i(l);
+  const r = R(), [d, o] = y(f), [i, n] = y(f), [l, a] = y(g), [I, p] = y(""), u = e.find((c) => c.sliceType === "entityList")?.rowSelection, s = h(
+    () => Object.keys(u ?? {}).filter((c) => u?.[c] && !c.startsWith("folder-")).sort(),
+    [u]
+  ), S = s.length && t ? `${t}|${s}` : "";
+  return P(() => {
+    if (!S) {
+      o(f), n(f), a(g), p("");
       return;
     }
-    const S = Object.keys(t).filter(
-      (u) => t[u] && !u.startsWith("folder-")
-    );
-    if (!S.length) {
-      r(l), i(l);
-      return;
-    }
-    let f = !1;
-    return o(!0), (async () => {
+    let c = !1;
+    return (async () => {
       try {
-        const u = await Promise.all(
-          S.map(
-            (m) => n(
-              v.endpoints.getListEntities.initiate({ projectName: e, listId: m })
+        const E = await Promise.all(
+          s.map(
+            (T) => r(
+              _.endpoints.getListEntities.initiate({ projectName: t, listId: T })
             ).unwrap()
           )
-        ), y = T(u);
-        f || i(y);
-        const h = await w(y, e, n);
-        f || r(h);
-      } catch (u) {
-        console.error("Error fetching entity list IDs:", u), f || (r(l), i(l));
+        ), v = b(E);
+        c || n(v);
+        const { parentMaps: w, ...L } = await C(
+          v,
+          t,
+          r
+        );
+        c || (o(L), a(w));
+      } catch (E) {
+        console.error("Error fetching entity list IDs:", E), c || (o(f), n(f), a(g));
       } finally {
-        f || o(!1);
+        c || p(S);
       }
     })(), () => {
-      f = !0;
+      c = !0;
     };
-  }, [s, t, e, n]), { entityIds: d, rawEntityIds: a, isLoading: c };
-}, H = ({ slice: t, attribFields: s }) => {
-  const e = {
+  }, [S, s, t, r]), { entityIds: d, rawEntityIds: i, parentMaps: l, isLoading: S !== I };
+}, M = ({ slice: e, attribFields: t }) => {
+  const r = {
     assignees: "list_of_strings",
     status: "string",
     taskType: "string",
@@ -144,41 +149,68 @@ const D = ({
     author: "string",
     hierarchy: void 0,
     entityList: void 0,
-    ...s.reduce((d, r) => (d["attrib." + r.name] = r.data.type, d), {})
+    ...t.reduce((o, i) => (o["attrib." + i.name] = i.data.type, o), {})
   };
   return (() => {
-    if (!t) return null;
-    const d = e[t?.sliceType], r = Object.keys(t.rowSelection).filter((a) => !!a).map((a) => ({
-      id: a,
-      label: a
+    if (!e) return null;
+    const o = r[e?.sliceType], i = Object.entries(e.rowSelection).filter(([n, l]) => !!n && l).map(([n]) => ({
+      id: n,
+      label: n
     }));
     return {
-      id: t?.sliceType,
-      label: t?.sliceType,
-      type: d,
+      id: e?.sliceType,
+      label: e?.sliceType,
+      type: o,
       inverted: !1,
       operator: "OR",
-      values: r
+      values: i
     };
   })();
+}, O = ({
+  slices: e,
+  attribFields: t
+}) => e.filter((r) => r.sliceType !== "hierarchy" && r.sliceType !== "entityList").map((r) => M({ slice: r, attribFields: t })).filter((r) => !!r), N = (e) => {
+  const { slices: t, getPanelSelection: r } = k(), { powerLicense: d, isLoading: o } = F(), i = h(() => {
+    const l = t.map((a) => ({
+      sliceType: a.sliceType,
+      rowSelection: r(a.id)
+    }));
+    return d ? l : l.slice(0, 1);
+  }, [t, r, d]), n = h(
+    () => O({ slices: i, attribFields: e }),
+    [i, e]
+  );
+  return {
+    sliceSelections: i,
+    sliceFilters: n,
+    isLicensePending: t.length > 1 && o
+  };
 };
 export {
-  Q as SLICER_PAGES_CONFIG,
-  et as SLICER_SPLITTER_PANEL_CONFIG,
-  rt as SLICER_SPLITTER_STATE_KEY,
-  K as Slicer,
-  U as SlicerProvider,
-  V as buildListFolderRowId,
-  H as createFilterFromSlicer,
-  $ as defaultSliceOptions,
-  j as useEntityListsSlice,
-  D as useFiltersWithHierarchy,
-  z as useHierarchyContextMenuItems,
-  X as useOptionalSlicerContext,
-  M as useSelectedEntityIds,
-  Z as useSlicerContext,
-  B as useSlicerCounts,
-  N as useSlicerRemotes,
-  tt as useSlicerRowSelection,
-  ot as useSlicerSplitter
+  Z as SLICER_DEFAULT_PANEL_HEIGHT,
+  ee as SLICER_MIN_PANEL_HEIGHT,
+  Ie as SLICER_PAGES_CONFIG,
+  te as SLICER_SPLITTER_PANEL_CONFIG,
+  se as SLICER_SPLITTER_STATE_KEY,
+  re as Slicer,
+  Se as SlicerProvider,
+  oe as buildListFolderRowId,
+  ie as clampDraggedHeights,
+  M as createFilterFromSlicer,
+  O as createFiltersFromSlicer,
+  ne as defaultSliceOptions,
+  de as resolvePanelLayout,
+  le as useEntityListsSlice,
+  B as useFiltersWithHierarchy,
+  ce as useHierarchyContextMenuItems,
+  ye as useHierarchySelection,
+  he as useOptionalSlicerContext,
+  J as useSelectedEntityIds,
+  k as useSlicerContext,
+  ae as useSlicerCounts,
+  ue as useSlicerPanelHeights,
+  N as useSlicerPanelSelections,
+  Ee as useSlicerRemotes,
+  me as useSlicerRowSelection,
+  pe as useSlicerSplitter
 };