@elevasis/ui 2.2.0 → 2.3.0

package/dist/{chunk-MZPVNRPL.js → chunk-ISHNN42L.js}

@@ -184,7 +184,15 @@ function useOptionalElevasisFeatures() {
   return useContext(ElevasisFeaturesContext);
 }
 function getEnabledFeatures(features, hasFeature) {
-  return features.filter((feature) => hasFeature(feature.key));
+  return features.filter((feature) => {
+    const accessKeys = [feature.key, feature.navEntry?.featureKey].filter(
+      (key) => Boolean(key)
+    );
+    if (accessKeys.length === 0) {
+      return true;
+    }
+    return accessKeys.some((key) => hasFeature(key));
+  });
 }
 function normalizeRoutePath(path) {
   const trimmedPath = path.trim();
@@ -198,6 +206,90 @@ function isRouteMatch(currentPath, route) {
   const normalizedRoute = normalizeRoutePath(route);
   return normalizedCurrentPath === normalizedRoute || normalizedCurrentPath.startsWith(`${normalizedRoute}/`);
 }
+function hasOrganizationModelFeatureKey(organizationModel, key) {
+  if (!organizationModel) {
+    return false;
+  }
+  return Object.prototype.hasOwnProperty.call(organizationModel.features.enabled, key);
+}
+function findSurfaceByPath(organizationModel, path) {
+  if (!organizationModel) {
+    return void 0;
+  }
+  const normalizedPath = normalizeRoutePath(path);
+  return organizationModel.navigation.surfaces.find(
+    (surface) => normalizeRoutePath(surface.path) === normalizedPath
+  );
+}
+function findSurfaceById(organizationModel, id) {
+  if (!organizationModel) {
+    return void 0;
+  }
+  return organizationModel.navigation.surfaces.find((surface) => surface.id === id);
+}
+function getOrganizationModelFeatureLabel(organizationModel, key) {
+  if (!organizationModel || !key) {
+    return void 0;
+  }
+  if (!hasOrganizationModelFeatureKey(organizationModel, key)) {
+    return void 0;
+  }
+  return organizationModel.features.labels[key];
+}
+function isOrganizationModelFeatureEnabled(organizationModel, key) {
+  if (!organizationModel) {
+    return void 0;
+  }
+  if (!hasOrganizationModelFeatureKey(organizationModel, key)) {
+    return void 0;
+  }
+  return organizationModel.features.enabled[key];
+}
+function resolveOrganizationGraphSurface(features, organizationModel) {
+  for (const feature of features) {
+    const graphBridge = feature.organizationGraph;
+    if (!graphBridge) {
+      continue;
+    }
+    const surface = findSurfaceById(organizationModel, graphBridge.surfaceId);
+    return {
+      available: Boolean(surface),
+      surfaceId: graphBridge.surfaceId,
+      surfacePath: surface?.path,
+      surfaceType: surface?.surfaceType,
+      featureKey: surface?.featureKey
+    };
+  }
+  return {
+    available: false
+  };
+}
+function resolveNavLink(link, organizationModel) {
+  const matchedSurface = findSurfaceByPath(organizationModel, link.link);
+  const featureLabel = getOrganizationModelFeatureLabel(organizationModel, link.featureKey);
+  return {
+    ...link,
+    label: matchedSurface?.label ?? featureLabel ?? link.label,
+    link: matchedSurface?.path ?? link.link,
+    links: link.links?.map((nestedLink) => resolveNavLink(nestedLink, organizationModel))
+  };
+}
+function resolveFeatureModule(feature, organizationModel) {
+  if (!feature.navEntry) {
+    return feature;
+  }
+  const matchedSurface = feature.navEntry.link ? findSurfaceByPath(organizationModel, feature.navEntry.link) : void 0;
+  const featureLabel = getOrganizationModelFeatureLabel(organizationModel, feature.navEntry.featureKey);
+  return {
+    ...feature,
+    navEntry: {
+      ...feature.navEntry,
+      label: matchedSurface?.label ?? featureLabel ?? feature.navEntry.label,
+      link: matchedSurface?.path ?? feature.navEntry.link,
+      links: feature.navEntry.links?.map((link) => resolveNavLink(link, organizationModel))
+    }
+  };
+}
 function filterNavLinks(links, disabledSubsectionPaths, isFeatureEnabled) {
   return links.flatMap((link) => {
     if (link.featureKey && !isFeatureEnabled(link.featureKey)) {
@@ -282,6 +374,7 @@ function resolveNavRoute(features, currentPath, disabledSubsectionPaths, isFeatu
 }
 function ElevasisFeaturesProvider({
   features,
+  organizationModel,
   timeRange,
   operationsApiUrl,
   operationsSSEManager,
@@ -289,22 +382,49 @@ function ElevasisFeaturesProvider({
   children
 }) {
   const { hasFeature } = useFeatureAccess();
+  const hasResolvedFeature = useCallback(
+    (key) => {
+      if (!hasFeature(key)) {
+        return false;
+      }
+      const organizationModelFeatureEnabled = isOrganizationModelFeatureEnabled(
+        organizationModel,
+        key
+      );
+      if (organizationModelFeatureEnabled === void 0) {
+        return true;
+      }
+      return organizationModelFeatureEnabled;
+    },
+    [hasFeature, organizationModel]
+  );
   const normalizedDisabledSubsectionPaths = useMemo(
     () => disabledSubsectionPaths.map((path) => normalizeRoutePath(path)),
     [disabledSubsectionPaths]
   );
-  const enabledFeatures = useMemo(() => getEnabledFeatures(features, hasFeature), [features, hasFeature]);
+  const enabledFeatures = useMemo(
+    () => getEnabledFeatures(features, hasResolvedFeature).map((feature) => resolveFeatureModule(feature, organizationModel)),
+    [features, hasResolvedFeature, organizationModel]
+  );
+  const allFeatures = useMemo(
+    () => features.map((feature) => resolveFeatureModule(feature, organizationModel)),
+    [features, organizationModel]
+  );
   const navItems = useMemo(
-    () => getNavItems(enabledFeatures, normalizedDisabledSubsectionPaths, hasFeature),
-    [enabledFeatures, normalizedDisabledSubsectionPaths, hasFeature]
+    () => getNavItems(enabledFeatures, normalizedDisabledSubsectionPaths, hasResolvedFeature),
+    [enabledFeatures, normalizedDisabledSubsectionPaths, hasResolvedFeature]
+  );
+  const organizationGraph = useMemo(
+    () => resolveOrganizationGraphSurface(enabledFeatures, organizationModel),
+    [enabledFeatures, organizationModel]
   );
   const getFeature = useCallback(
-    (key) => features.find((feature) => feature.key === key),
-    [features]
+    (key) => allFeatures.find((feature) => feature.key === key),
+    [allFeatures]
   );
   const isFeatureEnabled = useCallback(
-    (key) => enabledFeatures.some((feature) => feature.key === key),
-    [enabledFeatures]
+    (key) => hasResolvedFeature(key),
+    [hasResolvedFeature]
   );
   const resolveNavRouteByPath = useCallback(
     (path) => resolveNavRoute(enabledFeatures, path, normalizedDisabledSubsectionPaths, isFeatureEnabled),
@@ -314,7 +434,9 @@ function ElevasisFeaturesProvider({
     () => ({
       navItems,
       enabledFeatures,
-      allFeatures: features,
+      allFeatures,
+      organizationGraph,
+      organizationModel,
       timeRange,
       operationsApiUrl,
       operationsSSEManager,
@@ -326,7 +448,9 @@ function ElevasisFeaturesProvider({
     [
       navItems,
       enabledFeatures,
-      features,
+      allFeatures,
+      organizationGraph,
+      organizationModel,
       timeRange,
       operationsApiUrl,
       operationsSSEManager,

package/dist/{chunk-PFONCU6C.js → chunk-IWFIKQR5.js}

@@ -1,5 +1,5 @@
 import { useCyberColors, CyberLegendItem, CyberAreaChart } from './chunk-KFICYU6S.js';
-import { useResourcesHealth } from './chunk-J5TBNCMD.js';
+import { useResourcesHealth } from './chunk-2XWEOJSX.js';
 import { getTimeRangeDates, formatBucketTime } from './chunk-LXHZYSMQ.js';
 import { CardHeader, EmptyState } from './chunk-Y3D3WFJG.js';
 import { Paper, Center, Loader, Group } from '@mantine/core';

package/dist/{chunk-QITPFGWC.js → chunk-JT7WDIZI.js}

@@ -1,6 +1,6 @@
-import { PRESETS, getPreset, generateShades, mantineThemeOverride, createCssVariablesResolver, PresetsProvider } from './chunk-RB34YOIX.js';
+import { PRESETS, getPreset, generateShades, mantineThemeOverride, createCssVariablesResolver, PresetsProvider } from './chunk-47YILFON.js';
 import { AppBackground } from './chunk-CYXZHBP4.js';
-import { ElevasisCoreProvider } from './chunk-MZPVNRPL.js';
+import { ElevasisCoreProvider } from './chunk-ISHNN42L.js';
 import { ElevasisLoader } from './chunk-Y3D3WFJG.js';
 import { AppearanceProvider } from './chunk-QJ2KCHKX.js';
 import { getErrorInfo, formatErrorMessage, getErrorTitle } from './chunk-IOKL7BKE.js';