@ama-mfe/ng-utils 14.0.0-next.8 → 14.0.0-next.9

package/README.md

@@ -295,3 +295,157 @@ The host information is stored in session storage so it won't be lost when navig
 When using iframes to embed applications, the browser history might be shared by the main page and the embedded iframe. For example `<iframe src="https://example.com" sandbox="allow-same-origin">` will share the same history as the main page. This can lead to unexpected behavior when using browser 'back' and 'forward' buttons.
 
 To avoid this, the `@ama-mfe/ng-utils` will forbid the application running in the iframe to alter the browser history. It will happen when connection is configured using `provideConection()` function. This will prevent the iframe to be able to use the `history.pushState` and `history.replaceState` methods.
+
+### User Activity Tracking
+
+The User Activity Tracking feature allows a host application (shell) to monitor user interactions across embedded micro-frontends. This is useful for implementing session timeout functionality, analytics, or any feature that needs to know when users are actively interacting with the application.
+
+#### How it works
+
+- **Producer**: The `ActivityProducerService` listens for DOM events (click, keydown, scroll, touchstart, focus) and:
+  - Exposes a `localActivity` signal for consumers within the same application (not throttled for local detection).
+  - Sends throttled activity messages via the communication protocol to connected peers.
+- **Consumer**: The `ActivityConsumerService` receives activity messages from connected peers via the communication protocol and exposes them via the `latestReceivedActivity` signal.
+
+Both services can be used in either the shell (host) or embedded applications depending on your use case. For example:
+- A shell can produce activity signals to notify embedded modules of user interactions in the host.
+- An embedded module can consume activity signals from the shell.
+- An application can use the producer's `localActivity` signal to detect activity locally.
+
+The service automatically throttles messages sent to peers to prevent flooding the communication channel. High-frequency events like `scroll` have additional throttling.
+
+#### Producer Configuration
+
+Start the `ActivityProducerService` to send activity signals to connected peers:
+
+```typescript
+import { inject, runInInjectionContext } from '@angular/core';
+import { bootstrapApplication } from '@angular/platform-browser';
+import { ConnectionService, ActivityProducerService } from '@ama-mfe/ng-utils';
+
+bootstrapApplication(App, appConfig)
+  .then((m) => {
+    runInInjectionContext(m.injector, () => {
+      if (window.top !== window.self) {
+        inject(ConnectionService).connect('hostUniqueID');
+        // Start activity tracking with custom throttle
+        inject(ActivityProducerService).start({
+          throttleMs: 5000 // Send at most one message every 5 seconds
+        });
+      }
+    });
+  });
+```
+
+##### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `throttleMs` | `number` | `1000` | Minimum interval between activity messages sent to the host |
+| `trackNestedIframes` | `boolean` | `false` | Enable tracking of nested iframes within the application |
+| `nestedIframePollIntervalMs` | `number` | `1000` | Polling interval for detecting iframe focus changes |
+| `nestedIframeActivityEmitIntervalMs` | `number` | `30000` | Interval for sending activity signals while an iframe has focus |
+| `highFrequencyThrottleMs` | `number` | `300` | Throttle time for high-frequency events (scroll) |
+| `shouldBroadcast` | `(event: Event) => boolean` | - | Optional filter function to control which events are broadcast |
+
+##### Filtering Events with shouldBroadcast
+
+The `shouldBroadcast` option allows you to filter which events trigger activity messages. This is useful in the shell application to exclude events that occur on iframes, since user activity inside embedded modules is already tracked via the communication protocol.
+
+```typescript
+// In the shell application
+inject(ActivityProducerService).start({
+  throttleMs: 1000,
+  shouldBroadcast: (event: Event) => {
+    // Exclude events on iframes - activity from embedded modules comes via the communication protocol
+    return !(event.target instanceof HTMLIFrameElement);
+  }
+});
+```
+
+##### Tracking Nested Iframes
+
+When a user interacts with content inside an iframe (e.g., a third-party widget, payment form, or embedded content), the parent application cannot detect those interactions directly. This is because:
+
+1. **Cross-origin restrictions**: DOM events inside cross-origin iframes do not bubble up to the parent document.
+2. **Focus isolation**: When an iframe has focus, the parent document stops receiving keyboard and mouse events.
+
+This creates a problem for detection of user interactions: a user could be actively filling out a form inside an iframe, but the host application would see no activity and might incorrectly trigger a session timeout.
+
+**Solution**: When `trackNestedIframes` is enabled, the `ActivityProducerService` polls `document.activeElement` to detect when an iframe gains focus. While an iframe has focus, the service simulates activity by periodically emitting `iframeinteraction` events. This ensures the host application knows the user is still active, even though it cannot see the actual interactions inside the iframe.
+
+Enable nested iframe tracking in embedded applications that contain other iframes:
+
+```typescript
+inject(ActivityProducerService).start({
+  throttleMs: 5000,
+  trackNestedIframes: true,
+  nestedIframePollIntervalMs: 1000, // Check for iframe focus every second
+  nestedIframeActivityEmitIntervalMs: 30000 // Send activity every 30s while iframe has focus
+});
+```
+
+**When to use**: Enable this option in embedded modules that contain iframes whose content you cannot modify to include activity tracking (e.g., third-party widgets, payment providers, or external content).
+
+#### Consumer Configuration
+
+Start the `ActivityConsumerService` to receive activity signals from connected peers:
+
+```typescript
+import { Component, inject, effect } from '@angular/core';
+import { ActivityConsumerService } from '@ama-mfe/ng-utils';
+
+@Component({
+  selector: 'app-shell',
+  template: '...'
+})
+export class ShellComponent {
+  private readonly activityConsumer = inject(ActivityConsumerService);
+
+  constructor() {
+    // Start listening for activity messages
+    this.activityConsumer.start();
+
+    // React to activity changes
+    effect(() => {
+      const activity = this.activityConsumer.latestReceivedActivity();
+      if (activity) {
+        console.log(`Activity from ${activity.channelId}: ${activity.eventType} at ${activity.timestamp}`);
+        // Reset session timeout, update analytics, etc.
+      }
+    });
+  }
+
+  ngOnDestroy() {
+    this.activityConsumer.stop();
+  }
+}
+```
+
+#### Local Activity Signal
+
+The `ActivityProducerService` also exposes a `localActivity` signal for detecting activity within the same application:
+
+```typescript
+import { Component, inject, effect } from '@angular/core';
+import { ActivityProducerService } from '@ama-mfe/ng-utils';
+
+@Component({
+  selector: 'app-root',
+  template: '...'
+})
+export class AppComponent {
+  private readonly activityProducer = inject(ActivityProducerService);
+
+  constructor() {
+    this.activityProducer.start({ throttleMs: 1000 });
+
+    effect(() => {
+      const activity = this.activityProducer.localActivity();
+      if (activity) {
+        // React to local activity (not throttled for local detection)
+      }
+    });
+  }
+}
+```

package/fesm2022/ama-mfe-ng-utils.mjs

@@ -4,7 +4,7 @@ import * as i0 from '@angular/core';
 import { input, inject, ElementRef, computed, SecurityContext, effect, HostBinding, Directive, Injectable, signal, DestroyRef, provideAppInitializer, Pipe, makeEnvironmentProviders, untracked, afterNextRender, Renderer2 } from '@angular/core';
 import { DomSanitizer } from '@angular/platform-browser';
 import { LoggerService } from '@o3r/logger';
-import { HISTORY_MESSAGE_TYPE, NAVIGATION_MESSAGE_TYPE, RESIZE_MESSAGE_TYPE, THEME_MESSAGE_TYPE } from '@ama-mfe/messages';
+import { HISTORY_MESSAGE_TYPE, USER_ACTIVITY_MESSAGE_TYPE, NAVIGATION_MESSAGE_TYPE, RESIZE_MESSAGE_TYPE, THEME_MESSAGE_TYPE } from '@ama-mfe/messages';
 import { takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
 import { Router, ActivatedRoute, NavigationEnd } from '@angular/router';
 import { Subject, filter, map } from 'rxjs';
@@ -444,6 +444,17 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
 /** the error message type */
 const ERROR_MESSAGE_TYPE = 'error';
 
+/**
+ * Type guard to check if a message is a user activity message
+ * @param message The message to check
+ */
+function isUserActivityMessage(message) {
+    return (typeof message === 'object'
+        && message !== null
+        && 'type' in message
+        && message.type === USER_ACTIVITY_MESSAGE_TYPE);
+}
+
 /**
  * A constant array of known message types and their versions.
  */
@@ -1238,9 +1249,425 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
                 }]
         }], ctorParameters: () => [] });
 
+/**
+ * DOM events that indicate user activity
+ */
+const ACTIVITY_EVENTS = [
+    'click',
+    'keydown',
+    'scroll',
+    'touchstart',
+    'focus'
+];
+/**
+ * Custom activity event type for iframe interactions.
+ * Emitted programmatically when an iframe gains focus, not from a DOM event listener.
+ */
+const IFRAME_INTERACTION_EVENT = 'iframeinteraction';
+/**
+ * Custom activity event type for visibility changes.
+ * Emitted programmatically when the document becomes visible, not from a DOM event listener.
+ */
+const VISIBILITY_CHANGE_EVENT = 'visibilitychange';
+/**
+ * High-frequency events that require throttling to avoid performance issues
+ */
+const HIGH_FREQUENCY_EVENTS = [
+    'scroll'
+];
+/**
+ * Default configuration values for the ActivityProducerService
+ */
+const DEFAULT_ACTIVITY_PRODUCER_CONFIG = {
+    /** Default throttle time in milliseconds between activity messages */
+    throttleMs: 1000,
+    /** Default throttle time in milliseconds for high-frequency events */
+    highFrequencyThrottleMs: 300,
+    /** Whether to track nested iframes by default */
+    trackNestedIframes: false,
+    /** Default interval for iframe activity signals (30 seconds) */
+    nestedIframeActivityEmitIntervalMs: 30_000,
+    /** Default polling interval for detecting iframe focus changes (1 second) */
+    nestedIframePollIntervalMs: 1000
+};
+
+/**
+ * Service that tracks user activity within nested iframes.
+ *
+ * Polls document.activeElement frequently to detect when an iframe has focus.
+ * When an iframe gains focus, emits immediately and then at the configured interval.
+ * When focus leaves the iframe, it stops emitting.
+ *
+ * This is needed because cross-origin iframes don't fire focus/blur events
+ * that bubble to the parent, and the regular activity tracker can't detect
+ * user interactions inside iframes.
+ */
+class IframeActivityTrackerService {
+    constructor() {
+        /**
+         * Bound visibility change handler for cleanup
+         */
+        this.visibilityChangeHandler = () => this.handleVisibilityChange();
+    }
+    /**
+     * Whether the service has been started
+     */
+    get started() {
+        return this.config !== undefined;
+    }
+    /**
+     * Whether we are currently tracking iframe activity (iframe had focus on last poll)
+     */
+    get isTrackingIframeActivity() {
+        return this.activityIntervalId !== undefined;
+    }
+    /**
+     * Polls document.activeElement to detect iframe focus changes.
+     * When iframe gains focus: emit immediately and start activity interval.
+     * When iframe loses focus: stop activity interval.
+     */
+    checkActiveElement() {
+        const activeElement = document.activeElement;
+        const iframeFocused = activeElement instanceof HTMLIFrameElement;
+        if (iframeFocused && !this.isTrackingIframeActivity) {
+            // Iframe just gained focus - emit immediately and start activity interval
+            this.config?.onActivity();
+            this.startActivityInterval();
+        }
+        else if (!iframeFocused && this.isTrackingIframeActivity) {
+            // Focus left the iframe - stop activity interval
+            this.stopActivityInterval();
+        }
+    }
+    /**
+     * Handles visibility change events to pause/resume polling when tab visibility changes.
+     */
+    handleVisibilityChange() {
+        if (document.visibilityState === 'visible') {
+            this.startPolling();
+        }
+        else {
+            this.stopPolling();
+            this.stopActivityInterval();
+        }
+    }
+    /**
+     * Starts polling for active element changes.
+     */
+    startPolling() {
+        if (this.pollIntervalId) {
+            return;
+        }
+        this.pollIntervalId = setInterval(() => this.checkActiveElement(), this.config.pollIntervalMs);
+    }
+    /**
+     * Stops polling for active element changes.
+     */
+    stopPolling() {
+        if (this.pollIntervalId) {
+            clearInterval(this.pollIntervalId);
+            this.pollIntervalId = undefined;
+        }
+    }
+    /**
+     * Starts the activity emission interval.
+     */
+    startActivityInterval() {
+        this.stopActivityInterval();
+        this.activityIntervalId = setInterval(() => {
+            this.config?.onActivity();
+        }, this.config.activityIntervalMs);
+    }
+    /**
+     * Stops the activity emission interval.
+     */
+    stopActivityInterval() {
+        if (this.activityIntervalId) {
+            clearInterval(this.activityIntervalId);
+            this.activityIntervalId = undefined;
+        }
+    }
+    /**
+     * Starts tracking nested iframes within the document.
+     * @param config Configuration for the tracker
+     */
+    start(config) {
+        if (this.started) {
+            return;
+        }
+        this.config = config;
+        // Listen for visibility changes to pause/resume polling
+        document.addEventListener('visibilitychange', this.visibilityChangeHandler);
+        // Only start polling if document is currently visible
+        if (document.visibilityState === 'visible') {
+            this.startPolling();
+        }
+    }
+    /**
+     * Stops tracking nested iframes and cleans up resources.
+     */
+    stop() {
+        if (!this.started) {
+            return;
+        }
+        document.removeEventListener('visibilitychange', this.visibilityChangeHandler);
+        this.stopPolling();
+        this.stopActivityInterval();
+        this.config = undefined;
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: IframeActivityTrackerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: IframeActivityTrackerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: IframeActivityTrackerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+/**
+ * Generic service that tracks user activity and sends messages.
+ * Can be configured for different contexts (cockpit or modules) via start() method parameter.
+ */
+class ActivityProducerService {
+    constructor() {
+        this.messageService = inject(MessagePeerService);
+        this.destroyRef = inject(DestroyRef);
+        this.iframeActivityTracker = inject(IframeActivityTrackerService);
+        this.logger = inject(LoggerService);
+        /**
+         * Timestamp of the last sent activity message
+         */
+        this.lastSentTimestamp = 0;
+        /**
+         * Bound event listeners for cleanup
+         */
+        this.boundListeners = new Map();
+        /**
+         * Last emission timestamps for throttled high-frequency events
+         */
+        this.lastEmitTimestamps = new Map();
+        /**
+         * Whether the service has been started
+         */
+        this.started = false;
+        /**
+         * Signal that emits local activity information.
+         * This allows consumers to react to activity detected by this producer.
+         */
+        this.localActivityWritable = signal(undefined, ...(ngDevMode ? [{ debugName: "localActivityWritable" }] : []));
+        /**
+         * Read-only signal containing the latest local activity info.
+         * Use this signal to react to locally detected activity.
+         */
+        this.localActivity = this.localActivityWritable.asReadonly();
+        /**
+         * @inheritdoc
+         */
+        this.types = USER_ACTIVITY_MESSAGE_TYPE;
+        registerProducer(this);
+        this.destroyRef.onDestroy(() => this.stop());
+    }
+    /**
+     * Handles high-frequency events by applying a per-eventType throttle before calling onActivity.
+     *
+     * Difference with onActivity:
+     * - onActivityThrottled limits how often a given high-frequency event type (e.g. scroll) is processed
+     *   (based on highFrequencyThrottleMs and lastEmitTimestamps)
+     * - onActivity updates the local activity signal and applies the global message throttle
+     *   (based on global throttleMs and lastSentTimestamp)
+     * @param eventType The type of activity event that occurred
+     * @param configObject
+     */
+    onActivityThrottled(eventType, configObject) {
+        const now = Date.now();
+        const lastEmit = this.lastEmitTimestamps.get(eventType) ?? 0;
+        const throttleMs = configObject.highFrequencyThrottleMs;
+        if (now - lastEmit >= throttleMs) {
+            this.lastEmitTimestamps.set(eventType, now);
+            this.onActivity(eventType, configObject);
+        }
+    }
+    /**
+     * Handles activity by sending a throttled message and emitting to local signal.
+     * @param eventType The type of activity event that occurred
+     * @param configObject
+     */
+    onActivity(eventType, configObject) {
+        const now = Date.now();
+        // Always emit local activity signal (not throttled for local detection)
+        this.localActivityWritable.set({
+            channelId: 'local',
+            eventType,
+            timestamp: now
+        });
+        // Send message with throttling
+        if (now - this.lastSentTimestamp >= configObject.throttleMs) {
+            this.lastSentTimestamp = now;
+            this.sendActivityMessage(eventType, now);
+        }
+    }
+    /**
+     * Sends an activity message.
+     * @param eventType The type of activity event
+     * @param timestamp The timestamp of the event
+     */
+    sendActivityMessage(eventType, timestamp) {
+        const message = {
+            type: USER_ACTIVITY_MESSAGE_TYPE,
+            version: '1.0',
+            eventType,
+            timestamp
+        };
+        const registeredPeersIdsForUserActivity = [...this.messageService.knownPeers.entries()]
+            .filter(([peerId]) => peerId !== this.messageService.id)
+            .filter(([, messages]) => messages.some((msg) => msg.type === USER_ACTIVITY_MESSAGE_TYPE))
+            .map((peer) => peer[0]);
+        // send messages to the peers waiting for user activity
+        // avoids sending the message to modules which are not using it
+        if (registeredPeersIdsForUserActivity.length > 0) {
+            this.messageService.send(message, { to: registeredPeersIdsForUserActivity });
+        }
+    }
+    /**
+     * @inheritdoc
+     */
+    handleError(message) {
+        this.logger.error('Error in user activity service message', message);
+    }
+    /**
+     * Starts observing user activity events.
+     * When activity is detected, it sends a throttled message.
+     * Event listeners are attached after the next render to ensure DOM is ready.
+     * @param config Configuration for the activity producer
+     */
+    start(config) {
+        if (this.started) {
+            return;
+        }
+        this.started = true;
+        const configObject = { ...DEFAULT_ACTIVITY_PRODUCER_CONFIG, ...config };
+        // Always use afterNextRender to ensure DOM is ready in all contexts
+        afterNextRender(() => {
+            ACTIVITY_EVENTS.forEach((eventType) => {
+                const isHighFrequency = HIGH_FREQUENCY_EVENTS.includes(eventType);
+                const listener = (event) => {
+                    // do nothing if the event is a key kept pressed
+                    if (eventType === 'keydown' && event instanceof KeyboardEvent && event.repeat) {
+                        return;
+                    }
+                    // Apply filter if provided
+                    if (configObject.shouldBroadcast?.(event) === false) {
+                        return;
+                    }
+                    if (isHighFrequency) {
+                        this.onActivityThrottled(eventType, configObject);
+                    }
+                    else {
+                        this.onActivity(eventType, configObject);
+                    }
+                };
+                this.boundListeners.set(eventType, listener);
+                document.addEventListener(eventType, listener, { passive: true, capture: true });
+            });
+            // Also listen for visibility changes
+            const visibilityListener = () => {
+                if (document.visibilityState === 'visible') {
+                    this.onActivity(VISIBILITY_CHANGE_EVENT, configObject);
+                }
+            };
+            this.boundListeners.set(VISIBILITY_CHANGE_EVENT, visibilityListener);
+            document.addEventListener(VISIBILITY_CHANGE_EVENT, visibilityListener, { passive: true, capture: true });
+            // Set up nested iframe tracking if enabled
+            if (configObject.trackNestedIframes) {
+                this.iframeActivityTracker.start({
+                    pollIntervalMs: configObject.nestedIframePollIntervalMs,
+                    activityIntervalMs: configObject.nestedIframeActivityEmitIntervalMs,
+                    onActivity: () => this.onActivity(IFRAME_INTERACTION_EVENT, configObject)
+                });
+            }
+        });
+    }
+    /**
+     * Stops observing user activity events.
+     */
+    stop() {
+        this.boundListeners.forEach((listener, eventType) => {
+            document.removeEventListener(eventType, listener, { capture: true });
+        });
+        this.boundListeners.clear();
+        this.lastEmitTimestamps.clear();
+        this.iframeActivityTracker.stop();
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ActivityProducerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ActivityProducerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ActivityProducerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [] });
+
+/**
+ * Generic service that consumes user activity messages.
+ * Can be used in both shell (to receive from modules) and modules (to receive from shell).
+ */
+class ActivityConsumerService {
+    constructor() {
+        this.consumerManagerService = inject(ConsumerManagerService);
+        /**
+         * Signal containing the latest activity info
+         */
+        this.latestReceivedActivityWritable = signal(undefined, ...(ngDevMode ? [{ debugName: "latestReceivedActivityWritable" }] : []));
+        /**
+         * Read-only signal containing the latest activity info received from other peers via the message protocol.
+         * Access the timestamp via latestReceivedActivity()?.timestamp
+         */
+        this.latestReceivedActivity = this.latestReceivedActivityWritable.asReadonly();
+        /**
+         * @inheritdoc
+         */
+        this.type = USER_ACTIVITY_MESSAGE_TYPE;
+        /**
+         * @inheritdoc
+         */
+        this.supportedVersions = {
+            // eslint-disable-next-line @typescript-eslint/naming-convention -- Version keys follow message versioning convention
+            '1.0': (message) => {
+                this.latestReceivedActivityWritable.set({
+                    channelId: message.from || 'unknown',
+                    eventType: message.payload.eventType,
+                    timestamp: message.payload.timestamp
+                });
+            }
+        };
+    }
+    /**
+     * Starts the activity consumer service by registering it with the consumer manager.
+     */
+    start() {
+        this.consumerManagerService.register(this);
+    }
+    /**
+     * Stops the activity consumer service by unregistering it from the consumer manager.
+     */
+    stop() {
+        this.consumerManagerService.unregister(this);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ActivityConsumerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ActivityConsumerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: ActivityConsumerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { ApplyTheme, ConnectDirective, ConsumerManagerService, ERROR_MESSAGE_TYPE, HistoryConsumerService, HostInfoPipe, KNOWN_MESSAGES, MFE_HOST_APPLICATION_ID_PARAM, MFE_HOST_URL_PARAM, MFE_MODULE_APPLICATION_ID_PARAM, NavigationConsumerService, ProducerManagerService, ResizeConsumerService, ResizeService, RestoreRoute, RouteMemorizeDirective, RouteMemorizeService, RoutingService, ScalableDirective, THEME_QUERY_PARAM_NAME, THEME_URL_SUFFIX, ThemeConsumerService, ThemeProducerService, applyInitialTheme, applyTheme, downloadApplicationThemeCss, getAvailableConsumers, getDefaultClientEndpointStartOptions, getHostInfo, getStyle, hostQueryParams, isEmbedded, isErrorMessage, persistHostInfo, provideConnection, provideHistoryOverrides, registerConsumer, registerProducer, sendError };
+export { ACTIVITY_EVENTS, ActivityConsumerService, ActivityProducerService, ApplyTheme, ConnectDirective, ConsumerManagerService, DEFAULT_ACTIVITY_PRODUCER_CONFIG, ERROR_MESSAGE_TYPE, HIGH_FREQUENCY_EVENTS, HistoryConsumerService, HostInfoPipe, IFRAME_INTERACTION_EVENT, IframeActivityTrackerService, KNOWN_MESSAGES, MFE_HOST_APPLICATION_ID_PARAM, MFE_HOST_URL_PARAM, MFE_MODULE_APPLICATION_ID_PARAM, NavigationConsumerService, ProducerManagerService, ResizeConsumerService, ResizeService, RestoreRoute, RouteMemorizeDirective, RouteMemorizeService, RoutingService, ScalableDirective, THEME_QUERY_PARAM_NAME, THEME_URL_SUFFIX, ThemeConsumerService, ThemeProducerService, VISIBILITY_CHANGE_EVENT, applyInitialTheme, applyTheme, downloadApplicationThemeCss, getAvailableConsumers, getDefaultClientEndpointStartOptions, getHostInfo, getStyle, hostQueryParams, isEmbedded, isErrorMessage, isUserActivityMessage, persistHostInfo, provideConnection, provideHistoryOverrides, registerConsumer, registerProducer, sendError };
 //# sourceMappingURL=ama-mfe-ng-utils.mjs.map