@streamscloud/streams-analytics-collector 2.0.9 → 3.0.0

package/dist/reporting/gql-data-sender.d.ts

@@ -0,0 +1,12 @@
+import type { Client } from '@urql/core';
+export type GqlDataSenderOptions = {
+    client: Client;
+} | {
+    endpoint: string;
+};
+export declare class GqlDataSender {
+    private gqlEndpoint;
+    private client;
+    constructor(options: GqlDataSenderOptions);
+    send(query: string, variables?: object): Promise<void>;
+}

package/dist/reporting/gql-data-sender.js

@@ -0,0 +1,35 @@
+class GqlDataSender {
+    gqlEndpoint = null;
+    client = null;
+    constructor(options) {
+        if ('client' in options) {
+            this.client = options.client;
+            this.gqlEndpoint = null;
+        }
+        else {
+            this.gqlEndpoint = options.endpoint;
+            this.client = null;
+        }
+    }
+    async send(query, variables) {
+        if (this.gqlEndpoint) {
+            await sendGqlBeacon(this.gqlEndpoint, query, variables);
+        }
+        else if (this.client) {
+            await this.client.mutation(query, variables).toPromise();
+        }
+        else {
+            console.error('GqlDataSender not properly initialized.');
+        }
+    }
+}
+async function sendGqlBeacon(endpoint, query, variables) {
+    const body = JSON.stringify({ query, variables });
+    const blob = new Blob([body], { type: 'application/json' });
+    const accepted = navigator.sendBeacon(endpoint, blob);
+    if (!accepted) {
+        throw new Error('Failed to queue analytics beacon.');
+    }
+}
+
+export { GqlDataSender };

package/dist/reporting/index.d.ts

@@ -0,0 +1,4 @@
+export { type ReportedEvent, EventsReporter } from './events-reporter';
+export { type GqlDataSenderOptions, GqlDataSender } from './gql-data-sender';
+export { type ReportedMeasurement, MeasurementsReporter } from './measurements-reporter';
+export { EntityRelationType, EntityType, EventType, MeasurementType, type AnalyticsMetadata, type AnalyticsSchema, type Entity, type EntityRelation, } from './types';

package/dist/reporting/measurements-reporter.d.ts

@@ -0,0 +1,15 @@
+import type { AnalyticsSchema, AnalyticsMetadata, MeasurementType, EntityRelation, Entity } from './types';
+import type { GqlDataSender } from './gql-data-sender';
+export type ReportedMeasurement = {
+    entity: Entity;
+    measurementType: MeasurementType;
+    value: number;
+    relatedEntities?: EntityRelation[] | null;
+};
+export declare class MeasurementsReporter {
+    private gqlDataSender;
+    private analyticsSchema;
+    private analyticsMetadata?;
+    constructor(gqlDataSender: GqlDataSender, analyticsSchema: AnalyticsSchema, analyticsMetadata?: AnalyticsMetadata | null);
+    reportMeasurement({ entity, measurementType, value, relatedEntities }: ReportedMeasurement): Promise<void>;
+}

package/dist/reporting/measurements-reporter.js

@@ -0,0 +1,31 @@
+class MeasurementsReporter {
+    gqlDataSender;
+    analyticsSchema;
+    analyticsMetadata;
+    constructor(gqlDataSender, analyticsSchema, analyticsMetadata) {
+        this.gqlDataSender = gqlDataSender;
+        this.analyticsSchema = analyticsSchema;
+        this.analyticsMetadata = analyticsMetadata;
+    }
+    async reportMeasurement({ entity, measurementType, value, relatedEntities }) {
+        const input = {
+            entityType: entity.type,
+            entityId: entity.id,
+            measurementType,
+            value,
+            relatedEntities: relatedEntities
+                ?.map(({ relationType, entity }) => ({
+                relationType,
+                entityType: entity.type,
+                entityId: entity.id,
+            })) ?? null,
+            installation: this.analyticsMetadata?.installationId
+                ? {
+                    id: this.analyticsMetadata.installationId,
+                } : null,
+        };
+        await this.gqlDataSender.send(this.analyticsSchema.reportMeasurement, { input });
+    }
+}
+
+export { MeasurementsReporter };

package/dist/reporting/report-event.graphql.js

@@ -0,0 +1,3 @@
+var ReportEvent = "mutation ReportEvent($input: ReportEventInput!) {\n  reportEvent(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportEvent as default };

package/dist/reporting/report-external-event.graphql.js

@@ -0,0 +1,3 @@
+var ReportExternalEvent = "mutation ReportExternalEvent($input: ReportExternalEventInput!) {\n  reportExternalEvent(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportExternalEvent as default };

package/dist/reporting/report-external-measurement.graphql.js

@@ -0,0 +1,3 @@
+var ReportExternalMeasurement = "mutation ReportExternalMeasurement($input: ReportExternalMeasurementInput!) {\n  reportExternalMeasurement(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportExternalMeasurement as default };

package/dist/reporting/report-measurement.graphql.js

@@ -0,0 +1,3 @@
+var ReportMeasurement = "mutation ReportMeasurement($input: ReportMeasurementInput!) {\n  reportMeasurement(input: $input) {\n    void\n  }\n}\n";
+
+export { ReportMeasurement as default };

package/dist/reporting/types.d.ts

@@ -0,0 +1,54 @@
+export declare enum EntityType {
+    Article = "ARTICLE",
+    Audio = "AUDIO",
+    Event = "EVENT",
+    Media = "MEDIA",
+    Moment = "MOMENT",
+    Link = "LINK",
+    ShortVideo = "SHORT_VIDEO",
+    Text = "TEXT",
+    Video = "VIDEO",
+    Product = "PRODUCT",
+    Stream = "STREAM",
+    StreamPage = "STREAM_PAGE",
+    Ad = "AD",
+    MediaPage = "MEDIA_PAGE"
+}
+export declare enum EventType {
+    Appeared = "APPEARED",
+    Viewed = "VIEWED",
+    Clicked = "CLICKED"
+}
+export declare enum MeasurementType {
+    ScrollDepth = "SCROLL_DEPTH",
+    EngagementTime = "ENGAGEMENT_TIME",
+    Progress = "PROGRESS"
+}
+export declare enum EntityRelationType {
+    PlacedIn = "PLACED_IN"
+}
+export type AnalyticsSchema = {
+    reportEvent: string;
+    reportMeasurement: string;
+};
+export type AnalyticsMetadata = {
+    installationId?: string | null;
+};
+export type Entity = {
+    type: EntityType;
+    id: string;
+};
+export type EntityRelation = {
+    relationType: EntityRelationType;
+    entity: Entity;
+};
+export type EntityRelationInput = {
+    relationType: EntityRelationType;
+    entityType: EntityType;
+    entityId: string;
+};
+export type InstallationInput = {
+    id: string;
+    device?: string | null;
+    browser?: string | null;
+};

package/dist/reporting/types.js

@@ -0,0 +1,35 @@
+var EntityType;
+(function (EntityType) {
+    EntityType["Article"] = "ARTICLE";
+    EntityType["Audio"] = "AUDIO";
+    EntityType["Event"] = "EVENT";
+    EntityType["Media"] = "MEDIA";
+    EntityType["Moment"] = "MOMENT";
+    EntityType["Link"] = "LINK";
+    EntityType["ShortVideo"] = "SHORT_VIDEO";
+    EntityType["Text"] = "TEXT";
+    EntityType["Video"] = "VIDEO";
+    EntityType["Product"] = "PRODUCT";
+    EntityType["Stream"] = "STREAM";
+    EntityType["StreamPage"] = "STREAM_PAGE";
+    EntityType["Ad"] = "AD";
+    EntityType["MediaPage"] = "MEDIA_PAGE";
+})(EntityType || (EntityType = {}));
+var EventType;
+(function (EventType) {
+    EventType["Appeared"] = "APPEARED";
+    EventType["Viewed"] = "VIEWED";
+    EventType["Clicked"] = "CLICKED";
+})(EventType || (EventType = {}));
+var MeasurementType;
+(function (MeasurementType) {
+    MeasurementType["ScrollDepth"] = "SCROLL_DEPTH";
+    MeasurementType["EngagementTime"] = "ENGAGEMENT_TIME";
+    MeasurementType["Progress"] = "PROGRESS";
+})(MeasurementType || (MeasurementType = {}));
+var EntityRelationType;
+(function (EntityRelationType) {
+    EntityRelationType["PlacedIn"] = "PLACED_IN";
+})(EntityRelationType || (EntityRelationType = {}));
+
+export { EntityRelationType, EntityType, EventType, MeasurementType };

package/dist/schemas.d.ts

@@ -0,0 +1,5 @@
+import type { AnalyticsSchema } from './reporting';
+export declare const Schemas: {
+    internal: AnalyticsSchema;
+    external: AnalyticsSchema;
+};

package/dist/schemas.js

@@ -0,0 +1,17 @@
+import ReportEvent from './graphql/report-event.graphql.js';
+import ReportExternalEvent from './graphql/report-external-event.graphql.js';
+import ReportMeasurement from './graphql/report-measurement.graphql.js';
+import ReportExternalMeasurement from './graphql/report-external-measurement.graphql.js';
+
+const Schemas = {
+    internal: {
+        reportEvent: ReportEvent,
+        reportMeasurement: ReportMeasurement,
+    },
+    external: {
+        reportEvent: ReportExternalEvent,
+        reportMeasurement: ReportExternalMeasurement,
+    },
+};
+
+export { Schemas };

package/dist/types.d.ts

@@ -1,4 +0,0 @@
-export type GqlResponse<T> = {
-    data?: T;
-    errors?: unknown;
-};

package/dist/types.js

@@ -1 +1,39 @@
+var ApiMode;
+(function (ApiMode) {
+    ApiMode["Internal"] = "internal";
+    ApiMode["External"] = "external";
+})(ApiMode || (ApiMode = {}));
+var EntityType;
+(function (EntityType) {
+    EntityType["Article"] = "ARTICLE";
+    EntityType["Audio"] = "AUDIO";
+    EntityType["Event"] = "EVENT";
+    EntityType["Media"] = "MEDIA";
+    EntityType["Moment"] = "MOMENT";
+    EntityType["Link"] = "LINK";
+    EntityType["ShortVideo"] = "SHORT_VIDEO";
+    EntityType["Text"] = "TEXT";
+    EntityType["Video"] = "VIDEO";
+    EntityType["Product"] = "PRODUCT";
+    EntityType["Stream"] = "STREAM";
+    EntityType["StreamPage"] = "STREAM_PAGE";
+    EntityType["Ad"] = "AD";
+})(EntityType || (EntityType = {}));
+var EventType;
+(function (EventType) {
+    EventType["Appeared"] = "APPEARED";
+    EventType["Viewed"] = "VIEWED";
+    EventType["Clicked"] = "CLICKED";
+})(EventType || (EventType = {}));
+var MeasurementType;
+(function (MeasurementType) {
+    MeasurementType["ScrollDepth"] = "SCROLL_DEPTH";
+    MeasurementType["EngagementTime"] = "ENGAGEMENT_TIME";
+    MeasurementType["Progress"] = "PROGRESS";
+})(MeasurementType || (MeasurementType = {}));
+var EntityRelationType;
+(function (EntityRelationType) {
+    EntityRelationType["PlacedIn"] = "PLACED_IN";
+})(EntityRelationType || (EntityRelationType = {}));
 
+export { ApiMode, EntityRelationType, EntityType, EventType, MeasurementType };

package/dist/viewport-visibility-tracker.d.ts

@@ -0,0 +1,13 @@
+export declare class ViewportVisibilityTracker {
+    private trackedIds;
+    private targetToElements;
+    private elementToTargetId;
+    private callbacks;
+    private observer;
+    registerElement(el: HTMLElement, targetId: string, callback: (id: string) => void): void;
+    unregisterElement(el: HTMLElement): void;
+    unregisterAllElements(targetId: string): void;
+    reset(): void;
+    private getObserver;
+    private handleIntersections;
+}

package/dist/viewport-visibility-tracker.js

@@ -0,0 +1,104 @@
+const VISIBILITY_THRESHOLD = 0.5;
+class ViewportVisibilityTracker {
+    trackedIds = new Set();
+    targetToElements = new Map();
+    elementToTargetId = new Map();
+    callbacks = new Map();
+    observer;
+    registerElement(el, targetId, callback) {
+        if (this.trackedIds.has(targetId)) {
+            return;
+        }
+        const set = this.targetToElements.get(targetId) ?? new Set();
+        set.add(el);
+        this.targetToElements.set(targetId, set);
+        this.elementToTargetId.set(el, targetId);
+        this.callbacks.set(targetId, callback);
+        const observer = this.getObserver();
+        observer.observe(el);
+    }
+    unregisterElement(el) {
+        const targetId = this.elementToTargetId.get(el);
+        if (!targetId) {
+            return;
+        }
+        this.getObserver().unobserve(el);
+        this.elementToTargetId.delete(el);
+        const set = this.targetToElements.get(targetId);
+        if (set) {
+            set.delete(el);
+            if (set.size === 0) {
+                this.targetToElements.delete(targetId);
+                this.callbacks.delete(targetId);
+            }
+        }
+    }
+    unregisterAllElements(targetId) {
+        const set = this.targetToElements.get(targetId);
+        if (set) {
+            for (const el of set) {
+                this.getObserver().unobserve(el);
+                this.elementToTargetId.delete(el);
+            }
+        }
+        this.targetToElements.delete(targetId);
+        this.callbacks.delete(targetId);
+    }
+    reset() {
+        for (const set of this.targetToElements.values()) {
+            for (const el of set) {
+                this.getObserver().unobserve(el);
+            }
+        }
+        this.trackedIds.clear();
+        this.targetToElements.clear();
+        this.elementToTargetId.clear();
+        this.callbacks.clear();
+        if (this.observer) {
+            this.observer.disconnect();
+            this.observer = undefined;
+        }
+    }
+    getObserver() {
+        if (!this.observer) {
+            this.observer = new IntersectionObserver(this.handleIntersections.bind(this), {
+                threshold: VISIBILITY_THRESHOLD,
+            });
+        }
+        return this.observer;
+    }
+    handleIntersections(entries) {
+        for (const entry of entries) {
+            const el = entry.target;
+            const targetId = this.elementToTargetId.get(el);
+            if (!targetId) {
+                continue;
+            }
+            if (entry.isIntersecting && entry.intersectionRatio >= VISIBILITY_THRESHOLD) {
+                if (!this.trackedIds.has(targetId)) {
+                    this.trackedIds.add(targetId);
+                    const cb = this.callbacks.get(targetId);
+                    if (cb) {
+                        try {
+                            cb(targetId);
+                        }
+                        catch (err) {
+                            console.error('ViewportVisibilityTracker callback error:', err);
+                        }
+                    }
+                    const set = this.targetToElements.get(targetId);
+                    if (set) {
+                        for (const node of set) {
+                            this.getObserver().unobserve(node);
+                            this.elementToTargetId.delete(node);
+                        }
+                    }
+                    this.targetToElements.delete(targetId);
+                    this.callbacks.delete(targetId);
+                }
+            }
+        }
+    }
+}
+
+export { ViewportVisibilityTracker };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/streams-analytics-collector",
-  "version": "2.0.9",
+  "version": "3.0.0",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -8,12 +8,11 @@
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "types": "./dist/index.d.ts",
-      "svelte": "./dist/index.js"
+      "types": "./dist/index.d.ts"
     },
-    "./analytics": {
-      "import": "./dist/analytics/index.js",
-      "types": "./dist/analytics/index.d.ts"
+    "./reporting": {
+      "import": "./dist/reporting/index.js",
+      "types": "./dist/reporting/index.d.ts"
     }
   },
   "files": [

package/dist/adcampaignsquery.graphql.js

@@ -1,3 +0,0 @@
-var SiteActiveCampaignsQuery = "query SiteActiveCampaigns($filter: SiteActiveCampaignsFilterInput!, $pageQuery: PaginationOfAdCampaignsOrderByInput!) {\n  siteActiveCampaigns(filter: $filter, pagination: $pageQuery) {\n    total\n    items {\n      id\n      name\n      status\n      adGroupIds\n      adGroups {\n        name\n        ads {\n          ..._adForGridPayloadFragment\n        }\n        adPlacement {\n          name\n        }\n      }\n      status\n      updatedAt\n      editorProfile {\n        id\n        name\n        handle\n        image\n      }\n    }\n  }\n}\n\nfragment _adForGridPayloadFragment on Ad {\n  id\n  media {\n    type\n    url\n    thumbnailUrl\n  }\n  name\n  title\n  description\n  status\n  updatedAt\n}\n";
-
-export { SiteActiveCampaignsQuery as default };

package/dist/analytics/ViewportVisibilityTracker.d.ts

@@ -1,46 +0,0 @@
-/**
- * ViewportVisibilityTracker
- *
- * Utility for tracking when DOM elements (e.g., stream tiles) become visible in the viewport.
- * Fires impression events only once per unique element (by streamId) per session/visit.
- * Uses IntersectionObserver for efficient observation, with a fallback to manual visibility checks.
- *
- * Usage:
- *   ViewportVisibilityTracker.registerTile(element, streamId, callback?);
- *
- * - The element must have a unique streamId (e.g., from data-stream-id attribute).
- * - The impression event is fired only once per streamId per session.
- * - Handles rapid scrolling, re-renders, and element replacement.
- * - You can provide a custom callback to be called when the element becomes visible.
- */
-export declare class ViewportVisibilityTracker {
-    private static trackedStreamIds;
-    private static observedElements;
-    private static callbacks;
-    private static observer;
-    /**
-     * Register a tile element for visibility tracking.
-     * @param el The DOM element to observe
-     * @param streamId The unique stream ID for this tile
-     * @param callback Optional callback to call when the element becomes visible (defaults to AppEventsTracker.trackStreamTileImpression)
-     */
-    static registerTile(el: HTMLElement, streamId: string, callback?: (streamId: string) => void): void;
-    /**
-     * Internal: Get or create the IntersectionObserver instance
-     */
-    private static getObserver;
-    /**
-     * Internal: IntersectionObserver callback
-     */
-    private static handleIntersections;
-    /**
-     * Fallback: Check if an element is in the viewport (at least 50% visible)
-     * @param el The DOM element
-     * @returns true if at least 50% of the element is visible
-     */
-    static isElementInViewport(el: HTMLElement): boolean;
-    /**
-     * Reset tracked state (for testing or new session)
-     */
-    static reset(): void;
-}

package/dist/analytics/ViewportVisibilityTracker.js

@@ -1,117 +0,0 @@
-import { AppEventsTracker } from './app-events-tracker.js';
-
-/**
- * ViewportVisibilityTracker
- *
- * Utility for tracking when DOM elements (e.g., stream tiles) become visible in the viewport.
- * Fires impression events only once per unique element (by streamId) per session/visit.
- * Uses IntersectionObserver for efficient observation, with a fallback to manual visibility checks.
- *
- * Usage:
- *   ViewportVisibilityTracker.registerTile(element, streamId, callback?);
- *
- * - The element must have a unique streamId (e.g., from data-stream-id attribute).
- * - The impression event is fired only once per streamId per session.
- * - Handles rapid scrolling, re-renders, and element replacement.
- * - You can provide a custom callback to be called when the element becomes visible.
- */
-class ViewportVisibilityTracker {
-    // Set of streamIds that have already been tracked for impression
-    static trackedStreamIds = new Set();
-    // Map from streamId to the currently observed element
-    static observedElements = new Map();
-    // Map from streamId to the callback to call when visible
-    static callbacks = new Map();
-    // Singleton IntersectionObserver instance
-    static observer = null;
-    /**
-     * Register a tile element for visibility tracking.
-     * @param el The DOM element to observe
-     * @param streamId The unique stream ID for this tile
-     * @param callback Optional callback to call when the element becomes visible (defaults to AppEventsTracker.trackStreamTileImpression)
-     */
-    static registerTile(el, streamId, callback = AppEventsTracker.trackStreamTileImpression.bind(AppEventsTracker)) {
-        if (!el || !streamId)
-            return;
-        // If already tracked, do nothing
-        if (this.trackedStreamIds.has(streamId))
-            return;
-        // If an element for this streamId is already being observed, unobserve it (handles re-renders)
-        const prevEl = this.observedElements.get(streamId);
-        if (prevEl && prevEl !== el) {
-            this.getObserver().unobserve(prevEl);
-        }
-        this.observedElements.set(streamId, el);
-        this.callbacks.set(streamId, callback);
-        this.getObserver().observe(el);
-    }
-    /**
-     * Internal: Get or create the IntersectionObserver instance
-     */
-    static getObserver() {
-        if (!this.observer) {
-            this.observer = new window.IntersectionObserver(this.handleIntersections.bind(this), {
-                threshold: 0.5, // At least 50% of the element must be visible
-            });
-        }
-        return this.observer;
-    }
-    /**
-     * Internal: IntersectionObserver callback
-     */
-    static handleIntersections(entries) {
-        for (const entry of entries) {
-            const el = entry.target;
-            // Try to get streamId from map or from data attribute
-            let streamId = Array.from(this.observedElements.entries()).find(([, v]) => v === el)?.[0];
-            if (!streamId) {
-                streamId = el.getAttribute("data-stream-id") || undefined;
-            }
-            if (!streamId)
-                continue;
-            if (entry.isIntersecting && entry.intersectionRatio >= 0.5) {
-                // Only fire once per streamId per session
-                if (!this.trackedStreamIds.has(streamId)) {
-                    this.trackedStreamIds.add(streamId);
-                    const callback = this.callbacks.get(streamId);
-                    if (callback) {
-                        callback(streamId);
-                    }
-                }
-                // Once tracked, stop observing this element
-                this.getObserver().unobserve(el);
-                this.observedElements.delete(streamId);
-                this.callbacks.delete(streamId);
-            }
-        }
-    }
-    /**
-     * Fallback: Check if an element is in the viewport (at least 50% visible)
-     * @param el The DOM element
-     * @returns true if at least 50% of the element is visible
-     */
-    static isElementInViewport(el) {
-        if (!el)
-            return false;
-        const rect = el.getBoundingClientRect();
-        const windowHeight = window.innerHeight || document.documentElement.clientHeight;
-        const windowWidth = window.innerWidth || document.documentElement.clientWidth;
-        const vertInView = rect.top <= windowHeight * 0.5 && rect.top + rect.height * 0.5 >= 0;
-        const horInView = rect.left <= windowWidth * 0.5 && rect.left + rect.width * 0.5 >= 0;
-        return vertInView && horInView;
-    }
-    /**
-     * Reset tracked state (for testing or new session)
-     */
-    static reset() {
-        this.trackedStreamIds.clear();
-        this.observedElements.clear();
-        this.callbacks.clear();
-        if (this.observer) {
-            this.observer.disconnect();
-            this.observer = null;
-        }
-    }
-}
-
-export { ViewportVisibilityTracker };