@ynput/ayon-frontend-shared 0.4.2 → 0.4.4

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

@@ -1,4 +1,5 @@
 import "../../base/client.es.js";
+import { normalizeQueryError as N } from "../../base/queryError.es.js";
 import { api as te } from "../../generated/graphql.es.js";
 import "../../generated/graphqlLinks.es.js";
 import "../../generated/access.es.js";
@@ -13,6 +14,7 @@ import "../../generated/configuration.es.js";
 import "../../generated/dataImport.es.js";
 import "../../generated/desktop.es.js";
 import "../../generated/entityLists.es.js";
+import "../../generated/enums.es.js";
 import "../../generated/events.es.js";
 import "../../generated/files.es.js";
 import { api as se } from "../../generated/folders.es.js";
@@ -42,13 +44,14 @@ import L from "../../../util/pubsub.es.js";
 import "lodash";
 import "react-toastify";
 import "uuid";
-import { subscribeToThumbnailUpdates as U } from "../../../util/thumbnailWebsocket.es.js";
+import { subscribeToThumbnailUpdates as B } from "../../../util/thumbnailWebsocket.es.js";
 import "../users/updateUsers.es.js";
-import { createRealtimeBatcher as H, getSupportedEntityPatch as B, REALTIME_TASK_SUPPORTED_VALUE_FIELDS as J, REALTIME_REST_CALL_LIMIT as $, waitForRealtimeJitter as D } from "../../../util/realtimeUpdatesUtils.es.js";
-import { mergeFieldStats as K, transformStatsError as z, normalizeFieldStats as V } from "../columnStats/columnStats.es.js";
+import { createRealtimeBatcher as J, getSupportedEntityPatch as $, REALTIME_REST_CALL_LIMIT as D, waitForRealtimeJitter as H, REALTIME_TASK_SUPPORTED_VALUE_FIELDS as z } from "../../../util/realtimeUpdatesUtils.es.js";
+import "../../../util/searchTerms.es.js";
+import { mergeFieldStats as K, normalizeFieldStats as V } from "../columnStats/columnStats.es.js";
 import { hasNewTargetFields as X } from "../columnStats/metricTargets.es.js";
 import "../columnStats/groupCounts.es.js";
-const _ = 10, q = (t) => {
+const R = 10, j = (t) => {
   if (!t) return {};
   try {
     const e = JSON.parse(t);
@@ -56,7 +59,7 @@ const _ = 10, q = (t) => {
   } catch {
     return {};
   }
-}, tt = q, Y = (t) => {
+}, ot = j, Y = (t) => {
   if (!t.project)
     return [];
   const e = [];
@@ -64,25 +67,25 @@ const _ = 10, q = (t) => {
     e.push({
       ...s,
       folderId: s.folderId || "root",
-      attrib: q(s.allAttrib),
-      data: q(s.data),
+      attrib: j(s.allAttrib),
+      data: j(s.data),
       entityId: s.id,
       entityType: "task",
       links: []
     });
   return e;
-}, N = (t = [], e, s) => {
-  const n = t?.map((f) => ({ type: "overviewTask", id: f.id })) || [], a = s ? (Array.isArray(s) ? s : [s]).map((f) => ({
+}, O = (t = [], e, s) => {
+  const n = t?.map((m) => ({ type: "overviewTask", id: m.id })) || [], r = s ? (Array.isArray(s) ? s : [s]).map((m) => ({
     type: "overviewTask",
-    id: f
+    id: m
   })) : [];
   return [
     ...n,
-    ...a,
+    ...r,
     { type: "overviewTask", id: e },
     { type: "overviewTask", id: "LIST" }
   ];
-}, x = te.enhanceEndpoints({
+}, C = te.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
@@ -92,45 +95,43 @@ const _ = 10, q = (t) => {
         pageInfo: t?.project?.tasks?.pageInfo ?? { hasNextPage: !1, endCursor: null },
         tasks: Y(t)
       }),
-      providesTags: (t, e, { parentIds: s, projectName: n }) => N(t?.tasks || [], n, s),
-      keepUnusedDataFor: _
+      providesTags: (t, e, { parentIds: s, projectName: n }) => O(t?.tasks || [], n, s),
+      keepUnusedDataFor: R
     },
     GetTasksList: {
       transformResponse: (t) => ({
         tasks: Y(t),
         pageInfo: t.project.tasks.pageInfo
       }),
-      providesTags: (t, e, { projectName: s }) => N(t?.tasks || [], s),
-      keepUnusedDataFor: _
+      providesTags: (t, e, { projectName: s }) => O(t?.tasks || [], s),
+      keepUnusedDataFor: R
     },
     // footer stats: `targets` excluded from cache key + responses merged,
     // so column toggles reuse cache and only added targets refetch
     GetFolderColumnStats: {
       transformResponse: (t) => V(t?.project?.folders?.fieldStats ?? []),
-      transformErrorResponse: (t) => z(t, "folder"),
       serializeQueryArgs: ({ queryArgs: { targets: t, ...e } }) => e,
       merge: (t, e) => K(e, t),
       forceRefetch: ({ currentArg: t, previousArg: e }) => X(t, e),
       providesTags: (t, e, { projectName: s }) => [{ type: "folderColumnStats", id: s }],
-      keepUnusedDataFor: _
+      keepUnusedDataFor: R
     },
     GetTaskColumnStats: {
       transformResponse: (t) => V(t?.project?.tasks?.fieldStats ?? []),
-      transformErrorResponse: (t) => z(t, "task"),
       serializeQueryArgs: ({ queryArgs: { targets: t, ...e } }) => e,
       merge: (t, e) => K(e, t),
       forceRefetch: ({ currentArg: t, previousArg: e }) => X(t, e),
       providesTags: (t, e, { projectName: s }) => [{ type: "taskColumnStats", id: s }],
-      keepUnusedDataFor: _
+      keepUnusedDataFor: R
     }
   }
 }), re = se.enhanceEndpoints({
   endpoints: {
     searchFolders: {}
   }
-}), G = 100, O = {}, M = (t, e, s, n, a) => JSON.stringify({ projectName: t, filter: e, folderFilter: s, search: n, showComments: a }), oe = (t, e) => {
-  O[t] || (O[t] = /* @__PURE__ */ new Set()), e.forEach((s) => O[t].add(s));
-}, Z = (t) => O[t] || /* @__PURE__ */ new Set(), W = x.injectEndpoints({
+}), M = 100, G = {}, Q = (t, e, s, n, r) => JSON.stringify({ projectName: t, filter: e, folderFilter: s, search: n, showComments: r }), oe = (t, e) => {
+  G[t] || (G[t] = /* @__PURE__ */ new Set()), e.forEach((s) => G[t].add(s));
+}, Z = (t) => G[t] || /* @__PURE__ */ new Set(), W = C.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
@@ -138,55 +139,55 @@ const _ = 10, q = (t) => {
     // 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: t.query({
-      async queryFn({ projectName: e, parentIds: s, filter: n, folderFilter: a, search: f, showComments: E }, { dispatch: w, getState: A, forced: P }) {
+      async queryFn({ projectName: e, parentIds: s, filter: n, folderFilter: r, search: m, showComments: w }, { dispatch: F, getState: _, forced: P }) {
         try {
-          const T = A(), h = { projectName: e, filter: n, folderFilter: a, search: f, showComments: E }, b = W.endpoints.getOverviewTasksByFolders.select(
+          const I = _(), h = { projectName: e, filter: n, folderFilter: r, search: m, showComments: w }, v = W.endpoints.getOverviewTasksByFolders.select(
             h
-          )(T)?.data || [], y = M(e, n, a, f, E), r = Z(y), d = P ? s : s.filter((c) => !r.has(c));
+          )(I)?.data || [], y = Q(e, n, r, m, w), o = Z(y), d = P ? s : s.filter((c) => !o.has(c));
           if (d.length === 0)
-            return { data: b };
-          const o = [], p = 100, m = 20, i = 10, u = 1e3, k = p * m;
+            return { data: v };
+          const a = [], p = 100, f = 20, i = 10, u = 1e3, k = p * f;
           if (d.length > u)
             throw new Error(
               `Exceeded maximum folders count limit ${u} (${d.length}). Please reduce the number of expanded folders.`
             );
           for (let c = 0; c < d.length; c += p) {
-            const R = d.slice(c, c + p);
-            let g = !0, S, v = 0;
-            for (; g && v < i; ) {
-              if (v++, v === i)
+            const E = d.slice(c, c + p);
+            let g = !0, S, A = 0;
+            for (; g && A < i; ) {
+              if (A++, A === i)
                 throw new Error(
                   `Exceeded maximum tasks count limit ${i * k}.`
                 );
-              const C = await w(
-                x.endpoints.GetTasksByParent.initiate(
+              const x = await F(
+                C.endpoints.GetTasksByParent.initiate(
                   {
                     projectName: e,
-                    parentIds: R,
+                    parentIds: E,
                     filter: n,
-                    folderFilter: a,
-                    search: f,
-                    showComments: !!E,
+                    folderFilter: r,
+                    search: m,
+                    showComments: !!w,
                     first: k,
                     after: S
                   },
                   { forceRefetch: !0 }
                 )
               );
-              if (C.error) throw C.error;
-              const Q = C.data, ee = Q?.tasks || [];
-              o.push(...ee);
-              const j = Q?.pageInfo;
-              g = j?.hasNextPage || !1, S = j?.endCursor || void 0;
+              if (x.error) throw x.error;
+              const q = x.data, ee = q?.tasks || [];
+              a.push(...ee);
+              const U = q?.pageInfo;
+              g = U?.hasNextPage || !1, S = U?.endCursor || void 0;
             }
           }
           oe(y, d);
-          const I = [...b, ...o], l = new Map(I.map((c) => [c.id, c]));
+          const T = [...v, ...a], l = new Map(T.map((c) => [c.id, c]));
           return {
             data: Array.from(l.values())
           };
-        } catch (T) {
-          return console.error(T), { error: { status: "FETCH_ERROR", error: T.message || T.data?.message || JSON.stringify(T) || "Unknown Fetch Error" } };
+        } catch (I) {
+          return console.error(I), { error: N(I) };
         }
       },
       // keep one cache per project
@@ -197,23 +198,23 @@ const _ = 10, q = (t) => {
       forceRefetch({ currentArg: e, previousArg: s }) {
         return JSON.stringify(e) !== JSON.stringify(s);
       },
-      providesTags: (e, s, { parentIds: n, projectName: a }) => N(e, a, n),
-      async onCacheEntryAdded({ projectName: e, parentIds: s, filter: n, folderFilter: a, search: f, showComments: E }, { cacheDataLoaded: w, cacheEntryRemoved: A, updateCachedData: P, dispatch: T, getCacheEntry: h }) {
-        let F;
-        const y = H(
-          async (o, p) => {
-            const m = Z(
-              M(e, n, a, f, E)
+      providesTags: (e, s, { parentIds: n, projectName: r }) => O(e, r, n),
+      async onCacheEntryAdded({ projectName: e, parentIds: s, filter: n, folderFilter: r, search: m, showComments: w }, { cacheDataLoaded: F, cacheEntryRemoved: _, updateCachedData: P, dispatch: I, getCacheEntry: h }) {
+        let b;
+        const y = J(
+          async (a, p) => {
+            const f = Z(
+              Q(e, n, r, m, w)
             ), i = new Set(
               h().data?.map((l) => l.id) || []
             ), u = /* @__PURE__ */ new Set(), k = [];
-            o.filter((l) => l.project === e).filter((l) => m.has(l.summary?.parentId)).forEach((l) => {
+            a.filter((l) => l.project === e).filter((l) => f.has(l.summary?.parentId)).forEach((l) => {
               const c = l.summary?.entityId;
               if (!c || !i.has(c)) return;
-              const R = l.topic?.split(".")[2]?.replace("_changed", ""), g = B(
-                R,
+              const E = l.topic?.split(".")[2]?.replace("_changed", ""), g = $(
+                E,
                 l.summary,
-                J
+                z
               );
               g ? k.push({
                 taskId: c,
@@ -221,100 +222,101 @@ const _ = 10, q = (t) => {
                 value: g.value
               }) : u.add(c);
             }), k.length && P((l) => {
-              k.forEach(({ taskId: c, field: R, value: g }) => {
-                const S = l.find((v) => v.id === c);
-                S && Object.assign(S, { [R === "type" ? "taskType" : R]: g });
+              k.forEach(({ taskId: c, field: E, value: g }) => {
+                const S = l.find((A) => A.id === c);
+                S && Object.assign(S, { [E === "type" ? "taskType" : E]: g });
               });
             });
-            const I = Array.from(u);
-            if (!(!I.length || I.length > $))
+            const T = Array.from(u);
+            if (!(!T.length || T.length > D))
               try {
-                await D();
-                const c = (await T(
-                  x.endpoints.GetTasksList.initiate(
+                await H();
+                const c = (await I(
+                  C.endpoints.GetTasksList.initiate(
                     {
                       projectName: e,
-                      taskIds: I,
-                      showComments: !!E
+                      taskIds: T,
+                      showComments: !!w
                     },
                     { forceRefetch: !0 }
                   )
                 ).unwrap()).tasks || [];
                 if (!p()) return;
-                const R = new Map(c.map((g) => [g.id, g]));
+                const E = new Map(c.map((g) => [g.id, g]));
                 P((g) => {
                   for (const S of c) {
-                    const v = g.findIndex((C) => C.id === S.id);
-                    v > -1 ? g[v] = S : g.push(S);
+                    const A = g.findIndex((x) => x.id === S.id);
+                    A > -1 ? g[A] = S : g.push(S);
                   }
-                  for (const S of I)
-                    if (!R.has(S)) {
-                      const v = g.findIndex((C) => C.id === S);
-                      v > -1 && g.splice(v, 1);
+                  for (const S of T)
+                    if (!E.has(S)) {
+                      const A = g.findIndex((x) => x.id === S);
+                      A > -1 && g.splice(A, 1);
                     }
                 });
               } catch (l) {
                 console.error("Realtime overview batch update failed", l);
               }
           },
-          (o) => `${o.project ?? e}:${o.summary?.entityId}:${o.topic}`
+          (a) => `${a.project ?? e}:${a.summary?.entityId}:${a.topic}`
         );
-        let r;
+        let o;
         try {
-          await w, r = U(
+          await F, o = B(
             (p) => {
-              P((m) => {
+              P((f) => {
                 p.forEach((i) => {
                   if (i.summary.entityType === "task" && i.summary.thumbnailHash) {
-                    const u = m.findIndex((k) => k.id === i.summary.entityId);
-                    u > -1 && (m[u].thumbnailHash = i.summary.thumbnailHash);
+                    const u = f.findIndex((k) => k.id === i.summary.entityId);
+                    u > -1 && (f[u].thumbnailHash = i.summary.thumbnailHash);
                   }
                 });
               });
             },
             ["task"]
           );
-          const o = (p, m) => {
-            const i = m?.summary?.entityId, u = m?.summary?.parentId;
-            !i || !u || y.add({ ...m, topic: p });
+          const a = (p, f) => {
+            const i = f?.summary?.entityId, u = f?.summary?.parentId;
+            !i || !u || y.add({ ...f, topic: p });
           };
-          F = L.subscribe("entity.task", o);
+          b = L.subscribe("entity.task", a);
         } catch {
         }
-        await A, y.clear();
-        const d = M(e, n, a, f, E);
-        delete O[d], F && L.unsubscribe(F), r && r();
+        await _, y.clear();
+        const d = Q(e, n, r, m, w);
+        delete G[d], b && L.unsubscribe(b), o && o();
       },
-      keepUnusedDataFor: _
+      keepUnusedDataFor: R
     }),
     // 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: t.query({
       async queryFn({ projectName: e, folderSearchRequest: s }, { dispatch: n }) {
         try {
-          return { data: (await n(
+          const r = await n(
             re.endpoints.searchFolders.initiate({
               projectName: e,
               folderSearchRequest: s
             })
-          )).data?.folderIds || [] };
-        } catch (a) {
-          return console.error(a), { error: { status: "FETCH_ERROR", error: a.message } };
+          );
+          return r.error ? { error: N(r.error) } : { data: r.data?.folderIds || [] };
+        } catch (r) {
+          return console.error(r), { error: N(r) };
         }
       },
       providesTags: (e, s, { projectName: n }) => [{ type: "tasksFolder", id: n }],
-      keepUnusedDataFor: _
+      keepUnusedDataFor: R
     }),
     // Add new infinite query endpoint for tasks list
     getTasksListInfinite: t.infiniteQuery({
       infiniteQueryOptions: {
         initialPageParam: { cursor: "", desc: !1 },
         // Calculate the next page param based on current page response and params
-        getNextPageParam: (e, s, n, a) => {
-          const f = e.pageInfo;
-          if (!(!(n.desc ? f.hasPreviousPage : f.hasNextPage) || !f.endCursor))
+        getNextPageParam: (e, s, n, r) => {
+          const m = e.pageInfo;
+          if (!(!(n.desc ? m.hasPreviousPage : m.hasNextPage) || !m.endCursor))
             return {
-              cursor: f.endCursor,
+              cursor: m.endCursor,
               desc: n.desc
             };
         }
@@ -322,33 +324,33 @@ const _ = 10, q = (t) => {
       queryFn: async ({ queryArg: e, pageParam: s }, n) => {
         try {
           const {
-            projectName: a,
-            filter: f,
-            folderFilter: E,
-            search: w,
-            folderIds: A,
+            projectName: r,
+            filter: m,
+            folderFilter: w,
+            search: F,
+            folderIds: _,
             taskIds: P,
-            sortBy: T,
+            sortBy: I,
             desc: h,
-            showComments: F,
-            includeFolderChildren: b
-          } = e, { cursor: y } = s, r = {
-            projectName: a,
-            filter: f,
-            folderFilter: E,
-            search: w,
-            folderIds: A,
+            showComments: b,
+            includeFolderChildren: v
+          } = e, { cursor: y } = s, o = {
+            projectName: r,
+            filter: m,
+            folderFilter: w,
+            search: F,
+            folderIds: _,
             taskIds: P,
-            showComments: !!F,
-            includeFolderChildren: b !== !1
+            showComments: !!b,
+            includeFolderChildren: v !== !1
             // default to true
           };
-          T ? (r.sortBy = T, h ? (r.before = y || void 0, r.last = G) : (r.after = y || void 0, r.first = G)) : (r.after = y || void 0, r.first = G);
+          I ? (o.sortBy = I, h ? (o.before = y || void 0, o.last = M) : (o.after = y || void 0, o.first = M)) : (o.after = y || void 0, o.first = M);
           const d = await n.dispatch(
-            x.endpoints.GetTasksList.initiate(r, { forceRefetch: !0 })
+            C.endpoints.GetTasksList.initiate(o, { forceRefetch: !0 })
           );
           if (d.error) throw d.error;
-          const o = {
+          const a = {
             tasks: [],
             pageInfo: {
               hasNextPage: !1,
@@ -358,52 +360,52 @@ const _ = 10, q = (t) => {
             }
           };
           return {
-            data: d.data || o
+            data: d.data || a
           };
-        } catch (a) {
-          return console.error("Error in getTasksListInfinite queryFn:", a), { error: { status: "FETCH_ERROR", error: a.message } };
+        } catch (r) {
+          return console.error("ERROR [getOverview]:", r, r.data?.detail), { error: N(r) };
         }
       },
-      providesTags: (e, s, { projectName: n }) => N(e?.pages.flatMap((a) => a.tasks) || [], n),
-      async onCacheEntryAdded(e, { cacheDataLoaded: s, cacheEntryRemoved: n, updateCachedData: a, dispatch: f, getCacheEntry: E }) {
-        let w;
-        const P = H(
-          async (h, F) => {
-            const b = new Set(
-              (E().data?.pages || []).flatMap(
-                (o) => o.tasks.map((p) => p.id)
+      providesTags: (e, s, { projectName: n }) => O(e?.pages.flatMap((r) => r.tasks) || [], n),
+      async onCacheEntryAdded(e, { cacheDataLoaded: s, cacheEntryRemoved: n, updateCachedData: r, dispatch: m, getCacheEntry: w }) {
+        let F;
+        const P = J(
+          async (h, b) => {
+            const v = new Set(
+              (w().data?.pages || []).flatMap(
+                (a) => a.tasks.map((p) => p.id)
               )
-            ), y = /* @__PURE__ */ new Set(), r = [];
-            h.filter((o) => o.project === e.projectName).forEach((o) => {
-              const p = o.summary?.entityId;
-              if (!p || !b.has(p)) return;
-              const m = o.topic?.split(".")[2]?.replace("_changed", ""), i = B(
-                m,
-                o.summary,
-                J
+            ), y = /* @__PURE__ */ new Set(), o = [];
+            h.filter((a) => a.project === e.projectName).forEach((a) => {
+              const p = a.summary?.entityId;
+              if (!p || !v.has(p)) return;
+              const f = a.topic?.split(".")[2]?.replace("_changed", ""), i = $(
+                f,
+                a.summary,
+                z
               );
-              i ? r.push({
+              i ? o.push({
                 taskId: p,
                 field: i.field,
                 value: i.value
               }) : y.add(p);
-            }), r.length && a((o) => {
-              r.forEach(({ taskId: p, field: m, value: i }) => {
-                for (const u of o.pages) {
-                  const k = u.tasks.find((I) => I.id === p);
+            }), o.length && r((a) => {
+              o.forEach(({ taskId: p, field: f, value: i }) => {
+                for (const u of a.pages) {
+                  const k = u.tasks.find((T) => T.id === p);
                   if (k) {
-                    Object.assign(k, { [m === "type" ? "taskType" : m]: i });
+                    Object.assign(k, { [f === "type" ? "taskType" : f]: i });
                     break;
                   }
                 }
               });
             });
             const d = Array.from(y);
-            if (!(!d.length || d.length > $))
+            if (!(!d.length || d.length > D))
               try {
-                await D();
-                const p = (await f(
-                  x.endpoints.GetTasksList.initiate(
+                await H();
+                const p = (await m(
+                  C.endpoints.GetTasksList.initiate(
                     {
                       projectName: e.projectName,
                       taskIds: d,
@@ -413,15 +415,15 @@ const _ = 10, q = (t) => {
                     { forceRefetch: !0 }
                   )
                 ).unwrap()).tasks || [];
-                if (!F()) return;
-                const m = new Map(p.map((i) => [i.id, i]));
-                a((i) => {
+                if (!b()) return;
+                const f = new Map(p.map((i) => [i.id, i]));
+                r((i) => {
                   for (const u of p) {
                     let k = !1;
-                    for (const I of i.pages) {
-                      const l = I.tasks.findIndex((c) => c.id === u.id);
+                    for (const T of i.pages) {
+                      const l = T.tasks.findIndex((c) => c.id === u.id);
                       if (l !== -1) {
-                        I.tasks[l] = u, k = !0;
+                        T.tasks[l] = u, k = !0;
                         break;
                       }
                     }
@@ -436,32 +438,32 @@ const _ = 10, q = (t) => {
                     }));
                   }
                   for (const u of d)
-                    if (!m.has(u))
+                    if (!f.has(u))
                       for (const k of i.pages) {
-                        const I = k.tasks.findIndex((l) => l.id === u);
-                        if (I !== -1) {
-                          k.tasks.splice(I, 1);
+                        const T = k.tasks.findIndex((l) => l.id === u);
+                        if (T !== -1) {
+                          k.tasks.splice(T, 1);
                           break;
                         }
                       }
                 });
-              } catch (o) {
-                console.error("Realtime infinite tasks batch update failed", o);
+              } catch (a) {
+                console.error("Realtime infinite tasks batch update failed", a);
               }
           },
           (h) => `${h.project}:${h.summary?.entityId}:${h.topic}`
         );
-        let T;
+        let I;
         try {
-          await s, T = U(
-            (F) => {
-              a((b) => {
-                F.forEach((y) => {
+          await s, I = B(
+            (b) => {
+              r((v) => {
+                b.forEach((y) => {
                   if (y.summary.entityType === "task" && y.summary.thumbnailHash)
-                    for (const r of b.pages) {
-                      const d = r.tasks.findIndex((o) => o.id === y.summary.entityId);
+                    for (const o of v.pages) {
+                      const d = o.tasks.findIndex((a) => a.id === y.summary.entityId);
                       if (d > -1) {
-                        r.tasks[d].thumbnailHash = y.summary.thumbnailHash;
+                        o.tasks[d].thumbnailHash = y.summary.thumbnailHash;
                         break;
                       }
                     }
@@ -470,72 +472,72 @@ const _ = 10, q = (t) => {
             },
             ["task"]
           );
-          const h = (F, b) => {
-            b?.summary?.entityId && P.add({ ...b, topic: F });
+          const h = (b, v) => {
+            v?.summary?.entityId && P.add({ ...v, topic: b });
           };
-          w = L.subscribe("entity.task", h);
+          F = L.subscribe("entity.task", h);
         } catch {
         }
-        await n, P.clear(), w && L.unsubscribe(w), T && T();
+        await n, P.clear(), F && L.unsubscribe(F), I && I();
       },
-      keepUnusedDataFor: _
+      keepUnusedDataFor: R
     }),
     getGroupedTasksList: t.query({
       queryFn: async ({
         projectName: e,
         groups: s,
         search: n,
-        folderFilter: a,
-        folderIds: f,
-        desc: E,
-        sortBy: w,
-        groupCount: A,
+        folderFilter: r,
+        folderIds: m,
+        desc: w,
+        sortBy: F,
+        groupCount: _,
         showComments: P
-      }, T) => {
+      }, I) => {
         try {
           let h = [];
-          const F = /* @__PURE__ */ new Set(["folderType"]);
-          for (const r of s) {
-            const d = A || r.count || 500;
-            let o = r.filter, p = a;
-            if (r.filter)
+          const b = /* @__PURE__ */ new Set(["folderType"]);
+          for (const o of s) {
+            const d = _ || o.count || 500;
+            let a = o.filter, p = r;
+            if (o.filter)
               try {
-                const u = JSON.parse(r.filter), k = u.conditions || [], I = k.filter((c) => !F.has(c.key)), l = k.filter((c) => F.has(c.key));
+                const u = JSON.parse(o.filter), k = u.conditions || [], T = k.filter((c) => !b.has(c.key)), l = k.filter((c) => b.has(c.key));
                 if (l.length > 0) {
-                  o = I.length ? JSON.stringify({ ...u, conditions: I }) : void 0;
-                  const c = a ? JSON.parse(a) : null, g = [...c && Array.isArray(c.conditions) ? c.conditions : [], ...l];
+                  a = T.length ? JSON.stringify({ ...u, conditions: T }) : void 0;
+                  const c = r ? JSON.parse(r) : null, g = [...c && Array.isArray(c.conditions) ? c.conditions : [], ...l];
                   p = JSON.stringify(
                     c ? { ...c, conditions: g } : { conditions: g }
                   );
                 }
               } catch {
               }
-            const m = {
+            const f = {
               projectName: e,
-              filter: o,
+              filter: a,
               folderFilter: p,
               search: n,
-              folderIds: f,
-              sortBy: w,
+              folderIds: m,
+              sortBy: F,
               showComments: !!P,
               // @ts-expect-error - we know group does not exist on query variables but we need it for later
-              group: r.value
+              group: o.value
             };
-            E ? m.last = d : m.first = d;
-            const i = T.dispatch(
-              x.endpoints.GetTasksList.initiate(m, { forceRefetch: !0 })
+            w ? f.last = d : f.first = d;
+            const i = I.dispatch(
+              C.endpoints.GetTasksList.initiate(f, { forceRefetch: !0 })
             );
             h.push(i);
           }
-          const b = await Promise.all(h), y = [];
-          for (const r of b) {
-            if (r.error) throw r.error;
-            const d = r.originalArgs?.group, o = r.data?.pageInfo?.hasNextPage || r.data?.pageInfo?.hasPreviousPage || !1, p = r.data?.tasks.map((m, i, u) => ({
-              ...m,
+          const v = await Promise.all(h), y = [];
+          for (const o of v) {
+            if (o.error) throw o.error;
+            const d = o.originalArgs?.group, a = o.data?.pageInfo?.hasNextPage || o.data?.pageInfo?.hasPreviousPage || !1, p = o.data?.tasks.map((f, i, u) => ({
+              ...f,
               groups: [
                 {
                   value: d,
-                  hasNextPage: i === u.length - 1 && o ? d : void 0
+                  hasNextPage: i === u.length - 1 && a ? d : void 0
                   // Only add hasNextPage to the last task in the group
                 }
               ]
@@ -548,35 +550,35 @@ const _ = 10, q = (t) => {
             }
           };
         } catch (h) {
-          return console.error("Error in getGroupedTasksList queryFn:", h), { error: { status: "FETCH_ERROR", error: h.message } };
+          return console.error("ERROR [getGroupedTasksList]:", h, h.data?.detail), { error: N(h) };
         }
       },
-      providesTags: (e, s, { projectName: n }) => N(e?.tasks, n),
-      keepUnusedDataFor: _
+      providesTags: (e, s, { projectName: n }) => O(e?.tasks, n),
+      keepUnusedDataFor: R
     })
   })
 }), {
-  useGetOverviewTasksByFoldersQuery: st,
-  useGetSearchFoldersQuery: rt,
-  useGetTasksListQuery: ot,
-  useGetTasksListInfiniteInfiniteQuery: at,
-  useLazyGetTasksByParentQuery: nt,
-  useGetGroupedTasksListQuery: it,
-  useGetFolderColumnStatsQuery: ct,
-  useGetTaskColumnStatsQuery: dt
+  useGetOverviewTasksByFoldersQuery: at,
+  useGetSearchFoldersQuery: nt,
+  useGetTasksListQuery: it,
+  useGetTasksListInfiniteInfiniteQuery: ct,
+  useLazyGetTasksByParentQuery: dt,
+  useGetGroupedTasksListQuery: pt,
+  useGetFolderColumnStatsQuery: ut,
+  useGetTaskColumnStatsQuery: lt
 } = W;
 export {
-  G as TASKS_INFINITE_QUERY_COUNT,
+  M as TASKS_INFINITE_QUERY_COUNT,
   W as default,
-  tt as parseAllAttribs,
-  q as parseJSONField,
-  ct as useGetFolderColumnStatsQuery,
-  it as useGetGroupedTasksListQuery,
-  st as useGetOverviewTasksByFoldersQuery,
-  rt as useGetSearchFoldersQuery,
-  dt as useGetTaskColumnStatsQuery,
-  at as useGetTasksListInfiniteInfiniteQuery,
-  ot as useGetTasksListQuery,
-  nt as useLazyGetTasksByParentQuery
+  ot as parseAllAttribs,
+  j as parseJSONField,
+  ut as useGetFolderColumnStatsQuery,
+  pt as useGetGroupedTasksListQuery,
+  at as useGetOverviewTasksByFoldersQuery,
+  nt as useGetSearchFoldersQuery,
+  lt as useGetTaskColumnStatsQuery,
+  ct as useGetTasksListInfiniteInfiniteQuery,
+  it as useGetTasksListQuery,
+  dt as useLazyGetTasksByParentQuery
 };
 //# sourceMappingURL=getOverview.es.js.map