@ynput/ayon-frontend-shared 0.3.19 → 0.3.21

package/dist/shared/src/api/queries/overview/getOverview.es.js

@@ -1,5 +1,5 @@
 import "../../base/client.es.js";
-import { api as N } 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";
@@ -14,7 +14,7 @@ import "../../generated/desktop.es.js";
 import "../../generated/entityLists.es.js";
 import "../../generated/events.es.js";
 import "../../generated/files.es.js";
-import { api as F } from "../../generated/folders.es.js";
+import { api as x } from "../../generated/folders.es.js";
 import "../../generated/inbox.es.js";
 import "../../generated/links.es.js";
 import "../../generated/market.es.js";
@@ -40,198 +40,198 @@ import "../../generated/views.es.js";
 import "lodash";
 import "react-toastify";
 import "uuid";
-import b from "../../../util/pubsub.es.js";
-const x = (c) => {
+import E from "../../../util/pubsub.es.js";
+const S = (u) => {
   try {
-    return JSON.parse(c);
+    return JSON.parse(u);
   } catch {
     return {};
   }
-}, _ = (c) => {
-  if (!c.project)
+}, C = (u) => {
+  if (!u.project)
     return [];
-  const s = [];
-  for (const { node: e } of c.project.tasks.edges)
-    s.push({
+  const t = [];
+  for (const { node: e } of u.project.tasks.edges)
+    t.push({
       ...e,
       folderId: e.folderId || "root",
-      attrib: x(e.allAttrib),
+      attrib: S(e.allAttrib),
       entityId: e.id,
       entityType: "task",
       links: []
     });
-  return s;
-}, A = (c = [], s, e) => {
-  const a = c?.map((n) => ({ type: "overviewTask", id: n.id })) || [], i = e ? (Array.isArray(e) ? e : [e]).map((n) => ({
+  return t;
+}, b = (u = [], t, e) => {
+  const a = u?.map((c) => ({ type: "overviewTask", id: c.id })) || [], r = e ? (Array.isArray(e) ? e : [e]).map((c) => ({
     type: "overviewTask",
-    id: n
+    id: c
   })) : [];
   return [
     ...a,
-    ...i,
-    { type: "overviewTask", id: s },
+    ...r,
+    { type: "overviewTask", id: t },
     { type: "overviewTask", id: "LIST" }
   ];
-}, R = N.enhanceEndpoints({
+}, w = _.enhanceEndpoints({
   endpoints: {
     // This gets tasks for all parent folders provided
     // But in this case it will only ever receive one parent folder from the getOverviewTasksByFolders query
     // It is only used by getOverviewTasksByFolders in this file
     GetTasksByParent: {
-      transformResponse: _,
-      providesTags: (c, s, { parentIds: e, projectName: a }) => A(c, a, e)
+      transformResponse: C,
+      providesTags: (u, t, { parentIds: e, projectName: a }) => b(u, a, e)
     },
     GetTasksList: {
-      transformResponse: (c) => ({
-        tasks: _(c),
-        pageInfo: c.project.tasks.pageInfo
+      transformResponse: (u) => ({
+        tasks: C(u),
+        pageInfo: u.project.tasks.pageInfo
       }),
-      providesTags: (c, s, { projectName: e }) => A(c?.tasks || [], e)
+      providesTags: (u, t, { projectName: e }) => b(u?.tasks || [], e)
     }
   }
-}), C = F.enhanceEndpoints({
+}), G = x.enhanceEndpoints({
   endpoints: {
     searchFolders: {}
   }
-}), E = 100, G = R.injectEndpoints({
-  endpoints: (c) => ({
+}), F = 100, L = w.injectEndpoints({
+  endpoints: (u) => ({
     // Each project has one cache for all the tasks of the expanded folders
     // Changing the expanded folders will trigger a refetch but not a new cache
     // Each expanded folder has it's own query that is looped over here
     // When new folders are expanded, the new tasks are fetched and we use the cache for the rest
     // This also solves the pagination issue of getting all tasks in one query, splitting it up in multiple queries to avoid pagination limits
-    getOverviewTasksByFolders: c.query({
-      async queryFn({ projectName: s, parentIds: e, filter: a, folderFilter: i, search: n }, { dispatch: h, forced: l }) {
+    getOverviewTasksByFolders: u.query({
+      async queryFn({ projectName: t, parentIds: e, filter: a, folderFilter: r, search: c }, { dispatch: k, forced: f }) {
         try {
-          const y = [];
-          for (let o = 0; o < e.length; o += 20) {
-            const P = e.slice(o, o + 20), t = (await Promise.all(
-              P.map(
-                async (r) => h(
-                  R.endpoints.GetTasksByParent.initiate(
+          const g = [];
+          for (let i = 0; i < e.length; i += 20) {
+            const I = e.slice(i, i + 20), o = (await Promise.all(
+              I.map(
+                async (s) => k(
+                  w.endpoints.GetTasksByParent.initiate(
                     {
-                      projectName: s,
-                      parentIds: [r],
+                      projectName: t,
+                      parentIds: [s],
                       filter: a,
-                      folderFilter: i,
-                      search: n
+                      folderFilter: r,
+                      search: c
                     },
-                    { forceRefetch: l }
+                    { forceRefetch: f }
                   )
                 )
               )
-            )).filter((r) => !!r.data).flatMap((r) => r.data);
-            y.push(...t);
+            )).filter((s) => !!s.data).flatMap((s) => s.data);
+            g.push(...o);
           }
-          return { data: y };
-        } catch (k) {
-          return console.error(k), { error: { status: "FETCH_ERROR", error: k.message } };
+          return { data: g };
+        } catch (T) {
+          return console.error(T), { error: { status: "FETCH_ERROR", error: T.message } };
         }
       },
       // keep one cache per project
-      serializeQueryArgs: ({ queryArgs: { parentIds: s, ...e } }) => ({
+      serializeQueryArgs: ({ queryArgs: { parentIds: t, ...e } }) => ({
         ...e
       }),
       // Refetch when the page arg changes
-      forceRefetch({ currentArg: s, previousArg: e }) {
-        return JSON.stringify(s) !== JSON.stringify(e);
+      forceRefetch({ currentArg: t, previousArg: e }) {
+        return JSON.stringify(t) !== JSON.stringify(e);
       },
-      providesTags: (s, e, { parentIds: a, projectName: i }) => A(s, i, a),
-      async onCacheEntryAdded({ projectName: s, parentIds: e, filter: a, search: i }, { cacheDataLoaded: n, cacheEntryRemoved: h, updateCachedData: l, dispatch: k }) {
-        let y;
-        const o = /* @__PURE__ */ new Set(), P = 100, T = 500;
-        let t = !1;
-        const r = () => {
-          t || (t = !0, setTimeout(m, T));
-        }, m = async () => {
-          if (t = !1, !o.size) return;
-          const u = Array.from(o).slice(0, P);
-          u.forEach((p) => o.delete(p));
+      providesTags: (t, e, { parentIds: a, projectName: r }) => b(t, r, a),
+      async onCacheEntryAdded({ projectName: t, parentIds: e, filter: a, search: r }, { cacheDataLoaded: c, cacheEntryRemoved: k, updateCachedData: f, dispatch: T }) {
+        let g;
+        const i = /* @__PURE__ */ new Set(), I = 100, v = 500;
+        let o = !1;
+        const s = () => {
+          o || (o = !0, setTimeout(y, v));
+        }, y = async () => {
+          if (o = !1, !i.size) return;
+          const l = Array.from(i).slice(0, I);
+          l.forEach((d) => i.delete(d));
           try {
-            const f = (await k(
-              R.endpoints.GetTasksList.initiate(
+            const p = (await T(
+              w.endpoints.GetTasksList.initiate(
                 {
-                  projectName: s,
-                  taskIds: u
+                  projectName: t,
+                  taskIds: l
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], g = new Map(f.map((d) => [d.id, d]));
-            l((d) => {
-              for (const I of f) {
-                const v = d.findIndex((w) => w.id === I.id);
-                v > -1 ? d[v] = I : d.push(I);
+            ).unwrap()).tasks || [], m = new Map(p.map((n) => [n.id, n]));
+            f((n) => {
+              for (const h of p) {
+                const P = n.findIndex((R) => R.id === h.id);
+                P > -1 ? n[P] = h : n.push(h);
               }
-              for (const I of u)
-                if (!g.has(I)) {
-                  const v = d.findIndex((w) => w.id === I);
-                  v > -1 && d.splice(v, 1);
+              for (const h of l)
+                if (!m.has(h)) {
+                  const P = n.findIndex((R) => R.id === h);
+                  P > -1 && n.splice(P, 1);
                 }
             });
-          } catch (p) {
-            console.error("Realtime overview batch update failed", p);
+          } catch (d) {
+            console.error("Realtime overview batch update failed", d);
           } finally {
-            o.size && r();
+            i.size && s();
           }
         };
         try {
-          await n;
-          const u = async (p, f) => {
-            const g = f?.summary?.entityId, d = f?.summary?.parentId;
-            !g || !d || e.includes(d) && (o.add(g), r());
+          await c;
+          const l = async (d, p) => {
+            const m = p?.summary?.entityId, n = p?.summary?.parentId;
+            !m || !n || e.includes(n) && (i.add(m), s());
           };
-          y = b.subscribe("entity.task", u);
+          g = E.subscribe("entity.task", l);
         } catch {
         }
-        await h, y && b.unsubscribe(y);
+        await k, g && E.unsubscribe(g);
       }
     }),
     // searchFolders is a post so it's a bit annoying to consume
     // we wrap it in a queryFn to make it easier to consume as a query hook
-    getSearchFolders: c.query({
-      async queryFn({ projectName: s, folderSearchRequest: e }, { dispatch: a }) {
+    getSearchFolders: u.query({
+      async queryFn({ projectName: t, folderSearchRequest: e }, { dispatch: a }) {
         try {
           return { data: (await a(
-            C.endpoints.searchFolders.initiate({
-              projectName: s,
+            G.endpoints.searchFolders.initiate({
+              projectName: t,
               folderSearchRequest: e
             })
           )).data?.folderIds || [] };
-        } catch (i) {
-          return console.error(i), { error: { status: "FETCH_ERROR", error: i.message } };
+        } catch (r) {
+          return console.error(r), { error: { status: "FETCH_ERROR", error: r.message } };
         }
       }
     }),
     // Add new infinite query endpoint for tasks list
-    getTasksListInfinite: c.infiniteQuery({
+    getTasksListInfinite: u.infiniteQuery({
       infiniteQueryOptions: {
         initialPageParam: { cursor: "", desc: !1 },
         // Calculate the next page param based on current page response and params
-        getNextPageParam: (s, e, a, i) => {
-          const n = s.pageInfo;
-          if (!(!(a.desc ? n.hasPreviousPage : n.hasNextPage) || !n.endCursor))
+        getNextPageParam: (t, e, a, r) => {
+          const c = t.pageInfo;
+          if (!(!(a.desc ? c.hasPreviousPage : c.hasNextPage) || !c.endCursor))
             return {
-              cursor: n.endCursor,
+              cursor: c.endCursor,
               desc: a.desc
             };
         }
       },
-      queryFn: async ({ queryArg: s, pageParam: e }, a) => {
+      queryFn: async ({ queryArg: t, pageParam: e }, a) => {
         try {
-          const { projectName: i, filter: n, folderFilter: h, search: l, folderIds: k, taskIds: y, sortBy: o, desc: P } = s, { cursor: T } = e, t = {
-            projectName: i,
-            filter: n,
-            folderFilter: h,
-            search: l,
-            folderIds: k,
-            taskIds: y
+          const { projectName: r, filter: c, folderFilter: k, search: f, folderIds: T, taskIds: g, sortBy: i, desc: I } = t, { cursor: v } = e, o = {
+            projectName: r,
+            filter: c,
+            folderFilter: k,
+            search: f,
+            folderIds: T,
+            taskIds: g
           };
-          o ? (t.sortBy = o, P ? (t.before = T || void 0, t.last = E) : (t.after = T || void 0, t.first = E)) : (t.after = T || void 0, t.first = E);
-          const r = await a.dispatch(
-            R.endpoints.GetTasksList.initiate(t, { forceRefetch: !0 })
+          i ? (o.sortBy = i, I ? (o.before = v || void 0, o.last = F) : (o.after = v || void 0, o.first = F)) : (o.after = v || void 0, o.first = F);
+          const s = await a.dispatch(
+            w.endpoints.GetTasksList.initiate(o, { forceRefetch: !0 })
           );
-          if (r.error) throw r.error;
-          const m = {
+          if (s.error) throw s.error;
+          const y = {
             tasks: [],
             pageInfo: {
               hasNextPage: !1,
@@ -241,46 +241,46 @@ const x = (c) => {
             }
           };
           return {
-            data: r.data || m
+            data: s.data || y
           };
-        } catch (i) {
-          return console.error("Error in getTasksListInfinite queryFn:", i), { error: { status: "FETCH_ERROR", error: i.message } };
+        } catch (r) {
+          return console.error("Error in getTasksListInfinite queryFn:", r), { error: { status: "FETCH_ERROR", error: r.message } };
         }
       },
-      providesTags: (s, e, { projectName: a }) => A(s?.pages.flatMap((i) => i.tasks) || [], a),
-      async onCacheEntryAdded(s, { cacheDataLoaded: e, cacheEntryRemoved: a, updateCachedData: i, dispatch: n }) {
-        let h;
-        const l = /* @__PURE__ */ new Set(), k = 100, y = 500;
-        let o = !1;
-        const P = () => {
-          o || (o = !0, setTimeout(T, y));
-        }, T = async () => {
-          if (o = !1, !l.size) return;
-          const t = Array.from(l).slice(0, k);
-          t.forEach((r) => l.delete(r));
+      providesTags: (t, e, { projectName: a }) => b(t?.pages.flatMap((r) => r.tasks) || [], a),
+      async onCacheEntryAdded(t, { cacheDataLoaded: e, cacheEntryRemoved: a, updateCachedData: r, dispatch: c }) {
+        let k;
+        const f = /* @__PURE__ */ new Set(), T = 100, g = 500;
+        let i = !1;
+        const I = () => {
+          i || (i = !0, setTimeout(v, g));
+        }, v = async () => {
+          if (i = !1, !f.size) return;
+          const o = Array.from(f).slice(0, T);
+          o.forEach((s) => f.delete(s));
           try {
-            const m = (await n(
-              R.endpoints.GetTasksList.initiate(
+            const y = (await c(
+              w.endpoints.GetTasksList.initiate(
                 {
-                  projectName: s.projectName,
-                  taskIds: t,
-                  folderIds: s.folderIds
+                  projectName: t.projectName,
+                  taskIds: o,
+                  folderIds: t.folderIds
                 },
                 { forceRefetch: !0 }
               )
-            ).unwrap()).tasks || [], u = new Map(m.map((p) => [p.id, p]));
-            i((p) => {
-              for (const f of m) {
-                let g = !1;
-                for (const d of p.pages) {
-                  const I = d.tasks.findIndex((v) => v.id === f.id);
-                  if (I !== -1) {
-                    d.tasks[I] = f, g = !0;
+            ).unwrap()).tasks || [], l = new Map(y.map((d) => [d.id, d]));
+            r((d) => {
+              for (const p of y) {
+                let m = !1;
+                for (const n of d.pages) {
+                  const h = n.tasks.findIndex((P) => P.id === p.id);
+                  if (h !== -1) {
+                    n.tasks[h] = p, m = !0;
                     break;
                   }
                 }
-                g || (p.pages.length ? p.pages[0].tasks.unshift(f) : p.pages.push({
-                  tasks: [f],
+                m || (d.pages.length ? d.pages[0].tasks.unshift(p) : d.pages.push({
+                  tasks: [p],
                   pageInfo: {
                     startCursor: null,
                     endCursor: null,
@@ -289,100 +289,118 @@ const x = (c) => {
                   }
                 }));
               }
-              for (const f of t)
-                if (!u.has(f))
-                  for (const g of p.pages) {
-                    const d = g.tasks.findIndex((I) => I.id === f);
-                    if (d !== -1) {
-                      g.tasks.splice(d, 1);
+              for (const p of o)
+                if (!l.has(p))
+                  for (const m of d.pages) {
+                    const n = m.tasks.findIndex((h) => h.id === p);
+                    if (n !== -1) {
+                      m.tasks.splice(n, 1);
                       break;
                     }
                   }
             });
-          } catch (r) {
-            console.error("Realtime infinite tasks batch update failed", r);
+          } catch (s) {
+            console.error("Realtime infinite tasks batch update failed", s);
           } finally {
-            l.size && P();
+            f.size && I();
           }
         };
         try {
           await e;
-          const t = async (r, m) => {
-            const u = m?.summary?.entityId;
-            u && (l.add(u), P());
+          const o = async (s, y) => {
+            const l = y?.summary?.entityId;
+            l && (f.add(l), I());
           };
-          h = b.subscribe("entity.task", t);
+          k = E.subscribe("entity.task", o);
         } catch {
         }
-        await a, h && b.unsubscribe(h);
+        await a, k && E.unsubscribe(k);
       }
     }),
-    getGroupedTasksList: c.query({
-      queryFn: async ({ projectName: s, groups: e, search: a, folderFilter: i, folderIds: n, desc: h, sortBy: l, groupCount: k }, y) => {
+    getGroupedTasksList: u.query({
+      queryFn: async ({ projectName: t, groups: e, search: a, folderFilter: r, folderIds: c, desc: k, sortBy: f, groupCount: T }, g) => {
         try {
-          let o = [];
-          for (const t of e) {
-            const r = k || t.count || 500, m = {
-              projectName: s,
-              filter: t.filter,
-              folderFilter: i,
-              // Passed but not yet supported by backend
+          let i = [];
+          const I = /* @__PURE__ */ new Set(["folderType"]);
+          for (const s of e) {
+            const y = T || s.count || 500;
+            let l = s.filter, d = r;
+            if (s.filter)
+              try {
+                const n = JSON.parse(s.filter), h = n.conditions || [], P = h.filter(
+                  (A) => !I.has(A.key)
+                ), R = h.filter(
+                  (A) => I.has(A.key)
+                );
+                if (R.length > 0) {
+                  l = P.length ? JSON.stringify({ ...n, conditions: P }) : void 0;
+                  const A = r ? JSON.parse(r) : null, N = [...A && Array.isArray(A.conditions) ? A.conditions : [], ...R];
+                  d = JSON.stringify(
+                    A ? { ...A, conditions: N } : { conditions: N }
+                  );
+                }
+              } catch {
+              }
+            const p = {
+              projectName: t,
+              filter: l,
+              folderFilter: d,
               search: a,
-              folderIds: n,
-              sortBy: l,
+              folderIds: c,
+              sortBy: f,
               // @ts-expect-error - we know group does not exist on query variables but we need it for later
-              group: t.value
+              group: s.value
             };
-            h ? m.last = r : m.first = r;
-            const u = y.dispatch(
-              R.endpoints.GetTasksList.initiate(m, { forceRefetch: !0 })
+            k ? p.last = y : p.first = y;
+            const m = g.dispatch(
+              w.endpoints.GetTasksList.initiate(p, { forceRefetch: !0 })
             );
-            o.push(u);
+            i.push(m);
           }
-          const P = await Promise.all(o), T = [];
-          for (const t of P) {
-            if (t.error) throw t.error;
-            const r = t.originalArgs?.group, m = t.data?.pageInfo?.hasNextPage || t.data?.pageInfo?.hasPreviousPage || !1, u = t.data?.tasks.map((p, f, g) => ({
+          const v = await Promise.all(i), o = [];
+          for (const s of v) {
+            if (s.error) throw s.error;
+            const y = s.originalArgs?.group, l = s.data?.pageInfo?.hasNextPage || s.data?.pageInfo?.hasPreviousPage || !1, d = s.data?.tasks.map((p, m, n) => ({
               ...p,
               groups: [
                 {
-                  value: r,
-                  hasNextPage: f === g.length - 1 && m ? r : void 0
+                  value: y,
+                  hasNextPage: m === n.length - 1 && l ? y : void 0
                   // Only add hasNextPage to the last task in the group
                 }
               ]
             })) || [];
-            T.push(...u);
+            o.push(...d);
           }
           return {
             data: {
-              tasks: T
+              tasks: o
             }
           };
-        } catch (o) {
-          return console.error("Error in getGroupedTasksList queryFn:", o), { error: { status: "FETCH_ERROR", error: o.message } };
+        } catch (i) {
+          return console.error("Error in getGroupedTasksList queryFn:", i), { error: { status: "FETCH_ERROR", error: i.message } };
         }
       },
-      providesTags: (s, e, { projectName: a }) => A(s?.tasks, a)
+      providesTags: (t, e, { projectName: a }) => b(t?.tasks, a)
     })
   })
 }), {
-  useGetOverviewTasksByFoldersQuery: Re,
-  useGetSearchFoldersQuery: Ae,
-  useGetTasksListQuery: be,
-  useGetTasksListInfiniteInfiniteQuery: we,
-  useLazyGetTasksByParentQuery: Ee,
+  useGetOverviewTasksByFoldersQuery: be,
+  useGetSearchFoldersQuery: Ee,
+  useGetTasksListQuery: Fe,
+  useGetTasksListInfiniteInfiniteQuery: Ne,
+  useLazyGetTasksByParentQuery: Ce,
   useGetGroupedTasksListQuery: _e
-} = G;
+} = L;
 export {
-  E as TASKS_INFINITE_QUERY_COUNT,
-  G as default,
-  x as parseAllAttribs,
+  F as TASKS_INFINITE_QUERY_COUNT,
+  L as default,
+  S as parseAllAttribs,
   _e as useGetGroupedTasksListQuery,
-  Re as useGetOverviewTasksByFoldersQuery,
-  Ae as useGetSearchFoldersQuery,
-  we as useGetTasksListInfiniteInfiniteQuery,
-  be as useGetTasksListQuery,
-  Ee as useLazyGetTasksByParentQuery
+  be as useGetOverviewTasksByFoldersQuery,
+  Ee as useGetSearchFoldersQuery,
+  Ne as useGetTasksListInfiniteInfiniteQuery,
+  Fe as useGetTasksListQuery,
+  Ce as useLazyGetTasksByParentQuery
 };
 //# sourceMappingURL=getOverview.es.js.map