@ynput/ayon-frontend-shared 0.3.48 → 0.3.50

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

@@ -1,6 +1,6 @@
-import { foldersQueries as w } from "../folders/getFolders.es.js";
+import { foldersQueries as A } from "../folders/getFolders.es.js";
 import "../folders/getFolderDeleteInfo.es.js";
-import { detailsPanelQueries as E } from "../entities/getEntityPanel.es.js";
+import { detailsPanelQueries as w } from "../entities/getEntityPanel.es.js";
 import "../../base/client.es.js";
 import "../../generated/graphql.es.js";
 import "../../generated/graphqlLinks.es.js";
@@ -23,7 +23,7 @@ import "../../generated/inbox.es.js";
 import "../../generated/links.es.js";
 import "../../generated/market.es.js";
 import "../../generated/onboarding.es.js";
-import { api as H } from "../../generated/operations.es.js";
+import { api as _ } from "../../generated/operations.es.js";
 import "../../generated/products.es.js";
 import "../../generated/projectDashboard.es.js";
 import "../../generated/projects.es.js";
@@ -44,214 +44,217 @@ import "../../generated/views.es.js";
 import "../entityLists/updateLists.es.js";
 import T from "./getOverview.es.js";
 import "../entities/getEntity.es.js";
-import { patchVersions as U } from "./patchVersions.es.js";
-import { patchProducts as $ } from "./patchProducts.es.js";
+import { patchVersions as q } from "./patchVersions.es.js";
+import { patchProducts as M } from "./patchProducts.es.js";
 import "../links/getEntityLinks.es.js";
 import "../entities/updateEntity.es.js";
-import { patchDetailsPanelEntity as z } from "../entities/patchDetailsPanel.es.js";
-import { getUpdatedEntityIds as S } from "./filterRefetchUtils.es.js";
-import { refetchTasksForCacheEntry as G, refetchOverviewTasksForCacheEntry as V } from "./refetchFilteredEntities.es.js";
-import B from "../entityLists/getLists.es.js";
-const A = (e, t) => {
-  if (Object.keys(t).forEach((r) => {
-    r === "attrib" || r === "links" || r === "deleteLinks" || (e[r] = t[r]);
-  }), t.attrib && (e.attrib = {
-    ...e.attrib,
-    ...t.attrib
-  }), t.links) {
-    const r = e.links || [], o = t.links || [];
-    e.links || (e.links = []), e.links = [...r], o.forEach((i) => {
-      const l = e.links.findIndex((a) => a.id === i.id);
-      l !== -1 ? e.links[l] = { ...e.links[l], ...i } : e.links.push(i);
+import { patchDetailsPanelEntity as H } from "../entities/patchDetailsPanel.es.js";
+import { getUpdatedEntityIds as B } from "./filterRefetchUtils.es.js";
+import { refetchTasksForCacheEntry as U, refetchOverviewTasksForCacheEntry as $ } from "./refetchFilteredEntities.es.js";
+import b from "../entityLists/getLists.es.js";
+const L = (t, i) => {
+  if (Object.keys(i).forEach((n) => {
+    n === "attrib" || n === "links" || n === "deleteLinks" || (t[n] = i[n]);
+  }), i.attrib && (t.attrib = {
+    ...t.attrib,
+    ...i.attrib
+  }), i.links) {
+    const n = t.links || [], o = i.links || [];
+    t.links || (t.links = []), t.links = [...n], o.forEach((s) => {
+      const f = t.links.findIndex((d) => d.id === s.id);
+      f !== -1 ? t.links[f] = { ...t.links[f], ...s } : t.links.push(s);
     });
   }
-  if (t.deleteLinks) {
-    const r = t.deleteLinks || [];
-    e.links || (e.links = []), r.forEach((o) => {
-      e.links = e.links.filter((i) => i.id !== o);
+  if (i.deleteLinks) {
+    const n = i.deleteLinks || [];
+    t.links || (t.links = []), n.forEach((o) => {
+      t.links = t.links.filter((s) => s.id !== o);
     });
   }
-}, x = (e) => [
+}, G = (t) => [
   { type: "overviewTask", id: "LIST" },
-  ...e.map((t) => ({ type: "overviewTask", id: t.entityId })),
+  ...t.map((i) => ({ type: "overviewTask", id: i.entityId })),
   // we also add the projectName so that tasks that do not exist in the cache can still invalidate
-  ...e.filter((t) => t.data?.projectName).map((t) => ({
+  ...t.filter((i) => i.data?.projectName).map((i) => ({
     type: "overviewTask",
-    id: t.data?.projectName
+    id: i.data?.projectName
   }))
-], W = (e) => [
-  ...e.map((t) => ({ type: "folder", id: t.entityId })),
+], V = (t) => [
+  ...t.map((i) => ({ type: "folder", id: i.entityId })),
   // we also add the projectName so that tasks that do not exist in the cache can still invalidate
-  ...e.filter((t) => t.data?.projectName).map((t) => ({
+  ...t.filter((i) => i.data?.projectName).map((i) => ({
     type: "folder",
-    id: t.data?.projectName
+    id: i.data?.projectName
   }))
-], J = (e, t, r) => ({
-  entityId: e,
-  entityType: t,
+], W = (t, i, n) => ({
+  entityId: t,
+  entityType: i,
   type: "update",
-  data: { deleteLinks: r }
-}), Zt = (e, t) => e.map(
-  (r) => J(r.entityId, r.entityType, t)
-), te = (e, {
-  state: t,
-  dispatch: r
+  data: { deleteLinks: n }
+}), Xt = (t, i) => t.map(
+  (n) => W(n.entityId, n.entityType, i)
+), Yt = (t, {
+  state: i,
+  dispatch: n
 }, o) => {
-  const i = e.reduce((l, a) => (l[a.entityType] || (l[a.entityType] = []), l[a.entityType].push(a), l), {});
-  i.task && O(i.task, { state: t, dispatch: r }, o), i.folder && C(i.folder, { state: t, dispatch: r }, o);
-}, O = (e, {
-  state: t,
-  dispatch: r
+  const s = t.reduce((f, d) => (f[d.entityType] || (f[d.entityType] = []), f[d.entityType].push(d), f), {});
+  s.task && C(s.task, { state: i, dispatch: n }, o), s.folder && P(s.folder, { state: i, dispatch: n }, o);
+}, C = (t, {
+  state: i,
+  dispatch: n
 }, o) => {
-  const i = x(e), l = T.util.selectInvalidatedBy(t, i);
-  for (const a of l)
-    if (a.endpointName === "getTasksListInfinite") {
-      const p = r(
-        T.util.updateQueryData("getTasksListInfinite", a.originalArgs, (n) => {
-          for (const s of e)
-            if (s.type === "create" && s.data)
-              n.pages[0].tasks.push(s.data);
-            else
-              for (const d of n.pages) {
-                const f = d.tasks.find((m) => m.id === s.entityId);
-                f && A(f, s.data);
+  const s = G(t), f = T.util.selectInvalidatedBy(i, s), d = new Set(
+    t.filter((r) => r.type === "delete" && r.entityId).map((r) => r.entityId)
+  ), l = (r) => {
+    for (let a = r.length - 1; a >= 0; a--)
+      d.has(r[a].id) && r.splice(a, 1);
+  };
+  for (const r of f)
+    if (r.endpointName === "getTasksListInfinite") {
+      const a = n(
+        T.util.updateQueryData("getTasksListInfinite", r.originalArgs, (e) => {
+          for (const p of t)
+            if (p.type === "create" && p.data)
+              e.pages[0].tasks.push(p.data);
+            else if (p.type !== "delete")
+              for (const c of e.pages) {
+                const m = c.tasks.find((y) => y.id === p.entityId);
+                m && L(m, p.data);
               }
+          if (d.size > 0)
+            for (const p of e.pages)
+              l(p.tasks);
         })
       );
-      o?.push(p);
+      o?.push(a);
     } else {
-      const p = r(
+      const a = n(
         T.util.updateQueryData(
-          a.endpointName,
-          a.originalArgs,
-          (n) => {
-            for (const s of e)
-              if (s.type === "create" && s.data && a.originalArgs.parentIds?.includes(s.data.folderId)) {
-                const d = (f) => {
-                  f.push(s.data);
-                };
-                if (Array.isArray(n))
-                  d(n);
-                else if (n.tasks && Array.isArray(n.tasks)) {
-                  const f = n.tasks;
-                  d(f);
-                }
-              } else {
-                const d = (f) => {
-                  const m = f.find((I) => I.id === s.entityId);
-                  m && A(m, s.data);
-                };
-                if (Array.isArray(n))
-                  d(n);
-                else if (n.tasks && Array.isArray(n.tasks)) {
-                  const f = n.tasks;
-                  d(f);
-                }
-              }
+          r.endpointName,
+          r.originalArgs,
+          (e) => {
+            const p = (c) => {
+              Array.isArray(e) ? c(e) : e.tasks && Array.isArray(e.tasks) && c(e.tasks);
+            };
+            for (const c of t)
+              c.type === "create" && c.data && r.originalArgs.parentIds?.includes(c.data.folderId) ? p((m) => {
+                m.push(c.data);
+              }) : c.type !== "delete" && p((m) => {
+                const y = m.find((S) => S.id === c.entityId);
+                y && L(y, c.data);
+              });
+            d.size > 0 && p(l);
           }
         )
       );
-      o?.push(p);
+      o?.push(a);
     }
-}, K = (e, {
-  dispatch: t
-}) => {
-  e.length && t(T.util.invalidateTags(x(e)));
-}, L = /* @__PURE__ */ new Map(), b = (e, t, r) => {
-  const o = `${t}:${r.join()}`, i = L.get(o);
-  i && clearTimeout(i), L.set(
+}, O = /* @__PURE__ */ new Map(), Q = (t, i, n) => {
+  const o = `${i}:${n.join()}`, s = O.get(o);
+  s && clearTimeout(s), O.set(
     o,
     setTimeout(() => {
-      L.delete(o), e(
-        T.util.invalidateTags(r.map((l) => ({ type: l, id: t })))
+      O.delete(o), t(
+        T.util.invalidateTags(n.map((f) => ({ type: f, id: i })))
       );
     }, 500)
   );
-}, C = (e, {
-  state: t,
-  dispatch: r
+}, P = (t, {
+  state: i,
+  dispatch: n
 }, o) => {
-  const i = w.util.selectInvalidatedBy(t, W(e)).filter((l) => l.endpointName === "getFolderList");
-  for (const l of i) {
-    const a = r(
-      w.util.updateQueryData(
-        l.endpointName,
-        l.originalArgs,
-        (p) => {
-          const n = /* @__PURE__ */ new Map();
-          p.folders.forEach((s) => {
-            n.set(s.id, s);
+  const s = A.util.selectInvalidatedBy(i, V(t)).filter((d) => d.endpointName === "getFolderList"), f = new Set(
+    t.filter((d) => d.type === "delete" && d.entityId).map((d) => d.entityId)
+  );
+  for (const d of s) {
+    const l = n(
+      A.util.updateQueryData(
+        d.endpointName,
+        d.originalArgs,
+        (r) => {
+          const a = /* @__PURE__ */ new Map();
+          r.folders.forEach((e) => {
+            a.set(e.id, e);
           });
-          for (const s of e)
-            if (s.type === "create" && s.data)
-              p.folders.push(s.data);
-            else {
-              const d = n.get(s.entityId);
-              d && A(d, s.data);
+          for (const e of t)
+            if (e.type === "create" && e.data)
+              r.folders.push(e.data);
+            else if (e.type !== "delete") {
+              const p = a.get(e.entityId);
+              p && L(p, e.data);
             }
+          if (f.size > 0)
+            for (let e = r.folders.length - 1; e >= 0; e--)
+              f.has(r.folders[e].id) && r.folders.splice(e, 1);
         }
       )
     );
-    o?.push(a);
+    o?.push(l);
   }
-}, X = (e, {
-  state: t,
-  dispatch: r
+}, J = (t, {
+  state: i,
+  dispatch: n
 }, o) => {
-  const i = e.map((a) => ({ type: "entityListItem", id: a.entityId })), l = B.util.selectInvalidatedBy(t, i);
-  for (const a of l)
-    if (a.endpointName === "getListItemsInfinite") {
-      const p = r(
-        B.util.updateQueryData(
+  const s = t.map((l) => ({ type: "entityListItem", id: l.entityId })), f = b.util.selectInvalidatedBy(i, s), d = new Set(
+    t.filter((l) => l.type === "delete" && l.entityId).map((l) => l.entityId)
+  );
+  for (const l of f)
+    if (l.endpointName === "getListItemsInfinite") {
+      const r = n(
+        b.util.updateQueryData(
           "getListItemsInfinite",
-          a.originalArgs,
-          (n) => {
-            for (const s of e)
-              if (s.type === "update" && s.data)
-                for (const d of n.pages) {
-                  const f = d.items.find((m) => m.entityId === s.entityId);
-                  f && A(f, s.data);
+          l.originalArgs,
+          (a) => {
+            for (const e of t)
+              if (e.type === "update" && e.data)
+                for (const p of a.pages) {
+                  const c = p.items.find((m) => m.entityId === e.entityId);
+                  c && L(c, e.data);
                 }
+            if (d.size > 0)
+              for (const e of a.pages)
+                for (let p = e.items.length - 1; p >= 0; p--)
+                  d.has(e.items[p].entityId) && e.items.splice(p, 1);
           }
         )
       );
-      o?.push(p);
+      o?.push(r);
     }
-}, Q = (e) => e.reduce(
-  (t, r) => (t[r.type].push(r), t),
+}, R = (t) => t.reduce(
+  (i, n) => (i[n.type].push(n), i),
   {
     create: [],
     update: [],
     delete: []
   }
-), R = H.enhanceEndpoints({
+), x = _.enhanceEndpoints({
   endpoints: {
     operations: {}
   }
-}), Y = R.injectEndpoints({
-  endpoints: (e) => ({
-    updateOverviewEntities: e.mutation({
-      async queryFn(t, { dispatch: r }) {
+}), K = x.injectEndpoints({
+  endpoints: (t) => ({
+    updateOverviewEntities: t.mutation({
+      async queryFn(i, { dispatch: n }) {
         try {
-          const o = await r(R.endpoints.operations.initiate(t));
+          const o = await n(x.endpoints.operations.initiate(i));
           if (o.error)
             return { error: o.error };
-          const i = o.data, l = /* @__PURE__ */ new Set(), a = /* @__PURE__ */ new Set();
-          for (const p of i?.operations || [])
-            p.success === !1 && p.detail && (l.has(p.detail) || l.add(p.detail), a.has(p.errorCode) || a.add(p.errorCode));
-          return l.size > 0 ? { error: {
+          const s = o.data, f = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Set();
+          for (const l of s?.operations || [])
+            l.success === !1 && l.detail && (f.has(l.detail) || f.add(l.detail), d.has(l.errorCode) || d.add(l.errorCode));
+          return f.size > 0 ? { error: {
             status: "FETCH_ERROR",
-            error: Array.from(l).join(", "),
-            errorCodes: Array.from(a)
-          } } : { data: i };
+            error: Array.from(f).join(", "),
+            errorCodes: Array.from(d)
+          } } : { data: s };
         } catch (o) {
           return console.error(o), { error: { status: "FETCH_ERROR", error: o.message } };
         }
       },
-      async onQueryStarted({ operationsRequestModel: t, patchOperations: r = [], projectName: o }, { dispatch: i, queryFulfilled: l, getState: a }) {
-        if (!t.operations?.length) return;
-        const { operations: p } = t, n = p.reduce(
-          (c, u) => (c[u.entityType].push(u), c),
+      async onQueryStarted({ operationsRequestModel: i, patchOperations: n = [], projectName: o }, { dispatch: s, queryFulfilled: f, getState: d }) {
+        if (!i.operations?.length) return;
+        const { operations: l } = i, r = l.reduce(
+          (u, g) => (u[g.entityType].push(g), u),
           {
             task: [],
             folder: [],
@@ -260,113 +263,115 @@ const A = (e, t) => {
             representation: [],
             workfile: []
           }
-        ), s = a(), d = [];
-        if (n.task?.length) {
-          const { delete: c, update: u } = Q(n.task), g = u.filter(
-            (k) => !r.some((y) => y.entityId === k.entityId)
+        ), a = d(), e = [];
+        if (r.task?.length) {
+          const { delete: u, update: g } = R(r.task), k = g.filter(
+            (I) => !n.some((h) => h.entityId === I.entityId)
           );
-          O(g, { state: s, dispatch: i }, d), K([...c], {
-            dispatch: i
-          });
+          C([...k, ...u], { state: a, dispatch: s }, e);
         }
-        if (n.folder?.length) {
-          const { delete: c, update: u } = Q(n.folder), g = u.filter(
-            (k) => !r.some((y) => y.entityId === k.entityId)
+        if (r.folder?.length) {
+          const { delete: u, update: g } = R(r.folder), k = g.filter(
+            (I) => !n.some((h) => h.entityId === I.entityId)
           );
-          C(g, { state: s, dispatch: i }, d), c.length && i(w.util.invalidateTags([{ type: "folder", id: "LIST" }]));
+          P([...k, ...u], { state: a, dispatch: s }, e);
         }
-        const f = r.filter((c) => c.entityType === "task"), m = r.filter((c) => c.entityType === "folder");
-        f.length && O(f, { state: s, dispatch: i }, d), m.length && C(m, { state: s, dispatch: i }, d), X([...p, ...r], { state: s, dispatch: i }, d), n.version?.length && U(n.version, { state: s, dispatch: i }, d), n.product?.length && $(n.product, { state: s, dispatch: i }, d);
-        const I = p.map((c) => ({
-          id: c.entityId,
-          type: c.entityType
-        })), P = I.map((c) => ({
+        const p = n.filter((u) => u.entityType === "task"), c = n.filter((u) => u.entityType === "folder");
+        p.length && C(p, { state: a, dispatch: s }, e), c.length && P(c, { state: a, dispatch: s }, e), J([...l, ...n], { state: a, dispatch: s }, e), r.version?.length && q(r.version, { state: a, dispatch: s }, e), r.product?.length && M(r.product, { state: a, dispatch: s }, e);
+        const m = l.map((u) => ({
+          id: u.entityId,
+          type: u.entityType
+        })), y = m.map((u) => ({
           type: "entities",
-          id: c.id
-        })), j = () => i(E.util.invalidateTags(P)), D = E.util.selectInvalidatedBy(
-          s,
-          I
-        ), N = E.util.selectInvalidatedBy(
-          s,
-          P
+          id: u.id
+        })), S = () => s(w.util.invalidateTags(y)), z = w.util.selectInvalidatedBy(
+          a,
+          m
+        ), j = w.util.selectInvalidatedBy(
+          a,
+          y
         );
-        for (const c of N) {
-          if (c.endpointName !== "getEntitiesDetailsPanel") continue;
-          const u = i(
-            E.util.updateQueryData(
-              c.endpointName,
-              c.originalArgs,
-              (g) => {
-                for (const k of g)
-                  z(p, k);
+        for (const u of j) {
+          if (u.endpointName !== "getEntitiesDetailsPanel") continue;
+          const g = s(
+            w.util.updateQueryData(
+              u.endpointName,
+              u.originalArgs,
+              (k) => {
+                for (const I of k)
+                  H(l, I);
               }
             )
           );
-          d.push(u);
+          e.push(g);
         }
         try {
-          await l;
-          const c = n.task || [], u = n.folder || [], g = n.version || [], k = n.product || [];
-          if (o && ((c.length || u.length) && b(i, o, [
+          await f;
+          const u = r.task || [], g = r.folder || [], k = r.version || [], I = r.product || [];
+          if (o && ((u.length || g.length) && Q(s, o, [
             "folderColumnStats",
             "taskColumnStats",
             "entityListItemsColumnStats"
-          ]), (g.length || k.length) && b(i, o, [
+          ]), (k.length || I.length) && Q(s, o, [
             "productColumnStats",
             "versionColumnStats",
             "entityListItemsColumnStats"
-          ])), c.length === 0 && u.length === 0)
+          ])), u.length === 0 && g.length === 0)
             return;
-          const y = S(c), _ = S(u), F = y.map((h) => ({ type: "overviewTask", id: h })), q = T.util.selectInvalidatedBy(s, F).filter((h) => h.endpointName === "getTasksListInfinite");
-          if (y.length > 0 && o) {
-            for (const v of q)
-              await G({
-                dispatch: i,
+          const h = B(u), D = B(g), F = h.map((v) => ({ type: "overviewTask", id: v })), N = T.util.selectInvalidatedBy(a, F).filter((v) => v.endpointName === "getTasksListInfinite");
+          if (h.length > 0 && o) {
+            for (const E of N)
+              await U({
+                dispatch: s,
                 projectName: o,
-                updatedTaskIds: y,
-                cacheEntry: v
+                updatedTaskIds: h,
+                cacheEntry: E
               });
-            const h = T.util.selectInvalidatedBy(s, F).filter((v) => v.endpointName === "getOverviewTasksByFolders");
-            for (const v of h)
-              await V({
-                dispatch: i,
+            const v = T.util.selectInvalidatedBy(a, F).filter((E) => E.endpointName === "getOverviewTasksByFolders");
+            for (const E of v)
+              await $({
+                dispatch: s,
                 projectName: o,
-                updatedTaskIds: y,
-                cacheEntry: v
+                updatedTaskIds: h,
+                cacheEntry: E
               });
           }
-          const M = (n.folder || []).some(
-            (h) => h.type === "delete"
-          );
-          _.length > 0 && o && !M && i(w.util.invalidateTags([{ type: "folder", id: "LIST" }]));
+          D.length > 0 && o && s(A.util.invalidateTags([{ type: "folder", id: "LIST" }]));
         } catch {
-          for (const u of d)
-            u.undo();
-          D.length && j();
+          for (const g of e)
+            g.undo();
+          z.length && S();
         }
       },
-      invalidatesTags: (t, r, { operationsRequestModel: o, projectName: i }) => {
-        const l = [{ type: "kanban", id: "project-" + i }], a = [], p = [], n = [];
-        let s = !1;
-        return o.operations?.forEach((d) => {
-          const { entityId: f } = d;
-          f ? (a.push({ type: "progress", id: f }), p.push({ type: "entityListItem", id: f })) : a.push({ type: "progress", id: "LIST" }), d.data?.attrib && (s = !0);
-        }), s && n.push({ type: "tasksFolder", id: i }), [
+      invalidatesTags: (i, n, { operationsRequestModel: o, projectName: s }) => {
+        const f = [{ type: "kanban", id: "project-" + s }], d = [], l = [], r = [], a = [];
+        let e = !1;
+        const p = /* @__PURE__ */ new Set();
+        o.operations?.forEach((m) => {
+          const { entityId: y } = m;
+          y ? (d.push({ type: "progress", id: y }), l.push({ type: "entityListItem", id: y })) : d.push({ type: "progress", id: "LIST" }), m.data?.attrib && (e = !0), m.type === "delete" && y && (p.add(m.entityType), a.push({ type: m.entityType, id: y }), a.push({ type: "entities", id: y }));
+        }), e && r.push({ type: "tasksFolder", id: s });
+        const c = /* @__PURE__ */ new Set();
+        return p.has("folder") && ["folder", "task", "product", "version"].forEach((m) => c.add(m)), p.has("product") && c.add("version"), c.has("folder") && a.push({ type: "folder", id: "LIST" }), c.has("task") && a.push(
+          { type: "overviewTask", id: "LIST" },
+          { type: "overviewTask", id: s }
+        ), c.has("product") && a.push({ type: "product", id: "LIST" }), c.has("version") && a.push({ type: "version", id: "LIST" }), [
+          ...f,
+          ...d,
           ...l,
-          ...a,
-          ...p,
-          ...n
+          ...r,
+          ...a
         ];
       }
     })
   })
-}), { useUpdateOverviewEntitiesMutation: ee } = Y;
+}), { useUpdateOverviewEntitiesMutation: Zt } = K;
 export {
-  J as createLinkDeletionPatch,
-  Zt as deleteLinksFromEntities,
-  te as patchOverviewEntities,
-  C as patchOverviewFolders,
-  O as patchOverviewTasks,
-  ee as useUpdateOverviewEntitiesMutation
+  W as createLinkDeletionPatch,
+  Xt as deleteLinksFromEntities,
+  Yt as patchOverviewEntities,
+  P as patchOverviewFolders,
+  C as patchOverviewTasks,
+  Zt as useUpdateOverviewEntitiesMutation
 };
 //# sourceMappingURL=updateOverview.es.js.map