@equinor/fusion-framework-module-analytics 1.0.2 → 2.0.0

package/dist/types/AnalyticsConfigurator.d.ts

@@ -4,36 +4,41 @@ import type { IAnalyticsCollector } from './collectors/AnalyticsCollector.interf
 import type { IAnalyticsAdapter } from './adapters/AnalyticsAdapter.interface.js';
 import type { AnalyticsEvent } from './types.js';
 /**
- * Configures analytics settings for the module.
- *
- * The `AnalyticsConfigurator` class extends `BaseConfigBuilder` to provide a fluent API for
- * setting up analytics adapters and collectors.
+ * Default {@link IAnalyticsConfigurator} implementation for registering analytics adapters and collectors.
  *
  * @remarks
- * - Adapters are managed internally and can be set using `setAdapter`.
- * - Collectors are managed internally and can be set using `setCollector`.
- * - All setter methods return `this` for method chaining.
+ * Extends `BaseConfigBuilder` to resolve adapter and collector factories
+ * asynchronously at module-initialisation time using RxJS `mergeMap`. Each
+ * registered factory is invoked with the module’s `ConfigBuilderCallbackArgs`
+ * so it can resolve dependencies from the framework before returning its
+ * adapter or collector instance.
+ *
+ * Use {@link AnalyticsConfigurator.setAdapter | setAdapter} and
+ * {@link AnalyticsConfigurator.setCollector | setCollector} to register
+ * components. Both methods return `this` for fluent chaining.
  *
- * @see BaseConfigBuilder
- * @see IAnalyticsConfigurator
+ * @see {@link IAnalyticsConfigurator}
+ * @see {@link BaseConfigBuilder}
  */
 export declare class AnalyticsConfigurator extends BaseConfigBuilder<AnalyticsConfig> implements IAnalyticsConfigurator {
     #private;
     constructor();
     /**
-     * Registers a analytics collector with the configurator.
+     * Registers an analytics collector factory.
      *
-     * @param identifier - The name of the collector
-     * @param callback - A callback function that returns an analytics collector instance
-     * @returns The current instance for method chaining
+     * @template T - The concrete analytics event type the collector emits.
+     * @param identifier - Unique key for the collector.
+     * @param callback - Factory that receives module-resolution args and returns a collector.
+     * @returns `this` for method chaining.
      */
     setCollector<T extends AnalyticsEvent>(identifier: string, callback: ConfigBuilderCallback<IAnalyticsCollector<T>>): this;
     /**
-     * Registers a analytics adapter with the configurator.
+     * Registers an analytics adapter factory.
      *
-     * @param identifier - The name of the adapter
-     * @param callback - A callback function that returns an analytics adapter instance
-     * @returns The current instance for method chaining
+     * @template T - The concrete analytics event type the adapter handles.
+     * @param identifier - Unique key for the adapter.
+     * @param callback - Factory that receives module-resolution args and returns an adapter.
+     * @returns `this` for method chaining.
      */
     setAdapter<T extends AnalyticsEvent>(identifier: string, callback: ConfigBuilderCallback<IAnalyticsAdapter<T>>): this;
 }

package/dist/types/AnalyticsConfigurator.interface.d.ts

@@ -3,36 +3,65 @@ import type { IAnalyticsCollector } from './collectors/AnalyticsCollector.interf
 import type { IAnalyticsAdapter } from './adapters/AnalyticsAdapter.interface.js';
 import type { AnalyticsEvent } from './types.js';
 /**
- * Configuration options for setting up analytics within the framework.
+ * Resolved analytics configuration containing the instantiated collectors and adapters.
  *
- * @property collectors - Record of analytics collectors keyed by identifier to be used for reporting analytics data.
- * @property adapters - Record of analytics adapters keyed by identifier to be used to handle events.
+ * @remarks
+ * This type is the output of the configuration stage. The module’s `initialize`
+ * function receives the resolved `AnalyticsConfig` and passes it to
+ * {@link AnalyticsProvider}.
  */
 export type AnalyticsConfig = {
+    /** Record of analytics collectors keyed by a unique identifier. */
     collectors: Record<string, IAnalyticsCollector>;
+    /** Record of analytics adapters keyed by a unique identifier. */
     adapters: Record<string, IAnalyticsAdapter>;
 };
 /**
- * Interface for configuring analytics within the module.
+ * Configuration-time interface for registering analytics adapters and collectors.
  *
- * Provides methods to set analytics adapters and collectors.
+ * @remarks
+ * Obtain an instance of this interface inside the callback passed to
+ * {@link enableAnalytics}. Use {@link IAnalyticsConfigurator.setAdapter | setAdapter}
+ * and {@link IAnalyticsConfigurator.setCollector | setCollector} to register
+ * components. Both methods support method chaining.
  *
- * @interface IAnalyticsConfigurator
+ * @example
+ * ```ts
+ * enableAnalytics(configurator, (builder) => {
+ *   builder
+ *     .setAdapter('console', async () => new ConsoleAnalyticsAdapter())
+ *     .setCollector('context-selected', async (args) => {
+ *       const ctx = await args.requireInstance('context');
+ *       const app = await args.requireInstance('app');
+ *       return new ContextSelectedCollector(ctx, app);
+ *     });
+ * });
+ * ```
  */
 export interface IAnalyticsConfigurator {
     /**
-     * Sets a analytics collector with the given identifier and configuration callback.
+     * Registers an analytics collector factory identified by a unique key.
      *
-     * @param identifier - The unique identifier for the collector.
-     * @param callBack - Configuration callback that returns the collector instance.
+     * The factory callback receives module-resolution arguments so it can
+     * resolve dependencies (e.g. context or app providers) before returning
+     * the collector instance.
+     *
+     * @template T - The concrete analytics event type the collector emits.
+     * @param identifier - Unique key for this collector.
+     * @param callBack - Async factory that returns the collector instance.
      * @returns The configurator instance for method chaining.
      */
     setCollector<T extends AnalyticsEvent>(identifier: string, callBack: ConfigBuilderCallback<IAnalyticsCollector<T>>): this;
     /**
-     * Sets a analytics adapter with the given identifier and configuration callback.
+     * Registers an analytics adapter factory identified by a unique key.
+     *
+     * The factory callback receives module-resolution arguments so it can
+     * resolve dependencies (e.g. service-discovery HTTP clients) before
+     * returning the adapter instance.
      *
-     * @param identifier - The unique identifier for the adapter.
-     * @param callBack - Configuration callback that returns the adapter instance.
+     * @template T - The concrete analytics event type the adapter handles.
+     * @param identifier - Unique key for this adapter.
+     * @param callback - Async factory that returns the adapter instance.
      * @returns The configurator instance for method chaining.
      */
     setAdapter<T extends AnalyticsEvent>(identifier: string, callback: ConfigBuilderCallback<IAnalyticsAdapter<T>>): this;

package/dist/types/AnalyticsProvider.d.ts

@@ -4,42 +4,56 @@ import type { IAnalyticsProvider } from './AnalyticsProvider.interface.js';
 import type { AnalyticsEvent } from './types.js';
 import { type ObservableInput, Subscription } from 'rxjs';
 /**
- * Provides analytics tracking, adapters integration and collectors for application instrumentation.
+ * Runtime analytics provider that collects events from collectors and dispatches
+ * them to adapters.
  *
- * The `AnalyticsProvider` class is responsible for collecting, processing and relaying analytics
- * data to the adapters. The events are collected with collectors.
+ * @remarks
+ * Created by the analytics module during initialisation. The provider:
+ *
+ * 1. Initialises all registered adapters and collectors.
+ * 2. Subscribes to every collector and merges their events into a shared stream.
+ * 3. Forwards each emitted event to every registered adapter via
+ *    {@link IAnalyticsAdapter.registerAnalytic}.
+ *
+ * Consumers can also push ad-hoc events with {@link AnalyticsProvider.trackAnalytic}
+ * or subscribe an observable stream with {@link AnalyticsProvider.trackAnalytic$}.
  *
- * @typeParam AnalyticsConfig - The configuration type for analytics.
- * @implements IAnalyticsProvider
  * @extends BaseModuleProvider<AnalyticsConfig>
+ * @implements IAnalyticsProvider
  */
 export declare class AnalyticsProvider extends BaseModuleProvider<AnalyticsConfig> implements IAnalyticsProvider {
     #private;
     constructor(config: AnalyticsConfig);
     /**
-     * Initializes the analytics provider with adapters and collectors.
+     * Initialises all adapters and collectors, then wires collector output into
+     * the adapter pipeline.
+     *
+     * @remarks
+     * Initialisation is idempotent within the module lifecycle — the module calls
+     * this once during `module.initialize`. Steps:
+     *
+     * 1. Initialise all collectors (via `Promise.allSettled`).
+     * 2. Initialise all adapters (via `Promise.allSettled`).
+     * 3. Subscribe to each collector and forward events into the shared subject.
+     * 4. Subscribe to the shared subject and dispatch to every adapter.
      *
-     * This method sets up the provider for operation by:
-     * 1. Storing the provided adapters
-     * 2. Initializing all adapters
-     * 3. Storing the provided collectors
-     * 4. Initializing all collectors
-     * 5. Setting up subscription for analytics processing
+     * All subscriptions are registered as teardowns on the base provider.
      *
-     * @returns A promise that resolves when initialization is complete
+     * @returns A promise that resolves when all adapters and collectors are initialised.
      */
     initialize(): Promise<void>;
     /**
-     * Tracks an analytics event
+     * Pushes a single analytics event to all registered adapters.
      *
-     * @param event - The analytics event to track
+     * @param event - The analytics event to track.
      */
     trackAnalytic(event: AnalyticsEvent): void;
     /**
-     * Uses a analytics stream and returns both Disposable and Subscription for cleanup.
+     * Subscribes to an observable stream of analytics events and forwards each
+     * emission to all registered adapters.
      *
-     * @param analytic$ - Observable input stream of analytic events.
-     * @returns Object containing both Disposable and Subscription for proper cleanup.
+     * @param analytic$ - Observable input stream of analytics events.
+     * @returns A {@link DisposableSubscription} supporting both `unsubscribe()` and `Symbol.dispose`.
      */
     trackAnalytic$(analytic$: ObservableInput<AnalyticsEvent>): Disposable & Subscription;
 }

package/dist/types/AnalyticsProvider.interface.d.ts

@@ -1,20 +1,42 @@
 import type { ObservableInput, Subscription } from 'rxjs';
 import type { AnalyticsEvent } from './types.js';
 /**
- * Interface for analytics providers used to track analytics events.
+ * Public interface for the analytics provider exposed by the `analytics` module.
+ *
+ * @remarks
+ * Use `trackAnalytic` to push a single event or `trackAnalytic$` to forward
+ * an observable stream of events. Both methods route events to all registered
+ * adapters.
  */
 export interface IAnalyticsProvider {
     /**
-     * Tracks a analytics event.
+     * Pushes a single analytics event to all registered adapters.
      *
-     * @param event - The analytic event to track.
+     * @param event - The analytics event to track.
+     *
+     * @example
+     * ```ts
+     * provider.trackAnalytic({
+     *   name: 'button-click',
+     *   value: 'save',
+     *   attributes: { page: 'settings' },
+     * });
+     * ```
      */
     trackAnalytic(event: AnalyticsEvent): void;
     /**
-     * Uses a analytics stream and returns both Disposable and Subscription for cleanup.
+     * Subscribes to an observable stream of analytics events and forwards each
+     * emission to all registered adapters.
+     *
+     * @param analytic$ - Observable input stream of analytics events.
+     * @returns A combined `Disposable & Subscription` handle for cleanup.
      *
-     * @param analytic$ - Observable input stream of analytic events.
-     * @returns Object containing both Disposable and Subscription for proper cleanup.
+     * @example
+     * ```ts
+     * const sub = provider.trackAnalytic$(myEvent$);
+     * // later
+     * sub.unsubscribe();
+     * ```
      */
     trackAnalytic$(analytic$: ObservableInput<AnalyticsEvent>): Disposable & Subscription;
 }

package/dist/types/adapters/AnalyticsAdapter.interface.d.ts

@@ -1,8 +1,21 @@
 import type { AnalyticsEvent } from '../types.js';
 /**
- * Interface representing an analytics adapter responsible for handling analytics events.
+ * Contract for an analytics adapter that receives events and exports them to a backend.
  *
- * @template T - The type of analytics event handled by the adapter. Defaults to `AnalyticsEvent`.
+ * @remarks
+ * Implement this interface to create a custom adapter. Register it via
+ * {@link IAnalyticsConfigurator.setAdapter}. The adapter must also implement
+ * `Disposable` for resource cleanup.
+ *
+ * @template T - The analytics event type handled by the adapter, defaults to {@link AnalyticsEvent}.
+ *
+ * @example
+ * ```ts
+ * class MyAdapter implements IAnalyticsAdapter {
+ *   registerAnalytic(event) { fetch('/analytics', { method: 'POST', body: JSON.stringify(event) }); }
+ *   [Symbol.dispose]() { /* cleanup *\/ }
+ * }
+ * ```
  */
 export interface IAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent> extends Disposable {
     /**

package/dist/types/adapters/ConsoleAnalyticsAdapter.d.ts

@@ -1,9 +1,23 @@
 import type { IAnalyticsAdapter } from './AnalyticsAdapter.interface.js';
 import type { AnalyticsEvent } from '../types.js';
 /**
- * An analytics adapter printing the events to the console.
+ * Analytics adapter that logs every event to the browser console.
+ *
+ * @remarks
+ * Useful during development and debugging. Each event is logged with the
+ * prefix `Analytics::Adapter::Console`.
+ *
+ * @template T - Analytics event type, defaults to {@link AnalyticsEvent}.
+ *
+ * @example
+ * ```ts
+ * import { ConsoleAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/adapters';
+ *
+ * builder.setAdapter('console', async () => new ConsoleAnalyticsAdapter());
+ * ```
  */
 export declare class ConsoleAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent> implements IAnalyticsAdapter {
+    /** Logs the event to the console. */
     registerAnalytic(event: T): Promise<void> | void;
     [Symbol.dispose](): void;
 }

package/dist/types/adapters/FusionAnalyticsAdapter.d.ts

@@ -3,17 +3,46 @@ import type { AnalyticsEvent } from '../types.js';
 import { type ReadableLogRecord } from '@opentelemetry/sdk-logs';
 import type { OTLPExporterBase } from '@opentelemetry/otlp-exporter-base';
 /**
- * An analytics adapter for sending events to the log exporter for handling.
+ * Analytics adapter that forwards events to an OpenTelemetry log exporter.
  *
- * The exporter is a Open Telemetry exporter.
- * @see OTLPExporterBase
+ * @remarks
+ * Uses `@opentelemetry/sdk-logs` to batch and export log records through the
+ * provided {@link OTLPExporterBase} transport. Each analytics event is mapped
+ * to an OTLP `LogRecord` with severity `INFO`.
+ *
+ * Resource attributes automatically include the module version, a unique
+ * session ID (UUIDv7), and the portal ID supplied at construction time.
+ *
+ * @template T - Analytics event type, defaults to {@link AnalyticsEvent}.
+ *
+ * @example
+ * ```ts
+ * import { FusionAnalyticsAdapter } from '@equinor/fusion-framework-module-analytics/adapters';
+ * import { OTLPLogExporter } from '@equinor/fusion-framework-module-analytics/logExporters';
+ *
+ * builder.setAdapter('fusion-log', async () => {
+ *   const logExporter = new OTLPLogExporter({ url: '/v1/logs' });
+ *   return new FusionAnalyticsAdapter({ portalId: 'my-portal', logExporter });
+ * });
+ * ```
+ *
+ * @see {@link OTLPExporterBase}
  */
 export declare class FusionAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent> implements IAnalyticsAdapter {
     #private;
+    /**
+     * Creates a new `FusionAnalyticsAdapter`.
+     *
+     * @param args - Construction options.
+     * @param args.portalId - Portal identifier attached to every exported log record.
+     * @param args.logExporter - An OTLP-compatible log exporter for transport.
+     */
     constructor(args: {
         portalId: string;
         logExporter: OTLPExporterBase<ReadableLogRecord[]>;
     });
+    /** Maps an analytics event to an OTLP `LogRecord` and emits it via the logger. */
     registerAnalytic(event: T): Promise<void> | void;
+    /** Shuts down the log exporter and logger provider, flushing remaining records. */
     [Symbol.dispose](): void;
 }

package/dist/types/adapters/index.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Re-exports for built-in analytics adapters.
+ *
+ * @remarks
+ * Import from `'@equinor/fusion-framework-module-analytics/adapters'`.
+ *
+ * @packageDocumentation
+ */
 export { IAnalyticsAdapter } from './AnalyticsAdapter.interface.js';
 export { ConsoleAnalyticsAdapter } from './ConsoleAnalyticsAdapter.js';
 export { FusionAnalyticsAdapter } from './FusionAnalyticsAdapter.js';

package/dist/types/collectors/AnalyticsCollector.interface.d.ts

@@ -1,9 +1,18 @@
 import type { Subscribable } from 'rxjs';
 import type { AnalyticsEvent } from '../types.js';
 /**
- * Interface representing an analytics collector responsible for sending analytics events.
+ * Contract for an analytics collector that observes application state and emits
+ * structured analytics events.
  *
- * @template T - The type of analytics event handled by the adapter. Defaults to `AnalyticsEvent`.
+ * @remarks
+ * Implement this interface (or extend {@link BaseCollector}) to create a custom
+ * collector. Register it via {@link IAnalyticsConfigurator.setCollector}.
+ *
+ * The collector must be `Subscribable` so the provider can listen for emitted
+ * events. Optionally implement `initialize` for async setup (e.g. resolving
+ * module dependencies).
+ *
+ * @template T - Analytics event type emitted by this collector, defaults to {@link AnalyticsEvent}.
  */
 export interface IAnalyticsCollector<T extends AnalyticsEvent = AnalyticsEvent> extends Subscribable<T> {
     /**

package/dist/types/collectors/AppLoadedCollector.d.ts

@@ -6,13 +6,31 @@ import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
 import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
 import { type ObservableInput } from 'rxjs';
 /**
- * Collector to listen for app loaded and add values and attributes for
- * further processing by adapters.
+ * Collector that emits an analytics event whenever an application’s modules
+ * finish loading.
+ *
+ * @remarks
+ * Listens to the framework `onAppModulesLoaded` event, extracts application
+ * manifest metadata, and includes the current context (if available) in the
+ * event attributes.
+ *
+ * Register via:
+ * ```ts
+ * builder.setCollector('app-loaded', async (args) => {
+ *   const event = await args.requireInstance('event');
+ *   const app = await args.requireInstance('app');
+ *   return new AppLoadedCollector(event, app);
+ * });
+ * ```
  */
 export declare class AppLoadedCollector extends BaseCollector<AppItemType, {
     context?: ContextItemType;
 }> implements IAnalyticsCollector {
     #private;
+    /**
+     * @param eventProvider - Fusion event module provider to listen for app-loaded events.
+     * @param appProvider - Fusion app module provider for fallback manifest data.
+     */
     constructor(eventProvider: IEventModuleProvider, appProvider: AppModuleProvider);
     _initialize(): ObservableInput<{
         value: AppItemType;

package/dist/types/collectors/AppSelectedCollector.d.ts

@@ -4,13 +4,27 @@ import { BaseCollector } from './BaseCollector.js';
 import { type AppKeyType } from './utils/extractAppMetadata.js';
 import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
 /**
- * Collector to listen for app selection and add values and attributes for
- * further processing by adapters.
+ * Collector that emits an analytics event whenever the active Fusion application changes.
+ *
+ * @remarks
+ * Listens to `AppModuleProvider.current$`, pairs consecutive values, and emits
+ * both the new and previous app key metadata.
+ *
+ * Register via:
+ * ```ts
+ * builder.setCollector('app-selected', async (args) => {
+ *   const app = await args.requireInstance('app');
+ *   return new AppSelectedCollector(app);
+ * });
+ * ```
  */
 export declare class AppSelectedCollector extends BaseCollector<AppKeyType, {
     previous?: AppKeyType;
 }> implements IAnalyticsCollector {
     #private;
+    /**
+     * @param appProvider - Fusion app module provider to observe.
+     */
     constructor(appProvider: AppModuleProvider);
     _initialize(): ObservableInput<{
         value: AppKeyType;

package/dist/types/collectors/BaseCollector.d.ts

@@ -3,25 +3,80 @@ import type { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
 import { type ObservableInput, type Observer, type Unsubscribable } from 'rxjs';
 import { z } from 'zod';
 /**
- * Function to create zod schema to be used when collecting
+ * Creates a Zod schema for validating {@link AnalyticsEvent} instances with
+ * typed value and attributes.
+ *
+ * @template TValue - Schema type for the event body.
+ * @template TAttr - Schema type for the event attributes.
+ * @param value - Zod schema validating the event body.
+ * @param attributes - Zod schema validating the event attributes.
+ * @returns A Zod object schema matching `{ name, value, attributes? }`.
  */
 export declare const createSchema: <TValue = AnyValue, TAttr = AnyValueMap>(value: z.ZodSchema<TValue>, attributes: z.ZodSchema<TAttr>) => z.ZodObject<{
     name: z.ZodString;
     value: z.ZodType<TValue, unknown, z.core.$ZodTypeInternals<TValue, unknown>>;
     attributes: z.ZodOptional<z.ZodType<TAttr, unknown, z.core.$ZodTypeInternals<TAttr, unknown>>>;
 }, z.core.$strip>;
+/** Inferred Zod schema type produced by {@link createSchema}. */
 export type CollectorSchema<TValue = AnyValue, TAttr = AnyValueMap> = ReturnType<typeof createSchema<TValue, TAttr>>;
 /**
- * A base collector to help with parsing the events with provided schema before
- * emitting.
+ * Abstract base class for analytics collectors that validates events against a
+ * Zod schema before emitting.
+ *
+ * @remarks
+ * Subclasses implement {@link BaseCollector._initialize | _initialize} to return
+ * an observable of raw `{ value, attributes }` objects. `BaseCollector` wraps
+ * each emission with the collector name, validates it against the supplied schema,
+ * and publishes through an internal `Subject`.
+ *
+ * @template TValue - The event body type.
+ * @template TAttr - The event attributes type.
+ *
+ * @example
+ * ```ts
+ * class MyCollector extends BaseCollector<string, { page: string }> {
+ *   constructor() {
+ *     super('my-event', createSchema(z.string(), z.object({ page: z.string() })));
+ *   }
+ *   _initialize() {
+ *     return of({ value: 'hello', attributes: { page: '/home' } });
+ *   }
+ * }
+ * ```
  */
 export declare abstract class BaseCollector<TValue extends AnyValue, TAttr extends AnyValueMap = AnyValueMap> implements IAnalyticsCollector<AnalyticsEvent<TValue, TAttr>> {
     #private;
+    /**
+     * Creates a new `BaseCollector`.
+     *
+     * @param name - Event name assigned to every emission (e.g. `'context-selected'`).
+     * @param schema - Zod schema used to validate each event before publishing.
+     */
     constructor(name: string, schema: CollectorSchema<TValue, TAttr>);
+    /**
+     * Returns an observable source of raw `{ value, attributes }` objects.
+     *
+     * @remarks
+     * Subclasses implement this to provide the domain-specific event stream.
+     * The base class wraps the output with the collector name and validates it.
+     *
+     * @returns An observable input of value/attribute pairs.
+     */
     abstract _initialize(): ObservableInput<{
         value: TValue;
         attributes: TAttr;
     }>;
+    /**
+     * Subscribes to the source returned by {@link BaseCollector._initialize},
+     * validates each emission with the Zod schema, and publishes through the
+     * internal subject.
+     */
     initialize(): Promise<void> | void;
+    /**
+     * Subscribes an observer to the validated event stream.
+     *
+     * @param observer - Partial observer receiving validated events.
+     * @returns An `Unsubscribable` handle.
+     */
     subscribe(observer: Partial<Observer<z.infer<CollectorSchema<TValue, TAttr>>>>): Unsubscribable;
 }

package/dist/types/collectors/ContextSelectedCollector.d.ts

@@ -5,14 +5,31 @@ import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
 import { BaseCollector } from './BaseCollector.js';
 import { type ContextItemType } from './utils/extractContextMetadata.js';
 /**
- * Collector to listen for context changes and add values and attributes for
- * further processing by adapters.
+ * Collector that emits an analytics event whenever the active Fusion context changes.
+ *
+ * @remarks
+ * Listens to `IContextProvider.currentContext$`, de-duplicates by context ID,
+ * pairs consecutive values, and emits both the new and previous context
+ * metadata. The current application key is included in attributes.
+ *
+ * Register via:
+ * ```ts
+ * builder.setCollector('context-selected', async (args) => {
+ *   const ctx = await args.requireInstance('context');
+ *   const app = await args.requireInstance('app');
+ *   return new ContextSelectedCollector(ctx, app);
+ * });
+ * ```
  */
 export declare class ContextSelectedCollector extends BaseCollector<ContextItemType, {
     previous?: ContextItemType;
     appKey?: string;
 }> implements IAnalyticsCollector {
     #private;
+    /**
+     * @param contextProvider - Fusion context module provider to observe.
+     * @param appProvider - Fusion app module provider for the current app key.
+     */
     constructor(contextProvider: IContextProvider, appProvider: AppModuleProvider);
     _initialize(): ObservableInput<{
         value: ContextItemType;

package/dist/types/collectors/index.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Re-exports for built-in analytics collectors.
+ *
+ * @remarks
+ * Import from `'@equinor/fusion-framework-module-analytics/collectors'`.
+ *
+ * @packageDocumentation
+ */
 export { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
 export { ContextSelectedCollector } from './ContextSelectedCollector.js';
 export { AppSelectedCollector } from './AppSelectedCollector.js';

package/dist/types/collectors/utils/extractAppMetadata.d.ts

@@ -1,8 +1,21 @@
 import { z } from 'zod';
 import type { AppManifest, CurrentApp } from '@equinor/fusion-framework-module-app';
+/**
+ * Zod schema for an object containing an optional `appKey` string.
+ *
+ * @remarks
+ * Used by {@link AppSelectedCollector} to validate the event body.
+ */
 export declare const appKeySchema: z.ZodNullable<z.ZodOptional<z.ZodObject<{
     appKey: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>>;
+/**
+ * Zod schema for a Fusion application metadata object.
+ *
+ * @remarks
+ * Validates core app fields (appKey, displayName, type) and optional build
+ * and category information. Used by {@link AppLoadedCollector}.
+ */
 export declare const appSchema: z.ZodOptional<z.ZodObject<{
     appKey: z.ZodString;
     displayName: z.ZodString;
@@ -11,7 +24,21 @@ export declare const appSchema: z.ZodOptional<z.ZodObject<{
     buildVersion: z.ZodOptional<z.ZodString>;
     buildTag: z.ZodNullable<z.ZodOptional<z.ZodString>>;
 }, z.core.$strip>>;
+/** Inferred type from {@link appKeySchema}. */
 export type AppKeyType = z.infer<typeof appKeySchema>;
+/** Inferred type from {@link appSchema}. */
 export type AppItemType = z.infer<typeof appSchema>;
+/**
+ * Extracts app-key metadata from a `CurrentApp` instance.
+ *
+ * @param app - The current app object.
+ * @returns An object containing the optional `appKey`.
+ */
 export declare const extractAppKeyMetadata: (app: CurrentApp) => z.input<typeof appKeySchema>;
+/**
+ * Extracts detailed app metadata from an `AppManifest` for analytics events.
+ *
+ * @param app - The application manifest.
+ * @returns An object with appKey, displayName, type, and optional build/category info.
+ */
 export declare const extractAppMetadata: (app: AppManifest) => z.input<typeof appSchema>;