@ynput/ayon-frontend-shared 0.3.41 → 0.3.43

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

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as A } from "../../generated/graphql.es.js";
+import { api as O } from "../../generated/graphql.es.js";
 import "../../generated/graphqlLinks.es.js";
 import "../../generated/access.es.js";
 import "../../generated/actions.es.js";
@@ -38,98 +38,228 @@ import "../../generated/workfiles.es.js";
 import "../../generated/ynputCloud.es.js";
 import "../../generated/grouping.es.js";
 import "../../generated/views.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 { provideTagsForProductsResult as Q, transformProductsResponse as q, provideTagsForVersionsResult as N, transformVersionsResponse as k, parseGQLErrorMessage as A, provideTagsForProductsInfinite as H, provideTagsForVersionsInfinite as M } from "./getVersionsProductsUtils.es.js";
+import { parseAllAttribs as D } from "../overview/getOverview.es.js";
+import "../overview/updateOverview.es.js";
+import "../links/getEntityLinks.es.js";
+import P from "../../../util/pubsub.es.js";
 import "lodash";
 import "react-toastify";
 import "uuid";
-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;
+import { subscribeToThumbnailUpdates as R } 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 "../cloud/cloud.es.js";
+import { mergeFieldStats as B, transformStatsError as C, normalizeFieldStats as G } from "../columnStats/columnStats.es.js";
+import { hasNewTargetFields as S } from "../columnStats/metricTargets.es.js";
+import "../config/getConfig.es.js";
+import "../config/updateConfig.es.js";
+import "../entities/getEntity.es.js";
+import "../entities/getEntityPanel.es.js";
+import "../entities/updateEntity.es.js";
+import "../entityLists/getLists.es.js";
+import "../entityLists/updateLists.es.js";
+import "../entityLists/getListsAttributes.es.js";
+import "../entityLists/listItemsColumnStats.es.js";
+import "../entityLists/updateListsAttributes.es.js";
+import "../entityLists/listFolders.es.js";
+import "../folders/getFolders.es.js";
+import "../folders/getFolderDeleteInfo.es.js";
+import "../grouping/getGrouping.es.js";
+import "../links/updateLinks.es.js";
+import "../links/getLinks.es.js";
+import "../permissions/getPermissions.es.js";
+import "../products/createProduct.es.js";
+import "../products/getFolderProducts.es.js";
+import "../project/getProject.es.js";
+import "../project/updateProject.es.js";
+import "../projectFolders/projectFolders.es.js";
+import "../review/getReview.es.js";
+import "../review/updateReview.es.js";
+import "../share/share.es.js";
+import "../system/getSystem.es.js";
+import "../tasks/getTasks.es.js";
+import "../tasks/updateTasks.es.js";
+import "../teams/getTeams.es.js";
+import "../userDashboard/getUserDashboard.es.js";
+import "../users/getUsers.es.js";
+import "../users/updateUsers.es.js";
+import "../users/guests.es.js";
+import "./updateVersions.es.js";
+import "../views/getViews.es.js";
+import "../views/updateViews.es.js";
+import "../watchers/getWatchers.es.js";
+import "../uris/getUris.es.js";
+function w(m, e, u, y) {
+  for (let p = 0; p < m.length; p++) {
+    const d = e[u], v = m[p][u];
+    if (y ? d > v : d < v)
+      return p;
   }
-  return u.length;
+  return m.length;
 }
-function C(u, e, n, d, c, o) {
-  for (const p of u) {
-    const l = p[d], f = l.findIndex((r) => r.id === e);
+function $(m, e, u, y, p, d) {
+  for (const v of m) {
+    const l = v[y], f = l.findIndex((n) => n.id === e);
     if (f !== -1) {
-      n ? l[f] = n : l.splice(f, 1);
+      u ? l[f] = u : l.splice(f, 1);
       return;
     }
   }
-  if (n && u.length > 0) {
-    const p = u[0][d], l = k(p, n, c, o);
-    p.splice(l, 0, n);
+  if (u && m.length > 0) {
+    const v = m[0][y], l = w(v, u, p, d);
+    v.splice(l, 0, u);
   }
 }
-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 b = A.enhanceEndpoints({
+const F = O.enhanceEndpoints({
   endpoints: {
     // used by both stacked and non-stacked views
     GetVersions: {
-      transformResponse: T,
-      providesTags: E
+      transformResponse: k,
+      providesTags: N
     },
     // used by getVersionsByProducts only
     GetVersionsByProductId: {
-      transformResponse: T,
-      providesTags: E
+      transformResponse: k,
+      providesTags: N
     },
     // used by getProductsInfinite only
     GetProducts: {
-      transformResponse: O,
-      providesTags: q
+      transformResponse: q,
+      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 }]
+      transformResponse: (m) => G(m?.project?.products?.fieldStats ?? []),
+      transformErrorResponse: (m) => C(m, "product"),
+      serializeQueryArgs: ({ queryArgs: { targets: m, ...e } }) => e,
+      merge: (m, e) => B(e, m),
+      forceRefetch: ({ currentArg: m, previousArg: e }) => S(m, e),
+      providesTags: (m, e, { projectName: u }) => [{ type: "productColumnStats", id: u }]
     },
     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 }]
+      transformResponse: (m) => G(m?.project?.versions?.fieldStats ?? []),
+      transformErrorResponse: (m) => C(m, "version"),
+      serializeQueryArgs: ({ queryArgs: { targets: m, ...e } }) => e,
+      merge: (m, e) => B(e, m),
+      forceRefetch: ({ currentArg: m, previousArg: e }) => S(m, e),
+      providesTags: (m, e, { projectName: u }) => [{ type: "versionColumnStats", id: u }]
     }
   }
-}), R = 250, j = 1e3, U = 10, M = b.injectEndpoints({
-  endpoints: (u) => ({
+}), V = 250, j = 1e3, z = 10, L = 5e3, W = 1e3, U = 3e4, Y = 1500;
+function x(m, e, u) {
+  let y = [], p = null, d = /* @__PURE__ */ new Set(), v = null;
+  const l = async () => {
+    const n = [...y];
+    y = [], p = null;
+    const t = [], s = [], o = /* @__PURE__ */ new Set();
+    for (const { topic: r, message: c } of n) {
+      const a = c.summary?.entityId, h = c.summary?.parentId;
+      if (a) {
+        if (r === "entity.version.deleted")
+          t.push({ entityId: a, parentId: h });
+        else if (r.startsWith("entity.version.") && r.endsWith("_changed")) {
+          if (!u.checkVersionInCache(a, h)) continue;
+          const g = r.split(".")[2].split("_changed")[0];
+          if (g === "attrib") {
+            o.add(a);
+            continue;
+          }
+          const E = ["status", "tags"].includes(g), T = c.summary?.value;
+          if (!T || !E) {
+            d.add(a);
+            continue;
+          }
+          let _ = T;
+          g === "status" ? _ = String(T) : g === "tags" && (_ = Array.isArray(T) ? T : []), s.push({ entityId: a, field: g, value: _, parentId: h });
+        }
+      }
+    }
+    d.size > 0 && !v && (v = setTimeout(f, U));
+    const i = [];
+    if (o.size > 0 && e)
+      try {
+        await new Promise(
+          (a) => setTimeout(a, Math.random() * W)
+        );
+        const r = Array.from(o), c = await e(
+          F.endpoints.GetVersionsAttribs.initiate(
+            { projectName: m, versionIds: r },
+            { forceRefetch: !0 }
+          )
+        );
+        if (c.data?.project?.versions?.edges)
+          for (const a of c.data.project.versions.edges) {
+            const h = a.node;
+            h && i.push({
+              entityId: h.id,
+              allAttrib: h.allAttrib,
+              parsedAttrib: D(h.allAttrib)
+            });
+          }
+      } catch (r) {
+        console.error("Failed to fetch patched version attribs", r);
+      }
+    (t.length > 0 || s.length > 0 || i.length > 0) && u.onBatchUpdate({ deleted: t, patched: s, attribPatched: i });
+  }, f = async () => {
+    const n = Array.from(d);
+    if (d.clear(), v = null, !(n.length === 0 || !e))
+      try {
+        await new Promise(
+          (o) => setTimeout(o, Math.random() * Y)
+        );
+        const t = u.getBaseFilters?.() || {}, s = await e(
+          F.endpoints.GetVersions.initiate({
+            ...t,
+            projectName: m,
+            versionIds: n
+          })
+        );
+        s.data?.versions && u.onBatchUpdate({ fullUpdated: s.data.versions });
+      } catch (t) {
+        console.error("Failed to fetch full version data batch", t);
+      }
+  };
+  return (n, t) => {
+    if (t.project !== m) return;
+    const o = t.summary?.entityId;
+    o && (n === "entity.version.created" ? (d.add(o), v || (v = setTimeout(f, U))) : (y.push({ topic: n, message: t }), p && clearTimeout(p), p = setTimeout(l, L)));
+  };
+}
+const J = F.injectEndpoints({
+  endpoints: (m) => ({
     // enhance GetVersions with an infinite query
-    getVersionsInfinite: u.infiniteQuery(
+    getVersionsInfinite: m.infiniteQuery(
       {
         infiniteQueryOptions: {
           initialPageParam: { cursor: "", desc: !1 },
           // Calculate the next page param based on current page response and params
-          getNextPageParam: (e, n, d, c) => {
-            const o = e.pageInfo;
-            if (!(!(d.desc ? o?.hasPreviousPage : o?.hasNextPage) || !o?.endCursor))
+          getNextPageParam: (e, u, y, p) => {
+            const d = e.pageInfo;
+            if (!(!(y.desc ? d?.hasPreviousPage : d?.hasNextPage) || !d?.endCursor))
               return {
-                cursor: o?.endCursor,
-                desc: d.desc
+                cursor: d?.endCursor,
+                desc: y.desc
               };
           }
         },
-        queryFn: async ({ queryArg: e, pageParam: n }, d) => {
+        queryFn: async ({ queryArg: e, pageParam: u }, y) => {
           try {
-            const { sortBy: c, desc: o, folderIds: p, ...l } = e, { cursor: f } = n, r = {
+            const { sortBy: p, desc: d, folderIds: v, ...l } = e, { cursor: f } = u, n = {
               ...l
             };
-            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, {
+            p ? (n.sortBy = p, d ? (n.before = f || void 0, n.last = V) : (n.after = f || void 0, n.first = V)) : (n.after = f || void 0, n.first = V), v && v.length && (n.folderIds = v);
+            const t = await y.dispatch(
+              F.endpoints.GetVersions.initiate(n, {
                 forceRefetch: !0
               })
             );
@@ -146,124 +276,147 @@ const b = A.enhanceEndpoints({
             return {
               data: t.data || s
             };
-          } catch (c) {
-            return console.error("Error in getVersionsInfiniteQuery queryFn:", c), {
+          } catch (p) {
+            return console.error("Error in getVersionsInfiniteQuery queryFn:", p), {
               error: {
                 status: "FETCH_ERROR",
-                error: V(c.message)
+                error: A(p.message)
               }
             };
           }
         },
-        providesTags: B,
+        providesTags: M,
+        keepUnusedDataFor: 30,
         // Subscribes to version entity changes and updates cache accordingly
         // Handles: create, update, delete operations
-        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
+        onCacheEntryAdded: async (e, { getCacheEntry: u, updateCachedData: y, cacheEntryRemoved: p, dispatch: d }) => {
+          let v;
+          v = R(
+            (f) => {
+              const n = f.filter((t) => t.project === e.projectName);
+              n.length && y((t) => {
+                n.forEach((s) => {
+                  s.summary.entityType === "version" && t.pages.forEach((o) => {
+                    const i = o.versions.findIndex(
+                      (r) => r.id === s.summary.entityId
                     );
-                    i !== -1 && (s.versions[i].thumbnailHash = t.summary.thumbnailHash || "");
+                    i !== -1 && (o.versions[i].thumbnailHash = s.summary.thumbnailHash || "");
                   });
                 });
               });
             },
             ["version"]
           );
-          const p = P.subscribe("entity.version", async (l, f) => {
-            try {
-              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: [r],
-                    first: 1
-                  },
-                  {
-                    forceRefetch: !0
+          const l = P.subscribe(
+            "entity.version",
+            x(e.projectName, d, {
+              getBaseFilters: () => ({
+                versionFilter: e.versionFilter,
+                productFilter: e.productFilter,
+                taskFilter: e.taskFilter,
+                folderIds: e.folderIds?.length ? e.folderIds : void 0,
+                featuredOnly: e.featuredOnly,
+                hasReviewables: e.hasReviewables,
+                sortBy: e.sortBy
+              }),
+              checkVersionInCache: (f) => {
+                const n = u().data;
+                if (!n) return !1;
+                for (const t of n.pages || [])
+                  if (t.versions.some((s) => s.id === f)) return !0;
+                return !1;
+              },
+              onBatchUpdate: ({ deleted: f, patched: n, attribPatched: t, fullUpdated: s }) => {
+                y((o) => {
+                  for (const i of o?.pages || []) {
+                    if (f)
+                      for (const { entityId: r } of f) {
+                        const c = i.versions.findIndex((a) => a.id === r);
+                        c !== -1 && i.versions.splice(c, 1);
+                      }
+                    if (n)
+                      for (const { entityId: r, field: c, value: a } of n) {
+                        const h = i.versions.find((I) => I.id === r);
+                        h && (h[c] = a);
+                      }
+                    if (t)
+                      for (const { entityId: r, allAttrib: c, parsedAttrib: a } of t) {
+                        const h = i.versions.find((I) => I.id === r);
+                        h && (h.allAttrib = c, h.attrib = a);
+                      }
+                    if (s)
+                      for (const r of s) {
+                        const c = i.versions.findIndex((a) => a.id === r.id);
+                        if (c !== -1)
+                          i.versions[c] = r;
+                        else {
+                          const a = e.sortBy || "createdAt", h = w(
+                            i.versions,
+                            r,
+                            a,
+                            e.desc || !1
+                          );
+                          i === o.pages[0] && i.versions.splice(h, 0, r);
+                        }
+                      }
                   }
-                )
-              );
-              if (t.error) return;
-              n((s) => {
-                const i = t.data?.versions?.[0];
-                C(
-                  s.pages,
-                  r,
-                  i,
-                  "versions",
-                  e.sortBy || "createdAt",
-                  e.desc || !1
-                );
-              });
-            } catch {
-            }
-          });
-          await d, P.unsubscribe(p), o && o();
+                });
+              }
+            })
+          );
+          await p, P.unsubscribe(l), v && v();
         }
       }
     ),
     // custom query function that fetches versions by multiple parent ids -not infinite and gets 1000 versions max
-    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]
+    getVersionsByProducts: m.query({
+      queryFn: async (e, { dispatch: u, forced: y }) => {
+        const { productIds: p = [], desc: d, ...v } = e, l = async (o, i) => {
+          const r = {
+            ...v,
+            productIds: [o]
           };
-          return o ? (a && (m.before = a), m.last = j) : (a && (m.after = a), m.first = j), n(
-            b.endpoints.GetVersionsByProductId.initiate(m, {
-              forceRefetch: d
+          return d ? (i && (r.before = i), r.last = j) : (i && (r.after = i), r.first = j), u(
+            F.endpoints.GetVersionsByProductId.initiate(r, {
+              forceRefetch: y
             })
           );
-        }, 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) });
+        }, f = p.map((o) => l(o)), n = await Promise.allSettled(f), t = [], s = [];
+        for (let o = 0; o < n.length; o++) {
+          const i = n[o], r = p[o];
+          if (i.status === "rejected") {
+            console.error(`Error fetching versions for product ${r}:`, i.reason), s.push({ productId: r, error: A(i.reason) });
             continue;
           }
-          const y = a.value;
-          if (y.error) {
-            console.error(`Error fetching versions for product ${m}:`, y.error), s.push({
-              productId: m,
+          const c = i.value;
+          if (c.error) {
+            console.error(`Error fetching versions for product ${r}:`, c.error), s.push({
+              productId: r,
               // @ts-expect-error - message
-              error: V(y.error?.message || "Unknown error")
+              error: A(c.error?.message || "Unknown error")
             });
             continue;
           }
-          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) {
+          if (!c.data) continue;
+          t.push(...c.data.versions);
+          let a = c.data.pageInfo, h = 1;
+          for (; a && h < z; ) {
+            const I = d ? a.hasPreviousPage : a.hasNextPage, g = a.endCursor;
+            if (!I || !g) break;
+            const b = await l(r, g);
+            if (b.error) {
               console.error(
-                `Error fetching versions page ${v + 1} for product ${m}:`,
-                g.error
-              ), s.push({ productId: m, error: g.error });
+                `Error fetching versions page ${h + 1} for product ${r}:`,
+                b.error
+              ), s.push({ productId: r, error: b.error });
               break;
             }
-            if (!g.data) break;
-            t.push(...g.data.versions), h = g.data.pageInfo, v++;
+            if (!b.data) break;
+            t.push(...b.data.versions), a = b.data.pageInfo, h++;
           }
         }
         return s.length > 0 && console.warn(
-          `Partial success: ${s.length} of ${c.length} products failed to fetch versions`,
+          `Partial success: ${s.length} of ${p.length} products failed to fetch versions`,
           s
         ), {
           data: {
@@ -274,81 +427,106 @@ const b = A.enhanceEndpoints({
           }
         };
       },
+      keepUnusedDataFor: 30,
       // Subscribes to version entity changes for expanded products
       // Only updates versions that belong to currently expanded products
-      onCacheEntryAdded: async (e, { updateCachedData: n, cacheEntryRemoved: d, dispatch: c }) => {
-        let o;
-        o = x(
+      onCacheEntryAdded: async (e, { updateCachedData: u, cacheEntryRemoved: y, dispatch: p }) => {
+        let d;
+        d = R(
           (l) => {
-            const f = l.filter((r) => r.project === e.projectName);
-            f.length && n((r) => {
+            const f = l.filter((n) => n.project === e.projectName);
+            f.length && u((n) => {
               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 || "");
+                  const s = n.versions.findIndex((o) => o.id === t.summary.entityId);
+                  s !== -1 && (n.versions[s].thumbnailHash = t.summary.thumbnailHash || "");
                 }
               });
             });
           },
           ["version"]
         );
-        const p = P.subscribe("entity.version", async (l, f) => {
-          try {
-            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: [t],
-                  versionIds: [r],
-                  versionFilter: e.versionFilter,
-                  taskFilter: e.taskFilter,
-                  first: 1,
-                  ...e.featuredOnly && { featuredOnly: e.featuredOnly },
-                  ...e.hasReviewables !== void 0 && { hasReviewables: e.hasReviewables }
-                },
-                { forceRefetch: !0 }
-              )
-            );
-            if (s.error) return;
-            n((i) => {
-              const a = s.data?.versions?.[0];
-              H(i.versions, r, a);
-            });
-          } catch {
-          }
-        });
-        await d, P.unsubscribe(p), o && o();
+        const v = P.subscribe(
+          "entity.version",
+          x(e.projectName, p, {
+            getBaseFilters: () => ({
+              versionFilter: e.versionFilter,
+              taskFilter: e.taskFilter,
+              productIds: e.productIds
+            }),
+            checkVersionInCache: (l, f) => {
+              if (!f || !e.productIds.includes(f)) return !1;
+              let n = !1;
+              return u((t) => {
+                n = t.versions.some((s) => s.id === l);
+              }), n;
+            },
+            onBatchUpdate: ({ deleted: l, patched: f, attribPatched: n, fullUpdated: t }) => {
+              u((s) => {
+                if (l)
+                  for (const { entityId: o } of l) {
+                    const i = s.versions.findIndex((r) => r.id === o);
+                    i !== -1 && s.versions.splice(i, 1);
+                  }
+                if (f)
+                  for (const { entityId: o, field: i, value: r } of f) {
+                    const c = s.versions.find((a) => a.id === o);
+                    c && (c[i] = r);
+                  }
+                if (n)
+                  for (const { entityId: o, allAttrib: i, parsedAttrib: r } of n) {
+                    const c = s.versions.find((a) => a.id === o);
+                    c && (c.allAttrib = i, c.attrib = r);
+                  }
+                if (t)
+                  for (const o of t) {
+                    const i = s.versions.findIndex((r) => r.id === o.id);
+                    if (i !== -1)
+                      s.versions[i] = o;
+                    else {
+                      const r = e.sortBy || "createdAt", c = w(
+                        s.versions,
+                        o,
+                        r,
+                        e.desc || !1
+                      );
+                      s.versions.splice(c, 0, o);
+                    }
+                  }
+              });
+            }
+          })
+        );
+        await y, P.unsubscribe(v), d && d();
       },
-      providesTags: E
+      providesTags: N
     }),
     // enhance GetProducts with an infinite query
-    getProductsInfinite: u.infiniteQuery(
+    getProductsInfinite: m.infiniteQuery(
       {
         infiniteQueryOptions: {
           initialPageParam: { cursor: "", desc: !1 },
           // Calculate the next page param based on current page response and params
-          getNextPageParam: (e, n, d, c) => {
-            const o = e.pageInfo;
-            if (!(!(d.desc ? o?.hasPreviousPage : o?.hasNextPage) || !o?.endCursor))
+          getNextPageParam: (e, u, y, p) => {
+            const d = e.pageInfo;
+            if (!(!(y.desc ? d?.hasPreviousPage : d?.hasNextPage) || !d?.endCursor))
               return {
-                cursor: o?.endCursor,
-                desc: d.desc
+                cursor: d?.endCursor,
+                desc: y.desc
               };
           }
         },
-        queryFn: async ({ queryArg: e, pageParam: n }, d) => {
-          let c;
+        queryFn: async ({ queryArg: e, pageParam: u }, y) => {
+          let p;
           try {
-            const { sortBy: o, desc: p, folderIds: l, ...f } = e, { cursor: r } = n, t = {
+            const { sortBy: d, desc: v, folderIds: l, ...f } = e, { cursor: n } = u, t = {
               ...f
             };
-            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, {
+            if (d ? (t.sortBy = d, v ? (t.before = n || void 0, t.last = V) : (t.after = n || void 0, t.first = V)) : (t.after = n || void 0, t.first = V), l && l.length && (t.folderIds = l), p = await y.dispatch(
+              F.endpoints.GetProducts.initiate(t, {
                 forceRefetch: !0
               })
-            ), c.error) throw c.error;
+            ), p.error) throw p.error;
             const s = {
               products: [],
               pageInfo: {
@@ -359,31 +537,32 @@ const b = A.enhanceEndpoints({
               }
             };
             return {
-              data: c.data || s
+              data: p.data || s
             };
-          } catch (o) {
-            return console.error("Error in getProductsInfiniteQuery queryFn:", o), {
+          } catch (d) {
+            return console.error("Error in getProductsInfiniteQuery queryFn:", d), {
               error: {
                 status: "FETCH_ERROR",
-                error: V(o.message)
+                error: A(d.message)
               }
             };
           }
         },
-        providesTags: S,
+        providesTags: H,
+        keepUnusedDataFor: 30,
         // 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: 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 || "");
+        onCacheEntryAdded: async (e, { updateCachedData: u, cacheEntryRemoved: y, dispatch: p }) => {
+          let d;
+          d = R(
+            (t) => {
+              const s = t.filter((o) => o.project === e.projectName);
+              s.length && u((o) => {
+                s.forEach((i) => {
+                  i.summary.entityType === "version" && o.pages.forEach((r) => {
+                    r.products.forEach((c) => {
+                      c.featuredVersion?.id === i.summary.entityId && (c.featuredVersion.thumbnailHash = i.summary.thumbnailHash || "");
                     });
                   });
                 });
@@ -391,26 +570,26 @@ const b = A.enhanceEndpoints({
             },
             ["version"]
           );
-          const p = async (r) => {
-            const t = {
+          const v = async (t) => {
+            const s = {
               projectName: e.projectName,
-              productIds: [r],
+              productIds: [t],
               productFilter: e.productFilter,
               versionFilter: e.versionFilter,
               taskFilter: e.taskFilter,
               folderIds: e.folderIds?.length ? e.folderIds : void 0,
               first: 1
-            }, s = await c(
-              b.endpoints.GetProducts.initiate(t, {
+            }, o = await p(
+              F.endpoints.GetProducts.initiate(s, {
                 forceRefetch: !0
               })
             );
-            s.error || n((i) => {
-              const a = s.data?.products?.[0];
-              C(
+            o.error || u((i) => {
+              const r = o.data?.products?.[0];
+              $(
                 i.pages,
+                t,
                 r,
-                a,
                 "products",
                 e.sortBy || "createdAt",
                 e.desc || !1
@@ -418,200 +597,228 @@ const b = A.enhanceEndpoints({
             });
           }, l = P.subscribe(
             "entity.product",
-            async (r, t) => {
+            async (t, s) => {
               try {
-                const s = t.summary?.entityId;
-                if (!s) return;
-                await p(s);
+                const o = s.summary?.entityId;
+                if (!o) return;
+                let i = !1;
+                if (u((r) => {
+                  i = r.pages.some(
+                    (c) => c.products.some((a) => a.id === o)
+                  );
+                }), !i && t !== "entity.product.created") return;
+                await v(o);
               } catch {
               }
             }
           ), f = P.subscribe(
             "entity.version",
-            async (r, t) => {
-              try {
-                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)
+            x(e.projectName, p, {
+              getBaseFilters: () => ({
+                versionFilter: e.versionFilter,
+                productFilter: e.productFilter,
+                taskFilter: e.taskFilter,
+                folderIds: e.folderIds?.length ? e.folderIds : void 0
+              }),
+              checkVersionInCache: (t, s) => {
+                let o = !1;
+                return u((i) => {
+                  o = i.pages.some(
+                    (r) => r.products.some(
+                      (c) => c.id === s && c.featuredVersion?.id === t
+                    )
                   );
-                }), !i) return;
-                await p(s);
-              } catch {
+                }), o;
+              },
+              onBatchUpdate: ({ deleted: t, patched: s, attribPatched: o, fullUpdated: i }) => {
+                u((r) => {
+                  for (const c of r?.pages || [])
+                    for (const a of c.products) {
+                      const h = a.featuredVersion?.id;
+                      if (h) {
+                        if (t && t.some((I) => I.entityId === h && I.parentId === a.id) && n.add(a.id), s)
+                          for (const { entityId: I, field: g, value: b, parentId: E } of s)
+                            a.id === E && h === I && a.featuredVersion && (a.featuredVersion[g] = b);
+                        if (o)
+                          for (const { entityId: I, allAttrib: g, parsedAttrib: b } of o)
+                            h === I && a.featuredVersion && (a.featuredVersion.allAttrib = g, a.featuredVersion.attrib = b);
+                        if (i)
+                          for (const I of i)
+                            h === I.id && a.featuredVersion && (a.featuredVersion = I);
+                      }
+                    }
+                });
+                for (const r of n)
+                  v(r);
+                n.clear();
               }
-            }
-          );
-          await d, P.unsubscribe(l), P.unsubscribe(f), o && o();
+            })
+          ), n = /* @__PURE__ */ new Set();
+          await y, P.unsubscribe(l), P.unsubscribe(f), d && d();
         }
       }
     ),
     // Grouped versions query - fetches versions for multiple group filters
-    getGroupedVersionsList: u.query({
+    getGroupedVersionsList: m.query({
       queryFn: async ({
         projectName: e,
-        groups: n,
-        groupFilterKey: d = "versionFilter",
-        versionFilter: c,
+        groups: u,
+        groupFilterKey: y = "versionFilter",
+        versionFilter: p,
         // most of the time overridden by group filters
-        productFilter: o,
-        taskFilter: p,
+        productFilter: d,
+        taskFilter: v,
         folderIds: l,
         desc: f,
-        sortBy: r,
+        sortBy: n,
         featuredOnly: t,
         hasReviewables: s
-      }, i) => {
+      }, o) => {
         try {
-          const a = [];
-          for (const h of n) {
-            const v = h.count || 500, I = {
+          const i = [];
+          for (const a of u) {
+            const h = a.count || 500, I = {
               projectName: e,
               // base filters
-              productFilter: o,
-              taskFilter: p,
-              versionFilter: c,
+              productFilter: d,
+              taskFilter: v,
+              versionFilter: p,
               // specific group filter
-              [d]: h.filter,
+              [y]: a.filter,
               folderIds: l?.length ? l : void 0,
-              sortBy: r,
+              sortBy: n,
               featuredOnly: t,
               hasReviewables: s,
               // @ts-expect-error - group param used later on
-              group: h.value
+              group: a.value
             };
-            f ? I.last = v : I.first = v;
-            const F = i.dispatch(
-              b.endpoints.GetVersions.initiate(I, {
+            f ? I.last = h : I.first = h;
+            const g = o.dispatch(
+              F.endpoints.GetVersions.initiate(I, {
                 forceRefetch: !0
               })
             );
-            a.push(F);
+            i.push(g);
           }
-          const m = await Promise.all(a), y = [];
-          for (const h of m) {
-            if (h.error) throw h.error;
-            const v = h.originalArgs?.group, I = h.data?.pageInfo?.hasNextPage || h.data?.pageInfo?.hasPreviousPage || !1, F = h.data?.versions.map((g, N, Q) => ({
-              ...g,
+          const r = await Promise.all(i), c = [];
+          for (const a of r) {
+            if (a.error) throw a.error;
+            const h = a.originalArgs?.group, I = a.data?.pageInfo?.hasNextPage || a.data?.pageInfo?.hasPreviousPage || !1, g = a.data?.versions.map((b, E, T) => ({
+              ...b,
               groups: [
                 {
-                  value: v,
-                  hasNextPage: N === Q.length - 1 && I ? v : void 0
+                  value: h,
+                  hasNextPage: E === T.length - 1 && I ? h : void 0
                 }
               ]
             })) || [];
-            y.push(...F);
+            c.push(...g);
           }
           return {
             data: {
-              versions: y
+              versions: c
             }
           };
-        } catch (a) {
-          return console.error("Error in getGroupedVersionsList queryFn:", a), {
+        } catch (i) {
+          return console.error("Error in getGroupedVersionsList queryFn:", i), {
             error: {
               status: "FETCH_ERROR",
-              error: V(a.message)
+              error: A(i.message)
             }
           };
         }
       },
-      providesTags: E,
+      providesTags: N,
+      keepUnusedDataFor: 30,
       // Subscribes to version entity changes and updates cache accordingly
       // Handles: create, update, delete operations for grouped versions view
-      onCacheEntryAdded: async (e, { updateCachedData: n, cacheEntryRemoved: d, dispatch: c }) => {
-        let o;
-        o = x(
+      onCacheEntryAdded: async (e, { updateCachedData: u, cacheEntryRemoved: y, dispatch: p }) => {
+        let d;
+        d = R(
           (l) => {
-            const f = l.filter((r) => r.project === e.projectName);
-            f.length && n((r) => {
+            const f = l.filter((n) => n.project === e.projectName);
+            f.length && u((n) => {
               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 || "");
+                  const s = n.versions.findIndex((o) => o.id === t.summary.entityId);
+                  s !== -1 && (n.versions[s].thumbnailHash = t.summary.thumbnailHash || "");
                 }
               });
             });
           },
           ["version"]
         );
-        const p = P.subscribe("entity.version", async (l, f) => {
-          try {
-            const r = f.summary?.entityId;
-            if (!r) return;
-            const t = {
-              projectName: e.projectName,
+        const v = P.subscribe(
+          "entity.version",
+          x(e.projectName, p, {
+            getBaseFilters: () => ({
               versionFilter: e.versionFilter,
               productFilter: e.productFilter,
               taskFilter: e.taskFilter,
               folderIds: e.folderIds?.length ? e.folderIds : void 0,
-              versionIds: [r],
-              first: 1,
-              ...e.featuredOnly && { featuredOnly: e.featuredOnly },
-              ...e.hasReviewables !== void 0 && { hasReviewables: e.hasReviewables }
-            }, s = [];
-            let i = null;
-            for (const a of e.groups) {
-              const y = (await c(
-                b.endpoints.GetVersions.initiate(
-                  {
-                    ...t,
-                    [e.groupFilterKey]: a.filter,
-                    // group-specific filter
-                    versionIds: [r]
-                  },
-                  { forceRefetch: !0 }
-                  // Force fresh data to detect group membership changes
-                )
-              )).data?.versions?.[0];
-              y && (s.push({ value: a.value, hasNextPage: void 0 }), i = y);
+              sortBy: e.sortBy,
+              featuredOnly: e.featuredOnly,
+              hasReviewables: e.hasReviewables
+            }),
+            checkVersionInCache: (l) => {
+              let f = !1;
+              return u((n) => {
+                f = n.versions.some((t) => t.id === l);
+              }), f;
+            },
+            onBatchUpdate: ({ deleted: l, patched: f, attribPatched: n, fullUpdated: t }) => {
+              u((s) => {
+                if (l)
+                  for (const { entityId: o } of l) {
+                    const i = s.versions.findIndex((r) => r.id === o);
+                    i !== -1 && s.versions.splice(i, 1);
+                  }
+                if (f)
+                  for (const { entityId: o, field: i, value: r } of f) {
+                    const c = s.versions.find((a) => a.id === o);
+                    c && (c[i] = r);
+                  }
+                if (n)
+                  for (const { entityId: o, allAttrib: i, parsedAttrib: r } of n) {
+                    const c = s.versions.find((a) => a.id === o);
+                    c && (c.allAttrib = i, c.attrib = r);
+                  }
+                if (t)
+                  for (const o of t) {
+                    const i = s.versions.findIndex((r) => r.id === o.id);
+                    if (i !== -1) {
+                      const r = s.versions[i].groups;
+                      s.versions[i] = { ...o, groups: r };
+                    }
+                  }
+              });
             }
-            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 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 d, P.unsubscribe(p), o && o();
+          })
+        );
+        await y, P.unsubscribe(v), d && d();
       }
     })
   })
 }), {
-  useGetVersionsQuery: Oe,
-  useGetProductsColumnStatsQuery: Se,
-  useGetVersionsColumnStatsQuery: Be
-} = b, {
-  useGetVersionsInfiniteInfiniteQuery: He,
-  useGetVersionsByProductsQuery: Ue,
-  useGetProductsInfiniteInfiniteQuery: Me,
-  useGetGroupedVersionsListQuery: $e
-} = M;
+  useGetVersionsQuery: Mt,
+  useGetProductsColumnStatsQuery: Dt,
+  useGetVersionsColumnStatsQuery: $t
+} = F, {
+  useGetVersionsInfiniteInfiniteQuery: zt,
+  useGetVersionsByProductsQuery: Lt,
+  useGetProductsInfiniteInfiniteQuery: Wt,
+  useGetGroupedVersionsListQuery: Yt
+} = J;
 export {
-  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
+  V as VP_INFINITE_QUERY_COUNT,
+  F as enhancedVersionsPageApi,
+  J as injectedVersionsPageApi,
+  Yt as useGetGroupedVersionsListQuery,
+  Dt as useGetProductsColumnStatsQuery,
+  Wt as useGetProductsInfiniteQuery,
+  Lt as useGetVersionsByProductsQuery,
+  $t as useGetVersionsColumnStatsQuery,
+  zt as useGetVersionsInfiniteQuery,
+  Mt as useGetVersionsQuery
 };
 //# sourceMappingURL=getVersionsProducts.es.js.map