@ynput/ayon-frontend-shared 0.3.53 → 0.3.55

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

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as Q } from "../../generated/graphql.es.js";
+import { api as q } from "../../generated/graphql.es.js";
 import "../../generated/graphqlLinks.es.js";
 import "../../generated/access.es.js";
 import "../../generated/actions.es.js";
@@ -38,15 +38,14 @@ 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 H, provideTagsForVersionsResult as _, transformVersionsResponse as B, parseGQLErrorMessage as R, provideTagsForProductsInfinite as D, provideTagsForVersionsInfinite as M } from "./getVersionsProductsUtils.es.js";
-import { parseAllAttribs as $ } from "../overview/getOverview.es.js";
+import { provideTagsForProductsResult as O, transformProductsResponse as H, provideTagsForVersionsResult as k, transformVersionsResponse as w, parseGQLErrorMessage as E, provideTagsForProductsInfinite as M, provideTagsForVersionsInfinite as L } from "./getVersionsProductsUtils.es.js";
+import { parseAllAttribs as z } 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 { subscribeToThumbnailUpdates as A } from "../../../util/thumbnailWebsocket.es.js";
 import "../actions/getActions.es.js";
 import "../activities/getActivities.es.js";
 import "../activities/updateReaction.es.js";
@@ -60,8 +59,8 @@ import "../authentication/getAuthentication.es.js";
 import "../bundles/getBundles.es.js";
 import "../bundles/updateBundles.es.js";
 import "../cloud/cloud.es.js";
-import { mergeFieldStats as C, transformStatsError as U, normalizeFieldStats as G } from "../columnStats/columnStats.es.js";
-import { hasNewTargetFields as S } from "../columnStats/metricTargets.es.js";
+import { mergeFieldStats as _, transformStatsError as C, normalizeFieldStats as G } 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";
@@ -101,179 +100,178 @@ import "../views/getViews.es.js";
 import "../views/updateViews.es.js";
 import "../watchers/getWatchers.es.js";
 import "../uris/getUris.es.js";
-const T = 10;
-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)
+import { createRealtimeBatcher as $, getSupportedEntityPatch as D, REALTIME_REST_CALL_LIMIT as U, waitForRealtimeJitter as S } from "../../../util/realtimeUpdatesUtils.es.js";
+import P from "../../../util/pubsub.es.js";
+const V = 10;
+function B(h, e, f, y) {
+  for (let p = 0; p < h.length; p++) {
+    const u = e[f], l = h[p][f];
+    if (y ? u > l : u < l)
       return p;
   }
-  return m.length;
+  return h.length;
 }
-function z(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) {
-      u ? l[f] = u : l.splice(f, 1);
+function Y(h, e, f, y, p, u) {
+  for (const l of h) {
+    const m = l[y], v = m.findIndex((a) => a.id === e);
+    if (v !== -1) {
+      f ? m[v] = f : m.splice(v, 1);
       return;
     }
   }
-  if (u && m.length > 0) {
-    const v = m[0][y], l = w(v, u, p, d);
-    v.splice(l, 0, u);
+  if (f && h.length > 0) {
+    const l = h[0][y], m = B(l, f, p, u);
+    l.splice(m, 0, f);
   }
 }
-const F = Q.enhanceEndpoints({
+const F = q.enhanceEndpoints({
   endpoints: {
     // used by both stacked and non-stacked views
     GetVersions: {
-      transformResponse: B,
-      providesTags: _,
-      keepUnusedDataFor: T
+      transformResponse: w,
+      providesTags: k,
+      keepUnusedDataFor: V
     },
     // used by getVersionsByProducts only
     GetVersionsByProductId: {
-      transformResponse: B,
-      providesTags: _,
-      keepUnusedDataFor: T
+      transformResponse: w,
+      providesTags: k,
+      keepUnusedDataFor: V
     },
     // used by getProductsInfinite only
     GetProducts: {
       transformResponse: H,
-      providesTags: q,
-      keepUnusedDataFor: T
+      providesTags: O,
+      keepUnusedDataFor: V
     },
     // footer stats: `targets` excluded from cache key + responses merged,
     // so column toggles reuse cache and only added targets refetch
     GetProductsColumnStats: {
-      transformResponse: (m) => G(m?.project?.products?.fieldStats ?? []),
-      transformErrorResponse: (m) => U(m, "product"),
-      serializeQueryArgs: ({ queryArgs: { targets: m, ...e } }) => e,
-      merge: (m, e) => C(e, m),
-      forceRefetch: ({ currentArg: m, previousArg: e }) => S(m, e),
-      providesTags: (m, e, { projectName: u }) => [{ type: "productColumnStats", id: u }],
-      keepUnusedDataFor: T
+      transformResponse: (h) => G(h?.project?.products?.fieldStats ?? []),
+      transformErrorResponse: (h) => C(h, "product"),
+      serializeQueryArgs: ({ queryArgs: { targets: h, ...e } }) => e,
+      merge: (h, e) => _(e, h),
+      forceRefetch: ({ currentArg: h, previousArg: e }) => j(h, e),
+      providesTags: (h, e, { projectName: f }) => [{ type: "productColumnStats", id: f }],
+      keepUnusedDataFor: V
     },
     GetVersionsColumnStats: {
-      transformResponse: (m) => G(m?.project?.versions?.fieldStats ?? []),
-      transformErrorResponse: (m) => U(m, "version"),
-      serializeQueryArgs: ({ queryArgs: { targets: m, ...e } }) => e,
-      merge: (m, e) => C(e, m),
-      forceRefetch: ({ currentArg: m, previousArg: e }) => S(m, e),
-      providesTags: (m, e, { projectName: u }) => [{ type: "versionColumnStats", id: u }],
-      keepUnusedDataFor: T
+      transformResponse: (h) => G(h?.project?.versions?.fieldStats ?? []),
+      transformErrorResponse: (h) => C(h, "version"),
+      serializeQueryArgs: ({ queryArgs: { targets: h, ...e } }) => e,
+      merge: (h, e) => _(e, h),
+      forceRefetch: ({ currentArg: h, previousArg: e }) => j(h, e),
+      providesTags: (h, e, { projectName: f }) => [{ type: "versionColumnStats", id: f }],
+      keepUnusedDataFor: V
     }
   }
-}), E = 250, j = 1e3, L = 10, W = 5e3, Y = 1e3, O = 3e4, J = 1500;
-function N(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 A = ["status", "tags"].includes(g), V = c.summary?.value;
-          if (!V || !A) {
-            d.add(a);
-            continue;
+}), R = 250, Q = 1e3, W = 10, J = ["status", "tags"];
+function T(h, e, f) {
+  const p = $(
+    async (l) => {
+      const m = [], v = [], a = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+      for (const { topic: r, message: s } of l) {
+        const t = s.summary?.entityId, o = s.summary?.parentId;
+        if (t) {
+          if (r === "entity.version.deleted")
+            m.push({ entityId: t, parentId: o });
+          else if (r === "entity.version.created")
+            i.add(t);
+          else if (r.startsWith("entity.version.") && r.endsWith("_changed")) {
+            if (!f.checkVersionInCache(t, o)) continue;
+            const d = r.split(".")[2].split("_changed")[0];
+            if (d === "attrib") {
+              a.add(t);
+              continue;
+            }
+            const I = D(d, s.summary, J);
+            if (!I) {
+              i.add(t);
+              continue;
+            }
+            v.push({ entityId: t, field: I.field, value: I.value, parentId: o });
           }
-          let k = V;
-          g === "status" ? k = String(V) : g === "tags" && (k = Array.isArray(V) ? V : []), s.push({ entityId: a, field: g, value: k, parentId: h });
         }
       }
+      if (i.size > 0 && i.size <= U && e)
+        try {
+          await S();
+          const r = await e(
+            F.endpoints.GetVersions.initiate({
+              ...f.getBaseFilters?.() || {},
+              projectName: h,
+              versionIds: Array.from(i)
+            })
+          );
+          r.data?.versions && f.onBatchUpdate({ fullUpdated: r.data.versions });
+        } catch (r) {
+          console.error("Failed to fetch full version data batch", r);
+        }
+      const n = [];
+      if (a.size > 0 && a.size <= U && e)
+        try {
+          await S();
+          const r = Array.from(a), s = await e(
+            F.endpoints.GetVersionsAttribs.initiate(
+              { projectName: h, versionIds: r },
+              { forceRefetch: !0 }
+            )
+          );
+          if (s.data?.project?.versions?.edges)
+            for (const t of s.data.project.versions.edges) {
+              const o = t.node;
+              o && n.push({
+                entityId: o.id,
+                allAttrib: o.allAttrib,
+                parsedAttrib: z(o.allAttrib)
+              });
+            }
+        } catch (r) {
+          console.error("Failed to fetch patched version attribs", r);
+        }
+      (m.length > 0 || v.length > 0 || n.length > 0) && f.onBatchUpdate({ deleted: m, patched: v, attribPatched: n });
+    },
+    ({ message: l }) => l.summary?.entityId
+  );
+  return {
+    handle: (l, m) => {
+      m.project !== h || !m.summary?.entityId || p.add({ topic: l, message: m });
+    },
+    clear() {
+      p.clear();
     }
-    d.size > 0 && !v && (v = setTimeout(f, O));
-    const i = [];
-    if (o.size > 0 && e)
-      try {
-        await new Promise(
-          (a) => setTimeout(a, Math.random() * Y)
-        );
-        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: $(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() * J)
-        );
-        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, O))) : (y.push({ topic: n, message: t }), p && clearTimeout(p), p = setTimeout(l, W)));
   };
 }
 const K = F.injectEndpoints({
-  endpoints: (m) => ({
+  endpoints: (h) => ({
     // enhance GetVersions with an infinite query
-    getVersionsInfinite: m.infiniteQuery(
+    getVersionsInfinite: h.infiniteQuery(
       {
         infiniteQueryOptions: {
           initialPageParam: { cursor: "", desc: !1 },
           // Calculate the next page param based on current page response and params
-          getNextPageParam: (e, u, y, p) => {
-            const d = e.pageInfo;
-            if (!(!(y.desc ? d?.hasPreviousPage : d?.hasNextPage) || !d?.endCursor))
+          getNextPageParam: (e, f, y, p) => {
+            const u = e.pageInfo;
+            if (!(!(y.desc ? u?.hasPreviousPage : u?.hasNextPage) || !u?.endCursor))
               return {
-                cursor: d?.endCursor,
+                cursor: u?.endCursor,
                 desc: y.desc
               };
           }
         },
-        queryFn: async ({ queryArg: e, pageParam: u }, y) => {
+        queryFn: async ({ queryArg: e, pageParam: f }, y) => {
           try {
-            const { sortBy: p, desc: d, folderIds: v, ...l } = e, { cursor: f } = u, n = {
-              ...l
+            const { sortBy: p, desc: u, folderIds: l, ...m } = e, { cursor: v } = f, a = {
+              ...m
             };
-            p ? (n.sortBy = p, d ? (n.before = f || void 0, n.last = E) : (n.after = f || void 0, n.first = E)) : (n.after = f || void 0, n.first = E), v && v.length && (n.folderIds = v);
-            const t = await y.dispatch(
-              F.endpoints.GetVersions.initiate(n, {
+            p ? (a.sortBy = p, u ? (a.before = v || void 0, a.last = R) : (a.after = v || void 0, a.first = R)) : (a.after = v || void 0, a.first = R), l && l.length && (a.folderIds = l);
+            const i = await y.dispatch(
+              F.endpoints.GetVersions.initiate(a, {
                 forceRefetch: !0
               })
             );
-            if (t.error) throw t.error;
-            const s = {
+            if (i.error) throw i.error;
+            const n = {
               versions: [],
               pageInfo: {
                 hasNextPage: !1,
@@ -283,260 +281,254 @@ const K = F.injectEndpoints({
               }
             };
             return {
-              data: t.data || s
+              data: i.data || n
             };
           } catch (p) {
             return console.error("Error in getVersionsInfiniteQuery queryFn:", p), {
               error: {
                 status: "FETCH_ERROR",
-                error: R(p.message)
+                error: E(p.message)
               }
             };
           }
         },
-        providesTags: M,
+        providesTags: L,
         // Subscribes to version entity changes and updates cache accordingly
         // Handles: create, update, delete operations
-        onCacheEntryAdded: async (e, { getCacheEntry: u, updateCachedData: y, cacheEntryRemoved: p, dispatch: d }) => {
-          let v;
-          v = x(
-            (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
+        onCacheEntryAdded: async (e, { getCacheEntry: f, updateCachedData: y, cacheEntryRemoved: p, dispatch: u }) => {
+          let l;
+          l = A(
+            (a) => {
+              const i = a.filter((n) => n.project === e.projectName);
+              i.length && y((n) => {
+                i.forEach((r) => {
+                  r.summary.entityType === "version" && n.pages.forEach((s) => {
+                    const t = s.versions.findIndex(
+                      (o) => o.id === r.summary.entityId
                     );
-                    i !== -1 && (o.versions[i].thumbnailHash = s.summary.thumbnailHash || "");
+                    t !== -1 && (s.versions[t].thumbnailHash = r.summary.thumbnailHash || "");
                   });
                 });
               });
             },
             ["version"]
           );
-          const l = P.subscribe(
-            "entity.version",
-            N(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);
-                        }
+          const m = T(e.projectName, u, {
+            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: (a) => {
+              const i = f().data;
+              if (!i) return !1;
+              for (const n of i.pages || [])
+                if (n.versions.some((r) => r.id === a)) return !0;
+              return !1;
+            },
+            onBatchUpdate: ({ deleted: a, patched: i, attribPatched: n, fullUpdated: r }) => {
+              y((s) => {
+                for (const t of s?.pages || []) {
+                  if (a)
+                    for (const { entityId: o } of a) {
+                      const c = t.versions.findIndex((d) => d.id === o);
+                      c !== -1 && t.versions.splice(c, 1);
+                    }
+                  if (i)
+                    for (const { entityId: o, field: c, value: d } of i) {
+                      const I = t.versions.find((g) => g.id === o);
+                      I && (I[c] = d);
+                    }
+                  if (n)
+                    for (const { entityId: o, allAttrib: c, parsedAttrib: d } of n) {
+                      const I = t.versions.find((g) => g.id === o);
+                      I && (I.allAttrib = c, I.attrib = d);
+                    }
+                  if (r)
+                    for (const o of r) {
+                      const c = t.versions.findIndex((d) => d.id === o.id);
+                      if (c !== -1)
+                        t.versions[c] = o;
+                      else {
+                        const d = e.sortBy || "createdAt", I = B(
+                          t.versions,
+                          o,
+                          d,
+                          e.desc || !1
+                        );
+                        t === s.pages[0] && t.versions.splice(I, 0, o);
                       }
-                  }
-                });
-              }
-            })
-          );
-          await p, P.unsubscribe(l), v && v();
+                    }
+                }
+              });
+            }
+          }), v = P.subscribe("entity.version", m.handle);
+          await p, m.clear(), P.unsubscribe(v), l && l();
         },
-        keepUnusedDataFor: T
+        keepUnusedDataFor: V
       }
     ),
     // custom query function that fetches versions by multiple parent ids -not infinite and gets 1000 versions max
-    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]
+    getVersionsByProducts: h.query({
+      queryFn: async (e, { dispatch: f, forced: y }) => {
+        const { productIds: p = [], desc: u, ...l } = e, m = async (r, s) => {
+          const t = {
+            ...l,
+            productIds: [r]
           };
-          return d ? (i && (r.before = i), r.last = j) : (i && (r.after = i), r.first = j), u(
-            F.endpoints.GetVersionsByProductId.initiate(r, {
+          return u ? (s && (t.before = s), t.last = Q) : (s && (t.after = s), t.first = Q), f(
+            F.endpoints.GetVersionsByProductId.initiate(t, {
               forceRefetch: y
             })
           );
-        }, 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: R(i.reason) });
+        }, v = p.map((r) => m(r)), a = await Promise.allSettled(v), i = [], n = [];
+        for (let r = 0; r < a.length; r++) {
+          const s = a[r], t = p[r];
+          if (s.status === "rejected") {
+            console.error(`Error fetching versions for product ${t}:`, s.reason), n.push({ productId: t, error: E(s.reason) });
             continue;
           }
-          const c = i.value;
-          if (c.error) {
-            console.error(`Error fetching versions for product ${r}:`, c.error), s.push({
-              productId: r,
+          const o = s.value;
+          if (o.error) {
+            console.error(`Error fetching versions for product ${t}:`, o.error), n.push({
+              productId: t,
               // @ts-expect-error - message
-              error: R(c.error?.message || "Unknown error")
+              error: E(o.error?.message || "Unknown error")
             });
             continue;
           }
-          if (!c.data) continue;
-          t.push(...c.data.versions);
-          let a = c.data.pageInfo, h = 1;
-          for (; a && h < L; ) {
-            const I = d ? a.hasPreviousPage : a.hasNextPage, g = a.endCursor;
+          if (!o.data) continue;
+          i.push(...o.data.versions);
+          let c = o.data.pageInfo, d = 1;
+          for (; c && d < W; ) {
+            const I = u ? c.hasPreviousPage : c.hasNextPage, g = c.endCursor;
             if (!I || !g) break;
-            const b = await l(r, g);
+            const b = await m(t, g);
             if (b.error) {
               console.error(
-                `Error fetching versions page ${h + 1} for product ${r}:`,
+                `Error fetching versions page ${d + 1} for product ${t}:`,
                 b.error
-              ), s.push({ productId: r, error: b.error });
+              ), n.push({ productId: t, error: b.error });
               break;
             }
             if (!b.data) break;
-            t.push(...b.data.versions), a = b.data.pageInfo, h++;
+            i.push(...b.data.versions), c = b.data.pageInfo, d++;
           }
         }
-        return s.length > 0 && console.warn(
-          `Partial success: ${s.length} of ${p.length} products failed to fetch versions`,
-          s
+        return n.length > 0 && console.warn(
+          `Partial success: ${n.length} of ${p.length} products failed to fetch versions`,
+          n
         ), {
           data: {
-            versions: t,
+            versions: i,
             pageInfo: void 0,
             // pageInfo is undefined as we've flattened multiple queries
-            errors: s.length > 0 ? s : void 0
+            errors: n.length > 0 ? n : void 0
           }
         };
       },
       // Subscribes to version entity changes for expanded products
       // Only updates versions that belong to currently expanded products
-      onCacheEntryAdded: async (e, { updateCachedData: u, cacheEntryRemoved: y, dispatch: p }) => {
-        let d;
-        d = x(
-          (l) => {
-            const f = l.filter((n) => n.project === e.projectName);
-            f.length && u((n) => {
-              f.forEach((t) => {
-                if (t.summary.entityType === "version") {
-                  const s = n.versions.findIndex((o) => o.id === t.summary.entityId);
-                  s !== -1 && (n.versions[s].thumbnailHash = t.summary.thumbnailHash || "");
+      onCacheEntryAdded: async (e, { updateCachedData: f, cacheEntryRemoved: y, dispatch: p }) => {
+        let u;
+        u = A(
+          (v) => {
+            const a = v.filter((i) => i.project === e.projectName);
+            a.length && f((i) => {
+              a.forEach((n) => {
+                if (n.summary.entityType === "version") {
+                  const r = i.versions.findIndex((s) => s.id === n.summary.entityId);
+                  r !== -1 && (i.versions[r].thumbnailHash = n.summary.thumbnailHash || "");
                 }
               });
             });
           },
           ["version"]
         );
-        const v = P.subscribe(
-          "entity.version",
-          N(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);
-                    }
+        const l = T(e.projectName, p, {
+          getBaseFilters: () => ({
+            versionFilter: e.versionFilter,
+            taskFilter: e.taskFilter,
+            productIds: e.productIds
+          }),
+          checkVersionInCache: (v, a) => {
+            if (!a || !e.productIds.includes(a)) return !1;
+            let i = !1;
+            return f((n) => {
+              i = n.versions.some((r) => r.id === v);
+            }), i;
+          },
+          onBatchUpdate: ({ deleted: v, patched: a, attribPatched: i, fullUpdated: n }) => {
+            f((r) => {
+              if (v)
+                for (const { entityId: s } of v) {
+                  const t = r.versions.findIndex((o) => o.id === s);
+                  t !== -1 && r.versions.splice(t, 1);
+                }
+              if (a)
+                for (const { entityId: s, field: t, value: o } of a) {
+                  const c = r.versions.find((d) => d.id === s);
+                  c && (c[t] = o);
+                }
+              if (i)
+                for (const { entityId: s, allAttrib: t, parsedAttrib: o } of i) {
+                  const c = r.versions.find((d) => d.id === s);
+                  c && (c.allAttrib = t, c.attrib = o);
+                }
+              if (n)
+                for (const s of n) {
+                  const t = r.versions.findIndex((o) => o.id === s.id);
+                  if (t !== -1)
+                    r.versions[t] = s;
+                  else {
+                    const o = e.sortBy || "createdAt", c = B(
+                      r.versions,
+                      s,
+                      o,
+                      e.desc || !1
+                    );
+                    r.versions.splice(c, 0, s);
                   }
-              });
-            }
-          })
-        );
-        await y, P.unsubscribe(v), d && d();
+                }
+            });
+          }
+        }), m = P.subscribe("entity.version", l.handle);
+        await y, l.clear(), P.unsubscribe(m), u && u();
       },
-      providesTags: _,
-      keepUnusedDataFor: T
+      providesTags: k,
+      keepUnusedDataFor: V
     }),
     // enhance GetProducts with an infinite query
-    getProductsInfinite: m.infiniteQuery(
+    getProductsInfinite: h.infiniteQuery(
       {
         infiniteQueryOptions: {
           initialPageParam: { cursor: "", desc: !1 },
           // Calculate the next page param based on current page response and params
-          getNextPageParam: (e, u, y, p) => {
-            const d = e.pageInfo;
-            if (!(!(y.desc ? d?.hasPreviousPage : d?.hasNextPage) || !d?.endCursor))
+          getNextPageParam: (e, f, y, p) => {
+            const u = e.pageInfo;
+            if (!(!(y.desc ? u?.hasPreviousPage : u?.hasNextPage) || !u?.endCursor))
               return {
-                cursor: d?.endCursor,
+                cursor: u?.endCursor,
                 desc: y.desc
               };
           }
         },
-        queryFn: async ({ queryArg: e, pageParam: u }, y) => {
+        queryFn: async ({ queryArg: e, pageParam: f }, y) => {
           let p;
           try {
-            const { sortBy: d, desc: v, folderIds: l, ...f } = e, { cursor: n } = u, t = {
-              ...f
+            const { sortBy: u, desc: l, folderIds: m, ...v } = e, { cursor: a } = f, i = {
+              ...v
             };
-            if (d ? (t.sortBy = d, v ? (t.before = n || void 0, t.last = E) : (t.after = n || void 0, t.first = E)) : (t.after = n || void 0, t.first = E), l && l.length && (t.folderIds = l), p = await y.dispatch(
-              F.endpoints.GetProducts.initiate(t, {
+            if (u ? (i.sortBy = u, l ? (i.before = a || void 0, i.last = R) : (i.after = a || void 0, i.first = R)) : (i.after = a || void 0, i.first = R), m && m.length && (i.folderIds = m), p = await y.dispatch(
+              F.endpoints.GetProducts.initiate(i, {
                 forceRefetch: !0
               })
             ), p.error) throw p.error;
-            const s = {
+            const n = {
               products: [],
               pageInfo: {
                 hasNextPage: !1,
@@ -546,31 +538,31 @@ const K = F.injectEndpoints({
               }
             };
             return {
-              data: p.data || s
+              data: p.data || n
             };
-          } catch (d) {
-            return console.error("Error in getProductsInfiniteQuery queryFn:", d), {
+          } catch (u) {
+            return console.error("Error in getProductsInfiniteQuery queryFn:", u), {
               error: {
                 status: "FETCH_ERROR",
-                error: R(d.message)
+                error: E(u.message)
               }
             };
           }
         },
-        providesTags: D,
+        providesTags: M,
         // 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: u, cacheEntryRemoved: y, dispatch: p }) => {
-          let d;
-          d = x(
-            (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 || "");
+        onCacheEntryAdded: async (e, { updateCachedData: f, cacheEntryRemoved: y, dispatch: p }) => {
+          let u;
+          u = A(
+            (n) => {
+              const r = n.filter((s) => s.project === e.projectName);
+              r.length && f((s) => {
+                r.forEach((t) => {
+                  t.summary.entityType === "version" && s.pages.forEach((o) => {
+                    o.products.forEach((c) => {
+                      c.featuredVersion?.id === t.summary.entityId && (c.featuredVersion.thumbnailHash = t.summary.thumbnailHash || "");
                     });
                   });
                 });
@@ -578,256 +570,250 @@ const K = F.injectEndpoints({
             },
             ["version"]
           );
-          const v = async (t) => {
-            const s = {
+          const l = async (n) => {
+            const r = {
               projectName: e.projectName,
-              productIds: [t],
+              productIds: [n],
               productFilter: e.productFilter,
               versionFilter: e.versionFilter,
               taskFilter: e.taskFilter,
               folderIds: e.folderIds?.length ? e.folderIds : void 0,
               first: 1
-            }, o = await p(
-              F.endpoints.GetProducts.initiate(s, {
+            }, s = await p(
+              F.endpoints.GetProducts.initiate(r, {
                 forceRefetch: !0
               })
             );
-            o.error || u((i) => {
-              const r = o.data?.products?.[0];
-              z(
-                i.pages,
-                t,
-                r,
+            s.error || f((t) => {
+              const o = s.data?.products?.[0];
+              Y(
+                t.pages,
+                n,
+                o,
                 "products",
                 e.sortBy || "createdAt",
                 e.desc || !1
               );
             });
-          }, l = P.subscribe(
+          }, m = P.subscribe(
             "entity.product",
-            async (t, s) => {
+            async (n, r) => {
               try {
-                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)
+                const s = r.summary?.entityId;
+                if (!s) return;
+                let t = !1;
+                if (f((o) => {
+                  t = o.pages.some(
+                    (c) => c.products.some((d) => d.id === s)
                   );
-                }), !i && t !== "entity.product.created") return;
-                await v(o);
+                }), !t && n !== "entity.product.created") return;
+                await l(s);
               } catch {
               }
             }
-          ), f = P.subscribe(
-            "entity.version",
-            N(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
-                    )
-                  );
-                }), 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: A } of s)
-                            a.id === A && 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);
-                      }
+          ), v = T(e.projectName, p, {
+            getBaseFilters: () => ({
+              versionFilter: e.versionFilter,
+              productFilter: e.productFilter,
+              taskFilter: e.taskFilter,
+              folderIds: e.folderIds?.length ? e.folderIds : void 0
+            }),
+            checkVersionInCache: (n, r) => {
+              let s = !1;
+              return f((t) => {
+                s = t.pages.some(
+                  (o) => o.products.some(
+                    (c) => c.id === r && c.featuredVersion?.id === n
+                  )
+                );
+              }), s;
+            },
+            onBatchUpdate: ({ deleted: n, patched: r, attribPatched: s, fullUpdated: t }) => {
+              f((o) => {
+                for (const c of o?.pages || [])
+                  for (const d of c.products) {
+                    const I = d.featuredVersion?.id;
+                    if (I) {
+                      if (n && n.some((g) => g.entityId === I && g.parentId === d.id) && i.add(d.id), r)
+                        for (const { entityId: g, field: b, value: x, parentId: N } of r)
+                          d.id === N && I === g && d.featuredVersion && (d.featuredVersion[b] = x);
+                      if (s)
+                        for (const { entityId: g, allAttrib: b, parsedAttrib: x } of s)
+                          I === g && d.featuredVersion && (d.featuredVersion.allAttrib = b, d.featuredVersion.attrib = x);
+                      if (t)
+                        for (const g of t)
+                          I === g.id && d.featuredVersion && (d.featuredVersion = g);
                     }
-                });
-                for (const r of n)
-                  v(r);
-                n.clear();
-              }
-            })
-          ), n = /* @__PURE__ */ new Set();
-          await y, P.unsubscribe(l), P.unsubscribe(f), d && d();
+                  }
+              });
+              for (const o of i)
+                l(o);
+              i.clear();
+            }
+          }), a = P.subscribe("entity.version", v.handle), i = /* @__PURE__ */ new Set();
+          await y, v.clear(), P.unsubscribe(m), P.unsubscribe(a), u && u();
         },
-        keepUnusedDataFor: T
+        keepUnusedDataFor: V
       }
     ),
     // Grouped versions query - fetches versions for multiple group filters
-    getGroupedVersionsList: m.query({
+    getGroupedVersionsList: h.query({
       queryFn: async ({
         projectName: e,
-        groups: u,
+        groups: f,
         groupFilterKey: y = "versionFilter",
         versionFilter: p,
         // most of the time overridden by group filters
-        productFilter: d,
-        taskFilter: v,
-        folderIds: l,
-        desc: f,
-        sortBy: n,
-        featuredOnly: t,
-        hasReviewables: s
-      }, o) => {
+        productFilter: u,
+        taskFilter: l,
+        folderIds: m,
+        desc: v,
+        sortBy: a,
+        featuredOnly: i,
+        hasReviewables: n
+      }, r) => {
         try {
-          const i = [];
-          for (const a of u) {
-            const h = a.count || 500, I = {
+          const s = [];
+          for (const c of f) {
+            const d = c.count || 500, I = {
               projectName: e,
               // base filters
-              productFilter: d,
-              taskFilter: v,
+              productFilter: u,
+              taskFilter: l,
               versionFilter: p,
               // specific group filter
-              [y]: a.filter,
-              folderIds: l?.length ? l : void 0,
-              sortBy: n,
-              featuredOnly: t,
-              hasReviewables: s,
+              [y]: c.filter,
+              folderIds: m?.length ? m : void 0,
+              sortBy: a,
+              featuredOnly: i,
+              hasReviewables: n,
               // @ts-expect-error - group param used later on
-              group: a.value
+              group: c.value
             };
-            f ? I.last = h : I.first = h;
-            const g = o.dispatch(
+            v ? I.last = d : I.first = d;
+            const g = r.dispatch(
               F.endpoints.GetVersions.initiate(I, {
                 forceRefetch: !0
               })
             );
-            i.push(g);
+            s.push(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, A, V) => ({
+          const t = await Promise.all(s), o = [];
+          for (const c of t) {
+            if (c.error) throw c.error;
+            const d = c.originalArgs?.group, I = c.data?.pageInfo?.hasNextPage || c.data?.pageInfo?.hasPreviousPage || !1, g = c.data?.versions.map((b, x, N) => ({
               ...b,
               groups: [
                 {
-                  value: h,
-                  hasNextPage: A === V.length - 1 && I ? h : void 0
+                  value: d,
+                  hasNextPage: x === N.length - 1 && I ? d : void 0
                 }
               ]
             })) || [];
-            c.push(...g);
+            o.push(...g);
           }
           return {
             data: {
-              versions: c
+              versions: o
             }
           };
-        } catch (i) {
-          return console.error("Error in getGroupedVersionsList queryFn:", i), {
+        } catch (s) {
+          return console.error("Error in getGroupedVersionsList queryFn:", s), {
             error: {
               status: "FETCH_ERROR",
-              error: R(i.message)
+              error: E(s.message)
             }
           };
         }
       },
-      providesTags: _,
+      providesTags: k,
       // Subscribes to version entity changes and updates cache accordingly
       // Handles: create, update, delete operations for grouped versions view
-      onCacheEntryAdded: async (e, { updateCachedData: u, cacheEntryRemoved: y, dispatch: p }) => {
-        let d;
-        d = x(
-          (l) => {
-            const f = l.filter((n) => n.project === e.projectName);
-            f.length && u((n) => {
-              f.forEach((t) => {
-                if (t.summary.entityType === "version") {
-                  const s = n.versions.findIndex((o) => o.id === t.summary.entityId);
-                  s !== -1 && (n.versions[s].thumbnailHash = t.summary.thumbnailHash || "");
+      onCacheEntryAdded: async (e, { updateCachedData: f, cacheEntryRemoved: y, dispatch: p }) => {
+        let u;
+        u = A(
+          (v) => {
+            const a = v.filter((i) => i.project === e.projectName);
+            a.length && f((i) => {
+              a.forEach((n) => {
+                if (n.summary.entityType === "version") {
+                  const r = i.versions.findIndex((s) => s.id === n.summary.entityId);
+                  r !== -1 && (i.versions[r].thumbnailHash = n.summary.thumbnailHash || "");
                 }
               });
             });
           },
           ["version"]
         );
-        const v = P.subscribe(
-          "entity.version",
-          N(e.projectName, p, {
-            getBaseFilters: () => ({
-              versionFilter: e.versionFilter,
-              productFilter: e.productFilter,
-              taskFilter: e.taskFilter,
-              folderIds: e.folderIds?.length ? e.folderIds : void 0,
-              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 };
-                    }
+        const l = T(e.projectName, p, {
+          getBaseFilters: () => ({
+            versionFilter: e.versionFilter,
+            productFilter: e.productFilter,
+            taskFilter: e.taskFilter,
+            folderIds: e.folderIds?.length ? e.folderIds : void 0,
+            sortBy: e.sortBy,
+            featuredOnly: e.featuredOnly,
+            hasReviewables: e.hasReviewables
+          }),
+          checkVersionInCache: (v) => {
+            let a = !1;
+            return f((i) => {
+              a = i.versions.some((n) => n.id === v);
+            }), a;
+          },
+          onBatchUpdate: ({ deleted: v, patched: a, attribPatched: i, fullUpdated: n }) => {
+            f((r) => {
+              if (v)
+                for (const { entityId: s } of v) {
+                  const t = r.versions.findIndex((o) => o.id === s);
+                  t !== -1 && r.versions.splice(t, 1);
+                }
+              if (a)
+                for (const { entityId: s, field: t, value: o } of a) {
+                  const c = r.versions.find((d) => d.id === s);
+                  c && (c[t] = o);
+                }
+              if (i)
+                for (const { entityId: s, allAttrib: t, parsedAttrib: o } of i) {
+                  const c = r.versions.find((d) => d.id === s);
+                  c && (c.allAttrib = t, c.attrib = o);
+                }
+              if (n)
+                for (const s of n) {
+                  const t = r.versions.findIndex((o) => o.id === s.id);
+                  if (t !== -1) {
+                    const o = r.versions[t].groups;
+                    r.versions[t] = { ...s, groups: o };
                   }
-              });
-            }
-          })
-        );
-        await y, P.unsubscribe(v), d && d();
+                }
+            });
+          }
+        }), m = P.subscribe("entity.version", l.handle);
+        await y, l.clear(), P.unsubscribe(m), u && u();
       },
-      keepUnusedDataFor: T
+      keepUnusedDataFor: V
     })
   })
 }), {
-  useGetVersionsQuery: Lt,
+  useGetVersionsQuery: Yt,
   useGetProductsColumnStatsQuery: Wt,
-  useGetVersionsColumnStatsQuery: Yt
+  useGetVersionsColumnStatsQuery: Jt
 } = F, {
-  useGetVersionsInfiniteInfiniteQuery: Jt,
-  useGetVersionsByProductsQuery: Kt,
-  useGetProductsInfiniteInfiniteQuery: Xt,
-  useGetGroupedVersionsListQuery: Zt
+  useGetVersionsInfiniteInfiniteQuery: Kt,
+  useGetVersionsByProductsQuery: Xt,
+  useGetProductsInfiniteInfiniteQuery: Zt,
+  useGetGroupedVersionsListQuery: er
 } = K;
 export {
-  E as VP_INFINITE_QUERY_COUNT,
+  R as VP_INFINITE_QUERY_COUNT,
   F as enhancedVersionsPageApi,
   K as injectedVersionsPageApi,
-  Zt as useGetGroupedVersionsListQuery,
+  er as useGetGroupedVersionsListQuery,
   Wt as useGetProductsColumnStatsQuery,
-  Xt as useGetProductsInfiniteQuery,
-  Kt as useGetVersionsByProductsQuery,
-  Yt as useGetVersionsColumnStatsQuery,
-  Jt as useGetVersionsInfiniteQuery,
-  Lt as useGetVersionsQuery
+  Zt as useGetProductsInfiniteQuery,
+  Xt as useGetVersionsByProductsQuery,
+  Jt as useGetVersionsColumnStatsQuery,
+  Kt as useGetVersionsInfiniteQuery,
+  Yt as useGetVersionsQuery
 };
 //# sourceMappingURL=getVersionsProducts.es.js.map