@ynput/ayon-frontend-shared 0.3.36 → 0.3.38

package/dist/shared/src/api/queries/overview/getOverview.es.js

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as L } from "../../generated/graphql.es.js";
+import { api as O } from "../../generated/graphql.es.js";
 import "../../generated/graphqlLinks.es.js";
 import "../../generated/access.es.js";
 import "../../generated/actions.es.js";
@@ -15,7 +15,7 @@ import "../../generated/desktop.es.js";
 import "../../generated/entityLists.es.js";
 import "../../generated/events.es.js";
 import "../../generated/files.es.js";
-import { api as O } from "../../generated/folders.es.js";
+import { api as H } from "../../generated/folders.es.js";
 import "../../generated/inbox.es.js";
 import "../../generated/links.es.js";
 import "../../generated/market.es.js";
@@ -42,16 +42,16 @@ import "lodash";
 import "react-toastify";
 import "uuid";
 import { subscribeToThumbnailUpdates as E } from "../../../util/thumbnailWebsocket.es.js";
-import S from "../../../util/pubsub.es.js";
-import { mergeFieldStats as C, normalizeFieldStats as N } from "../columnStats/columnStats.es.js";
-import { hasNewTargetFields as x } from "../columnStats/metricTargets.es.js";
-const H = (s) => {
+import F from "../../../util/pubsub.es.js";
+import { mergeFieldStats as N, normalizeFieldStats as x } from "../columnStats/columnStats.es.js";
+import { hasNewTargetFields as G } from "../columnStats/metricTargets.es.js";
+const q = (s) => {
   try {
     return JSON.parse(s);
   } catch {
     return {};
   }
-}, G = (s) => {
+}, L = (s) => {
   if (!s.project)
     return [];
   const e = [];
@@ -59,16 +59,16 @@ const H = (s) => {
     e.push({
       ...t,
       folderId: t.folderId || "root",
-      attrib: H(t.allAttrib),
+      attrib: q(t.allAttrib),
       entityId: t.id,
       entityType: "task",
       links: []
     });
   return e;
-}, F = (s = [], e, t) => {
-  const o = s?.map((f) => ({ type: "overviewTask", id: f.id })) || [], a = t ? (Array.isArray(t) ? t : [t]).map((f) => ({
+}, R = (s = [], e, t) => {
+  const o = s?.map((l) => ({ type: "overviewTask", id: l.id })) || [], a = t ? (Array.isArray(t) ? t : [t]).map((l) => ({
     type: "overviewTask",
-    id: f
+    id: l
   })) : [];
   return [
     ...o,
@@ -76,44 +76,44 @@ const H = (s) => {
     { type: "overviewTask", id: e },
     { type: "overviewTask", id: "LIST" }
   ];
-}, R = L.enhanceEndpoints({
+}, P = O.enhanceEndpoints({
   endpoints: {
     // This gets tasks for all parent folders provided
     // But in this case it will only ever receive one parent folder from the getOverviewTasksByFolders query
     // It is only used by getOverviewTasksByFolders in this file
     GetTasksByParent: {
-      transformResponse: G,
-      providesTags: (s, e, { parentIds: t, projectName: o }) => F(s, o, t)
+      transformResponse: L,
+      providesTags: (s, e, { parentIds: t, projectName: o }) => R(s, o, t)
     },
     GetTasksList: {
       transformResponse: (s) => ({
-        tasks: G(s),
+        tasks: L(s),
         pageInfo: s.project.tasks.pageInfo
       }),
-      providesTags: (s, e, { projectName: t }) => F(s?.tasks || [], t)
+      providesTags: (s, e, { projectName: t }) => R(s?.tasks || [], t)
     },
     // footer stats: `targets` excluded from cache key + responses merged,
     // so column toggles reuse cache and only added targets refetch
     GetFolderColumnStats: {
-      transformResponse: (s) => N(s?.project?.folders?.fieldStats ?? []),
+      transformResponse: (s) => x(s?.project?.folders?.fieldStats ?? []),
       serializeQueryArgs: ({ queryArgs: { targets: s, ...e } }) => e,
-      merge: (s, e) => C(e, s),
-      forceRefetch: ({ currentArg: s, previousArg: e }) => x(s, e),
+      merge: (s, e) => N(e, s),
+      forceRefetch: ({ currentArg: s, previousArg: e }) => G(s, e),
       providesTags: (s, e, { projectName: t }) => [{ type: "folderColumnStats", id: t }]
     },
     GetTaskColumnStats: {
-      transformResponse: (s) => N(s?.project?.tasks?.fieldStats ?? []),
+      transformResponse: (s) => x(s?.project?.tasks?.fieldStats ?? []),
       serializeQueryArgs: ({ queryArgs: { targets: s, ...e } }) => e,
-      merge: (s, e) => C(e, s),
-      forceRefetch: ({ currentArg: s, previousArg: e }) => x(s, e),
+      merge: (s, e) => N(e, s),
+      forceRefetch: ({ currentArg: s, previousArg: e }) => G(s, e),
       providesTags: (s, e, { projectName: t }) => [{ type: "taskColumnStats", id: t }]
     }
   }
-}), q = O.enhanceEndpoints({
+}), Q = H.enhanceEndpoints({
   endpoints: {
     searchFolders: {}
   }
-}), _ = 100, Q = R.injectEndpoints({
+}), S = 100, B = P.injectEndpoints({
   endpoints: (s) => ({
     // Each project has one cache for all the tasks of the expanded folders
     // Changing the expanded folders will trigger a refetch but not a new cache
@@ -121,31 +121,32 @@ const H = (s) => {
     // When new folders are expanded, the new tasks are fetched and we use the cache for the rest
     // This also solves the pagination issue of getting all tasks in one query, splitting it up in multiple queries to avoid pagination limits
     getOverviewTasksByFolders: s.query({
-      async queryFn({ projectName: e, parentIds: t, filter: o, folderFilter: a, search: f }, { dispatch: I, forced: h }) {
+      async queryFn({ projectName: e, parentIds: t, filter: o, folderFilter: a, search: l, showComments: I }, { dispatch: g, forced: w }) {
         try {
-          const k = [];
-          for (let n = 0; n < t.length; n += 20) {
-            const v = t.slice(n, n + 20), l = (await Promise.all(
-              v.map(
-                async (r) => I(
-                  R.endpoints.GetTasksByParent.initiate(
+          const y = [];
+          for (let u = 0; u < t.length; u += 20) {
+            const C = t.slice(u, u + 20), i = (await Promise.all(
+              C.map(
+                async (r) => g(
+                  P.endpoints.GetTasksByParent.initiate(
                     {
                       projectName: e,
                       parentIds: [r],
                       filter: o,
                       folderFilter: a,
-                      search: f
+                      search: l,
+                      showComments: !!I
                     },
-                    { forceRefetch: h }
+                    { forceRefetch: w }
                   )
                 )
               )
             )).filter((r) => !!r.data).flatMap((r) => r.data);
-            k.push(...l);
+            y.push(...i);
           }
-          return { data: k };
-        } catch (b) {
-          return console.error(b), { error: { status: "FETCH_ERROR", error: b.message } };
+          return { data: y };
+        } catch (v) {
+          return console.error(v), { error: { status: "FETCH_ERROR", error: v.message } };
         }
       },
       // keep one cache per project
@@ -156,67 +157,68 @@ const H = (s) => {
       forceRefetch({ currentArg: e, previousArg: t }) {
         return JSON.stringify(e) !== JSON.stringify(t);
       },
-      providesTags: (e, t, { parentIds: o, projectName: a }) => F(e, a, o),
-      async onCacheEntryAdded({ projectName: e, parentIds: t, filter: o, search: a }, { cacheDataLoaded: f, cacheEntryRemoved: I, updateCachedData: h, dispatch: b }) {
-        let k;
-        const n = /* @__PURE__ */ new Set(), v = 100, A = 500;
-        let l = !1;
+      providesTags: (e, t, { parentIds: o, projectName: a }) => R(e, a, o),
+      async onCacheEntryAdded({ projectName: e, parentIds: t, filter: o, search: a, showComments: l }, { cacheDataLoaded: I, cacheEntryRemoved: g, updateCachedData: w, dispatch: v }) {
+        let y;
+        const u = /* @__PURE__ */ new Set(), C = 100, b = 500;
+        let i = !1;
         const r = () => {
-          l || (l = !0, setTimeout(m, A));
-        }, m = async () => {
-          if (l = !1, !n.size) return;
-          const p = Array.from(n).slice(0, v);
-          p.forEach((i) => n.delete(i));
+          i || (i = !0, setTimeout(h, b));
+        }, h = async () => {
+          if (i = !1, !u.size) return;
+          const c = Array.from(u).slice(0, C);
+          c.forEach((n) => u.delete(n));
           try {
-            const c = (await b(
-              R.endpoints.GetTasksList.initiate(
+            const p = (await v(
+              P.endpoints.GetTasksList.initiate(
                 {
                   projectName: e,
-                  taskIds: p
+                  taskIds: c,
+                  showComments: !!l
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], u = new Map(c.map((d) => [d.id, d]));
-            h((d) => {
-              for (const y of c) {
-                const P = d.findIndex((T) => T.id === y.id);
-                P > -1 ? d[P] = y : d.push(y);
+            ).unwrap()).tasks || [], f = new Map(p.map((d) => [d.id, d]));
+            w((d) => {
+              for (const k of p) {
+                const A = d.findIndex((T) => T.id === k.id);
+                A > -1 ? d[A] = k : d.push(k);
               }
-              for (const y of p)
-                if (!u.has(y)) {
-                  const P = d.findIndex((T) => T.id === y);
-                  P > -1 && d.splice(P, 1);
+              for (const k of c)
+                if (!f.has(k)) {
+                  const A = d.findIndex((T) => T.id === k);
+                  A > -1 && d.splice(A, 1);
                 }
             });
-          } catch (i) {
-            console.error("Realtime overview batch update failed", i);
+          } catch (n) {
+            console.error("Realtime overview batch update failed", n);
           } finally {
-            n.size && r();
+            u.size && r();
           }
         };
-        let g;
+        let m;
         try {
-          await f, g = E(
-            (i) => {
-              h((c) => {
-                i.forEach((u) => {
-                  if (u.summary.entityType === "task" && u.summary.thumbnailHash) {
-                    const d = c.findIndex((y) => y.id === u.summary.entityId);
-                    d > -1 && (c[d].thumbnailHash = u.summary.thumbnailHash);
+          await I, m = E(
+            (n) => {
+              w((p) => {
+                n.forEach((f) => {
+                  if (f.summary.entityType === "task" && f.summary.thumbnailHash) {
+                    const d = p.findIndex((k) => k.id === f.summary.entityId);
+                    d > -1 && (p[d].thumbnailHash = f.summary.thumbnailHash);
                   }
                 });
               });
             },
             ["task"]
           );
-          const p = async (i, c) => {
-            const u = c?.summary?.entityId, d = c?.summary?.parentId;
-            !u || !d || t.includes(d) && (n.add(u), r());
+          const c = async (n, p) => {
+            const f = p?.summary?.entityId, d = p?.summary?.parentId;
+            !f || !d || t.includes(d) && (u.add(f), r());
           };
-          k = S.subscribe("entity.task", p);
+          y = F.subscribe("entity.task", c);
         } catch {
         }
-        await I, k && S.unsubscribe(k), g && g();
+        await g, y && F.unsubscribe(y), m && m();
       }
     }),
     // searchFolders is a post so it's a bit annoying to consume
@@ -225,7 +227,7 @@ const H = (s) => {
       async queryFn({ projectName: e, folderSearchRequest: t }, { dispatch: o }) {
         try {
           return { data: (await o(
-            q.endpoints.searchFolders.initiate({
+            Q.endpoints.searchFolders.initiate({
               projectName: e,
               folderSearchRequest: t
             })
@@ -242,30 +244,41 @@ const H = (s) => {
         initialPageParam: { cursor: "", desc: !1 },
         // Calculate the next page param based on current page response and params
         getNextPageParam: (e, t, o, a) => {
-          const f = e.pageInfo;
-          if (!(!(o.desc ? f.hasPreviousPage : f.hasNextPage) || !f.endCursor))
+          const l = e.pageInfo;
+          if (!(!(o.desc ? l.hasPreviousPage : l.hasNextPage) || !l.endCursor))
             return {
-              cursor: f.endCursor,
+              cursor: l.endCursor,
               desc: o.desc
             };
         }
       },
       queryFn: async ({ queryArg: e, pageParam: t }, o) => {
         try {
-          const { projectName: a, filter: f, folderFilter: I, search: h, folderIds: b, taskIds: k, sortBy: n, desc: v } = e, { cursor: A } = t, l = {
+          const {
             projectName: a,
-            filter: f,
+            filter: l,
             folderFilter: I,
-            search: h,
-            folderIds: b,
-            taskIds: k
+            search: g,
+            folderIds: w,
+            taskIds: v,
+            sortBy: y,
+            desc: u,
+            showComments: C
+          } = e, { cursor: b } = t, i = {
+            projectName: a,
+            filter: l,
+            folderFilter: I,
+            search: g,
+            folderIds: w,
+            taskIds: v,
+            showComments: !!C
           };
-          n ? (l.sortBy = n, v ? (l.before = A || void 0, l.last = _) : (l.after = A || void 0, l.first = _)) : (l.after = A || void 0, l.first = _);
+          y ? (i.sortBy = y, u ? (i.before = b || void 0, i.last = S) : (i.after = b || void 0, i.first = S)) : (i.after = b || void 0, i.first = S);
           const r = await o.dispatch(
-            R.endpoints.GetTasksList.initiate(l, { forceRefetch: !0 })
+            P.endpoints.GetTasksList.initiate(i, { forceRefetch: !0 })
           );
           if (r.error) throw r.error;
-          const m = {
+          const h = {
             tasks: [],
             pageInfo: {
               hasNextPage: !1,
@@ -275,46 +288,47 @@ const H = (s) => {
             }
           };
           return {
-            data: r.data || m
+            data: r.data || h
           };
         } catch (a) {
           return console.error("Error in getTasksListInfinite queryFn:", a), { error: { status: "FETCH_ERROR", error: a.message } };
         }
       },
-      providesTags: (e, t, { projectName: o }) => F(e?.pages.flatMap((a) => a.tasks) || [], o),
-      async onCacheEntryAdded(e, { cacheDataLoaded: t, cacheEntryRemoved: o, updateCachedData: a, dispatch: f }) {
+      providesTags: (e, t, { projectName: o }) => R(e?.pages.flatMap((a) => a.tasks) || [], o),
+      async onCacheEntryAdded(e, { cacheDataLoaded: t, cacheEntryRemoved: o, updateCachedData: a, dispatch: l }) {
         let I;
-        const h = /* @__PURE__ */ new Set(), b = 100, k = 500;
-        let n = !1;
-        const v = () => {
-          n || (n = !0, setTimeout(A, k));
-        }, A = async () => {
-          if (n = !1, !h.size) return;
-          const r = Array.from(h).slice(0, b);
-          r.forEach((m) => h.delete(m));
+        const g = /* @__PURE__ */ new Set(), w = 100, v = 500;
+        let y = !1;
+        const u = () => {
+          y || (y = !0, setTimeout(C, v));
+        }, C = async () => {
+          if (y = !1, !g.size) return;
+          const i = Array.from(g).slice(0, w);
+          i.forEach((r) => g.delete(r));
           try {
-            const g = (await f(
-              R.endpoints.GetTasksList.initiate(
+            const h = (await l(
+              P.endpoints.GetTasksList.initiate(
                 {
                   projectName: e.projectName,
-                  taskIds: r,
-                  folderIds: e.folderIds
+                  taskIds: i,
+                  folderIds: e.folderIds,
+                  showComments: !!e.showComments
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], p = new Map(g.map((i) => [i.id, i]));
-            a((i) => {
-              for (const c of g) {
-                let u = !1;
-                for (const d of i.pages) {
-                  const y = d.tasks.findIndex((P) => P.id === c.id);
-                  if (y !== -1) {
-                    d.tasks[y] = c, u = !0;
+            ).unwrap()).tasks || [], m = new Map(h.map((c) => [c.id, c]));
+            a((c) => {
+              for (const n of h) {
+                let p = !1;
+                for (const f of c.pages) {
+                  const d = f.tasks.findIndex((k) => k.id === n.id);
+                  if (d !== -1) {
+                    f.tasks[d] = n, p = !0;
                     break;
                   }
                 }
-                u || (i.pages.length ? i.pages[0].tasks.unshift(c) : i.pages.push({
-                  tasks: [c],
+                p || (c.pages.length ? c.pages[0].tasks.unshift(n) : c.pages.push({
+                  tasks: [n],
                   pageInfo: {
                     startCursor: null,
                     endCursor: null,
@@ -323,33 +337,33 @@ const H = (s) => {
                   }
                 }));
               }
-              for (const c of r)
-                if (!p.has(c))
-                  for (const u of i.pages) {
-                    const d = u.tasks.findIndex((y) => y.id === c);
-                    if (d !== -1) {
-                      u.tasks.splice(d, 1);
+              for (const n of i)
+                if (!m.has(n))
+                  for (const p of c.pages) {
+                    const f = p.tasks.findIndex((d) => d.id === n);
+                    if (f !== -1) {
+                      p.tasks.splice(f, 1);
                       break;
                     }
                   }
             });
-          } catch (m) {
-            console.error("Realtime infinite tasks batch update failed", m);
+          } catch (r) {
+            console.error("Realtime infinite tasks batch update failed", r);
           } finally {
-            h.size && v();
+            g.size && u();
           }
         };
-        let l;
+        let b;
         try {
-          await t, l = E(
-            (m) => {
-              a((g) => {
-                m.forEach((p) => {
-                  if (p.summary.entityType === "task" && p.summary.thumbnailHash)
-                    for (const i of g.pages) {
-                      const c = i.tasks.findIndex((u) => u.id === p.summary.entityId);
-                      if (c > -1) {
-                        i.tasks[c].thumbnailHash = p.summary.thumbnailHash;
+          await t, b = E(
+            (r) => {
+              a((h) => {
+                r.forEach((m) => {
+                  if (m.summary.entityType === "task" && m.summary.thumbnailHash)
+                    for (const c of h.pages) {
+                      const n = c.tasks.findIndex((p) => p.id === m.summary.entityId);
+                      if (n > -1) {
+                        c.tasks[n].thumbnailHash = m.summary.thumbnailHash;
                         break;
                       }
                     }
@@ -358,100 +372,111 @@ const H = (s) => {
             },
             ["task"]
           );
-          const r = async (m, g) => {
-            const p = g?.summary?.entityId;
-            p && (h.add(p), v());
+          const i = async (r, h) => {
+            const m = h?.summary?.entityId;
+            m && (g.add(m), u());
           };
-          I = S.subscribe("entity.task", r);
+          I = F.subscribe("entity.task", i);
         } catch {
         }
-        await o, I && S.unsubscribe(I), l && l();
+        await o, I && F.unsubscribe(I), b && b();
       }
     }),
     getGroupedTasksList: s.query({
-      queryFn: async ({ projectName: e, groups: t, search: o, folderFilter: a, folderIds: f, desc: I, sortBy: h, groupCount: b }, k) => {
+      queryFn: async ({
+        projectName: e,
+        groups: t,
+        search: o,
+        folderFilter: a,
+        folderIds: l,
+        desc: I,
+        sortBy: g,
+        groupCount: w,
+        showComments: v
+      }, y) => {
         try {
-          let n = [];
-          const v = /* @__PURE__ */ new Set(["folderType"]);
+          let u = [];
+          const C = /* @__PURE__ */ new Set(["folderType"]);
           for (const r of t) {
-            const m = b || r.count || 500;
-            let g = r.filter, p = a;
+            const h = w || r.count || 500;
+            let m = r.filter, c = a;
             if (r.filter)
               try {
-                const u = JSON.parse(r.filter), d = u.conditions || [], y = d.filter((T) => !v.has(T.key)), P = d.filter((T) => v.has(T.key));
-                if (P.length > 0) {
-                  g = y.length ? JSON.stringify({ ...u, conditions: y }) : void 0;
-                  const T = a ? JSON.parse(a) : null, w = [...T && Array.isArray(T.conditions) ? T.conditions : [], ...P];
-                  p = JSON.stringify(
-                    T ? { ...T, conditions: w } : { conditions: w }
+                const f = JSON.parse(r.filter), d = f.conditions || [], k = d.filter((T) => !C.has(T.key)), A = d.filter((T) => C.has(T.key));
+                if (A.length > 0) {
+                  m = k.length ? JSON.stringify({ ...f, conditions: k }) : void 0;
+                  const T = a ? JSON.parse(a) : null, _ = [...T && Array.isArray(T.conditions) ? T.conditions : [], ...A];
+                  c = JSON.stringify(
+                    T ? { ...T, conditions: _ } : { conditions: _ }
                   );
                 }
               } catch {
               }
-            const i = {
+            const n = {
               projectName: e,
-              filter: g,
-              folderFilter: p,
+              filter: m,
+              folderFilter: c,
               search: o,
-              folderIds: f,
-              sortBy: h,
+              folderIds: l,
+              sortBy: g,
+              showComments: !!v,
               // @ts-expect-error - we know group does not exist on query variables but we need it for later
               group: r.value
             };
-            I ? i.last = m : i.first = m;
-            const c = k.dispatch(
-              R.endpoints.GetTasksList.initiate(i, { forceRefetch: !0 })
+            I ? n.last = h : n.first = h;
+            const p = y.dispatch(
+              P.endpoints.GetTasksList.initiate(n, { forceRefetch: !0 })
             );
-            n.push(c);
+            u.push(p);
           }
-          const A = await Promise.all(n), l = [];
-          for (const r of A) {
+          const b = await Promise.all(u), i = [];
+          for (const r of b) {
             if (r.error) throw r.error;
-            const m = r.originalArgs?.group, g = r.data?.pageInfo?.hasNextPage || r.data?.pageInfo?.hasPreviousPage || !1, p = r.data?.tasks.map((i, c, u) => ({
-              ...i,
+            const h = r.originalArgs?.group, m = r.data?.pageInfo?.hasNextPage || r.data?.pageInfo?.hasPreviousPage || !1, c = r.data?.tasks.map((n, p, f) => ({
+              ...n,
               groups: [
                 {
-                  value: m,
-                  hasNextPage: c === u.length - 1 && g ? m : void 0
+                  value: h,
+                  hasNextPage: p === f.length - 1 && m ? h : void 0
                   // Only add hasNextPage to the last task in the group
                 }
               ]
             })) || [];
-            l.push(...p);
+            i.push(...c);
           }
           return {
             data: {
-              tasks: l
+              tasks: i
             }
           };
-        } catch (n) {
-          return console.error("Error in getGroupedTasksList queryFn:", n), { error: { status: "FETCH_ERROR", error: n.message } };
+        } catch (u) {
+          return console.error("Error in getGroupedTasksList queryFn:", u), { error: { status: "FETCH_ERROR", error: u.message } };
         }
       },
-      providesTags: (e, t, { projectName: o }) => F(e?.tasks, o)
+      providesTags: (e, t, { projectName: o }) => R(e?.tasks, o)
     })
   })
 }), {
-  useGetOverviewTasksByFoldersQuery: Ge,
-  useGetSearchFoldersQuery: Le,
-  useGetTasksListQuery: Oe,
-  useGetTasksListInfiniteInfiniteQuery: He,
-  useLazyGetTasksByParentQuery: qe,
-  useGetGroupedTasksListQuery: Qe,
-  useGetFolderColumnStatsQuery: Be,
-  useGetTaskColumnStatsQuery: je
-} = Q;
+  useGetOverviewTasksByFoldersQuery: Le,
+  useGetSearchFoldersQuery: Oe,
+  useGetTasksListQuery: He,
+  useGetTasksListInfiniteInfiniteQuery: qe,
+  useLazyGetTasksByParentQuery: Qe,
+  useGetGroupedTasksListQuery: Be,
+  useGetFolderColumnStatsQuery: je,
+  useGetTaskColumnStatsQuery: ze
+} = B;
 export {
-  _ as TASKS_INFINITE_QUERY_COUNT,
-  Q as default,
-  H as parseAllAttribs,
-  Be as useGetFolderColumnStatsQuery,
-  Qe as useGetGroupedTasksListQuery,
-  Ge as useGetOverviewTasksByFoldersQuery,
-  Le as useGetSearchFoldersQuery,
-  je as useGetTaskColumnStatsQuery,
-  He as useGetTasksListInfiniteInfiniteQuery,
-  Oe as useGetTasksListQuery,
-  qe as useLazyGetTasksByParentQuery
+  S as TASKS_INFINITE_QUERY_COUNT,
+  B as default,
+  q as parseAllAttribs,
+  je as useGetFolderColumnStatsQuery,
+  Be as useGetGroupedTasksListQuery,
+  Le as useGetOverviewTasksByFoldersQuery,
+  Oe as useGetSearchFoldersQuery,
+  ze as useGetTaskColumnStatsQuery,
+  qe as useGetTasksListInfiniteInfiniteQuery,
+  He as useGetTasksListQuery,
+  Qe as useLazyGetTasksByParentQuery
 };
 //# sourceMappingURL=getOverview.es.js.map