@ynput/ayon-frontend-shared 0.4.0 → 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 $ } 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 V } 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";
@@ -38,76 +38,25 @@ 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 "../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 B, transformStatsError as U, normalizeFieldStats as j } from "../columnStats/columnStats.es.js";
-import { hasNewTargetFields as J } from "../columnStats/metricTargets.es.js";
-import "../columnStats/groupCounts.es.js";
-import "../config/getConfig.es.js";
-import "../config/updateConfig.es.js";
-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 { subscribeToThumbnailUpdates as U } from "../../../util/thumbnailWebsocket.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";
-const S = 10, L = (t) => {
+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 {
-    return JSON.parse(t);
+    const e = JSON.parse(t);
+    return e && typeof e == "object" && !Array.isArray(e) ? e : {};
   } catch {
     return {};
   }
-}, Xt = L, z = (t) => {
+}, tt = q, Y = (t) => {
   if (!t.project)
     return [];
   const e = [];
@@ -115,25 +64,25 @@ const S = 10, L = (t) => {
     e.push({
       ...s,
       folderId: s.folderId || "root",
-      attrib: L(s.allAttrib),
-      data: L(s.data),
+      attrib: q(s.allAttrib),
+      data: q(s.data),
       entityId: s.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) => ({
+}, 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: d
+    id: f
   })) : [];
   return [
-    ...o,
-    ...i,
+    ...n,
+    ...a,
     { type: "overviewTask", id: e },
     { type: "overviewTask", id: "LIST" }
   ];
-}, b = $.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
@@ -141,47 +90,47 @@ const S = 10, L = (t) => {
     GetTasksByParent: {
       transformResponse: (t) => ({
         pageInfo: t?.project?.tasks?.pageInfo ?? { hasNextPage: !1, endCursor: null },
-        tasks: z(t)
+        tasks: Y(t)
       }),
-      providesTags: (t, e, { parentIds: s, projectName: o }) => R(t?.tasks || [], o, s),
-      keepUnusedDataFor: S
+      providesTags: (t, e, { parentIds: s, projectName: n }) => N(t?.tasks || [], n, s),
+      keepUnusedDataFor: _
     },
     GetTasksList: {
       transformResponse: (t) => ({
-        tasks: z(t),
+        tasks: Y(t),
         pageInfo: t.project.tasks.pageInfo
       }),
-      providesTags: (t, e, { projectName: s }) => R(t?.tasks || [], s),
-      keepUnusedDataFor: S
+      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: (t) => j(t?.project?.folders?.fieldStats ?? []),
-      transformErrorResponse: (t) => U(t, "folder"),
+      transformResponse: (t) => V(t?.project?.folders?.fieldStats ?? []),
+      transformErrorResponse: (t) => z(t, "folder"),
       serializeQueryArgs: ({ queryArgs: { targets: t, ...e } }) => e,
-      merge: (t, e) => B(e, t),
-      forceRefetch: ({ currentArg: t, previousArg: e }) => J(t, 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: S
+      keepUnusedDataFor: _
     },
     GetTaskColumnStats: {
-      transformResponse: (t) => j(t?.project?.tasks?.fieldStats ?? []),
-      transformErrorResponse: (t) => U(t, "task"),
+      transformResponse: (t) => V(t?.project?.tasks?.fieldStats ?? []),
+      transformErrorResponse: (t) => z(t, "task"),
       serializeQueryArgs: ({ queryArgs: { targets: t, ...e } }) => e,
-      merge: (t, e) => B(e, t),
-      forceRefetch: ({ currentArg: t, previousArg: e }) => J(t, 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: S
+      keepUnusedDataFor: _
     }
   }
-}), Y = V.enhanceEndpoints({
+}), re = se.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({
+}), 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
@@ -189,55 +138,55 @@ const S = 10, L = (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: o, folderFilter: i, search: d, showComments: I }, { dispatch: F, getState: A, forced: v }) {
+      async queryFn({ projectName: e, parentIds: s, filter: n, folderFilter: a, search: f, 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: e, filter: n, folderFilter: a, search: f, showComments: E }, b = 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));
+          if (d.length === 0)
+            return { data: b };
+          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 ${m} (${n.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 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 < 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)
                 throw new Error(
-                  `Exceeded maximum tasks count limit ${p * f}.`
+                  `Exceeded maximum tasks count limit ${i * 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
+                    parentIds: R,
+                    filter: n,
+                    folderFilter: a,
+                    search: f,
+                    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, ee = Q?.tasks || [];
+              o.push(...ee);
+              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]));
+          oe(y, d);
+          const I = [...b, ...o], l = new Map(I.map((c) => [c.id, c]));
           return {
-            data: Array.from(h.values())
+            data: Array.from(l.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
@@ -248,135 +197,158 @@ const S = 10, L = (t) => {
       forceRefetch({ currentArg: e, previousArg: s }) {
         return JSON.stringify(e) !== JSON.stringify(s);
       },
-      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: (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)
+            ), 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) => {
+              const c = l.summary?.entityId;
+              if (!c || !i.has(c)) return;
+              const R = l.topic?.split(".")[2]?.replace("_changed", ""), g = B(
+                R,
+                l.summary,
+                J
+              );
+              g ? k.push({
+                taskId: c,
+                field: g.field,
+                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 });
+              });
             });
-          } 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 > $))
+              try {
+                await D();
+                const c = (await T(
+                  x.endpoints.GetTasksList.initiate(
+                    {
+                      projectName: e,
+                      taskIds: I,
+                      showComments: !!E
+                    },
+                    { forceRefetch: !0 }
+                  )
+                ).unwrap()).tasks || [];
+                if (!p()) 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 (l) {
+                console.error("Realtime overview batch update failed", l);
+              }
+          },
+          (o) => `${o.project ?? e}:${o.summary?.entityId}:${o.topic}`
+        );
+        let r;
         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, 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 p = async (m, f) => {
-            const T = f?.summary?.entityId, h = f?.summary?.parentId;
-            !T || !h || s.includes(h) && (w.add(T), n());
+          const o = (p, m) => {
+            const i = m?.summary?.entityId, u = m?.summary?.parentId;
+            !i || !u || y.add({ ...m, topic: p });
           };
-          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 d = M(e, n, a, f, E);
+        delete O[d], F && L.unsubscribe(F), r && r();
       },
-      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 }) {
+      async queryFn({ projectName: e, folderSearchRequest: s }, { dispatch: n }) {
         try {
-          return { data: (await o(
-            Y.endpoints.searchFolders.initiate({
+          return { data: (await n(
+            re.endpoints.searchFolders.initiate({
               projectName: e,
               folderSearchRequest: s
             })
           )).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: (e, s, { projectName: n }) => [{ type: "tasksFolder", id: n }],
+      keepUnusedDataFor: _
     }),
     // 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, o, i) => {
-          const d = e.pageInfo;
-          if (!(!(o.desc ? d.hasPreviousPage : d.hasNextPage) || !d.endCursor))
+        getNextPageParam: (e, s, n, a) => {
+          const f = e.pageInfo;
+          if (!(!(n.desc ? f.hasPreviousPage : f.hasNextPage) || !f.endCursor))
             return {
-              cursor: d.endCursor,
-              desc: o.desc
+              cursor: f.endCursor,
+              desc: n.desc
             };
         }
       },
-      queryFn: async ({ queryArg: e, pageParam: s }, o) => {
+      queryFn: async ({ queryArg: e, pageParam: s }, n) => {
         try {
           const {
-            projectName: i,
-            filter: d,
-            folderFilter: I,
-            search: F,
+            projectName: a,
+            filter: f,
+            folderFilter: E,
+            search: w,
             folderIds: A,
-            taskIds: v,
-            sortBy: g,
-            desc: k,
-            showComments: w,
-            includeFolderChildren: E
+            taskIds: P,
+            sortBy: T,
+            desc: h,
+            showComments: F,
+            includeFolderChildren: b
           } = e, { cursor: y } = s, r = {
-            projectName: i,
-            filter: d,
-            folderFilter: I,
-            search: F,
+            projectName: a,
+            filter: f,
+            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 ? (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 (n.error) throw n.error;
-          const u = {
+          if (d.error) throw d.error;
+          const o = {
             tasks: [],
             pageInfo: {
               hasNextPage: !1,
@@ -386,82 +358,110 @@ const S = 10, L = (t) => {
             }
           };
           return {
-            data: n.data || u
+            data: d.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: (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)
               )
-            ).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(), 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
+              );
+              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 === p);
+                  if (k) {
+                    Object.assign(k, { [m === "type" ? "taskType" : m]: i });
                     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 d = Array.from(y);
+            if (!(!d.length || d.length > $))
+              try {
+                await D();
+                const p = (await f(
+                  x.endpoints.GetTasksList.initiate(
+                    {
+                      projectName: e.projectName,
+                      taskIds: d,
+                      folderIds: e.folderIds,
+                      showComments: !!e.showComments
+                    },
+                    { forceRefetch: !0 }
+                  )
+                ).unwrap()).tasks || [];
+                if (!F()) return;
+                const m = new Map(p.map((i) => [i.id, i]));
+                a((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);
+                      if (l !== -1) {
+                        I.tasks[l] = u, k = !0;
+                        break;
+                      }
                     }
+                    k || (i.pages.length ? i.pages[0].tasks.unshift(u) : i.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 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;
+                        }
+                      }
+                });
+              } 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 s, T = U(
+            (F) => {
+              a((b) => {
+                F.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);
+                      if (d > -1) {
+                        r.tasks[d].thumbnailHash = y.summary.thumbnailHash;
                         break;
                       }
                     }
@@ -470,114 +470,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 n, P.clear(), w && L.unsubscribe(w), T && T();
       },
-      keepUnusedDataFor: S
+      keepUnusedDataFor: _
     }),
     getGroupedTasksList: t.query({
       queryFn: async ({
         projectName: e,
         groups: s,
-        search: o,
-        folderFilter: i,
-        folderIds: d,
-        desc: I,
-        sortBy: F,
+        search: n,
+        folderFilter: a,
+        folderIds: f,
+        desc: E,
+        sortBy: w,
         groupCount: A,
-        showComments: v
-      }, g) => {
+        showComments: P
+      }, T) => {
         try {
-          let k = [];
-          const w = /* @__PURE__ */ new Set(["folderType"]);
+          let h = [];
+          const F = /* @__PURE__ */ new Set(["folderType"]);
           for (const r of s) {
-            const n = A || r.count || 500;
-            let u = r.filter, c = i;
+            const d = A || r.count || 500;
+            let o = r.filter, p = a;
             if (r.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(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 : [], ...l];
+                  p = JSON.stringify(
+                    c ? { ...c, conditions: g } : { conditions: g }
                   );
                 }
               } catch {
               }
-            const l = {
+            const m = {
               projectName: e,
-              filter: u,
-              folderFilter: c,
-              search: o,
-              folderIds: d,
-              sortBy: F,
-              showComments: !!v,
+              filter: o,
+              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: r.value
             };
-            I ? l.last = n : l.first = n;
-            const p = g.dispatch(
-              b.endpoints.GetTasksList.initiate(l, { forceRefetch: !0 })
+            E ? m.last = d : m.first = d;
+            const i = T.dispatch(
+              x.endpoints.GetTasksList.initiate(m, { forceRefetch: !0 })
             );
-            k.push(p);
+            h.push(i);
           }
-          const E = await Promise.all(k), y = [];
-          for (const r of E) {
+          const b = await Promise.all(h), y = [];
+          for (const r of b) {
             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 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: n,
-                  hasNextPage: p === m.length - 1 && u ? n : 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(...c);
+            y.push(...p);
           }
           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: (e, s, { projectName: n }) => N(e?.tasks, n),
+      keepUnusedDataFor: _
     })
   })
 }), {
-  useGetOverviewTasksByFoldersQuery: $t,
-  useGetSearchFoldersQuery: Vt,
-  useGetTasksListQuery: Yt,
-  useGetTasksListInfiniteInfiniteQuery: Zt,
-  useLazyGetTasksByParentQuery: Wt,
-  useGetGroupedTasksListQuery: es,
-  useGetFolderColumnStatsQuery: ts,
-  useGetTaskColumnStatsQuery: ss
-} = K;
+  useGetOverviewTasksByFoldersQuery: st,
+  useGetSearchFoldersQuery: rt,
+  useGetTasksListQuery: ot,
+  useGetTasksListInfiniteInfiniteQuery: at,
+  useLazyGetTasksByParentQuery: nt,
+  useGetGroupedTasksListQuery: it,
+  useGetFolderColumnStatsQuery: ct,
+  useGetTaskColumnStatsQuery: dt
+} = 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,
+  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
 };
 //# sourceMappingURL=getOverview.es.js.map