@ynput/ayon-frontend-shared 0.4.0 → 0.4.1

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