22148703734

Committed 18 Feb 2026 04:41PM UTC coverage: 96.218% (+0.01%) from 96.205%

Build # 22148703734

Build Type

Pull #14488

github

Specific Base ff15b7

Committed by

patmmccann

Commit Message

Docs: require TypeScript for new src/modules/libraries files

Pull Request Pull Request #14488: Prebid 11: document TypeScript-first policy for new source files

Run Details

54237 of 66588 branches covered (81.45%)

208182 of 216366 relevant lines covered (96.22%)

69.07 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

60.76

/modules/hadronAnalyticsAdapter.js

import { ajax } from '../src/ajax.js';
import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
import adapterManager from '../src/adapterManager.js';
import * as utils from '../src/utils.js';
import { EVENTS } from '../src/constants.js';
import {getStorageManager} from '../src/storageManager.js';
import {getRefererInfo} from '../src/refererDetection.js';
import {MODULE_TYPE_ANALYTICS} from '../src/activities/modules.js';
import { getViewportSize } from '../libraries/viewport/viewport.js';

/**
 * hadronAnalyticsAdapter.js - Audigent Hadron Analytics Adapter
 */

const HADRON_ANALYTICS_URL = 'https://analytics.hadron.ad.gt/api/v1/analytics';
const HADRONID_ANALYTICS_VER = 'pbadgt0';
const DEFAULT_PARTNER_ID = 0;
const AU_GVLID = 561;
const MODULE_CODE = 'hadronAnalytics';

export const storage = getStorageManager({moduleType: MODULE_TYPE_ANALYTICS, moduleName: MODULE_CODE});

var viewId = utils.generateUUID();

var partnerId = DEFAULT_PARTNER_ID;
var eventsToTrack = [];

const { width: x, height: y } = getViewportSize();

var pageView = {
  eventType: 'pageView',
  userAgent: window.navigator.userAgent,
  timestamp: Date.now(),
  timezoneOffset: new Date().getTimezoneOffset(),
  language: window.navigator.language,
  vendor: window.navigator.vendor,
  pageUrl: getRefererInfo().page,
  screenWidth: x,
  screenHeight: y
};

var eventQueue = [
  pageView
];

var startAuction = 0;
var bidRequestTimeout = 0;
const analyticsType = 'endpoint';

const hadronAnalyticsAdapter = Object.assign(adapter({url: HADRON_ANALYTICS_URL, analyticsType}), {
  track({eventType, args}) {
    args = args ? utils.deepClone(args) : {};
    var data = {};
    if (!eventsToTrack.includes(eventType)) return;
    switch (eventType) {
      case EVENTS.AUCTION_INIT: {
        data = args;
        startAuction = data.timestamp;
        bidRequestTimeout = data.timeout;
        break;
      }

      case EVENTS.AUCTION_END: {
        data = args;
        data.start = startAuction;
        data.end = Date.now();
        break;
      }

      case EVENTS.BID_ADJUSTMENT: {
        data.bidders = args;
        break;
      }

      case EVENTS.BID_TIMEOUT: {
        data.bidders = args;
        data.duration = bidRequestTimeout;
        break;
      }

      case EVENTS.BID_REQUESTED: {
        data = args;
        break;
      }

      case EVENTS.BID_RESPONSE: {
        data = args;
        delete data.ad;
        break;
      }

      case EVENTS.BID_WON: {
        data = args;
        delete data.ad;
        delete data.adUrl;
        break;
      }

      case EVENTS.BIDDER_DONE: {
        data = args;
        break;
      }

      case EVENTS.SET_TARGETING: {
        data.targetings = args;
        break;
      }

      case EVENTS.REQUEST_BIDS: {
        data = args;
        break;
      }

      case EVENTS.AD_RENDER_FAILED: {
        data = args;
        break;
      }

      default:
        return;
    }

    data.eventType = eventType;
    data.timestamp = data.timestamp || Date.now();

    sendEvent(data);
  }
});

hadronAnalyticsAdapter.originEnableAnalytics = hadronAnalyticsAdapter.enableAnalytics;

hadronAnalyticsAdapter.enableAnalytics = function(conf = {}) {
  if (typeof conf.options === 'object') {
    if (conf.options.partnerId) {
      partnerId = conf.options.partnerId;
    } else {
      partnerId = DEFAULT_PARTNER_ID;
    }
    if (conf.options.eventsToTrack) {
      eventsToTrack = conf.options.eventsToTrack;
    }
  } else {
    utils.logError('HADRON_ANALYTICS_NO_CONFIG_ERROR');
    return;
  }

  hadronAnalyticsAdapter.originEnableAnalytics(conf);
};

function flush() {
  // Don't send anything if no partner id was declared
  if (partnerId === DEFAULT_PARTNER_ID) return;
  if (eventQueue.length > 1) {
    var data = {
      pageViewId: viewId,
      ver: HADRONID_ANALYTICS_VER,
      partnerId: partnerId,
      events: eventQueue
    };

    ajax(HADRON_ANALYTICS_URL,
      () => utils.logInfo('HADRON_ANALYTICS_BATCH_SEND'),
      JSON.stringify(data),
      {
        contentType: 'application/json',
        method: 'POST'
      }
    );

    eventQueue = [
      pageView
    ];
  }
}

function sendEvent(event) {
  eventQueue.push(event);
  utils.logInfo(`HADRON_ANALYTICS_EVENT ${event.eventType} `, event);

  if (event.eventType === EVENTS.AUCTION_END) {
    flush();
  }
}

adapterManager.registerAnalyticsAdapter({
  adapter: hadronAnalyticsAdapter,
  code: MODULE_CODE,
  gvlid: AU_GVLID
});

hadronAnalyticsAdapter.flush = flush;

export default hadronAnalyticsAdapter;

1	import { ajax } from '../src/ajax.js';	1✔
2	import adapter from '../libraries/analyticsAdapter/AnalyticsAdapter.js';
3	import adapterManager from '../src/adapterManager.js';
4	import * as utils from '../src/utils.js';
5	import { EVENTS } from '../src/constants.js';
6	import {getStorageManager} from '../src/storageManager.js';
7	import {getRefererInfo} from '../src/refererDetection.js';
8	import {MODULE_TYPE_ANALYTICS} from '../src/activities/modules.js';
9	import { getViewportSize } from '../libraries/viewport/viewport.js';
10
11	/**
12	* hadronAnalyticsAdapter.js - Audigent Hadron Analytics Adapter
13	*/
14
15	const HADRON_ANALYTICS_URL = 'https://analytics.hadron.ad.gt/api/v1/analytics';	1✔
16	const HADRONID_ANALYTICS_VER = 'pbadgt0';	1✔
17	const DEFAULT_PARTNER_ID = 0;	1✔
18	const AU_GVLID = 561;	1✔
19	const MODULE_CODE = 'hadronAnalytics';	1✔
20
21	export const storage = getStorageManager({moduleType: MODULE_TYPE_ANALYTICS, moduleName: MODULE_CODE});	1✔
22
23	var viewId = utils.generateUUID();	1✔
24
25	var partnerId = DEFAULT_PARTNER_ID;	1✔
26	var eventsToTrack = [];	1✔
27
28	const { width: x, height: y } = getViewportSize();	1✔
29
30	var pageView = {	1✔
31	eventType: 'pageView',
32	userAgent: window.navigator.userAgent,
33	timestamp: Date.now(),
34	timezoneOffset: new Date().getTimezoneOffset(),
35	language: window.navigator.language,
36	vendor: window.navigator.vendor,
37	pageUrl: getRefererInfo().page,
38	screenWidth: x,
39	screenHeight: y
40	};
41
42	var eventQueue = [	1✔
43	pageView
44	];
45
46	var startAuction = 0;	1✔
47	var bidRequestTimeout = 0;	1✔
48	const analyticsType = 'endpoint';	1✔
49
50	const hadronAnalyticsAdapter = Object.assign(adapter({url: HADRON_ANALYTICS_URL, analyticsType}), {	1✔
51	track({eventType, args}) {	2✔
52	args = args ? utils.deepClone(args) : {};	2!
53	var data = {};	2✔
54	if (!eventsToTrack.includes(eventType)) return;	2✔
55	switch (eventType) {	1!
56	case EVENTS.AUCTION_INIT: {
57	data = args;	×
58	startAuction = data.timestamp;	×
59	bidRequestTimeout = data.timeout;	×
60	break;	×
61	}
62
63	case EVENTS.AUCTION_END: {
64	data = args;	1✔
65	data.start = startAuction;	1✔
66	data.end = Date.now();	1✔
67	break;	1✔
68	}
69
70	case EVENTS.BID_ADJUSTMENT: {
71	data.bidders = args;	×
72	break;	×
73	}
74
75	case EVENTS.BID_TIMEOUT: {
76	data.bidders = args;	×
77	data.duration = bidRequestTimeout;	×
78	break;	×
79	}
80
81	case EVENTS.BID_REQUESTED: {
82	data = args;	×
83	break;	×
84	}
85
86	case EVENTS.BID_RESPONSE: {
87	data = args;	×
88	delete data.ad;	×
89	break;	×
90	}
91
92	case EVENTS.BID_WON: {
93	data = args;	×
94	delete data.ad;	×
95	delete data.adUrl;	×
96	break;	×
97	}
98
99	case EVENTS.BIDDER_DONE: {
100	data = args;	×
101	break;	×
102	}
103
104	case EVENTS.SET_TARGETING: {
105	data.targetings = args;	×
106	break;	×
107	}
108
109	case EVENTS.REQUEST_BIDS: {
110	data = args;	×
111	break;	×
112	}
113
114	case EVENTS.AD_RENDER_FAILED: {
115	data = args;	×
116	break;	×
117	}
118
119	default:
120	return;	×
121	}
122
123	data.eventType = eventType;	1✔
124	data.timestamp = data.timestamp \|\| Date.now();	1✔
125
126	sendEvent(data);	1✔
127	}
128	});
129
130	hadronAnalyticsAdapter.originEnableAnalytics = hadronAnalyticsAdapter.enableAnalytics;	1✔
131
132	hadronAnalyticsAdapter.enableAnalytics = function(conf = {}) {	3!
133	if (typeof conf.options === 'object') {	3!
134	if (conf.options.partnerId) {	3!
135	partnerId = conf.options.partnerId;	3✔
136	} else {
137	partnerId = DEFAULT_PARTNER_ID;	×
138	}
139	if (conf.options.eventsToTrack) {	3✔
140	eventsToTrack = conf.options.eventsToTrack;	3✔
141	}
142	} else {
143	utils.logError('HADRON_ANALYTICS_NO_CONFIG_ERROR');	×
144	return;	×
145	}
146
147	hadronAnalyticsAdapter.originEnableAnalytics(conf);	3✔
148	};
149
150	function flush() {
151	// Don't send anything if no partner id was declared
152	if (partnerId === DEFAULT_PARTNER_ID) return;	1!
153	if (eventQueue.length > 1) {	1✔
154	var data = {	1✔
155	pageViewId: viewId,
156	ver: HADRONID_ANALYTICS_VER,
157	partnerId: partnerId,
158	events: eventQueue
159	};
160
161	ajax(HADRON_ANALYTICS_URL,	1✔
162	() => utils.logInfo('HADRON_ANALYTICS_BATCH_SEND'),	×
163	JSON.stringify(data),
164	{
165	contentType: 'application/json',
166	method: 'POST'
167	}
168	);
169
170	eventQueue = [	1✔
171	pageView
172	];
173	}
174	}
175
176	function sendEvent(event) {
177	eventQueue.push(event);	1✔
178	utils.logInfo(`HADRON_ANALYTICS_EVENT ${event.eventType} `, event);	1✔
179
180	if (event.eventType === EVENTS.AUCTION_END) {	1✔
181	flush();	1✔
182	}
183	}
184
185	adapterManager.registerAnalyticsAdapter({	1✔
186	adapter: hadronAnalyticsAdapter,
187	code: MODULE_CODE,
188	gvlid: AU_GVLID
189	});
190
191	hadronAnalyticsAdapter.flush = flush;	1✔
192
193	export default hadronAnalyticsAdapter;

prebid / Prebid.js / 22148703734

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous