@elevasis/ui 2.31.0 → 2.33.0

package/dist/chunk-ZGTDKH3P.js

@@ -0,0 +1,467 @@
+import { getSemanticIconComponent } from './chunk-DWXDNT7P.js';
+import { devOnlyFor, requiresAdminFor, topLevel, parentOf, ancestorsOf, childrenOf, findById, findByPath, listAllSystems, defaultPathFor, getSortedSidebarEntries } from './chunk-GNRMB6DC.js';
+import { useInitialization } from './chunk-533DUEQY.js';
+import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { createContext, useMemo, useCallback, useContext } from 'react';
+import { jsx } 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
+    };
+  };
+}
+
+// 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)];
+}
+var useFeatureAccess = createFeatureAccessHook({
+  useInitialization,
+  useOrganization
+});
+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: {
+        featureKey: 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 { hasFeature } = useFeatureAccess();
+  const hasResolvedSystem = useCallback(
+    (key) => {
+      if (!hasFeature(key)) {
+        return false;
+      }
+      const organizationModelSystemEnabled = isOrganizationModelSystemEnabled(resolvedOrganizationModel, key);
+      return organizationModelSystemEnabled ?? true;
+    },
+    [hasFeature, 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, createFeatureAccessHook, useElevasisSystems, useOptionalElevasisSystems };

package/dist/components/chat/index.js

@@ -1,3 +1,3 @@
 export { ChatHeader, ChatInputArea, ChatInterface, ChatSidebar, MessageBubble, ProcessingIndicator } from '../../chunk-CXY7FMUM.js';
 import '../../chunk-3KMDHCAR.js';
-import '../../chunk-DZTG5IAC.js';
+import '../../chunk-I2KLQ2HA.js';

package/dist/components/index.css

@@ -534,6 +534,14 @@
 .mantine-Accordion-control:hover {
   background-color: var(--color-surface-hover);
 }
+[data-mantine-color-scheme] .mantine-Accordion-root .mantine-Accordion-item {
+  --item-filled-color: var(--color-surface);
+  --item-border-color: var(--color-border);
+}
+[data-mantine-color-scheme] .mantine-Accordion-root[data-variant=separated] .mantine-Accordion-item[data-active] {
+  background-color: var(--color-surface);
+  border-color: var(--color-border);
+}
 .mantine-Menu-item:hover:not([data-disabled]) {
   background-color: var(--color-surface-hover);
 }
@@ -599,6 +607,36 @@
   background-color: var(--color-primary);
   border-color: var(--color-primary);
 }
+.mantine-Tree-node:focus-visible > [data-value] {
+  outline: 2px solid color-mix(in srgb, var(--color-primary) 55%, transparent);
+  outline-offset: 2px;
+}
+.mantine-Tree-label[data-hovered] {
+  background-color: var(--color-surface-hover);
+  border-color: var(--color-border);
+}
+.mantine-Tree-label[data-selected] {
+  background-color: color-mix(in srgb, var(--color-primary) 12%, transparent);
+  border-color: color-mix(in srgb, var(--color-primary) 38%, var(--color-border));
+  color: var(--color-primary);
+}
+[data-knowledge-article] pre {
+  white-space: pre-wrap;
+  word-break: break-word;
+  overflow-x: auto;
+  max-width: 100%;
+  padding: var(--mantine-spacing-sm);
+  background-color: var(--color-surface);
+  border: 1px solid var(--color-border);
+  border-radius: var(--mantine-radius-sm);
+}
+[data-knowledge-article] pre code {
+  background: transparent;
+  border: none;
+  padding: 0;
+  white-space: inherit;
+  word-break: inherit;
+}
 .recharts-surface:focus {
   outline: none;
 }