@ynput/ayon-frontend-shared 0.4.0 → 0.4.1

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

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as $ } from "../../generated/graphql.es.js";
+import { api as et } 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 V } from "../../generated/folders.es.js";
+import { api as rt } 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 x from "../../../util/pubsub.es.js";
+import L from "../../../util/pubsub.es.js";
 import "lodash";
 import "react-toastify";
 import "uuid";
-import { subscribeToThumbnailUpdates as M } from "../../../util/thumbnailWebsocket.es.js";
+import { subscribeToThumbnailUpdates as U } 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 B, transformStatsError as U, normalizeFieldStats as j } from "../columnStats/columnStats.es.js";
-import { hasNewTargetFields as J } from "../columnStats/metricTargets.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";
@@ -100,283 +100,308 @@ import "../views/getViews.es.js";
 import "../views/updateViews.es.js";
 import "../watchers/getWatchers.es.js";
 import "../uris/getUris.es.js";
-const S = 10, L = (t) => {
-  if (!t) return {};
+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 {};
   try {
-    return JSON.parse(t);
+    const t = JSON.parse(e);
+    return t && typeof t == "object" && !Array.isArray(t) ? t : {};
   } catch {
     return {};
   }
-}, Xt = L, z = (t) => {
-  if (!t.project)
+}, tr = q, Y = (e) => {
+  if (!e.project)
     return [];
-  const e = [];
-  for (const { node: s } of t.project.tasks.edges)
-    e.push({
-      ...s,
-      folderId: s.folderId || "root",
-      attrib: L(s.allAttrib),
-      data: L(s.data),
-      entityId: s.id,
+  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,
       entityType: "task",
       links: []
     });
-  return e;
-}, R = (t = [], e, s) => {
-  const o = t?.map((d) => ({ type: "overviewTask", id: d.id })) || [], i = s ? (Array.isArray(s) ? s : [s]).map((d) => ({
+  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) => ({
     type: "overviewTask",
-    id: d
+    id: l
   })) : [];
   return [
-    ...o,
     ...i,
-    { type: "overviewTask", id: e },
+    ...a,
+    { type: "overviewTask", id: t },
     { type: "overviewTask", id: "LIST" }
   ];
-}, b = $.enhanceEndpoints({
+}, x = et.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: (t) => ({
-        pageInfo: t?.project?.tasks?.pageInfo ?? { hasNextPage: !1, endCursor: null },
-        tasks: z(t)
+      transformResponse: (e) => ({
+        pageInfo: e?.project?.tasks?.pageInfo ?? { hasNextPage: !1, endCursor: null },
+        tasks: Y(e)
       }),
-      providesTags: (t, e, { parentIds: s, projectName: o }) => R(t?.tasks || [], o, s),
-      keepUnusedDataFor: S
+      providesTags: (e, t, { parentIds: r, projectName: i }) => N(e?.tasks || [], i, r),
+      keepUnusedDataFor: _
     },
     GetTasksList: {
-      transformResponse: (t) => ({
-        tasks: z(t),
-        pageInfo: t.project.tasks.pageInfo
+      transformResponse: (e) => ({
+        tasks: Y(e),
+        pageInfo: e.project.tasks.pageInfo
       }),
-      providesTags: (t, e, { projectName: s }) => R(t?.tasks || [], s),
-      keepUnusedDataFor: S
+      providesTags: (e, t, { projectName: r }) => N(e?.tasks || [], r),
+      keepUnusedDataFor: _
     },
     // footer stats: `targets` excluded from cache key + responses merged,
     // so column toggles reuse cache and only added targets refetch
     GetFolderColumnStats: {
-      transformResponse: (t) => j(t?.project?.folders?.fieldStats ?? []),
-      transformErrorResponse: (t) => U(t, "folder"),
-      serializeQueryArgs: ({ queryArgs: { targets: t, ...e } }) => e,
-      merge: (t, e) => B(e, t),
-      forceRefetch: ({ currentArg: t, previousArg: e }) => J(t, e),
-      providesTags: (t, e, { projectName: s }) => [{ type: "folderColumnStats", id: s }],
-      keepUnusedDataFor: S
+      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 }],
+      keepUnusedDataFor: _
     },
     GetTaskColumnStats: {
-      transformResponse: (t) => j(t?.project?.tasks?.fieldStats ?? []),
-      transformErrorResponse: (t) => U(t, "task"),
-      serializeQueryArgs: ({ queryArgs: { targets: t, ...e } }) => e,
-      merge: (t, e) => B(e, t),
-      forceRefetch: ({ currentArg: t, previousArg: e }) => J(t, e),
-      providesTags: (t, e, { projectName: s }) => [{ type: "taskColumnStats", id: s }],
-      keepUnusedDataFor: S
+      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 }],
+      keepUnusedDataFor: _
     }
   }
-}), Y = V.enhanceEndpoints({
+}), st = rt.enhanceEndpoints({
   endpoints: {
     searchFolders: {}
   }
-}), 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(), K = b.injectEndpoints({
-  endpoints: (t) => ({
+}), 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) => ({
     // 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: t.query({
-      async queryFn({ projectName: e, parentIds: s, filter: o, folderFilter: i, search: d, showComments: I }, { dispatch: F, getState: A, forced: v }) {
+    getOverviewTasksByFolders: e.query({
+      async queryFn({ projectName: t, parentIds: r, filter: i, folderFilter: a, search: l, showComments: E }, { dispatch: w, getState: A, forced: P }) {
         try {
-          const g = A(), k = { projectName: e, filter: o, folderFilter: i, search: d, showComments: I }, E = K.endpoints.getOverviewTasksByFolders.select(
-            k
-          )(g)?.data || [], y = D(e, o, i, d, I), r = W(y), n = v ? 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)
+          const T = A(), h = { projectName: t, filter: i, folderFilter: a, search: l, 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)
+            return { data: b };
+          const o = [], d = 100, f = 20, n = 10, u = 1e3, k = d * f;
+          if (p.length > u)
             throw new Error(
-              `Exceeded maximum folders count limit ${m} (${n.length}). Please reduce the number of expanded folders.`
+              `Exceeded maximum folders count limit ${u} (${p.length}). Please reduce the number of expanded folders.`
             );
-          for (let a = 0; a < n.length; a += c) {
-            const P = n.slice(a, a + c);
-            let C = !0, Q, N = 0;
-            for (; C && N < p; ) {
-              if (N++, N === p)
+          for (let c = 0; c < p.length; c += d) {
+            const R = p.slice(c, c + d);
+            let g = !0, S, v = 0;
+            for (; g && v < n; ) {
+              if (v++, v === n)
                 throw new Error(
-                  `Exceeded maximum tasks count limit ${p * f}.`
+                  `Exceeded maximum tasks count limit ${n * k}.`
                 );
-              const G = await F(
-                b.endpoints.GetTasksByParent.initiate(
+              const C = await w(
+                x.endpoints.GetTasksByParent.initiate(
                   {
-                    projectName: e,
-                    parentIds: P,
-                    filter: o,
-                    folderFilter: i,
-                    search: d,
-                    showComments: !!I,
-                    first: f,
-                    after: Q
+                    projectName: t,
+                    parentIds: R,
+                    filter: i,
+                    folderFilter: a,
+                    search: l,
+                    showComments: !!E,
+                    first: k,
+                    after: S
                   },
                   { forceRefetch: !0 }
                 )
               );
-              if (G.error) throw G.error;
-              const q = G.data, X = q?.tasks || [];
-              u.push(...X);
-              const H = q?.pageInfo;
-              C = H?.hasNextPage || !1, Q = H?.endCursor || void 0;
+              if (C.error) throw C.error;
+              const Q = C.data, tt = Q?.tasks || [];
+              o.push(...tt);
+              const j = Q?.pageInfo;
+              g = j?.hasNextPage || !1, S = j?.endCursor || void 0;
             }
           }
-          Z(y, n);
-          const T = [...E, ...u], h = new Map(T.map((a) => [a.id, a]));
+          ot(y, p);
+          const I = [...b, ...o], m = new Map(I.map((c) => [c.id, c]));
           return {
-            data: Array.from(h.values())
+            data: Array.from(m.values())
           };
-        } catch (g) {
-          return console.error(g), { error: { status: "FETCH_ERROR", error: g.message || g.data?.message || JSON.stringify(g) || "Unknown Fetch Error" } };
+        } 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: e, ...s } }) => ({
-        ...s
+      serializeQueryArgs: ({ queryArgs: { parentIds: t, ...r } }) => ({
+        ...r
       }),
       // Refetch when the page arg changes
-      forceRefetch({ currentArg: e, previousArg: s }) {
-        return JSON.stringify(e) !== JSON.stringify(s);
+      forceRefetch({ currentArg: t, previousArg: r }) {
+        return JSON.stringify(t) !== JSON.stringify(r);
       },
-      providesTags: (e, s, { parentIds: o, projectName: i }) => R(e, i, o),
-      async onCacheEntryAdded({ projectName: e, parentIds: s, filter: o, folderFilter: i, search: d, showComments: I }, { cacheDataLoaded: F, cacheEntryRemoved: A, updateCachedData: v, dispatch: g }) {
-        let k;
-        const w = /* @__PURE__ */ new Set(), E = 100, y = 500;
-        let r = !1;
-        const n = () => {
-          r || (r = !0, setTimeout(u, y));
-        }, u = async () => {
-          if (r = !1, !w.size) return;
-          const p = Array.from(w).slice(0, E);
-          p.forEach((m) => w.delete(m));
-          try {
-            const f = (await g(
-              b.endpoints.GetTasksList.initiate(
-                {
-                  projectName: e,
-                  taskIds: p,
-                  showComments: !!I
-                },
-                { forceRefetch: !0 }
-              )
-            ).unwrap()).tasks || [], T = new Map(f.map((h) => [h.id, h]));
-            v((h) => {
-              for (const a of f) {
-                const P = h.findIndex((C) => C.id === a.id);
-                P > -1 ? h[P] = a : h.push(a);
-              }
-              for (const a of p)
-                if (!T.has(a)) {
-                  const P = h.findIndex((C) => C.id === a);
-                  P > -1 && h.splice(P, 1);
-                }
+      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 }) {
+        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) || []
+            ), 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(
+                R,
+                m.summary,
+                z
+              );
+              g ? k.push({
+                taskId: c,
+                field: g.field,
+                value: g.value
+              }) : u.add(c);
+            }), k.length && P((m) => {
+              k.forEach(({ taskId: c, field: R, value: g }) => {
+                const S = m.find((v) => v.id === c);
+                S && Object.assign(S, { [R === "type" ? "taskType" : R]: g });
+              });
             });
-          } catch (m) {
-            console.error("Realtime overview batch update failed", m);
-          } finally {
-            w.size && n();
-          }
-        };
-        let c;
+            const I = Array.from(u);
+            if (!(!I.length || I.length > V))
+              try {
+                await X();
+                const c = (await T(
+                  x.endpoints.GetTasksList.initiate(
+                    {
+                      projectName: t,
+                      taskIds: I,
+                      showComments: !!E
+                    },
+                    { forceRefetch: !0 }
+                  )
+                ).unwrap()).tasks || [];
+                if (!d()) return;
+                const R = 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);
+                  }
+                  for (const S of I)
+                    if (!R.has(S)) {
+                      const v = g.findIndex((C) => C.id === S);
+                      v > -1 && g.splice(v, 1);
+                    }
+                });
+              } catch (m) {
+                console.error("Realtime overview batch update failed", m);
+              }
+          },
+          (o) => `${o.project ?? t}:${o.summary?.entityId}:${o.topic}`
+        );
+        let s;
         try {
-          await F, c = M(
-            (m) => {
-              v((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);
+          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);
                   }
                 });
               });
             },
             ["task"]
           );
-          const p = async (m, f) => {
-            const T = f?.summary?.entityId, h = f?.summary?.parentId;
-            !T || !h || s.includes(h) && (w.add(T), n());
+          const o = (d, f) => {
+            const n = f?.summary?.entityId, u = f?.summary?.parentId;
+            !n || !u || y.add({ ...f, topic: d });
           };
-          k = x.subscribe("entity.task", p);
+          F = L.subscribe("entity.task", o);
         } catch {
         }
-        await A;
-        const l = D(e, o, i, d, I);
-        delete _[l], k && x.unsubscribe(k), c && c();
+        await A, y.clear();
+        const p = M(t, i, a, l, E);
+        delete O[p], F && L.unsubscribe(F), s && s();
       },
-      keepUnusedDataFor: S
+      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: t.query({
-      async queryFn({ projectName: e, folderSearchRequest: s }, { dispatch: o }) {
+    getSearchFolders: e.query({
+      async queryFn({ projectName: t, folderSearchRequest: r }, { dispatch: i }) {
         try {
-          return { data: (await o(
-            Y.endpoints.searchFolders.initiate({
-              projectName: e,
-              folderSearchRequest: s
+          return { data: (await i(
+            st.endpoints.searchFolders.initiate({
+              projectName: t,
+              folderSearchRequest: r
             })
           )).data?.folderIds || [] };
-        } catch (i) {
-          return console.error(i), { error: { status: "FETCH_ERROR", error: i.message } };
+        } catch (a) {
+          return console.error(a), { error: { status: "FETCH_ERROR", error: a.message } };
         }
       },
-      providesTags: (e, s, { projectName: o }) => [{ type: "tasksFolder", id: o }],
-      keepUnusedDataFor: S
+      providesTags: (t, r, { projectName: i }) => [{ type: "tasksFolder", id: i }],
+      keepUnusedDataFor: _
     }),
     // Add new infinite query endpoint for tasks list
-    getTasksListInfinite: t.infiniteQuery({
+    getTasksListInfinite: e.infiniteQuery({
       infiniteQueryOptions: {
         initialPageParam: { cursor: "", desc: !1 },
         // Calculate the next page param based on current page response and params
-        getNextPageParam: (e, s, o, i) => {
-          const d = e.pageInfo;
-          if (!(!(o.desc ? d.hasPreviousPage : d.hasNextPage) || !d.endCursor))
+        getNextPageParam: (t, r, i, a) => {
+          const l = t.pageInfo;
+          if (!(!(i.desc ? l.hasPreviousPage : l.hasNextPage) || !l.endCursor))
             return {
-              cursor: d.endCursor,
-              desc: o.desc
+              cursor: l.endCursor,
+              desc: i.desc
             };
         }
       },
-      queryFn: async ({ queryArg: e, pageParam: s }, o) => {
+      queryFn: async ({ queryArg: t, pageParam: r }, i) => {
         try {
           const {
-            projectName: i,
-            filter: d,
-            folderFilter: I,
-            search: F,
+            projectName: a,
+            filter: l,
+            folderFilter: E,
+            search: w,
             folderIds: A,
-            taskIds: v,
-            sortBy: g,
-            desc: k,
-            showComments: w,
-            includeFolderChildren: E
-          } = e, { cursor: y } = s, r = {
-            projectName: i,
-            filter: d,
-            folderFilter: I,
-            search: F,
+            taskIds: P,
+            sortBy: T,
+            desc: h,
+            showComments: F,
+            includeFolderChildren: b
+          } = t, { cursor: y } = r, s = {
+            projectName: a,
+            filter: l,
+            folderFilter: E,
+            search: w,
             folderIds: A,
-            taskIds: v,
-            showComments: !!w,
-            includeFolderChildren: E !== !1
+            taskIds: P,
+            showComments: !!F,
+            includeFolderChildren: b !== !1
             // default to true
           };
-          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(
-            b.endpoints.GetTasksList.initiate(r, { forceRefetch: !0 })
+          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 })
           );
-          if (n.error) throw n.error;
-          const u = {
+          if (p.error) throw p.error;
+          const o = {
             tasks: [],
             pageInfo: {
               hasNextPage: !1,
@@ -386,82 +411,110 @@ const S = 10, L = (t) => {
             }
           };
           return {
-            data: n.data || u
+            data: p.data || o
           };
-        } catch (i) {
-          return console.error("Error in getTasksListInfinite queryFn:", i), { error: { status: "FETCH_ERROR", error: i.message } };
+        } catch (a) {
+          return console.error("Error in getTasksListInfinite queryFn:", a), { error: { status: "FETCH_ERROR", error: a.message } };
         }
       },
-      providesTags: (e, s, { projectName: o }) => R(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(), A = 100, v = 500;
-        let g = !1;
-        const k = () => {
-          g || (g = !0, setTimeout(w, v));
-        }, w = async () => {
-          if (g = !1, !F.size) return;
-          const y = Array.from(F).slice(0, A);
-          y.forEach((r) => F.delete(r));
-          try {
-            const n = (await d(
-              b.endpoints.GetTasksList.initiate(
-                {
-                  projectName: e.projectName,
-                  taskIds: y,
-                  folderIds: e.folderIds,
-                  showComments: !!e.showComments
-                },
-                { forceRefetch: !0 }
+      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 }) {
+        let w;
+        const P = D(
+          async (h, F) => {
+            const b = new Set(
+              (E().data?.pages || []).flatMap(
+                (o) => o.tasks.map((d) => d.id)
               )
-            ).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;
+            ), 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,
+                o.summary,
+                z
+              );
+              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 }) => {
+                for (const u of o.pages) {
+                  const k = u.tasks.find((I) => I.id === d);
+                  if (k) {
+                    Object.assign(k, { [f === "type" ? "taskType" : f]: n });
                     break;
                   }
                 }
-                p || (c.pages.length ? c.pages[0].tasks.unshift(l) : c.pages.push({
-                  tasks: [l],
-                  pageInfo: {
-                    startCursor: null,
-                    endCursor: null,
-                    hasNextPage: !1,
-                    hasPreviousPage: !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;
+              });
+            });
+            const p = Array.from(y);
+            if (!(!p.length || p.length > V))
+              try {
+                await X();
+                const d = (await l(
+                  x.endpoints.GetTasksList.initiate(
+                    {
+                      projectName: t.projectName,
+                      taskIds: p,
+                      folderIds: t.folderIds,
+                      showComments: !!t.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) {
+                    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;
+                        break;
+                      }
                     }
+                    k || (n.pages.length ? n.pages[0].tasks.unshift(u) : n.pages.push({
+                      tasks: [u],
+                      pageInfo: {
+                        startCursor: null,
+                        endCursor: null,
+                        hasNextPage: !1,
+                        hasPreviousPage: !1
+                      }
+                    }));
                   }
-            });
-          } catch (r) {
-            console.error("Realtime infinite tasks batch update failed", r);
-          } finally {
-            F.size && k();
-          }
-        };
-        let 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);
+                        if (I !== -1) {
+                          k.tasks.splice(I, 1);
+                          break;
+                        }
+                      }
+                });
+              } catch (o) {
+                console.error("Realtime infinite tasks batch update failed", o);
+              }
+          },
+          (h) => `${h.project}:${h.summary?.entityId}:${h.topic}`
+        );
+        let T;
         try {
-          await s, E = M(
-            (r) => {
-              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;
+          await r, 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;
                         break;
                       }
                     }
@@ -470,114 +523,113 @@ const S = 10, L = (t) => {
             },
             ["task"]
           );
-          const y = async (r, n) => {
-            const u = n?.summary?.entityId;
-            u && (F.add(u), k());
+          const h = (F, b) => {
+            b?.summary?.entityId && P.add({ ...b, topic: F });
           };
-          I = x.subscribe("entity.task", y);
+          w = L.subscribe("entity.task", h);
         } catch {
         }
-        await o, I && x.unsubscribe(I), E && E();
+        await i, P.clear(), w && L.unsubscribe(w), T && T();
       },
-      keepUnusedDataFor: S
+      keepUnusedDataFor: _
     }),
-    getGroupedTasksList: t.query({
+    getGroupedTasksList: e.query({
       queryFn: async ({
-        projectName: e,
-        groups: s,
-        search: o,
-        folderFilter: i,
-        folderIds: d,
-        desc: I,
-        sortBy: F,
+        projectName: t,
+        groups: r,
+        search: i,
+        folderFilter: a,
+        folderIds: l,
+        desc: E,
+        sortBy: w,
         groupCount: A,
-        showComments: v
-      }, g) => {
+        showComments: P
+      }, T) => {
         try {
-          let k = [];
-          const w = /* @__PURE__ */ new Set(["folderType"]);
-          for (const r of s) {
-            const n = A || r.count || 500;
-            let u = r.filter, c = i;
-            if (r.filter)
+          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)
               try {
-                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 }
+                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) {
+                  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(
+                    c ? { ...c, conditions: g } : { conditions: g }
                   );
                 }
               } catch {
               }
-            const l = {
-              projectName: e,
-              filter: u,
-              folderFilter: c,
-              search: o,
-              folderIds: d,
-              sortBy: F,
-              showComments: !!v,
+            const f = {
+              projectName: t,
+              filter: o,
+              folderFilter: d,
+              search: i,
+              folderIds: l,
+              sortBy: w,
+              showComments: !!P,
               // @ts-expect-error - we know group does not exist on query variables but we need it for later
-              group: r.value
+              group: s.value
             };
-            I ? l.last = n : l.first = n;
-            const p = g.dispatch(
-              b.endpoints.GetTasksList.initiate(l, { forceRefetch: !0 })
+            E ? f.last = p : f.first = p;
+            const n = T.dispatch(
+              x.endpoints.GetTasksList.initiate(f, { forceRefetch: !0 })
             );
-            k.push(p);
+            h.push(n);
           }
-          const E = await Promise.all(k), y = [];
-          for (const r of E) {
-            if (r.error) throw r.error;
-            const n = r.originalArgs?.group, u = r.data?.pageInfo?.hasNextPage || r.data?.pageInfo?.hasPreviousPage || !1, c = r.data?.tasks.map((l, p, m) => ({
-              ...l,
+          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,
               groups: [
                 {
-                  value: n,
-                  hasNextPage: p === m.length - 1 && u ? n : void 0
+                  value: p,
+                  hasNextPage: n === u.length - 1 && o ? p : void 0
                   // Only add hasNextPage to the last task in the group
                 }
               ]
             })) || [];
-            y.push(...c);
+            y.push(...d);
           }
           return {
             data: {
               tasks: y
             }
           };
-        } catch (k) {
-          return console.error("Error in getGroupedTasksList queryFn:", k), { error: { status: "FETCH_ERROR", error: k.message } };
+        } catch (h) {
+          return console.error("Error in getGroupedTasksList queryFn:", h), { error: { status: "FETCH_ERROR", error: h.message } };
         }
       },
-      providesTags: (e, s, { projectName: o }) => R(e?.tasks, o),
-      keepUnusedDataFor: S
+      providesTags: (t, r, { projectName: i }) => N(t?.tasks, i),
+      keepUnusedDataFor: _
     })
   })
 }), {
-  useGetOverviewTasksByFoldersQuery: $t,
-  useGetSearchFoldersQuery: Vt,
-  useGetTasksListQuery: Yt,
-  useGetTasksListInfiniteInfiniteQuery: Zt,
-  useLazyGetTasksByParentQuery: Wt,
-  useGetGroupedTasksListQuery: es,
-  useGetFolderColumnStatsQuery: ts,
-  useGetTaskColumnStatsQuery: ss
-} = K;
+  useGetOverviewTasksByFoldersQuery: er,
+  useGetSearchFoldersQuery: rr,
+  useGetTasksListQuery: sr,
+  useGetTasksListInfiniteInfiniteQuery: or,
+  useLazyGetTasksByParentQuery: ar,
+  useGetGroupedTasksListQuery: ir,
+  useGetFolderColumnStatsQuery: nr,
+  useGetTaskColumnStatsQuery: cr
+} = W;
 export {
-  O as TASKS_INFINITE_QUERY_COUNT,
-  K as default,
-  Xt as parseAllAttribs,
-  L as parseJSONField,
-  ts as useGetFolderColumnStatsQuery,
-  es as useGetGroupedTasksListQuery,
-  $t as useGetOverviewTasksByFoldersQuery,
-  Vt as useGetSearchFoldersQuery,
-  ss as useGetTaskColumnStatsQuery,
-  Zt as useGetTasksListInfiniteInfiniteQuery,
-  Yt as useGetTasksListQuery,
-  Wt as useLazyGetTasksByParentQuery
+  G as TASKS_INFINITE_QUERY_COUNT,
+  W as default,
+  tr 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
 };
 //# sourceMappingURL=getOverview.es.js.map