@github/hydro-analytics-client 2.3.2 → 2.4.0

package/dist/analytics-client.d.ts

@@ -0,0 +1,30 @@
+export declare type Context = Record<string, string>;
+export interface AnalyticsClientOptions {
+    collectorUrl: string;
+    clientId?: string;
+    baseContext?: Context;
+    maxBatchSize?: number;
+    idleTimeout?: number;
+}
+export declare class AnalyticsClient {
+    readonly options: AnalyticsClientOptions;
+    private eventBatch;
+    private idleCallbackId;
+    private fallbackTimerId;
+    constructor(options: AnalyticsClientOptions);
+    get collectorUrl(): string;
+    get clientId(): string;
+    private get maxBatchSize();
+    private get idleTimeout();
+    private createEvent;
+    sendPageView(context?: Context): void;
+    sendEvent(type: string, context: Context): void;
+    sendBatchedEvent(type: string, context: Context): void;
+    flushBatch(): void;
+    destroy(): void;
+    private scheduleFlush;
+    private cancelScheduledFlush;
+    private onVisibilityChange;
+    private boundFlush;
+    private send;
+}

package/dist/analytics-client.js

@@ -0,0 +1,140 @@
+import { getRequestContext } from './request-context.js';
+import { getMarketingContext } from './marketing-context.js';
+import { getOrCreateClientId } from './client-id.js';
+export class AnalyticsClient {
+    constructor(options) {
+        this.options = options;
+        this.eventBatch = [];
+        this.idleCallbackId = null;
+        this.fallbackTimerId = null;
+        this.onVisibilityChange = () => {
+            if (document.visibilityState === 'hidden') {
+                this.flushBatch();
+            }
+        };
+        this.boundFlush = () => this.flushBatch();
+        if (typeof document !== 'undefined') {
+            document.addEventListener('visibilitychange', this.onVisibilityChange);
+        }
+        if (typeof window !== 'undefined') {
+            window.addEventListener('pagehide', this.boundFlush);
+        }
+    }
+    get collectorUrl() {
+        return this.options.collectorUrl;
+    }
+    get clientId() {
+        if (this.options.clientId) {
+            return this.options.clientId;
+        }
+        return getOrCreateClientId();
+    }
+    get maxBatchSize() {
+        return this.options.maxBatchSize ?? 10;
+    }
+    get idleTimeout() {
+        return this.options.idleTimeout ?? 1000;
+    }
+    createEvent(context) {
+        return {
+            page: location.href,
+            title: document.title,
+            context: {
+                ...this.options.baseContext,
+                ...getMarketingContext(),
+                ...context
+            }
+        };
+    }
+    sendPageView(context) {
+        const pageView = this.createEvent(context);
+        this.send({ page_views: [pageView] });
+    }
+    sendEvent(type, context) {
+        const event = {
+            ...this.createEvent(context),
+            type
+        };
+        this.send({ events: [event] });
+    }
+    sendBatchedEvent(type, context) {
+        const event = {
+            ...this.createEvent(context),
+            type
+        };
+        this.eventBatch.push(event);
+        if (this.eventBatch.length >= this.maxBatchSize) {
+            this.flushBatch();
+        }
+        else {
+            this.scheduleFlush();
+        }
+    }
+    flushBatch() {
+        if (this.eventBatch.length === 0)
+            return;
+        this.cancelScheduledFlush();
+        const events = this.eventBatch;
+        this.eventBatch = [];
+        this.send({ events });
+    }
+    destroy() {
+        this.flushBatch();
+        if (typeof document !== 'undefined') {
+            document.removeEventListener('visibilitychange', this.onVisibilityChange);
+        }
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('pagehide', this.boundFlush);
+        }
+    }
+    scheduleFlush() {
+        if (this.idleCallbackId !== null || this.fallbackTimerId !== null)
+            return;
+        if (typeof requestIdleCallback === 'function') {
+            this.idleCallbackId = requestIdleCallback(this.boundFlush, {
+                timeout: this.idleTimeout
+            });
+        }
+        else {
+            this.fallbackTimerId = setTimeout(this.boundFlush, this.idleTimeout);
+        }
+    }
+    cancelScheduledFlush() {
+        if (this.idleCallbackId !== null) {
+            if (typeof cancelIdleCallback === 'function') {
+                cancelIdleCallback(this.idleCallbackId);
+            }
+            this.idleCallbackId = null;
+        }
+        if (this.fallbackTimerId !== null) {
+            clearTimeout(this.fallbackTimerId);
+            this.fallbackTimerId = null;
+        }
+    }
+    send({ page_views, events }) {
+        const payload = {
+            client_id: this.clientId,
+            page_views,
+            events,
+            request_context: getRequestContext()
+        };
+        const body = JSON.stringify(payload);
+        try {
+            if (navigator.sendBeacon) {
+                navigator.sendBeacon(this.collectorUrl, body);
+                return;
+            }
+        }
+        catch {
+        }
+        fetch(this.collectorUrl, {
+            method: 'POST',
+            cache: 'no-cache',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body,
+            keepalive: false
+        });
+    }
+}

package/dist/client-id.d.ts

@@ -0,0 +1 @@
+export declare function getOrCreateClientId(): string;

package/dist/client-id.js

@@ -0,0 +1,50 @@
+let fallbackClientId;
+function generateClientId() {
+    return `${Math.round(Math.random() * (Math.pow(2, 31) - 1))}.${Math.round(Date.now() / 1000)}`;
+}
+function setClientIdCookie(clientId) {
+    const value = `GH1.1.${clientId}`;
+    const now = Date.now();
+    const expires = new Date(now + 1 * 365 * 86400 * 1000).toUTCString();
+    let { domain } = document;
+    if (domain.endsWith('.github.com')) {
+        domain = 'github.com';
+    }
+    document.cookie = `_octo=${value}; expires=${expires}; path=/; domain=${domain}; secure; samesite=lax`;
+}
+function getClientIdFromCookie() {
+    let clientId;
+    const cookie = document.cookie;
+    const matches = cookie.match(/_octo=([^;]+)/g);
+    if (!matches) {
+        return;
+    }
+    let latestVersion = [0, 0];
+    for (const match of matches) {
+        const [, value] = match.split('=');
+        const [, version, ...clientIdPortions] = value.split('.');
+        const semanticVersion = version.split('-').map(Number);
+        if (semanticVersion > latestVersion) {
+            latestVersion = semanticVersion;
+            clientId = clientIdPortions.join('.');
+        }
+    }
+    return clientId;
+}
+export function getOrCreateClientId() {
+    try {
+        const existingId = getClientIdFromCookie();
+        if (existingId) {
+            return existingId;
+        }
+        const clientId = generateClientId();
+        setClientIdCookie(clientId);
+        return clientId;
+    }
+    catch (_) {
+        if (!fallbackClientId) {
+            fallbackClientId = generateClientId();
+        }
+        return fallbackClientId;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './analytics-client.js';
+export * from './meta-helpers.js';
+export * from './client-id.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from './analytics-client.js';
+export * from './meta-helpers.js';
+export * from './client-id.js';

package/dist/marketing-context.d.ts

@@ -0,0 +1,10 @@
+interface MarketingContext {
+    scid?: string;
+    utm_source?: string;
+    utm_medium?: string;
+    utm_term?: string;
+    utm_campaign?: string;
+    utm_content?: string;
+}
+export declare function getMarketingContext(): MarketingContext;
+export {};

package/dist/marketing-context.js

@@ -0,0 +1,17 @@
+const MARKETING_PARAMS = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content', 'scid'];
+export function getMarketingContext() {
+    const marketingContext = {};
+    try {
+        const urlParams = new URLSearchParams(window.location.search);
+        for (const [key, value] of urlParams) {
+            const normalizedKey = key.toLowerCase();
+            if (MARKETING_PARAMS.includes(normalizedKey)) {
+                marketingContext[normalizedKey] = value;
+            }
+        }
+        return marketingContext;
+    }
+    catch (e) {
+        return {};
+    }
+}

package/dist/meta-helpers.d.ts

@@ -0,0 +1,2 @@
+import { AnalyticsClientOptions } from './analytics-client.js';
+export declare function getOptionsFromMeta(prefix?: string): AnalyticsClientOptions;

package/dist/meta-helpers.js

@@ -0,0 +1,22 @@
+export function getOptionsFromMeta(prefix = 'ha') {
+    let collectorUrl;
+    const baseContext = {};
+    const metaTags = document.head.querySelectorAll(`meta[name^="${prefix}-"]`);
+    for (const meta of Array.from(metaTags)) {
+        const { name: originalName, content } = meta;
+        const name = originalName.replace(`${prefix}-`, '').replace(/-/g, '_');
+        if (name === 'url') {
+            collectorUrl = content;
+        }
+        else {
+            baseContext[name] = content;
+        }
+    }
+    if (!collectorUrl) {
+        throw new Error(`AnalyticsClient ${prefix}-url meta tag not found`);
+    }
+    return {
+        collectorUrl,
+        ...(Object.keys(baseContext).length > 0 ? { baseContext } : {})
+    };
+}

package/dist/request-context.d.ts

@@ -0,0 +1,11 @@
+export interface RequestContext {
+    referrer?: string;
+    user_agent: string;
+    screen_resolution: string;
+    browser_resolution: string;
+    browser_languages: string;
+    pixel_ratio: number;
+    timestamp: number;
+    tz_seconds: number;
+}
+export declare function getRequestContext(): RequestContext;

package/dist/request-context.js

@@ -0,0 +1,69 @@
+function getReferrer() {
+    let referrer;
+    try {
+        referrer = window.top.document.referrer;
+    }
+    catch (error) {
+        if (window.parent) {
+            try {
+                referrer = window.parent.document.referrer;
+            }
+            catch (_) {
+            }
+        }
+    }
+    if (referrer === '') {
+        referrer = document.referrer;
+    }
+    return referrer;
+}
+function getScreenResolution() {
+    try {
+        return `${screen.width}x${screen.height}`;
+    }
+    catch (error) {
+        return 'unknown';
+    }
+}
+function getBrowserResolution() {
+    let height = 0;
+    let width = 0;
+    try {
+        if (typeof window.innerWidth === 'number') {
+            width = window.innerWidth;
+            height = window.innerHeight;
+        }
+        else if (document.documentElement != null && document.documentElement.clientWidth != null) {
+            width = document.documentElement.clientWidth;
+            height = document.documentElement.clientHeight;
+        }
+        else if (document.body != null && document.body.clientWidth != null) {
+            width = document.body.clientWidth;
+            height = document.body.clientHeight;
+        }
+        return `${width}x${height}`;
+    }
+    catch (error) {
+        return 'unknown';
+    }
+}
+function getBrowserLanguages() {
+    if (navigator.languages) {
+        return navigator.languages.join(',');
+    }
+    else {
+        return navigator.language || '';
+    }
+}
+export function getRequestContext() {
+    return {
+        referrer: getReferrer(),
+        user_agent: navigator.userAgent,
+        screen_resolution: getScreenResolution(),
+        browser_resolution: getBrowserResolution(),
+        browser_languages: getBrowserLanguages(),
+        pixel_ratio: window.devicePixelRatio,
+        timestamp: Date.now(),
+        tz_seconds: new Date().getTimezoneOffset() * -60
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@github/hydro-analytics-client",
-  "version": "2.3.2",
+  "version": "2.4.0",
   "description": "Client SDK for Hydro Analytics",
   "main": "./dist/index.js",
   "module": "dist/index.js",