@ynput/ayon-frontend-shared 0.6.0 → 0.6.1

package/dist/Slicer.es.js

@@ -1,147 +1,450 @@
-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";
-import "lodash";
+import { S as Ve, a as je, b as Ne, c as et, d as tt, e as st, f as nt, g as ot, r as rt, u as it, h as ct, i as lt, j as dt, k as at } from "./chunks/Slicer.es.js";
+import { jsx as Se } from "react/jsx-runtime";
+import { useState as A, useEffect as M, useRef as Y, useCallback as m, useMemo as L } from "react";
+import { a as z, o as U, s as ce, q as ye } from "./chunks/DeleteEntitiesContextInstance.es.js";
+import { S as he, c as pe, d as Ee } from "./chunks/MetaWidget.es.js";
+import { e as ft, u as St } from "./chunks/MetaWidget.es.js";
+import "@module-federation/enhanced/runtime";
+import { az as B, aq as Ie } from "./chunks/searchTerms.es.js";
+import "./chunks/getUris.es.js";
 import "primereact/confirmdialog";
+import "lodash";
 import "react-toastify";
 import "uuid";
-import { az as m, aq as _ } from "./chunks/searchTerms.es.js";
-import "./chunks/getUris.es.js";
-import { useDispatch as R } from "react-redux";
-import { a as F } from "./chunks/useLocalStorage.es.js";
-const B = ({
-  sliceFilter: e,
-  persistedHierarchySelection: t,
-  filters: r,
-  merge: d = !0
-}) => h(() => {
-  const i = (n) => ({
+import { u as le } from "./chunks/useLoadModule.es.js";
+import "@ynput/ayon-react-components";
+import "./chunks/ContextMenuContextInstance.es.js";
+import "clsx";
+import "react-dom";
+import { useDispatch as ge } from "react-redux";
+import "semver";
+import { u as ht } from "./chunks/useHierarchySelection.es.js";
+const me = () => {
+  const n = () => ({
+    formatStatuses: () => [],
+    formatTaskTypes: () => [],
+    formatTypes: () => [],
+    formatAssignees: () => [],
+    formatAttribute: () => [],
+    formatProductTypes: () => [],
+    formatAuthors: () => []
+  }), { powerLicense: e } = z(), [s, { isLoading: c }] = le({
+    addon: "powerpack",
+    remote: "slicer",
+    module: "useExtraSlices",
+    fallback: n,
+    skip: !e
+    // skip loading if powerpack license is not available
+  }), [l] = le({
+    addon: "powerpack",
+    remote: "slicer",
+    module: "SlicerDropdown",
+    fallback: he,
+    skip: !e
+    // skip loading if powerpack license is not available
+  });
+  return { useExtraSlices: s, isLoadingExtraSlices: c, SlicerDropdown: l };
+}, we = ["slicer-selection-", "slicer-expanded-"], de = (n, e, s) => s === "hierarchy" ? `slicer-selection-hierarchy-${n}` : `slicer-selection-${n}-${e}-${s}`, ae = (n, e, s) => s === "hierarchy" ? `slicer-expanded-hierarchy-${n}` : `slicer-expanded-${n}-${e}-${s}`, Pe = ({
+  sliceTypes: n,
+  page: e,
+  projectName: s,
+  ...c
+}) => {
+  const [l, f] = A(0);
+  M(() => {
+    const t = (a) => {
+      const u = a.detail?.key ?? ("key" in a ? a.key : void 0);
+      u && !we.some((I) => u.startsWith(I)) || f((I) => I + 1);
+    };
+    return window.addEventListener("session-storage", t), window.addEventListener("storage", t), () => {
+      window.removeEventListener("session-storage", t), window.removeEventListener("storage", t);
+    };
+  }, []);
+  const S = Y(/* @__PURE__ */ new Map()), d = m((t, a) => {
+    const u = typeof window > "u" ? null : sessionStorage.getItem(t), I = S.current.get(t);
+    if (I && I.raw === u) return I.value;
+    const _ = U(t, a);
+    return S.current.set(t, { raw: u, value: _ }), _;
+  }, []), o = n[0], y = m(
+    (t) => c.rowSelection !== void 0 && t === o ? c.rowSelection : d(de(s, e, t), {}),
+    // storageVersion invalidates memoized reads when any bucket changes
+    [c.rowSelection, o, s, e, d, l]
+  ), h = m(
+    (t, a) => {
+      if (c.setRowSelection && t === o) {
+        c.setRowSelection(a);
+        return;
+      }
+      const u = de(s, e, t), I = typeof a == "function" ? a(d(u, {})) : a;
+      ce(u, I);
+    },
+    [c.setRowSelection, o, s, e, d]
+  ), w = m(
+    (t) => c.expanded !== void 0 && t === o ? c.expanded : d(ae(s, e, t), {}),
+    [c.expanded, o, s, e, d, l]
+  ), i = m(
+    (t, a) => {
+      if (c.setExpanded && t === o) {
+        c.setExpanded(a);
+        return;
+      }
+      const u = ae(s, e, t), I = typeof a == "function" ? a(d(u, {})) : a;
+      ce(u, I);
+    },
+    [c.setExpanded, o, s, e, d]
+  ), P = y(o), E = m(
+    (t, a = o) => h(a, t),
+    [h, o]
+  ), T = w(o), x = m(
+    (t, a = o) => i(a, t),
+    [i, o]
+  );
+  return {
+    rowSelection: P,
+    setRowSelection: E,
+    expanded: T,
+    setExpanded: x,
+    getPanelSelection: y,
+    setPanelSelection: h,
+    getPanelExpanded: w,
+    setPanelExpanded: i
+  };
+}, ue = ["overview", "products"], Ue = ({
+  children: n,
+  page: e,
+  projectName: s,
+  viewSettings: c,
+  isLoadingViews: l,
+  updateViewSettings: f,
+  onOpenViewer: S,
+  onAddToList: d,
+  ...o
+}) => {
+  const [y, h] = ye(
+    `slicer-pinned-slice-${e}`,
+    null
+  ), { powerLicense: w } = z(), i = c, P = i?.sliceTypes, E = i?.sliceType, T = P?.length ? E && E !== P[0] ? [E, ...P.slice(1)] : P : [E ?? "hierarchy"], x = ue.includes(e) && !o.sliceType && !P?.length && T[0] !== "hierarchy" && y?.sliceType === "hierarchy" && Object.values(y.rowSelection || {}).some(Boolean), t = L(
+    () => [
+      ...new Set(
+        o.sliceType ? [o.sliceType] : x ? [...T, "hierarchy"] : T
+      )
+    ],
+    [o.sliceType, T.join("|"), x]
+  ), a = i?.collapsedSliceTypes, u = L(() => a ?? [], [a?.join("|")]), I = L(
+    () => t.map((r) => ({ id: r, sliceType: r })),
+    [t]
+  ), _ = I[0].sliceType, {
+    rowSelection: O,
+    setRowSelection: D,
+    expanded: G,
+    setExpanded: H,
+    getPanelSelection: W,
+    setPanelSelection: C,
+    getPanelExpanded: X,
+    setPanelExpanded: b
+  } = Pe({
+    sliceTypes: t,
+    page: e,
+    projectName: s,
+    ...o
+  }), J = m(
+    (r) => {
+      D(r);
+    },
+    [D]
+  ), k = m(
+    (r, g) => {
+      const p = () => {
+      };
+      f(
+        {
+          sliceTypes: r,
+          sliceType: r[0],
+          collapsedSliceTypes: (g ?? u).filter((R) => r.includes(R))
+        },
+        p,
+        p,
+        {}
+      );
+    },
+    [f, u]
+  ), Q = m(
+    (r) => {
+      const g = u.includes(r) ? u.filter((p) => p !== r) : [...u, r];
+      k(t, g);
+    },
+    [u, k, t]
+  ), F = `${s}-${e}`, Z = Y(/* @__PURE__ */ new Set());
+  M(() => {
+    !x || l || Z.current.has(F) || (Z.current.add(F), Object.keys(W("hierarchy")).length || (C("hierarchy", y.rowSelection), b("hierarchy", y.expanded)), k(t));
+  }, [x, l, F]);
+  const V = Y(/* @__PURE__ */ new Set());
+  M(() => {
+    if (V.current.has(F) || l || o.sliceType || o.rowSelection || o.setRowSelection || P?.length)
+      return;
+    V.current.add(F);
+    const r = `slicer-selection-${s}-${e}`, g = `slicer-expanded-${s}-${e}`, p = T[0];
+    if (p !== "hierarchy") {
+      const R = U(r, null);
+      if (R && Object.keys(R).length) {
+        C(
+          p,
+          (ie) => Object.keys(ie).length ? ie : R
+        );
+        const v = U(g, null);
+        v && b(p, v);
+      }
+    }
+    sessionStorage.removeItem(r), sessionStorage.removeItem(g);
+  }, [l, P, F]), M(() => {
+    ue.includes(e) && !o.sliceType && !l && y && !x && h(null);
+  }, [e, o.sliceType, l, y, x, h]);
+  const j = m(
+    (r, g) => {
+      if (w && t.slice(1).includes(r)) return;
+      o.onSliceTypeChange ? o.onSliceTypeChange(r, g) : k([r, ...t.slice(1).filter((v) => v !== r)]);
+      const p = (v) => o.setRowSelection ? o.setRowSelection(v) : D(v, r), R = (v) => o.setExpanded ? o.setExpanded(v) : H(v, r);
+      y && r === y.sliceType ? (p(y.rowSelection), R(y.expanded), h(null)) : r !== "hierarchy" && (p({}), R({})), g && h({
+        sliceType: _,
+        rowSelection: O,
+        expanded: G
+      });
+    },
+    [
+      k,
+      t,
+      O,
+      D,
+      y,
+      h,
+      G,
+      H,
+      o.setRowSelection,
+      o.setExpanded,
+      w
+    ]
+  ), K = m(
+    (r) => {
+      r !== "hierarchy" && (C(r, {}), b(r, {}));
+    },
+    [C, b]
+  ), N = m(
+    (r) => {
+      !r || t.includes(r) || (k([...t, r]), K(r));
+    },
+    [t, k, K]
+  ), ee = m(
+    (r) => {
+      if (t.length <= 1 || !t.includes(r)) return;
+      const g = t.filter((p) => p !== r);
+      k(g, g.length > 1 ? void 0 : []);
+    },
+    [t, k]
+  ), te = m(
+    (r, g) => {
+      !t.includes(r) || t.includes(g) || (k(
+        t.map((p) => p === r ? g : p),
+        u.map((p) => p === r ? g : p)
+      ), K(g));
+    },
+    [t, k, K, u]
+  ), se = m(
+    (r) => {
+      H(r);
+    },
+    [H]
+  ), { useExtraSlices: ne, isLoadingExtraSlices: oe, SlicerDropdown: re } = me(), fe = L(
+    () => ({
+      projectName: s,
+      page: e,
+      useExtraSlices: ne,
+      isLoadingExtraSlices: oe,
+      SlicerDropdown: re,
+      // SLICE TYPE
+      sliceType: _,
+      onSliceTypeChange: j,
+      // SLICE PANELS
+      slices: I,
+      addSlicePanel: N,
+      removeSlicePanel: ee,
+      setPanelSliceType: te,
+      getPanelSelection: W,
+      setPanelSelection: C,
+      getPanelExpanded: X,
+      setPanelExpanded: b,
+      collapsedPanels: u,
+      togglePanelCollapsed: Q,
+      // ROW SELECTION
+      rowSelection: O,
+      onRowSelectionChange: J,
+      // PINNED SLICE
+      pinnedSlice: y,
+      setPinnedSlice: h,
+      expanded: G,
+      onExpandedChange: se,
+      // loading state
+      isViewSyncPending: l,
+      onOpenViewer: S,
+      onAddToList: d
+    }),
+    [
+      e,
+      ne,
+      oe,
+      re,
+      _,
+      j,
+      I,
+      u,
+      Q,
+      N,
+      ee,
+      te,
+      W,
+      C,
+      X,
+      b,
+      O,
+      J,
+      y,
+      h,
+      G,
+      se,
+      l,
+      S,
+      d
+    ]
+  );
+  return /* @__PURE__ */ Se(pe.Provider, { value: fe, children: n });
+}, ze = ({
+  sliceFilter: n,
+  persistedHierarchySelection: e,
+  filters: s,
+  merge: c = !0
+}) => L(() => {
+  const f = (S) => ({
     id: "hierarchy",
     label: "Folder",
     type: "list_of_strings",
-    values: Object.keys(n).filter((l) => n[l]).map((l) => ({ id: l, label: l })),
+    values: Object.keys(S).filter((d) => S[d]).map((d) => ({ id: d, label: d })),
     isCustom: !0,
     singleSelect: !0,
     fieldType: "folder",
     operator: "OR",
     isReadonly: !0
   });
-  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
+  return n && e ? c ? [f(e), ...s] : [f(e)] : s;
+}, [n, e, s]), xe = async (n, e, s) => {
+  const c = new Set(n.folderIds), l = new Set(n.taskIds), f = new Set(n.versionIds), S = new Set(n.productIds), d = {}, o = {}, y = {}, h = [];
+  return n.taskIds.length && h.push(
+    s(
+      B.endpoints.GetTasksList.initiate({
+        projectName: e,
+        taskIds: n.taskIds,
+        first: n.taskIds.length
       })
-    ).unwrap().then((u) => {
-      for (const s of u.tasks)
-        s.folderId && (d.add(s.folderId), l[s.id] = s.folderId);
+    ).unwrap().then((w) => {
+      for (const i of w.tasks)
+        i.folderId && (c.add(i.folderId), d[i.id] = i.folderId);
     })
-  ), e.versionIds.length && p.push(
-    r(
-      m.endpoints.GetVersions.initiate({
-        projectName: t,
-        versionIds: e.versionIds,
-        first: e.versionIds.length
+  ), n.versionIds.length && h.push(
+    s(
+      B.endpoints.GetVersions.initiate({
+        projectName: e,
+        versionIds: n.versionIds,
+        first: n.versionIds.length
       })
-    ).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));
+    ).unwrap().then((w) => {
+      for (const i of w.versions)
+        i.task?.id && l.add(i.task.id), i.product?.id && S.add(i.product.id), i.product?.folder?.id && (c.add(i.product.folder.id), o[i.id] = i.product.folder.id, i.product?.id && (y[i.product.id] = i.product.folder.id));
     })
-  ), e.productIds.length && p.push(
-    r(
-      m.endpoints.GetProducts.initiate({
-        projectName: t,
-        productIds: e.productIds,
-        first: e.productIds.length
+  ), n.productIds.length && h.push(
+    s(
+      B.endpoints.GetProducts.initiate({
+        projectName: e,
+        productIds: n.productIds,
+        first: n.productIds.length
       })
-    ).unwrap().then((u) => {
-      for (const s of u.products)
-        s.folderId && (d.add(s.folderId), I[s.id] = s.folderId);
+    ).unwrap().then((w) => {
+      for (const i of w.products)
+        i.folderId && (c.add(i.folderId), y[i.id] = i.folderId);
     })
-  ), await Promise.all(p), {
-    folderIds: [...d],
-    taskIds: [...o],
-    versionIds: [...i],
-    productIds: [...n],
-    parentMaps: { taskFolderIds: l, versionFolderIds: a, productFolderIds: I }
+  ), await Promise.all(h), {
+    folderIds: [...c],
+    taskIds: [...l],
+    versionIds: [...f],
+    productIds: [...S],
+    parentMaps: { taskFolderIds: d, versionFolderIds: o, productFolderIds: y }
   };
-}, f = {
+}, $ = {
   folderIds: [],
   taskIds: [],
   versionIds: [],
   productIds: []
-}, g = {
+}, q = {
   taskFolderIds: {},
   versionFolderIds: {},
   productFolderIds: {}
-}, b = (e) => {
-  const t = {
+}, ke = (n) => {
+  const e = {
     folder: /* @__PURE__ */ new Set(),
     task: /* @__PURE__ */ new Set(),
     version: /* @__PURE__ */ new Set(),
     product: /* @__PURE__ */ new Set()
   };
-  for (const { entityType: r, entityIds: d } of e) {
-    const o = t[r];
-    if (o)
-      for (const i of d)
-        o.add(i);
+  for (const { entityType: s, entityIds: c } of n) {
+    const l = e[s];
+    if (l)
+      for (const f of c)
+        l.add(f);
   }
   return {
-    folderIds: [...t.folder],
-    taskIds: [...t.task],
-    versionIds: [...t.version],
-    productIds: [...t.product]
+    folderIds: [...e.folder],
+    taskIds: [...e.task],
+    versionIds: [...e.version],
+    productIds: [...e.product]
   };
-}, J = ({
-  slices: e,
-  projectName: t
+}, Xe = ({
+  slices: n,
+  projectName: e
 }) => {
-  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("");
+  const s = ge(), [c, l] = A($), [f, S] = A($), [d, o] = A(q), [y, h] = A(""), w = n.find((E) => E.sliceType === "entityList")?.rowSelection, i = L(
+    () => Object.keys(w ?? {}).filter((E) => w?.[E] && !E.startsWith("folder-")).sort(),
+    [w]
+  ), P = i.length && e ? `${e}|${i}` : "";
+  return M(() => {
+    if (!P) {
+      l($), S($), o(q), h("");
       return;
     }
-    let c = !1;
+    let E = !1;
     return (async () => {
       try {
-        const E = await Promise.all(
-          s.map(
-            (T) => r(
-              _.endpoints.getListEntities.initiate({ projectName: t, listId: T })
+        const x = await Promise.all(
+          i.map(
+            (I) => s(
+              Ie.endpoints.getListEntities.initiate({ projectName: e, listId: I })
             ).unwrap()
           )
-        ), v = b(E);
-        c || n(v);
-        const { parentMaps: w, ...L } = await C(
-          v,
+        ), t = ke(x);
+        E || S(t);
+        const { parentMaps: a, ...u } = await xe(
           t,
-          r
+          e,
+          s
         );
-        c || (o(L), a(w));
-      } catch (E) {
-        console.error("Error fetching entity list IDs:", E), c || (o(f), n(f), a(g));
+        E || (l(u), o(a));
+      } catch (x) {
+        console.error("Error fetching entity list IDs:", x), E || (l($), S($), o(q));
       } finally {
-        c || p(S);
+        E || h(P);
       }
     })(), () => {
-      c = !0;
+      E = !0;
     };
-  }, [S, s, t, r]), { entityIds: d, rawEntityIds: i, parentMaps: l, isLoading: S !== I };
-}, M = ({ slice: e, attribFields: t }) => {
-  const r = {
+  }, [P, i, e, s]), { entityIds: c, rawEntityIds: f, parentMaps: d, isLoading: P !== y };
+}, ve = ({ slice: n, attribFields: e }) => {
+  const s = {
     assignees: "list_of_strings",
     status: "string",
     taskType: "string",
@@ -149,68 +452,69 @@ const B = ({
     author: "string",
     hierarchy: void 0,
     entityList: void 0,
-    ...t.reduce((o, i) => (o["attrib." + i.name] = i.data.type, o), {})
+    ...e.reduce((l, f) => (l["attrib." + f.name] = f.data.type, l), {})
   };
   return (() => {
-    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
+    if (!n) return null;
+    const l = s[n?.sliceType], f = Object.entries(n.rowSelection).filter(([S, d]) => !!S && d).map(([S]) => ({
+      id: S,
+      label: S
     }));
     return {
-      id: e?.sliceType,
-      label: e?.sliceType,
-      type: o,
+      id: n?.sliceType,
+      label: n?.sliceType,
+      type: l,
       inverted: !1,
       operator: "OR",
-      values: i
+      values: f
     };
   })();
-}, 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)
+}, Te = ({
+  slices: n,
+  attribFields: e
+}) => n.filter((s) => s.sliceType !== "hierarchy" && s.sliceType !== "entityList").map((s) => ve({ slice: s, attribFields: e })).filter((s) => !!s), Je = (n) => {
+  const { slices: e, getPanelSelection: s } = Ee(), { powerLicense: c, isLoading: l } = z(), f = L(() => {
+    const d = e.map((o) => ({
+      sliceType: o.sliceType,
+      rowSelection: s(o.id)
     }));
-    return d ? l : l.slice(0, 1);
-  }, [t, r, d]), n = h(
-    () => O({ slices: i, attribFields: e }),
-    [i, e]
+    return c ? d : d.slice(0, 1);
+  }, [e, s, c]), S = L(
+    () => Te({ slices: f, attribFields: n }),
+    [f, n]
   );
   return {
-    sliceSelections: i,
-    sliceFilters: n,
-    isLicensePending: t.length > 1 && o
+    sliceSelections: f,
+    sliceFilters: S,
+    isLicensePending: e.length > 1 && l
   };
 };
 export {
-  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
+  Ve as SLICER_DEFAULT_PANEL_HEIGHT,
+  je as SLICER_MIN_PANEL_HEIGHT,
+  ft as SLICER_PAGES_CONFIG,
+  Ne as SLICER_SPLITTER_PANEL_CONFIG,
+  et as SLICER_SPLITTER_STATE_KEY,
+  tt as Slicer,
+  pe as SlicerContext,
+  Ue as SlicerProvider,
+  st as buildListFolderRowId,
+  nt as clampDraggedHeights,
+  ve as createFilterFromSlicer,
+  Te as createFiltersFromSlicer,
+  ot as defaultSliceOptions,
+  rt as resolvePanelLayout,
+  it as useEntityListsSlice,
+  ze as useFiltersWithHierarchy,
+  ct as useHierarchyContextMenuItems,
+  ht as useHierarchySelection,
+  St as useOptionalSlicerContext,
+  Xe as useSelectedEntityIds,
+  Ee as useSlicerContext,
+  lt as useSlicerCounts,
+  dt as useSlicerPanelHeights,
+  Je as useSlicerPanelSelections,
+  me as useSlicerRemotes,
+  Pe as useSlicerRowSelection,
+  at as useSlicerSplitter
 };