@ynput/ayon-frontend-shared 0.4.1 → 0.4.2

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

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as et } from "../../generated/graphql.es.js";
+import { api as te } 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 rt } from "../../generated/folders.es.js";
+import { api as se } from "../../generated/folders.es.js";
 import "../../generated/inbox.es.js";
 import "../../generated/links.es.js";
 import "../../generated/market.es.js";
@@ -43,182 +43,129 @@ import "lodash";
 import "react-toastify";
 import "uuid";
 import { subscribeToThumbnailUpdates as U } from "../../../util/thumbnailWebsocket.es.js";
-import "../actions/getActions.es.js";
-import "../activities/getActivities.es.js";
-import "../activities/updateReaction.es.js";
-import "../activities/getMentions.es.js";
-import "../activities/getCategories.es.js";
-import "../addons/getAddons.es.js";
-import "../addons/updateAddons.es.js";
-import "../attributes/getAttributes.es.js";
-import "../attributes/updateAttributes.es.js";
-import "../authentication/getAuthentication.es.js";
-import "../bundles/getBundles.es.js";
-import "../bundles/updateBundles.es.js";
-import "../cloud/cloud.es.js";
-import { mergeFieldStats as H, transformStatsError as B, normalizeFieldStats as J } from "../columnStats/columnStats.es.js";
-import { hasNewTargetFields as $ } from "../columnStats/metricTargets.es.js";
-import "../columnStats/groupCounts.es.js";
-import "../config/getConfig.es.js";
-import "../config/updateConfig.es.js";
-import "../entities/getEntity.es.js";
-import "../entities/getEntityPanel.es.js";
-import "./updateOverview.es.js";
-import "../versions/getVersionsProducts.es.js";
-import "../links/getEntityLinks.es.js";
-import "../entities/updateEntity.es.js";
-import "../entityLists/getLists.es.js";
-import "../entityLists/updateLists.es.js";
-import "../entityLists/getListsAttributes.es.js";
-import "../entityLists/listItemsColumnStats.es.js";
-import "../entityLists/updateListsAttributes.es.js";
-import "../entityLists/listFolders.es.js";
-import "../folders/getFolders.es.js";
-import "../folders/getFolderDeleteInfo.es.js";
-import "../grouping/getGrouping.es.js";
-import "../links/updateLinks.es.js";
-import "../links/getLinks.es.js";
-import "../permissions/getPermissions.es.js";
-import "../products/createProduct.es.js";
-import "../products/getFolderProducts.es.js";
-import "../project/getProject.es.js";
-import "../project/updateProject.es.js";
-import "../projectFolders/projectFolders.es.js";
-import "../review/getReview.es.js";
-import "../review/updateReview.es.js";
-import "../share/share.es.js";
-import "../system/getSystem.es.js";
-import "../tasks/getTasks.es.js";
-import "../tasks/updateTasks.es.js";
-import "../teams/getTeams.es.js";
-import "../userDashboard/getUserDashboard.es.js";
-import "../users/getUsers.es.js";
 import "../users/updateUsers.es.js";
-import "../users/guests.es.js";
-import "../versions/updateVersions.es.js";
-import "../views/getViews.es.js";
-import "../views/updateViews.es.js";
-import "../watchers/getWatchers.es.js";
-import "../uris/getUris.es.js";
-import { createRealtimeBatcher as D, getSupportedEntityPatch as K, REALTIME_TASK_SUPPORTED_VALUE_FIELDS as z, REALTIME_REST_CALL_LIMIT as V, waitForRealtimeJitter as X } from "../../../util/realtimeUpdatesUtils.es.js";
-const _ = 10, q = (e) => {
-  if (!e) return {};
+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 { hasNewTargetFields as X } from "../columnStats/metricTargets.es.js";
+import "../columnStats/groupCounts.es.js";
+const _ = 10, q = (t) => {
+  if (!t) return {};
   try {
-    const t = JSON.parse(e);
-    return t && typeof t == "object" && !Array.isArray(t) ? t : {};
+    const e = JSON.parse(t);
+    return e && typeof e == "object" && !Array.isArray(e) ? e : {};
   } catch {
     return {};
   }
-}, tr = q, Y = (e) => {
-  if (!e.project)
+}, tt = q, Y = (t) => {
+  if (!t.project)
     return [];
-  const t = [];
-  for (const { node: r } of e.project.tasks.edges)
-    t.push({
-      ...r,
-      folderId: r.folderId || "root",
-      attrib: q(r.allAttrib),
-      data: q(r.data),
-      entityId: r.id,
+  const e = [];
+  for (const { node: s } of t.project.tasks.edges)
+    e.push({
+      ...s,
+      folderId: s.folderId || "root",
+      attrib: q(s.allAttrib),
+      data: q(s.data),
+      entityId: s.id,
       entityType: "task",
       links: []
     });
-  return t;
-}, N = (e = [], t, r) => {
-  const i = e?.map((l) => ({ type: "overviewTask", id: l.id })) || [], a = r ? (Array.isArray(r) ? r : [r]).map((l) => ({
+  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) => ({
     type: "overviewTask",
-    id: l
+    id: f
   })) : [];
   return [
-    ...i,
+    ...n,
     ...a,
-    { type: "overviewTask", id: t },
+    { type: "overviewTask", id: e },
     { type: "overviewTask", id: "LIST" }
   ];
-}, x = et.enhanceEndpoints({
+}, x = 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
     // It is only used by getOverviewTasksByFolders in this file
     GetTasksByParent: {
-      transformResponse: (e) => ({
-        pageInfo: e?.project?.tasks?.pageInfo ?? { hasNextPage: !1, endCursor: null },
-        tasks: Y(e)
+      transformResponse: (t) => ({
+        pageInfo: t?.project?.tasks?.pageInfo ?? { hasNextPage: !1, endCursor: null },
+        tasks: Y(t)
       }),
-      providesTags: (e, t, { parentIds: r, projectName: i }) => N(e?.tasks || [], i, r),
+      providesTags: (t, e, { parentIds: s, projectName: n }) => N(t?.tasks || [], n, s),
       keepUnusedDataFor: _
     },
     GetTasksList: {
-      transformResponse: (e) => ({
-        tasks: Y(e),
-        pageInfo: e.project.tasks.pageInfo
+      transformResponse: (t) => ({
+        tasks: Y(t),
+        pageInfo: t.project.tasks.pageInfo
       }),
-      providesTags: (e, t, { projectName: r }) => N(e?.tasks || [], r),
+      providesTags: (t, e, { projectName: s }) => N(t?.tasks || [], s),
       keepUnusedDataFor: _
     },
     // footer stats: `targets` excluded from cache key + responses merged,
     // so column toggles reuse cache and only added targets refetch
     GetFolderColumnStats: {
-      transformResponse: (e) => J(e?.project?.folders?.fieldStats ?? []),
-      transformErrorResponse: (e) => B(e, "folder"),
-      serializeQueryArgs: ({ queryArgs: { targets: e, ...t } }) => t,
-      merge: (e, t) => H(t, e),
-      forceRefetch: ({ currentArg: e, previousArg: t }) => $(e, t),
-      providesTags: (e, t, { projectName: r }) => [{ type: "folderColumnStats", id: r }],
+      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: _
     },
     GetTaskColumnStats: {
-      transformResponse: (e) => J(e?.project?.tasks?.fieldStats ?? []),
-      transformErrorResponse: (e) => B(e, "task"),
-      serializeQueryArgs: ({ queryArgs: { targets: e, ...t } }) => t,
-      merge: (e, t) => H(t, e),
-      forceRefetch: ({ currentArg: e, previousArg: t }) => $(e, t),
-      providesTags: (e, t, { projectName: r }) => [{ type: "taskColumnStats", id: r }],
+      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: _
     }
   }
-}), st = rt.enhanceEndpoints({
+}), re = se.enhanceEndpoints({
   endpoints: {
     searchFolders: {}
   }
-}), G = 100, O = {}, M = (e, t, r, i, a) => JSON.stringify({ projectName: e, filter: t, folderFilter: r, search: i, showComments: a }), ot = (e, t) => {
-  O[e] || (O[e] = /* @__PURE__ */ new Set()), t.forEach((r) => O[e].add(r));
-}, Z = (e) => O[e] || /* @__PURE__ */ new Set(), W = x.injectEndpoints({
-  endpoints: (e) => ({
+}), 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({
+  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: r, filter: i, folderFilter: a, search: l, showComments: E }, { dispatch: w, getState: A, forced: P }) {
+    getOverviewTasksByFolders: t.query({
+      async queryFn({ projectName: e, parentIds: s, filter: n, folderFilter: a, search: f, showComments: E }, { dispatch: w, getState: A, forced: P }) {
         try {
-          const T = A(), h = { projectName: t, filter: i, folderFilter: a, search: l, showComments: E }, b = W.endpoints.getOverviewTasksByFolders.select(
+          const T = A(), h = { projectName: e, filter: n, folderFilter: a, search: f, showComments: E }, b = W.endpoints.getOverviewTasksByFolders.select(
             h
-          )(T)?.data || [], y = M(t, i, a, l, E), s = Z(y), p = P ? r : r.filter((c) => !s.has(c));
-          if (p.length === 0)
+          )(T)?.data || [], y = M(e, n, a, f, E), r = Z(y), d = P ? s : s.filter((c) => !r.has(c));
+          if (d.length === 0)
             return { data: b };
-          const o = [], d = 100, f = 20, n = 10, u = 1e3, k = d * f;
-          if (p.length > u)
+          const o = [], p = 100, m = 20, i = 10, u = 1e3, k = p * m;
+          if (d.length > u)
             throw new Error(
-              `Exceeded maximum folders count limit ${u} (${p.length}). Please reduce the number of expanded folders.`
+              `Exceeded maximum folders count limit ${u} (${d.length}). Please reduce the number of expanded folders.`
             );
-          for (let c = 0; c < p.length; c += d) {
-            const R = p.slice(c, c + d);
+          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 < n; ) {
-              if (v++, v === n)
+            for (; g && v < i; ) {
+              if (v++, v === i)
                 throw new Error(
-                  `Exceeded maximum tasks count limit ${n * k}.`
+                  `Exceeded maximum tasks count limit ${i * k}.`
                 );
               const C = await w(
                 x.endpoints.GetTasksByParent.initiate(
                   {
-                    projectName: t,
+                    projectName: e,
                     parentIds: R,
-                    filter: i,
+                    filter: n,
                     folderFilter: a,
-                    search: l,
+                    search: f,
                     showComments: !!E,
                     first: k,
                     after: S
@@ -227,73 +174,73 @@ const _ = 10, q = (e) => {
                 )
               );
               if (C.error) throw C.error;
-              const Q = C.data, tt = Q?.tasks || [];
-              o.push(...tt);
+              const Q = C.data, ee = Q?.tasks || [];
+              o.push(...ee);
               const j = Q?.pageInfo;
               g = j?.hasNextPage || !1, S = j?.endCursor || void 0;
             }
           }
-          ot(y, p);
-          const I = [...b, ...o], m = new Map(I.map((c) => [c.id, c]));
+          oe(y, d);
+          const I = [...b, ...o], l = new Map(I.map((c) => [c.id, c]));
           return {
-            data: Array.from(m.values())
+            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" } };
         }
       },
       // keep one cache per project
-      serializeQueryArgs: ({ queryArgs: { parentIds: t, ...r } }) => ({
-        ...r
+      serializeQueryArgs: ({ queryArgs: { parentIds: e, ...s } }) => ({
+        ...s
       }),
       // Refetch when the page arg changes
-      forceRefetch({ currentArg: t, previousArg: r }) {
-        return JSON.stringify(t) !== JSON.stringify(r);
+      forceRefetch({ currentArg: e, previousArg: s }) {
+        return JSON.stringify(e) !== JSON.stringify(s);
       },
-      providesTags: (t, r, { parentIds: i, projectName: a }) => N(t, a, i),
-      async onCacheEntryAdded({ projectName: t, parentIds: r, filter: i, folderFilter: a, search: l, showComments: E }, { cacheDataLoaded: w, cacheEntryRemoved: A, updateCachedData: P, dispatch: T, getCacheEntry: h }) {
+      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 = D(
-          async (o, d) => {
-            const f = Z(
-              M(t, i, a, l, E)
-            ), n = new Set(
-              h().data?.map((m) => m.id) || []
+        const y = H(
+          async (o, p) => {
+            const m = Z(
+              M(e, n, a, f, E)
+            ), i = new Set(
+              h().data?.map((l) => l.id) || []
             ), u = /* @__PURE__ */ new Set(), k = [];
-            o.filter((m) => m.project === t).filter((m) => f.has(m.summary?.parentId)).forEach((m) => {
-              const c = m.summary?.entityId;
-              if (!c || !n.has(c)) return;
-              const R = m.topic?.split(".")[2]?.replace("_changed", ""), g = K(
+            o.filter((l) => l.project === e).filter((l) => m.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,
-                m.summary,
-                z
+                l.summary,
+                J
               );
               g ? k.push({
                 taskId: c,
                 field: g.field,
                 value: g.value
               }) : u.add(c);
-            }), k.length && P((m) => {
+            }), k.length && P((l) => {
               k.forEach(({ taskId: c, field: R, value: g }) => {
-                const S = m.find((v) => v.id === c);
+                const S = l.find((v) => v.id === c);
                 S && Object.assign(S, { [R === "type" ? "taskType" : R]: g });
               });
             });
             const I = Array.from(u);
-            if (!(!I.length || I.length > V))
+            if (!(!I.length || I.length > $))
               try {
-                await X();
+                await D();
                 const c = (await T(
                   x.endpoints.GetTasksList.initiate(
                     {
-                      projectName: t,
+                      projectName: e,
                       taskIds: I,
                       showComments: !!E
                     },
                     { forceRefetch: !0 }
                   )
                 ).unwrap()).tasks || [];
-                if (!d()) return;
+                if (!p()) return;
                 const R = new Map(c.map((g) => [g.id, g]));
                 P((g) => {
                   for (const S of c) {
@@ -306,77 +253,77 @@ const _ = 10, q = (e) => {
                       v > -1 && g.splice(v, 1);
                     }
                 });
-              } catch (m) {
-                console.error("Realtime overview batch update failed", m);
+              } catch (l) {
+                console.error("Realtime overview batch update failed", l);
               }
           },
-          (o) => `${o.project ?? t}:${o.summary?.entityId}:${o.topic}`
+          (o) => `${o.project ?? e}:${o.summary?.entityId}:${o.topic}`
         );
-        let s;
+        let r;
         try {
-          await w, s = U(
-            (d) => {
-              P((f) => {
-                d.forEach((n) => {
-                  if (n.summary.entityType === "task" && n.summary.thumbnailHash) {
-                    const u = f.findIndex((k) => k.id === n.summary.entityId);
-                    u > -1 && (f[u].thumbnailHash = n.summary.thumbnailHash);
+          await w, r = U(
+            (p) => {
+              P((m) => {
+                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);
                   }
                 });
               });
             },
             ["task"]
           );
-          const o = (d, f) => {
-            const n = f?.summary?.entityId, u = f?.summary?.parentId;
-            !n || !u || y.add({ ...f, topic: d });
+          const o = (p, m) => {
+            const i = m?.summary?.entityId, u = m?.summary?.parentId;
+            !i || !u || y.add({ ...m, topic: p });
           };
           F = L.subscribe("entity.task", o);
         } catch {
         }
         await A, y.clear();
-        const p = M(t, i, a, l, E);
-        delete O[p], F && L.unsubscribe(F), s && s();
+        const d = M(e, n, a, f, E);
+        delete O[d], F && L.unsubscribe(F), r && r();
       },
       keepUnusedDataFor: _
     }),
     // 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: r }, { dispatch: i }) {
+    getSearchFolders: t.query({
+      async queryFn({ projectName: e, folderSearchRequest: s }, { dispatch: n }) {
         try {
-          return { data: (await i(
-            st.endpoints.searchFolders.initiate({
-              projectName: t,
-              folderSearchRequest: r
+          return { data: (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 } };
         }
       },
-      providesTags: (t, r, { projectName: i }) => [{ type: "tasksFolder", id: i }],
+      providesTags: (e, s, { projectName: n }) => [{ type: "tasksFolder", id: n }],
       keepUnusedDataFor: _
     }),
     // 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, r, i, a) => {
-          const l = t.pageInfo;
-          if (!(!(i.desc ? l.hasPreviousPage : l.hasNextPage) || !l.endCursor))
+        getNextPageParam: (e, s, n, a) => {
+          const f = e.pageInfo;
+          if (!(!(n.desc ? f.hasPreviousPage : f.hasNextPage) || !f.endCursor))
             return {
-              cursor: l.endCursor,
-              desc: i.desc
+              cursor: f.endCursor,
+              desc: n.desc
             };
         }
       },
-      queryFn: async ({ queryArg: t, pageParam: r }, i) => {
+      queryFn: async ({ queryArg: e, pageParam: s }, n) => {
         try {
           const {
             projectName: a,
-            filter: l,
+            filter: f,
             folderFilter: E,
             search: w,
             folderIds: A,
@@ -385,9 +332,9 @@ const _ = 10, q = (e) => {
             desc: h,
             showComments: F,
             includeFolderChildren: b
-          } = t, { cursor: y } = r, s = {
+          } = e, { cursor: y } = s, r = {
             projectName: a,
-            filter: l,
+            filter: f,
             folderFilter: E,
             search: w,
             folderIds: A,
@@ -396,11 +343,11 @@ const _ = 10, q = (e) => {
             includeFolderChildren: b !== !1
             // default to true
           };
-          T ? (s.sortBy = T, h ? (s.before = y || void 0, s.last = G) : (s.after = y || void 0, s.first = G)) : (s.after = y || void 0, s.first = G);
-          const p = await i.dispatch(
-            x.endpoints.GetTasksList.initiate(s, { forceRefetch: !0 })
+          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);
+          const d = await n.dispatch(
+            x.endpoints.GetTasksList.initiate(r, { forceRefetch: !0 })
           );
-          if (p.error) throw p.error;
+          if (d.error) throw d.error;
           const o = {
             tasks: [],
             pageInfo: {
@@ -411,74 +358,74 @@ const _ = 10, q = (e) => {
             }
           };
           return {
-            data: p.data || o
+            data: d.data || o
           };
         } catch (a) {
           return console.error("Error in getTasksListInfinite queryFn:", a), { error: { status: "FETCH_ERROR", error: a.message } };
         }
       },
-      providesTags: (t, r, { projectName: i }) => N(t?.pages.flatMap((a) => a.tasks) || [], i),
-      async onCacheEntryAdded(t, { cacheDataLoaded: r, cacheEntryRemoved: i, updateCachedData: a, dispatch: l, getCacheEntry: E }) {
+      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 = D(
+        const P = H(
           async (h, F) => {
             const b = new Set(
               (E().data?.pages || []).flatMap(
-                (o) => o.tasks.map((d) => d.id)
+                (o) => o.tasks.map((p) => p.id)
               )
-            ), y = /* @__PURE__ */ new Set(), s = [];
-            h.filter((o) => o.project === t.projectName).forEach((o) => {
-              const d = o.summary?.entityId;
-              if (!d || !b.has(d)) return;
-              const f = o.topic?.split(".")[2]?.replace("_changed", ""), n = K(
-                f,
+            ), 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,
-                z
+                J
               );
-              n ? s.push({
-                taskId: d,
-                field: n.field,
-                value: n.value
-              }) : y.add(d);
-            }), s.length && a((o) => {
-              s.forEach(({ taskId: d, field: f, value: n }) => {
+              i ? r.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 === d);
+                  const k = u.tasks.find((I) => I.id === p);
                   if (k) {
-                    Object.assign(k, { [f === "type" ? "taskType" : f]: n });
+                    Object.assign(k, { [m === "type" ? "taskType" : m]: i });
                     break;
                   }
                 }
               });
             });
-            const p = Array.from(y);
-            if (!(!p.length || p.length > V))
+            const d = Array.from(y);
+            if (!(!d.length || d.length > $))
               try {
-                await X();
-                const d = (await l(
+                await D();
+                const p = (await f(
                   x.endpoints.GetTasksList.initiate(
                     {
-                      projectName: t.projectName,
-                      taskIds: p,
-                      folderIds: t.folderIds,
-                      showComments: !!t.showComments
+                      projectName: e.projectName,
+                      taskIds: d,
+                      folderIds: e.folderIds,
+                      showComments: !!e.showComments
                     },
                     { forceRefetch: !0 }
                   )
                 ).unwrap()).tasks || [];
                 if (!F()) return;
-                const f = new Map(d.map((n) => [n.id, n]));
-                a((n) => {
-                  for (const u of d) {
+                const m = new Map(p.map((i) => [i.id, i]));
+                a((i) => {
+                  for (const u of p) {
                     let k = !1;
-                    for (const I of n.pages) {
-                      const m = I.tasks.findIndex((c) => c.id === u.id);
-                      if (m !== -1) {
-                        I.tasks[m] = u, k = !0;
+                    for (const I of i.pages) {
+                      const l = I.tasks.findIndex((c) => c.id === u.id);
+                      if (l !== -1) {
+                        I.tasks[l] = u, k = !0;
                         break;
                       }
                     }
-                    k || (n.pages.length ? n.pages[0].tasks.unshift(u) : n.pages.push({
+                    k || (i.pages.length ? i.pages[0].tasks.unshift(u) : i.pages.push({
                       tasks: [u],
                       pageInfo: {
                         startCursor: null,
@@ -488,10 +435,10 @@ const _ = 10, q = (e) => {
                       }
                     }));
                   }
-                  for (const u of p)
-                    if (!f.has(u))
-                      for (const k of n.pages) {
-                        const I = k.tasks.findIndex((m) => m.id === u);
+                  for (const u of d)
+                    if (!m.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);
                           break;
@@ -506,15 +453,15 @@ const _ = 10, q = (e) => {
         );
         let T;
         try {
-          await r, T = U(
+          await s, T = U(
             (F) => {
               a((b) => {
                 F.forEach((y) => {
                   if (y.summary.entityType === "task" && y.summary.thumbnailHash)
-                    for (const s of b.pages) {
-                      const p = s.tasks.findIndex((o) => o.id === y.summary.entityId);
-                      if (p > -1) {
-                        s.tasks[p].thumbnailHash = y.summary.thumbnailHash;
+                    for (const r of b.pages) {
+                      const d = r.tasks.findIndex((o) => o.id === y.summary.entityId);
+                      if (d > -1) {
+                        r.tasks[d].thumbnailHash = y.summary.thumbnailHash;
                         break;
                       }
                     }
@@ -529,17 +476,17 @@ const _ = 10, q = (e) => {
           w = L.subscribe("entity.task", h);
         } catch {
         }
-        await i, P.clear(), w && L.unsubscribe(w), T && T();
+        await n, P.clear(), w && L.unsubscribe(w), T && T();
       },
       keepUnusedDataFor: _
     }),
-    getGroupedTasksList: e.query({
+    getGroupedTasksList: t.query({
       queryFn: async ({
-        projectName: t,
-        groups: r,
-        search: i,
+        projectName: e,
+        groups: s,
+        search: n,
         folderFilter: a,
-        folderIds: l,
+        folderIds: f,
         desc: E,
         sortBy: w,
         groupCount: A,
@@ -548,52 +495,52 @@ const _ = 10, q = (e) => {
         try {
           let h = [];
           const F = /* @__PURE__ */ new Set(["folderType"]);
-          for (const s of r) {
-            const p = A || s.count || 500;
-            let o = s.filter, d = a;
-            if (s.filter)
+          for (const r of s) {
+            const d = A || r.count || 500;
+            let o = r.filter, p = a;
+            if (r.filter)
               try {
-                const u = JSON.parse(s.filter), k = u.conditions || [], I = k.filter((c) => !F.has(c.key)), m = k.filter((c) => F.has(c.key));
-                if (m.length > 0) {
+                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));
+                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 : [], ...m];
-                  d = JSON.stringify(
+                  const c = a ? JSON.parse(a) : null, g = [...c && Array.isArray(c.conditions) ? c.conditions : [], ...l];
+                  p = JSON.stringify(
                     c ? { ...c, conditions: g } : { conditions: g }
                   );
                 }
               } catch {
               }
-            const f = {
-              projectName: t,
+            const m = {
+              projectName: e,
               filter: o,
-              folderFilter: d,
-              search: i,
-              folderIds: l,
+              folderFilter: p,
+              search: n,
+              folderIds: f,
               sortBy: w,
               showComments: !!P,
               // @ts-expect-error - we know group does not exist on query variables but we need it for later
-              group: s.value
+              group: r.value
             };
-            E ? f.last = p : f.first = p;
-            const n = T.dispatch(
-              x.endpoints.GetTasksList.initiate(f, { forceRefetch: !0 })
+            E ? m.last = d : m.first = d;
+            const i = T.dispatch(
+              x.endpoints.GetTasksList.initiate(m, { forceRefetch: !0 })
             );
-            h.push(n);
+            h.push(i);
           }
           const b = await Promise.all(h), y = [];
-          for (const s of b) {
-            if (s.error) throw s.error;
-            const p = s.originalArgs?.group, o = s.data?.pageInfo?.hasNextPage || s.data?.pageInfo?.hasPreviousPage || !1, d = s.data?.tasks.map((f, n, u) => ({
-              ...f,
+          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,
               groups: [
                 {
-                  value: p,
-                  hasNextPage: n === u.length - 1 && o ? p : void 0
+                  value: d,
+                  hasNextPage: i === u.length - 1 && o ? d : void 0
                   // Only add hasNextPage to the last task in the group
                 }
               ]
             })) || [];
-            y.push(...d);
+            y.push(...p);
           }
           return {
             data: {
@@ -604,32 +551,32 @@ const _ = 10, q = (e) => {
           return console.error("Error in getGroupedTasksList queryFn:", h), { error: { status: "FETCH_ERROR", error: h.message } };
         }
       },
-      providesTags: (t, r, { projectName: i }) => N(t?.tasks, i),
+      providesTags: (e, s, { projectName: n }) => N(e?.tasks, n),
       keepUnusedDataFor: _
     })
   })
 }), {
-  useGetOverviewTasksByFoldersQuery: er,
-  useGetSearchFoldersQuery: rr,
-  useGetTasksListQuery: sr,
-  useGetTasksListInfiniteInfiniteQuery: or,
-  useLazyGetTasksByParentQuery: ar,
-  useGetGroupedTasksListQuery: ir,
-  useGetFolderColumnStatsQuery: nr,
-  useGetTaskColumnStatsQuery: cr
+  useGetOverviewTasksByFoldersQuery: st,
+  useGetSearchFoldersQuery: rt,
+  useGetTasksListQuery: ot,
+  useGetTasksListInfiniteInfiniteQuery: at,
+  useLazyGetTasksByParentQuery: nt,
+  useGetGroupedTasksListQuery: it,
+  useGetFolderColumnStatsQuery: ct,
+  useGetTaskColumnStatsQuery: dt
 } = W;
 export {
   G as TASKS_INFINITE_QUERY_COUNT,
   W as default,
-  tr as parseAllAttribs,
+  tt as parseAllAttribs,
   q as parseJSONField,
-  nr as useGetFolderColumnStatsQuery,
-  ir as useGetGroupedTasksListQuery,
-  er as useGetOverviewTasksByFoldersQuery,
-  rr as useGetSearchFoldersQuery,
-  cr as useGetTaskColumnStatsQuery,
-  or as useGetTasksListInfiniteInfiniteQuery,
-  sr as useGetTasksListQuery,
-  ar as useLazyGetTasksByParentQuery
+  ct as useGetFolderColumnStatsQuery,
+  it as useGetGroupedTasksListQuery,
+  st as useGetOverviewTasksByFoldersQuery,
+  rt as useGetSearchFoldersQuery,
+  dt as useGetTaskColumnStatsQuery,
+  at as useGetTasksListInfiniteInfiniteQuery,
+  ot as useGetTasksListQuery,
+  nt as useLazyGetTasksByParentQuery
 };
 //# sourceMappingURL=getOverview.es.js.map