@streamscloud/streams-analytics-collector 2.0.0 → 2.0.2

package/dist/adcampaignsquery.graphql.js

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,46 @@
+/**
+ * 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

@@ -0,0 +1,117 @@
+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 };

package/dist/analytics/app-events-tracker.d.ts

@@ -66,10 +66,19 @@ export declare class AppEventsTracker {
      */
     static trackCommunityMessageOpened(messageId: string, status: string): void;
     /**
-     * Track when a stream tile is shown to the user
+     * Track when a stream tile is shown to the user (basic, immediate call).
      * @param streamId - The ID of the stream
      */
     static trackStreamTileImpression(streamId: string): void;
+    /**
+     * Track when a stream tile is shown to the user, using viewport visibility tracking.
+     * The impression event will only be fired if the element becomes visible (at least 50% in viewport).
+     * The event is only fired once per streamId per session/visit.
+     *
+     * @param el - The DOM element to observe (e.g., the stream tile)
+     * @param streamId - The unique stream ID for this tile
+     */
+    static trackStreamTileImpressionWithVisibility(el: HTMLElement, streamId: string): void;
     /**
      * Track when a stream tile is clicked
      * @param streamId - The ID of the stream
@@ -111,6 +120,25 @@ export declare class AppEventsTracker {
      * @deprecated Consider using trackShortVideoProgress and reportPageVideoViews for better tracking of multiple videos
      */
     static trackClosed(postId: string, streamId: string): void;
+    /**
+     * Track when an ad is shown to the user
+     * @param adId - The ID of the ad
+     */
+    static trackAdImpression(adId: string): void;
+    /**
+     * Track when an ad is clicked by the user
+     * @param adId - The ID of the ad
+     */
+    static trackAdClick(adId: string): void;
+    /**
+     * Track when an ad is shown to the user, using viewport visibility tracking.
+     * The impression event will only be fired if the element becomes visible (at least 50% in viewport).
+     * The event is only fired once per adId per session/visit.
+     *
+     * @param el - The DOM element to observe (e.g., the ad element)
+     * @param adId - The unique ad ID for this element
+     */
+    static trackAdImpressionWithVisibility(el: HTMLElement, adId: string): void;
     /**
      * Report an app event to the API
      * @private

package/dist/analytics/app-events-tracker.js

@@ -1,5 +1,6 @@
 import { AppEventType, CommunityMessageStatus } from './types.js';
-import AnalyticsQuery from '../analytics.graphql.js';
+import ExternalTrackAppEvent from '../analytics.graphql.js';
+import { ViewportVisibilityTracker } from './ViewportVisibilityTracker.js';
 
 /**
  * AppEventsTracker is a utility class for tracking various user events in StreamsCloud applications
@@ -114,12 +115,28 @@ class AppEventsTracker {
         }
     }
     /**
-     * Track when a stream tile is shown to the user
+     * Track when a stream tile is shown to the user (basic, immediate call).
      * @param streamId - The ID of the stream
      */
     static trackStreamTileImpression(streamId) {
         this.reportAppEvent(streamId, AppEventType.StreamTileImpression);
     }
+    /**
+     * Track when a stream tile is shown to the user, using viewport visibility tracking.
+     * The impression event will only be fired if the element becomes visible (at least 50% in viewport).
+     * The event is only fired once per streamId per session/visit.
+     *
+     * @param el - The DOM element to observe (e.g., the stream tile)
+     * @param streamId - The unique stream ID for this tile
+     */
+    static trackStreamTileImpressionWithVisibility(el, streamId) {
+        if (!el || !streamId)
+            return;
+        ViewportVisibilityTracker.registerTile(el, streamId, (sid) => {
+            this.reportAppEvent(sid, AppEventType.StreamTileImpression);
+        });
+        // The ViewportVisibilityTracker will call the callback when visible
+    }
     /**
      * Track when a stream tile is clicked
      * @param streamId - The ID of the stream
@@ -186,6 +203,36 @@ class AppEventsTracker {
             this.reported.splice(postIndex, 1);
         }
     }
+    /**
+     * Track when an ad is shown to the user
+     * @param adId - The ID of the ad
+     */
+    static trackAdImpression(adId) {
+        this.reportAppEvent(adId, AppEventType.AdImpression);
+    }
+    /**
+     * Track when an ad is clicked by the user
+     * @param adId - The ID of the ad
+     */
+    static trackAdClick(adId) {
+        this.reportAppEvent(adId, AppEventType.AdClick);
+    }
+    /**
+     * Track when an ad is shown to the user, using viewport visibility tracking.
+     * The impression event will only be fired if the element becomes visible (at least 50% in viewport).
+     * The event is only fired once per adId per session/visit.
+     *
+     * @param el - The DOM element to observe (e.g., the ad element)
+     * @param adId - The unique ad ID for this element
+     */
+    static trackAdImpressionWithVisibility(el, adId) {
+        if (!el || !adId)
+            return;
+        ViewportVisibilityTracker.registerTile(el, adId, (aid) => {
+            this.reportAppEvent(aid, AppEventType.AdImpression);
+        });
+        // The ViewportVisibilityTracker will call the callback when visible
+    }
     /**
      * Report an app event to the API
      * @private
@@ -230,7 +277,7 @@ class AppEventsTracker {
                 return;
             }
             await this.client
-                .mutation(AnalyticsQuery, { input })
+                .mutation(ExternalTrackAppEvent, { input })
                 .toPromise();
         }
         else {
@@ -238,7 +285,7 @@ class AppEventsTracker {
                 console.warn('An attempt to save app event without initializing GraphQL endpoint detected');
                 return;
             }
-            await this.queryGql(AnalyticsQuery, { input });
+            await this.queryGql(ExternalTrackAppEvent, { input });
         }
     }
     static queryGql = async (query, variables) => {

package/dist/analytics/index.d.ts

@@ -1,2 +1,3 @@
 export { AppEventsTracker } from './app-events-tracker';
 export { AppEventType, CommunityMessageStatus, type TrackAppEventInput } from './types';
+export * from './ViewportVisibilityTracker';

package/dist/analytics/index.js

@@ -1,2 +1,3 @@
 export { AppEventsTracker } from './app-events-tracker.js';
 export { AppEventType, CommunityMessageStatus } from './types.js';
+export { ViewportVisibilityTracker } from './ViewportVisibilityTracker.js';

package/dist/analytics/types.d.ts

@@ -8,7 +8,9 @@ export declare enum AppEventType {
     StreamEngagementTime = "STREAM_ENGAGEMENT_TIME",
     StreamScrollDepth = "STREAM_SCROLL_DEPTH",
     StreamPageView = "STREAM_PAGE_VIEW",
-    StreamProductClick = "STREAM_PRODUCT_CLICK"
+    StreamProductClick = "STREAM_PRODUCT_CLICK",
+    AdImpression = "AD_IMPRESSION",
+    AdClick = "AD_CLICK"
 }
 export declare enum CommunityMessageStatus {
     Sent = "SENT",

package/dist/analytics/types.js

@@ -10,6 +10,8 @@ var AppEventType;
     AppEventType["StreamScrollDepth"] = "STREAM_SCROLL_DEPTH";
     AppEventType["StreamPageView"] = "STREAM_PAGE_VIEW";
     AppEventType["StreamProductClick"] = "STREAM_PRODUCT_CLICK";
+    AppEventType["AdImpression"] = "AD_IMPRESSION";
+    AppEventType["AdClick"] = "AD_CLICK";
 })(AppEventType || (AppEventType = {}));
 var CommunityMessageStatus;
 (function (CommunityMessageStatus) {

package/dist/analytics.graphql.js

@@ -1,3 +1,3 @@
-var AnalyticsQuery = "mutation TrackAppEvent($input: ExternalTrackAppEventInput!) {\n  externalTrackAppEvent(input: $input) {\n    void\n  }\n}\n";
+var ExternalTrackAppEvent = "mutation ExternalTrackAppEvent($input: ExternalTrackAppEventInput!) {\n  externalTrackAppEvent(input: $input) {\n    void\n  }\n}\n\nmutation TrackAppEvent($input: TrackAppEventInput!) {\n  trackAppEvent(input: $input) {\n    void\n  }\n}\n";
 
-export { AnalyticsQuery as default };
+export { ExternalTrackAppEvent as default };

package/dist/articlequery.graphql.js

@@ -0,0 +1,3 @@
+var SiteArticleQuery = "query SiteArticle($organizationId: String!, $slug: String!) {\n  siteArticle(filter: { organizationId: $organizationId, slug: $slug }) {\n    ...ArticleFragment\n  }\n}\n\nfragment ArticleFragment on Article {\n  id\n  postId\n  slug\n  publishedAt\n  mainImage(scale: ORIGINAL_ENCODED)\n  sections {\n    ...ArticleSectionPayloadFragment\n  }\n}\n\nfragment ArticleSectionPayloadFragment on ArticleSection {\n  id\n  isContentEditable\n  styles {\n    paddingBottom\n    paddingTop\n    paddingLeft\n    paddingRight\n  }\n  layouts {\n    ..._ArticleLayoutPayloadFragment\n  }\n}\n\nfragment _ArticleLayoutPayloadFragment on ArticleLayout {\n  id\n  type\n  styles {\n    paddingBottom\n    paddingTop\n    paddingLeft\n    paddingRight\n  }\n  fields {\n    ..._ArticleFieldPayloadFragment\n  }\n}\n\nfragment _ArticleFieldPayloadFragment on ArticleField {\n  id\n  name\n  description\n  fieldData {\n    type\n    bylineData {\n      ..._BylineFieldDataPayloadFragment\n    }\n    imageData {\n      ..._ImageFieldDataPayloadFragment\n    }\n    mediaData {\n      ..._MediaFieldDataPayloadFragment\n    }\n    mediaGalleryData {\n      ..._MediaGalleryFieldDataPayloadFragment\n    }\n    richTextData {\n      ..._RichTextFieldDataPayloadFragment\n    }\n    textData {\n      ..._TextFieldDataPayloadFragment\n    }\n    videoData {\n      ..._VideoFieldDataPayloadFragment\n    }\n  }\n}\n\nfragment _BylineFieldDataPayloadFragment on BylineFieldData {\n  authorName\n}\n\nfragment _ImageFieldDataPayloadFragment on ImageFieldData {\n  image {\n    ...MediaItemPayloadFragment\n  }\n  preferredMediaFormat\n}\n\nfragment _MediaFieldDataPayloadFragment on MediaFieldData {\n  media {\n    ...MediaItemPayloadFragment\n  }\n  preferredMediaFormat\n}\n\nfragment _MediaGalleryFieldDataPayloadFragment on MediaGalleryFieldData {\n  media {\n    ...MediaItemPayloadFragment\n  }\n  galleryMode\n  preferredMediaFormat\n}\n\nfragment _RichTextFieldDataPayloadFragment on RichTextFieldData {\n  text\n  textSize\n}\n\nfragment _TextFieldDataPayloadFragment on TextFieldData {\n  text\n  textMode\n  textSize\n  textWeight\n}\n\nfragment _VideoFieldDataPayloadFragment on VideoFieldData {\n  video {\n    ...MediaItemPayloadFragment\n  }\n  preferredMediaFormat\n}\n\nfragment MediaItemPayloadFragment on MediaItem {\n  url(scale: ORIGINAL_ENCODED)\n  thumbnailUrl(scale: ORIGINAL_ENCODED)\n  type\n  metadata {\n    ...MediaItemMetadataPayloadFragment\n  }\n}\n\nfragment MediaItemMetadataPayloadFragment on MediaItemMetadata {\n  fileName\n  width\n  height\n  durationSec\n}\n";
+
+export { SiteArticleQuery as default };

package/dist/components/index.d.ts

@@ -0,0 +1,2 @@
+export { DataType, ParameterType } from './types';
+export type { ComponentProps, ParameterValue, Parameters } from './types';

package/dist/components/index.js

@@ -0,0 +1 @@
+export { DataType, ParameterType } from './types.js';

package/dist/components/types.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentData } from '../components-data';
+export declare const DataType: {
+    Stream: string;
+    ShortVideo: string;
+};
+export declare const ParameterType: {
+    String: string;
+    Text: string;
+    Number: string;
+    Color: string;
+};
+export type ParameterValue = unknown;
+export type Parameters = {
+    [key: string]: ParameterValue;
+};
+export type ComponentProps = {
+    parameters?: Parameters;
+    data?: ComponentData;
+};

package/dist/components/types.js

@@ -0,0 +1,12 @@
+const DataType = {
+    Stream: 'STREAM',
+    ShortVideo: 'SHORT_VIDEO'
+};
+const ParameterType = {
+    String: 'STRING',
+    Text: 'TEXT',
+    Number: 'NUMBER',
+    Color: 'COLOR'
+};
+
+export { DataType, ParameterType };

package/dist/components-data/component-data-provider.service.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentData, ComponentDataProvider, ComponentsData, DataParameters } from './types';
+export declare const createComponentDataProvider: (componentsData?: ComponentsData, preserveOriginalData?: boolean) => ComponentDataProvider;
+export declare const getComponentData: (componentsData?: ComponentsData, parameters?: DataParameters) => ComponentData;

package/dist/components-data/component-data-provider.service.js

@@ -0,0 +1,35 @@
+const createComponentDataProvider = (componentsData, preserveOriginalData = false) => {
+    if (preserveOriginalData) {
+        componentsData = structuredClone(componentsData);
+    }
+    return {
+        getData: (parameters) => getComponentData(componentsData, parameters)
+    };
+};
+const getComponentData = (componentsData, parameters) => {
+    const result = {};
+    if (!componentsData) {
+        return result;
+    }
+    if (!parameters) {
+        return result;
+    }
+    for (const [dataType, params] of Object.entries(parameters)) {
+        if (!params) {
+            continue;
+        }
+        const data = componentsData[dataType];
+        if (!data) {
+            continue;
+        }
+        result[dataType] = getModels(data, params);
+    }
+    return result;
+};
+const getModels = (content, ids) => ids.length
+    ? content
+        .filter((x) => ids.includes(x.id))
+        .sort((a, b) => ids.indexOf(a.id) - ids.indexOf(b.id))
+    : [];
+
+export { createComponentDataProvider, getComponentData };

package/dist/components-data/components-data-fetcher.service.d.ts

@@ -0,0 +1,5 @@
+import { EmbedContentApiClient } from '../services';
+import { ComponentsData, ComponentsDataParameters } from './types';
+export declare const createComponentsDataFetcher: (client: EmbedContentApiClient) => {
+    fetch: (dataParameters: ComponentsDataParameters) => Promise<ComponentsData>;
+};

package/dist/components-data/components-data-fetcher.service.js

@@ -0,0 +1,35 @@
+import { getShortVideosDataLoader } from '../data-loaders/short-videos-data-loader/loader.js';
+import { getStreamsDataLoader } from '../data-loaders/streams-data-loader/loader.js';
+import { DataType } from './types.js';
+
+const createComponentsDataFetcher = (client) => {
+    const loadersMap = new Map([
+        [DataType.ShortVideo, getShortVideosDataLoader(client)],
+        [DataType.Stream, getStreamsDataLoader(client)]
+    ]);
+    return {
+        fetch: async (dataParameters) => {
+            const result = {};
+            const fetchActions = [];
+            for (const [dataType, params] of Object.entries(dataParameters)) {
+                if (!params) {
+                    continue;
+                }
+                const loader = loadersMap.get(dataType);
+                if (!loader) {
+                    continue;
+                }
+                fetchActions.push((async () => {
+                    result[dataType] = await loadContent(loader, params);
+                })());
+            }
+            await Promise.all(fetchActions);
+            return result;
+        }
+    };
+};
+const loadContent = async (dataLoader, contentParameters) => {
+    return contentParameters.ids.length ? await dataLoader.load(contentParameters.ids) : [];
+};
+
+export { createComponentsDataFetcher };

package/dist/components-data/components-data-parameters-reader.service.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentsDataParameters, DataParameters } from './types';
+export declare const getComponentsDataParameters: (parameters: DataParameters[]) => ComponentsDataParameters;

package/dist/components-data/components-data-parameters-reader.service.js

@@ -0,0 +1,20 @@
+const getComponentsDataParameters = (parameters) => {
+    const result = {};
+    const params = parameters
+        .flatMap((x) => Object.entries(x).filter(([_, v]) => Array.isArray(v)).map(([t, v]) => ({ type: t, value: v })));
+    const dataTypes = [...new Set(params.map(x => x.type))];
+    for (const dataType of dataTypes) {
+        result[dataType] = {
+            ids: getIds(params, dataType),
+        };
+    }
+    return result;
+};
+const getIds = (parameters, dataType) => [
+    ...new Set(parameters
+        .filter((x) => x.type === dataType && typeof Array.isArray(x.value))
+        .map((x) => x.value)
+        .flatMap((x) => x))
+];
+
+export { getComponentsDataParameters };

package/dist/components-data/index.d.ts

@@ -0,0 +1,4 @@
+export type { ComponentDataProvider, ComponentsData, ComponentsDataParameters, ContentParameters, ComponentData, ComponentDataModel, DataParameters } from './types';
+export { createComponentDataProvider } from './component-data-provider.service';
+export { createComponentsDataFetcher } from './components-data-fetcher.service';
+export { getComponentsDataParameters } from './components-data-parameters-reader.service';

package/dist/components-data/index.js

@@ -0,0 +1,3 @@
+export { createComponentDataProvider } from './component-data-provider.service.js';
+export { createComponentsDataFetcher } from './components-data-fetcher.service.js';
+export { getComponentsDataParameters } from './components-data-parameters-reader.service.js';

package/dist/components-data/types.d.ts

@@ -0,0 +1,24 @@
+import { ShortVideoModel, StreamModel } from '../data-loaders';
+export declare const DataType: {
+    ShortVideo: string;
+    Stream: string;
+};
+export type ComponentsDataParameters = {
+    [key: string]: ContentParameters | undefined;
+};
+export type ContentParameters = {
+    ids: string[];
+};
+export type ComponentsData = {
+    [key: string]: ComponentDataModel[];
+};
+export type ComponentDataModel = ShortVideoModel | StreamModel;
+export type DataParameters = {
+    [key: string]: string[] | undefined;
+};
+export type ComponentData = {
+    [key: string]: ComponentDataModel[] | undefined;
+};
+export type ComponentDataProvider = {
+    getData: (parameters?: DataParameters) => ComponentData;
+};

package/dist/components-data/types.js

@@ -0,0 +1,6 @@
+const DataType = {
+    ShortVideo: 'SHORT_VIDEO',
+    Stream: 'STREAM'
+};
+
+export { DataType };

package/dist/contentlistsquery.graphql.js

@@ -0,0 +1,3 @@
+var SiteContentListsQuery = "query SiteContentLists($cursor: CursorOfSiteContentListsOrderByInput!, $filter: SiteContentListsFilterInput!) {\n  siteContentLists(cursor: $cursor, filter: $filter) {\n    items {\n      ...ContentListFragment\n    }\n  }\n}\n\nfragment ContentListFragment on ContentList {\n  id\n  name\n}\n";
+
+export { SiteContentListsQuery as default };

package/dist/data-loaders/index.d.ts

@@ -0,0 +1,2 @@
+export { getShortVideosDataLoader, type ShortVideoModel } from './short-videos-data-loader';
+export { getStreamsDataLoader, type StreamModel } from './streams-data-loader';

package/dist/data-loaders/index.js

@@ -0,0 +1,2 @@
+export { getShortVideosDataLoader } from './short-videos-data-loader/loader.js';
+export { getStreamsDataLoader } from './streams-data-loader/loader.js';

package/dist/data-loaders/short-videos-data-loader/index.d.ts

@@ -0,0 +1,2 @@
+export { getShortVideosDataLoader } from './loader';
+export type { ShortVideoModel } from './types';

package/dist/data-loaders/short-videos-data-loader/loader.d.ts

@@ -0,0 +1,4 @@
+import { ShortVideoModel } from './types';
+import { EmbedContentApiClient } from '../../services';
+import { DataLoader } from '../types';
+export declare const getShortVideosDataLoader: (client: EmbedContentApiClient) => DataLoader<ShortVideoModel>;

package/dist/data-loaders/short-videos-data-loader/loader.js

@@ -0,0 +1,14 @@
+import { mapToSiteShortVideoModels } from './mapper.js';
+
+const getShortVideosDataLoader = (client) => ({
+    async load(ids) {
+        const posts = await client.getPosts(ids);
+        if (!posts) {
+            console.error('Failed to fetch site short video posts: Null-payload received', posts);
+            return [];
+        }
+        return mapToSiteShortVideoModels(posts);
+    },
+});
+
+export { getShortVideosDataLoader };

package/dist/data-loaders/short-videos-data-loader/mapper.d.ts

@@ -0,0 +1,3 @@
+import type { ShortVideoModel } from './types';
+import { Post } from '../../services/types';
+export declare const mapToSiteShortVideoModels: (posts: Post[]) => ShortVideoModel[];

package/dist/data-loaders/short-videos-data-loader/mapper.js

@@ -0,0 +1,27 @@
+const mapToSiteShortVideoModels = (posts) => {
+    return posts.map((post) => {
+        const shortVideo = {
+            id: post.id,
+            displayDate: post.postHeading.postDisplayDate,
+            authorName: post.postHeading.sourceName,
+            authorImage: post.postHeading.sourceImage ?? '',
+            authorType: post.postHeading.sourceType,
+            viewsCount: post.postHeading.postViewsCount,
+            reactionsCount: post.social?.reactions.total ?? 0,
+            commentsCount: post.social?.commentsCount ?? 0,
+            sharesCount: post.social?.sharesCount ?? 0,
+            text: post.postData.shortVideoData.text ?? '',
+            media: post.postData.media.map((x) => {
+                const media = {
+                    type: x.type,
+                    url: x.url,
+                    thumbnailUrl: x.thumbnailUrl
+                };
+                return media;
+            })
+        };
+        return shortVideo;
+    });
+};
+
+export { mapToSiteShortVideoModels };

package/dist/data-loaders/short-videos-data-loader/types.d.ts

@@ -0,0 +1,14 @@
+import type { Media } from '../../services/types';
+export interface ShortVideoModel {
+    id: string;
+    text: string;
+    authorName: string;
+    authorImage: string;
+    authorType: string;
+    displayDate: string;
+    viewsCount: number;
+    reactionsCount: number;
+    commentsCount: number;
+    sharesCount: number;
+    media: Media[];
+}

package/dist/data-loaders/streams-data-loader/index.d.ts

@@ -0,0 +1,2 @@
+export { getStreamsDataLoader } from './loader';
+export type { StreamModel } from './types';

package/dist/data-loaders/streams-data-loader/loader.d.ts

@@ -0,0 +1,4 @@
+import { EmbedContentApiClient } from '../../services';
+import { DataLoader } from '../types';
+import { StreamModel } from './types';
+export declare const getStreamsDataLoader: (client: EmbedContentApiClient) => DataLoader<StreamModel>;

package/dist/data-loaders/streams-data-loader/loader.js

@@ -0,0 +1,14 @@
+import { mapToStreamModels } from './mapper.js';
+
+const getStreamsDataLoader = (client) => ({
+    async load(ids) {
+        const streams = await client.getStreams(ids);
+        if (!streams) {
+            console.error('Failed to fetch site short video posts: Null-payload received', streams);
+            return [];
+        }
+        return mapToStreamModels(streams);
+    },
+});
+
+export { getStreamsDataLoader };

package/dist/data-loaders/streams-data-loader/mapper.d.ts

@@ -0,0 +1,3 @@
+import { StreamModel } from './types';
+import type { Stream } from '../../services/types';
+export declare const mapToStreamModels: (streams: Stream[]) => StreamModel[];

package/dist/data-loaders/streams-data-loader/mapper.js

@@ -0,0 +1,11 @@
+const mapToStreamModels = (streams) => {
+    return streams.map((s) => {
+        const stream = {
+            id: s.id,
+            cover: s.cover.url
+        };
+        return stream;
+    });
+};
+
+export { mapToStreamModels };

package/dist/data-loaders/streams-data-loader/types.d.ts

@@ -0,0 +1,4 @@
+export interface StreamModel {
+    id: string;
+    cover: string;
+}

package/dist/data-loaders/types.d.ts

@@ -0,0 +1,3 @@
+export interface DataLoader<T> {
+    load: (ids: string[]) => Promise<T[]>;
+}

package/dist/postsquery.graphql.js

@@ -0,0 +1,3 @@
+var SitePostsQuery = "query SitePosts($cursor: CursorOfSitePostsOrderByInput!, $filter: SitePostsFilterInput!) {\n  sitePosts(cursor: $cursor, filter: $filter) {\n    items {\n      ...PostItemFragment\n    }\n  }\n}\n\nfragment PostItemFragment on Post {\n  id\n  postType\n  postData {\n    media {\n      ...ContentMediaItemPayloadFragment\n      ...ContentMediaItemTagsPayloadFragment\n    }\n    audioData {\n      text\n    }\n    eventData {\n      title\n      text\n      location {\n        latitude\n        longitude\n        name\n      }\n      startDateTime\n      endDateTime\n    }\n    mediaData {\n      text\n    }\n    momentData {\n      text\n    }\n    linkData {\n      text\n      linkData {\n        ...LinkViewPayloadFragment\n      }\n    }\n    shortVideoData {\n      text\n    }\n    articleData {\n      title\n      kicker\n      article {\n        slug\n      }\n    }\n    textData {\n      text\n    }\n    videoData {\n      title\n      text\n    }\n  }\n  postHeading {\n    ...PostHeadingPayloadFragment\n  }\n}\n\nfragment ContentMediaItemPayloadFragment on ContentMediaItem {\n  url(scale: ORIGINAL_ENCODED)\n  thumbnailUrl(scale: ORIGINAL_ENCODED)\n  type\n  metadata {\n    ...MediaItemMetadataPayloadFragment\n  }\n}\n\nfragment MediaItemMetadataPayloadFragment on MediaItemMetadata {\n  fileName\n  width\n  height\n  durationSec\n}\n\nfragment ContentMediaItemTagsPayloadFragment on ContentMediaItem {\n  productTags {\n    ...ProductTagPositionPayloadFragment\n  }\n  userTags {\n    ...UserTagPositionPayloadFragment\n  }\n  mediaPageTags {\n    ...MediaPageTagPositionPayloadFragment\n  }\n}\n\nfragment ProductTagPositionPayloadFragment on ProductTagPosition {\n  itemId\n  leftPCT\n  topPCT\n  product {\n    id\n    name\n    image\n    price\n    currency\n  }\n}\n\nfragment UserTagPositionPayloadFragment on UserTagPosition {\n  itemId\n  leftPCT\n  topPCT\n  user {\n    id\n    name\n    image\n    username\n  }\n}\n\nfragment MediaPageTagPositionPayloadFragment on MediaPageTagPosition {\n  itemId\n  leftPCT\n  topPCT\n  mediaPage {\n    id\n    name\n    image\n    handle\n  }\n}\n\nfragment LinkViewPayloadFragment on LinkData {\n  hideImage\n  host\n  text\n  title\n  url\n  media {\n    url\n    thumbnailUrl\n    type\n  }\n}\n\nfragment PostHeadingPayloadFragment on PostHeading {\n  sourceId\n  sourceName\n  sourceImage\n  sourceHandle\n  sourceType\n  postDisplayDate\n  postViewsCount\n}\n";
+
+export { SitePostsQuery as default };

package/dist/services/embed-content-api-client.d.ts

@@ -0,0 +1,8 @@
+import type { Post, Stream } from './types';
+export declare class EmbedContentApiClient {
+    private readonly gqlEndpoint;
+    constructor(gqlEndpoint: string);
+    getPosts(ids: string[]): Promise<Post[] | undefined>;
+    getStreams(ids: string[]): Promise<Stream[] | undefined>;
+    private queryGql;
+}

package/dist/services/embed-content-api-client.js

@@ -0,0 +1,48 @@
+import EmbedPostsQuery from './operations/posts-query.graphql.js';
+import EmbedStreamsQuery from './operations/streams-query.graphql.js';
+
+class EmbedContentApiClient {
+    gqlEndpoint;
+    constructor(gqlEndpoint) {
+        this.gqlEndpoint = gqlEndpoint;
+    }
+    async getPosts(ids) {
+        const response = await this.queryGql(EmbedPostsQuery, {
+            input: {
+                filter: {
+                    ids: ids
+                }
+            }
+        });
+        return response.embedPosts?.items;
+    }
+    async getStreams(ids) {
+        const response = await this.queryGql(EmbedStreamsQuery, {
+            input: {
+                filter: {
+                    ids: ids
+                }
+            }
+        });
+        return response.embedStreams?.items;
+    }
+    queryGql = async (query, variables) => {
+        const response = await fetch(this.gqlEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                query,
+                variables
+            })
+        });
+        const gql = await response.json();
+        if (!gql.data) {
+            throw new Error(JSON.stringify(gql.errors));
+        }
+        return gql.data;
+    };
+}
+
+export { EmbedContentApiClient };

package/dist/services/embed-content-client.service.d.ts

@@ -0,0 +1,2 @@
+import { EmbedContentApiClient } from './embed-content-api-client';
+export declare const createEmbedContentClient: (endpointUrl: string) => EmbedContentApiClient;

package/dist/services/embed-content-client.service.js

@@ -0,0 +1,5 @@
+import { EmbedContentApiClient } from './embed-content-api-client.js';
+
+const createEmbedContentClient = (endpointUrl) => new EmbedContentApiClient(endpointUrl);
+
+export { createEmbedContentClient };

package/dist/services/index.d.ts

@@ -0,0 +1,2 @@
+export { EmbedContentApiClient } from './embed-content-api-client';
+export { createEmbedContentClient } from './embed-content-client.service';

package/dist/services/index.js

@@ -0,0 +1,2 @@
+export { EmbedContentApiClient } from './embed-content-api-client.js';
+export { createEmbedContentClient } from './embed-content-client.service.js';

package/dist/services/operations/posts-query.graphql.js

@@ -0,0 +1,3 @@
+var EmbedPostsQuery = "query EmbedPosts($input: EmbedPostsInput!) {\n  embedPosts(input: $input) {\n    items {\n      id\n      postHeading {\n        postDisplayDate\n        postViewsCount\n        sourceId\n        sourceImage\n        sourceName\n        sourceType\n      }\n      social {\n        commentsCount\n        sharesCount\n        reactions {\n          total\n        }\n      }\n      postData {\n        postType\n        media {\n          thumbnailUrl(scale: ORIGINAL_ENCODED)\n          url(scale: ORIGINAL_ENCODED)\n          type\n        }\n        shortVideoData {\n          text\n        }\n      }\n    }\n  }\n}";
+
+export { EmbedPostsQuery as default };

package/dist/services/operations/streams-query.graphql.js

@@ -0,0 +1,3 @@
+var EmbedStreamsQuery = "query EmbedStreams($input: EmbedStreamsInput!) {\n  embedStreams(input: $input) {\n    items {\n      id\n      cover {\n        url\n      }\n    }\n    continuationToken\n  }\n}";
+
+export { EmbedStreamsQuery as default };

package/dist/services/types.d.ts

@@ -0,0 +1,303 @@
+import { MediaItem } from '../types';
+export type EmbedContentApiClientModel = {
+    streamsGqlEndpoint: string;
+};
+export type EmbedPostsInput = {
+    filter: EmbedPostsFilterInput;
+};
+export type EmbedStreamsInput = {
+    filter: EmbedPostsFilterInput;
+};
+export interface Media {
+    type: MediaType;
+    url: string;
+    thumbnailUrl: string | null;
+}
+export type EmbedPostsFilterInput = {
+    ids: string[];
+};
+export type EmbedPostsData = {
+    embedPosts: CursorResultOfPost;
+};
+export type EmbedStreamsFilterInput = {
+    ids: string[];
+};
+export type EmbedStreamsData = {
+    embedStreams: CursorResultOfStreams;
+};
+export type GqlResponse<T> = {
+    data?: T;
+    errors?: unknown;
+};
+export type ContentMediaItem = IMediaItem & {
+    blobId: string;
+    mediaPageTags?: MediaPageTagPosition[];
+    metadata: MediaItemMetadata;
+    thumbnailBlobId?: string;
+    thumbnailUrl: string | null;
+    type: MediaType;
+    url: string;
+    userTags?: UserTagPosition[];
+};
+export type CtaButton = {
+    background: string;
+    border: string;
+    text: string;
+    textColor: string;
+    url: string;
+};
+export type IMediaItem = {
+    blobId: string;
+    metadata: MediaItemMetadata;
+    thumbnailBlobId?: string;
+    thumbnailUrl?: string;
+    type: MediaType;
+    url: string;
+};
+export declare enum MediaFormat {
+    W4H3 = "W4H3",
+    W16H9 = "W16H9"
+}
+export type MediaItemMetadata = {
+    durationSec?: number;
+    fileName?: string;
+    height: number;
+    width: number;
+};
+export type MediaPageTag = {
+    handle: string;
+    id: string;
+    image?: string;
+    name: string;
+};
+export type MediaPageTagPosition = TagPosition & {
+    itemId: string;
+    leftPCT: number;
+    mediaPage?: MediaPageTag;
+    topPCT: number;
+};
+export type MediaPostData = {
+    ctaButton?: CtaButton;
+    preferredMediaFormat: MediaFormat;
+    text?: string;
+};
+export declare enum MediaType {
+    Audio = "AUDIO",
+    Image = "IMAGE",
+    ShortVideo = "SHORT_VIDEO",
+    Video = "VIDEO"
+}
+export type MomentInfo = {
+    author: Profile;
+    cover: string;
+    displayDate: Date;
+    id: string;
+    isSeen: boolean;
+    text?: string;
+};
+export declare enum MomentLifetime {
+    Day = "DAY",
+    Week = "WEEK"
+}
+export type MomentPostData = {
+    lifetime: MomentLifetime;
+    text?: string;
+};
+export type MomentsContainerInfo = {
+    hideIfNoMoments: boolean;
+    image?: ScaledImageBlob;
+    momentsEnabled: boolean;
+    primaryColor?: string;
+    targetId: string;
+    targetType: PublishTargetType;
+    useImageAsMomentsCover: boolean;
+};
+export type MomentsInfo = {
+    containerInfo: MomentsContainerInfo;
+    moments: MomentInfo[];
+    unseenMomentsCount: number;
+};
+export type CursorResultOfStreams = {
+    continuationToken?: string;
+    items: Stream[];
+};
+export type CursorResultOfPost = {
+    continuationToken?: string;
+    items: Post[];
+};
+export type Post = {
+    authorProfile: Profile;
+    createdAt: Date;
+    createdBy: string;
+    displayDate: Date;
+    editorProfile: Profile;
+    enableSocialInteractions: boolean;
+    expiresOn?: Date;
+    generatedName: string;
+    id: string;
+    isPinned: boolean;
+    isSeen: boolean;
+    language: string;
+    mainImage?: string;
+    ownerProfile: Profile;
+    postData: PostData;
+    postHeading: PostHeading;
+    postProfile: Profile;
+    postType: PostType;
+    publishedTo?: PublishTarget;
+    scheduledOn?: Date;
+    sharesCount: number;
+    showInFeed: boolean;
+    social?: PostSocialInteractions;
+    status: Status;
+    updatedAt: Date;
+    updatedBy: string;
+    userReaction?: Reaction;
+    viewsCount: number;
+};
+export type PostData = {
+    media: ContentMediaItem[];
+    mediaData?: MediaPostData;
+    momentData?: MomentPostData;
+    postType: PostType;
+    shortVideoData?: ShortVideoPostData;
+    textData?: TextPostData;
+    videoData?: VideoPostData;
+};
+export type PostHeading = {
+    networkData?: PostHeadingNetworkTargetData;
+    postDisplayDate: string;
+    postViewsCount: number;
+    sourceHandle: string;
+    sourceId: string;
+    sourceImage?: string;
+    sourceIsRemoved: boolean;
+    sourceName: string;
+    sourceType: PostSourceType;
+    wasModified: boolean;
+};
+export type PostHeadingNetworkTargetData = {
+    momentsInfo: MomentsInfo;
+    primaryColor?: string;
+};
+export type PostSocialInteractions = {
+    commentsCount: number;
+    reactions: ReactionsCount;
+    sharesCount: number;
+};
+export declare enum PostSourceType {
+    Channel = "CHANNEL",
+    Group = "GROUP",
+    MediaPage = "MEDIA_PAGE",
+    Organization = "ORGANIZATION",
+    UserProfile = "USER_PROFILE"
+}
+export declare enum PostType {
+    Article = "ARTICLE",
+    Audio = "AUDIO",
+    Event = "EVENT",
+    Link = "LINK",
+    Media = "MEDIA",
+    Moment = "MOMENT",
+    ShortVideo = "SHORT_VIDEO",
+    Text = "TEXT",
+    Video = "VIDEO"
+}
+export type Profile = {
+    __typename?: 'Profile';
+    handle: string;
+    id: string;
+    image?: string;
+    isRemoved: boolean;
+    name: string;
+    type: ProfileType;
+};
+export declare enum ProfileType {
+    Channel = "CHANNEL",
+    Group = "GROUP",
+    Organization = "ORGANIZATION",
+    User = "USER"
+}
+export type PublishTarget = {
+    enableMoments: boolean;
+    enablePostsSocialInteractionsByDefault: boolean;
+    id: string;
+    image?: string;
+    isRemoved: boolean;
+    momentsLifetime: MomentLifetime;
+    name: string;
+    primaryColor?: string;
+    targetContentOwnerProfile?: Profile;
+    type: PublishTargetType;
+};
+export declare enum PublishTargetType {
+    Channel = "CHANNEL",
+    Group = "GROUP",
+    MediaPage = "MEDIA_PAGE",
+    User = "USER"
+}
+export declare enum ReactableType {
+    ChatMessage = "CHAT_MESSAGE",
+    Comment = "COMMENT",
+    CommunityMessage = "COMMUNITY_MESSAGE",
+    Post = "POST"
+}
+export type Reaction = {
+    code: string;
+    id: string;
+    reactableId: string;
+    reactableType: ReactableType;
+    userProfile: Profile;
+};
+export type ReactionCodeCount = {
+    code: string;
+    count: number;
+};
+export type ReactionsCount = {
+    perCode: ReactionCodeCount[];
+    total: number;
+};
+export type ScaledImageBlob = {
+    id: string;
+    url: string;
+};
+export type ShortVideoPostData = {
+    text?: string;
+};
+export declare enum Status {
+    Archived = "ARCHIVED",
+    Draft = "DRAFT",
+    Published = "PUBLISHED",
+    Scheduled = "SCHEDULED"
+}
+export type Stream = {
+    id: string;
+    cover: MediaItem;
+};
+export type TagPosition = {
+    itemId: string;
+    leftPCT: number;
+    topPCT: number;
+};
+export type TextPostData = {
+    ctaButton?: CtaButton;
+    text: string;
+};
+export type UserTag = {
+    id: string;
+    image: string;
+    name: string;
+    username?: string;
+};
+export type UserTagPosition = TagPosition & {
+    itemId: string;
+    leftPCT: number;
+    topPCT: number;
+    user?: UserTag;
+};
+export type VideoPostData = {
+    preferredMediaFormat: MediaFormat;
+    text?: string;
+    title?: string;
+    viewsCount?: number;
+};

package/dist/streams-api-client-model.d.ts

@@ -0,0 +1,5 @@
+export type StreamsApiClientModel = {
+    streamsGqlEndpoint: string;
+    organizationId: string;
+    siteId: string;
+};

package/dist/streams-content-api-client.d.ts

@@ -0,0 +1,14 @@
+import type { AdCampaign, Article, ContentList, Post } from './types';
+export declare class StreamsContentApiClient {
+    private readonly gqlEndpoint;
+    private readonly organizationId;
+    private readonly siteId;
+    private readonly postStatus;
+    constructor(gqlEndpoint: string, organizationId: string, siteId: string);
+    getArticle(slug: string): Promise<Article | null>;
+    getPost(id: string): Promise<Post | undefined>;
+    getPosts(ids: string[] | null, types?: string[] | null, contentListId?: string | null): Promise<Post[] | undefined>;
+    getContentLists(): Promise<ContentList[] | undefined>;
+    getAdCampaigns(page: number, perPage: number): Promise<AdCampaign[] | undefined>;
+    private queryGql;
+}

package/dist/streams-content-api-client.js

@@ -0,0 +1,89 @@
+import SiteActiveCampaignsQuery from './adcampaignsquery.graphql.js';
+import SiteArticleQuery from './articlequery.graphql.js';
+import SiteContentListsQuery from './contentlistsquery.graphql.js';
+import SitePostsQuery from './postsquery.graphql.js';
+import { SitePostsOrderBy, SiteContentListsOrderBy, SiteAdCampaignsOrderBy } from './types.js';
+
+class StreamsContentApiClient {
+    gqlEndpoint = '{{streamsGqlEndpoint}}';
+    organizationId = '{{organizationId}}';
+    siteId = '{{siteId}}';
+    postStatus = 'PUBLISHED';
+    constructor(gqlEndpoint, organizationId, siteId) {
+        this.gqlEndpoint = gqlEndpoint;
+        this.organizationId = organizationId;
+        this.siteId = siteId;
+    }
+    async getArticle(slug) {
+        const response = await this.queryGql(SiteArticleQuery, { organizationId: this.organizationId, slug });
+        return response.siteArticle;
+    }
+    async getPost(id) {
+        const response = await this.getPosts([id]);
+        return response?.pop();
+    }
+    async getPosts(ids, types = null, contentListId = null) {
+        const response = await this.queryGql(SitePostsQuery, {
+            cursor: {
+                sorting: {
+                    orderBy: SitePostsOrderBy.Published
+                }
+            },
+            filter: {
+                ids: ids,
+                organizationId: this.organizationId,
+                postTypes: types,
+                statuses: [this.postStatus],
+                contentListId: contentListId
+            }
+        });
+        return response.sitePosts?.items;
+    }
+    async getContentLists() {
+        const response = await this.queryGql(SiteContentListsQuery, {
+            cursor: {
+                sorting: {
+                    orderBy: SiteContentListsOrderBy.Name
+                }
+            },
+            filter: {
+                organizationId: this.organizationId
+            }
+        });
+        return response.siteContentLists?.items;
+    }
+    async getAdCampaigns(page, perPage) {
+        const response = await this.queryGql(SiteActiveCampaignsQuery, {
+            pageQuery: {
+                orderBy: SiteAdCampaignsOrderBy.Modified,
+                fetchTotal: false,
+                page: page,
+                perPage: perPage
+            },
+            filter: {
+                organizationId: this.organizationId,
+                siteId: this.siteId
+            }
+        });
+        return response.siteActiveCampaigns?.items;
+    }
+    queryGql = async (query, variables) => {
+        const response = await fetch(this.gqlEndpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                query,
+                variables
+            })
+        });
+        const gql = await response.json();
+        if (!gql.data) {
+            throw new Error(JSON.stringify(gql.errors));
+        }
+        return gql.data;
+    };
+}
+
+export { StreamsContentApiClient };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@streamscloud/streams-analytics-collector",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",