@ynput/ayon-frontend-shared 0.3.31 → 0.3.33

package/dist/shared/src/api/queries/versions/getVersionsProducts.es.js

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as T } from "../../generated/graphql.es.js";
+import { api as A } from "../../generated/graphql.es.js";
 import "../../generated/graphqlLinks.es.js";
 import "../../generated/access.es.js";
 import "../../generated/actions.es.js";
@@ -38,84 +38,103 @@ import "../../generated/workfiles.es.js";
 import "../../generated/ynputCloud.es.js";
 import "../../generated/grouping.es.js";
 import "../../generated/views.es.js";
-import { provideTagsForProductsResult as k, transformProductsResponse as O, provideTagsForVersionsResult as x, transformVersionsResponse as w, parseGQLErrorMessage as b, provideTagsForProductsInfinite as Q, provideTagsForVersionsInfinite as q } from "./getVersionsProductsUtils.es.js";
+import { provideTagsForProductsResult as q, transformProductsResponse as O, provideTagsForVersionsResult as E, transformVersionsResponse as T, parseGQLErrorMessage as V, provideTagsForProductsInfinite as S, provideTagsForVersionsInfinite as B } from "./getVersionsProductsUtils.es.js";
 import "lodash";
 import "react-toastify";
 import "uuid";
-import I from "../../../util/pubsub.es.js";
-function G(y, e, i, a) {
-  for (let t = 0; t < y.length; t++) {
-    const s = e[i], l = y[t][i];
-    if (a ? s > l : s < l)
-      return t;
+import { subscribeToThumbnailUpdates as x } from "../../../util/thumbnailWebsocket.es.js";
+import P from "../../../util/pubsub.es.js";
+import { mergeFieldStats as G, normalizeFieldStats as w } from "../columnStats/columnStats.es.js";
+import { hasNewTargetFields as _ } from "../columnStats/metricTargets.es.js";
+function k(u, e, n, d) {
+  for (let c = 0; c < u.length; c++) {
+    const o = e[n], p = u[c][n];
+    if (d ? o > p : o < p)
+      return c;
   }
-  return y.length;
+  return u.length;
 }
-function N(y, e, i, a, t, s) {
-  for (const l of y) {
-    const c = l[a], n = c.findIndex((o) => o.id === e);
-    if (n !== -1) {
-      i ? c[n] = i : c.splice(n, 1);
+function C(u, e, n, d, c, o) {
+  for (const p of u) {
+    const l = p[d], f = l.findIndex((r) => r.id === e);
+    if (f !== -1) {
+      n ? l[f] = n : l.splice(f, 1);
       return;
     }
   }
-  if (i && y.length > 0) {
-    const l = y[0][a], c = G(l, i, t, s);
-    l.splice(c, 0, i);
+  if (n && u.length > 0) {
+    const p = u[0][d], l = k(p, n, c, o);
+    p.splice(l, 0, n);
   }
 }
-function A(y, e, i) {
-  const a = y.findIndex((t) => t.id === e);
-  return a !== -1 ? i ? (y[a] = i, { index: a, action: "updated" }) : (y.splice(a, 1), { index: a, action: "deleted" }) : i ? (y.push(i), { index: y.length - 1, action: "added" }) : { index: -1, action: "none" };
+function H(u, e, n) {
+  const d = u.findIndex((c) => c.id === e);
+  return d !== -1 ? n ? (u[d] = n, { index: d, action: "updated" }) : (u.splice(d, 1), { index: d, action: "deleted" }) : n ? (u.push(n), { index: u.length - 1, action: "added" }) : { index: -1, action: "none" };
 }
-const F = T.enhanceEndpoints({
+const b = A.enhanceEndpoints({
   endpoints: {
     // used by both stacked and non-stacked views
     GetVersions: {
-      transformResponse: w,
-      providesTags: x
+      transformResponse: T,
+      providesTags: E
     },
     // used by getVersionsByProducts only
     GetVersionsByProductId: {
-      transformResponse: w,
-      providesTags: x
+      transformResponse: T,
+      providesTags: E
     },
     // used by getProductsInfinite only
     GetProducts: {
       transformResponse: O,
-      providesTags: k
+      providesTags: q
+    },
+    // footer stats: `targets` excluded from cache key + responses merged,
+    // so column toggles reuse cache and only added targets refetch
+    GetProductsColumnStats: {
+      transformResponse: (u) => w(u?.project?.products?.fieldStats ?? []),
+      serializeQueryArgs: ({ queryArgs: { targets: u, ...e } }) => e,
+      merge: (u, e) => G(e, u),
+      forceRefetch: ({ currentArg: u, previousArg: e }) => _(u, e),
+      providesTags: (u, e, { projectName: n }) => [{ type: "productColumnStats", id: n }]
+    },
+    GetVersionsColumnStats: {
+      transformResponse: (u) => w(u?.project?.versions?.fieldStats ?? []),
+      serializeQueryArgs: ({ queryArgs: { targets: u, ...e } }) => e,
+      merge: (u, e) => G(e, u),
+      forceRefetch: ({ currentArg: u, previousArg: e }) => _(u, e),
+      providesTags: (u, e, { projectName: n }) => [{ type: "versionColumnStats", id: n }]
     }
   }
-}), V = 250, E = 1e3, j = 10, B = F.injectEndpoints({
-  endpoints: (y) => ({
+}), R = 250, j = 1e3, U = 10, M = b.injectEndpoints({
+  endpoints: (u) => ({
     // enhance GetVersions with an infinite query
-    getVersionsInfinite: y.infiniteQuery(
+    getVersionsInfinite: u.infiniteQuery(
       {
         infiniteQueryOptions: {
           initialPageParam: { cursor: "", desc: !1 },
           // Calculate the next page param based on current page response and params
-          getNextPageParam: (e, i, a, t) => {
-            const s = e.pageInfo;
-            if (!(!(a.desc ? s?.hasPreviousPage : s?.hasNextPage) || !s?.endCursor))
+          getNextPageParam: (e, n, d, c) => {
+            const o = e.pageInfo;
+            if (!(!(d.desc ? o?.hasPreviousPage : o?.hasNextPage) || !o?.endCursor))
               return {
-                cursor: s?.endCursor,
-                desc: a.desc
+                cursor: o?.endCursor,
+                desc: d.desc
               };
           }
         },
-        queryFn: async ({ queryArg: e, pageParam: i }, a) => {
+        queryFn: async ({ queryArg: e, pageParam: n }, d) => {
           try {
-            const { sortBy: t, desc: s, folderIds: l, ...c } = e, { cursor: n } = i, o = {
-              ...c
+            const { sortBy: c, desc: o, folderIds: p, ...l } = e, { cursor: f } = n, r = {
+              ...l
             };
-            t ? (o.sortBy = t, s ? (o.before = n || void 0, o.last = V) : (o.after = n || void 0, o.first = V)) : (o.after = n || void 0, o.first = V), l && l.length && (o.folderIds = l);
-            const r = await a.dispatch(
-              F.endpoints.GetVersions.initiate(o, {
+            c ? (r.sortBy = c, o ? (r.before = f || void 0, r.last = R) : (r.after = f || void 0, r.first = R)) : (r.after = f || void 0, r.first = R), p && p.length && (r.folderIds = p);
+            const t = await d.dispatch(
+              b.endpoints.GetVersions.initiate(r, {
                 forceRefetch: !0
               })
             );
-            if (r.error) throw r.error;
-            const u = {
+            if (t.error) throw t.error;
+            const s = {
               versions: [],
               pageInfo: {
                 hasNextPage: !1,
@@ -125,34 +144,51 @@ const F = T.enhanceEndpoints({
               }
             };
             return {
-              data: r.data || u
+              data: t.data || s
             };
-          } catch (t) {
-            return console.error("Error in getVersionsInfiniteQuery queryFn:", t), {
+          } catch (c) {
+            return console.error("Error in getVersionsInfiniteQuery queryFn:", c), {
               error: {
                 status: "FETCH_ERROR",
-                error: b(t.message)
+                error: V(c.message)
               }
             };
           }
         },
-        providesTags: q,
+        providesTags: B,
         // Subscribes to version entity changes and updates cache accordingly
         // Handles: create, update, delete operations
-        onCacheEntryAdded: async (e, { updateCachedData: i, cacheEntryRemoved: a, dispatch: t }) => {
-          const s = I.subscribe("entity.version", async (l, c) => {
+        onCacheEntryAdded: async (e, { updateCachedData: n, cacheEntryRemoved: d, dispatch: c }) => {
+          let o;
+          o = x(
+            (l) => {
+              const f = l.filter((r) => r.project === e.projectName);
+              f.length && n((r) => {
+                f.forEach((t) => {
+                  t.summary.entityType === "version" && r.pages.forEach((s) => {
+                    const i = s.versions.findIndex(
+                      (a) => a.id === t.summary.entityId
+                    );
+                    i !== -1 && (s.versions[i].thumbnailHash = t.summary.thumbnailHash || "");
+                  });
+                });
+              });
+            },
+            ["version"]
+          );
+          const p = P.subscribe("entity.version", async (l, f) => {
             try {
-              const n = c.summary?.entityId;
-              if (!n) return;
-              const o = await t(
-                F.endpoints.GetVersions.initiate(
+              const r = f.summary?.entityId;
+              if (!r) return;
+              const t = await c(
+                b.endpoints.GetVersions.initiate(
                   {
                     projectName: e.projectName,
                     versionFilter: e.versionFilter,
                     productFilter: e.productFilter,
                     taskFilter: e.taskFilter,
                     folderIds: e.folderIds?.length ? e.folderIds : void 0,
-                    versionIds: [n],
+                    versionIds: [r],
                     first: 1
                   },
                   {
@@ -160,13 +196,13 @@ const F = T.enhanceEndpoints({
                   }
                 )
               );
-              if (o.error) return;
-              i((r) => {
-                const u = o.data?.versions?.[0];
-                N(
-                  r.pages,
-                  n,
-                  u,
+              if (t.error) return;
+              n((s) => {
+                const i = t.data?.versions?.[0];
+                C(
+                  s.pages,
+                  r,
+                  i,
                   "versions",
                   e.sortBy || "createdAt",
                   e.desc || !1
@@ -175,82 +211,97 @@ const F = T.enhanceEndpoints({
             } catch {
             }
           });
-          await a, I.unsubscribe(s);
+          await d, P.unsubscribe(p), o && o();
         }
       }
     ),
     // custom query function that fetches versions by multiple parent ids -not infinite and gets 1000 versions max
-    getVersionsByProducts: y.query({
-      queryFn: async (e, { dispatch: i, forced: a }) => {
-        const { productIds: t = [], desc: s, ...l } = e, c = async (d, p) => {
-          const f = {
-            ...l,
-            productIds: [d]
+    getVersionsByProducts: u.query({
+      queryFn: async (e, { dispatch: n, forced: d }) => {
+        const { productIds: c = [], desc: o, ...p } = e, l = async (i, a) => {
+          const m = {
+            ...p,
+            productIds: [i]
           };
-          return s ? (p && (f.before = p), f.last = E) : (p && (f.after = p), f.first = E), i(
-            F.endpoints.GetVersionsByProductId.initiate(f, {
-              forceRefetch: a
+          return o ? (a && (m.before = a), m.last = j) : (a && (m.after = a), m.first = j), n(
+            b.endpoints.GetVersionsByProductId.initiate(m, {
+              forceRefetch: d
             })
           );
-        }, n = t.map((d) => c(d)), o = await Promise.allSettled(n), r = [], u = [];
-        for (let d = 0; d < o.length; d++) {
-          const p = o[d], f = t[d];
-          if (p.status === "rejected") {
-            console.error(`Error fetching versions for product ${f}:`, p.reason), u.push({ productId: f, error: b(p.reason) });
+        }, f = c.map((i) => l(i)), r = await Promise.allSettled(f), t = [], s = [];
+        for (let i = 0; i < r.length; i++) {
+          const a = r[i], m = c[i];
+          if (a.status === "rejected") {
+            console.error(`Error fetching versions for product ${m}:`, a.reason), s.push({ productId: m, error: V(a.reason) });
             continue;
           }
-          const v = p.value;
-          if (v.error) {
-            console.error(`Error fetching versions for product ${f}:`, v.error), u.push({
-              productId: f,
+          const y = a.value;
+          if (y.error) {
+            console.error(`Error fetching versions for product ${m}:`, y.error), s.push({
+              productId: m,
               // @ts-expect-error - message
-              error: b(v.error?.message || "Unknown error")
+              error: V(y.error?.message || "Unknown error")
             });
             continue;
           }
-          if (!v.data) continue;
-          r.push(...v.data.versions);
-          let h = v.data.pageInfo, m = 1;
-          for (; h && m < j; ) {
-            const R = s ? h.hasPreviousPage : h.hasNextPage, g = h.endCursor;
-            if (!R || !g) break;
-            const P = await c(f, g);
-            if (P.error) {
+          if (!y.data) continue;
+          t.push(...y.data.versions);
+          let h = y.data.pageInfo, v = 1;
+          for (; h && v < U; ) {
+            const I = o ? h.hasPreviousPage : h.hasNextPage, F = h.endCursor;
+            if (!I || !F) break;
+            const g = await l(m, F);
+            if (g.error) {
               console.error(
-                `Error fetching versions page ${m + 1} for product ${f}:`,
-                P.error
-              ), u.push({ productId: f, error: P.error });
+                `Error fetching versions page ${v + 1} for product ${m}:`,
+                g.error
+              ), s.push({ productId: m, error: g.error });
               break;
             }
-            if (!P.data) break;
-            r.push(...P.data.versions), h = P.data.pageInfo, m++;
+            if (!g.data) break;
+            t.push(...g.data.versions), h = g.data.pageInfo, v++;
           }
         }
-        return u.length > 0 && console.warn(
-          `Partial success: ${u.length} of ${t.length} products failed to fetch versions`,
-          u
+        return s.length > 0 && console.warn(
+          `Partial success: ${s.length} of ${c.length} products failed to fetch versions`,
+          s
         ), {
           data: {
-            versions: r,
+            versions: t,
             pageInfo: void 0,
             // pageInfo is undefined as we've flattened multiple queries
-            errors: u.length > 0 ? u : void 0
+            errors: s.length > 0 ? s : void 0
           }
         };
       },
       // Subscribes to version entity changes for expanded products
       // Only updates versions that belong to currently expanded products
-      onCacheEntryAdded: async (e, { updateCachedData: i, cacheEntryRemoved: a, dispatch: t }) => {
-        const s = I.subscribe("entity.version", async (l, c) => {
+      onCacheEntryAdded: async (e, { updateCachedData: n, cacheEntryRemoved: d, dispatch: c }) => {
+        let o;
+        o = x(
+          (l) => {
+            const f = l.filter((r) => r.project === e.projectName);
+            f.length && n((r) => {
+              f.forEach((t) => {
+                if (t.summary.entityType === "version") {
+                  const s = r.versions.findIndex((i) => i.id === t.summary.entityId);
+                  s !== -1 && (r.versions[s].thumbnailHash = t.summary.thumbnailHash || "");
+                }
+              });
+            });
+          },
+          ["version"]
+        );
+        const p = P.subscribe("entity.version", async (l, f) => {
           try {
-            const n = c.summary?.entityId, o = c.summary?.parentId;
-            if (!n || !o || !e.productIds.includes(o)) return;
-            const r = await t(
-              F.endpoints.GetVersions.initiate(
+            const r = f.summary?.entityId, t = f.summary?.parentId;
+            if (!r || !t || !e.productIds.includes(t)) return;
+            const s = await c(
+              b.endpoints.GetVersions.initiate(
                 {
                   projectName: e.projectName,
-                  productIds: [o],
-                  versionIds: [n],
+                  productIds: [t],
+                  versionIds: [r],
                   versionFilter: e.versionFilter,
                   taskFilter: e.taskFilter,
                   first: 1,
@@ -260,45 +311,45 @@ const F = T.enhanceEndpoints({
                 { forceRefetch: !0 }
               )
             );
-            if (r.error) return;
-            i((u) => {
-              const d = r.data?.versions?.[0];
-              A(u.versions, n, d);
+            if (s.error) return;
+            n((i) => {
+              const a = s.data?.versions?.[0];
+              H(i.versions, r, a);
             });
           } catch {
           }
         });
-        await a, I.unsubscribe(s);
+        await d, P.unsubscribe(p), o && o();
       },
-      providesTags: x
+      providesTags: E
     }),
     // enhance GetProducts with an infinite query
-    getProductsInfinite: y.infiniteQuery(
+    getProductsInfinite: u.infiniteQuery(
       {
         infiniteQueryOptions: {
           initialPageParam: { cursor: "", desc: !1 },
           // Calculate the next page param based on current page response and params
-          getNextPageParam: (e, i, a, t) => {
-            const s = e.pageInfo;
-            if (!(!(a.desc ? s?.hasPreviousPage : s?.hasNextPage) || !s?.endCursor))
+          getNextPageParam: (e, n, d, c) => {
+            const o = e.pageInfo;
+            if (!(!(d.desc ? o?.hasPreviousPage : o?.hasNextPage) || !o?.endCursor))
               return {
-                cursor: s?.endCursor,
-                desc: a.desc
+                cursor: o?.endCursor,
+                desc: d.desc
               };
           }
         },
-        queryFn: async ({ queryArg: e, pageParam: i }, a) => {
-          let t;
+        queryFn: async ({ queryArg: e, pageParam: n }, d) => {
+          let c;
           try {
-            const { sortBy: s, desc: l, folderIds: c, ...n } = e, { cursor: o } = i, r = {
-              ...n
+            const { sortBy: o, desc: p, folderIds: l, ...f } = e, { cursor: r } = n, t = {
+              ...f
             };
-            if (s ? (r.sortBy = s, l ? (r.before = o || void 0, r.last = V) : (r.after = o || void 0, r.first = V)) : (r.after = o || void 0, r.first = V), c && c.length && (r.folderIds = c), t = await a.dispatch(
-              F.endpoints.GetProducts.initiate(r, {
+            if (o ? (t.sortBy = o, p ? (t.before = r || void 0, t.last = R) : (t.after = r || void 0, t.first = R)) : (t.after = r || void 0, t.first = R), l && l.length && (t.folderIds = l), c = await d.dispatch(
+              b.endpoints.GetProducts.initiate(t, {
                 forceRefetch: !0
               })
-            ), t.error) throw t.error;
-            const u = {
+            ), c.error) throw c.error;
+            const s = {
               products: [],
               pageInfo: {
                 hasNextPage: !1,
@@ -308,217 +359,259 @@ const F = T.enhanceEndpoints({
               }
             };
             return {
-              data: t.data || u
+              data: c.data || s
             };
-          } catch (s) {
-            return console.error("Error in getProductsInfiniteQuery queryFn:", s), {
+          } catch (o) {
+            return console.error("Error in getProductsInfiniteQuery queryFn:", o), {
               error: {
                 status: "FETCH_ERROR",
-                error: b(s.message)
+                error: V(o.message)
               }
             };
           }
         },
-        providesTags: Q,
+        providesTags: S,
         // Subscribes to product entity changes and updates cache accordingly
         // Handles: create, update, delete operations
         // Often triggered together with version changes (new product + version)
-        onCacheEntryAdded: async (e, { updateCachedData: i, cacheEntryRemoved: a, dispatch: t }) => {
-          const s = async (n) => {
-            const o = {
+        onCacheEntryAdded: async (e, { updateCachedData: n, cacheEntryRemoved: d, dispatch: c }) => {
+          let o;
+          o = x(
+            (r) => {
+              const t = r.filter((s) => s.project === e.projectName);
+              t.length && n((s) => {
+                t.forEach((i) => {
+                  i.summary.entityType === "version" && s.pages.forEach((a) => {
+                    a.products.forEach((m) => {
+                      m.featuredVersion?.id === i.summary.entityId && (m.featuredVersion.thumbnailHash = i.summary.thumbnailHash || "");
+                    });
+                  });
+                });
+              });
+            },
+            ["version"]
+          );
+          const p = async (r) => {
+            const t = {
               projectName: e.projectName,
-              productIds: [n],
+              productIds: [r],
               productFilter: e.productFilter,
               versionFilter: e.versionFilter,
               taskFilter: e.taskFilter,
               folderIds: e.folderIds?.length ? e.folderIds : void 0,
               first: 1
-            }, r = await t(
-              F.endpoints.GetProducts.initiate(o, {
+            }, s = await c(
+              b.endpoints.GetProducts.initiate(t, {
                 forceRefetch: !0
               })
             );
-            r.error || i((u) => {
-              const d = r.data?.products?.[0];
-              N(
-                u.pages,
-                n,
-                d,
+            s.error || n((i) => {
+              const a = s.data?.products?.[0];
+              C(
+                i.pages,
+                r,
+                a,
                 "products",
                 e.sortBy || "createdAt",
                 e.desc || !1
               );
             });
-          }, l = I.subscribe(
+          }, l = P.subscribe(
             "entity.product",
-            async (n, o) => {
+            async (r, t) => {
               try {
-                const r = o.summary?.entityId;
-                if (!r) return;
-                await s(r);
+                const s = t.summary?.entityId;
+                if (!s) return;
+                await p(s);
               } catch {
               }
             }
-          ), c = I.subscribe(
+          ), f = P.subscribe(
             "entity.version",
-            async (n, o) => {
+            async (r, t) => {
               try {
-                const r = o.summary?.parentId;
-                if (!r) return;
-                let u = !1;
-                if (i((d) => {
-                  u = d.pages.some(
-                    (p) => p.products.some((f) => f.id === r)
+                const s = t.summary?.parentId;
+                if (!s) return;
+                let i = !1;
+                if (n((a) => {
+                  i = a.pages.some(
+                    (m) => m.products.some((y) => y.id === s)
                   );
-                }), !u) return;
-                await s(r);
+                }), !i) return;
+                await p(s);
               } catch {
               }
             }
           );
-          await a, I.unsubscribe(l), I.unsubscribe(c);
+          await d, P.unsubscribe(l), P.unsubscribe(f), o && o();
         }
       }
     ),
     // Grouped versions query - fetches versions for multiple group filters
-    getGroupedVersionsList: y.query({
+    getGroupedVersionsList: u.query({
       queryFn: async ({
         projectName: e,
-        groups: i,
-        groupFilterKey: a = "versionFilter",
-        versionFilter: t,
+        groups: n,
+        groupFilterKey: d = "versionFilter",
+        versionFilter: c,
         // most of the time overridden by group filters
-        productFilter: s,
-        taskFilter: l,
-        folderIds: c,
-        desc: n,
-        sortBy: o,
-        featuredOnly: r,
-        hasReviewables: u
-      }, d) => {
+        productFilter: o,
+        taskFilter: p,
+        folderIds: l,
+        desc: f,
+        sortBy: r,
+        featuredOnly: t,
+        hasReviewables: s
+      }, i) => {
         try {
-          const p = [];
-          for (const h of i) {
-            const m = h.count || 500, R = {
+          const a = [];
+          for (const h of n) {
+            const v = h.count || 500, I = {
               projectName: e,
               // base filters
-              productFilter: s,
-              taskFilter: l,
-              versionFilter: t,
+              productFilter: o,
+              taskFilter: p,
+              versionFilter: c,
               // specific group filter
-              [a]: h.filter,
-              folderIds: c?.length ? c : void 0,
-              sortBy: o,
-              featuredOnly: r,
-              hasReviewables: u,
+              [d]: h.filter,
+              folderIds: l?.length ? l : void 0,
+              sortBy: r,
+              featuredOnly: t,
+              hasReviewables: s,
               // @ts-expect-error - group param used later on
               group: h.value
             };
-            n ? R.last = m : R.first = m;
-            const g = d.dispatch(
-              F.endpoints.GetVersions.initiate(R, {
+            f ? I.last = v : I.first = v;
+            const F = i.dispatch(
+              b.endpoints.GetVersions.initiate(I, {
                 forceRefetch: !0
               })
             );
-            p.push(g);
+            a.push(F);
           }
-          const f = await Promise.all(p), v = [];
-          for (const h of f) {
+          const m = await Promise.all(a), y = [];
+          for (const h of m) {
             if (h.error) throw h.error;
-            const m = h.originalArgs?.group, R = h.data?.pageInfo?.hasNextPage || h.data?.pageInfo?.hasPreviousPage || !1, g = h.data?.versions.map((P, C, _) => ({
-              ...P,
+            const v = h.originalArgs?.group, I = h.data?.pageInfo?.hasNextPage || h.data?.pageInfo?.hasPreviousPage || !1, F = h.data?.versions.map((g, N, Q) => ({
+              ...g,
               groups: [
                 {
-                  value: m,
-                  hasNextPage: C === _.length - 1 && R ? m : void 0
+                  value: v,
+                  hasNextPage: N === Q.length - 1 && I ? v : void 0
                 }
               ]
             })) || [];
-            v.push(...g);
+            y.push(...F);
           }
           return {
             data: {
-              versions: v
+              versions: y
             }
           };
-        } catch (p) {
-          return console.error("Error in getGroupedVersionsList queryFn:", p), {
+        } catch (a) {
+          return console.error("Error in getGroupedVersionsList queryFn:", a), {
             error: {
               status: "FETCH_ERROR",
-              error: b(p.message)
+              error: V(a.message)
             }
           };
         }
       },
-      providesTags: x,
+      providesTags: E,
       // Subscribes to version entity changes and updates cache accordingly
       // Handles: create, update, delete operations for grouped versions view
-      onCacheEntryAdded: async (e, { updateCachedData: i, cacheEntryRemoved: a, dispatch: t }) => {
-        const s = I.subscribe("entity.version", async (l, c) => {
+      onCacheEntryAdded: async (e, { updateCachedData: n, cacheEntryRemoved: d, dispatch: c }) => {
+        let o;
+        o = x(
+          (l) => {
+            const f = l.filter((r) => r.project === e.projectName);
+            f.length && n((r) => {
+              f.forEach((t) => {
+                if (t.summary.entityType === "version") {
+                  const s = r.versions.findIndex((i) => i.id === t.summary.entityId);
+                  s !== -1 && (r.versions[s].thumbnailHash = t.summary.thumbnailHash || "");
+                }
+              });
+            });
+          },
+          ["version"]
+        );
+        const p = P.subscribe("entity.version", async (l, f) => {
           try {
-            const n = c.summary?.entityId;
-            if (!n) return;
-            const o = {
+            const r = f.summary?.entityId;
+            if (!r) return;
+            const t = {
               projectName: e.projectName,
               versionFilter: e.versionFilter,
               productFilter: e.productFilter,
               taskFilter: e.taskFilter,
               folderIds: e.folderIds?.length ? e.folderIds : void 0,
-              versionIds: [n],
+              versionIds: [r],
               first: 1,
               ...e.featuredOnly && { featuredOnly: e.featuredOnly },
               ...e.hasReviewables !== void 0 && { hasReviewables: e.hasReviewables }
-            }, r = [];
-            let u = null;
-            for (const d of e.groups) {
-              const f = (await t(
-                F.endpoints.GetVersions.initiate(
+            }, s = [];
+            let i = null;
+            for (const a of e.groups) {
+              const y = (await c(
+                b.endpoints.GetVersions.initiate(
                   {
-                    ...o,
-                    [e.groupFilterKey]: d.filter,
+                    ...t,
+                    [e.groupFilterKey]: a.filter,
                     // group-specific filter
-                    versionIds: [n]
+                    versionIds: [r]
                   },
                   { forceRefetch: !0 }
                   // Force fresh data to detect group membership changes
                 )
               )).data?.versions?.[0];
-              f && (r.push({ value: d.value, hasNextPage: void 0 }), u = f);
+              y && (s.push({ value: a.value, hasNextPage: void 0 }), i = y);
             }
-            i((d) => {
-              const p = d.versions.findIndex((v) => v.id === n), f = p !== -1;
-              if (r.length === 0)
-                f && d.versions.splice(p, 1);
-              else if (u)
-                if (f) {
-                  const v = d.versions[p].groups || [], h = v.map((g) => g.value).sort(), m = r.map((g) => g.value).sort();
-                  h.length !== m.length || h.some((g, P) => g !== m[P]) ? d.versions[p] = { ...u, groups: r } : d.versions[p] = { ...u, groups: v };
+            n((a) => {
+              const m = a.versions.findIndex((h) => h.id === r), y = m !== -1;
+              if (s.length === 0)
+                y && a.versions.splice(m, 1);
+              else if (i)
+                if (y) {
+                  const h = a.versions[m].groups || [], v = h.map((g) => g.value).sort(), I = s.map((g) => g.value).sort();
+                  v.length !== I.length || v.some((g, N) => g !== I[N]) ? a.versions[m] = { ...i, groups: s } : a.versions[m] = { ...i, groups: h };
                 } else {
-                  const v = { ...u, groups: r }, h = e.sortBy || "createdAt", m = G(d.versions, v, h, e.desc || !1);
-                  d.versions.splice(m, 0, v);
+                  const h = { ...i, groups: s }, v = e.sortBy || "createdAt", I = k(
+                    a.versions,
+                    h,
+                    v,
+                    e.desc || !1
+                  );
+                  a.versions.splice(I, 0, h);
                 }
             });
           } catch {
           }
         });
-        await a, I.unsubscribe(s);
+        await d, P.unsubscribe(p), o && o();
       }
     })
   })
-}), { useGetVersionsQuery: _e } = F, {
-  useGetVersionsInfiniteInfiniteQuery: Te,
-  useGetVersionsByProductsQuery: ke,
-  useGetProductsInfiniteInfiniteQuery: Oe,
-  useGetGroupedVersionsListQuery: Qe
-} = B;
+}), {
+  useGetVersionsQuery: Oe,
+  useGetProductsColumnStatsQuery: Se,
+  useGetVersionsColumnStatsQuery: Be
+} = b, {
+  useGetVersionsInfiniteInfiniteQuery: He,
+  useGetVersionsByProductsQuery: Ue,
+  useGetProductsInfiniteInfiniteQuery: Me,
+  useGetGroupedVersionsListQuery: $e
+} = M;
 export {
-  V as VP_INFINITE_QUERY_COUNT,
-  F as enhancedVersionsPageApi,
-  B as injectedVersionsPageApi,
-  Qe as useGetGroupedVersionsListQuery,
-  Oe as useGetProductsInfiniteQuery,
-  ke as useGetVersionsByProductsQuery,
-  Te as useGetVersionsInfiniteQuery,
-  _e as useGetVersionsQuery
+  R as VP_INFINITE_QUERY_COUNT,
+  b as enhancedVersionsPageApi,
+  M as injectedVersionsPageApi,
+  $e as useGetGroupedVersionsListQuery,
+  Se as useGetProductsColumnStatsQuery,
+  Me as useGetProductsInfiniteQuery,
+  Ue as useGetVersionsByProductsQuery,
+  Be as useGetVersionsColumnStatsQuery,
+  He as useGetVersionsInfiniteQuery,
+  Oe as useGetVersionsQuery
 };
 //# sourceMappingURL=getVersionsProducts.es.js.map