@elevasis/ui 2.31.0 → 2.32.0

package/dist/chunk-QXCDKE2O.js

@@ -0,0 +1,486 @@
+import { devOnlyFor, requiresAdminFor, topLevel, parentOf, ancestorsOf, childrenOf, findById, findByPath, listAllSystems, defaultPathFor, getSortedSidebarEntries } from './chunk-T35FWDAB.js';
+import { useInitialization } from './chunk-533DUEQY.js';
+import { useOrganization } from './chunk-DD3CCMCZ.js';
+import { createContext, useMemo, useCallback, useContext } from 'react';
+import { IconSettings, IconArchive, IconShieldLock, IconBriefcase, IconUsers, IconChartBar, IconCalendar, IconDashboard, IconBrain, IconActivity, IconCode, IconTarget, IconTool } from '@tabler/icons-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);
+var FALLBACK_SIDEBAR_ICONS = {
+  "feature.dashboard": IconDashboard,
+  "feature.business": IconBriefcase,
+  "feature.sales": IconTarget,
+  "feature.clients": IconUsers,
+  "feature.projects": IconBriefcase,
+  "feature.operations": IconCode,
+  "feature.monitoring": IconActivity,
+  "feature.knowledge": IconBrain,
+  "feature.settings": IconSettings,
+  "feature.admin": IconShieldLock,
+  dashboard: IconDashboard,
+  calendar: IconCalendar,
+  business: IconBriefcase,
+  sales: IconChartBar,
+  clients: IconUsers,
+  projects: IconBriefcase,
+  admin: IconShieldLock,
+  archive: IconArchive,
+  settings: IconSettings
+};
+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 FALLBACK_SIDEBAR_ICONS[node.icon] ?? IconTool;
+}
+function activeMatchPathsForSurface(node, context) {
+  const paths = (node.targets?.systems ?? []).flatMap(
+    (systemId) => context.shellModel.childrenOf(systemId).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 ?? { nodes: [] }
+    };
+  }, [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/{chunk-3BAPR3KA.js → chunk-RQA2EVN3.js}

@@ -367,6 +367,9 @@ var componentThemes = {
       }
     }
   }),
+  // Tree pseudo-class/attribute state selectors (&:focus-visible, &[data-hovered],
+  // &[data-selected]) are in custom.css -- Mantine's styles object applies these
+  // as inline styles and React rejects selector keys.
   Tree: Tree.extend({
     defaultProps: {
       levelOffset: DEFAULT_SIZE
@@ -380,11 +383,7 @@ var componentThemes = {
       },
       node: {
         listStyle: "none",
-        outline: "none",
-        "&:focus-visible > [data-value]": {
-          outline: "2px solid color-mix(in srgb, var(--color-primary) 55%, transparent)",
-          outlineOffset: "2px"
-        }
+        outline: "none"
       },
       subtree: {
         listStyle: "none",
@@ -402,16 +401,7 @@ var componentThemes = {
         border: "1px solid transparent",
         borderRadius: "var(--mantine-radius-sm)",
         color: "var(--color-text)",
-        transition: `background-color var(--duration-fast) var(--easing), border-color var(--duration-fast) var(--easing), color var(--duration-fast) var(--easing)`,
-        "&[data-hovered]": {
-          backgroundColor: "var(--color-surface-hover)",
-          borderColor: "var(--color-border)"
-        },
-        "&[data-selected]": {
-          backgroundColor: "color-mix(in srgb, var(--color-primary) 12%, transparent)",
-          borderColor: "color-mix(in srgb, var(--color-primary) 38%, var(--color-border))",
-          color: "var(--color-primary)"
-        }
+        transition: `background-color var(--duration-fast) var(--easing), border-color var(--duration-fast) var(--easing), color var(--duration-fast) var(--easing)`
       }
     }
   }),

package/dist/{chunk-HYNYEBHM.js → chunk-RQTWIXJ5.js}

@@ -1,10 +1,10 @@
-import { mantineThemeOverride, createCssVariablesResolver, PresetsProvider } from './chunk-3BAPR3KA.js';
+import { mantineThemeOverride, createCssVariablesResolver, PresetsProvider } from './chunk-RQA2EVN3.js';
 import { PRESETS, getPreset, generateShades } from './chunk-3FV6HBXS.js';
 import { AppBackground } from './chunk-WLOQ4IBG.js';
-import { ElevasisCoreProvider } from './chunk-CQZ3DNQY.js';
+import { ElevasisCoreProvider } from './chunk-YLQEVSOR.js';
 import { ElevasisLoader } from './chunk-SZHARWKU.js';
 import { AppearanceProvider } from './chunk-E565XMTQ.js';
-import { getErrorInfo, formatErrorMessage, getErrorTitle } from './chunk-XQHZBA65.js';
+import { getErrorInfo, formatErrorMessage, getErrorTitle } from './chunk-2RJMVWFJ.js';
 import { useMemo, useEffect } from 'react';
 import { Loader, mergeThemeOverrides, MantineProvider } from '@mantine/core';
 import '@mantine/core/styles.css';