@elevasis/ui 2.15.0 → 2.17.0

package/dist/provider/published.d.ts

@@ -277,249 +277,249 @@ declare function ElevasisCoreProvider({ auth, queryClient, apiUrl, onError, noti
  */
 type TimeRange = '1h' | '24h' | '7d' | '30d';
 
-declare const SurfaceDefinitionSchema = z.object({
-  id: ModelIdSchema,
-  label: LabelSchema,
-  path: PathSchema,
-  surfaceType: SurfaceTypeSchema,
-  description: DescriptionSchema.optional(),
-  enabled: z.boolean().default(true),
-  icon: IconNameSchema.optional(),
-  featureId: ModelIdSchema.optional(),
-  featureIds: ReferenceIdsSchema,
-  entityIds: ReferenceIdsSchema,
-  resourceIds: ReferenceIdsSchema,
-  capabilityIds: ReferenceIdsSchema,
-  parentId: ModelIdSchema.optional()
+declare const SurfaceDefinitionSchema = z.object({
+  id: ModelIdSchema,
+  label: LabelSchema,
+  path: PathSchema,
+  surfaceType: SurfaceTypeSchema,
+  description: DescriptionSchema.optional(),
+  enabled: z.boolean().default(true),
+  icon: IconNameSchema.optional(),
+  featureId: ModelIdSchema.optional(),
+  featureIds: ReferenceIdsSchema,
+  entityIds: ReferenceIdsSchema,
+  resourceIds: ReferenceIdsSchema,
+  capabilityIds: ReferenceIdsSchema,
+  parentId: ModelIdSchema.optional()
 })
 
-declare const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
-  const featuresById = collectIds(model.features, ctx, ['features'], 'Feature')
-  const surfacesById = collectIds(model.navigation.surfaces, ctx, ['navigation', 'surfaces'], 'Surface')
-  collectIds(model.navigation.groups, ctx, ['navigation', 'groups'], 'Navigation group')
-  collectIds(model.resourceMappings, ctx, ['resourceMappings'], 'Resource mapping')
-
-  const resourceMappingsByResourceId = new Map<string, (typeof model.resourceMappings)[number]>()
-  model.resourceMappings.forEach((resourceMapping, index) => {
-    if (resourceMappingsByResourceId.has(resourceMapping.resourceId)) {
-      addIssue(
-        ctx,
-        ['resourceMappings', index, 'resourceId'],
-        `Resource mapping resourceId "${resourceMapping.resourceId}" must be unique`
-      )
-      return
-    }
-
-    resourceMappingsByResourceId.set(resourceMapping.resourceId, resourceMapping)
-  })
-
-  if (model.navigation.defaultSurfaceId && !surfacesById.has(model.navigation.defaultSurfaceId)) {
-    addIssue(
-      ctx,
-      ['navigation', 'defaultSurfaceId'],
-      `Default surface "${model.navigation.defaultSurfaceId}" must reference a declared navigation surface`
-    )
-  }
-
-  model.navigation.groups.forEach((group, groupIndex) => {
-    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      if (!surfacesById.has(surfaceId)) {
-        addIssue(
-          ctx,
-          ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
-          `Navigation group "${group.id}" references unknown surface "${surfaceId}"`
-        )
-      }
-    })
-  })
-
-  // Feature -> Surface bidirectional validation
-  model.features.forEach((feature, featureIndex) => {
-    feature.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      const surface = surfacesById.get(surfaceId)
-      if (!surface) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'surfaceIds', surfaceIndex],
-          `Feature "${feature.id}" references unknown surface "${surfaceId}"`
-        )
-        return
-      }
-
-      if (!surface.featureIds.includes(feature.id)) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'surfaceIds', surfaceIndex],
-          `Feature "${feature.id}" references surface "${surfaceId}" but that surface does not include feature "${feature.id}"`
-        )
-      }
-    })
-
-    // Feature -> Resource bidirectional validation
-    feature.resourceIds.forEach((resourceId, resourceIndex) => {
-      const resourceMapping = resourceMappingsByResourceId.get(resourceId)
-      if (!resourceMapping) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'resourceIds', resourceIndex],
-          `Feature "${feature.id}" references unknown resource "${resourceId}"`
-        )
-        return
-      }
-
-      if (!resourceMapping.featureIds.includes(feature.id)) {
-        addIssue(
-          ctx,
-          ['features', featureIndex, 'resourceIds', resourceIndex],
-          `Feature "${feature.id}" references resource "${resourceId}" but that resource mapping does not include feature "${feature.id}"`
-        )
-      }
-    })
-  })
-
-  // Surface -> Feature bidirectional validation and other surface refs
-  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
-    if (surface.parentId && !surfacesById.has(surface.parentId)) {
-      addIssue(
-        ctx,
-        ['navigation', 'surfaces', surfaceIndex, 'parentId'],
-        `Surface "${surface.id}" references unknown parent surface "${surface.parentId}"`
-      )
-    }
-
-    surface.featureIds.forEach((featureId, featureIndex) => {
-      const feature = featuresById.get(featureId)
-      if (!feature) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
-          `Surface "${surface.id}" references unknown feature "${featureId}"`
-        )
-        return
-      }
-
-      if (!feature.surfaceIds.includes(surface.id)) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
-          `Surface "${surface.id}" references feature "${featureId}" but that feature does not include surface "${surface.id}"`
-        )
-      }
-    })
-
-    // Surface -> Resource bidirectional validation
-    surface.resourceIds.forEach((resourceId, resourceIndex) => {
-      const resourceMapping = resourceMappingsByResourceId.get(resourceId)
-      if (!resourceMapping) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'resourceIds', resourceIndex],
-          `Surface "${surface.id}" references unknown resource "${resourceId}"`
-        )
-        return
-      }
-
-      if (!resourceMapping.surfaceIds.includes(surface.id)) {
-        addIssue(
-          ctx,
-          ['navigation', 'surfaces', surfaceIndex, 'resourceIds', resourceIndex],
-          `Surface "${surface.id}" references resource "${resourceId}" but that surface does not include resource "${surface.id}"`
-        )
-      }
-    })
-  })
-
-  // Offerings -> CustomerSegment cross-ref: targetSegmentIds must resolve
-  const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]))
-  model.offerings.products.forEach((product, productIndex) => {
-    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
-      if (!segmentsById.has(segmentId)) {
-        addIssue(
-          ctx,
-          ['offerings', 'products', productIndex, 'targetSegmentIds', segmentIndex],
-          `Product "${product.id}" references unknown customer segment "${segmentId}"`
-        )
-      }
-    })
-
-    // Offerings -> Feature cross-ref: deliveryFeatureId must resolve (when present)
-    if (product.deliveryFeatureId !== undefined && !featuresById.has(product.deliveryFeatureId)) {
-      addIssue(
-        ctx,
-        ['offerings', 'products', productIndex, 'deliveryFeatureId'],
-        `Product "${product.id}" references unknown delivery feature "${product.deliveryFeatureId}"`
-      )
-    }
-  })
-
-  // Goals -> period-range validation: periodEnd must be strictly after periodStart
-  model.goals.objectives.forEach((objective, index) => {
-    if (objective.periodEnd <= objective.periodStart) {
-      addIssue(
-        ctx,
-        ['goals', 'objectives', index, 'periodEnd'],
-        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
-      )
-    }
-  })
-
-  // Roles -> reportsToId cross-ref: each reportsToId must resolve to another role in the same collection
-  const rolesById = new Map(model.roles.roles.map((role) => [role.id, role]))
-  model.roles.roles.forEach((role, roleIndex) => {
-    if (role.reportsToId !== undefined && !rolesById.has(role.reportsToId)) {
-      addIssue(
-        ctx,
-        ['roles', 'roles', roleIndex, 'reportsToId'],
-        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
-      )
-    }
-  })
-
-  // ResourceMapping -> Feature and Surface bidirectional validation
-  model.resourceMappings.forEach((resourceMapping, resourceIndex) => {
-    resourceMapping.featureIds.forEach((featureId, featureIndex) => {
-      const feature = featuresById.get(featureId)
-      if (!feature) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'featureIds', featureIndex],
-          `Resource mapping "${resourceMapping.id}" references unknown feature "${featureId}"`
-        )
-        return
-      }
-
-      if (!feature.resourceIds.includes(resourceMapping.resourceId)) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'featureIds', featureIndex],
-          `Resource mapping "${resourceMapping.id}" references feature "${featureId}" but that feature does not include resource "${resourceMapping.resourceId}"`
-        )
-      }
-    })
-
-    resourceMapping.surfaceIds.forEach((surfaceId, surfaceIndex) => {
-      const surface = surfacesById.get(surfaceId)
-      if (!surface) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'surfaceIds', surfaceIndex],
-          `Resource mapping "${resourceMapping.id}" references unknown surface "${surfaceId}"`
-        )
-        return
-      }
-
-      if (!surface.resourceIds.includes(resourceMapping.resourceId)) {
-        addIssue(
-          ctx,
-          ['resourceMappings', resourceIndex, 'surfaceIds', surfaceIndex],
-          `Resource mapping "${resourceMapping.id}" references surface "${surfaceId}" but that surface does not include resource "${resourceMapping.resourceId}"`
-        )
-      }
-    })
-  })
+declare const OrganizationModelSchema = OrganizationModelSchemaBase.superRefine((model, ctx) => {
+  const featuresById = collectIds(model.features, ctx, ['features'], 'Feature')
+  const surfacesById = collectIds(model.navigation.surfaces, ctx, ['navigation', 'surfaces'], 'Surface')
+  collectIds(model.navigation.groups, ctx, ['navigation', 'groups'], 'Navigation group')
+  collectIds(model.resourceMappings, ctx, ['resourceMappings'], 'Resource mapping')
+
+  const resourceMappingsByResourceId = new Map<string, (typeof model.resourceMappings)[number]>()
+  model.resourceMappings.forEach((resourceMapping, index) => {
+    if (resourceMappingsByResourceId.has(resourceMapping.resourceId)) {
+      addIssue(
+        ctx,
+        ['resourceMappings', index, 'resourceId'],
+        `Resource mapping resourceId "${resourceMapping.resourceId}" must be unique`
+      )
+      return
+    }
+
+    resourceMappingsByResourceId.set(resourceMapping.resourceId, resourceMapping)
+  })
+
+  if (model.navigation.defaultSurfaceId && !surfacesById.has(model.navigation.defaultSurfaceId)) {
+    addIssue(
+      ctx,
+      ['navigation', 'defaultSurfaceId'],
+      `Default surface "${model.navigation.defaultSurfaceId}" must reference a declared navigation surface`
+    )
+  }
+
+  model.navigation.groups.forEach((group, groupIndex) => {
+    group.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      if (!surfacesById.has(surfaceId)) {
+        addIssue(
+          ctx,
+          ['navigation', 'groups', groupIndex, 'surfaceIds', surfaceIndex],
+          `Navigation group "${group.id}" references unknown surface "${surfaceId}"`
+        )
+      }
+    })
+  })
+
+  // Feature -> Surface bidirectional validation
+  model.features.forEach((feature, featureIndex) => {
+    feature.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      const surface = surfacesById.get(surfaceId)
+      if (!surface) {
+        addIssue(
+          ctx,
+          ['features', featureIndex, 'surfaceIds', surfaceIndex],
+          `Feature "${feature.id}" references unknown surface "${surfaceId}"`
+        )
+        return
+      }
+
+      if (!surface.featureIds.includes(feature.id)) {
+        addIssue(
+          ctx,
+          ['features', featureIndex, 'surfaceIds', surfaceIndex],
+          `Feature "${feature.id}" references surface "${surfaceId}" but that surface does not include feature "${feature.id}"`
+        )
+      }
+    })
+
+    // Feature -> Resource bidirectional validation
+    feature.resourceIds.forEach((resourceId, resourceIndex) => {
+      const resourceMapping = resourceMappingsByResourceId.get(resourceId)
+      if (!resourceMapping) {
+        addIssue(
+          ctx,
+          ['features', featureIndex, 'resourceIds', resourceIndex],
+          `Feature "${feature.id}" references unknown resource "${resourceId}"`
+        )
+        return
+      }
+
+      if (!resourceMapping.featureIds.includes(feature.id)) {
+        addIssue(
+          ctx,
+          ['features', featureIndex, 'resourceIds', resourceIndex],
+          `Feature "${feature.id}" references resource "${resourceId}" but that resource mapping does not include feature "${feature.id}"`
+        )
+      }
+    })
+  })
+
+  // Surface -> Feature bidirectional validation and other surface refs
+  model.navigation.surfaces.forEach((surface, surfaceIndex) => {
+    if (surface.parentId && !surfacesById.has(surface.parentId)) {
+      addIssue(
+        ctx,
+        ['navigation', 'surfaces', surfaceIndex, 'parentId'],
+        `Surface "${surface.id}" references unknown parent surface "${surface.parentId}"`
+      )
+    }
+
+    surface.featureIds.forEach((featureId, featureIndex) => {
+      const feature = featuresById.get(featureId)
+      if (!feature) {
+        addIssue(
+          ctx,
+          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
+          `Surface "${surface.id}" references unknown feature "${featureId}"`
+        )
+        return
+      }
+
+      if (!feature.surfaceIds.includes(surface.id)) {
+        addIssue(
+          ctx,
+          ['navigation', 'surfaces', surfaceIndex, 'featureIds', featureIndex],
+          `Surface "${surface.id}" references feature "${featureId}" but that feature does not include surface "${surface.id}"`
+        )
+      }
+    })
+
+    // Surface -> Resource bidirectional validation
+    surface.resourceIds.forEach((resourceId, resourceIndex) => {
+      const resourceMapping = resourceMappingsByResourceId.get(resourceId)
+      if (!resourceMapping) {
+        addIssue(
+          ctx,
+          ['navigation', 'surfaces', surfaceIndex, 'resourceIds', resourceIndex],
+          `Surface "${surface.id}" references unknown resource "${resourceId}"`
+        )
+        return
+      }
+
+      if (!resourceMapping.surfaceIds.includes(surface.id)) {
+        addIssue(
+          ctx,
+          ['navigation', 'surfaces', surfaceIndex, 'resourceIds', resourceIndex],
+          `Surface "${surface.id}" references resource "${resourceId}" but that surface does not include resource "${surface.id}"`
+        )
+      }
+    })
+  })
+
+  // Offerings -> CustomerSegment cross-ref: targetSegmentIds must resolve
+  const segmentsById = new Map(model.customers.segments.map((seg) => [seg.id, seg]))
+  model.offerings.products.forEach((product, productIndex) => {
+    product.targetSegmentIds.forEach((segmentId, segmentIndex) => {
+      if (!segmentsById.has(segmentId)) {
+        addIssue(
+          ctx,
+          ['offerings', 'products', productIndex, 'targetSegmentIds', segmentIndex],
+          `Product "${product.id}" references unknown customer segment "${segmentId}"`
+        )
+      }
+    })
+
+    // Offerings -> Feature cross-ref: deliveryFeatureId must resolve (when present)
+    if (product.deliveryFeatureId !== undefined && !featuresById.has(product.deliveryFeatureId)) {
+      addIssue(
+        ctx,
+        ['offerings', 'products', productIndex, 'deliveryFeatureId'],
+        `Product "${product.id}" references unknown delivery feature "${product.deliveryFeatureId}"`
+      )
+    }
+  })
+
+  // Goals -> period-range validation: periodEnd must be strictly after periodStart
+  model.goals.objectives.forEach((objective, index) => {
+    if (objective.periodEnd <= objective.periodStart) {
+      addIssue(
+        ctx,
+        ['goals', 'objectives', index, 'periodEnd'],
+        `Goal "${objective.id}" has periodEnd "${objective.periodEnd}" which must be strictly after periodStart "${objective.periodStart}"`
+      )
+    }
+  })
+
+  // Roles -> reportsToId cross-ref: each reportsToId must resolve to another role in the same collection
+  const rolesById = new Map(model.roles.roles.map((role) => [role.id, role]))
+  model.roles.roles.forEach((role, roleIndex) => {
+    if (role.reportsToId !== undefined && !rolesById.has(role.reportsToId)) {
+      addIssue(
+        ctx,
+        ['roles', 'roles', roleIndex, 'reportsToId'],
+        `Role "${role.id}" references unknown reportsToId "${role.reportsToId}"`
+      )
+    }
+  })
+
+  // ResourceMapping -> Feature and Surface bidirectional validation
+  model.resourceMappings.forEach((resourceMapping, resourceIndex) => {
+    resourceMapping.featureIds.forEach((featureId, featureIndex) => {
+      const feature = featuresById.get(featureId)
+      if (!feature) {
+        addIssue(
+          ctx,
+          ['resourceMappings', resourceIndex, 'featureIds', featureIndex],
+          `Resource mapping "${resourceMapping.id}" references unknown feature "${featureId}"`
+        )
+        return
+      }
+
+      if (!feature.resourceIds.includes(resourceMapping.resourceId)) {
+        addIssue(
+          ctx,
+          ['resourceMappings', resourceIndex, 'featureIds', featureIndex],
+          `Resource mapping "${resourceMapping.id}" references feature "${featureId}" but that feature does not include resource "${resourceMapping.resourceId}"`
+        )
+      }
+    })
+
+    resourceMapping.surfaceIds.forEach((surfaceId, surfaceIndex) => {
+      const surface = surfacesById.get(surfaceId)
+      if (!surface) {
+        addIssue(
+          ctx,
+          ['resourceMappings', resourceIndex, 'surfaceIds', surfaceIndex],
+          `Resource mapping "${resourceMapping.id}" references unknown surface "${surfaceId}"`
+        )
+        return
+      }
+
+      if (!surface.resourceIds.includes(resourceMapping.resourceId)) {
+        addIssue(
+          ctx,
+          ['resourceMappings', resourceIndex, 'surfaceIds', surfaceIndex],
+          `Resource mapping "${resourceMapping.id}" references surface "${surfaceId}" but that surface does not include resource "${resourceMapping.resourceId}"`
+        )
+      }
+    })
+  })
 })
 
-type OrganizationModel = z.infer<typeof OrganizationModelSchema>
+type OrganizationModel = z.infer<typeof OrganizationModelSchema>
 type OrganizationModelSurface = z.infer<typeof SurfaceDefinitionSchema>
 
 interface EventSourceMessage {
@@ -648,6 +648,8 @@ interface ElevasisFeaturesProviderProps {
     timeRange?: TimeRange;
     operationsApiUrl?: string;
     operationsSSEManager?: SSEConnectionManagerLike;
+    deliveryApiUrl?: string;
+    deliverySSEManager?: SSEConnectionManagerLike;
     disabledSubsectionPaths?: string[];
     children: ReactNode;
 }
@@ -661,6 +663,8 @@ interface ElevasisFeaturesContextValue {
     timeRange?: TimeRange;
     operationsApiUrl?: string;
     operationsSSEManager?: SSEConnectionManagerLike;
+    deliveryApiUrl?: string;
+    deliverySSEManager?: SSEConnectionManagerLike;
     disabledSubsectionPaths: string[];
     isFeatureEnabled: (key: string) => boolean;
     getResolvedFeature: (key: string) => ResolvedFeatureModule | undefined;
@@ -668,7 +672,7 @@ interface ElevasisFeaturesContextValue {
 
 declare function useElevasisFeatures(): ElevasisFeaturesContextValue;
 declare function useOptionalElevasisFeatures(): ElevasisFeaturesContextValue | null;
-declare function ElevasisFeaturesProvider({ features, organizationModel, appShellOverrides, timeRange, operationsApiUrl, operationsSSEManager, disabledSubsectionPaths, children }: ElevasisFeaturesProviderProps): react_jsx_runtime.JSX.Element;
+declare function ElevasisFeaturesProvider({ features, organizationModel, appShellOverrides, timeRange, operationsApiUrl, operationsSSEManager, deliveryApiUrl, deliverySSEManager, disabledSubsectionPaths, children }: ElevasisFeaturesProviderProps): react_jsx_runtime.JSX.Element;
 
 declare function FeatureShell({ children }: {
     children: ReactNode;

package/dist/provider/published.js

@@ -1,23 +1,24 @@
-export { ElevasisFeaturesProvider, FeatureShell, useElevasisFeatures, useOptionalElevasisFeatures } from '../chunk-C7BX547M.js';
+export { ElevasisFeaturesProvider, FeatureShell, useElevasisFeatures, useOptionalElevasisFeatures } from '../chunk-2TDZBYXI.js';
+export { ElevasisCoreProvider, NotificationProvider, useNotificationAdapter } from '../chunk-P3TFNFZS.js';
 import '../chunk-RX4UWZZR.js';
-import '../chunk-SQQGLGHW.js';
+import '../chunk-TTP62HWW.js';
+import '../chunk-SZHARWKU.js';
 import '../chunk-3KMDHCAR.js';
 import '../chunk-NYBEU5TE.js';
-export { ElevasisCoreProvider, NotificationProvider, useNotificationAdapter } from '../chunk-ZB5GAV7J.js';
-import '../chunk-SZHARWKU.js';
-import '../chunk-NVOCKXUQ.js';
+import '../chunk-VDM6DQES.js';
 import '../chunk-2IFYDILW.js';
-import '../chunk-ELJIFLCB.js';
-import '../chunk-L4XXM55J.js';
-import '../chunk-FL67C3WY.js';
+import '../chunk-Q7DJKLEN.js';
+import '../chunk-7YQKVWSD.js';
+import '../chunk-6IA2OMAE.js';
 export { AppearanceProvider, useAppearance } from '../chunk-QJ2KCHKX.js';
-import '../chunk-SLVC5OJ2.js';
+import '../chunk-HQ7M6PBW.js';
 import '../chunk-DT3QYZVU.js';
 import '../chunk-RNP5R5I3.js';
-import '../chunk-IOKL7BKE.js';
-import '../chunk-MTJ43R2E.js';
-import '../chunk-TUXTSEAF.js';
+import '../chunk-GCBWGGI6.js';
+import '../chunk-KRWALB24.js';
+import '../chunk-SLH2QLKV.js';
+import '../chunk-DK2HVHCY.js';
 import '../chunk-DD3CCMCZ.js';
-export { ElevasisServiceProvider, useElevasisServices } from '../chunk-QEPXAWE2.js';
+import '../chunk-QHSW4WHM.js';
+export { ElevasisServiceProvider, useElevasisServices } from '../chunk-IRW7JMQ4.js';
 import '../chunk-BRJ3QZ4E.js';
-import '../chunk-Q7DJKLEN.js';