@glomex/integration-analytics 1.1480.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2025 glomex GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+# @glomex/integration-analytics
+
+A unified analytics integration package for the [turbo player](https://www.npmjs.com/package/@glomex/integration-web-component). This package provides adapters for various analytics providers including NPAW/Youbora, with planned support for Nielsen, Comscore, and more.
+
+## Installation
+
+```bash
+npm install @glomex/integration-analytics
+```
+
+## Available Adapters
+
+### NPAW/Youbora
+
+[NPAW analytics](https://npaw.com/) integration for video analytics and quality of experience monitoring.
+
+```typescript
+import { connectToNpaw } from '@glomex/integration-analytics/npaw';
+
+// Get your integration element
+const integration = document.querySelector('glomex-integration');
+
+// Simple setup for NPAW analytics (that also handles consent)
+const { npawPlugin, destroy } = connectToNpaw(integration, 'your-npaw-account-code');
+```
+
+#### Advanced NPAW Configuration
+
+```typescript
+import { connectToNpaw } from '@glomex/integration-analytics/npaw';
+
+const { npawPlugin, destroy } = connectToNpaw(integration, 'your-npaw-account-code', {
+  appName: 'my-app',
+  appVersion: '1.0.0'
+});
+
+npawPlugin.setAnalyticsOptions({
+  userId: 'my-user-id',
+  'content.customDimensions': {
+    tenant: 'my-tenant'
+  }
+});
+
+// Clean up when done
+destroy();
+```
+
+#### Direct NPAW Integration
+
+```typescript
+import { NpawTurboPlayerAdapter } from '@glomex/integration-analytics/npaw';
+import NpawPlugin from 'npaw-plugin';
+
+const npawPlugin = new NpawPlugin('your-npaw-account-code');
+npawPlugin.registerAdapterFromClass(integration, NpawTurboPlayerAdapter);
+```
+
+## Planned Adapters
+
+The following adapters are planned for future releases:
+
+- [Nielsen](https://www.nielsen.com/solutions/audience-measurement/streaming-measurement/) - `@glomex/integration-analytics/nielsen`
+- [Comscore](https://www.comscore.com/) - `@glomex/integration-analytics/comscore`
+- [GfK Sensic](https://sensic.net/) - `@glomex/integration-analytics/sensic`
+- [Datazoom](https://www.datazoom.io/) - `@glomex/integration-analytics/datazoom`
+
+## Features
+
+- 🎯 **Easy Integration**: Simple setup with turbo player
+- 📊 **Multiple Providers**: Support for various analytics providers
+- 🔧 **Smart Metadata Mapping**: Automatically maps player content metadata to each analytics provider's format, with full support for custom overrides
+- 📱 **Cross-Platform**: Works with web, mobile web, and embedded players
+- 🔒 **Consent Handling**: Built-in consent management support
+
+## License
+
+MIT
+
+## Support
+
+For issues and questions, please visit the [glomex documentation](https://docs.glomex.com) or contact support.

package/dist/npaw/index.d.ts

@@ -0,0 +1,315 @@
+import { IntegrationElement, IntegrationElementEventMap } from '@glomex/integration-web-component';
+import NpawPlugin from 'npaw-plugin';
+
+/**
+ * Interfaces gathered from the npm module npaw-plugin by generating source from the contained sourcemap.
+ *
+ * @see https://www.npmjs.com/package/npaw-plugin
+ */
+interface Adapter {
+    flags: AdapterFlags;
+    monitor: PlayheadMonitor | null;
+    player: unknown;
+    plugin: {
+        getAdsAdapter(): AdapterAd;
+        setAdsAdapter(adapterClass: unknown, videoKey: string): void;
+        removeAdsAdapter(videoKey?: string): void;
+    };
+    getVideo(): {
+        getVideoKey(): string;
+        removeAdsAdapter(videoKey?: string): void;
+        options: Record<string, unknown>;
+    };
+    getNpawUtils(): {
+        calculateAdViewability(player: HTMLElement): boolean;
+        buildRenditionString(width: number, height: number, bitrate: number): string;
+    };
+    getNpawReference(): {
+        Constants: {
+            AdPosition: {
+                Preroll: string;
+                Midroll: string;
+                Postroll: string;
+            };
+        };
+    };
+    setPlayer(player: unknown): void;
+    registerListeners(): void;
+    unregisterListeners(): void;
+    monitorPlayhead(monitorBuffers: boolean, monitorSeeks: boolean, interval?: number): void;
+    stopMonitor(): void;
+    monitorReadyState(intervalMilliseconds?: number): void;
+    startReadyStateMonitor(): void;
+    stopReadyStateMonitor(): void;
+    checkReadyState(readyState: number | null | undefined, triggeredEvent?: string): void;
+    getPlugin(): unknown;
+    getLog(): unknown;
+    isStarted(): boolean;
+    getAdapterClass(className: string): unknown;
+    getAdapterName(adapterObject?: unknown): string;
+    getAdapterNameFromClass(adapterClass?: unknown): string;
+    getAdapterClasses(): Record<string, unknown>;
+    getPlayhead(): number | null;
+    getDuration(): number | null;
+    getBitrate(): number | null;
+    getTotalBytes(): number | null;
+    getTitle(): string | null;
+    getResource(): string | null;
+    getPlayerVersion(): string | null;
+    getPlayerName(): string | null;
+    getVersion(): string;
+    getVideoObject(): unknown | null;
+    getLastUsedCdn(): string | undefined;
+    checkExistsPlayer(): boolean;
+    checkExistsObjectOnPage(object: unknown): boolean;
+    fireInit(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireStart(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireJoin(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    firePause(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireResume(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireBufferBegin(params?: Record<string, unknown>, convertFromSeek?: boolean, triggeredEvent?: string, triggeredByStateProperty?: boolean): void;
+    fireBufferEnd(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    cancelBuffer(params?: Record<string, unknown>): void;
+    fireStop(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    firePlayerLog(playerEvent: string, playerData: unknown): void;
+    setIsAds(value: boolean): void;
+    fireCasted(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    fireError(code?: string | number | Record<string, unknown>, msg?: string, metadata?: Record<string, unknown>, level?: string, triggeredEvent?: string, fatalError?: boolean, duration?: number): void;
+    fireFatalError(code?: string | number | Record<string, unknown>, msg?: string, metadata?: Record<string, unknown>, level?: string, triggeredEvent?: string, duration?: number): void;
+    isLegacyBufferBehaviourEnabled(): boolean;
+}
+interface AdapterContent extends Adapter {
+    getPlayrate(): number;
+    getFramesPerSecond(): number | undefined;
+    getDroppedFrames(): number | undefined;
+    getThroughput(): number | undefined;
+    getRendition(): unknown | undefined;
+    getTitle2(): string | undefined;
+    getIsLive(): boolean | undefined;
+    getCdnTraffic(): number | undefined;
+    getP2PTraffic(): number | undefined;
+    getUploadTraffic(): number | undefined;
+    getIsP2PEnabled(): boolean | undefined;
+    getSegmentDuration(): number | undefined;
+    getHouseholdId(): string | undefined;
+    getLatency(): number | undefined;
+    getPacketLoss(): number | undefined;
+    getPacketSent(): number | undefined;
+    getMetrics(): Record<string, unknown> | undefined;
+    getAudioCodec(): string | undefined;
+    getVideoCodec(): string | undefined;
+    setUrlToParse(url: string): void;
+    getURLToParse(): string | undefined;
+    fireSeekBegin(params?: Record<string, unknown>, convertFromBuffer?: boolean, triggeredEvent?: string): void;
+    fireSeekEnd(params?: Record<string, unknown>, triggeredEvent?: string): void;
+    cancelSeek(params?: Record<string, unknown>): void;
+    fireEvent(eventName: string, dimensions?: Record<string, unknown>, values?: Record<string, unknown>, topLevelDimensions?: Record<string, unknown>, hasEndDatetime?: boolean): void;
+    fireEventEnd(eventName: string): void;
+    storeNewRendition(rendition: unknown): void;
+}
+type AdPosition = string | number | null;
+interface AdBreaksCount {
+    pre?: number;
+    mid?: number;
+    post?: number;
+}
+/**
+ * Structure of ads requested. This is intentionally generic because the source
+ * only states "structure of ads requested" without a concrete schema.
+ */
+type AdPattern = unknown;
+type AdInsertionType = string | null;
+interface AdapterAd extends AdapterContent {
+    /** Current ad position */
+    getPosition(): AdPosition;
+    /** Given ad structure (number of pre/mid/post breaks) */
+    getGivenBreaks(): AdBreaksCount | null;
+    /** Expected ad structure (number of pre/mid/post breaks) */
+    getExpectedBreaks(): AdBreaksCount | null;
+    /** Structure of ads requested */
+    getExpectedPattern(): AdPattern | null;
+    /** Playheads (in seconds or ms, depending on implementation) of ad break start times */
+    getBreaksTime(): number[] | null;
+    /** Number of ads given for the current break */
+    getGivenAds(): number | null;
+    /** Number of ads requested for the current break */
+    getExpectedAds(): number | null;
+    /**
+     * Whether the ad is visible on screen (standard: >50% pixels visible)
+     * Defaults to true in the base mixin.
+     */
+    getIsVisible(): boolean;
+    /** Whether audio is enabled when the ad begins */
+    getAudioEnabled(): boolean | null;
+    /** Whether the ad is skippable */
+    getIsSkippable(): boolean | null;
+    /** Whether the player is fullscreen when the ad begins */
+    getIsFullscreen(): boolean | null;
+    /** Ad campaign identifier/name */
+    getCampaign(): string | null;
+    /** Ad creative ID */
+    getCreativeId(): string | null;
+    /** Ad provider name */
+    getProvider(): string | null;
+    /** Ad insertion type (client-side/server-side) */
+    getAdInsertionType(): AdInsertionType;
+    /**
+     * Fire a click event.
+     * If a string is passed, it is treated as the URL: params = { url: string }.
+     */
+    fireClick(params?: Record<string, unknown> | string): void;
+    /**
+     * Fire a quartile event (0..3). Increments `lastQuartileSent` internally.
+     */
+    fireQuartile(quartile: number): void;
+    /** Start visibility/view tracking chrono for ads */
+    startChronoView(): void;
+    /** Stop visibility/view tracking chrono for ads */
+    stopChronoView(): void;
+    /**
+     * Fire a manifest-related event. If first arg is string, it is treated as errorType
+     * and `message` is used as errorMessage.
+     */
+    fireManifest(params?: Record<string, unknown> | string, message?: string): void;
+    /**
+     * Mark ad as skipped and fire stop with params.skipped = true
+     */
+    fireSkip(params?: Record<string, unknown>): void;
+    /** Alias to fireAdBreakStart */
+    fireBreakStart(params?: Record<string, unknown>): void;
+    /** Alias to fireAdBreakStop */
+    fireBreakStop(params?: Record<string, unknown>): void;
+    /** Fire Ad Break (Pod) start */
+    fireAdBreakStart(params?: Record<string, unknown>): void;
+    /** Fire Ad Break (Pod) stop */
+    fireAdBreakStop(params?: Record<string, unknown>): void;
+}
+interface PlayheadMonitor {
+    stop(): void;
+    skipNextTick(): void;
+    progress(): void;
+}
+interface AdapterFlags {
+    initCalled: boolean;
+    isStarted: boolean;
+    isStopped: boolean;
+    isJoined: boolean;
+    isBuffering: boolean;
+    isSeeking: boolean;
+    isPaused: boolean;
+    isAdPaused: boolean;
+    isEnded: boolean;
+    isVideoStateBuffering: boolean;
+    lastQuartileSent: number;
+}
+
+declare module './npaw-turbo-player-ad-adapter' {
+    interface NpawTurboPlayerAdAdapter extends AdapterAd {
+        player: IntegrationElement;
+    }
+}
+type AdapterEventListeners$1 = {
+    [K in keyof IntegrationElementEventMap]?: (event: IntegrationElementEventMap[K]) => void;
+};
+declare class NpawTurboPlayerAdAdapter {
+    _refs?: AdapterEventListeners$1;
+    getVersion(): string;
+    getPlayerVersion(): string;
+    getPlayhead(): number;
+    getTitle(): string;
+    getTitle2(): string | undefined;
+    getCreativeId(): string | null;
+    getProvider(): string | null;
+    getAdInsertionType(): string;
+    getDuration(): number | null;
+    getBreaksTime(): null;
+    getResource(): string;
+    getGivenAds(): number | null;
+    getAudioEnabled(): boolean;
+    getIsSkippable(): boolean;
+    getIsFullscreen(): boolean;
+    getIsVisible(): boolean;
+    getPosition(): string | null;
+    registerListeners(): void;
+    unregisterListeners(): void;
+    _isSupportedAd(): boolean | undefined;
+    impressionListener(): void;
+    pausedListener(): void;
+    resumedListener(): void;
+    bufferingStartListener(): void;
+    bufferingEndListener(): void;
+    completeListener(): void;
+    clickListener(): void;
+    skippedListener(): void;
+    errorListener(event: IntegrationElementEventMap['aderror']): void;
+}
+
+declare module './npaw-turbo-player-adapter' {
+    interface NpawTurboPlayerAdapter extends AdapterContent {
+        player: IntegrationElement;
+    }
+}
+type AdapterEventListeners = {
+    [K in keyof IntegrationElementEventMap]?: (event: IntegrationElementEventMap[K]) => void;
+};
+declare class NpawTurboPlayerAdapter {
+    _refs?: AdapterEventListeners;
+    adsAdapters: {
+        npawTurboPlayerAdAdapter: typeof NpawTurboPlayerAdAdapter;
+    };
+    getPlayerName(): string;
+    getVersion(): string;
+    getPlayerVersion(): string;
+    getResource(): string | null;
+    getTitle(): string | null;
+    getDuration(): number;
+    getPlayhead(): number;
+    getPlayrate(): number;
+    getIsLive(): boolean;
+    getBitrate(): number | null;
+    getLatency(): number | undefined;
+    getRendition(): string;
+    getThroughput(): number | undefined;
+    getDroppedFrames(): number | undefined;
+    getTotalBytes(): number | null;
+    registerListeners(): void;
+    unregisterListeners(): void;
+    contentStart(): void;
+    contentImpression(): void;
+    playListener(): void;
+    pauseListener(): void;
+    seekingListener(): void;
+    seekedListener(): void;
+    contentBufferStart(): void;
+    contentBufferEnd(): void;
+    contentStop(): void;
+    contentSelect(): void;
+    contentError(event: IntegrationElementEventMap['contenterror']): void;
+}
+
+interface NpawIntegrationOptions {
+    /**
+     * Application name for analytics, defaults to `integration.extraContext.appName`
+     * @example 'my-app'
+     */
+    appName?: string;
+    /**
+     * Application release version, defaults to `integration.extraContext.appVersion`
+     * @example '1.0.0'
+     */
+    appVersion?: string;
+}
+/**
+ * Connects NPAW analytics integration to a turbo player integration
+ *
+ * @param integration - The integration element
+ * @param accountCode - NPAW account code
+ * @param options - NPAW configuration options
+ * @returns The NPAW plugin instance and a destroy function
+ */
+declare function connectToNpaw(integration: IntegrationElement, accountCode: string, options?: NpawIntegrationOptions): {
+    npawPlugin: NpawPlugin;
+    destroy(): void;
+};
+
+export { type NpawIntegrationOptions, NpawTurboPlayerAdapter, connectToNpaw };

package/dist/npaw/index.js

@@ -0,0 +1,317 @@
+import { PlaybackMode, IntegrationEvent, Mimetype, EXTERNAL_PLAYER_NAME } from '@glomex/integration-web-component';
+import NpawPlugin from 'npaw-plugin';
+
+// src/npaw/index.ts
+
+// package.json
+var package_default = {
+  version: "1.1480.0"};
+
+// src/npaw/package-info.ts
+var { version } = package_default;
+
+// src/npaw/npaw-turbo-player-ad-adapter.ts
+var NpawTurboPlayerAdAdapter = class {
+  _refs;
+  getVersion() {
+    return `turbo-ad-v${version}`;
+  }
+  getPlayerVersion() {
+    return this.player.version;
+  }
+  getPlayhead() {
+    return this.player.adCurrentTime;
+  }
+  getTitle() {
+    return this.player.currentAd?.title || "";
+  }
+  getTitle2() {
+    return this.player.currentAd?.advertiserName || void 0;
+  }
+  getCreativeId() {
+    return this.player.currentAd?.creativeId || null;
+  }
+  getProvider() {
+    return this.player.currentAd?.adSystem || null;
+  }
+  getAdInsertionType() {
+    return "client-side";
+  }
+  getDuration() {
+    return this.player.currentAd?.duration || this.player.adDuration || null;
+  }
+  getBreaksTime() {
+    return null;
+  }
+  getResource() {
+    return this.player.currentAd?.adUrl || "unknown";
+  }
+  getGivenAds() {
+    return this.player.currentAd?.totalAds || null;
+  }
+  getAudioEnabled() {
+    return Boolean(!this.player.adMuted);
+  }
+  getIsSkippable() {
+    return this.player.currentAd?.skippable || false;
+  }
+  getIsFullscreen() {
+    return this.player.presentationMode === "fullscreen";
+  }
+  getIsVisible() {
+    return this.getNpawUtils().calculateAdViewability(this.player);
+  }
+  getPosition() {
+    if (this.player.currentAd?.breakName === "preroll") {
+      return this.getNpawReference().Constants.AdPosition.Preroll;
+    }
+    if (this.player.currentAd?.breakName === "midroll") {
+      return this.getNpawReference().Constants.AdPosition.Midroll;
+    }
+    if (this.player.currentAd?.breakName === "postroll") {
+      return this.getNpawReference().Constants.AdPosition.Postroll;
+    }
+    return null;
+  }
+  registerListeners() {
+    this._refs = {
+      [IntegrationEvent.AD_IMPRESSION]: this.impressionListener.bind(this),
+      [IntegrationEvent.AD_RESUMED]: this.resumedListener.bind(this),
+      [IntegrationEvent.AD_PAUSED]: this.pausedListener.bind(this),
+      [IntegrationEvent.AD_BUFFERING_START]: this.bufferingStartListener.bind(this),
+      [IntegrationEvent.AD_BUFFERING_END]: this.bufferingEndListener.bind(this),
+      [IntegrationEvent.AD_CLICK]: this.clickListener.bind(this),
+      [IntegrationEvent.AD_SKIPPED]: this.skippedListener.bind(this),
+      [IntegrationEvent.AD_COMPLETE]: this.completeListener.bind(this),
+      [IntegrationEvent.AD_ERROR]: this.errorListener.bind(this)
+    };
+    for (const type of Object.keys(this._refs)) {
+      const handler = this._refs?.[type];
+      this.player.addEventListener(
+        type,
+        handler
+      );
+    }
+  }
+  unregisterListeners() {
+    for (const type of Object.keys(this._refs || {})) {
+      const handler = this._refs?.[type];
+      this.player.removeEventListener(
+        type,
+        handler
+      );
+    }
+    this._refs = void 0;
+  }
+  _isSupportedAd() {
+    return this.player.currentAd?.isLinear;
+  }
+  impressionListener() {
+    if (!this._isSupportedAd()) return;
+    this.fireStart({}, "impressionListener");
+    this.fireJoin({}, "impressionListener");
+  }
+  pausedListener() {
+    if (!this._isSupportedAd()) return;
+    this.firePause({}, IntegrationEvent.AD_PAUSED);
+  }
+  resumedListener() {
+    if (!this._isSupportedAd()) return;
+    this.fireResume({}, IntegrationEvent.AD_RESUMED);
+  }
+  bufferingStartListener() {
+    if (!this._isSupportedAd()) return;
+    this.fireBufferBegin({}, true, IntegrationEvent.AD_BUFFERING_START);
+  }
+  bufferingEndListener() {
+    if (!this._isSupportedAd()) return;
+    this.fireBufferEnd({}, IntegrationEvent.AD_BUFFERING_END);
+  }
+  completeListener() {
+    if (!this._isSupportedAd()) return;
+    this.fireStop({}, IntegrationEvent.AD_COMPLETE);
+  }
+  clickListener() {
+    if (!this._isSupportedAd()) return;
+    this.fireClick(this.player.currentAd?.clickThroughUrl || "");
+  }
+  skippedListener() {
+    if (!this._isSupportedAd()) return;
+    this.fireSkip();
+  }
+  errorListener(event) {
+    if (!this._isSupportedAd()) return;
+    this.fireError(event.detail.error.code, event.detail.error.message);
+  }
+};
+
+// src/npaw/npaw-turbo-player-adapter.ts
+var NpawTurboPlayerAdapter = class {
+  _refs;
+  adsAdapters = {
+    npawTurboPlayerAdAdapter: NpawTurboPlayerAdAdapter
+  };
+  getPlayerName() {
+    return "turbo-player";
+  }
+  getVersion() {
+    return `turbo-v${version}`;
+  }
+  getPlayerVersion() {
+    return this.player.version;
+  }
+  getResource() {
+    return this.player.source?.src || null;
+  }
+  getTitle() {
+    return this.player.content?.title || null;
+  }
+  getDuration() {
+    return this.player.duration;
+  }
+  getPlayhead() {
+    return this.getIsLive() ? this.player.wallClockTime : this.player.currentTime;
+  }
+  getPlayrate() {
+    return 1;
+  }
+  getIsLive() {
+    return this.player.content?.sources[0]?.playbackMode === PlaybackMode.LIVE;
+  }
+  getBitrate() {
+    return this.player.getVideoPlaybackQuality()?.bitrate || null;
+  }
+  getLatency() {
+    return this.player.getVideoPlaybackQuality()?.liveLatency;
+  }
+  getRendition() {
+    const { width, height, bandwidth } = this.player.getVideoPlaybackQuality() || {};
+    if (width && height && bandwidth) {
+      return this.getNpawUtils().buildRenditionString(width, height, bandwidth);
+    }
+    return "unknown";
+  }
+  getThroughput() {
+    return this.player.getVideoPlaybackQuality()?.throughput;
+  }
+  getDroppedFrames() {
+    return this.player.getVideoPlaybackQuality()?.droppedVideoFrames;
+  }
+  getTotalBytes() {
+    return this.player.getVideoPlaybackQuality()?.bytes || null;
+  }
+  registerListeners() {
+    this._refs = {
+      [IntegrationEvent.CONTENT_PLAY]: this.playListener.bind(this),
+      [IntegrationEvent.CONTENT_PAUSE]: this.pauseListener.bind(this),
+      [IntegrationEvent.CONTENT_SEEKING]: this.seekingListener.bind(this),
+      [IntegrationEvent.CONTENT_SEEKED]: this.seekedListener.bind(this),
+      [IntegrationEvent.CONTENT_BUFFERING_START]: this.contentBufferStart.bind(this),
+      [IntegrationEvent.CONTENT_BUFFERING_END]: this.contentBufferEnd.bind(this),
+      [IntegrationEvent.CONTENT_START]: this.contentStart.bind(this),
+      [IntegrationEvent.CONTENT_IMPRESSION]: this.contentImpression.bind(this),
+      [IntegrationEvent.CONTENT_STOP]: this.contentStop.bind(this),
+      [IntegrationEvent.CONTENT_SELECT]: this.contentSelect.bind(this),
+      [IntegrationEvent.CONTENT_ERROR]: this.contentError.bind(this)
+    };
+    for (const type of Object.keys(this._refs)) {
+      const handler = this._refs?.[type];
+      this.player.addEventListener(
+        type,
+        handler
+      );
+    }
+    this.plugin.setAdsAdapter(
+      this.getAdapterClass("npawTurboPlayerAdAdapter"),
+      this.getVideo().getVideoKey()
+    );
+  }
+  unregisterListeners() {
+    for (const type of Object.keys(this._refs || {})) {
+      const handler = this._refs?.[type];
+      this.player.removeEventListener(
+        type,
+        handler
+      );
+    }
+    this._refs = void 0;
+    this.plugin.removeAdsAdapter(this.getVideo().getVideoKey());
+  }
+  contentStart() {
+    const { options } = this.getVideo();
+    const streamingProtocol = this.player.source?.mimetype === Mimetype.DASH ? "DASH" : this.player.source?.mimetype === Mimetype.HLS ? "HLS" : void 0;
+    options["content.id"] = this.player.source?.id || this.player.content?.id;
+    options["content.streamingProtocol"] = streamingProtocol;
+    options["content.playbackType"] = this.player.source?.playbackMode;
+    options["content.tvShow"] = this.player.content?.show?.name;
+    options["content.season"] = this.player.content?.show?.seasonNumber;
+    options["content.language"] = this.player.content?.language;
+    this.fireStart({}, IntegrationEvent.CONTENT_START);
+  }
+  contentImpression() {
+    this.fireJoin({}, IntegrationEvent.CONTENT_IMPRESSION);
+  }
+  playListener() {
+    this.fireResume({}, IntegrationEvent.CONTENT_PLAY);
+    this.plugin.getAdsAdapter().fireAdBreakStop({});
+  }
+  pauseListener() {
+    this.firePause({}, "pauseListener");
+  }
+  seekingListener() {
+    this.fireSeekBegin({}, true, IntegrationEvent.CONTENT_SEEKING);
+  }
+  seekedListener() {
+    this.fireSeekEnd({}, IntegrationEvent.CONTENT_SEEKED);
+  }
+  contentBufferStart() {
+    this.fireBufferBegin({}, true, IntegrationEvent.CONTENT_BUFFERING_START);
+  }
+  contentBufferEnd() {
+    this.fireBufferEnd({}, IntegrationEvent.CONTENT_BUFFERING_END);
+  }
+  contentStop() {
+    this.fireStop({}, IntegrationEvent.CONTENT_STOP);
+  }
+  contentSelect() {
+    this.fireStop({}, IntegrationEvent.CONTENT_SELECT);
+  }
+  contentError(event) {
+    this.fireFatalError(
+      event.detail.error.code,
+      event.detail.error.message,
+      void 0,
+      "fatal",
+      IntegrationEvent.CONTENT_ERROR
+    );
+  }
+};
+
+// src/npaw/index.ts
+function connectToNpaw(integration, accountCode, options) {
+  const { appName = EXTERNAL_PLAYER_NAME, appVersion } = options || {};
+  const npawPlugin = new NpawPlugin(accountCode);
+  npawPlugin.setAnalyticsOptions({
+    "app.name": appName || integration.extraContext?.appName,
+    "app.releaseVersion": appVersion || integration.extraContext?.appVersion
+  });
+  const onUserUpdateConsent = () => {
+    const hasPurpose1Consent = Boolean(integration.consent?.purposeConsents?.["1"]);
+    npawPlugin.setAnalyticsOptions({
+      "user.obfuscateIp": !hasPurpose1Consent,
+      disableStorage: !hasPurpose1Consent,
+      ...hasPurpose1Consent ? {} : { userId: void 0 }
+    });
+  };
+  npawPlugin.registerAdapterFromClass(integration, NpawTurboPlayerAdapter);
+  integration.addEventListener(IntegrationEvent.USER_UPDATE_CONSENT, onUserUpdateConsent);
+  return {
+    npawPlugin,
+    destroy() {
+      integration.removeEventListener(IntegrationEvent.USER_UPDATE_CONSENT, onUserUpdateConsent);
+      npawPlugin?.destroy();
+    }
+  };
+}
+
+export { NpawTurboPlayerAdapter, connectToNpaw };

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@glomex/integration-analytics",
+  "version": "1.1480.0",
+  "description": "Analytics integrations for the turbo player",
+  "documentation": "https://docs.glomex.com",
+  "homepage": "https://glomex.com",
+  "keywords": [
+    "glomex",
+    "video",
+    "player",
+    "streaming",
+    "media-player",
+    "web-player",
+    "analytics",
+    "npaw",
+    "youbora",
+    "nielsen",
+    "comscore",
+    "datazoom",
+    "sensic"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    "./npaw": {
+      "types": "./dist/npaw/index.d.ts",
+      "import": "./dist/npaw/index.js"
+    }
+  },
+  "files": [
+    "LICENSE.md",
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "prepack": "npm run build",
+    "build": "rm -rf dist && npm run build:ts --force && npm run build:tsup",
+    "build:ts": "tsc --build",
+    "build:tsup": "tsup",
+    "lint": "tsc --noEmit && biome ci",
+    "watch": "npm run build:ts --force && tsup --watch"
+  },
+  "dependencies": {
+    "@glomex/integration-web-component": "workspace:*",
+    "npaw-plugin": "^7.3.18"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "catalog:",
+    "tsup": "catalog:",
+    "typescript": "catalog:"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT"
+}