@ynput/ayon-frontend-shared 0.3.4 → 0.3.6

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

@@ -19,7 +19,7 @@ import "../../generated/inbox.es.js";
 import "../../generated/links.es.js";
 import "../../generated/market.es.js";
 import "../../generated/onboarding.es.js";
-import { api as S } from "../../generated/operations.es.js";
+import { api as D } from "../../generated/operations.es.js";
 import "../../generated/products.es.js";
 import "../../generated/projectDashboard.es.js";
 import "../../generated/projects.es.js";
@@ -53,7 +53,8 @@ import "../config/updateConfig.es.js";
 import "../entities/getEntity.es.js";
 import { detailsPanelQueries as E } from "../entities/getEntityPanel.es.js";
 import "../entities/updateEntity.es.js";
-import P from "../entityLists/getLists.es.js";
+import { patchDetailsPanelEntity as _ } from "../entities/patchDetailsPanel.es.js";
+import F from "../entityLists/getLists.es.js";
 import "../entityLists/updateLists.es.js";
 import "../entityLists/getListsAttributes.es.js";
 import "../entityLists/updateListsAttributes.es.js";
@@ -64,8 +65,8 @@ import "../links/updateLinks.es.js";
 import "../links/getLinks.es.js";
 import "../links/getEntityLinks.es.js";
 import T from "./getOverview.es.js";
-import { patchVersions as _ } from "./patchVersions.es.js";
-import { patchProducts as q } from "./patchProducts.es.js";
+import { patchVersions as q } from "./patchVersions.es.js";
+import { patchProducts as H } from "./patchProducts.es.js";
 import "../permissions/getPermissions.es.js";
 import "../products/createProduct.es.js";
 import "../project/getProject.es.js";
@@ -74,6 +75,7 @@ import "../review/getReview.es.js";
 import "../review/updateReview.es.js";
 import "../share/share.es.js";
 import "../system/getSystem.es.js";
+import "../tasks/updateTasks.es.js";
 import "../userDashboard/getUserDashboard.es.js";
 import "../users/getUsers.es.js";
 import "../users/updateUsers.es.js";
@@ -84,28 +86,28 @@ import "../views/getViews.es.js";
 import "../views/updateViews.es.js";
 import "../watchers/getWatchers.es.js";
 import "../uris/getUris.es.js";
-import { getUpdatedEntityIds as j } from "./filterRefetchUtils.es.js";
-import { refetchTasksForCacheEntry as U, refetchOverviewTasksForCacheEntry as H } from "./refetchFilteredEntities.es.js";
+import { getUpdatedEntityIds as B } from "./filterRefetchUtils.es.js";
+import { refetchTasksForCacheEntry as M, refetchOverviewTasksForCacheEntry as U } from "./refetchFilteredEntities.es.js";
 const A = (t, e) => {
-  if (Object.keys(e).forEach((i) => {
-    i === "attrib" || i === "links" || i === "deleteLinks" || (t[i] = e[i]);
+  if (Object.keys(e).forEach((o) => {
+    o === "attrib" || o === "links" || o === "deleteLinks" || (t[o] = e[o]);
   }), e.attrib && (t.attrib = {
     ...t.attrib,
     ...e.attrib
   }), e.links) {
-    const i = t.links || [], a = e.links || [];
-    t.links || (t.links = []), t.links = [...i], a.forEach((s) => {
-      const l = t.links.findIndex((p) => p.id === s.id);
-      l !== -1 ? t.links[l] = { ...t.links[l], ...s } : t.links.push(s);
+    const o = t.links || [], a = e.links || [];
+    t.links || (t.links = []), t.links = [...o], a.forEach((r) => {
+      const p = t.links.findIndex((n) => n.id === r.id);
+      p !== -1 ? t.links[p] = { ...t.links[p], ...r } : t.links.push(r);
     });
   }
   if (e.deleteLinks) {
-    const i = e.deleteLinks || [];
-    t.links || (t.links = []), i.forEach((a) => {
-      t.links = t.links.filter((s) => s.id !== a);
+    const o = e.deleteLinks || [];
+    t.links || (t.links = []), o.forEach((a) => {
+      t.links = t.links.filter((r) => r.id !== a);
     });
   }
-}, B = (t) => [
+}, j = (t) => [
   { type: "overviewTask", id: "LIST" },
   ...t.map((e) => ({ type: "overviewTask", id: e.entityId })),
   // we also add the projectName so that tasks that do not exist in the cache can still invalidate
@@ -113,251 +115,169 @@ const A = (t, e) => {
     type: "overviewTask",
     id: e.data?.projectName
   }))
-], M = (t) => [
+], z = (t) => [
   ...t.map((e) => ({ type: "folder", id: e.entityId })),
   // we also add the projectName so that tasks that do not exist in the cache can still invalidate
   ...t.filter((e) => e.data?.projectName).map((e) => ({
     type: "folder",
     id: e.data?.projectName
   }))
-], z = (t, e, i) => ({
+], G = (t, e, o) => ({
   entityId: t,
   entityType: e,
   type: "update",
-  data: { deleteLinks: i }
-}), De = (t, e) => t.map(
-  (i) => z(i.entityId, i.entityType, e)
-), Fe = (t, {
+  data: { deleteLinks: o }
+}), Ne = (t, e) => t.map(
+  (o) => G(o.entityId, o.entityType, e)
+), je = (t, {
   state: e,
-  dispatch: i
+  dispatch: o
 }, a) => {
-  const s = t.reduce((l, p) => (l[p.entityType] || (l[p.entityType] = []), l[p.entityType].push(p), l), {});
-  s.task && b(s.task, { state: e, dispatch: i }, a), s.folder && L(s.folder, { state: e, dispatch: i }, a);
-}, b = (t, {
+  const r = t.reduce((p, n) => (p[n.entityType] || (p[n.entityType] = []), p[n.entityType].push(n), p), {});
+  r.task && L(r.task, { state: e, dispatch: o }, a), r.folder && O(r.folder, { state: e, dispatch: o }, a);
+}, L = (t, {
   state: e,
-  dispatch: i
+  dispatch: o
 }, a) => {
-  const s = B(t), l = T.util.selectInvalidatedBy(e, s);
-  for (const p of l)
-    if (p.endpointName === "getTasksListInfinite") {
-      const n = i(
-        T.util.updateQueryData("getTasksListInfinite", p.originalArgs, (o) => {
-          for (const r of t)
-            if (r.type === "create" && r.data)
-              o.pages[0].tasks.push(r.data);
+  const r = j(t), p = T.util.selectInvalidatedBy(e, r);
+  for (const n of p)
+    if (n.endpointName === "getTasksListInfinite") {
+      const d = o(
+        T.util.updateQueryData("getTasksListInfinite", n.originalArgs, (s) => {
+          for (const i of t)
+            if (i.type === "create" && i.data)
+              s.pages[0].tasks.push(i.data);
             else
-              for (const c of o.pages) {
-                const m = c.tasks.find((y) => y.id === r.entityId);
-                m && A(m, r.data);
+              for (const m of s.pages) {
+                const c = m.tasks.find((y) => y.id === i.entityId);
+                c && A(c, i.data);
               }
         })
       );
-      a?.push(n);
+      a?.push(d);
     } else {
-      const n = i(
+      const d = o(
         T.util.updateQueryData(
-          p.endpointName,
-          p.originalArgs,
-          (o) => {
-            for (const r of t)
-              if (r.type === "create" && r.data && p.originalArgs.parentIds?.includes(r.data.folderId)) {
-                const c = (m) => {
-                  m.push(r.data);
+          n.endpointName,
+          n.originalArgs,
+          (s) => {
+            for (const i of t)
+              if (i.type === "create" && i.data && n.originalArgs.parentIds?.includes(i.data.folderId)) {
+                const m = (c) => {
+                  c.push(i.data);
                 };
-                if (Array.isArray(o))
-                  c(o);
-                else if (o.tasks && Array.isArray(o.tasks)) {
-                  const m = o.tasks;
-                  c(m);
+                if (Array.isArray(s))
+                  m(s);
+                else if (s.tasks && Array.isArray(s.tasks)) {
+                  const c = s.tasks;
+                  m(c);
                 }
               } else {
-                const c = (m) => {
-                  const y = m.find((I) => I.id === r.entityId);
-                  y && A(y, r.data);
+                const m = (c) => {
+                  const y = c.find((I) => I.id === i.entityId);
+                  y && A(y, i.data);
                 };
-                if (Array.isArray(o))
-                  c(o);
-                else if (o.tasks && Array.isArray(o.tasks)) {
-                  const m = o.tasks;
-                  c(m);
+                if (Array.isArray(s))
+                  m(s);
+                else if (s.tasks && Array.isArray(s.tasks)) {
+                  const c = s.tasks;
+                  m(c);
                 }
               }
           }
         )
       );
-      a?.push(n);
+      a?.push(d);
     }
-}, G = (t, {
+}, V = (t, {
   dispatch: e
 }) => {
-  t.length && e(T.util.invalidateTags(B(t)));
-}, L = (t, {
+  t.length && e(T.util.invalidateTags(j(t)));
+}, O = (t, {
   state: e,
-  dispatch: i
+  dispatch: o
 }, a) => {
-  const s = w.util.selectInvalidatedBy(e, M(t)).filter((l) => l.endpointName === "getFolderList");
-  for (const l of s) {
-    const p = i(
+  const r = w.util.selectInvalidatedBy(e, z(t)).filter((p) => p.endpointName === "getFolderList");
+  for (const p of r) {
+    const n = o(
       w.util.updateQueryData(
-        l.endpointName,
-        l.originalArgs,
-        (n) => {
-          const o = /* @__PURE__ */ new Map();
-          n.folders.forEach((r) => {
-            o.set(r.id, r);
+        p.endpointName,
+        p.originalArgs,
+        (d) => {
+          const s = /* @__PURE__ */ new Map();
+          d.folders.forEach((i) => {
+            s.set(i.id, i);
           });
-          for (const r of t)
-            if (r.type === "create" && r.data)
-              n.folders.push(r.data);
+          for (const i of t)
+            if (i.type === "create" && i.data)
+              d.folders.push(i.data);
             else {
-              const c = o.get(r.entityId);
-              c && A(c, r.data);
+              const m = s.get(i.entityId);
+              m && A(m, i.data);
             }
         }
       )
     );
-    a?.push(p);
-  }
-}, V = (t, e) => {
-  const i = {
-    name: t.name,
-    attrib: t.attrib,
-    status: t.status,
-    tags: t.tags,
-    label: t.label,
-    updatedAt: t.updatedAt,
-    createdAt: t.createdAt,
-    hasReviewables: t.hasReviewables,
-    thumbnailId: t.thumbnailId
-  };
-  switch (e) {
-    case "task":
-      return {
-        ...i,
-        task: {
-          assignees: t.assignees,
-          label: t.label,
-          name: t.name,
-          taskType: t.taskType
-        }
-      };
-    case "folder":
-      return {
-        ...i,
-        folder: {
-          id: t.id,
-          name: t.name,
-          label: t.label,
-          folderType: t.folderType
-        }
-      };
-    case "version":
-      return {
-        ...i,
-        version: {
-          id: t.id,
-          name: t.name
-        }
-      };
-    case "representation":
-      return {
-        ...i
-      };
+    a?.push(n);
   }
-}, W = (t = [], e) => {
-  const i = t.find((n) => n.entityId === e.id), a = i?.data;
-  if (!a || i.entityType === "product" || i.entityType === "workfile")
-    return console.warn("No operation data found or entity type not supported");
-  const s = V(a, i.entityType);
-  if (i.entityType === "folder" && a.name && e.path) {
-    const n = e.path.split("/");
-    n[n.length - 1] = a.name, s.path = n.join("/");
-  }
-  function l(n) {
-    Object.entries(n).forEach(([o, r]) => {
-      r === void 0 ? delete n[o] : r !== null && typeof r == "object" && l(r);
-    });
-  }
-  l(s);
-  const p = {
-    ...e,
-    ...s,
-    attrib: {
-      ...e?.attrib || {},
-      ...s.attrib
-    },
-    folder: {
-      ...e?.folder || {},
-      ...s.folder
-    },
-    task: {
-      ...e?.task || {},
-      ...s.task
-    },
-    version: {
-      ...e?.version || {},
-      ...s.version
-    }
-  };
-  Object.assign(e, p);
-}, J = (t, {
+}, W = (t, {
   state: e,
-  dispatch: i
+  dispatch: o
 }, a) => {
-  const s = t.map((p) => ({ type: "entityListItem", id: p.entityId })), l = P.util.selectInvalidatedBy(e, s);
-  for (const p of l)
-    if (p.endpointName === "getListItemsInfinite") {
-      const n = i(
-        P.util.updateQueryData(
+  const r = t.map((n) => ({ type: "entityListItem", id: n.entityId })), p = F.util.selectInvalidatedBy(e, r);
+  for (const n of p)
+    if (n.endpointName === "getListItemsInfinite") {
+      const d = o(
+        F.util.updateQueryData(
           "getListItemsInfinite",
-          p.originalArgs,
-          (o) => {
-            for (const r of t)
-              if (r.type === "update" && r.data)
-                for (const c of o.pages) {
-                  const m = c.items.find((y) => y.entityId === r.entityId);
-                  m && A(m, r.data);
+          n.originalArgs,
+          (s) => {
+            for (const i of t)
+              if (i.type === "update" && i.data)
+                for (const m of s.pages) {
+                  const c = m.items.find((y) => y.entityId === i.entityId);
+                  c && A(c, i.data);
                 }
           }
         )
       );
-      a?.push(n);
+      a?.push(d);
     }
-}, D = (t) => t.reduce(
-  (e, i) => (e[i.type].push(i), e),
+}, C = (t) => t.reduce(
+  (e, o) => (e[o.type].push(o), e),
   {
     create: [],
     update: [],
     delete: []
   }
-), F = S.enhanceEndpoints({
+), N = D.enhanceEndpoints({
   endpoints: {
     operations: {}
   }
-}), K = F.injectEndpoints({
+}), J = N.injectEndpoints({
   endpoints: (t) => ({
     updateOverviewEntities: t.mutation({
-      async queryFn(e, { dispatch: i }) {
+      async queryFn(e, { dispatch: o }) {
         try {
-          const a = await i(F.endpoints.operations.initiate(e));
+          const a = await o(N.endpoints.operations.initiate(e));
           if (a.error)
             return { error: a.error };
-          const s = a.data, l = /* @__PURE__ */ new Set(), p = /* @__PURE__ */ new Set();
-          for (const n of s?.operations || [])
-            n.success === !1 && n.detail && (l.has(n.detail) || l.add(n.detail), p.has(n.errorCode) || p.add(n.errorCode));
-          return l.size > 0 ? { error: {
+          const r = a.data, p = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+          for (const d of r?.operations || [])
+            d.success === !1 && d.detail && (p.has(d.detail) || p.add(d.detail), n.has(d.errorCode) || n.add(d.errorCode));
+          return p.size > 0 ? { error: {
             status: "FETCH_ERROR",
-            error: Array.from(l).join(", "),
-            errorCodes: Array.from(p)
-          } } : { data: s };
+            error: Array.from(p).join(", "),
+            errorCodes: Array.from(n)
+          } } : { data: r };
         } catch (a) {
           return console.error(a), { error: { status: "FETCH_ERROR", error: a.message } };
         }
       },
-      async onQueryStarted({ operationsRequestModel: e, patchOperations: i = [], projectName: a }, { dispatch: s, queryFulfilled: l, getState: p }) {
+      async onQueryStarted({ operationsRequestModel: e, patchOperations: o = [], projectName: a }, { dispatch: r, queryFulfilled: p, getState: n }) {
         if (!e.operations?.length) return;
-        const { operations: n } = e, o = n.reduce(
-          (d, f) => (d[f.entityType].push(f), d),
+        const { operations: d } = e, s = d.reduce(
+          (l, f) => (l[f.entityType].push(f), l),
           {
             task: [],
             folder: [],
@@ -366,100 +286,99 @@ const A = (t, e) => {
             representation: [],
             workfile: []
           }
-        ), r = p(), c = [];
-        if (o.task?.length) {
-          const { delete: d, update: f } = D(o.task), u = f.filter(
-            (g) => !i.some((h) => h.entityId === g.entityId)
+        ), i = n(), m = [];
+        if (s.task?.length) {
+          const { delete: l, update: f } = C(s.task), u = f.filter(
+            (g) => !o.some((h) => h.entityId === g.entityId)
           );
-          b(u, { state: r, dispatch: s }, c), G([...d], {
-            dispatch: s
+          L(u, { state: i, dispatch: r }, m), V([...l], {
+            dispatch: r
           });
         }
-        if (o.folder?.length) {
-          const { delete: d, update: f } = D(o.folder), u = f.filter(
-            (g) => !i.some((h) => h.entityId === g.entityId)
+        if (s.folder?.length) {
+          const { delete: l, update: f } = C(s.folder), u = f.filter(
+            (g) => !o.some((h) => h.entityId === g.entityId)
           );
-          L(u, { state: r, dispatch: s }, c), d.length && s(w.util.invalidateTags([{ type: "folder", id: "LIST" }]));
+          O(u, { state: i, dispatch: r }, m), l.length && r(w.util.invalidateTags([{ type: "folder", id: "LIST" }]));
         }
-        const m = i.filter((d) => d.entityType === "task"), y = i.filter((d) => d.entityType === "folder");
-        m.length && b(m, { state: r, dispatch: s }, c), y.length && L(y, { state: r, dispatch: s }, c), J([...n, ...i], { state: r, dispatch: s }, c), o.version?.length && _(o.version, { state: r, dispatch: s }, c), o.product?.length && q(o.product, { state: r, dispatch: s }, c);
-        const I = n.map((d) => ({
-          id: d.entityId,
-          type: d.entityType
-        })), O = I.map((d) => ({
+        const c = o.filter((l) => l.entityType === "task"), y = o.filter((l) => l.entityType === "folder");
+        c.length && L(c, { state: i, dispatch: r }, m), y.length && O(y, { state: i, dispatch: r }, m), W([...d, ...o], { state: i, dispatch: r }, m), s.version?.length && q(s.version, { state: i, dispatch: r }, m), s.product?.length && H(s.product, { state: i, dispatch: r }, m);
+        const I = d.map((l) => ({
+          id: l.entityId,
+          type: l.entityType
+        })), P = I.map((l) => ({
           type: "entities",
-          id: d.id
-        })), N = () => s(E.util.invalidateTags(O)), C = E.util.selectInvalidatedBy(
-          r,
+          id: l.id
+        })), Q = () => r(E.util.invalidateTags(P)), b = E.util.selectInvalidatedBy(
+          i,
           I
-        ), Q = E.util.selectInvalidatedBy(
-          r,
-          O
+        ), x = E.util.selectInvalidatedBy(
+          i,
+          P
         );
-        for (const d of Q) {
-          if (d.endpointName !== "getEntitiesDetailsPanel") continue;
-          const f = s(
+        for (const l of x) {
+          if (l.endpointName !== "getEntitiesDetailsPanel") continue;
+          const f = r(
             E.util.updateQueryData(
-              d.endpointName,
-              d.originalArgs,
+              l.endpointName,
+              l.originalArgs,
               (u) => {
                 for (const g of u)
-                  W(n, g);
+                  _(d, g);
               }
             )
           );
-          c.push(f);
+          m.push(f);
         }
         try {
-          await l;
-          const d = o.task || [], f = o.folder || [];
-          if (d.length === 0 && f.length === 0)
+          await p;
+          const l = s.task || [], f = s.folder || [];
+          if (l.length === 0 && f.length === 0)
             return;
-          const u = j(d), g = j(f), h = u.map((k) => ({ type: "overviewTask", id: k })), R = T.util.selectInvalidatedBy(r, h).filter((k) => k.endpointName === "getTasksListInfinite");
+          const u = B(l), g = B(f), h = u.map((k) => ({ type: "overviewTask", id: k })), R = T.util.selectInvalidatedBy(i, h).filter((k) => k.endpointName === "getTasksListInfinite");
           if (u.length > 0 && a) {
             for (const v of R)
-              await U({
-                dispatch: s,
+              await M({
+                dispatch: r,
                 projectName: a,
                 updatedTaskIds: u,
                 cacheEntry: v
               });
-            const k = T.util.selectInvalidatedBy(r, h).filter((v) => v.endpointName === "getOverviewTasksByFolders");
+            const k = T.util.selectInvalidatedBy(i, h).filter((v) => v.endpointName === "getOverviewTasksByFolders");
             for (const v of k)
-              await H({
-                dispatch: s,
+              await U({
+                dispatch: r,
                 projectName: a,
                 updatedTaskIds: u,
                 cacheEntry: v
               });
           }
-          const x = (o.folder || []).some(
+          const S = (s.folder || []).some(
             (k) => k.type === "delete"
           );
-          g.length > 0 && a && !x && s(w.util.invalidateTags([{ type: "folder", id: "LIST" }]));
+          g.length > 0 && a && !S && r(w.util.invalidateTags([{ type: "folder", id: "LIST" }]));
         } catch {
-          for (const f of c)
+          for (const f of m)
             f.undo();
-          C.length && N();
+          b.length && Q();
         }
       },
-      invalidatesTags: (e, i, { operationsRequestModel: a, projectName: s }) => {
-        const l = [{ type: "kanban", id: "project-" + s }], p = [], n = [];
-        return a.operations?.forEach((o) => {
-          const { entityId: r } = o;
-          r ? (p.push({ type: "progress", id: r }), n.push({ type: "entityListItem", id: r })) : p.push({ type: "progress", id: "LIST" });
-        }), [...l, ...p, ...n];
+      invalidatesTags: (e, o, { operationsRequestModel: a, projectName: r }) => {
+        const p = [{ type: "kanban", id: "project-" + r }], n = [], d = [];
+        return a.operations?.forEach((s) => {
+          const { entityId: i } = s;
+          i ? (n.push({ type: "progress", id: i }), d.push({ type: "entityListItem", id: i })) : n.push({ type: "progress", id: "LIST" });
+        }), [...p, ...n, ...d];
       }
     })
   })
-}), { useUpdateOverviewEntitiesMutation: Be } = K;
+}), { useUpdateOverviewEntitiesMutation: Qe } = J;
 export {
-  z as createLinkDeletionPatch,
-  De as deleteLinksFromEntities,
-  W as patchDetailsPanelEntity,
-  Fe as patchOverviewEntities,
-  L as patchOverviewFolders,
-  b as patchOverviewTasks,
-  Be as useUpdateOverviewEntitiesMutation
+  G as createLinkDeletionPatch,
+  Ne as deleteLinksFromEntities,
+  je as patchOverviewEntities,
+  O as patchOverviewFolders,
+  L as patchOverviewTasks,
+  Qe as useUpdateOverviewEntitiesMutation
 };
 //# sourceMappingURL=updateOverview.es.js.map