@elevasis/ui 2.66.0 → 2.68.0

package/dist/chunk-LGKLC5MG.js

@@ -0,0 +1,44 @@
+import { Box, Text } from '@mantine/core';
+import { AreaChart } from '@mantine/charts';
+import { jsx } from 'react/jsx-runtime';
+
+// src/components/monitoring/ResourceHealthChart.tsx
+function getHealthColor(successRate, hasExecutions = true) {
+  if (!hasExecutions) return "var(--mantine-color-gray-6)";
+  if (successRate >= 95) return "var(--color-success)";
+  if (successRate >= 80) return "var(--color-warning)";
+  return "var(--color-error)";
+}
+function ResourceHealthChart({
+  healthData,
+  hasExecutions = true,
+  width = 300,
+  height = 60
+}) {
+  if (!healthData || healthData.trendData.length === 0) {
+    return /* @__PURE__ */ jsx(Box, { w: width, h: height, style: { display: "flex", alignItems: "center", justifyContent: "center" }, children: /* @__PURE__ */ jsx(Text, { size: "xs", c: "dimmed", children: "No activity" }) });
+  }
+  const chartData = healthData.trendData.map((d) => ({
+    time: d.time,
+    rate: d.rate
+  }));
+  const chartColor = getHealthColor(healthData.summary.successRate, hasExecutions);
+  return /* @__PURE__ */ jsx(Box, { w: width, h: height, children: /* @__PURE__ */ jsx(
+    AreaChart,
+    {
+      h: height,
+      data: chartData,
+      dataKey: "time",
+      series: [{ name: "rate", color: chartColor }],
+      curveType: "monotone",
+      withDots: false,
+      withTooltip: false,
+      withXAxis: false,
+      withYAxis: false,
+      fillOpacity: 0.2,
+      gridAxis: "none"
+    }
+  ) });
+}
+
+export { ResourceHealthChart, getHealthColor };

package/dist/{chunk-4DV4ECMG.js → chunk-N7U24M2J.js}

@@ -19,6 +19,10 @@ var mockUseAuth = {
   // to it when no account exists yet.
   signUp: vi.fn(),
   signOut: vi.fn(),
+  // AuthKit's useAuth also exposes switchToOrganization; components that render
+  // OrganizationSwitcher call it directly, so the default mock needs a resolved
+  // implementation rather than leaving consumers to redefine it locally.
+  switchToOrganization: vi.fn().mockResolvedValue(void 0),
   getAccessToken: vi.fn().mockResolvedValue("mock-access-token"),
   organizationId: "test-org-id",
   canRecover: vi.fn(() => false)

package/dist/chunk-NDHMZT2G.js

@@ -0,0 +1,383 @@
+import { getErrorInfo, formatErrorMessage, getErrorTitle } from './chunk-L3HFJFYF.js';
+import { useElevasisServices } from './chunk-BI5VDO2K.js';
+import { useQuery, useQueryClient, useMutation } from '@tanstack/react-query';
+import { notifications } from '@mantine/notifications';
+
+var showInfoNotification = (message) => {
+  notifications.show({
+    title: "Info",
+    message,
+    autoClose: 5e3,
+    color: "blue",
+    position: "top-right"
+  });
+};
+var showSuccessNotification = (message) => {
+  notifications.show({
+    title: "Action Successful",
+    message,
+    autoClose: 5e3,
+    color: "green",
+    position: "top-right"
+  });
+};
+var showErrorNotification = (error) => {
+  if (error instanceof Error) {
+    error = error.message;
+  }
+  notifications.show({
+    title: "Action Failed",
+    message: error,
+    autoClose: 5e3,
+    color: "red",
+    position: "top-right"
+  });
+};
+var showWarningNotification = (message) => {
+  notifications.show({
+    title: "Warning",
+    message,
+    autoClose: 5e3,
+    color: "orange",
+    position: "top-right"
+  });
+};
+var showApiErrorNotification = (error) => {
+  const { message, code, requestId, fields, retryAfter } = getErrorInfo(error);
+  notifications.show({
+    title: getErrorTitle(code),
+    message: formatErrorMessage(message, requestId, fields, retryAfter),
+    autoClose: retryAfter ? retryAfter * 1e3 : 5e3,
+    color: "red",
+    position: "top-right"
+  });
+};
+var milestoneKeys = {
+  all: ["project-milestones"],
+  lists: () => [...milestoneKeys.all, "list"],
+  list: (orgId, filters) => [...milestoneKeys.all, "list", orgId, filters],
+  details: () => [...milestoneKeys.all, "detail"],
+  detail: (id) => [...milestoneKeys.all, "detail", id]
+};
+function useMilestones(filters = {}) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: milestoneKeys.list(workOSOrganizationId, filters),
+    queryFn: async () => {
+      const res = await apiRequest(`/projects/${filters.projectId}/milestones`);
+      return res.milestones;
+    },
+    enabled: isReady && !!filters.projectId
+  });
+}
+function useCreateMilestone() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      const { project_id, ...body } = params;
+      if (!project_id) throw new Error("project_id is required to create a milestone");
+      const res = await apiRequest(`/projects/${project_id}/milestones`, {
+        method: "POST",
+        body: JSON.stringify(body)
+      });
+      return res.milestone;
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({ queryKey: milestoneKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.detail(data.project_id) });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useUpdateMilestone() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      const res = await apiRequest(`/milestones/${params.id}`, {
+        method: "PATCH",
+        body: JSON.stringify(params.updates)
+      });
+      return res.milestone;
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({ queryKey: milestoneKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.detail(data.project_id) });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useDeleteMilestone() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      await apiRequest(`/milestones/${params.id}`, {
+        method: "DELETE"
+      });
+    },
+    onSuccess: (_, params) => {
+      queryClient.invalidateQueries({ queryKey: milestoneKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.detail(params.projectId) });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+var taskKeys = {
+  all: ["project-tasks"],
+  lists: () => [...taskKeys.all, "list"],
+  list: (orgId, filters) => [...taskKeys.all, "list", orgId, filters],
+  details: () => [...taskKeys.all, "detail"],
+  detail: (id) => [...taskKeys.all, "detail", id]
+};
+function useTasks(filters = {}) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: taskKeys.list(workOSOrganizationId, filters),
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (filters.status) params.set("status", filters.status);
+      if (filters.milestoneId) params.set("milestone_id", filters.milestoneId);
+      const qs = params.toString();
+      const base = `/projects/${filters.projectId}/tasks`;
+      const path = qs ? `${base}?${qs}` : base;
+      const res = await apiRequest(path);
+      return res.tasks;
+    },
+    enabled: isReady && !!filters.projectId
+  });
+}
+function useCreateTask() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      const res = await apiRequest("/project-tasks", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+      return res.task;
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({ queryKey: taskKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.detail(data.project_id) });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useUpdateTask() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      const res = await apiRequest(`/project-tasks/${params.id}`, {
+        method: "PATCH",
+        body: JSON.stringify(params.updates)
+      });
+      return res.task;
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({ queryKey: taskKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.detail(data.project_id) });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useDeleteTask() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      await apiRequest(`/project-tasks/${params.id}`, {
+        method: "DELETE"
+      });
+    },
+    onSuccess: (_, params) => {
+      queryClient.invalidateQueries({ queryKey: taskKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.detail(params.projectId) });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+var noteKeys = {
+  all: ["project-notes"],
+  lists: () => [...noteKeys.all, "list"],
+  list: (orgId, filters) => [...noteKeys.all, "list", orgId, filters],
+  details: () => [...noteKeys.all, "detail"],
+  detail: (id) => [...noteKeys.all, "detail", id]
+};
+function useProjectNotes(filters = {}) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: noteKeys.list(workOSOrganizationId, filters),
+    queryFn: async () => {
+      const res = await apiRequest(`/projects/${filters.projectId}/notes`);
+      return res.notes;
+    },
+    enabled: isReady && !!filters.projectId
+  });
+}
+function useCreateNote() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      const res = await apiRequest("/project-notes", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+      return res.note;
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({ queryKey: noteKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.detail(data.project_id) });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+
+// src/hooks/delivery/useProjects.ts
+var projectKeys = {
+  all: ["projects"],
+  lists: () => [...projectKeys.all, "list"],
+  list: (orgId, filters) => [...projectKeys.all, "list", orgId, filters],
+  details: () => [...projectKeys.all, "detail"],
+  detail: (id) => [...projectKeys.all, "detail", id],
+  milestones: (id) => [...projectKeys.all, id, "milestones"],
+  tasks: (id) => [...projectKeys.all, id, "tasks"]
+};
+function useProjects(filters = {}) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: projectKeys.list(workOSOrganizationId, filters),
+    queryFn: async () => {
+      const params = new URLSearchParams();
+      if (filters.kind) params.set("kind", filters.kind);
+      const qs = params.toString();
+      const path = qs ? `/projects?${qs}` : "/projects";
+      const res = await apiRequest(path);
+      return res.projects;
+    },
+    enabled: isReady
+  });
+}
+function useProject(id) {
+  const { apiRequest, isReady, workOSOrganizationId } = useElevasisServices();
+  return useQuery({
+    queryKey: [...projectKeys.detail(id), workOSOrganizationId],
+    queryFn: async () => {
+      try {
+        const res = await apiRequest(`/projects/${id}`);
+        return res.project;
+      } catch (err) {
+        if (err && typeof err === "object" && "statusCode" in err && err.statusCode === 404) {
+          return null;
+        }
+        throw err;
+      }
+    },
+    enabled: isReady && !!id
+  });
+}
+function useProjectMilestones(projectId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: projectKeys.milestones(projectId),
+    queryFn: async () => {
+      const res = await apiRequest(`/projects/${projectId}/milestones`);
+      return res.milestones;
+    },
+    enabled: isReady && !!projectId
+  });
+}
+function useProjectTasks(projectId) {
+  const { apiRequest, isReady } = useElevasisServices();
+  return useQuery({
+    queryKey: projectKeys.tasks(projectId),
+    queryFn: async () => {
+      const res = await apiRequest(`/projects/${projectId}/tasks`);
+      return res.tasks;
+    },
+    enabled: isReady && !!projectId
+  });
+}
+function useCreateProject() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      const res = await apiRequest("/projects", {
+        method: "POST",
+        body: JSON.stringify(params)
+      });
+      return res.project;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useUpdateProject() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (params) => {
+      const res = await apiRequest(`/projects/${params.id}`, {
+        method: "PATCH",
+        body: JSON.stringify(params.updates)
+      });
+      return res.project;
+    },
+    onSuccess: (data) => {
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+      queryClient.invalidateQueries({ queryKey: projectKeys.detail(data.id) });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+function useDeleteProject() {
+  const { apiRequest } = useElevasisServices();
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: async (id) => {
+      await apiRequest(`/projects/${id}`, {
+        method: "DELETE"
+      });
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: projectKeys.all });
+    },
+    onError: (error) => {
+      showApiErrorNotification(error);
+    }
+  });
+}
+
+export { milestoneKeys, noteKeys, projectKeys, showApiErrorNotification, showErrorNotification, showInfoNotification, showSuccessNotification, showWarningNotification, taskKeys, useCreateMilestone, useCreateNote, useCreateProject, useCreateTask, useDeleteMilestone, useDeleteProject, useDeleteTask, useMilestones, useProject, useProjectMilestones, useProjectNotes, useProjectTasks, useProjects, useTasks, useUpdateMilestone, useUpdateProject, useUpdateTask };

package/dist/chunk-OOACTYRA.js

@@ -0,0 +1,10 @@
+import { useAppearance } from './chunk-ZGCWTWBD.js';
+import { Center } from '@mantine/core';
+import { jsx } from 'react/jsx-runtime';
+
+function SubshellLoader() {
+  const { loader } = useAppearance();
+  return /* @__PURE__ */ jsx(Center, { mih: "calc(100vh - 70px)", children: loader });
+}
+
+export { SubshellLoader };

package/dist/chunk-PDHTXPSF.js

@@ -0,0 +1,12 @@
+import { Card, Group } from '@mantine/core';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/components/table/FilterBar.tsx
+function FilterBar({ children, actions }) {
+  return /* @__PURE__ */ jsx(Card, { children: /* @__PURE__ */ jsxs(Group, { gap: "md", wrap: "wrap", justify: "space-between", children: [
+    /* @__PURE__ */ jsx(Group, { gap: "md", wrap: "wrap", children }),
+    /* @__PURE__ */ jsx(Group, { gap: "md", children: actions })
+  ] }) });
+}
+
+export { FilterBar };

package/dist/chunk-QYI5BZKM.js

@@ -0,0 +1,85 @@
+import { useOptionalElevasisSystems } from './chunk-ZGCWTWBD.js';
+import { useRouterContext } from './chunk-Q7DJKLEN.js';
+import { useMemo } from 'react';
+
+var useBreadcrumbs = (options = {}) => {
+  const { currentPath } = useRouterContext();
+  const systemContext = useOptionalElevasisSystems();
+  const { labelsByPath = {} } = options;
+  return useMemo(() => {
+    const shellModel = systemContext?.shellModel;
+    const overriddenLabel = labelsByPath[currentPath];
+    if (overriddenLabel) {
+      return [{ label: overriddenLabel, isActive: true }];
+    }
+    if (shellModel) {
+      const matchedNode = shellModel.findByPath(currentPath);
+      if (matchedNode) {
+        return shellModel.ancestorsOf(matchedNode.id).map((node, index, items) => ({
+          label: labelsByPath[node.path ?? ""] ?? node.label,
+          path: index === items.length - 1 ? void 0 : node.path,
+          isActive: index === items.length - 1
+        }));
+      }
+    }
+    const segments = currentPath.split("/").filter(Boolean);
+    if (segments.length === 0) {
+      return [{ label: "Dashboard", isActive: true }];
+    }
+    const breadcrumbs = [{ label: "Dashboard", path: "/" }];
+    let currentSegmentPath = "";
+    for (let i = 0; i < segments.length; i++) {
+      currentSegmentPath += `/${segments[i]}`;
+      const isLast = i === segments.length - 1;
+      const label = labelsByPath[currentSegmentPath] ?? formatSegmentLabel(segments[i]);
+      breadcrumbs.push({
+        label,
+        path: isLast ? void 0 : currentSegmentPath,
+        isActive: isLast
+      });
+    }
+    return breadcrumbs;
+  }, [currentPath, systemContext, labelsByPath]);
+};
+function formatSegmentLabel(segment) {
+  const decodedSegment = safeDecodeURIComponent(segment);
+  const routeLabel = formatRouteIdLabel(decodedSegment);
+  if (routeLabel) return routeLabel;
+  return titleCaseSegment(decodedSegment);
+}
+function safeDecodeURIComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+function formatRouteIdLabel(segment) {
+  if (segment.startsWith("group:")) {
+    const groupKey = segment.slice("group:".length);
+    return groupKey === "graph" ? "Ontology" : titleCaseSegment(groupKey);
+  }
+  if (segment.startsWith("domain:")) {
+    return titleCaseSegment(segment.slice("domain:".length));
+  }
+  if (segment.startsWith("item:")) {
+    const rest = segment.slice("item:".length);
+    const separatorIndex = rest.indexOf(":");
+    const itemId = separatorIndex === -1 ? rest : rest.slice(separatorIndex + 1);
+    return formatOntologyOrIdLabel(itemId);
+  }
+  if (segment.startsWith("ontology:")) {
+    return formatOntologyOrIdLabel(segment);
+  }
+  return void 0;
+}
+function formatOntologyOrIdLabel(value) {
+  const localId = value.includes("/") ? value.slice(value.lastIndexOf("/") + 1) : value;
+  const suffix = localId.includes(":") ? localId.slice(localId.lastIndexOf(":") + 1) : localId;
+  return titleCaseSegment(suffix);
+}
+function titleCaseSegment(segment) {
+  return segment.split("-").flatMap((part) => part.split("_")).flatMap((part) => part.split(".")).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
+export { useBreadcrumbs };