glitch-javascript-sdk 1.8.1 → 1.8.3

package/dist/cjs/index.js

@@ -25352,6 +25352,7 @@ var SchedulerRoute = /** @class */ (function () {
         getSchedulePosts: { url: '/schedulers/{scheduler_id}/posts', method: HTTP_METHODS.GET },
         // Title Update Routes
         listUpdates: { url: '/schedulers/{scheduler_id}/updates', method: HTTP_METHODS.GET },
+        searchUpdates: { url: '/schedulers/{scheduler_id}/updates/search', method: HTTP_METHODS.GET },
         createUpdate: { url: '/schedulers/{scheduler_id}/updates', method: HTTP_METHODS.POST },
         getUpdate: { url: '/schedulers/{scheduler_id}/updates/{update_id}', method: HTTP_METHODS.GET },
         updateUpdate: { url: '/schedulers/{scheduler_id}/updates/{update_id}', method: HTTP_METHODS.PUT },
@@ -25537,6 +25538,18 @@ var Scheduler = /** @class */ (function () {
     Scheduler.listUpdates = function (scheduler_id, params) {
         return Requests.processRoute(SchedulerRoute.routes.listUpdates, {}, { scheduler_id: scheduler_id }, params);
     };
+    /**
+     * Search the updates related to a promotion schedule.
+     *
+     * @see https://api.glitch.fun/api/documentation#/Scheduler/searchTitleUpdates
+     *
+     * @param scheduler_id The ID of the promotion schedule.
+     *
+     * @returns promise
+     */
+    Scheduler.searchUpdates = function (scheduler_id, params) {
+        return Requests.processRoute(SchedulerRoute.routes.listUpdates, {}, { scheduler_id: scheduler_id }, params);
+    };
     /**
      * Create a new title update for a promotion schedule.
      *
@@ -26157,6 +26170,292 @@ var Hashtags = /** @class */ (function () {
     return Hashtags;
 }());
 
+var WebsiteAnalyticsRoute = /** @class */ (function () {
+    function WebsiteAnalyticsRoute() {
+    }
+    WebsiteAnalyticsRoute.routes = {
+        listSessions: {
+            url: '/analytics/sessions',
+            method: HTTP_METHODS.GET
+        },
+        listPageviews: {
+            url: '/analytics/pageviews',
+            method: HTTP_METHODS.GET
+        },
+        listEvents: {
+            url: '/analytics/events',
+            method: HTTP_METHODS.GET
+        },
+        overview: {
+            url: '/analytics/overview',
+            method: HTTP_METHODS.GET
+        },
+        collect: {
+            url: '/analytics/collect',
+            method: HTTP_METHODS.POST
+        },
+        sessionsAverage: {
+            url: '/analytics/sessions/average',
+            method: HTTP_METHODS.GET
+        },
+        sessionsHistogram: {
+            url: '/analytics/sessions/histogram',
+            method: HTTP_METHODS.GET
+        },
+        pageviewsOverTime: {
+            url: '/analytics/pageviews/over-time',
+            method: HTTP_METHODS.GET
+        },
+        topPages: {
+            url: '/analytics/pageviews/top-pages',
+            method: HTTP_METHODS.GET
+        },
+        eventsSummary: {
+            url: '/analytics/events/summary',
+            method: HTTP_METHODS.GET
+        },
+        popularEvents: {
+            url: '/analytics/events/popular',
+            method: HTTP_METHODS.GET
+        },
+        geoDistribution: {
+            url: '/analytics/geo-distribution',
+            method: HTTP_METHODS.GET
+        },
+        deviceBreakdown: {
+            url: '/analytics/device-breakdown',
+            method: HTTP_METHODS.GET
+        },
+        referrers: {
+            url: '/analytics/referrers',
+            method: HTTP_METHODS.GET
+        },
+        utmPerformance: {
+            url: '/analytics/utm-performance',
+            method: HTTP_METHODS.GET
+        }
+    };
+    return WebsiteAnalyticsRoute;
+}());
+
+var WebsiteAnalytics = /** @class */ (function () {
+    function WebsiteAnalytics() {
+    }
+    /**
+     * List website analytics sessions with comprehensive filtering
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - device_type?: 'desktop'|'mobile'|'tablet'|'bot'|'other'
+     *   - country_code?: string - 2-letter country code
+     *   - is_bot?: boolean - Filter by bot status
+     *   - sort?: 'started_at'|'total_duration'|'pageview_count' - Sort field
+     *   - order?: 'asc'|'desc' - Sort order
+     *   - per_page?: number - Items per page (max 100)
+     * @returns Promise with paginated sessions data
+     */
+    WebsiteAnalytics.listSessions = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.listSessions, {}, undefined, params);
+    };
+    /**
+     * Get a paginated list of pageviews with filtering options
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - analytics_session_id?: string - Filter by session ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - is_exit?: boolean - Filter by exit pageviews
+     *   - sort?: 'occurred_at'|'load_time_ms'|'dom_complete_ms' - Sort field
+     *   - order?: 'asc'|'desc' - Sort order
+     *   - per_page?: number - Items per page (max 100)
+     * @returns Promise with paginated pageviews data
+     */
+    WebsiteAnalytics.listPageviews = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.listPageviews, {}, undefined, params);
+    };
+    /**
+     * Get a paginated list of events with filtering options
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - analytics_session_id?: string - Filter by session ID
+     *   - event_name?: string - Filter by event name
+     *   - event_category?: string - Filter by event category
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - sort?: 'occurred_at'|'event_name' - Sort field
+     *   - order?: 'asc'|'desc' - Sort order
+     *   - per_page?: number - Items per page (max 100)
+     * @returns Promise with paginated events data
+     */
+    WebsiteAnalytics.listEvents = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.listEvents, {}, undefined, params);
+    };
+    /**
+     * Get an analytics overview with summarized metrics
+     *
+     * @param params Overview options:
+     *   - title_id: string - Required title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - group_by?: 'day'|'week'|'month'|'year' - Grouping period
+     *   - include_breakdowns?: boolean - Include detailed breakdowns
+     * @returns Promise with overview data
+     */
+    WebsiteAnalytics.overview = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.overview, {}, undefined, params);
+    };
+    /**
+     * Single ingestion endpoint for sessions, pageviews and events
+     *
+     * @param data Analytics data payload with type property:
+     *   - type: 'session'|'pageview'|'event' - Type of analytics data
+     *   - title_id: string - Title ID
+     *   - tracking_token: string - HMAC token for verification
+     *   - plus type-specific fields
+     * @returns Promise with acceptance response
+     */
+    WebsiteAnalytics.collect = function (data) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.collect, data);
+    };
+    /**
+     * Get average session length data with optional grouping
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - group_by?: 'day'|'week'|'month' - Grouping period
+     *   - device_type?: string - Filter by device type
+     *   - country_code?: string - Filter by country
+     * @returns Promise with average session data
+     */
+    WebsiteAnalytics.sessionsAverage = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.sessionsAverage, {}, undefined, params);
+    };
+    /**
+     * Get session duration histogram data
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - bucket_size?: number - Duration bucket size in seconds
+     * @returns Promise with histogram data
+     */
+    WebsiteAnalytics.sessionsHistogram = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.sessionsHistogram, {}, undefined, params);
+    };
+    /**
+     * Get pageviews over time with optional grouping
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - group_by?: 'hour'|'day'|'week'|'month' - Grouping period
+     *   - path?: string - Filter by specific path
+     * @returns Promise with pageviews over time data
+     */
+    WebsiteAnalytics.pageviewsOverTime = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.pageviewsOverTime, {}, undefined, params);
+    };
+    /**
+     * Get top pages by views
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - limit?: number - Number of top pages to return
+     * @returns Promise with top pages data
+     */
+    WebsiteAnalytics.topPages = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.topPages, {}, undefined, params);
+    };
+    /**
+     * Get summary of events
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - event_category?: string - Filter by event category
+     * @returns Promise with events summary data
+     */
+    WebsiteAnalytics.eventsSummary = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.eventsSummary, {}, undefined, params);
+    };
+    /**
+     * Get most popular events
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - limit?: number - Number of events to return
+     * @returns Promise with popular events data
+     */
+    WebsiteAnalytics.popularEvents = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.popularEvents, {}, undefined, params);
+    };
+    /**
+     * Get geographic distribution of visitors
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - limit?: number - Number of countries to return
+     * @returns Promise with geo distribution data
+     */
+    WebsiteAnalytics.geoDistribution = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.geoDistribution, {}, undefined, params);
+    };
+    /**
+     * Get device type breakdown
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     * @returns Promise with device breakdown data
+     */
+    WebsiteAnalytics.deviceBreakdown = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.deviceBreakdown, {}, undefined, params);
+    };
+    /**
+     * Get top referrers
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - limit?: number - Number of referrers to return
+     * @returns Promise with referrers data
+     */
+    WebsiteAnalytics.referrers = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.referrers, {}, undefined, params);
+    };
+    /**
+     * Get UTM campaign performance
+     *
+     * @param params Filtering options:
+     *   - title_id?: string - Filter by title ID
+     *   - start_date?: string - Start date (YYYY-MM-DD)
+     *   - end_date?: string - End date (YYYY-MM-DD)
+     *   - group_by?: 'source'|'medium'|'campaign' - Grouping field
+     * @returns Promise with UTM performance data
+     */
+    WebsiteAnalytics.utmPerformance = function (params) {
+        return Requests.processRoute(WebsiteAnalyticsRoute.routes.utmPerformance, {}, undefined, params);
+    };
+    return WebsiteAnalytics;
+}());
+
 var Parser = /** @class */ (function () {
     function Parser() {
     }
@@ -26180,6 +26479,75 @@ var Parser = /** @class */ (function () {
     return Parser;
 }());
 
+// Browser implementation using crypto-js
+var BrowserCrypto = /** @class */ (function () {
+    function BrowserCrypto() {
+        this.CryptoJS = require('crypto-js');
+    }
+    BrowserCrypto.prototype.createHmac = function (algorithm, secret) {
+        var _this = this;
+        var data = '';
+        var hmac = {
+            update: function (updateData) {
+                data = updateData;
+                return hmac;
+            },
+            digest: function (encoding) {
+                if (encoding !== 'hex') {
+                    throw new Error('Only hex encoding is supported in browser implementation');
+                }
+                return _this.CryptoJS.HmacSHA256(data, secret).toString(_this.CryptoJS.enc.Hex);
+            }
+        };
+        return hmac;
+    };
+    return BrowserCrypto;
+}());
+// Node.js implementation that maintains sync interface
+var NodeCrypto = /** @class */ (function () {
+    function NodeCrypto() {
+        // Use dynamic import but handle it synchronously for interface compliance
+        try {
+            // This will throw in browser environments
+            this.crypto = require('crypto');
+        }
+        catch (e) {
+            this.crypto = undefined;
+        }
+    }
+    NodeCrypto.prototype.createHmac = function (algorithm, secret) {
+        if (!this.crypto) {
+            throw new Error('Node.js crypto module not available');
+        }
+        return this.crypto.createHmac(algorithm, secret);
+    };
+    return NodeCrypto;
+}());
+// Determine which crypto implementation to use
+var getCrypto = function () {
+    var _a;
+    try {
+        // Check if we're in Node.js environment and crypto is available
+        if (typeof process !== 'undefined' && ((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node)) {
+            var nodeCrypto = new NodeCrypto();
+            // Verify crypto was actually loaded
+            try {
+                nodeCrypto.createHmac('sha256', 'test');
+                return nodeCrypto;
+            }
+            catch (e) {
+                console.warn('Node.js crypto not available, falling back to browser implementation');
+            }
+        }
+    }
+    catch (e) {
+        console.warn('Node.js environment detection failed, falling back to browser implementation');
+    }
+    // Fall back to browser implementation
+    return new BrowserCrypto();
+};
+// Singleton crypto instance
+var cryptoInstance = getCrypto();
 var Session = /** @class */ (function () {
     function Session() {
     }
@@ -26204,10 +26572,7 @@ var Session = /** @class */ (function () {
     };
     Session.hasJoinedCommunity = function () {
         var community = Storage.get('community');
-        if (!community) {
-            return false;
-        }
-        return (community === null || community === void 0 ? void 0 : community.me) ? true : false;
+        return !!(community === null || community === void 0 ? void 0 : community.me);
     };
     Session.end = function () {
         Storage.setAuthToken(null);
@@ -26226,6 +26591,31 @@ var Session = /** @class */ (function () {
         Storage.set(Session._email_key, data.email);
         Config.setAuthToken(data.token.access_token);
     };
+    /**
+     * Generate a tracking token for analytics collection
+     * @param titleId The title ID to generate token for
+     * @param secret The secret key (should match server config)
+     * @returns HMAC-SHA256 token
+     * @throws Error if crypto operations fail
+     */
+    Session.generateTrackingToken = function (titleId, secret) {
+        try {
+            if (!titleId) {
+                throw new Error('titleId is required');
+            }
+            if (!secret) {
+                throw new Error('secret is required');
+            }
+            return cryptoInstance
+                .createHmac('sha256', secret)
+                .update(titleId)
+                .digest('hex');
+        }
+        catch (error) {
+            console.error('Failed to generate tracking token:', error);
+            throw new Error('Failed to generate tracking token');
+        }
+    };
     Session._id_key = 'user_id';
     Session._first_name_key = 'user_first_name';
     Session._last_name_key = 'user_last_name';
@@ -26586,7 +26976,8 @@ var Glitch = /** @class */ (function () {
         Media: Media,
         Scheduler: Scheduler,
         Funnel: Funnel,
-        SocialStats: SocialStats
+        SocialStats: SocialStats,
+        WebsiteAnalytics: WebsiteAnalytics
     };
     Glitch.util = {
         Requests: Requests,