@o3r/analytics 12.1.0-prerelease.79 → 12.1.0-prerelease.80

package/esm2022/contracts/events-contracts.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"events-contracts.js","sourceRoot":"","sources":["../../../src/contracts/events-contracts.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Category\n */\nexport interface Category {\n  /** Primary category */\n  primaryCategory: string;\n  /** Sub category */\n  subCategory?: string;\n}\n\n/**\n * The event information\n */\nexport interface EventInfo {\n  /** Event key */\n  key?: string;\n  /** Event name */\n  eventName: string;\n  /** Page id */\n  pageId?: string;\n  /** Timestamp */\n  timeStamp?: string;\n  /** Product id */\n  productId?: string;\n  /** Component id */\n  componentId?: string;\n}\n\n/**\n * An event attribute\n */\nexport interface Attribute {\n  /** Attribute key */\n  key: string;\n  /** Attribute value */\n  value: string;\n  /** Attribute to defined if it is a sensitive data or not */\n  isSensitiveData?: boolean;\n}\n\n/**\n * The event context\n */\nexport interface EventContext {\n  /** Category */\n  category?: Category;\n  /** Event information */\n  eventInfo: EventInfo;\n  /** List of attribute */\n  attributes?: Attribute[];\n}\n\n/**\n * Generic analytics event\n */\nexport interface AnalyticsEvent extends EventContext {}\n\n/**\n * Generic model for the parameter of `ConstructorAnalyticsEvent`\n */\nexport interface ConstructorAnalyticsEventParameters {\n  [key: string]: any;\n}\n\n/**\n * Type for AnalyticsEvent classes\n */\nexport type ConstructorAnalyticsEvent<T extends AnalyticsEvent> = new (parameters?: ConstructorAnalyticsEventParameters) => T;\n\n/**\n * Dictionary of analytics events\n */\nexport interface AnalyticsEvents {\n  [key: string]: ConstructorAnalyticsEvent<AnalyticsEvent>;\n}\n\n/**\n * Trackable item\n */\nexport interface Trackable<T extends AnalyticsEvents> {\n  /**\n   * Analytics events\n   */\n  readonly analyticsEvents: T;\n}\n\n/** The UI event object which will be emitted by event tracker service */\nexport interface UiEventPayload {\n  /** The event which takes place in the DOM */\n  nativeEvent: Event;\n  /** The custom object with additional information about the event captured */\n  context: EventContext;\n}\n\n/** The custom event object which will be emitted by event tracker service */\nexport interface CustomEventPayload {\n  /** The custom object with additional information about the event captured */\n  context: EventContext;\n}\n\n/** The event name which has to be tracked */\nexport type TrackEventName = keyof GlobalEventHandlersEventMap;\n\n/**\n * Event timing marks\n * Those marks are meant to be used either as start and end of an event (e.g. a server call)\n * either as lower and upper bound for a specific mark (e.g. first paint)\n */\nexport interface EventTiming {\n  /** Timestamp of the start of an event or lower bound for a time mark */\n  startTime: number;\n  /** Timestamp of the end of an event or upper bound for a time mark */\n  endTime?: number;\n}\n\n/** Perceived events marks */\nexport interface PerceivedEvents {\n  /**\n   * Mark the time from the navigation start until the loading indicator triggers\n   * {@link https://developers.google.com/web/tools/lighthouse/audits/first-contentful-paint|FP}\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention -- naming convention imposed by Lighthouse\n  FP?: EventTiming;\n  /**\n   * Marks the time when the page appears to be meaningfully complete\n   * This is essentially the paint after which the biggest above-the-fold layout change has happened, and web fonts have loaded.\n   * {@link https://developers.google.com/web/tools/lighthouse/audits/first-meaningful-paint|FMP}\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention -- naming convention imposed by Lighthouse\n  FMP?: EventTiming;\n  /** Marks the time when the page considers it has all the data to become interactive  */\n  dataReady?: EventTiming;\n}\n\n/** Network metrics for a server call */\nexport interface ServerCallMetric {\n  /** Request url */\n  url: string;\n  /** Http request method */\n  httpMethod?: string;\n  /** Time taken for a server call; Start time when the call has fired and end time when the call has finished */\n  timing: EventTiming;\n  /** Custom error object added for a request; ex. An error object when the network is down */\n  error?: Error;\n  /** Status code of the response  */\n  httpStatus?: number;\n  /** Size of the response in bytes */\n  responseSize?: number;\n  /** If available, it identifies the call with the server logs (e.g. ama-request-id for DxAPI calls) */\n  requestId?: string;\n}\n\n/** Custom mark event added on a page */\nexport interface CustomEventMarks {\n  /** Name of the metric needed */\n  label: string;\n  /** Time range taken for the added mark */\n  timing: EventTiming;\n}\n\n/** Object structure for first load of the app */\nexport interface FirstLoadDataPayload {\n  /** Time between navigation is triggered and the connection is opened to the network in ms */\n  connection: number;\n  /** Time between the connection is opened to the network (connectEnd) and the first byte of response is received (responseStart) in ms */\n  request: number;\n  /** The duration while the response is received in ms; from the first byte from response received to the last one */\n  response: number;\n  /** DOM loading. Time between browser resources received and DOM rendered in ms */\n  // eslint-disable-next-line @typescript-eslint/naming-convention -- naming convention imposed by Lighthouse\n  DOM: number;\n  /** The total page load time in ms */\n  total: number;\n}\n\n/** The performance event object which will be emitted by event tracker service  for a page */\nexport interface PerfEventPayload {\n  /** The page name (route or page code or naming convention) where the performance events are tracked */\n  page: string;\n  /** Marks for perceived events */\n  perceived: PerceivedEvents;\n  /** Marks for the first load of the app  */\n  firstLoad?: FirstLoadDataPayload;\n  /** Server calls in the page, excluding the resources calls */\n  serverCalls: ServerCallMetric[];\n  /** Custom marks added to the page */\n  customMarks: CustomEventMarks[];\n}\n"]}

package/esm2022/contracts/index.mjs

@@ -0,0 +1,2 @@
+export * from './events-contracts';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY29udHJhY3RzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2V2ZW50cy1jb250cmFjdHMnO1xuIl19

package/esm2022/directives/index.mjs

@@ -0,0 +1,2 @@
+export * from './track-events/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvZGlyZWN0aXZlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHNCQUFzQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90cmFjay1ldmVudHMvaW5kZXgnO1xuIl19

package/esm2022/directives/track-events/base-track-events.mjs

@@ -0,0 +1,72 @@
+import { Directive, ElementRef, Renderer2, } from '@angular/core';
+import { takeUntilDestroyed, } from '@angular/core/rxjs-interop';
+import { EventTrackService, } from '../../services/event-track';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/event-track";
+export class BaseTrackEvents {
+    constructor(el, trackEventsService, renderer) {
+        this.el = el;
+        this.trackEventsService = trackEventsService;
+        this.renderer = renderer;
+        /**
+         * Store the functions returned by the angular renderer when an event listener is built
+         * The functions can be called to destroy the associated listeners
+         */
+        this.unlistenFns = [];
+        /** Array of track events objects */
+        this.trackingEvents = [];
+        /** Flag for the tracking mode */
+        this.isTrackingActive = false;
+        this.trackEventsService.uiTrackingActive$.pipe(takeUntilDestroyed()).subscribe((isActive) => {
+            this.isTrackingActive = isActive;
+            if (isActive) {
+                this.listen();
+            }
+            else {
+                this.unlisten();
+            }
+        });
+    }
+    /**
+     * Create the listener for the given event
+     * @param event name
+     */
+    nativeListen(event) {
+        // Renderer is used because it is manipulating the DOM and when the element is destroyed the event listener is destroyed too.
+        // Usage of an observable from event was not possible because the ngOnDestroy with the unsubscribe was called before the ui event was handled
+        return this.renderer.listen(this.el.nativeElement, event, (nativeEvent) => {
+            if (this.trackEventContextConstructor) {
+                this.trackEventsService.addUiEvent({ nativeEvent, context: new this.trackEventContextConstructor(this.trackEventContextConstructorParameters) });
+            }
+            else if (this.trackEventContext) {
+                this.trackEventsService.addUiEvent({ nativeEvent, context: this.trackEventContext });
+            }
+        });
+    }
+    /** Create the events listeners */
+    listen() {
+        this.unlisten();
+        this.unlistenFns = this.trackingEvents.map((event) => this.nativeListen(event));
+    }
+    /** Remove the created events listeners */
+    unlisten() {
+        this.unlistenFns.forEach((fn) => fn());
+        this.unlistenFns = [];
+    }
+    /**
+     * Keep the events to be listen and create the listener event for the given event name
+     * @param event name
+     */
+    trackEvent(event) {
+        this.trackingEvents.push(event);
+        if (this.isTrackingActive) {
+            this.unlistenFns.push(this.nativeListen(event));
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseTrackEvents, deps: [{ token: i0.ElementRef }, { token: i1.EventTrackService }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: BaseTrackEvents, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: BaseTrackEvents, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.EventTrackService }, { type: i0.Renderer2 }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/track-events/index.mjs

@@ -0,0 +1,5 @@
+export * from './track-click/track-click.directive';
+export * from './track-events.directive';
+export * from './track-events.module';
+export * from './track-focus/track-focus.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZGlyZWN0aXZlcy90cmFjay1ldmVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxxQ0FBcUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vdHJhY2stY2xpY2svdHJhY2stY2xpY2suZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vdHJhY2stZXZlbnRzLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3RyYWNrLWV2ZW50cy5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi90cmFjay1mb2N1cy90cmFjay1mb2N1cy5kaXJlY3RpdmUnO1xuIl19

package/esm2022/directives/track-events/track-click/track-click.directive.mjs

@@ -0,0 +1,42 @@
+import { Directive, ElementRef, Input, Renderer2, } from '@angular/core';
+import { EventTrackService, } from '../../../services/event-track/event-track.service';
+import { BaseTrackEvents, } from '../base-track-events';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/event-track/event-track.service";
+/**
+ * Directive to capture the 'click' event on the reference element.
+ * The captured event will be exposed via EventTrackService
+ * @example
+ * ```html
+ * <my-component
+ *    (click)="doSomething()"
+ *    trackClick
+ *    [trackEventContext]="{context: 'click on the component with tag: my-component'}">
+ * </my-component>
+ * ```
+ */
+export class TrackClickDirective extends BaseTrackEvents {
+    constructor(el, trackEventsService, renderer) {
+        super(el, trackEventsService, renderer);
+    }
+    ngOnInit() {
+        this.trackEvent('click');
+        this.trackEvent('contextmenu');
+        this.trackEvent('auxclick');
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrackClickDirective, deps: [{ token: i0.ElementRef }, { token: i1.EventTrackService }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TrackClickDirective, selector: "[trackClick]", inputs: { trackEventContext: "trackEventContext", trackEventContextConstructor: "trackEventContextConstructor", trackEventContextConstructorParameters: "trackEventContextConstructorParameters" }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrackClickDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[trackClick]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.EventTrackService }, { type: i0.Renderer2 }], propDecorators: { trackEventContext: [{
+                type: Input
+            }], trackEventContextConstructor: [{
+                type: Input
+            }], trackEventContextConstructorParameters: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/directives/track-events/track-events.directive.mjs

@@ -0,0 +1,49 @@
+import { Directive, ElementRef, Input, Renderer2, } from '@angular/core';
+import { EventTrackService, } from '../../services/event-track/event-track.service';
+import { BaseTrackEvents, } from './base-track-events';
+import * as i0 from "@angular/core";
+import * as i1 from "../../services/event-track/event-track.service";
+/**
+ * Directive to capture the events given as input, on the reference element.
+ * The captured event will be exposed via EventTrackService
+ * @example
+ * ```html
+ * <my-component
+ *    (click)="doSomething()"
+ *    [trackEvents]="['mouseenter', 'mouseleave']"
+ *    [trackEventContext]="{context: 'click on the component with tag: my-component'}">
+ * </my-component>
+ * ```
+ */
+export class TrackEventsDirective extends BaseTrackEvents {
+    constructor(el, trackEventsService, renderer) {
+        super(el, trackEventsService, renderer);
+        /** The list of events to listen */
+        this.trackEventNames = [];
+    }
+    ngOnChanges(changes) {
+        if ('trackEventNames' in changes) {
+            this.trackingEvents = [];
+            this.unlisten();
+            this.trackEventNames.forEach((eventName) => this.trackEvent(eventName));
+        }
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrackEventsDirective, deps: [{ token: i0.ElementRef }, { token: i1.EventTrackService }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TrackEventsDirective, selector: "[trackEvents]", inputs: { trackEventContext: "trackEventContext", trackEventContextConstructor: "trackEventContextConstructor", trackEventContextConstructorParameters: "trackEventContextConstructorParameters", trackEventNames: ["trackEvents", "trackEventNames"] }, usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrackEventsDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[trackEvents]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.EventTrackService }, { type: i0.Renderer2 }], propDecorators: { trackEventContext: [{
+                type: Input
+            }], trackEventContextConstructor: [{
+                type: Input
+            }], trackEventContextConstructorParameters: [{
+                type: Input
+            }], trackEventNames: [{
+                type: Input,
+                args: ['trackEvents']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhY2stZXZlbnRzLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmVzL3RyYWNrLWV2ZW50cy90cmFjay1ldmVudHMuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxTQUFTLEVBQ1QsVUFBVSxFQUNWLEtBQUssRUFFTCxTQUFTLEdBRVYsTUFBTSxlQUFlLENBQUM7QUFRdkIsT0FBTyxFQUNMLGlCQUFpQixHQUNsQixNQUFNLGdEQUFnRCxDQUFDO0FBQ3hELE9BQU8sRUFDTCxlQUFlLEdBQ2hCLE1BQU0scUJBQXFCLENBQUM7OztBQUU3Qjs7Ozs7Ozs7Ozs7R0FXRztBQUlILE1BQU0sT0FBTyxvQkFBcUIsU0FBUSxlQUFlO0lBbUJ2RCxZQUFZLEVBQWMsRUFBRSxrQkFBcUMsRUFBRSxRQUFtQjtRQUNwRixLQUFLLENBQUMsRUFBRSxFQUFFLGtCQUFrQixFQUFFLFFBQVEsQ0FBQyxDQUFDO1FBSjFDLG1DQUFtQztRQUNOLG9CQUFlLEdBQXFCLEVBQUUsQ0FBQztJQUlwRSxDQUFDO0lBRU0sV0FBVyxDQUFDLE9BQXNCO1FBQ3ZDLElBQUksaUJBQWlCLElBQUksT0FBTyxFQUFFLENBQUM7WUFDakMsSUFBSSxDQUFDLGNBQWMsR0FBRyxFQUFFLENBQUM7WUFDekIsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1lBQ2hCLElBQUksQ0FBQyxlQUFlLENBQUMsT0FBTyxDQUFDLENBQUMsU0FBUyxFQUFFLEVBQUUsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUM7UUFDMUUsQ0FBQztJQUNILENBQUM7a0lBN0JVLG9CQUFvQjtzSEFBcEIsb0JBQW9COzs0RkFBcEIsb0JBQW9CO2tCQUhoQyxTQUFTO21CQUFDO29CQUNULFFBQVEsRUFBRSxlQUFlO2lCQUMxQjt1SUFLaUIsaUJBQWlCO3NCQUFoQyxLQUFLO2dCQUtVLDRCQUE0QjtzQkFBM0MsS0FBSztnQkFLVSxzQ0FBc0M7c0JBQXJELEtBQUs7Z0JBR3VCLGVBQWU7c0JBQTNDLEtBQUs7dUJBQUMsYUFBYSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIERpcmVjdGl2ZSxcbiAgRWxlbWVudFJlZixcbiAgSW5wdXQsXG4gIE9uQ2hhbmdlcyxcbiAgUmVuZGVyZXIyLFxuICBTaW1wbGVDaGFuZ2VzLFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7XG4gIEFuYWx5dGljc0V2ZW50LFxuICBDb25zdHJ1Y3RvckFuYWx5dGljc0V2ZW50LFxuICBDb25zdHJ1Y3RvckFuYWx5dGljc0V2ZW50UGFyYW1ldGVycyxcbiAgRXZlbnRDb250ZXh0LFxuICBUcmFja0V2ZW50TmFtZSxcbn0gZnJvbSAnLi4vLi4vY29udHJhY3RzJztcbmltcG9ydCB7XG4gIEV2ZW50VHJhY2tTZXJ2aWNlLFxufSBmcm9tICcuLi8uLi9zZXJ2aWNlcy9ldmVudC10cmFjay9ldmVudC10cmFjay5zZXJ2aWNlJztcbmltcG9ydCB7XG4gIEJhc2VUcmFja0V2ZW50cyxcbn0gZnJvbSAnLi9iYXNlLXRyYWNrLWV2ZW50cyc7XG5cbi8qKlxuICogRGlyZWN0aXZlIHRvIGNhcHR1cmUgdGhlIGV2ZW50cyBnaXZlbiBhcyBpbnB1dCwgb24gdGhlIHJlZmVyZW5jZSBlbGVtZW50LlxuICogVGhlIGNhcHR1cmVkIGV2ZW50IHdpbGwgYmUgZXhwb3NlZCB2aWEgRXZlbnRUcmFja1NlcnZpY2VcbiAqIEBleGFtcGxlXG4gKiBgYGBodG1sXG4gKiA8bXktY29tcG9uZW50XG4gKiAgICAoY2xpY2spPVwiZG9Tb21ldGhpbmcoKVwiXG4gKiAgICBbdHJhY2tFdmVudHNdPVwiWydtb3VzZWVudGVyJywgJ21vdXNlbGVhdmUnXVwiXG4gKiAgICBbdHJhY2tFdmVudENvbnRleHRdPVwie2NvbnRleHQ6ICdjbGljayBvbiB0aGUgY29tcG9uZW50IHdpdGggdGFnOiBteS1jb21wb25lbnQnfVwiPlxuICogPC9teS1jb21wb25lbnQ+XG4gKiBgYGBcbiAqL1xuQERpcmVjdGl2ZSh7XG4gIHNlbGVjdG9yOiAnW3RyYWNrRXZlbnRzXSdcbn0pXG5leHBvcnQgY2xhc3MgVHJhY2tFdmVudHNEaXJlY3RpdmUgZXh0ZW5kcyBCYXNlVHJhY2tFdmVudHMgaW1wbGVtZW50cyBPbkNoYW5nZXMge1xuICAvKipcbiAgICogQGluaGVyaXRkb2NcbiAgICovXG4gIEBJbnB1dCgpIHB1YmxpYyB0cmFja0V2ZW50Q29udGV4dD86IEV2ZW50Q29udGV4dDtcblxuICAvKipcbiAgICogQGluaGVyaXRkb2NcbiAgICovXG4gIEBJbnB1dCgpIHB1YmxpYyB0cmFja0V2ZW50Q29udGV4dENvbnN0cnVjdG9yPzogQ29uc3RydWN0b3JBbmFseXRpY3NFdmVudDxBbmFseXRpY3NFdmVudD47XG5cbiAgLyoqXG4gICAqIEBpbmhlcml0ZG9jXG4gICAqL1xuICBASW5wdXQoKSBwdWJsaWMgdHJhY2tFdmVudENvbnRleHRDb25zdHJ1Y3RvclBhcmFtZXRlcnM/OiBDb25zdHJ1Y3RvckFuYWx5dGljc0V2ZW50UGFyYW1ldGVycztcblxuICAvKiogVGhlIGxpc3Qgb2YgZXZlbnRzIHRvIGxpc3RlbiAqL1xuICBASW5wdXQoJ3RyYWNrRXZlbnRzJykgcHVibGljIHRyYWNrRXZlbnROYW1lczogVHJhY2tFdmVudE5hbWVbXSA9IFtdO1xuXG4gIGNvbnN0cnVjdG9yKGVsOiBFbGVtZW50UmVmLCB0cmFja0V2ZW50c1NlcnZpY2U6IEV2ZW50VHJhY2tTZXJ2aWNlLCByZW5kZXJlcjogUmVuZGVyZXIyKSB7XG4gICAgc3VwZXIoZWwsIHRyYWNrRXZlbnRzU2VydmljZSwgcmVuZGVyZXIpO1xuICB9XG5cbiAgcHVibGljIG5nT25DaGFuZ2VzKGNoYW5nZXM6IFNpbXBsZUNoYW5nZXMpIHtcbiAgICBpZiAoJ3RyYWNrRXZlbnROYW1lcycgaW4gY2hhbmdlcykge1xuICAgICAgdGhpcy50cmFja2luZ0V2ZW50cyA9IFtdO1xuICAgICAgdGhpcy51bmxpc3RlbigpO1xuICAgICAgdGhpcy50cmFja0V2ZW50TmFtZXMuZm9yRWFjaCgoZXZlbnROYW1lKSA9PiB0aGlzLnRyYWNrRXZlbnQoZXZlbnROYW1lKSk7XG4gICAgfVxuICB9XG59XG4iXX0=

package/esm2022/directives/track-events/track-events.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule, } from '@angular/core';
+import { TrackClickDirective, } from './track-click/track-click.directive';
+import { TrackEventsDirective, } from './track-events.directive';
+import { TrackFocusDirective, } from './track-focus/track-focus.directive';
+import * as i0 from "@angular/core";
+export class TrackEventsModule {
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrackEventsModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: TrackEventsModule, declarations: [TrackEventsDirective, TrackClickDirective, TrackFocusDirective], exports: [TrackEventsDirective, TrackClickDirective, TrackFocusDirective] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrackEventsModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrackEventsModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [TrackEventsDirective, TrackClickDirective, TrackFocusDirective],
+                    exports: [TrackEventsDirective, TrackClickDirective, TrackFocusDirective]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhY2stZXZlbnRzLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9kaXJlY3RpdmVzL3RyYWNrLWV2ZW50cy90cmFjay1ldmVudHMubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxRQUFRLEdBQ1QsTUFBTSxlQUFlLENBQUM7QUFDdkIsT0FBTyxFQUNMLG1CQUFtQixHQUNwQixNQUFNLHFDQUFxQyxDQUFDO0FBQzdDLE9BQU8sRUFDTCxvQkFBb0IsR0FDckIsTUFBTSwwQkFBMEIsQ0FBQztBQUNsQyxPQUFPLEVBQ0wsbUJBQW1CLEdBQ3BCLE1BQU0scUNBQXFDLENBQUM7O0FBTTdDLE1BQU0sT0FBTyxpQkFBaUI7a0lBQWpCLGlCQUFpQjttSUFBakIsaUJBQWlCLGlCQUhiLG9CQUFvQixFQUFFLG1CQUFtQixFQUFFLG1CQUFtQixhQUNuRSxvQkFBb0IsRUFBRSxtQkFBbUIsRUFBRSxtQkFBbUI7bUlBRTdELGlCQUFpQjs7NEZBQWpCLGlCQUFpQjtrQkFKN0IsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxvQkFBb0IsRUFBRSxtQkFBbUIsRUFBRSxtQkFBbUIsQ0FBQztvQkFDOUUsT0FBTyxFQUFFLENBQUMsb0JBQW9CLEVBQUUsbUJBQW1CLEVBQUUsbUJBQW1CLENBQUM7aUJBQzFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgTmdNb2R1bGUsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHtcbiAgVHJhY2tDbGlja0RpcmVjdGl2ZSxcbn0gZnJvbSAnLi90cmFjay1jbGljay90cmFjay1jbGljay5kaXJlY3RpdmUnO1xuaW1wb3J0IHtcbiAgVHJhY2tFdmVudHNEaXJlY3RpdmUsXG59IGZyb20gJy4vdHJhY2stZXZlbnRzLmRpcmVjdGl2ZSc7XG5pbXBvcnQge1xuICBUcmFja0ZvY3VzRGlyZWN0aXZlLFxufSBmcm9tICcuL3RyYWNrLWZvY3VzL3RyYWNrLWZvY3VzLmRpcmVjdGl2ZSc7XG5cbkBOZ01vZHVsZSh7XG4gIGRlY2xhcmF0aW9uczogW1RyYWNrRXZlbnRzRGlyZWN0aXZlLCBUcmFja0NsaWNrRGlyZWN0aXZlLCBUcmFja0ZvY3VzRGlyZWN0aXZlXSxcbiAgZXhwb3J0czogW1RyYWNrRXZlbnRzRGlyZWN0aXZlLCBUcmFja0NsaWNrRGlyZWN0aXZlLCBUcmFja0ZvY3VzRGlyZWN0aXZlXVxufSlcbmV4cG9ydCBjbGFzcyBUcmFja0V2ZW50c01vZHVsZSB7fVxuIl19

package/esm2022/directives/track-events/track-focus/track-focus.directive.mjs

@@ -0,0 +1,39 @@
+import { Directive, ElementRef, Input, Renderer2, } from '@angular/core';
+import { EventTrackService, } from '../../../services/event-track/event-track.service';
+import { BaseTrackEvents, } from '../base-track-events';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../services/event-track/event-track.service";
+/**
+ * Directive to capture the 'focus' event on the reference element.
+ * The captured event will be exposed via EventTrackService
+ * @example
+ * ```html
+ * <my-component
+ *    trackFocus
+ *    [trackEventContext]="{context: 'focus on the component with tag: my-component'}">
+ * </my-component>
+ * ```
+ */
+export class TrackFocusDirective extends BaseTrackEvents {
+    constructor(el, trackEventsService, renderer) {
+        super(el, trackEventsService, renderer);
+    }
+    ngOnInit() {
+        this.trackEvent('focus');
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrackFocusDirective, deps: [{ token: i0.ElementRef }, { token: i1.EventTrackService }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
+    /** @nocollapse */ static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: TrackFocusDirective, selector: "[trackFocus]", inputs: { trackEventContext: "trackEventContext", trackEventContextConstructor: "trackEventContextConstructor", trackEventContextConstructorParameters: "trackEventContextConstructorParameters" }, usesInheritance: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: TrackFocusDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[trackFocus]'
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.EventTrackService }, { type: i0.Renderer2 }], propDecorators: { trackEventContext: [{
+                type: Input
+            }], trackEventContextConstructor: [{
+                type: Input
+            }], trackEventContextConstructorParameters: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/fixtures/jasmine/event-track.service.fixture.jasmine.mjs

@@ -0,0 +1,40 @@
+/**
+ * Fixture for the EventTrack Service
+ */
+export class EventTrackServiceFixture {
+    constructor() {
+        /** @inheritdoc */
+        this.markFirstLoad = jasmine.createSpy('markFirstLoad');
+        /** @inheritdoc */
+        this.markFP = jasmine.createSpy('markFP');
+        /** @inheritdoc */
+        this.markFMP = jasmine.createSpy('markFMP');
+        /** @inheritdoc */
+        this.markDataReady = jasmine.createSpy('markDataReady');
+        /** @inheritdoc */
+        this.addCustomMark = jasmine.createSpy('addCustomMark');
+        /** @inheritdoc */
+        this.addServerCallMark = jasmine.createSpy('addServerCallMark');
+        /** @inheritdoc */
+        this.addSDKServerCallMark = jasmine.createSpy('addSDKServerCallMark');
+        /** @inheritdoc */
+        this.startCustomMark = jasmine.createSpy('startCustomMark');
+        /** @inheritdoc */
+        this.endCustomMark = jasmine.createSpy('endCustomMark');
+        /** @inheritdoc */
+        this.getTiming = jasmine.createSpy('getTiming');
+        /** @inheritdoc */
+        this.addEvent = jasmine.createSpy('addEvent');
+        /** @inheritdoc */
+        this.addUiEvent = jasmine.createSpy('addUiEvent');
+        /** @inheritdoc */
+        this.toggleTracking = jasmine.createSpy('toggleTracking');
+        /** @inheritdoc */
+        this.toggleUiTracking = jasmine.createSpy('toggleUiTracking');
+        /** @inheritdoc */
+        this.togglePerfTracking = jasmine.createSpy('togglePerfTracking');
+        /** @inheritdoc */
+        this.addCustomEvent = jasmine.createSpy('addCustomEvent');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/fixtures/jasmine/index.mjs

@@ -0,0 +1,2 @@
+export * from './event-track.service.fixture.jasmine';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZml4dHVyZXMvamFzbWluZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ldmVudC10cmFjay5zZXJ2aWNlLmZpeHR1cmUuamFzbWluZSc7XG4iXX0=

package/esm2022/fixtures/jasmine/o3r-analytics-fixtures-jasmine.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibzNyLWFuYWx5dGljcy1maXh0dXJlcy1qYXNtaW5lLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2ZpeHR1cmVzL2phc21pbmUvbzNyLWFuYWx5dGljcy1maXh0dXJlcy1qYXNtaW5lLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/fixtures/jest/event-track.service.fixture.jest.mjs

@@ -0,0 +1,40 @@
+/**
+ * Fixture for the EventTrack Service
+ */
+export class EventTrackServiceFixture {
+    constructor() {
+        /** @inheritdoc */
+        this.markFirstLoad = jest.fn();
+        /** @inheritdoc */
+        this.markFP = jest.fn();
+        /** @inheritdoc */
+        this.markFMP = jest.fn();
+        /** @inheritdoc */
+        this.markDataReady = jest.fn();
+        /** @inheritdoc */
+        this.addCustomMark = jest.fn();
+        /** @inheritdoc */
+        this.addServerCallMark = jest.fn();
+        /** @inheritdoc */
+        this.addSDKServerCallMark = jest.fn();
+        /** @inheritdoc */
+        this.startCustomMark = jest.fn();
+        /** @inheritdoc */
+        this.endCustomMark = jest.fn();
+        /** @inheritdoc */
+        this.getTiming = jest.fn();
+        /** @inheritdoc */
+        this.addEvent = jest.fn();
+        /** @inheritdoc */
+        this.addUiEvent = jest.fn();
+        /** @inheritdoc */
+        this.toggleTracking = jest.fn();
+        /** @inheritdoc */
+        this.toggleUiTracking = jest.fn();
+        /** @inheritdoc */
+        this.togglePerfTracking = jest.fn();
+        /** @inheritdoc */
+        this.addCustomEvent = jest.fn();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/fixtures/jest/index.mjs

@@ -0,0 +1,2 @@
+export * from './event-track.service.fixture.jest';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZml4dHVyZXMvamVzdC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9DQUFvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ldmVudC10cmFjay5zZXJ2aWNlLmZpeHR1cmUuamVzdCc7XG4iXX0=

package/esm2022/fixtures/jest/o3r-analytics-fixtures-jest.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibzNyLWFuYWx5dGljcy1maXh0dXJlcy1qZXN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2ZpeHR1cmVzL2plc3QvbzNyLWFuYWx5dGljcy1maXh0dXJlcy1qZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxTQUFTLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuIl19

package/esm2022/o3r-analytics.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibzNyLWFuYWx5dGljcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9vM3ItYW5hbHl0aWNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/esm2022/public_api.mjs

@@ -0,0 +1,5 @@
+export * from './contracts/index';
+export * from './directives/index';
+export * from './services/index';
+export * from './stores/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9wdWJsaWNfYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsZ0JBQWdCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NvbnRyYWN0cy9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL2RpcmVjdGl2ZXMvaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcy9pbmRleCc7XG5leHBvcnQgKiBmcm9tICcuL3N0b3Jlcy9pbmRleCc7XG4iXX0=

package/esm2022/services/event-track/event-track.configuration.mjs

@@ -0,0 +1,14 @@
+import { InjectionToken, } from '@angular/core';
+/** Default configuration of tracking service */
+export const defaultEventTrackConfiguration = {
+    perfBufferSize: 10,
+    uiEventsBufferSize: 20,
+    useBrowserApiForFirstFP: false,
+    activate: {
+        uiTracking: true,
+        perfTracking: true
+    }
+};
+/** Tracking service configuration token used to override the default configuration */
+export const EVENT_TRACK_SERVICE_CONFIGURATION = new InjectionToken('EVENT TRACK');
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/services/event-track/event-track.service.mjs

@@ -0,0 +1,303 @@
+import { Inject, Injectable, NgZone, Optional, } from '@angular/core';
+import { NavigationEnd, Router, } from '@angular/router';
+import { BehaviorSubject, combineLatest, fromEvent, ReplaySubject, } from 'rxjs';
+import { delay, filter, skip, skipWhile, take, takeWhile, withLatestFrom, } from 'rxjs/operators';
+import { defaultEventTrackConfiguration, EVENT_TRACK_SERVICE_CONFIGURATION, } from './event-track.configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+/** The initial value of the performance measurements */
+export const performanceMarksInitialState = {
+    page: '',
+    perceived: {},
+    serverCalls: [],
+    customMarks: []
+};
+/**
+ * Service to expose the tracked events as streams. Also provide a way to activate/deactivate the tracking
+ */
+export class EventTrackService {
+    /** Performance payload object */
+    get performancePayload() {
+        return this._performancePayload;
+    }
+    /** Performance payload object */
+    set performancePayload(value) {
+        if (this.isPerfTrackingActive) {
+            this._performancePayload = { ...value, page: this.router.url }; // Saves the current page url
+            this.perfEventTrack.next(this._performancePayload);
+        }
+    }
+    constructor(router, zone, config) {
+        this.router = router;
+        this.zone = zone;
+        /** Boolean to indicate the first load of the application */
+        this.isFirstLoad = true;
+        this._performancePayload = performanceMarksInitialState;
+        const eventConfiguration = { ...defaultEventTrackConfiguration, ...config };
+        this.uiTrackingActivated = new BehaviorSubject(eventConfiguration.activate.uiTracking);
+        this.uiTrackingActive$ = this.uiTrackingActivated.asObservable();
+        this.uiEventTrack = new ReplaySubject(eventConfiguration.uiEventsBufferSize);
+        this.uiEventTrack$ = this.uiEventTrack.asObservable();
+        // Custom events
+        this.customEventTrack = new ReplaySubject();
+        this.customEventTrack$ = this.customEventTrack.asObservable();
+        this.perfTrackingActivated = new BehaviorSubject(eventConfiguration.activate.perfTracking);
+        this.perfTrackingActive$ = this.perfTrackingActivated.asObservable();
+        this.perfEventTrack = new ReplaySubject(eventConfiguration.perfBufferSize);
+        this.perfEventTrack$ = this.perfEventTrack.asObservable();
+        this.perfTrackingActive$.subscribe((activated) => this.isPerfTrackingActive = activated);
+        const routerNavigationEnd$ = this.router.events.pipe(filter((event) => event instanceof NavigationEnd));
+        const trackingNavigationEnd$ = routerNavigationEnd$.pipe(withLatestFrom(this.perfTrackingActive$));
+        // Handles first load navigation
+        combineLatest(trackingNavigationEnd$.pipe(take(1), filter(() => typeof window.performance.timing !== 'undefined'), takeWhile(([_event, active]) => active)), fromEvent(window, 'load').pipe(delay(0))).subscribe(async () => {
+            if (eventConfiguration.useBrowserApiForFirstFP) {
+                const browserEntries = window.performance.getEntriesByType && window.performance.getEntriesByType('paint');
+                const browserFP = browserEntries && browserEntries.find((entry) => entry.name === 'first-paint');
+                if (browserFP) {
+                    const endTime = Math.round(browserFP.startTime);
+                    this.addFPToPerfPayload({ startTime: 0, endTime });
+                }
+            }
+            else if (this.firstPaint) { // If there is a registered firstPaint value emit it
+                this.addFPToPerfPayload(await this.firstPaint);
+                this.firstPaint = undefined;
+            }
+            this.markFirstLoad();
+        });
+        // Handles later navigation
+        trackingNavigationEnd$.pipe(skip(1), skipWhile(([_event, active]) => !active)).subscribe(async () => {
+            this.isFirstLoad = false;
+            this.resetPerfMarks();
+            if (this.firstPaint) { // If there is a registered firstPaint value emit it
+                this.addFPToPerfPayload(await this.firstPaint);
+                this.firstPaint = undefined;
+            }
+        });
+    }
+    /**
+     * Create metrics object for the first load of the application
+     */
+    createFirstLoadData() {
+        const navigation = window.performance.timing;
+        return {
+            connection: Math.round(navigation.connectEnd - navigation.navigationStart),
+            request: Math.round(navigation.responseStart - navigation.connectEnd),
+            response: Math.round(navigation.responseEnd - navigation.responseStart),
+            DOM: Math.round(navigation.loadEventEnd - navigation.responseEnd),
+            total: Math.round(navigation.loadEventEnd - navigation.navigationStart)
+        };
+    }
+    /**
+     * Populate performance payload with FP object
+     * @param FP
+     */
+    addFPToPerfPayload(FP) {
+        const perfFirstPaint = {
+            ...this.performancePayload,
+            perceived: {
+                ...this.performancePayload.perceived,
+                FP
+            }
+        };
+        this.performancePayload = perfFirstPaint;
+    }
+    /**
+     * Reset all metrics to initial state; Add the pageName on top of it
+     */
+    resetPerfMarks() {
+        this.performancePayload = { ...performanceMarksInitialState };
+    }
+    /**
+     * Mark the first load metrics using the navigation API.
+     * This has to be called only once in a single page application, being meaningful only for the first load
+     * This mark is populated by default in this service when the NavigationEnd event of the router emits for the first time
+     */
+    markFirstLoad() {
+        const firstLoad = this.createFirstLoadData();
+        this.performancePayload = { ...this.performancePayload, firstLoad };
+    }
+    /**
+     * Mark the first paint value
+     * Store the first paint timing value to be emitted at Navigation End
+     * @param emit If true, sets the FP to the current page. Otherwise, wait for next NavigationEnd event to happen
+     */
+    async markFP(emit = false) {
+        this.firstPaint = this.getTiming();
+        if (emit) {
+            this.addFPToPerfPayload(await this.firstPaint);
+            this.firstPaint = undefined;
+        }
+    }
+    /**
+     * Mark the first meaningful paint value.
+     * @param markOnlyFirstLoad If false, marks the FMP for subsequent loads else only for the first load of the application
+     */
+    async markFMP(markOnlyFirstLoad = true) {
+        if (!markOnlyFirstLoad || (markOnlyFirstLoad && this.isFirstLoad)) {
+            const timing = await this.getTiming();
+            const perfFirstMeaningfulPaint = {
+                ...this.performancePayload,
+                perceived: {
+                    ...this.performancePayload.perceived,
+                    FMP: timing
+                }
+            };
+            this.performancePayload = perfFirstMeaningfulPaint;
+        }
+    }
+    /**
+     * Add data ready perceived event
+     * This probe marks the time when the page considers it has all the data to become interactive
+     */
+    async markDataReady() {
+        const timing = await this.getTiming();
+        const perfDataReady = {
+            ...this.performancePayload,
+            perceived: {
+                ...this.performancePayload.perceived,
+                dataReady: timing
+            }
+        };
+        this.performancePayload = perfDataReady;
+    }
+    /**
+     * Add a custom event and its measurements
+     * @param label The event name
+     */
+    async addCustomMark(label) {
+        const timing = await this.getTiming();
+        const customMark = { label, timing };
+        const perf = { ...this.performancePayload, customMarks: this.performancePayload.customMarks.concat(customMark) };
+        this.performancePayload = perf;
+    }
+    /**
+     * Add a server call object in the list of server calls metrics
+     * @param serverCall The object to add in the server calls metrics
+     */
+    addServerCallMark(serverCall) {
+        const perf = { ...this.performancePayload, serverCalls: this.performancePayload.serverCalls.concat(serverCall) };
+        this.performancePayload = perf;
+    }
+    /**
+     * Add a DxAPI SDK server call object, created by the SDK Probe plugin, in the list of server calls metrics.
+     * In order to have requestId for the DxAPI calls, your server has to expose 'ama-request-id' via Access-Control-Expose-Headers
+     * @param serverMark The mark object
+     */
+    async addSDKServerCallMark(serverMark) {
+        let serverCallMetric = {
+            url: serverMark.url,
+            httpMethod: serverMark.requestOptions.method,
+            httpStatus: serverMark.response && serverMark.response.status,
+            timing: { startTime: serverMark.startTime, endTime: serverMark.endTime },
+            error: serverMark.error
+        };
+        if (serverMark.response) {
+            const clonedResponse = serverMark.response.clone();
+            const amaRequestId = clonedResponse.headers.get('ama-request-id');
+            const blob = await clonedResponse.blob();
+            serverCallMetric = {
+                ...serverCallMetric,
+                responseSize: blob.size,
+                requestId: amaRequestId || undefined
+            };
+        }
+        this.addServerCallMark(serverCallMetric);
+    }
+    /**
+     * Add a custom event and mark the start time, and returns the element index
+     * @param label Event name
+     * @returns the element index if tracking is active. Otherwise, -1
+     */
+    startCustomMark(label) {
+        if (!this.isPerfTrackingActive) {
+            return -1;
+        }
+        const startTime = Math.round(window.performance.now());
+        const customMark = { label, timing: { startTime } };
+        const perf = { ...this.performancePayload, customMarks: this.performancePayload.customMarks.concat(customMark) };
+        this.performancePayload = perf;
+        return this.performancePayload.customMarks.length - 1;
+    }
+    /**
+     * End the event mark given in parameter;
+     * Returns false if the custom event is not found in the list of custom marks; true otherwise
+     * @param eventIndex Index of the custom event to be marked as ended
+     */
+    endCustomMark(eventIndex) {
+        if (!this.isPerfTrackingActive) {
+            return false;
+        }
+        let updated = false;
+        const perf = {
+            ...this.performancePayload,
+            customMarks: this.performancePayload.customMarks.map((eventObj, index) => {
+                if (index !== eventIndex) {
+                    return eventObj;
+                }
+                updated = true;
+                const endTime = Math.round(window.performance.now());
+                return { label: eventObj.label, timing: { ...eventObj.timing, endTime } };
+            })
+        };
+        this.performancePayload = perf;
+        return updated;
+    }
+    /**
+     * The goal of this method is to compute a time range duration between the moment you call the function (lower bound timestamp)
+     * and the end of the composite rendering (upper bound measurement - a time mark that occurs after the real composite)
+     * For the first load of the application, the start time is considered as the start of navigation to ensure a cumulative measure.
+     * It is using the 'NgZone' service to runOutsideAngular to prevent any change detection to occur, nor angular error handling, speeding up the measurement.
+     * Example {@link markFMP} is called in {@link ngAfterViewInit}, the end time will be computed once the render pipeline stage completed the changes triggered by the javascript
+     */
+    getTiming() {
+        const startTime = this.isFirstLoad ? 0 : Math.round(window.performance.now());
+        return new Promise((resolve) => {
+            this.zone.runOutsideAngular(() => {
+                setTimeout(() => {
+                    const endTime = Math.round(window.performance.now());
+                    resolve({ startTime, endTime });
+                }, 0);
+            });
+        });
+    }
+    /**
+     * Add an event to the stream of captured UI events
+     * @param uiEvent emitted event object
+     */
+    addUiEvent(uiEvent) {
+        this.uiEventTrack.next(uiEvent);
+    }
+    /**
+     * Add an event to the stream of captured custom events
+     * @param customEvent emitted event object
+     */
+    addCustomEvent(customEvent) {
+        this.customEventTrack.next(customEvent);
+    }
+    /**
+     * Activate/deactivate the tracking mode for UI events
+     * @param activate activation/deactivation boolean
+     */
+    toggleUiTracking(activate) {
+        this.uiTrackingActivated.next(activate);
+    }
+    /**
+     * Activate/deactivate the tracking mode for performance measurements
+     * @param activate activation/deactivation boolean
+     */
+    togglePerfTracking(activate) {
+        this.perfTrackingActivated.next(activate);
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventTrackService, deps: [{ token: i1.Router }, { token: i0.NgZone }, { token: EVENT_TRACK_SERVICE_CONFIGURATION, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    /** @nocollapse */ static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventTrackService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventTrackService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: i1.Router }, { type: i0.NgZone }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [EVENT_TRACK_SERVICE_CONFIGURATION]
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-track.service.js","sourceRoot":"","sources":["../../../../src/services/event-track/event-track.service.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable @typescript-eslint/naming-convention -- naming convention for DOM, FP, and FMP imposed by Lighthouse */\nimport type {\n  Mark,\n} from '@ama-sdk/core';\nimport {\n  Inject,\n  Injectable,\n  NgZone,\n  Optional,\n} from '@angular/core';\nimport {\n  NavigationEnd,\n  Router,\n} from '@angular/router';\nimport {\n  BehaviorSubject,\n  combineLatest,\n  fromEvent,\n  Observable,\n  ReplaySubject,\n} from 'rxjs';\nimport {\n  delay,\n  filter,\n  skip,\n  skipWhile,\n  take,\n  takeWhile,\n  withLatestFrom,\n} from 'rxjs/operators';\nimport {\n  CustomEventMarks,\n  CustomEventPayload,\n  EventTiming,\n  FirstLoadDataPayload,\n  PerfEventPayload,\n  ServerCallMetric,\n  UiEventPayload,\n} from '../../contracts';\nimport {\n  defaultEventTrackConfiguration,\n  EVENT_TRACK_SERVICE_CONFIGURATION,\n  EventTrackConfiguration,\n} from './event-track.configuration';\n\n/** The initial value of the performance measurements */\nexport const performanceMarksInitialState: Readonly<PerfEventPayload> = {\n  page: '',\n  perceived: {},\n  serverCalls: [],\n  customMarks: []\n} as const;\n\n/**\n * Service to expose the tracked events as streams. Also provide a way to activate/deactivate the tracking\n */\n@Injectable(\n  { providedIn: 'root' }\n)\nexport class EventTrackService {\n  private readonly uiEventTrack: ReplaySubject<UiEventPayload>;\n\n  private readonly customEventTrack: ReplaySubject<CustomEventPayload>;\n\n  private readonly perfEventTrack: ReplaySubject<PerfEventPayload>;\n\n  private readonly uiTrackingActivated: BehaviorSubject<boolean>;\n\n  private readonly perfTrackingActivated: BehaviorSubject<boolean>;\n\n  private firstPaint?: Promise<EventTiming>;\n\n  /** UI captured events as stream */\n  public uiEventTrack$: Observable<UiEventPayload>;\n\n  /** Custom captured events as stream */\n  public customEventTrack$: Observable<CustomEventPayload>;\n\n  /** Performance captured events as stream */\n  public perfEventTrack$: Observable<PerfEventPayload>;\n\n  /** Stream of booleans for the ui tracking mode active/inactive */\n  public uiTrackingActive$: Observable<boolean>;\n\n  /** Stream of booleans for the performance tracking mode active/inactive */\n  public perfTrackingActive$: Observable<boolean>;\n\n  /** True if the perf tracking is activated; false otherwise */\n  private isPerfTrackingActive!: boolean;\n\n  /** Boolean to indicate the first load of the application */\n  private isFirstLoad = true;\n\n  private _performancePayload: PerfEventPayload = performanceMarksInitialState;\n  /** Performance payload object */\n  private get performancePayload() {\n    return this._performancePayload;\n  }\n\n  /** Performance payload object */\n  private set performancePayload(value: PerfEventPayload) {\n    if (this.isPerfTrackingActive) {\n      this._performancePayload = { ...value, page: this.router.url }; // Saves the current page url\n      this.perfEventTrack.next(this._performancePayload);\n    }\n  }\n\n  constructor(private readonly router: Router, private readonly zone: NgZone, @Optional() @Inject(EVENT_TRACK_SERVICE_CONFIGURATION) config?: EventTrackConfiguration) {\n    const eventConfiguration = { ...defaultEventTrackConfiguration, ...config };\n    this.uiTrackingActivated = new BehaviorSubject<boolean>(eventConfiguration.activate.uiTracking);\n    this.uiTrackingActive$ = this.uiTrackingActivated.asObservable();\n    this.uiEventTrack = new ReplaySubject<UiEventPayload>(eventConfiguration.uiEventsBufferSize);\n    this.uiEventTrack$ = this.uiEventTrack.asObservable();\n\n    // Custom events\n    this.customEventTrack = new ReplaySubject<CustomEventPayload>();\n    this.customEventTrack$ = this.customEventTrack.asObservable();\n\n    this.perfTrackingActivated = new BehaviorSubject<boolean>(eventConfiguration.activate.perfTracking);\n    this.perfTrackingActive$ = this.perfTrackingActivated.asObservable();\n    this.perfEventTrack = new ReplaySubject<PerfEventPayload>(eventConfiguration.perfBufferSize);\n    this.perfEventTrack$ = this.perfEventTrack.asObservable();\n\n    this.perfTrackingActive$.subscribe((activated) => this.isPerfTrackingActive = activated);\n\n    const routerNavigationEnd$ = this.router.events.pipe(filter((event): event is NavigationEnd => event instanceof NavigationEnd));\n    const trackingNavigationEnd$ = routerNavigationEnd$.pipe(withLatestFrom(this.perfTrackingActive$));\n\n    // Handles first load navigation\n    combineLatest(\n      trackingNavigationEnd$.pipe(\n        take(1),\n        filter(() => typeof window.performance.timing !== 'undefined'),\n        takeWhile(([_event, active]) => active)\n      ),\n      fromEvent(window, 'load').pipe(delay(0))\n    ).subscribe(async () => {\n      if (eventConfiguration.useBrowserApiForFirstFP) {\n        const browserEntries = window.performance.getEntriesByType && window.performance.getEntriesByType('paint');\n        const browserFP = browserEntries && browserEntries.find((entry) => entry.name === 'first-paint');\n        if (browserFP) {\n          const endTime = Math.round(browserFP.startTime);\n          this.addFPToPerfPayload({ startTime: 0, endTime });\n        }\n      } else if (this.firstPaint) { // If there is a registered firstPaint value emit it\n        this.addFPToPerfPayload(await this.firstPaint);\n        this.firstPaint = undefined;\n      }\n      this.markFirstLoad();\n    });\n\n    // Handles later navigation\n    trackingNavigationEnd$.pipe(\n      skip(1),\n      skipWhile(([_event, active]) => !active)\n    ).subscribe(async () => {\n      this.isFirstLoad = false;\n      this.resetPerfMarks();\n      if (this.firstPaint) { // If there is a registered firstPaint value emit it\n        this.addFPToPerfPayload(await this.firstPaint);\n        this.firstPaint = undefined;\n      }\n    });\n  }\n\n  /**\n   * Create metrics object for the first load of the application\n   */\n  private createFirstLoadData(): FirstLoadDataPayload {\n    const navigation = window.performance.timing;\n    return {\n      connection: Math.round(navigation.connectEnd - navigation.navigationStart),\n      request: Math.round(navigation.responseStart - navigation.connectEnd),\n      response: Math.round(navigation.responseEnd - navigation.responseStart),\n      DOM: Math.round(navigation.loadEventEnd - navigation.responseEnd),\n      total: Math.round(navigation.loadEventEnd - navigation.navigationStart)\n    };\n  }\n\n  /**\n   * Populate performance payload with FP object\n   * @param FP\n   */\n  private addFPToPerfPayload(FP: EventTiming) {\n    const perfFirstPaint = {\n      ...this.performancePayload,\n      perceived: {\n        ...this.performancePayload.perceived,\n        FP\n      }\n    };\n    this.performancePayload = perfFirstPaint;\n  }\n\n  /**\n   * Reset all metrics to initial state; Add the pageName on top of it\n   */\n  public resetPerfMarks() {\n    this.performancePayload = { ...performanceMarksInitialState };\n  }\n\n  /**\n   * Mark the first load metrics using the navigation API.\n   * This has to be called only once in a single page application, being meaningful only for the first load\n   * This mark is populated by default in this service when the NavigationEnd event of the router emits for the first time\n   */\n  public markFirstLoad() {\n    const firstLoad = this.createFirstLoadData();\n    this.performancePayload = { ...this.performancePayload, firstLoad };\n  }\n\n  /**\n   * Mark the first paint value\n   * Store the first paint timing value to be emitted at Navigation End\n   * @param emit If true, sets the FP to the current page. Otherwise, wait for next NavigationEnd event to happen\n   */\n  public async markFP(emit = false) {\n    this.firstPaint = this.getTiming();\n    if (emit) {\n      this.addFPToPerfPayload(await this.firstPaint);\n      this.firstPaint = undefined;\n    }\n  }\n\n  /**\n   * Mark the first meaningful paint value.\n   * @param markOnlyFirstLoad If false, marks the FMP for subsequent loads else only for the first load of the application\n   */\n  public async markFMP(markOnlyFirstLoad = true) {\n    if (!markOnlyFirstLoad || (markOnlyFirstLoad && this.isFirstLoad)) {\n      const timing = await this.getTiming();\n      const perfFirstMeaningfulPaint = {\n        ...this.performancePayload,\n        perceived: {\n          ...this.performancePayload.perceived,\n          FMP: timing\n        }\n      };\n      this.performancePayload = perfFirstMeaningfulPaint;\n    }\n  }\n\n  /**\n   * Add data ready perceived event\n   * This probe marks the time when the page considers it has all the data to become interactive\n   */\n  public async markDataReady() {\n    const timing = await this.getTiming();\n    const perfDataReady = {\n      ...this.performancePayload,\n      perceived: {\n        ...this.performancePayload.perceived,\n        dataReady: timing\n      }\n    };\n    this.performancePayload = perfDataReady;\n  }\n\n  /**\n   * Add a custom event and its measurements\n   * @param label The event name\n   */\n  public async addCustomMark(label: string) {\n    const timing = await this.getTiming();\n    const customMark = { label, timing } as const satisfies CustomEventMarks;\n    const perf = { ...this.performancePayload, customMarks: this.performancePayload.customMarks.concat(customMark) };\n    this.performancePayload = perf;\n  }\n\n  /**\n   * Add a server call object in the list of server calls metrics\n   * @param serverCall The object to add in the server calls metrics\n   */\n  public addServerCallMark(serverCall: ServerCallMetric) {\n    const perf = { ...this.performancePayload, serverCalls: this.performancePayload.serverCalls.concat(serverCall) };\n    this.performancePayload = perf;\n  }\n\n  /**\n   * Add a DxAPI SDK server call object, created by the SDK Probe plugin, in the list of server calls metrics.\n   * In order to have requestId for the DxAPI calls, your server has to expose 'ama-request-id' via Access-Control-Expose-Headers\n   * @param serverMark The mark object\n   */\n  public async addSDKServerCallMark(serverMark: Mark) {\n    let serverCallMetric: ServerCallMetric = {\n      url: serverMark.url,\n      httpMethod: serverMark.requestOptions.method,\n      httpStatus: serverMark.response && serverMark.response.status,\n      timing: { startTime: serverMark.startTime, endTime: serverMark.endTime },\n      error: serverMark.error\n    };\n    if (serverMark.response) {\n      const clonedResponse = serverMark.response.clone();\n      const amaRequestId = clonedResponse.headers.get('ama-request-id');\n      const blob = await clonedResponse.blob();\n      serverCallMetric = {\n        ...serverCallMetric,\n        responseSize: blob.size,\n        requestId: amaRequestId || undefined\n      };\n    }\n    this.addServerCallMark(serverCallMetric);\n  }\n\n  /**\n   * Add a custom event and mark the start time, and returns the element index\n   * @param label Event name\n   * @returns the element index if tracking is active. Otherwise, -1\n   */\n  public startCustomMark(label: string) {\n    if (!this.isPerfTrackingActive) {\n      return -1;\n    }\n    const startTime = Math.round(window.performance.now());\n    const customMark = { label, timing: { startTime } } as const satisfies CustomEventMarks;\n    const perf = { ...this.performancePayload, customMarks: this.performancePayload.customMarks.concat(customMark) };\n    this.performancePayload = perf;\n    return this.performancePayload.customMarks.length - 1;\n  }\n\n  /**\n   * End the event mark given in parameter;\n   * Returns false if the custom event is not found in the list of custom marks; true otherwise\n   * @param eventIndex Index of the custom event to be marked as ended\n   */\n  public endCustomMark(eventIndex: number) {\n    if (!this.isPerfTrackingActive) {\n      return false;\n    }\n    let updated = false;\n    const perf = {\n      ...this.performancePayload,\n      customMarks: this.performancePayload.customMarks.map((eventObj, index) => {\n        if (index !== eventIndex) {\n          return eventObj;\n        }\n        updated = true;\n        const endTime = Math.round(window.performance.now());\n        return { label: eventObj.label, timing: { ...eventObj.timing, endTime } };\n      })\n    };\n    this.performancePayload = perf;\n    return updated;\n  }\n\n  /**\n   * The goal of this method is to compute a time range duration between the moment you call the function (lower bound timestamp)\n   * and the end of the composite rendering (upper bound measurement - a time mark that occurs after the real composite)\n   * For the first load of the application, the start time is considered as the start of navigation to ensure a cumulative measure.\n   * It is using the 'NgZone' service to runOutsideAngular to prevent any change detection to occur, nor angular error handling, speeding up the measurement.\n   * Example {@link markFMP} is called in {@link ngAfterViewInit}, the end time will be computed once the render pipeline stage completed the changes triggered by the javascript\n   */\n  public getTiming(): Promise<EventTiming> {\n    const startTime = this.isFirstLoad ? 0 : Math.round(window.performance.now());\n    return new Promise((resolve) => {\n      this.zone.runOutsideAngular(() => {\n        setTimeout(() => {\n          const endTime = Math.round(window.performance.now());\n          resolve({ startTime, endTime });\n        }, 0);\n      });\n    });\n  }\n\n  /**\n   * Add an event to the stream of captured UI events\n   * @param uiEvent emitted event object\n   */\n  public addUiEvent(uiEvent: UiEventPayload) {\n    this.uiEventTrack.next(uiEvent);\n  }\n\n  /**\n   * Add an event to the stream of captured custom events\n   * @param customEvent emitted event object\n   */\n  public addCustomEvent(customEvent: CustomEventPayload) {\n    this.customEventTrack.next(customEvent);\n  }\n\n  /**\n   * Activate/deactivate the tracking mode for UI events\n   * @param activate activation/deactivation boolean\n   */\n  public toggleUiTracking(activate: boolean) {\n    this.uiTrackingActivated.next(activate);\n  }\n\n  /**\n   * Activate/deactivate the tracking mode for performance measurements\n   * @param activate activation/deactivation boolean\n   */\n  public togglePerfTracking(activate: boolean) {\n    this.perfTrackingActivated.next(activate);\n  }\n}\n"]}

package/esm2022/services/event-track/index.mjs

@@ -0,0 +1,3 @@
+export * from './event-track.configuration';
+export * from './event-track.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc2VydmljZXMvZXZlbnQtdHJhY2svaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ldmVudC10cmFjay5jb25maWd1cmF0aW9uJztcbmV4cG9ydCAqIGZyb20gJy4vZXZlbnQtdHJhY2suc2VydmljZSc7XG4iXX0=

package/esm2022/services/index.mjs

@@ -0,0 +1,2 @@
+export * from './event-track/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc2VydmljZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZXZlbnQtdHJhY2svaW5kZXgnO1xuIl19

package/esm2022/stores/event-track/event-track.actions.mjs

@@ -0,0 +1,28 @@
+import { createAction, props, } from '@ngrx/store';
+/** StateActions */
+const ACTION_SET = '[EventTrack] set';
+const ACTION_UPDATE = '[EventTrack] update';
+const ACTION_REGISTER_HERO_COMPONENT = '[EventTrack] register hero component';
+const ACTION_SET_HERO_COMPONENT_TTI = '[EventTrack] set hero component TTI';
+const ACTION_RESET = '[EventTrack] reset';
+/**
+ * Clear the current store object and replace it with the new one
+ */
+export const setEventTrack = createAction(ACTION_SET, props());
+/**
+ * Change a part or the whole object in the store.
+ */
+export const updateEventTrack = createAction(ACTION_UPDATE, props());
+/**
+ * Clear the whole state, return to the initial one
+ */
+export const resetEventTrack = createAction(ACTION_RESET);
+/**
+ * Register hero component in the store
+ */
+export const registerHeroComponent = createAction(ACTION_REGISTER_HERO_COMPONENT, props());
+/**
+ * Set the TTI measure for a hero component in the store
+ */
+export const setHeroComponentTTI = createAction(ACTION_SET_HERO_COMPONENT_TTI, props());
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/stores/event-track/event-track.module.mjs

@@ -0,0 +1,39 @@
+import { InjectionToken, NgModule, } from '@angular/core';
+import { StoreModule, } from '@ngrx/store';
+import { eventTrackReducer, } from './event-track.reducer';
+import { EVENT_TRACK_STORE_NAME, } from './event-track.state';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngrx/store";
+/** Token of the EventTrack reducer */
+export const EVENT_TRACK_REDUCER_TOKEN = new InjectionToken('Feature EventTrack Reducer');
+/** Provide default reducer for EventTrack store */
+export function getDefaultEventTrackReducer() {
+    return eventTrackReducer;
+}
+export class EventTrackStoreModule {
+    static forRoot(reducerFactory) {
+        return {
+            ngModule: EventTrackStoreModule,
+            providers: [
+                { provide: EVENT_TRACK_REDUCER_TOKEN, useFactory: reducerFactory }
+            ]
+        };
+    }
+    /** @nocollapse */ static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventTrackStoreModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    /** @nocollapse */ static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: EventTrackStoreModule, imports: [i1.StoreFeatureModule] }); }
+    /** @nocollapse */ static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventTrackStoreModule, providers: [
+            { provide: EVENT_TRACK_REDUCER_TOKEN, useFactory: getDefaultEventTrackReducer }
+        ], imports: [StoreModule.forFeature(EVENT_TRACK_STORE_NAME, EVENT_TRACK_REDUCER_TOKEN)] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: EventTrackStoreModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        StoreModule.forFeature(EVENT_TRACK_STORE_NAME, EVENT_TRACK_REDUCER_TOKEN)
+                    ],
+                    providers: [
+                        { provide: EVENT_TRACK_REDUCER_TOKEN, useFactory: getDefaultEventTrackReducer }
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/stores/event-track/event-track.reducer.mjs

@@ -0,0 +1,101 @@
+import { createReducer, on, } from '@ngrx/store';
+import * as actions from './event-track.actions';
+/** The initial value of the Hero component */
+export const heroComponentInitialState = { id: '', TTI: 0, involvedApiEndpoints: [] };
+/**
+ * eventTrack initial state
+ */
+export const eventTrackInitialState = {
+    heroComponent: heroComponentInitialState,
+    isTTIComputed: false
+};
+/**
+ * Return all the involved API endpoints present in the component including its child & subchild
+ * Iterate recursively till the component with no children
+ * @param component
+ * @returns string[]
+ */
+function getComponentInvolvedEndPoints(component) {
+    return Array.from((component.children || []).reduce((accum, value) => {
+        getComponentInvolvedEndPoints(value).forEach((item) => accum.add(item));
+        return accum;
+    }, new Set(component.involvedApiEndpoints)));
+}
+/**
+ * Get all the involved API endpoints of the heroComponent with maximum TTI value
+ * If the parent contains max TTI, then all its child & subchild end points are used
+ * otherwise only component with max TTI end points are used
+ * @param component
+ * @param maxTTI
+ * @returns string[]
+ */
+function getInvolvedAPIEndpoints(component, maxTTI) {
+    if (component.componentTTI === maxTTI) {
+        return getComponentInvolvedEndPoints(component);
+    }
+    return Array.from((component.children || []).reduce((accum, value) => {
+        getInvolvedAPIEndpoints(value, maxTTI).forEach((endpoint) => accum.add(endpoint));
+        return accum;
+    }, new Set()));
+}
+/**
+ * Recursively iterate the page hierarchy
+ * and set the TTI for the specified component
+ * and compute the TTI for the corresponding parent
+ * @param component the parent component/page
+ * @param id the identifier of the component/page
+ * @param value the TTI value
+ * @param endpoints API URLs of the component
+ * @returns HeroComponent
+ */
+function computeTTI(component, id, value, endpoints = []) {
+    const computedComponent = { ...component };
+    if (computedComponent.id === id) {
+        computedComponent.TTI = value;
+        computedComponent.hasBeenLogged = true;
+        computedComponent.involvedApiEndpoints = endpoints;
+        computedComponent.componentTTI = value;
+    }
+    else if (computedComponent.children) {
+        computedComponent.children = computedComponent.children.map((child) => computeTTI(child, id, value, endpoints));
+    }
+    // Compute the TTI of the current component comparing the child TTI measures
+    if (computedComponent.children && computedComponent.children.length > 0) {
+        const maxChildTTI = Math.max(...computedComponent.children.map((child) => child.TTI));
+        computedComponent.TTI = Math.max(maxChildTTI, computedComponent.TTI);
+    }
+    return computedComponent;
+}
+/**
+ * Check if the TTI for the page is computed
+ * @param component the parent component/page
+ * @returns boolean
+ */
+function isTTIComputed(component) {
+    if (component.measureSelf && !component.hasBeenLogged) {
+        return false;
+    }
+    return component.children && component.children.length > 0 ? component.children.every((child) => isTTIComputed(child)) : component.TTI > 0;
+}
+/**
+ * List of basic actions for EventTrack
+ */
+export const eventTrackReducerFeatures = [
+    on(actions.setEventTrack, (_state, payload) => ({ ...payload.model })),
+    on(actions.updateEventTrack, (state, payload) => ({ ...state, ...payload.model })),
+    on(actions.resetEventTrack, () => eventTrackInitialState),
+    on(actions.registerHeroComponent, (state, payload) => ({ ...state, heroComponent: { ...payload.model, TTI: 0 } })),
+    on(actions.setHeroComponentTTI, (state, payload) => {
+        const updatedHeroComponent = computeTTI(state.heroComponent, payload.model.id, payload.model.TTI, payload.model.involvedApiEndpoints);
+        const isComputed = isTTIComputed(updatedHeroComponent);
+        if (isComputed) {
+            updatedHeroComponent.involvedApiEndpoints = getInvolvedAPIEndpoints(updatedHeroComponent, updatedHeroComponent.TTI) || [];
+        }
+        return { ...state, heroComponent: updatedHeroComponent, isTTIComputed: isComputed };
+    })
+];
+/**
+ * EventTrack Store default reducer
+ */
+export const eventTrackReducer = createReducer(eventTrackInitialState, ...eventTrackReducerFeatures);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-track.reducer.js","sourceRoot":"","sources":["../../../../src/stores/event-track/event-track.reducer.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ActionCreator,\n  createReducer,\n  on,\n  ReducerTypes,\n} from '@ngrx/store';\nimport * as actions from './event-track.actions';\nimport {\n  EventTrackState,\n  HeroComponent,\n} from './event-track.state';\n\n/** The initial value of the Hero component */\nexport const heroComponentInitialState: HeroComponent = { id: '', TTI: 0, involvedApiEndpoints: [] };\n\n/**\n * eventTrack initial state\n */\nexport const eventTrackInitialState: EventTrackState = {\n  heroComponent: heroComponentInitialState,\n  isTTIComputed: false\n};\n\n/**\n * Return all the involved API endpoints present in the component including its child & subchild\n * Iterate recursively till the component with no children\n * @param component\n * @returns string[]\n */\nfunction getComponentInvolvedEndPoints(component: HeroComponent): string[] {\n  return Array.from(\n    (component.children || []).reduce((accum, value) => {\n      getComponentInvolvedEndPoints(value).forEach((item) => accum.add(item));\n      return accum;\n    }, new Set<string>(component.involvedApiEndpoints))\n  );\n}\n\n/**\n * Get all the involved API endpoints of the heroComponent with maximum TTI value\n * If the parent contains max TTI, then all its child & subchild end points are used\n * otherwise only component with max TTI end points are used\n * @param component\n * @param maxTTI\n * @returns string[]\n */\nfunction getInvolvedAPIEndpoints(component: HeroComponent, maxTTI: number): string[] {\n  if (component.componentTTI === maxTTI) {\n    return getComponentInvolvedEndPoints(component);\n  }\n  return Array.from(\n    (component.children || []).reduce((accum, value) => {\n      getInvolvedAPIEndpoints(value, maxTTI).forEach((endpoint) => accum.add(endpoint));\n      return accum;\n    }, new Set<string>())\n  );\n}\n\n/**\n * Recursively iterate the page hierarchy\n * and set the TTI for the specified component\n * and compute the TTI for the corresponding parent\n * @param component the parent component/page\n * @param id the identifier of the component/page\n * @param value the TTI value\n * @param endpoints API URLs of the component\n * @returns HeroComponent\n */\nfunction computeTTI(component: HeroComponent, id: string, value: number, endpoints: string[] = []): HeroComponent {\n  const computedComponent = { ...component };\n  if (computedComponent.id === id) {\n    computedComponent.TTI = value;\n    computedComponent.hasBeenLogged = true;\n    computedComponent.involvedApiEndpoints = endpoints;\n    computedComponent.componentTTI = value;\n  } else if (computedComponent.children) {\n    computedComponent.children = computedComponent.children.map((child) => computeTTI(child, id, value, endpoints));\n  }\n  // Compute the TTI of the current component comparing the child TTI measures\n  if (computedComponent.children && computedComponent.children.length > 0) {\n    const maxChildTTI = Math.max(...computedComponent.children.map((child: HeroComponent) => child.TTI));\n    computedComponent.TTI = Math.max(maxChildTTI, computedComponent.TTI);\n  }\n  return computedComponent;\n}\n\n/**\n * Check if the TTI for the page is computed\n * @param component the parent component/page\n * @returns boolean\n */\nfunction isTTIComputed(component: HeroComponent): boolean {\n  if (component.measureSelf && !component.hasBeenLogged) {\n    return false;\n  }\n  return component.children && component.children.length > 0 ? component.children.every((child) => isTTIComputed(child)) : component.TTI > 0;\n}\n\n/**\n * List of basic actions for EventTrack\n */\nexport const eventTrackReducerFeatures: ReducerTypes<EventTrackState, ActionCreator[]>[] = [\n  on(actions.setEventTrack, (_state, payload) => ({ ...payload.model })),\n\n  on(actions.updateEventTrack, (state, payload) => ({ ...state, ...payload.model })),\n\n  on(actions.resetEventTrack, () => eventTrackInitialState),\n\n  on(actions.registerHeroComponent, (state, payload) => ({ ...state, heroComponent: { ...payload.model, TTI: 0 } })),\n\n  on(actions.setHeroComponentTTI, (state, payload) => {\n    const updatedHeroComponent = computeTTI(state.heroComponent, payload.model.id, payload.model.TTI, payload.model.involvedApiEndpoints);\n    const isComputed = isTTIComputed(updatedHeroComponent);\n    if (isComputed) {\n      updatedHeroComponent.involvedApiEndpoints = getInvolvedAPIEndpoints(updatedHeroComponent, updatedHeroComponent.TTI) || [];\n    }\n    return { ...state, heroComponent: updatedHeroComponent, isTTIComputed: isComputed };\n  })\n];\n\n/**\n * EventTrack Store default reducer\n */\nexport const eventTrackReducer = createReducer(\n  eventTrackInitialState,\n  ...eventTrackReducerFeatures\n);\n"]}

package/esm2022/stores/event-track/event-track.selectors.mjs

@@ -0,0 +1,7 @@
+import { createFeatureSelector, createSelector, } from '@ngrx/store';
+import { EVENT_TRACK_STORE_NAME, } from './event-track.state';
+/** Select EventTrack State */
+export const selectEventTrackState = createFeatureSelector(EVENT_TRACK_STORE_NAME);
+/** Select hero component status */
+export const selectHeroComponentStatus = createSelector(selectEventTrackState, (state) => (state.isTTIComputed ? state.heroComponent.TTI : undefined));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtdHJhY2suc2VsZWN0b3JzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL3N0b3Jlcy9ldmVudC10cmFjay9ldmVudC10cmFjay5zZWxlY3RvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLHFCQUFxQixFQUNyQixjQUFjLEdBQ2YsTUFBTSxhQUFhLENBQUM7QUFDckIsT0FBTyxFQUNMLHNCQUFzQixHQUV2QixNQUFNLHFCQUFxQixDQUFDO0FBRTdCLDhCQUE4QjtBQUM5QixNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBRyxxQkFBcUIsQ0FBa0Isc0JBQXNCLENBQUMsQ0FBQztBQUVwRyxtQ0FBbUM7QUFDbkMsTUFBTSxDQUFDLE1BQU0seUJBQXlCLEdBQUcsY0FBYyxDQUFDLHFCQUFxQixFQUFFLENBQUMsS0FBSyxFQUFzQixFQUFFLENBQUMsQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIGNyZWF0ZUZlYXR1cmVTZWxlY3RvcixcbiAgY3JlYXRlU2VsZWN0b3IsXG59IGZyb20gJ0BuZ3J4L3N0b3JlJztcbmltcG9ydCB7XG4gIEVWRU5UX1RSQUNLX1NUT1JFX05BTUUsXG4gIEV2ZW50VHJhY2tTdGF0ZSxcbn0gZnJvbSAnLi9ldmVudC10cmFjay5zdGF0ZSc7XG5cbi8qKiBTZWxlY3QgRXZlbnRUcmFjayBTdGF0ZSAqL1xuZXhwb3J0IGNvbnN0IHNlbGVjdEV2ZW50VHJhY2tTdGF0ZSA9IGNyZWF0ZUZlYXR1cmVTZWxlY3RvcjxFdmVudFRyYWNrU3RhdGU+KEVWRU5UX1RSQUNLX1NUT1JFX05BTUUpO1xuXG4vKiogU2VsZWN0IGhlcm8gY29tcG9uZW50IHN0YXR1cyAqL1xuZXhwb3J0IGNvbnN0IHNlbGVjdEhlcm9Db21wb25lbnRTdGF0dXMgPSBjcmVhdGVTZWxlY3RvcihzZWxlY3RFdmVudFRyYWNrU3RhdGUsIChzdGF0ZSk6IG51bWJlciB8IHVuZGVmaW5lZCA9PiAoc3RhdGUuaXNUVElDb21wdXRlZCA/IHN0YXRlLmhlcm9Db21wb25lbnQuVFRJIDogdW5kZWZpbmVkKSk7XG4iXX0=

package/esm2022/stores/event-track/event-track.state.mjs

@@ -0,0 +1,5 @@
+/**
+ * Name of the EventTrack Store
+ */
+export const EVENT_TRACK_STORE_NAME = 'eventTrack';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtdHJhY2suc3RhdGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc3RvcmVzL2V2ZW50LXRyYWNrL2V2ZW50LXRyYWNrLnN0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQTREQTs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLHNCQUFzQixHQUFHLFlBQVksQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogVGhlIGludGVyZmFjZSBmb3IgSGVybyBjb21wb25lbnQsIHdoaWNoIGRldGVybWluZXMgdGhlIFRpbWUgVG8gSW50ZXJhY3RpdmUgKFRUSSkgZm9yIGEgcGFnZVxuICogSXQgZm9sbG93cyBhIFRyZWUgZGF0YSBzdHJ1Y3R1cmUsIHdpdGggdGhlIHJvb3Qgbm9kZSBhcyB0aGUgUGFnZSBhbmQgdGhlIGhlcm8gY29tcG9uZW50cyBhc1xuICogaXRzIGNoaWxkcmVuLiBFYWNoIGNoaWxkIGNhbiBoYXZlIGl0cyBvd24gaGVybyBjb21wb25lbnRzLiBUaGUgVFRJIGZvciB0aGUgcGFnZVxuICogd291bGQgYmUgY29tcHV0ZWQgdXNpbmcgYSBib3R0b20tdXAgYXBwcm9hY2ggc3RhcnRpbmcgZnJvbSB0aGUgY2hpbGRyZW4gYXQgdGhlIGJvdHRvbSAobGVhZiBub2RlcykuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSGVyb0NvbXBvbmVudCBleHRlbmRzIFJlZ2lzdGVySGVyb0NvbXBvbmVudFBheWxvYWQge1xuICAvKiogVGhlIFRpbWUgVG8gSW50ZXJhY3RpdmUoVFRJKSBtZWFzdXJlIGZvciB0aGUgY29tcG9uZW50ICovXG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBAdHlwZXNjcmlwdC1lc2xpbnQvbmFtaW5nLWNvbnZlbnRpb24gLS0gbmFtaW5nIGNvbnZlbnRpb24gaW1wb3NlZCBieSBMaWdodGhvdXNlXG4gIFRUSTogbnVtYmVyO1xuXG4gIC8qKlxuICAgKiBCb29sZWFuIHRvIGluZGljYXRlIGlmIHRoZSBUVEkgZm9yIHRoZSBjb21wb25lbnRcbiAgICogaGFzIGJlZW4gZXhwbGljaXRseSBtZWFzdXJlZCBhbmQgbG9nZ2VkXG4gICAqL1xuICBoYXNCZWVuTG9nZ2VkPzogYm9vbGVhbjtcblxuICAvKipcbiAgICogTGlzdCBvZiBBUEkgZW5kcG9pbnRzIHVzZWQgaW4gdGhlIEhlcm8gY29tcG9uZW50IGFuZCBpdCdzIHN1YmNvbXBvbmVudHNcbiAgICogVGhlc2UgYXJlIHRoZSBBUEkncyBpbnZva2VkIHdoZW4gdGhlIFRUSSBpcyBtZWFzdXJlZFxuICAgKi9cbiAgaW52b2x2ZWRBcGlFbmRwb2ludHM/OiBzdHJpbmdbXTtcblxuICAvKipcbiAgICogQWN0dWFsIFRUSSBtZWFzdXJlIG9mIHRoZSBjb21wb25lbnQsXG4gICAqIGRvZXNuJ3QgY2hhbmdlIHVwb24gaXQncyBjaGlsZHJlbiBNYXggVFRJIHZhbHVlXG4gICAqL1xuICBjb21wb25lbnRUVEk/OiBudW1iZXI7XG59XG5cbi8qKiBUaGUgaW50ZXJmYWNlIGZvciB0aGUgcmVnaXN0ZXIgaGVybyBjb21wb25lbnQgcGF5bG9hZCwgd2hpY2ggaXMgdXNlZCB0byByZWdpc3RlciBhIGhlcm8gY29tcG9uZW50IGFuZCBpdHMgY2hpbGRyZW4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgUmVnaXN0ZXJIZXJvQ29tcG9uZW50UGF5bG9hZCB7XG4gIC8qKiBUaGUgaWRlbnRpZmllciBvZiB0aGUgaGVybyBjb21wb25lbnQgKi9cbiAgaWQ6IHN0cmluZztcbiAgLyoqXG4gICAqIEJvb2xlYW4gdG8gaW5kaWNhdGUgaWYgdGhlIFRUSSBjb21wdXRhdGlvbiBzaG91bGQgdGFrZSBpbnRvIGFjY291bnRcbiAgICogdGhlIFRUSSBvZiB0aGUgY29tcG9uZW50IGl0c2VsZiBpbiBhZGRpdGlvbiB0byB0aGF0IG9mIGl0cyBjaGlsZCBjb21wb25lbnRzXG4gICAqL1xuICBtZWFzdXJlU2VsZj86IGJvb2xlYW47XG4gIC8qKiBUaGUgaWRlbnRpZmllcnMgb2YgdGhlIGNoaWxkcmVuIGhlcm8gY29tcG9uZW50cyAqL1xuICBjaGlsZHJlbj86IEhlcm9Db21wb25lbnRbXTtcbn1cblxuLyoqXG4gKiBFdmVudFRyYWNrIHN0b3JlIHN0YXRlXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgRXZlbnRUcmFja1N0YXRlIHtcbiAgLyoqIFRoZSBoZXJvIGNvbXBvbmVudCBmb3IgY29tcHV0aW5nIFRUSSAqL1xuICBoZXJvQ29tcG9uZW50OiBIZXJvQ29tcG9uZW50O1xuXG4gIC8qKlxuICAgKiBCb29sZWFuIHRvIGluZGljYXRlIHRoZSBjb21wbGV0aW9uIG9mIFRUSSBjb21wdXRhdGlvblxuICAgKiBUVEkgZm9yIGEgaGVybyBjb21wb25lbnQgaXMgY29uc2lkZXJlZCB0byBiZSBjb21wdXRlZFxuICAgKiBvbmx5IHdoZW4gdGhlIFRUSSBvZiBhbGwgaXRzIGNoaWxkcmVuIGhhdmUgYmVlbiBjb21wdXRlZFxuICAgKiBlZzogZm9yIGEgY29tcG9uZW50IEEgaGF2aW5nIEIgYW5kIEMgYXMgY2hpbGRyZW4sIHRoaXMgdmFsdWVcbiAgICogaXMgc2V0IG9ubHkgd2hlbiBUVEkgZm9yIGFsbCBBLCBCIGFuZCBDIGhhdmUgYmVlbiBzZXRcbiAgICovXG4gIGlzVFRJQ29tcHV0ZWQ6IGJvb2xlYW47XG59XG5cbi8qKlxuICogTmFtZSBvZiB0aGUgRXZlbnRUcmFjayBTdG9yZVxuICovXG5leHBvcnQgY29uc3QgRVZFTlRfVFJBQ0tfU1RPUkVfTkFNRSA9ICdldmVudFRyYWNrJztcblxuLyoqXG4gKiBFdmVudFRyYWNrIFN0b3JlIEludGVyZmFjZVxuICovXG5leHBvcnQgaW50ZXJmYWNlIEV2ZW50VHJhY2tTdG9yZSB7XG4gIC8qKiBFdmVudFRyYWNrIHN0YXRlICovXG4gIFtFVkVOVF9UUkFDS19TVE9SRV9OQU1FXTogRXZlbnRUcmFja1N0YXRlO1xufVxuIl19

package/esm2022/stores/event-track/event-track.sync.mjs

@@ -0,0 +1,7 @@
+import { eventTrackInitialState, } from './event-track.reducer';
+export const eventTrackStorageSync = {
+    deserialize: (rawObject) => {
+        return rawObject ? rawObject : eventTrackInitialState;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXZlbnQtdHJhY2suc3luYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9zdG9yZXMvZXZlbnQtdHJhY2svZXZlbnQtdHJhY2suc3luYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSxPQUFPLEVBQ0wsc0JBQXNCLEdBQ3ZCLE1BQU0sdUJBQXVCLENBQUM7QUFLL0IsTUFBTSxDQUFDLE1BQU0scUJBQXFCLEdBQTBDO0lBQzFFLFdBQVcsRUFBRSxDQUFDLFNBQWMsRUFBRSxFQUFFO1FBQzlCLE9BQU8sU0FBUyxDQUFDLENBQUMsQ0FBQyxTQUE0QixDQUFDLENBQUMsQ0FBQyxzQkFBc0IsQ0FBQztJQUMzRSxDQUFDO0NBQ08sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHtcbiAgU2VyaWFsaXplcixcbn0gZnJvbSAnQG8zci9jb3JlJztcbmltcG9ydCB7XG4gIGV2ZW50VHJhY2tJbml0aWFsU3RhdGUsXG59IGZyb20gJy4vZXZlbnQtdHJhY2sucmVkdWNlcic7XG5pbXBvcnQge1xuICBFdmVudFRyYWNrU3RhdGUsXG59IGZyb20gJy4vZXZlbnQtdHJhY2suc3RhdGUnO1xuXG5leHBvcnQgY29uc3QgZXZlbnRUcmFja1N0b3JhZ2VTeW5jOiBSZWFkb25seTxTZXJpYWxpemVyPEV2ZW50VHJhY2tTdGF0ZT4+ID0ge1xuICBkZXNlcmlhbGl6ZTogKHJhd09iamVjdDogYW55KSA9PiB7XG4gICAgcmV0dXJuIHJhd09iamVjdCA/IHJhd09iamVjdCBhcyBFdmVudFRyYWNrU3RhdGUgOiBldmVudFRyYWNrSW5pdGlhbFN0YXRlO1xuICB9XG59IGFzIGNvbnN0O1xuIl19

package/esm2022/stores/event-track/index.mjs

@@ -0,0 +1,7 @@
+export * from './event-track.actions';
+export * from './event-track.module';
+export * from './event-track.reducer';
+export * from './event-track.selectors';
+export * from './event-track.state';
+export * from './event-track.sync';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvc3RvcmVzL2V2ZW50LXRyYWNrL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9ldmVudC10cmFjay5hY3Rpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vZXZlbnQtdHJhY2subW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vZXZlbnQtdHJhY2sucmVkdWNlcic7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50LXRyYWNrLnNlbGVjdG9ycyc7XG5leHBvcnQgKiBmcm9tICcuL2V2ZW50LXRyYWNrLnN0YXRlJztcbmV4cG9ydCAqIGZyb20gJy4vZXZlbnQtdHJhY2suc3luYyc7XG4iXX0=

package/esm2022/stores/index.mjs

@@ -0,0 +1,2 @@
+export * from './event-track/index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RvcmVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2V2ZW50LXRyYWNrL2luZGV4JztcbiJdfQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o3r/analytics",
-  "version": "12.1.0-prerelease.79",
+  "version": "12.1.0-prerelease.80",
   "publishConfig": {
     "access": "public"
   },
@@ -11,7 +11,7 @@
     "otter-module"
   ],
   "peerDependencies": {
-    "@ama-sdk/core": "^12.1.0-prerelease.79",
+    "@ama-sdk/core": "^12.1.0-prerelease.80",
     "@angular-devkit/schematics": "^19.0.0",
     "@angular/common": "^19.0.0",
     "@angular/core": "^19.0.0",
@@ -19,8 +19,8 @@
     "@angular/platform-browser-dynamic": "^19.0.0",
     "@angular/router": "^19.0.0",
     "@ngrx/store": "^19.0.0",
-    "@o3r/core": "^12.1.0-prerelease.79",
-    "@o3r/schematics": "^12.1.0-prerelease.79",
+    "@o3r/core": "^12.1.0-prerelease.80",
+    "@o3r/schematics": "^12.1.0-prerelease.80",
     "@schematics/angular": "^19.0.0",
     "jasmine": "^5.0.0",
     "rxjs": "^7.8.1",
@@ -63,13 +63,13 @@
       "types": "./index.d.ts",
       "default": "./fesm2022/o3r-analytics.mjs"
     },
-    "./fixtures/jest": {
-      "types": "./fixtures/jest/index.d.ts",
-      "default": "./fesm2022/o3r-analytics-fixtures-jest.mjs"
-    },
     "./fixtures/jasmine": {
       "types": "./fixtures/jasmine/index.d.ts",
       "default": "./fesm2022/o3r-analytics-fixtures-jasmine.mjs"
+    },
+    "./fixtures/jest": {
+      "types": "./fixtures/jest/index.d.ts",
+      "default": "./fesm2022/o3r-analytics-fixtures-jest.mjs"
     }
   },
   "engines": {

package/schematics/analytics-to-component/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../schematics/analytics-to-component/index.ts"],"names":[],"mappings":"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"}

package/schematics/analytics-to-component/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../schematics/analytics-to-component/schema.ts"],"names":[],"mappings":""}

package/schematics/ng-add/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../schematics/ng-add/index.ts"],"names":[],"mappings":";;;AAAA,kCAAkC;AAQlC,MAAM,eAAe,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,CAAC,CAAC;AAE5E,MAAM,0BAA0B,GAAG,CAAC,MAA2C,EAAE,EAAE,CAAC,CAAC,MAAW,EAAE,EAAE;IAClG,MAAM,CAAC,KAAK,CAAC;;8CAE+B,CAAC,CAAC;IAC9C,MAAM,MAAM,CAAC;AACf,CAAC,CAAC;AAEF;;;GAGG;AACH,SAAS,OAAO,CAAC,OAA8B;IAC7C,kBAAkB;IAClB,OAAO,KAAK,EAAE,IAAI,EAAE,EAAE;QACpB,MAAM,EAAE,uBAAuB,EAAE,iBAAiB,EAAE,GAAG,2CAAa,iBAAiB,EAAC,CAAC;QACvF,OAAO,iBAAiB,CAAC;YACvB,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,YAAY,EAAE,uBAAuB,CAAC,eAAe,EAAE,IAAI,EAAE,OAAO,CAAC,WAAW,EAAE,KAAK,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAAC;SACpH,CAAC,CAAC;IACL,CAAC,CAAC;AACJ,CAAC;AAEM,MAAM,KAAK,GAAG,CAAC,OAA8B,EAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE;IACrF,MAAM,EACJ,oBAAoB,EACrB,GAAG,MAAM,qCAAO,iBAAiB,GAAE,KAAK,CAAC,0BAA0B,CAAC,MAAM,CAAC,CAAC,CAAC;IAC9E,OAAO,oBAAoB,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC;AAChD,CAAC,CAAC;AALW,QAAA,KAAK,SAKhB"}

package/schematics/ng-add/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../schematics/ng-add/schema.ts"],"names":[],"mappings":""}