chore: type fixes

Author: bbrzoska

src/main.ts

@@ -56,10 +56,19 @@ export type * from './v3/hooksTypes'
 // eslint-disable-next-line import/first, import/newline-after-import
 import * as match from './v3/matchSpan'
 export { match }
+export type {
+  Context,
+  NameMatcher,
+  SpanMatch,
+  SpanMatchDefinition,
+  SpanMatcherFn,
+  SpanMatcherTags,
+} from './v3/matchSpan'
 export * from './v3/observePerformanceWithTraceManager'
 export * from './v3/recordingComputeUtils'
 export type * from './v3/spanAnnotationTypes'
 export type * from './v3/spanTypes'
 export * from './v3/traceManager'
 export type * from './v3/traceRecordingTypes'
 export type * from './v3/types'
+export type * from './v3/typeUtils'

src/v3/convertToRum.ts

@@ -4,6 +4,8 @@ import type { Context, SpanMatcherFn } from './matchSpan'
 import { SpanAndAnnotation } from './spanAnnotationTypes'
 import { ComponentRenderSpan, Span } from './spanTypes'
 import { TraceRecording, TraceRecordingBase } from './traceRecordingTypes'
+import type { SelectScopeByKey } from './types'
+import type { KeysOfUnion } from './typeUtils'
 
 export interface EmbeddedEntry {
   count: number
@@ -87,14 +89,17 @@ export const defaultEmbedSpanSelector = <ScopeT>(
   return isRenderEntry(span)
 }
 
-export function convertTraceToRUM<TracerScopeT, AllPossibleScopesT>(
-  traceRecording: TraceRecording<TracerScopeT, AllPossibleScopesT>,
-  context: Context<TracerScopeT, AllPossibleScopesT>,
+export function convertTraceToRUM<
+  TracerScopeKeysT extends KeysOfUnion<AllPossibleScopesT>,
+  AllPossibleScopesT,
+>(
+  traceRecording: TraceRecording<TracerScopeKeysT, AllPossibleScopesT>,
+  context: Context<TracerScopeKeysT, AllPossibleScopesT>,
   embedSpanSelector: SpanMatcherFn<
-    TracerScopeT,
+    TracerScopeKeysT,
     AllPossibleScopesT
   > = defaultEmbedSpanSelector,
-): RumTraceRecording<TracerScopeT> {
+): RumTraceRecording<SelectScopeByKey<TracerScopeKeysT, AllPossibleScopesT>> {
   const { entries, ...otherTraceRecordingAttributes } = traceRecording
   const embeddedEntries: SpanAndAnnotation<AllPossibleScopesT>[] = []
   const nonEmbeddedSpans = new Set<string>()

src/v3/matchSpan.ts

@@ -38,7 +38,7 @@ export interface SpanMatcherFn<
   ): boolean
 }
 
-type NameMatcher<TracerScopeT> =
+export type NameMatcher<TracerScopeT> =
   | string
   | RegExp
   | ((name: string, scope: TracerScopeT) => boolean)
@@ -83,9 +83,10 @@ export function withName<
   }
 }
 
-export function withLabel<TracerScopeT, AllPossibleScopesT>(
-  value: string,
-): SpanMatcherFn<TracerScopeT, AllPossibleScopesT> {
+export function withLabel<
+  const TracerScopeKeysT extends KeysOfUnion<AllPossibleScopesT>,
+  const AllPossibleScopesT,
+>(value: string): SpanMatcherFn<TracerScopeKeysT, AllPossibleScopesT> {
   return ({ annotation }) => annotation.labels?.includes(value) ?? false
 }
 

src/v3/test/fixtures/ticket.activation.ts

@@ -13,7 +13,7 @@ const TICKET_DISPOSE_EVENT_NAME = `ticket.dispose`
 const TICKET_NAVIGATED_AWAY_EVENT_NAME = `ticket.navigated-away`
 
 export const ticketActivationDefinition: TraceDefinition<
-  TicketIdScope,
+  'ticketId',
   FixtureAllPossibleScopes
 > = {
   name: 'ticket.activation',

src/v3/typeUtils.ts

@@ -27,18 +27,18 @@ export type UnionToIntersection<U> = (
   : never
 
 type HandlerToPayloadTuples<
-  TracerScopeT,
+  TracerScopeKeysT extends KeysOfUnion<AllPossibleScopesT>,
   AllPossibleScopesT,
   State extends TraceStates = TraceStates,
 > = State extends State
   ? {
-      [K in keyof States<TracerScopeT, AllPossibleScopesT>[State]]: States<
-        TracerScopeT,
+      [K in keyof States<TracerScopeKeysT, AllPossibleScopesT>[State]]: States<
+        TracerScopeKeysT,
         AllPossibleScopesT
       >[State][K] extends (...args: infer ArgsT) => infer ReturnT
         ? [K, ArgsT[0], ReturnT]
         : never
-    }[keyof States<TracerScopeT, AllPossibleScopesT>[State]]
+    }[keyof States<TracerScopeKeysT, AllPossibleScopesT>[State]]
   : never
 
 type TupleToObject<T extends [PropertyKey, any, any]> = Prettify<{
@@ -49,16 +49,23 @@ type TupleToObject2<T extends [PropertyKey, any, any]> = Prettify<{
   [K in T[0]]: T extends [K, any, infer V] ? V : never
 }>
 
-export type StateHandlerPayloads<TracerScopeT, AllPossibleScopesT> =
-  TupleToObject<HandlerToPayloadTuples<TracerScopeT, AllPossibleScopesT>>
+export type StateHandlerPayloads<
+  TracerScopeKeysT extends KeysOfUnion<AllPossibleScopesT>,
+  AllPossibleScopesT,
+> = TupleToObject<HandlerToPayloadTuples<TracerScopeKeysT, AllPossibleScopesT>>
 
-export type StateHandlerReturnTypes<TracerScopeT, AllPossibleScopesT> =
-  TupleToObject2<HandlerToPayloadTuples<TracerScopeT, AllPossibleScopesT>>
+export type StateHandlerReturnTypes<
+  TracerScopeKeysT extends KeysOfUnion<AllPossibleScopesT>,
+  AllPossibleScopesT,
+> = TupleToObject2<HandlerToPayloadTuples<TracerScopeKeysT, AllPossibleScopesT>>
 
-export type MergedStateHandlerMethods<TracerScopeT, AllPossibleScopesT> = {
-  [K in keyof StateHandlerPayloads<TracerScopeT, AllPossibleScopesT>]: (
-    payload: StateHandlerPayloads<TracerScopeT, AllPossibleScopesT>[K],
-  ) => StateHandlerReturnTypes<TracerScopeT, AllPossibleScopesT>[K]
+export type MergedStateHandlerMethods<
+  TracerScopeKeysT extends KeysOfUnion<AllPossibleScopesT>,
+  AllPossibleScopesT,
+> = {
+  [K in keyof StateHandlerPayloads<TracerScopeKeysT, AllPossibleScopesT>]: (
+    payload: StateHandlerPayloads<TracerScopeKeysT, AllPossibleScopesT>[K],
+  ) => StateHandlerReturnTypes<TracerScopeKeysT, AllPossibleScopesT>[K]
 }
 export type ArrayWithAtLeastOneElement<T> = readonly [T, ...T[]]
 export type MapTuple<KeysTuple extends readonly unknown[], MapToValue> = {