@equinor/fusion-framework-module-analytics 3.1.0 → 3.1.1

package/src/__tests__/mock/analytics-mock-adapter.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { ModulesConfigurator } from '@equinor/fusion-framework-module';
-import { Subject } from 'rxjs';
-
-import { enableAnalytics } from '../../enable-analytics.js';
-import { ConsoleAnalyticsAdapter } from '../../adapters/ConsoleAnalyticsAdapter.js';
-import { MockAnalyticsAdapter } from '../../mock/MockAnalyticsAdapter.js';
-import type { IAnalyticsConfigurator } from '../../AnalyticsConfigurator.interface.js';
-import type { IAnalyticsProvider } from '../../AnalyticsProvider.interface.js';
-import type { AnalyticsEvent } from '../../types.js';
-
-/**
- * Initializes the analytics module through the real module system, with a
- * `MockAnalyticsAdapter` registered alongside whatever the test configures.
- *
- * @remarks
- * Deliberately avoids hand-building an `AnalyticsProvider`. Testing the
- * adapter's own logic in isolation (see `MockAnalyticsAdapter.test.ts`) can't
- * prove it actually receives events through the real configure -> initialize
- * -> collector/adapter dispatch pipeline every other adapter goes through.
- *
- * @param configure - Optional callback to register additional adapters/collectors.
- * @returns The real `IAnalyticsProvider` instance and the recording adapter.
- */
-const initializeWith = async (
-  configure?: (builder: IAnalyticsConfigurator) => void,
-): Promise<{ provider: IAnalyticsProvider; recorder: MockAnalyticsAdapter }> => {
-  const recorder = new MockAnalyticsAdapter();
-  const configurator = new ModulesConfigurator([]);
-
-  enableAnalytics(configurator, (builder) => {
-    builder.setAdapter('mock', async () => recorder);
-    configure?.(builder);
-  });
-
-  const instances = await configurator.initialize();
-  const provider = (instances as unknown as { analytics: IAnalyticsProvider }).analytics;
-
-  return { provider, recorder };
-};
-
-describe('MockAnalyticsAdapter (through the real analytics module)', () => {
-  it('observes events pushed via provider.trackAnalytic', async () => {
-    const { provider, recorder } = await initializeWith();
-
-    provider.trackAnalytic({ name: 'button-click', value: 'save' });
-
-    expect(recorder.getAnalytics('button-click')).toHaveLength(1);
-  });
-
-  it('observes events emitted by a real registered collector', async () => {
-    const clicks$ = new Subject<AnalyticsEvent>();
-    const { recorder } = await initializeWith((builder) => {
-      builder.setCollector('clicks', async () => clicks$);
-    });
-
-    clicks$.next({ name: 'window-click', value: 42 });
-
-    const event = await recorder.waitForAnalytic('window-click');
-    expect(event.value).toBe(42);
-  });
-
-  it('does not interfere with other adapters registered alongside it', async () => {
-    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => undefined);
-    const { provider, recorder } = await initializeWith((builder) => {
-      builder.setAdapter('console', async () => new ConsoleAnalyticsAdapter());
-    });
-
-    provider.trackAnalytic({ name: 'page-view', value: null });
-
-    expect(recorder.getAnalytics('page-view')).toHaveLength(1);
-    expect(logSpy).toHaveBeenCalledWith('Analytics::Adapter::Console', {
-      name: 'page-view',
-      value: null,
-    });
-
-    logSpy.mockRestore();
-  });
-});

package/src/adapters/AnalyticsAdapter.interface.ts

@@ -1,36 +0,0 @@
-import type { AnalyticsEvent } from '../types.js';
-
-/**
- * Contract for an analytics adapter that receives events and exports them to a backend.
- *
- * @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 {
-  /**
-   * Initializes the analytics adapter for setup and configuration.
-   *
-   * @returns Promise that resolves when initialization is complete, or void for synchronous initialization.
-   */
-  initialize?(): Promise<void> | void;
-
-  /**
-   * Exports analytics event to the configured backend.
-   *
-   * @param events - Array of analytics events to export.
-   * @returns Promise that resolves when export is complete.
-   */
-  registerAnalytic(event: T): Promise<void> | void;
-}

package/src/adapters/ConsoleAnalyticsAdapter.ts

@@ -1,37 +0,0 @@
-import type { IAnalyticsAdapter } from './AnalyticsAdapter.interface.js';
-import type { AnalyticsEvent } from '../types.js';
-
-/**
- * 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 class ConsoleAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent>
-  implements IAnalyticsAdapter
-{
-  /**
-   * Logs the event to the console.
-   *
-   * @param event - The analytics event to log.
-   * @returns Resolves once the event has been logged.
-   */
-  registerAnalytic(event: T): Promise<void> | void {
-    console.log('Analytics::Adapter::Console', event);
-  }
-
-  /** No teardown is required for this adapter. */
-  [Symbol.dispose]() {
-    // no-op
-  }
-}

package/src/adapters/FusionAnalyticsAdapter.ts

@@ -1,95 +0,0 @@
-import type { IAnalyticsAdapter } from './AnalyticsAdapter.interface.js';
-import type { AnalyticsEvent } from '../types.js';
-
-import {
-  LoggerProvider,
-  BatchLogRecordProcessor,
-  type ReadableLogRecord,
-} from '@opentelemetry/sdk-logs';
-import type { OTLPExporterBase } from '@opentelemetry/otlp-exporter-base';
-import {
-  SeverityNumber,
-  type LogAttributes,
-  type Logger,
-  type LogRecord,
-} from '@opentelemetry/api-logs';
-import { resourceFromAttributes } from '@opentelemetry/resources';
-import { version } from '../version.js';
-import { v7 as uuid } from 'uuid';
-
-/**
- * Analytics adapter that forwards events to an OpenTelemetry log exporter.
- *
- * @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 class FusionAnalyticsAdapter<T extends AnalyticsEvent = AnalyticsEvent>
-  implements IAnalyticsAdapter
-{
-  #logExporter: OTLPExporterBase<ReadableLogRecord[]>;
-  #loggerProvider: LoggerProvider;
-  #logger: Logger;
-
-  /**
-   * 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[]> }) {
-    this.#logExporter = args.logExporter;
-
-    this.#loggerProvider = new LoggerProvider({
-      processors: [new BatchLogRecordProcessor({ exporter: this.#logExporter })],
-      resource: resourceFromAttributes({
-        'module.version': version,
-        'session.id': uuid(),
-        'portal.id': args.portalId,
-      }),
-    });
-    this.#logger = this.#loggerProvider.getLogger('fusion');
-  }
-
-  /**
-   * Maps an analytics event to an OTLP `LogRecord` and emits it via the logger.
-   *
-   * @param event - The analytics event to map and emit.
-   * @returns Resolves once the event has been emitted to the logger.
-   */
-  registerAnalytic(event: T): Promise<void> | void {
-    const logRecord: Partial<LogRecord> = {
-      eventName: event.name,
-      attributes: event.attributes as LogAttributes,
-      body: event.value,
-      severityNumber: SeverityNumber.INFO,
-    };
-    this.#logger.emit(logRecord);
-  }
-
-  /** Shuts down the log exporter and logger provider, flushing remaining records. */
-  [Symbol.dispose]() {
-    this.#logExporter.shutdown();
-    this.#loggerProvider.shutdown();
-  }
-}

package/src/adapters/index.ts

@@ -1,11 +0,0 @@
-/**
- * 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/src/collectors/AnalyticsCollector.interface.ts

@@ -1,27 +0,0 @@
-import type { Subscribable } from 'rxjs';
-import type { AnalyticsEvent } from '../types.js';
-
-/**
- * Contract for an analytics collector that observes application state and emits
- * structured analytics events.
- *
- * @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> {
-  /**
-   * Initializes the analytics collector for setup and configuration.
-   * This method is optional - if not implemented, the collector should be directly subscribable.
-   *
-   * @returns Promise that resolves when initialization is complete, or void for synchronous initialization.
-   */
-  initialize?(): Promise<void> | void;
-}

package/src/collectors/AppLoadedCollector.ts

@@ -1,94 +0,0 @@
-import { BaseCollector, createSchema } from './create-schema.js';
-import { type AppItemType, appSchema } from './utils/app-schema.js';
-import { extractAppMetadata } from './utils/extract-app-metadata.js';
-import { type ContextItemType, contextSchema } from './utils/context-schema.js';
-import { extractContextMetadata } from './utils/extract-context-metadata.js';
-import type { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
-
-import type {
-  AppModulesInstance,
-  AppManifest,
-  AppModuleProvider,
-} from '@equinor/fusion-framework-module-app';
-import type { IEventModuleProvider } from '@equinor/fusion-framework-module-event';
-
-import { type ObservableInput, Subject } from 'rxjs';
-import { z } from 'zod';
-import type { ContextModule } from '@equinor/fusion-framework-module-context';
-
-const EVENT_NAME = 'onAppModulesLoaded';
-
-/** Zod schema for the `app-loaded` event (value + attributes). */
-const eventSchema = createSchema(appSchema, z.object({ context: contextSchema }));
-
-/**
- * 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 class AppLoadedCollector
-  extends BaseCollector<AppItemType, { context?: ContextItemType }>
-  implements IAnalyticsCollector
-{
-  #eventProvider: IEventModuleProvider;
-  #appProvider: AppModuleProvider;
-
-  /**
-   * @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) {
-    super('app-loaded', eventSchema);
-    this.#eventProvider = eventProvider;
-    this.#appProvider = appProvider;
-  }
-
-  /**
-   * Builds an observable that emits an analytics event whenever the app-loaded
-   * event fires, falling back to `appProvider` for manifest data when needed.
-   *
-   * @returns An observable input emitting the app-loaded event's value and attributes.
-   */
-  _initialize(): ObservableInput<{
-    value: AppItemType;
-    attributes: { context?: ContextItemType };
-  }> {
-    const subject = new Subject<{
-      value: AppItemType;
-      attributes: { context?: ContextItemType };
-    }>();
-    this.#eventProvider.addEventListener(EVENT_NAME, (event) => {
-      // Fallback to appProvider for manifest if app is not updated with latest
-      // payload for onAppModulesLoaded (missing manifest).
-      const manifest =
-        (event.detail.manifest as AppManifest) ?? this.#appProvider.current?.manifest;
-      const modules = event.detail.modules as AppModulesInstance<[ContextModule]>;
-
-      const data = {
-        value: manifest && extractAppMetadata(manifest),
-        attributes: {
-          context:
-            modules.context?.currentContext &&
-            extractContextMetadata(modules.context.currentContext),
-        },
-      };
-
-      subject.next(data);
-    });
-
-    return subject;
-  }
-}

package/src/collectors/AppSelectedCollector.ts

@@ -1,70 +0,0 @@
-import { map, type ObservableInput, pairwise } from 'rxjs';
-import type { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
-import { BaseCollector, createSchema } from './create-schema.js';
-import { type AppKeyType, appKeySchema } from './utils/app-key-schema.js';
-import { extractAppKeyMetadata } from './utils/extract-app-key-metadata.js';
-
-import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
-
-import { z } from 'zod';
-
-/** Zod schema for the `app-selected` event (value + attributes). */
-const eventSchema = createSchema(appKeySchema, z.object({ previous: appKeySchema }));
-
-/**
- * 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 class AppSelectedCollector
-  extends BaseCollector<AppKeyType, { previous?: AppKeyType }>
-  implements IAnalyticsCollector
-{
-  #appProvider: AppModuleProvider;
-
-  /**
-   * @param appProvider - Fusion app module provider to observe.
-   */
-  constructor(appProvider: AppModuleProvider) {
-    super('app-selected', eventSchema);
-    this.#appProvider = appProvider;
-  }
-
-  /**
-   * Builds an observable that emits an analytics event each time the selected
-   * app changes, including the previous app's key metadata.
-   *
-   * @returns An observable input emitting the newly selected app's value and attributes.
-   */
-  _initialize(): ObservableInput<{
-    value: AppKeyType;
-    attributes: { previous?: AppKeyType };
-  }> {
-    // Pair each app-selection emission with the previously selected app
-    const appSelected$ = this.#appProvider.current$.pipe(pairwise());
-
-    // Map the [previous, next] pair into the analytics event shape
-    const data$ = appSelected$.pipe(
-      map(([prev, next]) => {
-        return {
-          value: extractAppKeyMetadata(next),
-          attributes: {
-            previous: prev && extractAppKeyMetadata(prev),
-          },
-        };
-      }),
-    );
-
-    return data$;
-  }
-}

package/src/collectors/ContextSelectedCollector.ts

@@ -1,83 +0,0 @@
-import { distinctUntilChanged, map, type ObservableInput, pairwise } from 'rxjs';
-import type { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
-import type { IContextProvider } from '@equinor/fusion-framework-module-context';
-import type { AppModuleProvider } from '@equinor/fusion-framework-module-app';
-import { z } from 'zod';
-import { BaseCollector, createSchema } from './create-schema.js';
-import { type ContextItemType, contextSchema } from './utils/context-schema.js';
-import { extractContextMetadata } from './utils/extract-context-metadata.js';
-
-/** Zod schema for the `context-selected` event (value + attributes). */
-const eventSchema = createSchema(
-  contextSchema,
-  z.object({ previous: contextSchema, appKey: z.string().optional() }),
-);
-
-/**
- * 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 class ContextSelectedCollector
-  extends BaseCollector<ContextItemType, { previous?: ContextItemType; appKey?: string }>
-  implements IAnalyticsCollector
-{
-  #contextProvider: IContextProvider;
-  #appProvider: AppModuleProvider;
-
-  /**
-   * @param contextProvider - Fusion context module provider to observe.
-   * @param appProvider - Fusion app module provider for the current app key.
-   */
-  constructor(contextProvider: IContextProvider, appProvider: AppModuleProvider) {
-    super('context-selected', eventSchema);
-    this.#contextProvider = contextProvider;
-    this.#appProvider = appProvider;
-  }
-
-  /**
-   * Builds an observable that emits an analytics event each time the selected
-   * context changes, including the previous context and current app key.
-   *
-   * @returns An observable input emitting the newly selected context's value and attributes.
-   */
-  _initialize(): ObservableInput<{
-    value: ContextItemType;
-    attributes: { previous?: ContextItemType; appKey?: string };
-  }> {
-    // Track context changes, pairing each new context with the previously selected one
-    const contextSelected$ = this.#contextProvider.currentContext$.pipe(
-      // Only emit when an actual change has happened.
-      distinctUntilChanged((prev, curr) => prev?.id === curr?.id),
-      // Provide both the old and the new value.
-      pairwise(),
-    );
-
-    // Map the [previous, next] pair into the analytics event shape
-    const data$ = contextSelected$.pipe(
-      map(([prev, next]) => {
-        return {
-          value: next && extractContextMetadata(next),
-          attributes: {
-            previous: prev && extractContextMetadata(prev),
-            appKey: this.#appProvider.current?.appKey,
-          },
-        };
-      }),
-    );
-
-    return data$;
-  }
-}

package/src/collectors/create-schema.ts

@@ -1,123 +0,0 @@
-import type { AnyValue, AnyValueMap, AnalyticsEvent } from '../types.js';
-import type { IAnalyticsCollector } from './AnalyticsCollector.interface.js';
-
-import { from, map, type ObservableInput, Subject, type Observer, type Unsubscribable } from 'rxjs';
-import { z } from 'zod';
-
-/**
- * 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 const createSchema = <TValue = AnyValue, TAttr = AnyValueMap>(
-  value: z.ZodSchema<TValue>,
-  attributes: z.ZodSchema<TAttr>,
-) => {
-  return z.object({
-    name: z.string(),
-    value: value,
-    attributes: attributes.optional(),
-  });
-};
-
-/** Inferred Zod schema type produced by {@link createSchema}. */
-export type CollectorSchema<TValue = AnyValue, TAttr = AnyValueMap> = ReturnType<
-  typeof createSchema<TValue, TAttr>
->;
-
-/**
- * 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 abstract class BaseCollector<
-  TValue extends AnyValue,
-  TAttr extends AnyValueMap = AnyValueMap,
-> implements IAnalyticsCollector<AnalyticsEvent<TValue, TAttr>>
-{
-  #schema: CollectorSchema<TValue, TAttr>;
-  #name: string;
-  #subject: Subject<z.infer<CollectorSchema<TValue, TAttr>>> = new Subject<
-    z.infer<CollectorSchema<TValue, TAttr>>
-  >();
-
-  /**
-   * 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>) {
-    this.#name = name;
-    this.#schema = schema;
-  }
-
-  /**
-   * 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.
-   *
-   * @returns Resolves once the source has been subscribed to.
-   */
-  initialize(): Promise<void> | void {
-    // Shape each emission into the named/validated event before publishing
-    from(this._initialize())
-      .pipe(
-        map(({ value, attributes }) => {
-          return {
-            name: this.#name,
-            value: value,
-            attributes: attributes,
-          };
-        }),
-        map((x) => this.#schema.parse(x)),
-      )
-      .subscribe(this.#subject);
-  }
-
-  /**
-   * 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 {
-    return this.#subject.subscribe(observer);
-  }
-}

package/src/collectors/index.ts

@@ -1,12 +0,0 @@
-/**
- * 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';
-export { AppLoadedCollector } from './AppLoadedCollector.js';