@elevasis/ui 2.30.0 → 2.32.0

package/dist/chunk-6IXOKUBC.js

@@ -1,347 +0,0 @@
-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
-    };
-  };
-}
-
-// ../core/src/organization-model/helpers.ts
-function defaultPathFor(id) {
-  return `/${id.replaceAll(".", "/")}`;
-}
-function parentIdOf(id) {
-  const index = id.lastIndexOf(".");
-  return index === -1 ? void 0 : id.slice(0, index);
-}
-function findById(features, id) {
-  return features.find((feature) => feature.id === id);
-}
-function findByPath(features, path) {
-  return features.find((feature) => (feature.path ?? defaultPathFor(feature.id)) === path);
-}
-function childrenOf(features, id) {
-  const prefix = `${id}.`;
-  return features.filter((feature) => feature.id.startsWith(prefix) && !feature.id.slice(prefix.length).includes("."));
-}
-function topLevel(features) {
-  return features.filter((feature) => !feature.id.includes("."));
-}
-function ancestorsOf(features, id) {
-  const segments = id.split(".");
-  const ids = segments.map((_, index) => segments.slice(0, index + 1).join("."));
-  return ids.map((ancestorId) => findById(features, ancestorId)).filter((feature) => Boolean(feature));
-}
-function parentOf(features, id) {
-  const parentId = parentIdOf(id);
-  return parentId ? findById(features, parentId) : void 0;
-}
-function inheritedValue(features, id, getValue) {
-  return ancestorsOf(features, id).slice().reverse().map(getValue).find((value) => value !== void 0);
-}
-function uiPositionFor(features, id) {
-  return inheritedValue(features, id, (feature) => feature.uiPosition);
-}
-function requiresAdminFor(features, id) {
-  return inheritedValue(features, id, (feature) => feature.requiresAdmin) ?? false;
-}
-function devOnlyFor(features, id) {
-  return inheritedValue(features, id, (feature) => feature.devOnly) ?? false;
-}
-
-// 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 validateManifests(manifests, organizationModel) {
-  if (!organizationModel) {
-    return;
-  }
-  const validFeatureIds = new Set((organizationModel.features ?? []).map((f) => f.id));
-  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 (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 ElevasisFeaturesContext = createContext(null);
-var useFeatureAccess = createFeatureAccessHook({
-  useInitialization,
-  useOrganization
-});
-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 defaultFeatures(organizationModel) {
-  return organizationModel?.features ?? [];
-}
-function featurePath(feature) {
-  return feature.path ?? defaultPathFor(feature.id);
-}
-function isOrganizationModelFeatureEnabled(organizationModel, featureId) {
-  const feature = organizationModel?.features.find((f) => f.id === featureId);
-  return feature?.enabled;
-}
-function resolveFeatureModules(features, isFeatureEnabled) {
-  return features.map((feature) => {
-    const featureId = feature.featureId;
-    return {
-      ...feature,
-      access: {
-        featureId,
-        enabled: isFeatureEnabled(featureId)
-      },
-      semantics: {
-        capabilityIds: uniqueIds(feature.capabilityIds ?? [])
-      }
-    };
-  });
-}
-function buildShellFeatures(organizationModel, modules) {
-  const iconByFeatureId = new Map(modules.map((module) => [module.featureId, module.icon]));
-  return defaultFeatures(organizationModel).map((feature) => ({
-    ...feature,
-    iconComponent: iconByFeatureId.get(feature.id)
-  }));
-}
-function createShellModel(features) {
-  return {
-    features,
-    findByPath: (path) => findByPath(features, normalizeRoutePath(path)),
-    findById: (id) => findById(features, id),
-    childrenOf: (id) => childrenOf(features, id),
-    ancestorsOf: (id) => ancestorsOf(features, id),
-    parentOf: (id) => parentOf(features, id),
-    topLevel: () => topLevel(features),
-    uiPositionFor: (id) => uiPositionFor(features, id),
-    requiresAdminFor: (id) => requiresAdminFor(features, id),
-    devOnlyFor: (id) => devOnlyFor(features, id)
-  };
-}
-function resolveOrganizationGraphFeature(features, shellModel) {
-  for (const feature of features) {
-    const graphBridge = feature.organizationGraph;
-    if (!graphBridge) continue;
-    const node = shellModel.findById(graphBridge.featureId);
-    return {
-      available: Boolean(node),
-      featureId: graphBridge.featureId,
-      featurePath: node ? featurePath(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.features].filter((feature) => {
-    const path = normalizeRoutePath(featurePath(feature));
-    return path !== "/" && isRouteMatch(normalizedPath, path);
-  }).sort((a, b) => featurePath(b).length - featurePath(a).length)[0];
-}
-function ownsNode(module, node) {
-  if (!node) return false;
-  return node.id === module.featureId || node.id.startsWith(`${module.featureId}.`);
-}
-function resolveRoute(features, 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 feature = features.find((candidate) => ownsNode(candidate, node));
-  if (!feature) {
-    return {
-      status: "unmatched",
-      path: currentPath,
-      node
-    };
-  }
-  return {
-    status: "matched",
-    path: currentPath,
-    feature,
-    node
-  };
-}
-function ElevasisFeaturesProvider({
-  features,
-  organizationModel,
-  timeRange,
-  operationsApiUrl,
-  operationsSSEManager,
-  deliveryApiUrl,
-  deliverySSEManager,
-  disabledSubsectionPaths = [],
-  children
-}) {
-  const resolvedOrganizationModel = useMemo(() => {
-    if (!organizationModel) {
-      return void 0;
-    }
-    return {
-      ...organizationModel,
-      knowledge: organizationModel.knowledge ?? { nodes: [] }
-    };
-  }, [organizationModel]);
-  useMemo(() => validateManifests(features, resolvedOrganizationModel), [features, resolvedOrganizationModel]);
-  const { hasFeature } = useFeatureAccess();
-  const hasResolvedFeature = useCallback(
-    (key) => {
-      if (!hasFeature(key)) {
-        return false;
-      }
-      const organizationModelFeatureEnabled = isOrganizationModelFeatureEnabled(resolvedOrganizationModel, key);
-      return organizationModelFeatureEnabled ?? true;
-    },
-    [hasFeature, resolvedOrganizationModel]
-  );
-  const shellFeatures = useMemo(
-    () => buildShellFeatures(resolvedOrganizationModel, features),
-    [resolvedOrganizationModel, features]
-  );
-  const shellModel = useMemo(() => createShellModel(shellFeatures), [shellFeatures]);
-  const normalizedDisabledSubsectionPaths = useMemo(
-    () => [...new Set(disabledSubsectionPaths.map((path) => normalizeRoutePath(path)))],
-    [disabledSubsectionPaths]
-  );
-  const resolvedFeatures = useMemo(
-    () => resolveFeatureModules(features, hasResolvedFeature),
-    [features, hasResolvedFeature]
-  );
-  const enabledResolvedFeatures = useMemo(
-    () => resolvedFeatures.filter((feature) => feature.access.enabled),
-    [resolvedFeatures]
-  );
-  const organizationGraph = useMemo(
-    () => resolveOrganizationGraphFeature(enabledResolvedFeatures, shellModel),
-    [enabledResolvedFeatures, shellModel]
-  );
-  const getResolvedFeature = useCallback(
-    (key) => resolvedFeatures.find((feature) => feature.key === key),
-    [resolvedFeatures]
-  );
-  const isFeatureEnabled = useCallback((key) => hasResolvedFeature(key), [hasResolvedFeature]);
-  const resolveRouteByPath = useCallback(
-    (path) => resolveRoute(enabledResolvedFeatures, shellModel, path, normalizedDisabledSubsectionPaths),
-    [enabledResolvedFeatures, shellModel, normalizedDisabledSubsectionPaths]
-  );
-  const shellRuntime = useMemo(
-    () => ({
-      resolveRoute: resolveRouteByPath
-    }),
-    [resolveRouteByPath]
-  );
-  const value = useMemo(
-    () => ({
-      shellModel,
-      shellRuntime,
-      enabledResolvedFeatures,
-      resolvedFeatures,
-      organizationGraph,
-      organizationModel: resolvedOrganizationModel,
-      timeRange,
-      operationsApiUrl,
-      operationsSSEManager,
-      deliveryApiUrl,
-      deliverySSEManager,
-      disabledSubsectionPaths: normalizedDisabledSubsectionPaths,
-      isFeatureEnabled,
-      getResolvedFeature
-    }),
-    [
-      shellModel,
-      shellRuntime,
-      enabledResolvedFeatures,
-      resolvedFeatures,
-      organizationGraph,
-      resolvedOrganizationModel,
-      timeRange,
-      operationsApiUrl,
-      operationsSSEManager,
-      deliveryApiUrl,
-      deliverySSEManager,
-      normalizedDisabledSubsectionPaths,
-      isFeatureEnabled,
-      getResolvedFeature
-    ]
-  );
-  return /* @__PURE__ */ jsx(ElevasisFeaturesContext.Provider, { value, children });
-}
-
-export { ElevasisFeaturesProvider, createFeatureAccessHook, useElevasisFeatures, useOptionalElevasisFeatures };