@reveldigital/player-client 1.0.13 → 1.0.15

package/esm2020/lib/player-client.service.mjs

@@ -3,26 +3,118 @@ import { BehaviorSubject, fromEvent, Subject } from 'rxjs';
 import { filter, map, share, tap } from 'rxjs/operators';
 import { version } from './version';
 import * as i0 from "@angular/core";
+/**
+ * Service for interacting with the Revel Digital player client.
+ *
+ * This service provides a comprehensive interface for gadgets and web applications
+ * to communicate with the Revel Digital player environment. It handles device
+ * information, commands, events, analytics tracking, and configuration management.
+ *
+ * The service supports both direct API calls and event-based communication patterns,
+ * allowing gadgets to respond to player lifecycle events (start, stop, commands) and
+ * send data back to the player or remote devices.
+ *
+ * ```typescript
+ * constructor(private client: PlayerClientService) {
+ *   // Subscribe to player events
+ *   this.client.onStart$.subscribe(() => {
+ *     console.log('Gadget started');
+ *   });
+ *
+ *   this.client.onCommand$.subscribe(command => {
+ *     console.log('Received command:', command);
+ *   });
+ * }
+ *
+ * async ngOnInit() {
+ *   // Get device information
+ *   const device = await this.client.getDevice();
+ *   const deviceTime = await this.client.getDeviceTime();
+ *
+ *   // Track analytics
+ *   this.client.track('gadget_loaded', { version: '1.0' });
+ * }
+ * ```
+ *
+ * @since 1.0.0
+ */
 export class PlayerClientService {
     /** @ignore */
     constructor(zone) {
         /**
-         * Commands sent to this player.
+         * Observable stream of commands sent to this player from the Revel Digital platform.
+         * Subscribe to this to handle custom commands sent from templates, playlists, or remote devices.
+         *
+         * ```typescript
+         * this.client.onCommand$.subscribe(command => {
+         *   if (command.name === 'customAction') {
+         *     this.handleCustomAction(command.arg);
+         *   }
+         * });
+         * ```
          */
         this.onCommand$ = new Subject();
         /**
-         * Signals the gadget has been loaded and is ready to start.
+         * Observable that signals when the gadget has been loaded and is ready to start.
+         * Emits `true` when ready, `false` when destroyed.
+         *
+         * ```typescript
+         * this.client.onReady$.subscribe(isReady => {
+         *   if (isReady) {
+         *     console.log('Client is ready');
+         *     this.initializeGadget();
+         *   }
+         * });
+         * ```
          */
         this.onReady$ = new BehaviorSubject(false);
         /**
-         * Signals the gadget has been started by the player.
+         * Observable that signals when the gadget has been started by the player.
+         * This event occurs when the player begins execution of the gadget content.
+         *
+         * ```typescript
+         * this.client.onStart$.subscribe(() => {
+         *   console.log('Gadget started');
+         *   this.startAnimation();
+         * });
+         * ```
          */
         this.onStart$ = new Subject();
         /**
-         * Signals the gadgets has been stopped by the player.
+         * Observable that signals when the gadget has been stopped by the player.
+         * This event occurs when the player stops execution, typically when moving
+         * to the next item in a playlist or when the content duration expires.
+         *
+         * ```typescript
+         * this.client.onStop$.subscribe(() => {
+         *   console.log('Gadget stopped');
+         *   this.cleanup();
+         * });
+         * ```
          */
         this.onStop$ = new Subject();
+        /**
+         * Observable that signals when the gadget should open the configuration window.
+         * This allows gadgets to respond to configuration requests from the player.
+         *
+         * ```typescript
+         * this.client.onConfig$.subscribe(() => {
+         *   this.openConfigurationDialog();
+         * });
+         * ```
+         */
         this.onConfig$ = new Subject();
+        /**
+         * Observable that signals when the gadget has received a postMessage event from the player.
+         * This handles communication between the gadget and player via the postMessage API.
+         *
+         * ```typescript
+         * this.client.onPostMessage$.subscribe(message => {
+         *   console.log('Received message:', message);
+         *   this.handlePlayerMessage(message);
+         * });
+         * ```
+         */
         this.onPostMessage$ = new Subject();
         /** @ignore */
         this.onStartEvt$ = fromEvent(window, 'RevelDigital.Start').pipe(share(), tap(this.onStart$));
@@ -84,14 +176,21 @@ export class PlayerClientService {
         console.log('%c⚙️ Initializing Revel Digital client library', 'background-color:blue; color:yellow;');
     }
     /**
+     * Sends a callback to player scripting with variable arguments.
+     *
      * This method allows the gadget to communicate with player scripting.
-     * If the appropriate scripting is in place in the currently running template, calling this method
-     * will initiate a callback which can be acted upon in player script.
+     * If the appropriate scripting is in place in the currently running template,
+     * calling this method will initiate a callback which can be acted upon in player script.
+     *
+     * @param args - Variable number of arguments to pass to the callback (max 5 arguments)
      *
-     * @example
-     * client.callback('test', 'this');
+     * ```typescript
+     * // Send a simple callback
+     * this.client.callback('test', 'data');
      *
-     * @param args variable number of arguments
+     * // Send multiple parameters
+     * this.client.callback('action', 'value1', 'value2', { data: 'object' });
+     * ```
      */
     callback(...args) {
         this.getClient().then((client) => {
@@ -118,26 +217,47 @@ export class PlayerClientService {
         });
     }
     /**
-     * Accessor method for the user preferences interface exposed by the Gadgets API.
+     * Gets the user preferences interface exposed by the Google Gadgets API.
      *
-     * See {@link https://developers.google.com/gadgets/docs/basic} for more details on the Gadgets API.
+     * This method provides access to gadget preferences which can be configured
+     * in the Revel Digital CMS. Use this to retrieve user-configurable settings
+     * for your gadget.
      *
-     * @example
+     * @returns The Gadgets API Prefs object for accessing preference values
+     *
+     * ```typescript
      * constructor(public client: PlayerClientService) {
-     *            let prefs = client.getPrefs();
-     *            let myString = prefs.getString('myStringPref');
+     *   const prefs = client.getPrefs();
+     *   const myString = prefs.getString('myStringPref');
+     *   const myNumber = prefs.getInt('myNumberPref');
+     *   const myBool = prefs.getBool('myBoolPref');
      * }
-     * @returns {gadgets.Prefs} Gadget API Prefs object
+     * ```
+     *
+     * @see {@link https://developers.google.com/gadgets/docs/basic} Google Gadgets API documentation
      */
     getPrefs() {
         return new window['gadgets']['Prefs']();
     }
     /**
-     * Returns the current device time in ISO8601 format.
+     * Gets the current device time in ISO8601 format.
+     *
      * Current device time is determined by the device timezone assigned to the device in the CMS.
+     * This is useful for displaying time-sensitive content or scheduling operations based on
+     * the device's local time rather than browser time.
      *
-     * @param date Optional. If supplied will translate the supplied date/time to device time based on respective timezones.
-     * @returns Date/time in ISO8601 format
+     * @param date - Optional. If supplied, will translate the supplied date/time to device time based on respective timezones
+     * @returns Promise resolving to date/time in ISO8601 format
+     *
+     * ```typescript
+     * // Get current device time
+     * const currentTime = await this.client.getDeviceTime();
+     * console.log('Device time:', currentTime);
+     *
+     * // Convert a specific date to device time
+     * const specificDate = new Date('2023-01-01T12:00:00Z');
+     * const deviceTime = await this.client.getDeviceTime(specificDate);
+     * ```
      */
     async getDeviceTime(date) {
         const client = await this.getClient();
@@ -147,55 +267,99 @@ export class PlayerClientService {
         return client.getDeviceTime();
     }
     /**
-     * Returns the timezone name currently assigned to the device.
+     * Gets the timezone name currently assigned to the device.
+     *
+     * @returns Promise resolving to the timezone name (e.g., "America/New_York")
      *
-     * @returns Timezone Name
+     * ```typescript
+     * const timezoneName = await this.client.getDeviceTimeZoneName();
+     * console.log('Device timezone:', timezoneName);
+     * ```
      */
     async getDeviceTimeZoneName() {
         const client = await this.getClient();
         return client.getDeviceTimeZoneName();
     }
     /**
-     * Returns the timezone ID currently assigned to the device.
+     * Gets the timezone ID currently assigned to the device.
      *
-     * @returns Timezone ID
+     * @returns Promise resolving to the timezone ID
+     *
+     * ```typescript
+     * const timezoneId = await this.client.getDeviceTimeZoneID();
+     * console.log('Device timezone ID:', timezoneId);
+     * ```
      */
     async getDeviceTimeZoneID() {
         const client = await this.getClient();
         return client.getDeviceTimeZoneID();
     }
     /**
-     * Returns the numerical offset from GMT of the timezone currently assigned to the device.
+     * Gets the numerical offset from GMT of the timezone currently assigned to the device.
+     *
+     * @returns Promise resolving to the timezone offset in hours (e.g., -5 for EST)
      *
-     * @returns Timezone offset
+     * ```typescript
+     * const offset = await this.client.getDeviceTimeZoneOffset();
+     * console.log('Device timezone offset:', offset, 'hours from GMT');
+     * ```
      */
     async getDeviceTimeZoneOffset() {
         const client = await this.getClient();
         return client.getDeviceTimeZoneOffset();
     }
     /**
-     * Returns the language code of the language currently assigned to the device.
+     * Gets the language code of the language currently assigned to the device.
+     *
+     * @returns Promise resolving to the language code (e.g., "en-US", "fr-FR")
      *
-     * @returns Language code
+     * ```typescript
+     * const languageCode = await this.client.getLanguageCode();
+     * console.log('Device language:', languageCode);
+     * // Use for localization
+     * this.loadLanguageResources(languageCode);
+     * ```
      */
     async getLanguageCode() {
         const client = await this.getClient();
         return client.getLanguageCode();
     }
     /**
-     * Returns the unique Revel Digital device key associated with the device.
+     * Gets the unique Revel Digital device key associated with the device.
      *
-     * @returns Device key
+     * The device key is a unique identifier for this specific player device
+     * and can be used for device-specific operations or remote commands.
+     *
+     * @returns Promise resolving to the device key string
+     *
+     * ```typescript
+     * const deviceKey = await this.client.getDeviceKey();
+     * console.log('Device key:', deviceKey);
+     * ```
      */
     async getDeviceKey() {
         const client = await this.getClient();
         return client.getDeviceKey();
     }
     /**
-     * Send a command to the player device.
+     * Sends a command to the local player device.
+     *
+     * Commands can be used to control various aspects of the player or trigger
+     * specific behaviors. The command is processed by the local player only.
      *
-     * @param name Command name
-     * @param arg Command argument
+     * @param name - The command name/identifier
+     * @param arg - The command argument/payload
+     *
+     * ```typescript
+     * // Send a simple command
+     * this.client.sendCommand('refresh', '');
+     *
+     * // Send a command with data
+     * this.client.sendCommand('setVolume', '50');
+     *
+     * // Send a command with JSON data
+     * this.client.sendCommand('configure', JSON.stringify({ setting: 'value' }));
+     * ```
      */
     sendCommand(name, arg) {
         this.getClient().then((client) => {
@@ -203,12 +367,29 @@ export class PlayerClientService {
         });
     }
     /**
-     * Send a command to any remote player with the supplied device key(s).
+     * Sends a command to remote player devices with the specified device keys.
+     *
+     * Remote commands allow cross-device communication within the same Revel Digital account.
+     * This is useful for synchronized displays, device coordination, or remote control scenarios.
+     *
      * Note: Remote commands can only be delivered to devices within the same account as the sender device.
      *
-     * @param deviceKeys Array of remote device keys
-     * @param name Command name
-     * @param arg Command arg
+     * @param deviceKeys - Array of target device keys to send the command to
+     * @param name - The command name/identifier
+     * @param arg - The command argument/payload
+     *
+     * ```typescript
+     * // Send command to specific devices
+     * const targetDevices = ['device-key-1', 'device-key-2'];
+     * this.client.sendRemoteCommand(targetDevices, 'syncAction', 'start');
+     *
+     * // Broadcast to multiple devices
+     * this.client.sendRemoteCommand(
+     *   ['lobby-display', 'kiosk-1', 'kiosk-2'],
+     *   'updateContent',
+     *   JSON.stringify({ contentId: '12345' })
+     * );
+     * ```
      */
     sendRemoteCommand(deviceKeys, name, arg) {
         this.getClient().then((client) => {
@@ -216,11 +397,33 @@ export class PlayerClientService {
         });
     }
     /**
-     * Log an event for use with AdHawk analytics.
-     * Events are used for tracking various metrics including usage statistics, player condition, state changes, etc.
+     * Logs an analytics event for use with AdHawk analytics and reporting.
+     *
+     * Events are used for tracking various metrics including usage statistics,
+     * player condition, state changes, user interactions, and custom business metrics.
+     * These events can be viewed in the Revel Digital analytics dashboard.
+     *
+     * @param eventName - Unique name for this event (should be descriptive and consistent)
+     * @param properties - Optional map of user-defined properties to associate with this event
+     *
+     * ```typescript
+     * // Simple event tracking
+     * this.client.track('gadget_loaded');
+     *
+     * // Event with properties
+     * this.client.track('user_interaction', {
+     *   action: 'button_click',
+     *   button_id: 'start_button',
+     *   timestamp: new Date().toISOString()
+     * });
      *
-     * @param eventName Unique name for this event
-     * @param properties A map of user defined properties to associate with this event
+     * // Performance tracking
+     * this.client.track('content_displayed', {
+     *   content_type: 'video',
+     *   duration: 30,
+     *   quality: 'HD'
+     * });
+     * ```
      */
     track(eventName, properties) {
         this.getClient().then((client) => {
@@ -228,13 +431,32 @@ export class PlayerClientService {
         });
     }
     /**
-     * Method for initiating a timed event.
-     * Timed events are useful for tracking the duration of an event and must be proceeded with a call to track().
+     * Initiates a timed event for duration tracking.
+     *
+     * Timed events are useful for tracking the duration of operations or user interactions.
+     * This method must be followed by a call to track() with the same event name to complete
+     * the timing measurement. The duration will be automatically calculated and included
+     * in the event properties.
+     *
+     * @param eventName - Unique name for this timed event (must match the subsequent track() call)
+     *
+     * ```typescript
+     * // Start timing an event
+     * this.client.timeEvent('video_playback');
+     *
+     * // ... video plays for some duration ...
+     *
+     * // End timing and log the event with duration
+     * this.client.track('video_playback', {
+     *   video_id: 'abc123',
+     *   quality: 'HD'
+     * }); // Duration will be automatically added
      *
-     * @example
-     * client.timeEvent('testEvent');
-     * client.track("test", { "a": "b" });
-     * @param eventName Unique name for this event
+     * // Example for user interaction timing
+     * this.client.timeEvent('form_completion');
+     * // ... user fills out form ...
+     * this.client.track('form_completion', { form_type: 'contact' });
+     * ```
      */
     timeEvent(eventName) {
         this.getClient().then((client) => {
@@ -242,11 +464,33 @@ export class PlayerClientService {
         });
     }
     /**
-     * A session is a way of grouping events together. Each event has an associated session ID.
-     * Session ID's are randomly generated and reset by subsequent calls to newEventSession().
+     * Creates a new analytics event session for grouping related events.
      *
-     * Each call to track() will utilize the same session ID, until another call to newEventSession().
-     * @param id Optional. User supplied session ID. If not supplied a random session ID will be generated.
+     * A session is a way of grouping events together for analysis. Each event tracked
+     * after calling this method will have the same session ID until a new session is created.
+     * Session IDs are randomly generated unless explicitly provided.
+     *
+     * This is useful for tracking user journeys, workflow completion, or grouping
+     * related interactions within a specific time period.
+     *
+     * @param id - Optional user-supplied session ID. If not provided, a random session ID will be generated
+     *
+     * ```typescript
+     * // Start a new session with auto-generated ID
+     * this.client.newEventSession();
+     * this.client.track('session_start');
+     * this.client.track('user_action_1');
+     * this.client.track('user_action_2');
+     *
+     * // Start a session with custom ID
+     * this.client.newEventSession('user-workflow-12345');
+     * this.client.track('workflow_start');
+     * this.client.track('step_completed', { step: 1 });
+     *
+     * // Start a new session for different workflow
+     * this.client.newEventSession();
+     * this.client.track('different_workflow_start');
+     * ```
      */
     newEventSession(id) {
         this.getClient().then((client) => {
@@ -259,26 +503,74 @@ export class PlayerClientService {
         });
     }
     /**
-     * Returns the root folder utilized by this player device.
+     * Gets the root folder path utilized by this player device.
+     *
+     * This returns the base directory path where the Revel Digital player
+     * stores its files and resources on the local device.
      *
-     * @returns Path to the root folder
+     * @returns Promise resolving to the path of the root folder
+     *
+     * ```typescript
+     * const rootPath = await this.client.getRevelRoot();
+     * console.log('Player root directory:', rootPath);
+     * // Use for constructing file paths or understanding storage structure
+     * ```
      */
     async getRevelRoot() {
         const client = await this.getClient();
         return client.getRevelRoot();
     }
     /**
-     * Returns a map of commands currently active for this device.
+     * Gets a map of commands currently active for this device.
+     *
+     * This returns the current command configuration that defines how the device
+     * responds to various command triggers and remote commands.
+     *
+     * @returns Promise resolving to a map of currently active commands
      *
-     * @returns Map of commands currently active for this device.
+     * ```typescript
+     * const commandMap = await this.client.getCommandMap();
+     * console.log('Active commands:', commandMap);
+     *
+     * // Check if specific command is available
+     * if (commandMap['customCommand']) {
+     *   console.log('Custom command is available');
+     * }
+     * ```
      */
     async getCommandMap() {
         const client = await this.getClient();
         return JSON.parse(await client.getCommandMap());
     }
     /**
-     * Indicate to the player that this gadget has finished it's visualization.
-     * This allows the player to proceed with the next item in a playlist if applicable.
+     * Signals to the player that this gadget has completed its visualization.
+     *
+     * This method notifies the player that the current gadget has finished its
+     * content display or interaction cycle. The player can then proceed with
+     * the next item in a playlist if applicable, or handle the completion
+     * according to its configuration.
+     *
+     * Call this method when your gadget has completed its intended function,
+     * such as finishing an animation, completing a form, or reaching a natural
+     * stopping point.
+     *
+     * ```typescript
+     * // After completing an animation
+     * private onAnimationComplete(): void {
+     *   this.client.finish();
+     * }
+     *
+     * // After user interaction is complete
+     * private onFormSubmitted(): void {
+     *   this.saveFormData();
+     *   this.client.finish();
+     * }
+     *
+     * // After a timed display period
+     * setTimeout(() => {
+     *   this.client.finish();
+     * }, 30000); // 30 seconds
+     * ```
      */
     finish() {
         this.getClient().then((client) => {
@@ -286,20 +578,64 @@ export class PlayerClientService {
         });
     }
     /**
-     * Check is the gadget is running in preview mode. Preview mode is enabled when the gadget is
-     * being edited in the CMS, or otherwise not running in a normal player environment.
+     * Checks if the gadget is running in preview mode.
+     *
+     * Preview mode is enabled when the gadget is being edited in the Revel Digital CMS,
+     * tested in the gadget editor, or otherwise not running in a normal player environment.
+     * This is useful for providing different behavior during development/testing versus
+     * production deployment.
+     *
+     * @returns Promise resolving to true if running in preview mode, false if running on actual player
+     *
+     * ```typescript
+     * const isPreview = await this.client.isPreviewMode();
+     *
+     * if (isPreview) {
+     *   console.log('Running in preview mode - using mock data');
+     *   this.loadMockData();
+     * } else {
+     *   console.log('Running on player device - using live data');
+     *   this.loadLiveData();
+     * }
      *
-     * @returns True if the gadget is running in preview mode, false otherwise.
+     * // Show different UI in preview
+     * this.showPreviewIndicator = isPreview;
+     * ```
      */
     async isPreviewMode() {
         const client = await this.getClient();
         return client instanceof NoopClient;
     }
     /**
-   * Returns the device details associated with the player running the gadget or web app.
-   *
-   * @returns Device details.
-   */
+     * Gets detailed information about the device running the player.
+     *
+     * Returns comprehensive device details including name, registration key, type,
+     * service date, language, timezone, tags, and location information. This data
+     * is configured in the Revel Digital CMS for each device.
+     *
+     * @returns Promise resolving to device details object, or null if not available
+     *
+     * ```typescript
+     * const device = await this.client.getDevice();
+     *
+     * if (device) {
+     *   console.log('Device name:', device.name);
+     *   console.log('Device type:', device.deviceType);
+     *   console.log('Location:', device.location.city, device.location.state);
+     *   console.log('Tags:', device.tags);
+     *
+     *   // Use device info for customization
+     *   if (device.location.country === 'US') {
+     *     this.loadUSContent();
+     *   }
+     *
+     *   // Check device capabilities based on type
+     *   if (device.deviceType === 'android') {
+     *     this.enableTouchFeatures();
+     *   }
+     * }
+     * ```
+     */
     async getDevice() {
         const client = await this.getClient();
         let obj = JSON.parse(await client.getDevice());
@@ -326,41 +662,125 @@ export class PlayerClientService {
         return device[0];
     }
     /**
-     * Returns the width of the visualization area.
+     * Gets the width of the visualization area in pixels.
+     *
+     * This returns the available width for content display, which may be
+     * different from the full screen width depending on player configuration
+     * and template layout.
+     *
+     * @returns Promise resolving to width in pixels, or null if not available
      *
-     * @returns Width of the visualization area
+     * ```typescript
+     * const width = await this.client.getWidth();
+     *
+     * if (width) {
+     *   console.log('Available width:', width, 'pixels');
+     *
+     *   // Adapt content layout based on width
+     *   if (width < 800) {
+     *     this.enableMobileLayout();
+     *   } else {
+     *     this.enableDesktopLayout();
+     *   }
+     * }
+     * ```
      */
     async getWidth() {
         const client = await this.getClient();
         return client.getWidth();
     }
     /**
-     * Returns the height of the visualization area.
+     * Gets the height of the visualization area in pixels.
+     *
+     * This returns the available height for content display, which may be
+     * different from the full screen height depending on player configuration
+     * and template layout.
+     *
+     * @returns Promise resolving to height in pixels, or null if not available
+     *
+     * ```typescript
+     * const height = await this.client.getHeight();
      *
-     * @returns Height of the visualization area
+     * if (height) {
+     *   console.log('Available height:', height, 'pixels');
+     *
+     *   // Calculate aspect ratio for responsive design
+     *   const width = await this.client.getWidth();
+     *   const aspectRatio = width / height;
+     *   this.adjustContentForAspectRatio(aspectRatio);
+     * }
+     * ```
      */
     async getHeight() {
         const client = await this.getClient();
         return client.getHeight();
     }
     /**
-     * Returns the duration of the currently playing source.
-     * (only applicable when associated with a playlist)
+     * Gets the duration of the currently playing content item.
+     *
+     * This method is only applicable when the gadget is associated with a playlist
+     * and returns the duration assigned to the current playlist item. The duration
+     * determines how long the content should be displayed before moving to the next item.
+     *
+     * @returns Promise resolving to duration in milliseconds, or null if not applicable/available
+     *
+     * ```typescript
+     * const duration = await this.client.getDuration();
      *
-     * @returns Duration of the current item in milliseconds
+     * if (duration) {
+     *   console.log('Content duration:', duration, 'milliseconds');
+     *
+     *   // Set up auto-finish timer
+     *   setTimeout(() => {
+     *     this.client.finish();
+     *   }, duration);
+     *
+     *   // Show progress indicator
+     *   this.startProgressIndicator(duration);
+     * }
+     * ```
      */
     async getDuration() {
         const client = await this.getClient();
         return client.getDuration();
     }
     /**
-     * Returns the current SDK version.
+     * Gets the current version of the Revel Digital SDK.
      *
-     * @returns SDK version
+     * @returns Promise resolving to the SDK version string
+     *
+     * ```typescript
+     * const version = await this.client.getSdkVersion();
+     * console.log('SDK Version:', version);
+     *
+     * // Use for compatibility checks or logging
+     * this.client.track('gadget_loaded', { sdkVersion: version });
+     * ```
      */
     async getSdkVersion() {
         return Promise.resolve(version);
     }
+    /**
+     * Applies configuration preferences to the gadget (preview mode only).
+     *
+     * This method is only available when running in preview mode (typically during
+     * gadget development or testing in the CMS). It allows applying configuration
+     * changes that would normally come from the gadget's preference settings.
+     *
+     * @param prefs - Dictionary of preference key-value pairs to apply
+     *
+     * ```typescript
+     * if (await this.client.isPreviewMode()) {
+     *   // Apply test configuration in preview
+     *   await this.client.applyConfig({
+     *     'title': 'Test Title',
+     *     'backgroundColor': '#ff0000',
+     *     'showBorder': true,
+     *     'refreshInterval': 30
+     *   });
+     * }
+     * ```
+     */
     async applyConfig(prefs) {
         if (await this.isPreviewMode()) {
             const client = await this.getClient();
@@ -417,10 +837,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImpo
         }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
 // ----------------------------------------------------------------------------------- //
 // ----------------------------------------------------------------------------------- //
-// I provide a mock API for the 3rd-party script. This just allows the consuming code to
-// act as though the library is available even if it failed to load (example, it was
-// blocked by an ad-blocker).
-/** @ignore */
+/**
+ * Mock implementation of the IClient interface.
+ *
+ * This class provides a no-operation (NOOP) implementation of the client API
+ * that allows consuming code to function normally even when the actual player
+ * API is not available. This typically occurs during development, testing,
+ * or when the player script is blocked by ad-blockers.
+ *
+ * All methods in this class either return null/empty values or perform no
+ * operations, allowing gadgets to function without errors while providing
+ * appropriate fallback behavior.
+ *
+ * @private
+ */
 class NoopClient {
     constructor() {
         console.log('%cClient API not available, falling back to mock API', 'background-color:blue; color:yellow;');
@@ -495,4 +925,4 @@ class NoopClient {
         }
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"player-client.service.js","sourceRoot":"","sources":["../../../../../projects/reveldigital/player-client/src/lib/player-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, OnDestroy } from '@angular/core';\r\nimport { gadgets } from '@reveldigital/gadget-types';\r\nimport { BehaviorSubject, fromEvent, Subject, Subscription } from 'rxjs';\r\nimport { filter, map, share, tap } from 'rxjs/operators';\r\nimport { IClient } from './interfaces/client.interface';\r\nimport { ICommand } from './interfaces/command.interface';\r\nimport { IDictionary } from './interfaces/config.interface';\r\nimport { IDevice } from './interfaces/device.interface';\r\nimport { IEventProperties } from './interfaces/event-properties.interface';\r\nimport { version } from './version';\r\n\r\n//import { version } from './version.js';\r\n\r\n// So that TypeScript doesn't complain, we're going to augment the GLOBAL / WINDOW \r\n// name-space definition to include the Tracker API. This also provides us with a place\r\n// to actually DOCUMENT the API so that our developers aren't guessing about what's\r\n// available on the library.\r\n\r\n/** @ignore */\r\ndeclare global {\r\n  var Client: IClient;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PlayerClientService implements OnDestroy {\r\n\r\n  /** @ignore */\r\n  private clientPromise: Promise<IClient> | null;\r\n\r\n  /**\r\n   * Commands sent to this player.\r\n   */\r\n  public onCommand$ = new Subject<ICommand>();\r\n  /**\r\n   * Signals the gadget has been loaded and is ready to start.\r\n   */\r\n  public onReady$ = new BehaviorSubject(false);\r\n  /**\r\n   * Signals the gadget has been started by the player.\r\n   */\r\n  public onStart$ = new Subject();\r\n  /**\r\n   * Signals the gadgets has been stopped by the player.\r\n   */\r\n  public onStop$ = new Subject();\r\n\r\n  public onConfig$ = new Subject();\r\n\r\n  public onPostMessage$ = new Subject();\r\n\r\n  //\r\n  // Two methods available for calling into the library:\r\n  //\r\n  // 1) Using dispatchEvent() with the following custom events\r\n  // 2) Using the window scoped RevelDigital object as defined in the constructor\r\n  //\r\n  /** @ignore */\r\n  private onStartSub: Subscription;\r\n  /** @ignore */\r\n  private onStartEvt$ = fromEvent(window, 'RevelDigital.Start').pipe(\r\n    share(),\r\n    tap(this.onStart$)\r\n  );\r\n  /** @ignore */\r\n  private onStopSub: Subscription;\r\n  /** @ignore */\r\n  private onStopEvt$ = fromEvent(window, 'RevelDigital.Stop').pipe(\r\n    share(),\r\n    tap(this.onStop$)\r\n  );\r\n  /** @ignore */\r\n  private onCommandSub: Subscription;\r\n  /** @ignore */\r\n  private onCommandEvt$ = fromEvent<ICommand>(window, 'RevelDigital.Command').pipe(\r\n    map((e: any) => { return { name: e.detail.name, arg: e.detail.arg } as ICommand }),\r\n    share(),\r\n    tap(this.onCommand$)\r\n  );\r\n  /** @ignore */\r\n  // private onConfigSub: Subscription;\r\n  // /** @ignore */\r\n  // private onConfigEvt$ = fromEvent(window, 'RevelDigital.Config').pipe(\r\n  //   share(),\r\n  //   tap((e: CustomEvent) => {\r\n  //     console.log(e);\r\n\r\n  //     if (e.detail.type === 'applyConfig' && e.detail.isOpener) {\r\n  //       this.applyConfig(e.detail.config); // propagate config to iframe parent from the popup window\r\n  //     } else {\r\n  //       this.onConfig$.next(e.detail);\r\n  //     }\r\n  //   })\r\n  // );\r\n  // private onPostMessageSub: Subscription;\r\n  // private onPostMessageEvt$ = fromEvent(window, 'message').pipe(\r\n  //   filter((messageEvent: MessageEvent) =>\r\n  //     messageEvent.source !== window.parent &&\r\n  //     typeof messageEvent.data === 'string' &&\r\n  //     messageEvent.data.startsWith('reveldigital:')),\r\n  //   map((e: any) => { return JSON.parse(e.substring(13)) as Command }),\r\n  //   share(),\r\n  //   tap(this.onCommand$)\r\n  // );\r\n\r\n  private onPostMessageSub: Subscription;\r\n  private onPostMessageEvt$ = fromEvent(window, 'message').pipe(\r\n    filter((messageEvent: MessageEvent) =>\r\n      //messageEvent.source !== window.parent &&\r\n      typeof messageEvent.data === 'string'),\r\n    map((e: any) => JSON.parse(e.data)),\r\n    share(),\r\n    tap((e: any) => {\r\n      if (e.type === 'applyConfig' && e.isOpener) {\r\n        e.isOpener = false;\r\n        // propagate config to iframe parent from the popup window\r\n        window.parent.postMessage(\r\n          JSON.stringify(e),\r\n          '*'\r\n        );\r\n      } else if (e.type === 'openConfig') {\r\n        this.onConfig$.next(null);\r\n      }\r\n    }),\r\n    tap(e => this.onPostMessage$.next(e))\r\n  );\r\n\r\n\r\n  /** @ignore */\r\n  constructor(zone: NgZone) {\r\n\r\n    let self = this;\r\n    (window as any).RevelDigital = {\r\n      Controller: {\r\n        onCommand: function (name: string, arg: string) {\r\n          zone.run(() => {\r\n            self.onCommand$.next({ name: name, arg: arg });\r\n          });\r\n        },\r\n        onStart: function () {\r\n          zone.run(() => {\r\n            self.onStart$.next(null);\r\n          });\r\n        },\r\n        onStop: function () {\r\n          zone.run(() => {\r\n            self.onStop$.next(null);\r\n          });\r\n        }\r\n      }\r\n    }\r\n\r\n    this.onStartSub = this.onStartEvt$.subscribe(() => { });\r\n    this.onStopSub = this.onStopEvt$.subscribe(() => { });\r\n    this.onCommandSub = this.onCommandEvt$.subscribe(() => { });\r\n    //this.onConfigSub = this.onConfigEvt$.subscribe(() => { });\r\n    this.onPostMessageSub = this.onPostMessageEvt$.subscribe(() => { });\r\n\r\n    this.clientPromise = null;\r\n\r\n    this.onReady$.next(true);\r\n  }\r\n\r\n  /** @ignore */\r\n  ngOnDestroy(): void {\r\n\r\n    this.onStartSub?.unsubscribe();\r\n    this.onStopSub?.unsubscribe();\r\n    this.onCommandSub?.unsubscribe();\r\n    //this.onConfigSub?.unsubscribe();\r\n    this.onPostMessageSub?.unsubscribe();\r\n\r\n    this.onReady$.next(false);\r\n  }\r\n\r\n  /** @ignore */\r\n  public static init(data: any) {\r\n\r\n    console.log(\r\n      '%c⚙️ Initializing Revel Digital client library',\r\n      'background-color:blue; color:yellow;'\r\n    );\r\n  }\r\n\r\n  /**\r\n   * This method allows the gadget to communicate with player scripting.\r\n   * If the appropriate scripting is in place in the currently running template, calling this method\r\n   * will initiate a callback which can be acted upon in player script.\r\n   * \r\n   * @example\r\n   * client.callback('test', 'this');\r\n   * \r\n   * @param args variable number of arguments\r\n   */\r\n  public callback(...args: any[]): void {\r\n\r\n    this.getClient().then((client) => {\r\n\r\n      switch (args.length) {\r\n        case 0:\r\n          client.callback();\r\n          break;\r\n        case 1:\r\n          client.callback(args[0]);\r\n          break;\r\n        case 2:\r\n          client.callback(args[1]);\r\n          break;\r\n        case 3:\r\n          client.callback(args[2]);\r\n          break;\r\n        case 4:\r\n          client.callback(args[3]);\r\n          break;\r\n        case 5:\r\n          client.callback(args[4]);\r\n          break;\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Accessor method for the user preferences interface exposed by the Gadgets API.\r\n   * \r\n   * See {@link https://developers.google.com/gadgets/docs/basic} for more details on the Gadgets API.\r\n   * \r\n   * @example\r\n   * constructor(public client: PlayerClientService) {\r\n   *            let prefs = client.getPrefs();\r\n   *            let myString = prefs.getString('myStringPref');\r\n   * }\r\n   * @returns {gadgets.Prefs} Gadget API Prefs object\r\n   */\r\n  public getPrefs(): gadgets.Prefs {\r\n\r\n    return new window['gadgets']['Prefs']();\r\n  }\r\n\r\n  /**\r\n   * Returns the current device time in ISO8601 format.\r\n   * Current device time is determined by the device timezone assigned to the device in the CMS.\r\n   * \r\n   * @param date Optional. If supplied will translate the supplied date/time to device time based on respective timezones.\r\n   * @returns Date/time in ISO8601 format\r\n   */\r\n  public async getDeviceTime(date?: Date): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    if (date !== undefined) {\r\n      return client.getDeviceTime(date);\r\n    }\r\n    return client.getDeviceTime();\r\n  }\r\n\r\n  /**\r\n   * Returns the timezone name currently assigned to the device.\r\n   * \r\n   * @returns Timezone Name\r\n   */\r\n  public async getDeviceTimeZoneName(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneName();\r\n  }\r\n\r\n  /**\r\n   * Returns the timezone ID currently assigned to the device.\r\n   * \r\n   * @returns Timezone ID\r\n   */\r\n  public async getDeviceTimeZoneID(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneID();\r\n  }\r\n\r\n  /**\r\n   * Returns the numerical offset from GMT of the timezone currently assigned to the device.\r\n   * \r\n   * @returns Timezone offset\r\n   */\r\n  public async getDeviceTimeZoneOffset(): Promise<number> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneOffset();\r\n  }\r\n\r\n  /**\r\n   * Returns the language code of the language currently assigned to the device.\r\n   * \r\n   * @returns Language code\r\n   */\r\n  public async getLanguageCode(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getLanguageCode();\r\n  }\r\n\r\n  /**\r\n   * Returns the unique Revel Digital device key associated with the device.\r\n   * \r\n   * @returns Device key\r\n   */\r\n  public async getDeviceKey(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceKey();\r\n  }\r\n\r\n  /**\r\n   * Send a command to the player device.\r\n   * \r\n   * @param name Command name\r\n   * @param arg Command argument\r\n   */\r\n  public sendCommand(name: string, arg: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.sendCommand(name, arg);\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Send a command to any remote player with the supplied device key(s).\r\n   * Note: Remote commands can only be delivered to devices within the same account as the sender device.\r\n   * \r\n   * @param deviceKeys Array of remote device keys\r\n   * @param name Command name\r\n   * @param arg Command arg\r\n   */\r\n  public sendRemoteCommand(deviceKeys: string[], name: string, arg: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.sendRemoteCommand(deviceKeys, name, arg);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Log an event for use with AdHawk analytics.\r\n   * Events are used for tracking various metrics including usage statistics, player condition, state changes, etc.\r\n   * \r\n   * @param eventName Unique name for this event\r\n   * @param properties A map of user defined properties to associate with this event\r\n   */\r\n  public track(eventName: string, properties?: IEventProperties): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.track(eventName, JSON.stringify(properties));\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Method for initiating a timed event.\r\n   * Timed events are useful for tracking the duration of an event and must be proceeded with a call to track().\r\n   * \r\n   * @example\r\n   * client.timeEvent('testEvent');\r\n   * client.track(\"test\", { \"a\": \"b\" });\r\n   * @param eventName Unique name for this event\r\n   */\r\n  public timeEvent(eventName: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.timeEvent(eventName);\r\n    })\r\n  }\r\n\r\n  /**\r\n   * A session is a way of grouping events together. Each event has an associated session ID.\r\n   * Session ID's are randomly generated and reset by subsequent calls to newEventSession().\r\n   * \r\n   * Each call to track() will utilize the same session ID, until another call to newEventSession().\r\n   * @param id Optional. User supplied session ID. If not supplied a random session ID will be generated.\r\n   */\r\n  public newEventSession(id?: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      if (id !== undefined) {\r\n        client.newEventSession();\r\n      } else {\r\n        client.newEventSession(id);\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Returns the root folder utilized by this player device.\r\n   * \r\n   * @returns Path to the root folder\r\n   */\r\n  public async getRevelRoot(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getRevelRoot();\r\n  }\r\n\r\n  /**\r\n   * Returns a map of commands currently active for this device.\r\n   * \r\n   * @returns Map of commands currently active for this device.\r\n   */\r\n  public async getCommandMap(): Promise<any> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return JSON.parse(await client.getCommandMap());\r\n  }\r\n\r\n  /**\r\n   * Indicate to the player that this gadget has finished it's visualization.\r\n   * This allows the player to proceed with the next item in a playlist if applicable.\r\n   */\r\n  public finish(): void {\r\n\r\n    this.getClient().then((client) => {\r\n\r\n      client.finish();\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Check is the gadget is running in preview mode. Preview mode is enabled when the gadget is\r\n   * being edited in the CMS, or otherwise not running in a normal player environment.\r\n   * \r\n   * @returns True if the gadget is running in preview mode, false otherwise.\r\n   */\r\n  public async isPreviewMode(): Promise<boolean> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client instanceof NoopClient;\r\n  }\r\n\r\n  /**\r\n * Returns the device details associated with the player running the gadget or web app.\r\n * \r\n * @returns Device details.\r\n */\r\n  public async getDevice(): Promise<IDevice | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    let obj: any = JSON.parse(<string>await client.getDevice());\r\n\r\n    const device: IDevice[] = [obj].map((device: any) => {\r\n\r\n      return {\r\n        name: device.name,\r\n        registrationKey: device.key,\r\n        deviceType: device.devicetype,\r\n        enteredService: new Date(device.enteredservice),\r\n        langCode: device.langcode,\r\n        timeZone: device.timezone,\r\n        tags: device.description?.split('\\n'),\r\n        location: {\r\n          city: device.location?.city,\r\n          state: device.location?.state,\r\n          country: device.location?.country,\r\n          postalCode: device.location?.postalcode,\r\n          address: device.location?.address,\r\n          latitude: device.location?.latitude,\r\n          longitude: device.location?.longitude\r\n        }\r\n      }\r\n    });\r\n    return device[0];\r\n  }\r\n\r\n  /**\r\n   * Returns the width of the visualization area.\r\n   * \r\n   * @returns Width of the visualization area\r\n   */\r\n  public async getWidth(): Promise<number | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getWidth();\r\n  }\r\n\r\n  /**\r\n   * Returns the height of the visualization area.\r\n   * \r\n   * @returns Height of the visualization area\r\n   */\r\n  public async getHeight(): Promise<number | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getHeight();\r\n  }\r\n\r\n  /**\r\n   * Returns the duration of the currently playing source.\r\n   * (only applicable when associated with a playlist)\r\n   * \r\n   * @returns Duration of the current item in milliseconds\r\n   */\r\n  public async getDuration(): Promise<number | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDuration();\r\n  }\r\n\r\n  /**\r\n   * Returns the current SDK version.\r\n   * \r\n   * @returns SDK version\r\n   */\r\n  public async getSdkVersion(): Promise<string> {\r\n\r\n    return Promise.resolve(version);\r\n  }\r\n\r\n  public async applyConfig(prefs: IDictionary<any>) {\r\n\r\n    if (await this.isPreviewMode()) {\r\n      const client = await this.getClient();\r\n      client.applyConfig(prefs);\r\n    } else {\r\n      console.log(\r\n        '%capplyConfig() is only available in preview mode.',\r\n        'background-color:blue; color:yellow;'\r\n      );\r\n    }\r\n  }\r\n\r\n  // ---\r\n  // PRIVATE METHODS.\r\n  // ---\r\n  /** @ignore */\r\n  private getClient(): Promise<IClient> {\r\n\r\n    if (this.clientPromise) {\r\n\r\n      return (this.clientPromise);\r\n    }\r\n\r\n    if (window.Client) {\r\n\r\n      return (this.clientPromise = Promise.resolve(window.Client));\r\n    }\r\n\r\n    // A \"complete\" status indicates that the \"load\" event has been fired on the\r\n    // window; and, that all sub-resources such as Scripts, Images, and Frames have\r\n    // been loaded.\r\n    if (window.document.readyState === \"complete\") {\r\n\r\n      // If this event has fired AND the 3rd-party script isn't available (see IF-\r\n      // condition BEFORE this one), it means that the 3rd-party script either\r\n      // failed on the network or was BLOCKED by an ad-blocker. As such, we have to\r\n      // fall-back to using a mock API.\r\n      return (this.clientPromise = Promise.resolve(new NoopClient()));\r\n    }\r\n\r\n    // ASSERT: If we made it this far, the document has not completed loading (but it\r\n    // may be in an \"interactive\" state which is when I believe that the Angular app\r\n    // gets bootstrapped). As such, we need bind to the LOAD event to wait for our\r\n    // third-party scripts to load (or fail to load, or be blocked).\r\n    this.clientPromise = new Promise<IClient>(\r\n      (resolve) => {\r\n\r\n        window.addEventListener(\r\n          \"load\",\r\n          function handleWindowLoad() {\r\n\r\n            // At this point, the 3rd-party library is either available or\r\n            // it's not - there's no further loading to do. If it's not\r\n            // present on the global scope, we're going to fall-back to using\r\n            // a mock API.\r\n            resolve(window.Client || new NoopClient());\r\n          }\r\n        );\r\n\r\n      }\r\n    );\r\n\r\n    return (this.clientPromise);\r\n  }\r\n}\r\n\r\n\r\n\r\n// ----------------------------------------------------------------------------------- //\r\n// ----------------------------------------------------------------------------------- //\r\n\r\n// I provide a mock API for the 3rd-party script. This just allows the consuming code to\r\n// act as though the library is available even if it failed to load (example, it was\r\n// blocked by an ad-blocker).\r\n\r\n/** @ignore */\r\nclass NoopClient implements IClient {\r\n\r\n  constructor() {\r\n\r\n    console.log(\r\n      '%cClient API not available, falling back to mock API',\r\n      'background-color:blue; color:yellow;'\r\n    );\r\n  }\r\n\r\n  public callback(...args: any[]): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public getDeviceTime(date?: Date): Promise<string> {\r\n\r\n    return Promise.resolve(new Date().toISOString());\r\n  }\r\n\r\n  public async getDeviceTimeZoneName(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceTimeZoneID(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceTimeZoneOffset(): Promise<number> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getLanguageCode(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceKey(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public sendCommand(name: string, arg: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public sendRemoteCommand(deviceKeys: string[], name: string, arg: string) {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public track(eventName: string, properties?: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public timeEvent(eventName: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public newEventSession(id?: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public async getRevelRoot(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getCommandMap(): Promise<string> {\r\n\r\n    return Promise.resolve('{}');\r\n  }\r\n\r\n  public finish(): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public async getDevice(): Promise<string | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getWidth(): Promise<number | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getHeight(): Promise<number | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDuration(): Promise<number | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getSdkVersion(): Promise<string> {\r\n\r\n    return Promise.resolve(version);\r\n  }\r\n\r\n  public applyConfig(prefs: IDictionary<any>): void {\r\n\r\n    let evt = { type: 'applyConfig', prefs: prefs, isOpener: window.opener !== null };\r\n\r\n    if (window.opener) {\r\n      window.opener.postMessage(\r\n        JSON.stringify(evt),\r\n        '*'\r\n      );\r\n    } else {\r\n      window.parent.postMessage(\r\n        JSON.stringify(evt),\r\n        '*'\r\n      );\r\n    }\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"player-client.service.js","sourceRoot":"","sources":["../../../../../projects/reveldigital/player-client/src/lib/player-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, OnDestroy } from '@angular/core';\r\nimport { gadgets } from '@reveldigital/gadget-types';\r\nimport { BehaviorSubject, fromEvent, Subject, Subscription } from 'rxjs';\r\nimport { filter, map, share, tap } from 'rxjs/operators';\r\nimport { IClient } from './interfaces/client.interface';\r\nimport { ICommand } from './interfaces/command.interface';\r\nimport { IDictionary } from './interfaces/config.interface';\r\nimport { IDevice } from './interfaces/device.interface';\r\nimport { IEventProperties } from './interfaces/event-properties.interface';\r\nimport { version } from './version';\r\n\r\n//import { version } from './version.js';\r\n\r\n// So that TypeScript doesn't complain, we're going to augment the GLOBAL / WINDOW \r\n// name-space definition to include the Tracker API. This also provides us with a place\r\n// to actually DOCUMENT the API so that our developers aren't guessing about what's\r\n// available on the library.\r\n\r\n/** @ignore */\r\ndeclare global {\r\n  var Client: IClient;\r\n}\r\n\r\n/**\r\n * Service for interacting with the Revel Digital player client.\r\n * \r\n * This service provides a comprehensive interface for gadgets and web applications\r\n * to communicate with the Revel Digital player environment. It handles device\r\n * information, commands, events, analytics tracking, and configuration management.\r\n * \r\n * The service supports both direct API calls and event-based communication patterns,\r\n * allowing gadgets to respond to player lifecycle events (start, stop, commands) and\r\n * send data back to the player or remote devices.\r\n * \r\n * ```typescript\r\n * constructor(private client: PlayerClientService) {\r\n *   // Subscribe to player events\r\n *   this.client.onStart$.subscribe(() => {\r\n *     console.log('Gadget started');\r\n *   });\r\n *   \r\n *   this.client.onCommand$.subscribe(command => {\r\n *     console.log('Received command:', command);\r\n *   });\r\n * }\r\n * \r\n * async ngOnInit() {\r\n *   // Get device information\r\n *   const device = await this.client.getDevice();\r\n *   const deviceTime = await this.client.getDeviceTime();\r\n *   \r\n *   // Track analytics\r\n *   this.client.track('gadget_loaded', { version: '1.0' });\r\n * }\r\n * ```\r\n * \r\n * @since 1.0.0\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PlayerClientService implements OnDestroy {\r\n\r\n  /** @ignore */\r\n  private clientPromise: Promise<IClient> | null;\r\n\r\n  /**\r\n   * Observable stream of commands sent to this player from the Revel Digital platform.\r\n   * Subscribe to this to handle custom commands sent from templates, playlists, or remote devices.\r\n   * \r\n   * ```typescript\r\n   * this.client.onCommand$.subscribe(command => {\r\n   *   if (command.name === 'customAction') {\r\n   *     this.handleCustomAction(command.arg);\r\n   *   }\r\n   * });\r\n   * ```\r\n   */\r\n  public onCommand$ = new Subject<ICommand>();\r\n\r\n  /**\r\n   * Observable that signals when the gadget has been loaded and is ready to start.\r\n   * Emits `true` when ready, `false` when destroyed.\r\n   * \r\n   * ```typescript\r\n   * this.client.onReady$.subscribe(isReady => {\r\n   *   if (isReady) {\r\n   *     console.log('Client is ready');\r\n   *     this.initializeGadget();\r\n   *   }\r\n   * });\r\n   * ```\r\n   */\r\n  public onReady$ = new BehaviorSubject(false);\r\n\r\n  /**\r\n   * Observable that signals when the gadget has been started by the player.\r\n   * This event occurs when the player begins execution of the gadget content.\r\n   * \r\n   * ```typescript\r\n   * this.client.onStart$.subscribe(() => {\r\n   *   console.log('Gadget started');\r\n   *   this.startAnimation();\r\n   * });\r\n   * ```\r\n   */\r\n  public onStart$ = new Subject();\r\n\r\n  /**\r\n   * Observable that signals when the gadget has been stopped by the player.\r\n   * This event occurs when the player stops execution, typically when moving\r\n   * to the next item in a playlist or when the content duration expires.\r\n   * \r\n   * ```typescript\r\n   * this.client.onStop$.subscribe(() => {\r\n   *   console.log('Gadget stopped');\r\n   *   this.cleanup();\r\n   * });\r\n   * ```\r\n   */\r\n  public onStop$ = new Subject();\r\n\r\n  /**\r\n   * Observable that signals when the gadget should open the configuration window.\r\n   * This allows gadgets to respond to configuration requests from the player.\r\n   * \r\n   * ```typescript\r\n   * this.client.onConfig$.subscribe(() => {\r\n   *   this.openConfigurationDialog();\r\n   * });\r\n   * ```\r\n   */\r\n  public onConfig$ = new Subject();\r\n\r\n  /**\r\n   * Observable that signals when the gadget has received a postMessage event from the player.\r\n   * This handles communication between the gadget and player via the postMessage API.\r\n   * \r\n   * ```typescript\r\n   * this.client.onPostMessage$.subscribe(message => {\r\n   *   console.log('Received message:', message);\r\n   *   this.handlePlayerMessage(message);\r\n   * });\r\n   * ```\r\n   */\r\n  public onPostMessage$ = new Subject();\r\n\r\n  //\r\n  // Two methods available for calling into the library:\r\n  //\r\n  // 1) Using dispatchEvent() with the following custom events\r\n  // 2) Using the window scoped RevelDigital object as defined in the constructor\r\n  //\r\n  /** @ignore */\r\n  private onStartSub: Subscription;\r\n  /** @ignore */\r\n  private onStartEvt$ = fromEvent(window, 'RevelDigital.Start').pipe(\r\n    share(),\r\n    tap(this.onStart$)\r\n  );\r\n  /** @ignore */\r\n  private onStopSub: Subscription;\r\n  /** @ignore */\r\n  private onStopEvt$ = fromEvent(window, 'RevelDigital.Stop').pipe(\r\n    share(),\r\n    tap(this.onStop$)\r\n  );\r\n  /** @ignore */\r\n  private onCommandSub: Subscription;\r\n  /** @ignore */\r\n  private onCommandEvt$ = fromEvent<ICommand>(window, 'RevelDigital.Command').pipe(\r\n    map((e: any) => { return { name: e.detail.name, arg: e.detail.arg } as ICommand }),\r\n    share(),\r\n    tap(this.onCommand$)\r\n  );\r\n  /** @ignore */\r\n  // private onConfigSub: Subscription;\r\n  // /** @ignore */\r\n  // private onConfigEvt$ = fromEvent(window, 'RevelDigital.Config').pipe(\r\n  //   share(),\r\n  //   tap((e: CustomEvent) => {\r\n  //     console.log(e);\r\n\r\n  //     if (e.detail.type === 'applyConfig' && e.detail.isOpener) {\r\n  //       this.applyConfig(e.detail.config); // propagate config to iframe parent from the popup window\r\n  //     } else {\r\n  //       this.onConfig$.next(e.detail);\r\n  //     }\r\n  //   })\r\n  // );\r\n  // private onPostMessageSub: Subscription;\r\n  // private onPostMessageEvt$ = fromEvent(window, 'message').pipe(\r\n  //   filter((messageEvent: MessageEvent) =>\r\n  //     messageEvent.source !== window.parent &&\r\n  //     typeof messageEvent.data === 'string' &&\r\n  //     messageEvent.data.startsWith('reveldigital:')),\r\n  //   map((e: any) => { return JSON.parse(e.substring(13)) as Command }),\r\n  //   share(),\r\n  //   tap(this.onCommand$)\r\n  // );\r\n\r\n  private onPostMessageSub: Subscription;\r\n  private onPostMessageEvt$ = fromEvent(window, 'message').pipe(\r\n    filter((messageEvent: MessageEvent) =>\r\n      //messageEvent.source !== window.parent &&\r\n      typeof messageEvent.data === 'string'),\r\n    map((e: any) => JSON.parse(e.data)),\r\n    share(),\r\n    tap((e: any) => {\r\n      if (e.type === 'applyConfig' && e.isOpener) {\r\n        e.isOpener = false;\r\n        // propagate config to iframe parent from the popup window\r\n        window.parent.postMessage(\r\n          JSON.stringify(e),\r\n          '*'\r\n        );\r\n      } else if (e.type === 'openConfig') {\r\n        this.onConfig$.next(null);\r\n      }\r\n    }),\r\n    tap(e => this.onPostMessage$.next(e))\r\n  );\r\n\r\n\r\n  /** @ignore */\r\n  constructor(zone: NgZone) {\r\n\r\n    let self = this;\r\n    (window as any).RevelDigital = {\r\n      Controller: {\r\n        onCommand: function (name: string, arg: string) {\r\n          zone.run(() => {\r\n            self.onCommand$.next({ name: name, arg: arg });\r\n          });\r\n        },\r\n        onStart: function () {\r\n          zone.run(() => {\r\n            self.onStart$.next(null);\r\n          });\r\n        },\r\n        onStop: function () {\r\n          zone.run(() => {\r\n            self.onStop$.next(null);\r\n          });\r\n        }\r\n      }\r\n    }\r\n\r\n    this.onStartSub = this.onStartEvt$.subscribe(() => { });\r\n    this.onStopSub = this.onStopEvt$.subscribe(() => { });\r\n    this.onCommandSub = this.onCommandEvt$.subscribe(() => { });\r\n    //this.onConfigSub = this.onConfigEvt$.subscribe(() => { });\r\n    this.onPostMessageSub = this.onPostMessageEvt$.subscribe(() => { });\r\n\r\n    this.clientPromise = null;\r\n\r\n    this.onReady$.next(true);\r\n  }\r\n\r\n  /** @ignore */\r\n  ngOnDestroy(): void {\r\n\r\n    this.onStartSub?.unsubscribe();\r\n    this.onStopSub?.unsubscribe();\r\n    this.onCommandSub?.unsubscribe();\r\n    //this.onConfigSub?.unsubscribe();\r\n    this.onPostMessageSub?.unsubscribe();\r\n\r\n    this.onReady$.next(false);\r\n  }\r\n\r\n  /** @ignore */\r\n  public static init(data: any) {\r\n\r\n    console.log(\r\n      '%c⚙️ Initializing Revel Digital client library',\r\n      'background-color:blue; color:yellow;'\r\n    );\r\n  }\r\n\r\n  /**\r\n   * Sends a callback to player scripting with variable arguments.\r\n   * \r\n   * This method allows the gadget to communicate with player scripting.\r\n   * If the appropriate scripting is in place in the currently running template, \r\n   * calling this method will initiate a callback which can be acted upon in player script.\r\n   * \r\n   * @param args - Variable number of arguments to pass to the callback (max 5 arguments)\r\n   * \r\n   * ```typescript\r\n   * // Send a simple callback\r\n   * this.client.callback('test', 'data');\r\n   * \r\n   * // Send multiple parameters\r\n   * this.client.callback('action', 'value1', 'value2', { data: 'object' });\r\n   * ```\r\n   */\r\n  public callback(...args: any[]): void {\r\n\r\n    this.getClient().then((client) => {\r\n\r\n      switch (args.length) {\r\n        case 0:\r\n          client.callback();\r\n          break;\r\n        case 1:\r\n          client.callback(args[0]);\r\n          break;\r\n        case 2:\r\n          client.callback(args[1]);\r\n          break;\r\n        case 3:\r\n          client.callback(args[2]);\r\n          break;\r\n        case 4:\r\n          client.callback(args[3]);\r\n          break;\r\n        case 5:\r\n          client.callback(args[4]);\r\n          break;\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Gets the user preferences interface exposed by the Google Gadgets API.\r\n   * \r\n   * This method provides access to gadget preferences which can be configured\r\n   * in the Revel Digital CMS. Use this to retrieve user-configurable settings\r\n   * for your gadget.\r\n   * \r\n   * @returns The Gadgets API Prefs object for accessing preference values\r\n   * \r\n   * ```typescript\r\n   * constructor(public client: PlayerClientService) {\r\n   *   const prefs = client.getPrefs();\r\n   *   const myString = prefs.getString('myStringPref');\r\n   *   const myNumber = prefs.getInt('myNumberPref');\r\n   *   const myBool = prefs.getBool('myBoolPref');\r\n   * }\r\n   * ```\r\n   * \r\n   * @see {@link https://developers.google.com/gadgets/docs/basic} Google Gadgets API documentation\r\n   */\r\n  public getPrefs(): gadgets.Prefs {\r\n\r\n    return new window['gadgets']['Prefs']();\r\n  }\r\n\r\n  /**\r\n   * Gets the current device time in ISO8601 format.\r\n   * \r\n   * Current device time is determined by the device timezone assigned to the device in the CMS.\r\n   * This is useful for displaying time-sensitive content or scheduling operations based on\r\n   * the device's local time rather than browser time.\r\n   * \r\n   * @param date - Optional. If supplied, will translate the supplied date/time to device time based on respective timezones\r\n   * @returns Promise resolving to date/time in ISO8601 format\r\n   * \r\n   * ```typescript\r\n   * // Get current device time\r\n   * const currentTime = await this.client.getDeviceTime();\r\n   * console.log('Device time:', currentTime);\r\n   * \r\n   * // Convert a specific date to device time\r\n   * const specificDate = new Date('2023-01-01T12:00:00Z');\r\n   * const deviceTime = await this.client.getDeviceTime(specificDate);\r\n   * ```\r\n   */\r\n  public async getDeviceTime(date?: Date): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    if (date !== undefined) {\r\n      return client.getDeviceTime(date);\r\n    }\r\n    return client.getDeviceTime();\r\n  }\r\n\r\n  /**\r\n   * Gets the timezone name currently assigned to the device.\r\n   * \r\n   * @returns Promise resolving to the timezone name (e.g., \"America/New_York\")\r\n   * \r\n   * ```typescript\r\n   * const timezoneName = await this.client.getDeviceTimeZoneName();\r\n   * console.log('Device timezone:', timezoneName);\r\n   * ```\r\n   */\r\n  public async getDeviceTimeZoneName(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneName();\r\n  }\r\n\r\n  /**\r\n   * Gets the timezone ID currently assigned to the device.\r\n   * \r\n   * @returns Promise resolving to the timezone ID\r\n   * \r\n   * ```typescript\r\n   * const timezoneId = await this.client.getDeviceTimeZoneID();\r\n   * console.log('Device timezone ID:', timezoneId);\r\n   * ```\r\n   */\r\n  public async getDeviceTimeZoneID(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneID();\r\n  }\r\n\r\n  /**\r\n   * Gets the numerical offset from GMT of the timezone currently assigned to the device.\r\n   * \r\n   * @returns Promise resolving to the timezone offset in hours (e.g., -5 for EST)\r\n   * \r\n   * ```typescript\r\n   * const offset = await this.client.getDeviceTimeZoneOffset();\r\n   * console.log('Device timezone offset:', offset, 'hours from GMT');\r\n   * ```\r\n   */\r\n  public async getDeviceTimeZoneOffset(): Promise<number> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneOffset();\r\n  }\r\n\r\n  /**\r\n   * Gets the language code of the language currently assigned to the device.\r\n   * \r\n   * @returns Promise resolving to the language code (e.g., \"en-US\", \"fr-FR\")\r\n   * \r\n   * ```typescript\r\n   * const languageCode = await this.client.getLanguageCode();\r\n   * console.log('Device language:', languageCode);\r\n   * // Use for localization\r\n   * this.loadLanguageResources(languageCode);\r\n   * ```\r\n   */\r\n  public async getLanguageCode(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getLanguageCode();\r\n  }\r\n\r\n  /**\r\n   * Gets the unique Revel Digital device key associated with the device.\r\n   * \r\n   * The device key is a unique identifier for this specific player device\r\n   * and can be used for device-specific operations or remote commands.\r\n   * \r\n   * @returns Promise resolving to the device key string\r\n   * \r\n   * ```typescript\r\n   * const deviceKey = await this.client.getDeviceKey();\r\n   * console.log('Device key:', deviceKey);\r\n   * ```\r\n   */\r\n  public async getDeviceKey(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceKey();\r\n  }\r\n\r\n  /**\r\n   * Sends a command to the local player device.\r\n   * \r\n   * Commands can be used to control various aspects of the player or trigger\r\n   * specific behaviors. The command is processed by the local player only.\r\n   * \r\n   * @param name - The command name/identifier\r\n   * @param arg - The command argument/payload\r\n   * \r\n   * ```typescript\r\n   * // Send a simple command\r\n   * this.client.sendCommand('refresh', '');\r\n   * \r\n   * // Send a command with data\r\n   * this.client.sendCommand('setVolume', '50');\r\n   * \r\n   * // Send a command with JSON data\r\n   * this.client.sendCommand('configure', JSON.stringify({ setting: 'value' }));\r\n   * ```\r\n   */\r\n  public sendCommand(name: string, arg: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.sendCommand(name, arg);\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Sends a command to remote player devices with the specified device keys.\r\n   * \r\n   * Remote commands allow cross-device communication within the same Revel Digital account.\r\n   * This is useful for synchronized displays, device coordination, or remote control scenarios.\r\n   * \r\n   * Note: Remote commands can only be delivered to devices within the same account as the sender device.\r\n   * \r\n   * @param deviceKeys - Array of target device keys to send the command to\r\n   * @param name - The command name/identifier\r\n   * @param arg - The command argument/payload\r\n   * \r\n   * ```typescript\r\n   * // Send command to specific devices\r\n   * const targetDevices = ['device-key-1', 'device-key-2'];\r\n   * this.client.sendRemoteCommand(targetDevices, 'syncAction', 'start');\r\n   * \r\n   * // Broadcast to multiple devices\r\n   * this.client.sendRemoteCommand(\r\n   *   ['lobby-display', 'kiosk-1', 'kiosk-2'], \r\n   *   'updateContent', \r\n   *   JSON.stringify({ contentId: '12345' })\r\n   * );\r\n   * ```\r\n   */\r\n  public sendRemoteCommand(deviceKeys: string[], name: string, arg: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.sendRemoteCommand(deviceKeys, name, arg);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Logs an analytics event for use with AdHawk analytics and reporting.\r\n   * \r\n   * Events are used for tracking various metrics including usage statistics, \r\n   * player condition, state changes, user interactions, and custom business metrics.\r\n   * These events can be viewed in the Revel Digital analytics dashboard.\r\n   * \r\n   * @param eventName - Unique name for this event (should be descriptive and consistent)\r\n   * @param properties - Optional map of user-defined properties to associate with this event\r\n   * \r\n   * ```typescript\r\n   * // Simple event tracking\r\n   * this.client.track('gadget_loaded');\r\n   * \r\n   * // Event with properties\r\n   * this.client.track('user_interaction', {\r\n   *   action: 'button_click',\r\n   *   button_id: 'start_button',\r\n   *   timestamp: new Date().toISOString()\r\n   * });\r\n   * \r\n   * // Performance tracking\r\n   * this.client.track('content_displayed', {\r\n   *   content_type: 'video',\r\n   *   duration: 30,\r\n   *   quality: 'HD'\r\n   * });\r\n   * ```\r\n   */\r\n  public track(eventName: string, properties?: IEventProperties): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.track(eventName, JSON.stringify(properties));\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Initiates a timed event for duration tracking.\r\n   * \r\n   * Timed events are useful for tracking the duration of operations or user interactions.\r\n   * This method must be followed by a call to track() with the same event name to complete\r\n   * the timing measurement. The duration will be automatically calculated and included\r\n   * in the event properties.\r\n   * \r\n   * @param eventName - Unique name for this timed event (must match the subsequent track() call)\r\n   * \r\n   * ```typescript\r\n   * // Start timing an event\r\n   * this.client.timeEvent('video_playback');\r\n   * \r\n   * // ... video plays for some duration ...\r\n   * \r\n   * // End timing and log the event with duration\r\n   * this.client.track('video_playback', {\r\n   *   video_id: 'abc123',\r\n   *   quality: 'HD'\r\n   * }); // Duration will be automatically added\r\n   * \r\n   * // Example for user interaction timing\r\n   * this.client.timeEvent('form_completion');\r\n   * // ... user fills out form ...\r\n   * this.client.track('form_completion', { form_type: 'contact' });\r\n   * ```\r\n   */\r\n  public timeEvent(eventName: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.timeEvent(eventName);\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Creates a new analytics event session for grouping related events.\r\n   * \r\n   * A session is a way of grouping events together for analysis. Each event tracked\r\n   * after calling this method will have the same session ID until a new session is created.\r\n   * Session IDs are randomly generated unless explicitly provided.\r\n   * \r\n   * This is useful for tracking user journeys, workflow completion, or grouping\r\n   * related interactions within a specific time period.\r\n   * \r\n   * @param id - Optional user-supplied session ID. If not provided, a random session ID will be generated\r\n   * \r\n   * ```typescript\r\n   * // Start a new session with auto-generated ID\r\n   * this.client.newEventSession();\r\n   * this.client.track('session_start');\r\n   * this.client.track('user_action_1');\r\n   * this.client.track('user_action_2');\r\n   * \r\n   * // Start a session with custom ID\r\n   * this.client.newEventSession('user-workflow-12345');\r\n   * this.client.track('workflow_start');\r\n   * this.client.track('step_completed', { step: 1 });\r\n   * \r\n   * // Start a new session for different workflow\r\n   * this.client.newEventSession();\r\n   * this.client.track('different_workflow_start');\r\n   * ```\r\n   */\r\n  public newEventSession(id?: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      if (id !== undefined) {\r\n        client.newEventSession();\r\n      } else {\r\n        client.newEventSession(id);\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Gets the root folder path utilized by this player device.\r\n   * \r\n   * This returns the base directory path where the Revel Digital player\r\n   * stores its files and resources on the local device.\r\n   * \r\n   * @returns Promise resolving to the path of the root folder\r\n   * \r\n   * ```typescript\r\n   * const rootPath = await this.client.getRevelRoot();\r\n   * console.log('Player root directory:', rootPath);\r\n   * // Use for constructing file paths or understanding storage structure\r\n   * ```\r\n   */\r\n  public async getRevelRoot(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getRevelRoot();\r\n  }\r\n\r\n  /**\r\n   * Gets a map of commands currently active for this device.\r\n   * \r\n   * This returns the current command configuration that defines how the device\r\n   * responds to various command triggers and remote commands.\r\n   * \r\n   * @returns Promise resolving to a map of currently active commands\r\n   * \r\n   * ```typescript\r\n   * const commandMap = await this.client.getCommandMap();\r\n   * console.log('Active commands:', commandMap);\r\n   * \r\n   * // Check if specific command is available\r\n   * if (commandMap['customCommand']) {\r\n   *   console.log('Custom command is available');\r\n   * }\r\n   * ```\r\n   */\r\n  public async getCommandMap(): Promise<any> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return JSON.parse(await client.getCommandMap());\r\n  }\r\n\r\n  /**\r\n   * Signals to the player that this gadget has completed its visualization.\r\n   * \r\n   * This method notifies the player that the current gadget has finished its\r\n   * content display or interaction cycle. The player can then proceed with\r\n   * the next item in a playlist if applicable, or handle the completion\r\n   * according to its configuration.\r\n   * \r\n   * Call this method when your gadget has completed its intended function,\r\n   * such as finishing an animation, completing a form, or reaching a natural\r\n   * stopping point.\r\n   * \r\n   * ```typescript\r\n   * // After completing an animation\r\n   * private onAnimationComplete(): void {\r\n   *   this.client.finish();\r\n   * }\r\n   * \r\n   * // After user interaction is complete\r\n   * private onFormSubmitted(): void {\r\n   *   this.saveFormData();\r\n   *   this.client.finish();\r\n   * }\r\n   * \r\n   * // After a timed display period\r\n   * setTimeout(() => {\r\n   *   this.client.finish();\r\n   * }, 30000); // 30 seconds\r\n   * ```\r\n   */\r\n  public finish(): void {\r\n\r\n    this.getClient().then((client) => {\r\n\r\n      client.finish();\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Checks if the gadget is running in preview mode.\r\n   * \r\n   * Preview mode is enabled when the gadget is being edited in the Revel Digital CMS,\r\n   * tested in the gadget editor, or otherwise not running in a normal player environment.\r\n   * This is useful for providing different behavior during development/testing versus\r\n   * production deployment.\r\n   * \r\n   * @returns Promise resolving to true if running in preview mode, false if running on actual player\r\n   * \r\n   * ```typescript\r\n   * const isPreview = await this.client.isPreviewMode();\r\n   * \r\n   * if (isPreview) {\r\n   *   console.log('Running in preview mode - using mock data');\r\n   *   this.loadMockData();\r\n   * } else {\r\n   *   console.log('Running on player device - using live data');\r\n   *   this.loadLiveData();\r\n   * }\r\n   * \r\n   * // Show different UI in preview\r\n   * this.showPreviewIndicator = isPreview;\r\n   * ```\r\n   */\r\n  public async isPreviewMode(): Promise<boolean> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client instanceof NoopClient;\r\n  }\r\n\r\n  /**\r\n   * Gets detailed information about the device running the player.\r\n   * \r\n   * Returns comprehensive device details including name, registration key, type,\r\n   * service date, language, timezone, tags, and location information. This data\r\n   * is configured in the Revel Digital CMS for each device.\r\n   * \r\n   * @returns Promise resolving to device details object, or null if not available\r\n   * \r\n   * ```typescript\r\n   * const device = await this.client.getDevice();\r\n   * \r\n   * if (device) {\r\n   *   console.log('Device name:', device.name);\r\n   *   console.log('Device type:', device.deviceType);\r\n   *   console.log('Location:', device.location.city, device.location.state);\r\n   *   console.log('Tags:', device.tags);\r\n   *   \r\n   *   // Use device info for customization\r\n   *   if (device.location.country === 'US') {\r\n   *     this.loadUSContent();\r\n   *   }\r\n   *   \r\n   *   // Check device capabilities based on type\r\n   *   if (device.deviceType === 'android') {\r\n   *     this.enableTouchFeatures();\r\n   *   }\r\n   * }\r\n   * ```\r\n   */\r\n  public async getDevice(): Promise<IDevice | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    let obj: any = JSON.parse(<string>await client.getDevice());\r\n\r\n    const device: IDevice[] = [obj].map((device: any) => {\r\n\r\n      return {\r\n        name: device.name,\r\n        registrationKey: device.key,\r\n        deviceType: device.devicetype,\r\n        enteredService: new Date(device.enteredservice),\r\n        langCode: device.langcode,\r\n        timeZone: device.timezone,\r\n        tags: device.description?.split('\\n'),\r\n        location: {\r\n          city: device.location?.city,\r\n          state: device.location?.state,\r\n          country: device.location?.country,\r\n          postalCode: device.location?.postalcode,\r\n          address: device.location?.address,\r\n          latitude: device.location?.latitude,\r\n          longitude: device.location?.longitude\r\n        }\r\n      }\r\n    });\r\n    return device[0];\r\n  }\r\n\r\n  /**\r\n   * Gets the width of the visualization area in pixels.\r\n   * \r\n   * This returns the available width for content display, which may be\r\n   * different from the full screen width depending on player configuration\r\n   * and template layout.\r\n   * \r\n   * @returns Promise resolving to width in pixels, or null if not available\r\n   * \r\n   * ```typescript\r\n   * const width = await this.client.getWidth();\r\n   * \r\n   * if (width) {\r\n   *   console.log('Available width:', width, 'pixels');\r\n   *   \r\n   *   // Adapt content layout based on width\r\n   *   if (width < 800) {\r\n   *     this.enableMobileLayout();\r\n   *   } else {\r\n   *     this.enableDesktopLayout();\r\n   *   }\r\n   * }\r\n   * ```\r\n   */\r\n  public async getWidth(): Promise<number | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getWidth();\r\n  }\r\n\r\n  /**\r\n   * Gets the height of the visualization area in pixels.\r\n   * \r\n   * This returns the available height for content display, which may be\r\n   * different from the full screen height depending on player configuration\r\n   * and template layout.\r\n   * \r\n   * @returns Promise resolving to height in pixels, or null if not available\r\n   * \r\n   * ```typescript\r\n   * const height = await this.client.getHeight();\r\n   * \r\n   * if (height) {\r\n   *   console.log('Available height:', height, 'pixels');\r\n   *   \r\n   *   // Calculate aspect ratio for responsive design\r\n   *   const width = await this.client.getWidth();\r\n   *   const aspectRatio = width / height;\r\n   *   this.adjustContentForAspectRatio(aspectRatio);\r\n   * }\r\n   * ```\r\n   */\r\n  public async getHeight(): Promise<number | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getHeight();\r\n  }\r\n\r\n  /**\r\n   * Gets the duration of the currently playing content item.\r\n   * \r\n   * This method is only applicable when the gadget is associated with a playlist\r\n   * and returns the duration assigned to the current playlist item. The duration\r\n   * determines how long the content should be displayed before moving to the next item.\r\n   * \r\n   * @returns Promise resolving to duration in milliseconds, or null if not applicable/available\r\n   * \r\n   * ```typescript\r\n   * const duration = await this.client.getDuration();\r\n   * \r\n   * if (duration) {\r\n   *   console.log('Content duration:', duration, 'milliseconds');\r\n   *   \r\n   *   // Set up auto-finish timer\r\n   *   setTimeout(() => {\r\n   *     this.client.finish();\r\n   *   }, duration);\r\n   *   \r\n   *   // Show progress indicator\r\n   *   this.startProgressIndicator(duration);\r\n   * }\r\n   * ```\r\n   */\r\n  public async getDuration(): Promise<number | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDuration();\r\n  }\r\n\r\n  /**\r\n   * Gets the current version of the Revel Digital SDK.\r\n   * \r\n   * @returns Promise resolving to the SDK version string\r\n   * \r\n   * ```typescript\r\n   * const version = await this.client.getSdkVersion();\r\n   * console.log('SDK Version:', version);\r\n   * \r\n   * // Use for compatibility checks or logging\r\n   * this.client.track('gadget_loaded', { sdkVersion: version });\r\n   * ```\r\n   */\r\n  public async getSdkVersion(): Promise<string> {\r\n\r\n    return Promise.resolve(version);\r\n  }\r\n\r\n  /**\r\n   * Applies configuration preferences to the gadget (preview mode only).\r\n   * \r\n   * This method is only available when running in preview mode (typically during\r\n   * gadget development or testing in the CMS). It allows applying configuration\r\n   * changes that would normally come from the gadget's preference settings.\r\n   * \r\n   * @param prefs - Dictionary of preference key-value pairs to apply\r\n   * \r\n   * ```typescript\r\n   * if (await this.client.isPreviewMode()) {\r\n   *   // Apply test configuration in preview\r\n   *   await this.client.applyConfig({\r\n   *     'title': 'Test Title',\r\n   *     'backgroundColor': '#ff0000',\r\n   *     'showBorder': true,\r\n   *     'refreshInterval': 30\r\n   *   });\r\n   * }\r\n   * ```\r\n   */\r\n  public async applyConfig(prefs: IDictionary<any>) {\r\n\r\n    if (await this.isPreviewMode()) {\r\n      const client = await this.getClient();\r\n      client.applyConfig(prefs);\r\n    } else {\r\n      console.log(\r\n        '%capplyConfig() is only available in preview mode.',\r\n        'background-color:blue; color:yellow;'\r\n      );\r\n    }\r\n  }\r\n\r\n  // ---\r\n  // PRIVATE METHODS.\r\n  // ---\r\n  /** @ignore */\r\n  private getClient(): Promise<IClient> {\r\n\r\n    if (this.clientPromise) {\r\n\r\n      return (this.clientPromise);\r\n    }\r\n\r\n    if (window.Client) {\r\n\r\n      return (this.clientPromise = Promise.resolve(window.Client));\r\n    }\r\n\r\n    // A \"complete\" status indicates that the \"load\" event has been fired on the\r\n    // window; and, that all sub-resources such as Scripts, Images, and Frames have\r\n    // been loaded.\r\n    if (window.document.readyState === \"complete\") {\r\n\r\n      // If this event has fired AND the 3rd-party script isn't available (see IF-\r\n      // condition BEFORE this one), it means that the 3rd-party script either\r\n      // failed on the network or was BLOCKED by an ad-blocker. As such, we have to\r\n      // fall-back to using a mock API.\r\n      return (this.clientPromise = Promise.resolve(new NoopClient()));\r\n    }\r\n\r\n    // ASSERT: If we made it this far, the document has not completed loading (but it\r\n    // may be in an \"interactive\" state which is when I believe that the Angular app\r\n    // gets bootstrapped). As such, we need bind to the LOAD event to wait for our\r\n    // third-party scripts to load (or fail to load, or be blocked).\r\n    this.clientPromise = new Promise<IClient>(\r\n      (resolve) => {\r\n\r\n        window.addEventListener(\r\n          \"load\",\r\n          function handleWindowLoad() {\r\n\r\n            // At this point, the 3rd-party library is either available or\r\n            // it's not - there's no further loading to do. If it's not\r\n            // present on the global scope, we're going to fall-back to using\r\n            // a mock API.\r\n            resolve(window.Client || new NoopClient());\r\n          }\r\n        );\r\n\r\n      }\r\n    );\r\n\r\n    return (this.clientPromise);\r\n  }\r\n}\r\n\r\n\r\n\r\n// ----------------------------------------------------------------------------------- //\r\n// ----------------------------------------------------------------------------------- //\r\n\r\n/**\r\n * Mock implementation of the IClient interface.\r\n * \r\n * This class provides a no-operation (NOOP) implementation of the client API\r\n * that allows consuming code to function normally even when the actual player\r\n * API is not available. This typically occurs during development, testing,\r\n * or when the player script is blocked by ad-blockers.\r\n * \r\n * All methods in this class either return null/empty values or perform no\r\n * operations, allowing gadgets to function without errors while providing\r\n * appropriate fallback behavior.\r\n * \r\n * @private\r\n */\r\nclass NoopClient implements IClient {\r\n\r\n  constructor() {\r\n\r\n    console.log(\r\n      '%cClient API not available, falling back to mock API',\r\n      'background-color:blue; color:yellow;'\r\n    );\r\n  }\r\n\r\n  public callback(...args: any[]): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public getDeviceTime(date?: Date): Promise<string> {\r\n\r\n    return Promise.resolve(new Date().toISOString());\r\n  }\r\n\r\n  public async getDeviceTimeZoneName(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceTimeZoneID(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceTimeZoneOffset(): Promise<number> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getLanguageCode(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceKey(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public sendCommand(name: string, arg: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public sendRemoteCommand(deviceKeys: string[], name: string, arg: string) {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public track(eventName: string, properties?: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public timeEvent(eventName: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public newEventSession(id?: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public async getRevelRoot(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getCommandMap(): Promise<string> {\r\n\r\n    return Promise.resolve('{}');\r\n  }\r\n\r\n  public finish(): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public async getDevice(): Promise<string | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getWidth(): Promise<number | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getHeight(): Promise<number | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDuration(): Promise<number | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getSdkVersion(): Promise<string> {\r\n\r\n    return Promise.resolve(version);\r\n  }\r\n\r\n  public applyConfig(prefs: IDictionary<any>): void {\r\n\r\n    let evt = { type: 'applyConfig', prefs: prefs, isOpener: window.opener !== null };\r\n\r\n    if (window.opener) {\r\n      window.opener.postMessage(\r\n        JSON.stringify(evt),\r\n        '*'\r\n      );\r\n    } else {\r\n      window.parent.postMessage(\r\n        JSON.stringify(evt),\r\n        '*'\r\n      );\r\n    }\r\n  }\r\n}\r\n"]}