@elevasis/ui 2.35.0 → 2.37.0

package/dist/chunk-NYNOMAAS.js

@@ -0,0 +1,422 @@
+import { devOnlyFor, requiresAdminFor, topLevel, parentOf, ancestorsOf, childrenOf, findById, findByPath, listAllSystems, defaultPathFor, getSortedSidebarEntries, getSemanticIconComponent } from './chunk-NWMPBG4U.js';
+import { createContext, useContext, useMemo, useCallback } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/provider/resolvers/RouteResolver.ts
+function normalizeRoutePath(path) {
+  const trimmedPath = path.trim();
+  if (!trimmedPath || trimmedPath === "/") {
+    return "/";
+  }
+  return trimmedPath.replace(/\/+$/, "") || "/";
+}
+function isRouteMatch(currentPath, route) {
+  const normalizedCurrentPath = normalizeRoutePath(currentPath);
+  const normalizedRoute = normalizeRoutePath(route);
+  return normalizedCurrentPath === normalizedRoute || normalizedCurrentPath.startsWith(`${normalizedRoute}/`);
+}
+
+// src/provider/resolvers/NavResolver.ts
+function uniqueIds(ids) {
+  return ids ? [...new Set(ids)] : [];
+}
+
+// src/provider/validateManifests.ts
+function listSystemRefs(systems) {
+  const refs = [];
+  function walk(map, prefix = "") {
+    for (const [key, system] of Object.entries(map)) {
+      const path = prefix ? `${prefix}.${key}` : key;
+      refs.push(path, system.id);
+      const subsystems = system.subsystems;
+      if (subsystems) {
+        walk(subsystems, path);
+      }
+    }
+  }
+  walk(systems);
+  return refs;
+}
+function validateManifests(manifests, organizationModel) {
+  if (!organizationModel) {
+    return;
+  }
+  const validSystemIds = /* @__PURE__ */ new Set([
+    ...Object.keys(organizationModel.systems ?? {}),
+    ...listSystemRefs(organizationModel.systems ?? {})
+  ]);
+  const errors = [];
+  for (const manifest of manifests) {
+    const key = manifest.key;
+    const systemId = manifest.systemId;
+    if (!systemId) {
+      continue;
+    }
+    if (!validSystemIds.has(systemId)) {
+      errors.push(
+        `Manifest "${key}": systemId "${systemId}" is not a known system id. Valid values: ${[...validSystemIds].sort().join(", ")}`
+      );
+    }
+  }
+  if (errors.length > 0) {
+    throw new Error(
+      `System manifest validation failed with ${errors.length} error(s):
+` + errors.map((e, i) => `  ${i + 1}. ${e}`).join("\n")
+    );
+  }
+}
+var ElevasisSystemsContext = createContext(null);
+
+// src/provider/sidebarProjection.ts
+function isLifecycleEnabled(system) {
+  if (system.enabled === false) return false;
+  return system.lifecycle !== "deprecated" && system.lifecycle !== "archived";
+}
+function isSystemAccessible(systemId, context) {
+  const system = context.shellModel.findById(systemId);
+  if (!system || !isLifecycleEnabled(system)) return false;
+  if (!context.isSystemEnabled(systemId)) return false;
+  if (context.shellModel.requiresAdminFor(systemId) && !context.isPlatformAdmin) return false;
+  if (context.shellModel.devOnlyFor(systemId) && !context.isDev) return false;
+  return true;
+}
+function isSurfaceAccessible(node, context) {
+  if (node.devOnly && !context.isDev) return false;
+  if (node.requiresAdmin && !context.isPlatformAdmin) return false;
+  const systemTargets = node.targets?.systems ?? [];
+  if (systemTargets.length === 0) return true;
+  return systemTargets.some((systemId) => isSystemAccessible(systemId, context));
+}
+function iconForNode(node, context) {
+  if (node.type === "surface") {
+    const targetIcon = node.targets?.systems?.map((systemId) => context.shellModel.findById(systemId)?.iconComponent).find(Boolean);
+    if (targetIcon) return targetIcon;
+  }
+  return getSemanticIconComponent(node.icon);
+}
+function activeMatchPathsForSurface(node, context) {
+  const targets = node.targets?.systems ?? [];
+  if (targets.length !== 1) return void 0;
+  const paths = context.shellModel.childrenOf(targets[0]).map((child) => child.path).filter((path) => Boolean(path && path !== node.path));
+  return paths.length > 0 ? [...new Set(paths)] : void 0;
+}
+function surfaceToLinkItem(node, context, siblings) {
+  if (!isSurfaceAccessible(node, context)) return void 0;
+  const siblingShadows = siblings.some((sibling) => sibling !== node && sibling.path.startsWith(`${node.path}/`));
+  const activeMatchPaths = activeMatchPathsForSurface(node, context);
+  return {
+    label: node.label,
+    link: node.path,
+    ...siblingShadows ? { exact: true } : {},
+    ...activeMatchPaths ? { activeMatchPaths } : {}
+  };
+}
+function projectNode(node, context) {
+  if (node.type === "surface") {
+    if (!isSurfaceAccessible(node, context)) return void 0;
+    return {
+      label: node.label,
+      icon: iconForNode(node, context),
+      link: node.path
+    };
+  }
+  const childEntries = getSortedSidebarEntries(node.children);
+  const childSurfaces = childEntries.map(([, child]) => child).filter((child) => child.type === "surface");
+  const links = childEntries.flatMap(([, child]) => {
+    if (child.type === "surface") {
+      const link = surfaceToLinkItem(child, context, childSurfaces);
+      return link ? [link] : [];
+    }
+    const nestedGroup = projectNode(child, context);
+    return nestedGroup?.link ? [
+      {
+        label: nestedGroup.label,
+        link: nestedGroup.link
+      }
+    ] : nestedGroup?.links ?? [];
+  });
+  if (links.length === 0) return void 0;
+  return {
+    label: node.label,
+    icon: iconForNode(node, context),
+    links
+  };
+}
+function projectSection(section, context) {
+  const entries = getSortedSidebarEntries(section);
+  return entries.flatMap(([, node]) => {
+    const group = projectNode(node, context);
+    return group ? [group] : [];
+  });
+}
+function projectSidebarLinks({
+  shellModel,
+  organizationModel,
+  isSystemEnabled,
+  isPlatformAdmin = false,
+  isDev = false,
+  section
+}) {
+  const context = {
+    shellModel,
+    isSystemEnabled,
+    isPlatformAdmin,
+    isDev
+  };
+  const sidebar = organizationModel?.navigation.sidebar;
+  if (!sidebar) return [];
+  if (section) {
+    return projectSection(sidebar[section], context);
+  }
+  return [...projectSection(sidebar.primary, context), ...projectSection(sidebar.bottom, context)];
+}
+function useElevasisSystems() {
+  const context = useContext(ElevasisSystemsContext);
+  if (!context) {
+    throw new Error(
+      "useElevasisSystems must be used within an ElevasisSystemsProvider. Wrap your app (or the relevant subtree) with <ElevasisSystemsProvider>."
+    );
+  }
+  return context;
+}
+function useOptionalElevasisSystems() {
+  return useContext(ElevasisSystemsContext);
+}
+function defaultSystems(organizationModel) {
+  if (!organizationModel) return [];
+  return listAllSystems(organizationModel).map(({ path, system }) => ({ ...system, id: path }));
+}
+function systemPath(system) {
+  return system.ui?.path ?? system.path ?? defaultPathFor(system.id);
+}
+function systemLabel(system) {
+  return system.label ?? system.title ?? system.id;
+}
+function moduleSystemId(module) {
+  return module.systemId ?? module.key;
+}
+function isLifecycleEnabled2(system) {
+  if (system.enabled === false) return false;
+  return system.lifecycle !== "deprecated" && system.lifecycle !== "archived";
+}
+function isOrganizationModelSystemEnabled(organizationModel, systemId) {
+  const system = defaultSystems(organizationModel).find((candidate) => candidate.id === systemId);
+  return system ? isLifecycleEnabled2(system) : void 0;
+}
+function resolveSystemModules(systems, isSystemEnabled) {
+  return systems.map((system) => {
+    const systemId = system.systemId;
+    const accessKey = systemId ?? system.key;
+    return {
+      ...system,
+      systemId,
+      access: {
+        systemKey: system.key,
+        systemId,
+        enabled: isSystemEnabled(accessKey)
+      },
+      semantics: {
+        capabilityIds: uniqueIds(system.capabilityIds ?? [])
+      }
+    };
+  });
+}
+function buildShellSystems(organizationModel, modules) {
+  const iconBySystemId = new Map(
+    modules.flatMap((module) => module.systemId ? [[moduleSystemId(module), module.icon]] : [])
+  );
+  return defaultSystems(organizationModel).map((system) => ({
+    ...system,
+    label: systemLabel(system),
+    path: systemPath(system),
+    iconComponent: iconBySystemId.get(system.id)
+  }));
+}
+function createShellModel(systems) {
+  const systemsRecord = Object.fromEntries(systems.map((s) => [s.id, s]));
+  return {
+    systems,
+    findByPath: (path) => findByPath(systemsRecord, normalizeRoutePath(path)),
+    findById: (id) => findById(systemsRecord, id),
+    childrenOf: (id) => childrenOf(systemsRecord, id),
+    ancestorsOf: (id) => ancestorsOf(systemsRecord, id),
+    parentOf: (id) => parentOf(systemsRecord, id),
+    topLevel: () => topLevel(systemsRecord),
+    requiresAdminFor: (id) => requiresAdminFor(systemsRecord, id),
+    devOnlyFor: (id) => devOnlyFor(systemsRecord, id)
+  };
+}
+function resolveOrganizationGraphSystem(systems, shellModel) {
+  for (const system of systems) {
+    const graphBridge = system.organizationGraph;
+    if (!graphBridge) continue;
+    const systemId = graphBridge.systemId;
+    if (!systemId) continue;
+    const node = shellModel.findById(systemId);
+    return {
+      available: Boolean(node),
+      systemId,
+      systemPath: node ? systemPath(node) : void 0
+    };
+  }
+  return {
+    available: false
+  };
+}
+function findMatchingNode(shellModel, currentPath) {
+  const normalizedPath = normalizeRoutePath(currentPath);
+  const exact = shellModel.findByPath(normalizedPath);
+  if (exact) return exact;
+  return [...shellModel.systems].filter((system) => {
+    const path = normalizeRoutePath(systemPath(system));
+    return path !== "/" && isRouteMatch(normalizedPath, path);
+  }).sort((a, b) => systemPath(b).length - systemPath(a).length)[0];
+}
+function ownsNode(module, node) {
+  if (!node || !module.systemId) return false;
+  return node.id === module.systemId || node.id.startsWith(`${module.systemId}.`);
+}
+function ownsRoutePrefix(module, normalizedPath) {
+  return (module.routePrefixes ?? []).some((prefix) => isRouteMatch(normalizedPath, normalizeRoutePath(prefix)));
+}
+function resolveRoute(systems, shellModel, currentPath, disabledSubsectionPaths) {
+  const node = findMatchingNode(shellModel, currentPath);
+  const normalizedPath = normalizeRoutePath(currentPath);
+  if (disabledSubsectionPaths.some((disabledPath) => isRouteMatch(normalizedPath, disabledPath))) {
+    return {
+      status: "hidden",
+      path: currentPath,
+      node
+    };
+  }
+  const system = systems.find((candidate) => ownsNode(candidate, node)) ?? systems.filter((candidate) => ownsRoutePrefix(candidate, normalizedPath)).sort(
+    (a, b) => Math.max(...(b.routePrefixes ?? []).map((prefix) => prefix.length)) - Math.max(...(a.routePrefixes ?? []).map((prefix) => prefix.length))
+  )[0];
+  if (!system) {
+    return {
+      status: "unmatched",
+      path: currentPath,
+      node
+    };
+  }
+  return {
+    status: "matched",
+    path: currentPath,
+    system,
+    node
+  };
+}
+function ElevasisSystemsProvider({
+  systems,
+  organizationModel,
+  timeRange,
+  operationsApiUrl,
+  operationsSSEManager,
+  deliveryApiUrl,
+  deliverySSEManager,
+  disabledSubsectionPaths = [],
+  children
+}) {
+  const activeSystems = systems ?? [];
+  const resolvedOrganizationModel = useMemo(() => {
+    if (!organizationModel) {
+      return void 0;
+    }
+    return {
+      ...organizationModel,
+      knowledge: organizationModel.knowledge ?? {}
+    };
+  }, [organizationModel]);
+  useMemo(() => validateManifests(activeSystems, resolvedOrganizationModel), [activeSystems, resolvedOrganizationModel]);
+  const hasResolvedSystem = useCallback(
+    (key) => {
+      const organizationModelSystemEnabled = isOrganizationModelSystemEnabled(resolvedOrganizationModel, key);
+      return organizationModelSystemEnabled ?? true;
+    },
+    [resolvedOrganizationModel]
+  );
+  const shellSystems = useMemo(
+    () => buildShellSystems(resolvedOrganizationModel, activeSystems),
+    [resolvedOrganizationModel, activeSystems]
+  );
+  const shellModel = useMemo(() => createShellModel(shellSystems), [shellSystems]);
+  const normalizedDisabledSubsectionPaths = useMemo(
+    () => [...new Set(disabledSubsectionPaths.map((path) => normalizeRoutePath(path)))],
+    [disabledSubsectionPaths]
+  );
+  const resolvedSystems = useMemo(
+    () => resolveSystemModules(activeSystems, hasResolvedSystem),
+    [activeSystems, hasResolvedSystem]
+  );
+  const enabledResolvedSystems = useMemo(
+    () => resolvedSystems.filter((system) => system.access.enabled),
+    [resolvedSystems]
+  );
+  const organizationGraph = useMemo(
+    () => resolveOrganizationGraphSystem(enabledResolvedSystems, shellModel),
+    [enabledResolvedSystems, shellModel]
+  );
+  const getResolvedSystem = useCallback(
+    (key) => resolvedSystems.find((system) => system.key === key),
+    [resolvedSystems]
+  );
+  const isSystemEnabled = useCallback((key) => hasResolvedSystem(key), [hasResolvedSystem]);
+  const getSidebarLinks = useCallback(
+    (options = {}) => projectSidebarLinks({
+      shellModel,
+      organizationModel: resolvedOrganizationModel,
+      isSystemEnabled,
+      ...options
+    }),
+    [shellModel, resolvedOrganizationModel, isSystemEnabled]
+  );
+  const resolveRouteByPath = useCallback(
+    (path) => resolveRoute(enabledResolvedSystems, shellModel, path, normalizedDisabledSubsectionPaths),
+    [enabledResolvedSystems, shellModel, normalizedDisabledSubsectionPaths]
+  );
+  const shellRuntime = useMemo(
+    () => ({
+      resolveRoute: resolveRouteByPath
+    }),
+    [resolveRouteByPath]
+  );
+  const value = useMemo(
+    () => ({
+      shellModel,
+      shellRuntime,
+      getSidebarLinks,
+      enabledResolvedSystems,
+      resolvedSystems,
+      organizationGraph,
+      organizationModel: resolvedOrganizationModel,
+      timeRange,
+      operationsApiUrl,
+      operationsSSEManager,
+      deliveryApiUrl,
+      deliverySSEManager,
+      disabledSubsectionPaths: normalizedDisabledSubsectionPaths,
+      isSystemEnabled,
+      getResolvedSystem
+    }),
+    [
+      shellModel,
+      shellRuntime,
+      enabledResolvedSystems,
+      resolvedSystems,
+      organizationGraph,
+      resolvedOrganizationModel,
+      timeRange,
+      operationsApiUrl,
+      operationsSSEManager,
+      deliveryApiUrl,
+      deliverySSEManager,
+      normalizedDisabledSubsectionPaths,
+      isSystemEnabled,
+      getResolvedSystem,
+      getSidebarLinks
+    ]
+  );
+  return /* @__PURE__ */ jsx(ElevasisSystemsContext.Provider, { value, children });
+}
+
+export { ElevasisSystemsProvider, useElevasisSystems, useOptionalElevasisSystems };

package/dist/chunk-S3KBYQTI.js

@@ -0,0 +1,39 @@
+import { usePresetsContext } from './chunk-CWYQRM5T.js';
+import { useMemo } from 'react';
+
+var BUILT_IN_NAMES = /* @__PURE__ */ new Set([
+  "default",
+  "tactical",
+  "regal",
+  "cyber-volt",
+  "aurora",
+  "rose-gold",
+  "midnight",
+  "titanium",
+  "obsidian",
+  "honey",
+  "abyss",
+  "canopy",
+  "slate",
+  "cyber-strike",
+  "cyber-chrome",
+  "cyber-void",
+  "quarry"
+]);
+function titleCase(str) {
+  return str.replace(/(^|-)(\w)/g, (_, sep, char) => (sep ? " " : "") + char.toUpperCase());
+}
+function useAvailablePresets() {
+  const presetsMap = usePresetsContext();
+  return useMemo(() => {
+    return Object.entries(presetsMap).map(([key, preset]) => ({
+      value: key,
+      label: preset.label ?? titleCase(key),
+      description: preset.description ?? "",
+      colors: preset.colors ?? [preset.dark.primary, preset.dark.background, preset.light.background],
+      isCustom: !BUILT_IN_NAMES.has(key)
+    }));
+  }, [presetsMap]);
+}
+
+export { useAvailablePresets };

package/dist/chunk-S3XR4II4.js

@@ -0,0 +1,30 @@
+import { Group, Box, Title, Text, ThemeIcon } from '@mantine/core';
+import { jsxs, jsx } from 'react/jsx-runtime';
+
+// src/components/display/CardHeader.tsx
+function CardHeader({
+  icon,
+  title,
+  subtitle,
+  rightSection,
+  titleOrder = 3,
+  iconColor,
+  mb = "md"
+}) {
+  const wrappedIcon = icon ? /* @__PURE__ */ jsx(ThemeIcon, { size: "md", variant: "light", color: iconColor, children: icon }) : null;
+  return /* @__PURE__ */ jsxs(Group, { justify: "space-between", mb, gap: "md", align: "flex-start", wrap: "nowrap", children: [
+    subtitle ? /* @__PURE__ */ jsxs(Box, { style: { minWidth: 0 }, children: [
+      /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
+        wrappedIcon,
+        /* @__PURE__ */ jsx(Title, { order: titleOrder, style: { overflowWrap: "anywhere" }, children: title })
+      ] }),
+      /* @__PURE__ */ jsx(Text, { size: "sm", mt: 2, style: { color: "var(--color-text-dimmed)", overflowWrap: "anywhere" }, children: subtitle })
+    ] }) : /* @__PURE__ */ jsxs(Group, { gap: "xs", children: [
+      wrappedIcon,
+      /* @__PURE__ */ jsx(Title, { order: titleOrder, style: { overflowWrap: "anywhere" }, children: title })
+    ] }),
+    rightSection
+  ] });
+}
+
+export { CardHeader };