@elevasis/ui 2.20.0 → 2.21.0

package/dist/chunk-LR5CRY5A.js

@@ -1,514 +0,0 @@
-import { SubshellContainer, SubshellSidebar, SubshellRightSideContainer } from './chunk-RX4UWZZR.js';
-import { FeatureUnavailableState } from './chunk-BHR7IV72.js';
-import { useRouterContext } from './chunk-Q7DJKLEN.js';
-import { useInitialization } from './chunk-DK2HVHCY.js';
-import { useOrganization } from './chunk-DD3CCMCZ.js';
-import { createContext, useMemo, useCallback, useContext } from 'react';
-import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
-
-function createFeatureAccessHook({
-  useInitialization: useInitialization2,
-  useOrganization: useOrganization2
-}) {
-  return function useFeatureAccess2() {
-    const { profile, organizationReady } = useInitialization2();
-    const { currentMembership } = useOrganization2();
-    const { orgConfig, membershipConfig } = useMemo(() => {
-      const organizationConfig = currentMembership?.organization?.config;
-      const memberConfig = currentMembership?.config;
-      return { orgConfig: organizationConfig, membershipConfig: memberConfig };
-    }, [currentMembership]);
-    const userConfig = profile?.config;
-    const checkFeature = useCallback(
-      (featureKey) => {
-        if (profile?.is_platform_admin) {
-          return { allowed: true, restrictedBy: null };
-        }
-        const membershipValue = membershipConfig?.features?.[featureKey];
-        if (membershipValue === false) return { allowed: false, restrictedBy: "membership" };
-        return { allowed: true, restrictedBy: null };
-      },
-      [profile?.is_platform_admin, membershipConfig]
-    );
-    const hasFeature = useCallback((featureKey) => checkFeature(featureKey).allowed, [checkFeature]);
-    return {
-      orgConfig,
-      membershipConfig,
-      userConfig,
-      hasFeature,
-      checkFeature,
-      isReady: organizationReady
-    };
-  };
-}
-var createUseFeatureAccess = createFeatureAccessHook;
-
-// 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)] : [];
-}
-function collectNavLinkPaths(links) {
-  if (!links?.length) {
-    return [];
-  }
-  return links.flatMap((link) => [link.link, ...collectNavLinkPaths(link.links)]);
-}
-
-// src/provider/validateManifests.ts
-function validateManifests(manifests, organizationModel) {
-  if (!organizationModel) {
-    return;
-  }
-  const validFeatureIds = new Set(organizationModel.features.map((f) => f.id));
-  const validCapabilityIds = /* @__PURE__ */ new Set([
-    ...organizationModel.features.flatMap((f) => f.capabilityIds),
-    ...organizationModel.navigation.surfaces.flatMap((s) => s.capabilityIds),
-    ...organizationModel.resourceMappings.flatMap((r) => r.capabilityIds)
-  ]);
-  const errors = [];
-  for (const manifest of manifests) {
-    const key = manifest.key;
-    if (!validFeatureIds.has(manifest.featureId)) {
-      errors.push(
-        `Manifest "${key}": featureId "${manifest.featureId}" is not a known feature id. Valid values: ${[...validFeatureIds].sort().join(", ")}`
-      );
-    }
-    if (manifest.capabilityIds) {
-      for (let i = 0; i < manifest.capabilityIds.length; i++) {
-        const capabilityId = manifest.capabilityIds[i];
-        if (!validCapabilityIds.has(capabilityId)) {
-          errors.push(
-            `Manifest "${key}": capabilityIds[${i}] references unknown capability "${capabilityId}". Valid capabilities: ${[...validCapabilityIds].sort().join(", ")}`
-          );
-        }
-      }
-    }
-  }
-  if (errors.length > 0) {
-    throw new Error(
-      `Feature manifest validation failed with ${errors.length} error(s):
-` + errors.map((e, i) => `  ${i + 1}. ${e}`).join("\n")
-    );
-  }
-}
-var useFeatureAccess = createFeatureAccessHook({
-  useInitialization,
-  useOrganization
-});
-var ElevasisFeaturesContext = createContext(null);
-function useElevasisFeatures() {
-  const context = useContext(ElevasisFeaturesContext);
-  if (!context) {
-    throw new Error(
-      "useElevasisFeatures must be used within an ElevasisFeaturesProvider. Wrap your app (or the relevant subtree) with <ElevasisFeaturesProvider>."
-    );
-  }
-  return context;
-}
-function useOptionalElevasisFeatures() {
-  return useContext(ElevasisFeaturesContext);
-}
-function findOrganizationModelFeature(organizationModel, featureId) {
-  if (!organizationModel) {
-    return void 0;
-  }
-  return organizationModel.features.find((f) => f.id === featureId);
-}
-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 findSurfacesByPaths(organizationModel, paths) {
-  if (!organizationModel || paths.length === 0) {
-    return [];
-  }
-  const normalizedPaths = new Set(paths.map((path) => normalizeRoutePath(path)));
-  return organizationModel.navigation.surfaces.filter(
-    (surface) => normalizedPaths.has(normalizeRoutePath(surface.path))
-  );
-}
-function getOrganizationModelFeatureLabel(organizationModel, featureId) {
-  if (!organizationModel || !featureId) {
-    return void 0;
-  }
-  return findOrganizationModelFeature(organizationModel, featureId)?.label;
-}
-function isOrganizationModelFeatureEnabled(organizationModel, featureId) {
-  if (!organizationModel) {
-    return void 0;
-  }
-  const feature = findOrganizationModelFeature(organizationModel, featureId);
-  if (!feature) {
-    return void 0;
-  }
-  return feature.enabled;
-}
-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,
-      featureId: surface?.featureId
-    };
-  }
-  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 resolveNavEntry(navEntry, organizationModel, ownerFeatureId) {
-  const matchedSurface = navEntry.link ? findSurfaceByPath(organizationModel, navEntry.link) : void 0;
-  const featureLabel = getOrganizationModelFeatureLabel(organizationModel, navEntry.featureKey ?? ownerFeatureId);
-  return {
-    ...navEntry,
-    label: featureLabel ?? matchedSurface?.label ?? navEntry.label,
-    link: matchedSurface?.path ?? navEntry.link,
-    links: navEntry.links?.map((link) => resolveNavLink(link, organizationModel))
-  };
-}
-function resolveFeatureModule(feature, organizationModel) {
-  if (!feature.navEntry) {
-    return feature;
-  }
-  return {
-    ...feature,
-    navEntry: resolveNavEntry(feature.navEntry, organizationModel, feature.featureId)
-  };
-}
-function resolveFeatureSemantics(feature, resolvedFeature, organizationModel) {
-  const linkedPaths = [resolvedFeature.navEntry?.link, ...collectNavLinkPaths(resolvedFeature.navEntry?.links)].filter(
-    (path) => Boolean(path)
-  );
-  const linkedSurfaces = findSurfacesByPaths(organizationModel, linkedPaths);
-  const organizationGraphSurface = feature.organizationGraph ? findSurfaceById(organizationModel, feature.organizationGraph.surfaceId) : void 0;
-  const surfaces = [...linkedSurfaces, ...organizationGraphSurface ? [organizationGraphSurface] : []].filter(
-    (surface, index, items) => Boolean(surface) && items.findIndex((candidate) => candidate.id === surface.id) === index
-  );
-  return {
-    capabilityIds: uniqueIds([
-      ...feature.capabilityIds ?? [],
-      ...surfaces.flatMap((surface) => surface.capabilityIds)
-    ]),
-    surfaceIds: surfaces.map((surface) => surface.id),
-    surfaces
-  };
-}
-function resolveFeatureModules(features, organizationModel, isFeatureEnabled) {
-  return features.map((feature) => {
-    const resolvedFeature = resolveFeatureModule(feature, organizationModel);
-    const featureId = feature.featureId;
-    return {
-      ...resolvedFeature,
-      access: {
-        featureId,
-        enabled: isFeatureEnabled(featureId)
-      },
-      semantics: resolveFeatureSemantics(feature, resolvedFeature, organizationModel)
-    };
-  });
-}
-function filterNavLinks(links, disabledSubsectionPaths, isFeatureEnabled) {
-  return links.flatMap((link) => {
-    if (link.featureKey && !isFeatureEnabled(link.featureKey)) {
-      return [];
-    }
-    if (disabledSubsectionPaths.some((disabledPath) => isRouteMatch(link.link, disabledPath))) {
-      return [];
-    }
-    const nestedLinks = link.links?.length ? filterNavLinks(link.links, disabledSubsectionPaths, isFeatureEnabled) : void 0;
-    return [
-      {
-        ...link,
-        links: nestedLinks
-      }
-    ];
-  });
-}
-function createShellNavItem(navEntry, placement, source, featureId, links = navEntry.links) {
-  return {
-    ...navEntry,
-    links,
-    placement,
-    source,
-    featureId
-  };
-}
-function createFeatureShellNavItem(feature, links = feature.navEntry?.links) {
-  if (!feature.navEntry) {
-    return void 0;
-  }
-  return createShellNavItem(feature.navEntry, "primary", "feature", feature.access.featureId, links);
-}
-function getFeatureNavItems(features, disabledSubsectionPaths, isFeatureEnabled) {
-  return features.flatMap((feature) => {
-    if (!feature.navEntry) {
-      return [];
-    }
-    const links = feature.navEntry.links?.length ? filterNavLinks(feature.navEntry.links, disabledSubsectionPaths, isFeatureEnabled) : void 0;
-    const navItem = createFeatureShellNavItem(feature, links);
-    return navItem ? [navItem] : [];
-  });
-}
-function resolveAppShellOverrides(appShellOverrides, organizationModel) {
-  if (!appShellOverrides) {
-    return {};
-  }
-  return {
-    primaryNavItems: appShellOverrides.primaryNavItems?.map((navItem) => resolveNavEntry(navItem, organizationModel)),
-    bottomNavItems: appShellOverrides.bottomNavItems?.map((navItem) => resolveNavEntry(navItem, organizationModel))
-  };
-}
-function getAppShellNavItems(navItems, placement, disabledSubsectionPaths, isFeatureEnabled) {
-  if (!navItems?.length) {
-    return [];
-  }
-  return navItems.flatMap((navItem) => {
-    if (navItem.featureKey && !isFeatureEnabled(navItem.featureKey)) {
-      return [];
-    }
-    const links = navItem.links?.length ? filterNavLinks(navItem.links, disabledSubsectionPaths, isFeatureEnabled) : void 0;
-    if (navItem.links && !links?.length && !navItem.link) {
-      return [];
-    }
-    return [createShellNavItem(navItem, placement, "app", navItem.featureKey, links)];
-  });
-}
-function findMatchingNavLink(links, currentPath) {
-  for (const link of links) {
-    if (link.links?.length) {
-      const nestedLink = findMatchingNavLink(link.links, currentPath);
-      if (nestedLink) {
-        return nestedLink;
-      }
-    }
-    if (isRouteMatch(currentPath, link.link)) {
-      return link;
-    }
-  }
-  return null;
-}
-function isHiddenNavLink(link, disabledSubsectionPaths, isFeatureEnabled) {
-  if (link.featureKey && !isFeatureEnabled(link.featureKey)) {
-    return true;
-  }
-  return disabledSubsectionPaths.some((disabledPath) => isRouteMatch(link.link, disabledPath));
-}
-function resolveRoute(features, currentPath, disabledSubsectionPaths, isFeatureEnabled) {
-  for (const feature of features) {
-    const navEntry = feature.navEntry;
-    const matchesSubshell = feature.subshellRoutes?.some((route) => isRouteMatch(currentPath, route)) ?? false;
-    const matchesEntryLink = navEntry?.link ? isRouteMatch(currentPath, navEntry.link) : false;
-    const matchedLink = navEntry?.links?.length ? findMatchingNavLink(navEntry.links, currentPath) : null;
-    if (!matchesSubshell && !matchesEntryLink && !matchedLink) {
-      continue;
-    }
-    if (matchedLink && isHiddenNavLink(matchedLink, disabledSubsectionPaths, isFeatureEnabled)) {
-      return {
-        status: "hidden",
-        path: currentPath,
-        feature,
-        navItem: createFeatureShellNavItem(feature),
-        navLink: matchedLink
-      };
-    }
-    return {
-      status: "matched",
-      path: currentPath,
-      feature,
-      navItem: createFeatureShellNavItem(feature),
-      navLink: matchedLink ?? void 0
-    };
-  }
-  return {
-    status: "unmatched",
-    path: currentPath
-  };
-}
-function ElevasisFeaturesProvider({
-  features,
-  organizationModel,
-  appShellOverrides,
-  timeRange,
-  operationsApiUrl,
-  operationsSSEManager,
-  deliveryApiUrl,
-  deliverySSEManager,
-  disabledSubsectionPaths = [],
-  children
-}) {
-  useMemo(() => validateManifests(features, organizationModel), [features, organizationModel]);
-  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(() => {
-    const explicit = disabledSubsectionPaths.map((path) => normalizeRoutePath(path));
-    const fromModel = organizationModel?.navigation.surfaces.filter((s) => s.enabled === false).map((s) => normalizeRoutePath(s.path)) ?? [];
-    return [.../* @__PURE__ */ new Set([...explicit, ...fromModel])];
-  }, [disabledSubsectionPaths, organizationModel]);
-  const resolvedFeatures = useMemo(
-    () => resolveFeatureModules(features, organizationModel, hasResolvedFeature),
-    [features, organizationModel, hasResolvedFeature]
-  );
-  const resolvedAppShellOverrides = useMemo(
-    () => resolveAppShellOverrides(appShellOverrides, organizationModel),
-    [appShellOverrides, organizationModel]
-  );
-  const enabledResolvedFeatures = useMemo(
-    () => resolvedFeatures.filter((feature) => feature.access.enabled),
-    [resolvedFeatures]
-  );
-  const featureNavItems = useMemo(
-    () => getFeatureNavItems(enabledResolvedFeatures, normalizedDisabledSubsectionPaths, hasResolvedFeature),
-    [enabledResolvedFeatures, normalizedDisabledSubsectionPaths, hasResolvedFeature]
-  );
-  const primaryNavItems = useMemo(
-    () => [
-      ...getAppShellNavItems(
-        resolvedAppShellOverrides.primaryNavItems,
-        "primary",
-        normalizedDisabledSubsectionPaths,
-        hasResolvedFeature
-      ),
-      ...featureNavItems
-    ],
-    [resolvedAppShellOverrides.primaryNavItems, normalizedDisabledSubsectionPaths, hasResolvedFeature, featureNavItems]
-  );
-  const bottomNavItems = useMemo(
-    () => getAppShellNavItems(
-      resolvedAppShellOverrides.bottomNavItems,
-      "bottom",
-      normalizedDisabledSubsectionPaths,
-      hasResolvedFeature
-    ),
-    [resolvedAppShellOverrides.bottomNavItems, normalizedDisabledSubsectionPaths, hasResolvedFeature]
-  );
-  const shellNavItems = useMemo(() => [...primaryNavItems, ...bottomNavItems], [primaryNavItems, bottomNavItems]);
-  const shellModel = useMemo(
-    () => ({
-      navItems: shellNavItems
-    }),
-    [shellNavItems]
-  );
-  const organizationGraph = useMemo(
-    () => resolveOrganizationGraphSurface(enabledResolvedFeatures, organizationModel),
-    [enabledResolvedFeatures, organizationModel]
-  );
-  const getResolvedFeature = useCallback(
-    (key) => resolvedFeatures.find((feature) => feature.key === key),
-    [resolvedFeatures]
-  );
-  const isFeatureEnabled = useCallback((key) => hasResolvedFeature(key), [hasResolvedFeature]);
-  const resolveRouteByPath = useCallback(
-    (path) => resolveRoute(enabledResolvedFeatures, path, normalizedDisabledSubsectionPaths, isFeatureEnabled),
-    [enabledResolvedFeatures, normalizedDisabledSubsectionPaths, isFeatureEnabled]
-  );
-  const shellRuntime = useMemo(
-    () => ({
-      resolveRoute: resolveRouteByPath
-    }),
-    [resolveRouteByPath]
-  );
-  const value = useMemo(
-    () => ({
-      shellModel,
-      shellRuntime,
-      enabledResolvedFeatures,
-      resolvedFeatures,
-      organizationGraph,
-      organizationModel,
-      timeRange,
-      operationsApiUrl,
-      operationsSSEManager,
-      deliveryApiUrl,
-      deliverySSEManager,
-      disabledSubsectionPaths: normalizedDisabledSubsectionPaths,
-      isFeatureEnabled,
-      getResolvedFeature
-    }),
-    [
-      shellModel,
-      shellRuntime,
-      enabledResolvedFeatures,
-      resolvedFeatures,
-      organizationGraph,
-      organizationModel,
-      timeRange,
-      operationsApiUrl,
-      operationsSSEManager,
-      deliveryApiUrl,
-      deliverySSEManager,
-      normalizedDisabledSubsectionPaths,
-      isFeatureEnabled,
-      getResolvedFeature
-    ]
-  );
-  return /* @__PURE__ */ jsx(ElevasisFeaturesContext.Provider, { value, children });
-}
-function FeatureShell({ children }) {
-  const { shellRuntime } = useElevasisFeatures();
-  const { currentPath } = useRouterContext();
-  const routeMatch = shellRuntime.resolveRoute(currentPath);
-  if (routeMatch.status === "hidden") {
-    return /* @__PURE__ */ jsx(FeatureUnavailableState, { path: currentPath });
-  }
-  if (routeMatch.status !== "matched" || !routeMatch.feature?.sidebar) {
-    return /* @__PURE__ */ jsx(Fragment, { children });
-  }
-  const SidebarComponent = routeMatch.feature.sidebar;
-  return /* @__PURE__ */ jsxs(SubshellContainer, { children: [
-    /* @__PURE__ */ jsx(SubshellSidebar, { width: 250, children: /* @__PURE__ */ jsx(SidebarComponent, {}) }),
-    /* @__PURE__ */ jsx(SubshellRightSideContainer, { children })
-  ] });
-}
-
-export { ElevasisFeaturesProvider, FeatureShell, createFeatureAccessHook, createUseFeatureAccess, useElevasisFeatures, useOptionalElevasisFeatures };

package/dist/chunk-MG3NF7QL.js

@@ -1,63 +0,0 @@
-import { useRouterContext } from './chunk-Q7DJKLEN.js';
-import { useMemo } from 'react';
-
-var useBreadcrumbs = (options = {}) => {
-  const { currentPath } = useRouterContext();
-  const { navItems = [] } = options;
-  return useMemo(() => {
-    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;
-      let label = formatSegmentLabel(segments[i]);
-      let matchedItem = null;
-      for (const navItem of navItems) {
-        if (navItem.link === currentSegmentPath) {
-          matchedItem = navItem;
-          break;
-        }
-        if (navItem.links) {
-          for (const subItem of navItem.links) {
-            if (subItem.link === currentSegmentPath) {
-              if (i === 0 && subItem.label === "Overview") {
-                matchedItem = { label: navItem.label };
-              } else {
-                matchedItem = subItem;
-              }
-              break;
-            }
-            if (subItem.links) {
-              for (const nestedLink of subItem.links) {
-                if (nestedLink.link === currentSegmentPath) {
-                  matchedItem = nestedLink;
-                  break;
-                }
-              }
-            }
-            if (matchedItem) break;
-          }
-        }
-        if (matchedItem) break;
-      }
-      if (matchedItem) {
-        label = matchedItem.label;
-      }
-      breadcrumbs.push({
-        label,
-        path: isLast ? void 0 : currentSegmentPath,
-        isActive: isLast
-      });
-    }
-    return breadcrumbs;
-  }, [currentPath, navItems]);
-};
-function formatSegmentLabel(segment) {
-  return segment.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-}
-
-export { useBreadcrumbs };