@ynput/ayon-frontend-shared 0.3.46 → 0.3.48

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

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as U } from "../../generated/graphql.es.js";
+import { api as X } 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 X } from "../../generated/folders.es.js";
+import { api as $ } from "../../generated/folders.es.js";
 import "../../generated/inbox.es.js";
 import "../../generated/links.es.js";
 import "../../generated/market.es.js";
@@ -38,11 +38,11 @@ import "../../generated/workfiles.es.js";
 import "../../generated/ynputCloud.es.js";
 import "../../generated/grouping.es.js";
 import "../../generated/views.es.js";
-import _ from "../../../util/pubsub.es.js";
+import x from "../../../util/pubsub.es.js";
 import "lodash";
 import "react-toastify";
 import "uuid";
-import { subscribeToThumbnailUpdates as Q } from "../../../util/thumbnailWebsocket.es.js";
+import { subscribeToThumbnailUpdates as H } from "../../../util/thumbnailWebsocket.es.js";
 import "../actions/getActions.es.js";
 import "../activities/getActivities.es.js";
 import "../activities/updateReaction.es.js";
@@ -56,8 +56,8 @@ import "../authentication/getAuthentication.es.js";
 import "../bundles/getBundles.es.js";
 import "../bundles/updateBundles.es.js";
 import "../cloud/cloud.es.js";
-import { mergeFieldStats as q, transformStatsError as H, normalizeFieldStats as B } from "../columnStats/columnStats.es.js";
-import { hasNewTargetFields as M } from "../columnStats/metricTargets.es.js";
+import { mergeFieldStats as M, transformStatsError as B, normalizeFieldStats as U } from "../columnStats/columnStats.es.js";
+import { hasNewTargetFields as j } from "../columnStats/metricTargets.es.js";
 import "../columnStats/groupCounts.es.js";
 import "../config/getConfig.es.js";
 import "../config/updateConfig.es.js";
@@ -100,222 +100,227 @@ import "../views/getViews.es.js";
 import "../views/updateViews.es.js";
 import "../watchers/getWatchers.es.js";
 import "../uris/getUris.es.js";
-const $ = (e) => {
+const P = 10, V = (t) => {
   try {
-    return JSON.parse(e);
+    return JSON.parse(t);
   } catch {
     return {};
   }
-}, j = (e) => {
-  if (!e.project)
+}, z = (t) => {
+  if (!t.project)
     return [];
-  const t = [];
-  for (const { node: s } of e.project.tasks.edges)
-    t.push({
+  const e = [];
+  for (const { node: s } of t.project.tasks.edges)
+    e.push({
       ...s,
       folderId: s.folderId || "root",
-      attrib: $(s.allAttrib),
+      attrib: V(s.allAttrib),
       entityId: s.id,
       entityType: "task",
       links: []
     });
-  return t;
-}, R = (e = [], t, s) => {
-  const o = e?.map((n) => ({ type: "overviewTask", id: n.id })) || [], i = s ? (Array.isArray(s) ? s : [s]).map((n) => ({
+  return e;
+}, S = (t = [], e, s) => {
+  const o = t?.map((d) => ({ type: "overviewTask", id: d.id })) || [], i = s ? (Array.isArray(s) ? s : [s]).map((d) => ({
     type: "overviewTask",
-    id: n
+    id: d
   })) : [];
   return [
     ...o,
     ...i,
-    { type: "overviewTask", id: t },
+    { type: "overviewTask", id: e },
     { type: "overviewTask", id: "LIST" }
   ];
-}, C = U.enhanceEndpoints({
+}, R = X.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: (e) => ({
-        pageInfo: e?.project?.tasks?.pageInfo ?? { hasNextPage: !1, endCursor: null },
-        tasks: j(e)
+      transformResponse: (t) => ({
+        pageInfo: t?.project?.tasks?.pageInfo ?? { hasNextPage: !1, endCursor: null },
+        tasks: z(t)
       }),
-      providesTags: (e, t, { parentIds: s, projectName: o }) => R(e?.tasks || [], o, s)
+      providesTags: (t, e, { parentIds: s, projectName: o }) => S(t?.tasks || [], o, s),
+      keepUnusedDataFor: P
     },
     GetTasksList: {
-      transformResponse: (e) => ({
-        tasks: j(e),
-        pageInfo: e.project.tasks.pageInfo
+      transformResponse: (t) => ({
+        tasks: z(t),
+        pageInfo: t.project.tasks.pageInfo
       }),
-      providesTags: (e, t, { projectName: s }) => R(e?.tasks || [], s)
+      providesTags: (t, e, { projectName: s }) => S(t?.tasks || [], s),
+      keepUnusedDataFor: P
     },
     // footer stats: `targets` excluded from cache key + responses merged,
     // so column toggles reuse cache and only added targets refetch
     GetFolderColumnStats: {
-      transformResponse: (e) => B(e?.project?.folders?.fieldStats ?? []),
-      transformErrorResponse: (e) => H(e, "folder"),
-      serializeQueryArgs: ({ queryArgs: { targets: e, ...t } }) => t,
-      merge: (e, t) => q(t, e),
-      forceRefetch: ({ currentArg: e, previousArg: t }) => M(e, t),
-      providesTags: (e, t, { projectName: s }) => [{ type: "folderColumnStats", id: s }]
+      transformResponse: (t) => U(t?.project?.folders?.fieldStats ?? []),
+      transformErrorResponse: (t) => B(t, "folder"),
+      serializeQueryArgs: ({ queryArgs: { targets: t, ...e } }) => e,
+      merge: (t, e) => M(e, t),
+      forceRefetch: ({ currentArg: t, previousArg: e }) => j(t, e),
+      providesTags: (t, e, { projectName: s }) => [{ type: "folderColumnStats", id: s }],
+      keepUnusedDataFor: P
     },
     GetTaskColumnStats: {
-      transformResponse: (e) => B(e?.project?.tasks?.fieldStats ?? []),
-      transformErrorResponse: (e) => H(e, "task"),
-      serializeQueryArgs: ({ queryArgs: { targets: e, ...t } }) => t,
-      merge: (e, t) => q(t, e),
-      forceRefetch: ({ currentArg: e, previousArg: t }) => M(e, t),
-      providesTags: (e, t, { projectName: s }) => [{ type: "taskColumnStats", id: s }]
+      transformResponse: (t) => U(t?.project?.tasks?.fieldStats ?? []),
+      transformErrorResponse: (t) => B(t, "task"),
+      serializeQueryArgs: ({ queryArgs: { targets: t, ...e } }) => e,
+      merge: (t, e) => M(e, t),
+      forceRefetch: ({ currentArg: t, previousArg: e }) => j(t, e),
+      providesTags: (t, e, { projectName: s }) => [{ type: "taskColumnStats", id: s }],
+      keepUnusedDataFor: P
     }
   }
-}), V = X.enhanceEndpoints({
+}), Y = $.enhanceEndpoints({
   endpoints: {
     searchFolders: {}
   }
-}), G = 100, S = {}, z = (e, t, s, o, i) => JSON.stringify({ projectName: e, filter: t, folderFilter: s, search: o, showComments: i }), D = (e, t) => {
-  S[e] || (S[e] = /* @__PURE__ */ new Set()), t.forEach((s) => S[e].add(s));
-}, Y = (e) => S[e] || /* @__PURE__ */ new Set(), J = C.injectEndpoints({
-  endpoints: (e) => ({
+}), O = 100, _ = {}, D = (t, e, s, o, i) => JSON.stringify({ projectName: t, filter: e, folderFilter: s, search: o, showComments: i }), Z = (t, e) => {
+  _[t] || (_[t] = /* @__PURE__ */ new Set()), e.forEach((s) => _[t].add(s));
+}, W = (t) => _[t] || /* @__PURE__ */ new Set(), J = R.injectEndpoints({
+  endpoints: (t) => ({
     // 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
     // Each expanded folder has it's own query that is looped over here
     // 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: e.query({
-      async queryFn({ projectName: t, parentIds: s, filter: o, folderFilter: i, search: n, showComments: k }, { dispatch: E, getState: F }) {
+    getOverviewTasksByFolders: t.query({
+      async queryFn({ projectName: e, parentIds: s, filter: o, folderFilter: i, search: d, showComments: I }, { dispatch: F, getState: v, forced: A }) {
         try {
-          const T = F(), v = { projectName: t, filter: o, folderFilter: i, search: n, showComments: k }, w = J.endpoints.getOverviewTasksByFolders.select(
-            v
-          )(T)?.data || [], A = z(t, o, i, n, k), y = Y(A), r = s.filter((a) => !y.has(a));
-          if (r.length === 0)
-            return { data: w };
-          const c = [], d = 100, p = 20, u = 10, m = 1e3, l = d * p;
-          if (r.length > m)
+          const g = v(), k = { projectName: e, filter: o, folderFilter: i, search: d, showComments: I }, E = J.endpoints.getOverviewTasksByFolders.select(
+            k
+          )(g)?.data || [], y = D(e, o, i, d, I), r = W(y), n = A ? s : s.filter((a) => !r.has(a));
+          if (n.length === 0)
+            return { data: E };
+          const u = [], c = 100, l = 20, p = 10, m = 1e3, f = c * l;
+          if (n.length > m)
             throw new Error(
-              `Exceeded maximum folders count limit ${m} (${r.length}). Please reduce the number of expanded folders.`
+              `Exceeded maximum folders count limit ${m} (${n.length}). Please reduce the number of expanded folders.`
             );
-          for (let a = 0; a < r.length; a += d) {
-            const f = r.slice(a, a + d);
-            let b = !0, P, x = 0;
-            for (; b && x < u; ) {
-              if (x++, x === u)
+          for (let a = 0; a < n.length; a += c) {
+            const b = n.slice(a, a + c);
+            let C = !0, L, N = 0;
+            for (; C && N < p; ) {
+              if (N++, N === p)
                 throw new Error(
-                  `Exceeded maximum tasks count limit ${u * l}.`
+                  `Exceeded maximum tasks count limit ${p * f}.`
                 );
-              const N = await E(
-                C.endpoints.GetTasksByParent.initiate(
+              const G = await F(
+                R.endpoints.GetTasksByParent.initiate(
                   {
-                    projectName: t,
-                    parentIds: f,
+                    projectName: e,
+                    parentIds: b,
                     filter: o,
                     folderFilter: i,
-                    search: n,
-                    showComments: !!k,
-                    first: l,
-                    after: P
+                    search: d,
+                    showComments: !!I,
+                    first: f,
+                    after: L
                   },
                   { forceRefetch: !0 }
                 )
               );
-              if (N.error) throw N.error;
-              const O = N.data, K = O?.tasks || [];
-              c.push(...K);
-              const L = O?.pageInfo;
-              b = L?.hasNextPage || !1, P = L?.endCursor || void 0;
+              if (G.error) throw G.error;
+              const Q = G.data, K = Q?.tasks || [];
+              u.push(...K);
+              const q = Q?.pageInfo;
+              C = q?.hasNextPage || !1, L = q?.endCursor || void 0;
             }
           }
-          D(A, r);
-          const h = [...w, ...c], g = new Map(h.map((a) => [a.id, a]));
+          Z(y, n);
+          const T = [...E, ...u], h = new Map(T.map((a) => [a.id, a]));
           return {
-            data: Array.from(g.values())
+            data: Array.from(h.values())
           };
-        } catch (T) {
-          return console.error(T), { error: { status: "FETCH_ERROR", error: T.message || T.data?.message || JSON.stringify(T) || "Unknown Fetch Error" } };
+        } catch (g) {
+          return console.error(g), { error: { status: "FETCH_ERROR", error: g.message || g.data?.message || JSON.stringify(g) || "Unknown Fetch Error" } };
         }
       },
       // keep one cache per project
-      serializeQueryArgs: ({ queryArgs: { parentIds: t, ...s } }) => ({
+      serializeQueryArgs: ({ queryArgs: { parentIds: e, ...s } }) => ({
         ...s
       }),
       // Refetch when the page arg changes
-      forceRefetch({ currentArg: t, previousArg: s }) {
-        return JSON.stringify(t) !== JSON.stringify(s);
+      forceRefetch({ currentArg: e, previousArg: s }) {
+        return JSON.stringify(e) !== JSON.stringify(s);
       },
-      providesTags: (t, s, { parentIds: o, projectName: i }) => R(t, i, o),
-      async onCacheEntryAdded({ projectName: t, parentIds: s, filter: o, folderFilter: i, search: n, showComments: k }, { cacheDataLoaded: E, cacheEntryRemoved: F, updateCachedData: T, dispatch: v }) {
-        let I;
-        const w = /* @__PURE__ */ new Set(), A = 100, y = 500;
+      providesTags: (e, s, { parentIds: o, projectName: i }) => S(e, i, o),
+      async onCacheEntryAdded({ projectName: e, parentIds: s, filter: o, folderFilter: i, search: d, showComments: I }, { cacheDataLoaded: F, cacheEntryRemoved: v, updateCachedData: A, dispatch: g }) {
+        let k;
+        const w = /* @__PURE__ */ new Set(), E = 100, y = 500;
         let r = !1;
-        const c = () => {
-          r || (r = !0, setTimeout(d, y));
-        }, d = async () => {
+        const n = () => {
+          r || (r = !0, setTimeout(u, y));
+        }, u = async () => {
           if (r = !1, !w.size) return;
-          const m = Array.from(w).slice(0, A);
-          m.forEach((l) => w.delete(l));
+          const p = Array.from(w).slice(0, E);
+          p.forEach((m) => w.delete(m));
           try {
-            const h = (await v(
-              C.endpoints.GetTasksList.initiate(
+            const f = (await g(
+              R.endpoints.GetTasksList.initiate(
                 {
-                  projectName: t,
-                  taskIds: m,
-                  showComments: !!k
+                  projectName: e,
+                  taskIds: p,
+                  showComments: !!I
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], g = new Map(h.map((a) => [a.id, a]));
-            T((a) => {
-              for (const f of h) {
-                const b = a.findIndex((P) => P.id === f.id);
-                b > -1 ? a[b] = f : a.push(f);
+            ).unwrap()).tasks || [], T = new Map(f.map((h) => [h.id, h]));
+            A((h) => {
+              for (const a of f) {
+                const b = h.findIndex((C) => C.id === a.id);
+                b > -1 ? h[b] = a : h.push(a);
               }
-              for (const f of m)
-                if (!g.has(f)) {
-                  const b = a.findIndex((P) => P.id === f);
-                  b > -1 && a.splice(b, 1);
+              for (const a of p)
+                if (!T.has(a)) {
+                  const b = h.findIndex((C) => C.id === a);
+                  b > -1 && h.splice(b, 1);
                 }
             });
-          } catch (l) {
-            console.error("Realtime overview batch update failed", l);
+          } catch (m) {
+            console.error("Realtime overview batch update failed", m);
           } finally {
-            w.size && c();
+            w.size && n();
           }
         };
-        let p;
+        let c;
         try {
-          await E, p = Q(
-            (l) => {
-              T((h) => {
-                l.forEach((g) => {
-                  if (g.summary.entityType === "task" && g.summary.thumbnailHash) {
-                    const a = h.findIndex((f) => f.id === g.summary.entityId);
-                    a > -1 && (h[a].thumbnailHash = g.summary.thumbnailHash);
+          await F, c = H(
+            (m) => {
+              A((f) => {
+                m.forEach((T) => {
+                  if (T.summary.entityType === "task" && T.summary.thumbnailHash) {
+                    const h = f.findIndex((a) => a.id === T.summary.entityId);
+                    h > -1 && (f[h].thumbnailHash = T.summary.thumbnailHash);
                   }
                 });
               });
             },
             ["task"]
           );
-          const m = async (l, h) => {
-            const g = h?.summary?.entityId, a = h?.summary?.parentId;
-            !g || !a || s.includes(a) && (w.add(g), c());
+          const p = async (m, f) => {
+            const T = f?.summary?.entityId, h = f?.summary?.parentId;
+            !T || !h || s.includes(h) && (w.add(T), n());
           };
-          I = _.subscribe("entity.task", m);
+          k = x.subscribe("entity.task", p);
         } catch {
         }
-        await F;
-        const u = z(t, o, i, n, k);
-        delete S[u], I && _.unsubscribe(I), p && p();
-      }
+        await v;
+        const l = D(e, o, i, d, I);
+        delete _[l], k && x.unsubscribe(k), c && c();
+      },
+      keepUnusedDataFor: P
     }),
     // searchFolders is a post so it's a bit annoying to consume
     // we wrap it in a queryFn to make it easier to consume as a query hook
-    getSearchFolders: e.query({
-      async queryFn({ projectName: t, folderSearchRequest: s }, { dispatch: o }) {
+    getSearchFolders: t.query({
+      async queryFn({ projectName: e, folderSearchRequest: s }, { dispatch: o }) {
         try {
           return { data: (await o(
-            V.endpoints.searchFolders.initiate({
-              projectName: t,
+            Y.endpoints.searchFolders.initiate({
+              projectName: e,
               folderSearchRequest: s
             })
           )).data?.folderIds || [] };
@@ -323,52 +328,53 @@ const $ = (e) => {
           return console.error(i), { error: { status: "FETCH_ERROR", error: i.message } };
         }
       },
-      providesTags: (t, s, { projectName: o }) => [{ type: "tasksFolder", id: o }]
+      providesTags: (e, s, { projectName: o }) => [{ type: "tasksFolder", id: o }],
+      keepUnusedDataFor: P
     }),
     // Add new infinite query endpoint for tasks list
-    getTasksListInfinite: e.infiniteQuery({
+    getTasksListInfinite: t.infiniteQuery({
       infiniteQueryOptions: {
         initialPageParam: { cursor: "", desc: !1 },
         // Calculate the next page param based on current page response and params
-        getNextPageParam: (t, s, o, i) => {
-          const n = t.pageInfo;
-          if (!(!(o.desc ? n.hasPreviousPage : n.hasNextPage) || !n.endCursor))
+        getNextPageParam: (e, s, o, i) => {
+          const d = e.pageInfo;
+          if (!(!(o.desc ? d.hasPreviousPage : d.hasNextPage) || !d.endCursor))
             return {
-              cursor: n.endCursor,
+              cursor: d.endCursor,
               desc: o.desc
             };
         }
       },
-      queryFn: async ({ queryArg: t, pageParam: s }, o) => {
+      queryFn: async ({ queryArg: e, pageParam: s }, o) => {
         try {
           const {
             projectName: i,
-            filter: n,
-            folderFilter: k,
-            search: E,
-            folderIds: F,
-            taskIds: T,
-            sortBy: v,
-            desc: I,
+            filter: d,
+            folderFilter: I,
+            search: F,
+            folderIds: v,
+            taskIds: A,
+            sortBy: g,
+            desc: k,
             showComments: w,
-            includeFolderChildren: A
-          } = t, { cursor: y } = s, r = {
+            includeFolderChildren: E
+          } = e, { cursor: y } = s, r = {
             projectName: i,
-            filter: n,
-            folderFilter: k,
-            search: E,
-            folderIds: F,
-            taskIds: T,
+            filter: d,
+            folderFilter: I,
+            search: F,
+            folderIds: v,
+            taskIds: A,
             showComments: !!w,
-            includeFolderChildren: A !== !1
+            includeFolderChildren: E !== !1
             // default to true
           };
-          v ? (r.sortBy = v, I ? (r.before = y || void 0, r.last = G) : (r.after = y || void 0, r.first = G)) : (r.after = y || void 0, r.first = G);
-          const c = await o.dispatch(
-            C.endpoints.GetTasksList.initiate(r, { forceRefetch: !0 })
+          g ? (r.sortBy = g, k ? (r.before = y || void 0, r.last = O) : (r.after = y || void 0, r.first = O)) : (r.after = y || void 0, r.first = O);
+          const n = await o.dispatch(
+            R.endpoints.GetTasksList.initiate(r, { forceRefetch: !0 })
           );
-          if (c.error) throw c.error;
-          const d = {
+          if (n.error) throw n.error;
+          const u = {
             tasks: [],
             pageInfo: {
               hasNextPage: !1,
@@ -378,47 +384,47 @@ const $ = (e) => {
             }
           };
           return {
-            data: c.data || d
+            data: n.data || u
           };
         } catch (i) {
           return console.error("Error in getTasksListInfinite queryFn:", i), { error: { status: "FETCH_ERROR", error: i.message } };
         }
       },
-      providesTags: (t, s, { projectName: o }) => R(t?.pages.flatMap((i) => i.tasks) || [], o),
-      async onCacheEntryAdded(t, { cacheDataLoaded: s, cacheEntryRemoved: o, updateCachedData: i, dispatch: n }) {
-        let k;
-        const E = /* @__PURE__ */ new Set(), F = 100, T = 500;
-        let v = !1;
-        const I = () => {
-          v || (v = !0, setTimeout(w, T));
+      providesTags: (e, s, { projectName: o }) => S(e?.pages.flatMap((i) => i.tasks) || [], o),
+      async onCacheEntryAdded(e, { cacheDataLoaded: s, cacheEntryRemoved: o, updateCachedData: i, dispatch: d }) {
+        let I;
+        const F = /* @__PURE__ */ new Set(), v = 100, A = 500;
+        let g = !1;
+        const k = () => {
+          g || (g = !0, setTimeout(w, A));
         }, w = async () => {
-          if (v = !1, !E.size) return;
-          const y = Array.from(E).slice(0, F);
-          y.forEach((r) => E.delete(r));
+          if (g = !1, !F.size) return;
+          const y = Array.from(F).slice(0, v);
+          y.forEach((r) => F.delete(r));
           try {
-            const c = (await n(
-              C.endpoints.GetTasksList.initiate(
+            const n = (await d(
+              R.endpoints.GetTasksList.initiate(
                 {
-                  projectName: t.projectName,
+                  projectName: e.projectName,
                   taskIds: y,
-                  folderIds: t.folderIds,
-                  showComments: !!t.showComments
+                  folderIds: e.folderIds,
+                  showComments: !!e.showComments
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], d = new Map(c.map((p) => [p.id, p]));
-            i((p) => {
-              for (const u of c) {
-                let m = !1;
-                for (const l of p.pages) {
-                  const h = l.tasks.findIndex((g) => g.id === u.id);
-                  if (h !== -1) {
-                    l.tasks[h] = u, m = !0;
+            ).unwrap()).tasks || [], u = new Map(n.map((c) => [c.id, c]));
+            i((c) => {
+              for (const l of n) {
+                let p = !1;
+                for (const m of c.pages) {
+                  const f = m.tasks.findIndex((T) => T.id === l.id);
+                  if (f !== -1) {
+                    m.tasks[f] = l, p = !0;
                     break;
                   }
                 }
-                m || (p.pages.length ? p.pages[0].tasks.unshift(u) : p.pages.push({
-                  tasks: [u],
+                p || (c.pages.length ? c.pages[0].tasks.unshift(l) : c.pages.push({
+                  tasks: [l],
                   pageInfo: {
                     startCursor: null,
                     endCursor: null,
@@ -427,12 +433,12 @@ const $ = (e) => {
                   }
                 }));
               }
-              for (const u of y)
-                if (!d.has(u))
-                  for (const m of p.pages) {
-                    const l = m.tasks.findIndex((h) => h.id === u);
-                    if (l !== -1) {
-                      m.tasks.splice(l, 1);
+              for (const l of y)
+                if (!u.has(l))
+                  for (const p of c.pages) {
+                    const m = p.tasks.findIndex((f) => f.id === l);
+                    if (m !== -1) {
+                      p.tasks.splice(m, 1);
                       break;
                     }
                   }
@@ -440,20 +446,20 @@ const $ = (e) => {
           } catch (r) {
             console.error("Realtime infinite tasks batch update failed", r);
           } finally {
-            E.size && I();
+            F.size && k();
           }
         };
-        let A;
+        let E;
         try {
-          await s, A = Q(
+          await s, E = H(
             (r) => {
-              i((c) => {
-                r.forEach((d) => {
-                  if (d.summary.entityType === "task" && d.summary.thumbnailHash)
-                    for (const p of c.pages) {
-                      const u = p.tasks.findIndex((m) => m.id === d.summary.entityId);
-                      if (u > -1) {
-                        p.tasks[u].thumbnailHash = d.summary.thumbnailHash;
+              i((n) => {
+                r.forEach((u) => {
+                  if (u.summary.entityType === "task" && u.summary.thumbnailHash)
+                    for (const c of n.pages) {
+                      const l = c.tasks.findIndex((p) => p.id === u.summary.entityId);
+                      if (l > -1) {
+                        c.tasks[l].thumbnailHash = u.summary.thumbnailHash;
                         break;
                       }
                     }
@@ -462,111 +468,113 @@ const $ = (e) => {
             },
             ["task"]
           );
-          const y = async (r, c) => {
-            const d = c?.summary?.entityId;
-            d && (E.add(d), I());
+          const y = async (r, n) => {
+            const u = n?.summary?.entityId;
+            u && (F.add(u), k());
           };
-          k = _.subscribe("entity.task", y);
+          I = x.subscribe("entity.task", y);
         } catch {
         }
-        await o, k && _.unsubscribe(k), A && A();
-      }
+        await o, I && x.unsubscribe(I), E && E();
+      },
+      keepUnusedDataFor: P
     }),
-    getGroupedTasksList: e.query({
+    getGroupedTasksList: t.query({
       queryFn: async ({
-        projectName: t,
+        projectName: e,
         groups: s,
         search: o,
         folderFilter: i,
-        folderIds: n,
-        desc: k,
-        sortBy: E,
-        groupCount: F,
-        showComments: T
-      }, v) => {
+        folderIds: d,
+        desc: I,
+        sortBy: F,
+        groupCount: v,
+        showComments: A
+      }, g) => {
         try {
-          let I = [];
+          let k = [];
           const w = /* @__PURE__ */ new Set(["folderType"]);
           for (const r of s) {
-            const c = F || r.count || 500;
-            let d = r.filter, p = i;
+            const n = v || r.count || 500;
+            let u = r.filter, c = i;
             if (r.filter)
               try {
-                const l = JSON.parse(r.filter), h = l.conditions || [], g = h.filter((f) => !w.has(f.key)), a = h.filter((f) => w.has(f.key));
-                if (a.length > 0) {
-                  d = g.length ? JSON.stringify({ ...l, conditions: g }) : void 0;
-                  const f = i ? JSON.parse(i) : null, P = [...f && Array.isArray(f.conditions) ? f.conditions : [], ...a];
-                  p = JSON.stringify(
-                    f ? { ...f, conditions: P } : { conditions: P }
+                const m = JSON.parse(r.filter), f = m.conditions || [], T = f.filter((a) => !w.has(a.key)), h = f.filter((a) => w.has(a.key));
+                if (h.length > 0) {
+                  u = T.length ? JSON.stringify({ ...m, conditions: T }) : void 0;
+                  const a = i ? JSON.parse(i) : null, C = [...a && Array.isArray(a.conditions) ? a.conditions : [], ...h];
+                  c = JSON.stringify(
+                    a ? { ...a, conditions: C } : { conditions: C }
                   );
                 }
               } catch {
               }
-            const u = {
-              projectName: t,
-              filter: d,
-              folderFilter: p,
+            const l = {
+              projectName: e,
+              filter: u,
+              folderFilter: c,
               search: o,
-              folderIds: n,
-              sortBy: E,
-              showComments: !!T,
+              folderIds: d,
+              sortBy: F,
+              showComments: !!A,
               // @ts-expect-error - we know group does not exist on query variables but we need it for later
               group: r.value
             };
-            k ? u.last = c : u.first = c;
-            const m = v.dispatch(
-              C.endpoints.GetTasksList.initiate(u, { forceRefetch: !0 })
+            I ? l.last = n : l.first = n;
+            const p = g.dispatch(
+              R.endpoints.GetTasksList.initiate(l, { forceRefetch: !0 })
             );
-            I.push(m);
+            k.push(p);
           }
-          const A = await Promise.all(I), y = [];
-          for (const r of A) {
+          const E = await Promise.all(k), y = [];
+          for (const r of E) {
             if (r.error) throw r.error;
-            const c = r.originalArgs?.group, d = r.data?.pageInfo?.hasNextPage || r.data?.pageInfo?.hasPreviousPage || !1, p = r.data?.tasks.map((u, m, l) => ({
-              ...u,
+            const n = r.originalArgs?.group, u = r.data?.pageInfo?.hasNextPage || r.data?.pageInfo?.hasPreviousPage || !1, c = r.data?.tasks.map((l, p, m) => ({
+              ...l,
               groups: [
                 {
-                  value: c,
-                  hasNextPage: m === l.length - 1 && d ? c : void 0
+                  value: n,
+                  hasNextPage: p === m.length - 1 && u ? n : void 0
                   // Only add hasNextPage to the last task in the group
                 }
               ]
             })) || [];
-            y.push(...p);
+            y.push(...c);
           }
           return {
             data: {
               tasks: y
             }
           };
-        } catch (I) {
-          return console.error("Error in getGroupedTasksList queryFn:", I), { error: { status: "FETCH_ERROR", error: I.message } };
+        } catch (k) {
+          return console.error("Error in getGroupedTasksList queryFn:", k), { error: { status: "FETCH_ERROR", error: k.message } };
         }
       },
-      providesTags: (t, s, { projectName: o }) => R(t?.tasks, o)
+      providesTags: (e, s, { projectName: o }) => S(e?.tasks, o),
+      keepUnusedDataFor: P
     })
   })
 }), {
-  useGetOverviewTasksByFoldersQuery: Ue,
-  useGetSearchFoldersQuery: Xe,
-  useGetTasksListQuery: $e,
-  useGetTasksListInfiniteInfiniteQuery: Ve,
-  useLazyGetTasksByParentQuery: De,
-  useGetGroupedTasksListQuery: Ye,
-  useGetFolderColumnStatsQuery: Ze,
-  useGetTaskColumnStatsQuery: We
+  useGetOverviewTasksByFoldersQuery: Xt,
+  useGetSearchFoldersQuery: $t,
+  useGetTasksListQuery: Vt,
+  useGetTasksListInfiniteInfiniteQuery: Yt,
+  useLazyGetTasksByParentQuery: Zt,
+  useGetGroupedTasksListQuery: Wt,
+  useGetFolderColumnStatsQuery: es,
+  useGetTaskColumnStatsQuery: ts
 } = J;
 export {
-  G as TASKS_INFINITE_QUERY_COUNT,
+  O as TASKS_INFINITE_QUERY_COUNT,
   J as default,
-  $ as parseAllAttribs,
-  Ze as useGetFolderColumnStatsQuery,
-  Ye as useGetGroupedTasksListQuery,
-  Ue as useGetOverviewTasksByFoldersQuery,
-  Xe as useGetSearchFoldersQuery,
-  We as useGetTaskColumnStatsQuery,
-  Ve as useGetTasksListInfiniteInfiniteQuery,
-  $e as useGetTasksListQuery,
-  De as useLazyGetTasksByParentQuery
+  V as parseAllAttribs,
+  es as useGetFolderColumnStatsQuery,
+  Wt as useGetGroupedTasksListQuery,
+  Xt as useGetOverviewTasksByFoldersQuery,
+  $t as useGetSearchFoldersQuery,
+  ts as useGetTaskColumnStatsQuery,
+  Yt as useGetTasksListInfiniteInfiniteQuery,
+  Vt as useGetTasksListQuery,
+  Zt as useLazyGetTasksByParentQuery
 };
 //# sourceMappingURL=getOverview.es.js.map