@reveldigital/player-client 2.8.0 → 2.10.0

package/esm2022/lib/interfaces/powerbi.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

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

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

package/esm2022/lib/powerbi-ref.mjs

@@ -0,0 +1,146 @@
+import { decode } from 'html-entities';
+/**
+ * Angular-friendly wrapper around the global `gadgets.reveldigital.powerbi` library.
+ *
+ * Provides typed Promise-based methods for embedding Power BI reports and dashboards.
+ *
+ * ```typescript
+ * const pbi = this.client.createPowerBI({
+ *   workspaceId: '...',
+ *   reportId: '...',
+ *   container: this.containerEl.nativeElement
+ * });
+ *
+ * // Embed the report
+ * await pbi.embed();
+ *
+ * // Refresh the token
+ * await pbi.refresh();
+ *
+ * // Cleanup
+ * pbi.dispose();
+ * ```
+ */
+export class PowerBIRef {
+    /**
+     * Creates a new PowerBIRef.
+     *
+     * @param options - Power BI embed configuration
+     * @param zone - Angular NgZone for ensuring change detection on callbacks
+     * @throws Error if the global Power BI library is not loaded
+     */
+    constructor(options, zone) {
+        this._zone = zone;
+        const lib = window.gadgets?.['reveldigital.powerbi'];
+        if (!lib || typeof lib.create !== 'function') {
+            throw new Error('RevelDigital PowerBI library is not available. ' +
+                'Ensure the Power BI feature is enabled for this gadget.');
+        }
+        this._instance = lib.create(options);
+    }
+    /**
+     * Fetches the embed configuration from the API and renders the Power BI
+     * content in the container element.
+     *
+     * @returns Promise resolving to the embed configuration returned by the API
+     */
+    embed() {
+        return this._zone.run(() => this._instance.embed());
+    }
+    /**
+     * Refreshes the embed token without re-rendering.
+     *
+     * @returns Promise resolving when the token has been refreshed
+     */
+    refresh() {
+        return this._zone.run(() => this._instance.refresh());
+    }
+    /**
+     * Releases all resources: stops the token refresh timer and disposes
+     * the embedded Power BI component.
+     */
+    dispose() {
+        this._instance.dispose();
+    }
+    /** @ignore */
+    static _fromInstance(instance, zone) {
+        const ref = Object.create(PowerBIRef.prototype);
+        ref._instance = instance;
+        ref._zone = zone;
+        return ref;
+    }
+}
+/**
+ * Wrapper around a Power BI embed created from a gadget preference value.
+ *
+ * Automatically configures workspace, report/dashboard, and display settings
+ * from the preference.
+ *
+ * ```typescript
+ * const pbi = this.client.createPowerBIFromPref(
+ *   prefs.getString('rdPowerBI'),
+ *   this.containerEl.nativeElement
+ * );
+ *
+ * // Embed with preference settings
+ * await pbi.embed();
+ *
+ * // Cleanup
+ * pbi.dispose();
+ * ```
+ */
+export class PowerBIPrefRef {
+    /**
+     * Creates a new PowerBIPrefRef from a gadget preference JSON string.
+     *
+     * @param prefValue - The raw gadget preference string (JSON)
+     * @param container - DOM element to embed into
+     * @param zone - Angular NgZone for ensuring change detection on callbacks
+     * @param extraOptions - Additional options to merge
+     * @throws Error if the global Power BI library is not loaded
+     */
+    constructor(prefValue, container, zone, extraOptions) {
+        const lib = window.gadgets?.['reveldigital.powerbi'];
+        if (!lib || typeof lib.createFromPref !== 'function') {
+            throw new Error('RevelDigital PowerBI library is not available. ' +
+                'Ensure the Power BI feature is enabled for this gadget.');
+        }
+        // gadgets.Prefs.getString() returns HTML-encoded values, decode before parsing
+        const decoded = decode(prefValue);
+        const instance = lib.createFromPref(decoded, container, extraOptions);
+        this.pref = this._parsePref(decoded);
+        this.powerBI = PowerBIRef._fromInstance(instance, zone);
+    }
+    /**
+     * Fetches the embed configuration and renders the Power BI content.
+     *
+     * @returns Promise resolving to the embed configuration
+     */
+    embed() {
+        return this.powerBI.embed();
+    }
+    /**
+     * Refreshes the embed token without re-rendering.
+     *
+     * @returns Promise resolving when the token has been refreshed
+     */
+    refresh() {
+        return this.powerBI.refresh();
+    }
+    /**
+     * Releases all resources held by the underlying PowerBIRef.
+     */
+    dispose() {
+        this.powerBI.dispose();
+    }
+    /** @ignore */
+    _parsePref(decoded) {
+        try {
+            return JSON.parse(decoded);
+        }
+        catch {
+            return {};
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"powerbi-ref.js","sourceRoot":"","sources":["../../../../../projects/reveldigital/player-client/src/lib/powerbi-ref.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAGvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,OAAO,UAAU;IAQrB;;;;;;OAMG;IACH,YAAY,OAAwB,EAAE,IAAY;QAEhD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QAElB,MAAM,GAAG,GAAI,MAAc,CAAC,OAAO,EAAE,CAAC,sBAAsB,CAAC,CAAC;QAE9D,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,CAAC,MAAM,KAAK,UAAU,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CACb,iDAAiD;gBACjD,yDAAyD,CAC1D,CAAC;QACJ,CAAC;QAED,IAAI,CAAC,SAAS,GAAG,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACI,KAAK;QACV,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;IACtD,CAAC;IAED;;;;OAIG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC,CAAC;IACxD,CAAC;IAED;;;OAGG;IACI,OAAO;QACZ,IAAI,CAAC,SAAS,CAAC,OAAO,EAAE,CAAC;IAC3B,CAAC;IAED,cAAc;IACd,MAAM,CAAC,aAAa,CAAC,QAAa,EAAE,IAAY;QAC9C,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC,SAAS,CAAe,CAAC;QAC9D,GAAG,CAAC,SAAS,GAAG,QAAQ,CAAC;QACzB,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC;QACjB,OAAO,GAAG,CAAC;IACb,CAAC;CACF;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,OAAO,cAAc;IAQzB;;;;;;;;OAQG;IACH,YAAY,SAAiB,EAAE,SAAsB,EAAE,IAAY,EAAE,YAAuC;QAE1G,MAAM,GAAG,GAAI,MAAc,CAAC,OAAO,EAAE,CAAC,sBAAsB,CAAC,CAAC;QAE9D,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,CAAC,cAAc,KAAK,UAAU,EAAE,CAAC;YACrD,MAAM,IAAI,KAAK,CACb,iDAAiD;gBACjD,yDAAyD,CAC1D,CAAC;QACJ,CAAC;QAED,+EAA+E;QAC/E,MAAM,OAAO,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;QAElC,MAAM,QAAQ,GAAG,GAAG,CAAC,cAAc,CAAC,OAAO,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;QACtE,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACrC,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC,aAAa,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;IAC1D,CAAC;IAED;;;;OAIG;IACI,KAAK;QACV,OAAO,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;IAC9B,CAAC;IAED;;;;OAIG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAChC,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IACzB,CAAC;IAED,cAAc;IACN,UAAU,CAAC,OAAe;QAChC,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;QAC7B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;CACF","sourcesContent":["import { NgZone } from '@angular/core';\nimport { decode } from 'html-entities';\nimport { IPowerBIOptions, IPowerBIPref } from './interfaces/powerbi.interface';\n\n/**\n * Angular-friendly wrapper around the global `gadgets.reveldigital.powerbi` library.\n *\n * Provides typed Promise-based methods for embedding Power BI reports and dashboards.\n *\n * ```typescript\n * const pbi = this.client.createPowerBI({\n *   workspaceId: '...',\n *   reportId: '...',\n *   container: this.containerEl.nativeElement\n * });\n *\n * // Embed the report\n * await pbi.embed();\n *\n * // Refresh the token\n * await pbi.refresh();\n *\n * // Cleanup\n * pbi.dispose();\n * ```\n */\nexport class PowerBIRef {\n\n  /** @ignore */\n  private _instance: any;\n\n  /** @ignore */\n  private _zone: NgZone;\n\n  /**\n   * Creates a new PowerBIRef.\n   *\n   * @param options - Power BI embed configuration\n   * @param zone - Angular NgZone for ensuring change detection on callbacks\n   * @throws Error if the global Power BI library is not loaded\n   */\n  constructor(options: IPowerBIOptions, zone: NgZone) {\n\n    this._zone = zone;\n\n    const lib = (window as any).gadgets?.['reveldigital.powerbi'];\n\n    if (!lib || typeof lib.create !== 'function') {\n      throw new Error(\n        'RevelDigital PowerBI library is not available. ' +\n        'Ensure the Power BI feature is enabled for this gadget.'\n      );\n    }\n\n    this._instance = lib.create(options);\n  }\n\n  /**\n   * Fetches the embed configuration from the API and renders the Power BI\n   * content in the container element.\n   *\n   * @returns Promise resolving to the embed configuration returned by the API\n   */\n  public embed(): Promise<any> {\n    return this._zone.run(() => this._instance.embed());\n  }\n\n  /**\n   * Refreshes the embed token without re-rendering.\n   *\n   * @returns Promise resolving when the token has been refreshed\n   */\n  public refresh(): Promise<void> {\n    return this._zone.run(() => this._instance.refresh());\n  }\n\n  /**\n   * Releases all resources: stops the token refresh timer and disposes\n   * the embedded Power BI component.\n   */\n  public dispose(): void {\n    this._instance.dispose();\n  }\n\n  /** @ignore */\n  static _fromInstance(instance: any, zone: NgZone): PowerBIRef {\n    const ref = Object.create(PowerBIRef.prototype) as PowerBIRef;\n    ref._instance = instance;\n    ref._zone = zone;\n    return ref;\n  }\n}\n\n\n/**\n * Wrapper around a Power BI embed created from a gadget preference value.\n *\n * Automatically configures workspace, report/dashboard, and display settings\n * from the preference.\n *\n * ```typescript\n * const pbi = this.client.createPowerBIFromPref(\n *   prefs.getString('rdPowerBI'),\n *   this.containerEl.nativeElement\n * );\n *\n * // Embed with preference settings\n * await pbi.embed();\n *\n * // Cleanup\n * pbi.dispose();\n * ```\n */\nexport class PowerBIPrefRef {\n\n  /** The underlying PowerBIRef with full access to embed, refresh, etc. */\n  public readonly powerBI: PowerBIRef;\n\n  /** The parsed preference object. */\n  public readonly pref: IPowerBIPref;\n\n  /**\n   * Creates a new PowerBIPrefRef from a gadget preference JSON string.\n   *\n   * @param prefValue - The raw gadget preference string (JSON)\n   * @param container - DOM element to embed into\n   * @param zone - Angular NgZone for ensuring change detection on callbacks\n   * @param extraOptions - Additional options to merge\n   * @throws Error if the global Power BI library is not loaded\n   */\n  constructor(prefValue: string, container: HTMLElement, zone: NgZone, extraOptions?: Partial<IPowerBIOptions>) {\n\n    const lib = (window as any).gadgets?.['reveldigital.powerbi'];\n\n    if (!lib || typeof lib.createFromPref !== 'function') {\n      throw new Error(\n        'RevelDigital PowerBI library is not available. ' +\n        'Ensure the Power BI feature is enabled for this gadget.'\n      );\n    }\n\n    // gadgets.Prefs.getString() returns HTML-encoded values, decode before parsing\n    const decoded = decode(prefValue);\n\n    const instance = lib.createFromPref(decoded, container, extraOptions);\n    this.pref = this._parsePref(decoded);\n    this.powerBI = PowerBIRef._fromInstance(instance, zone);\n  }\n\n  /**\n   * Fetches the embed configuration and renders the Power BI content.\n   *\n   * @returns Promise resolving to the embed configuration\n   */\n  public embed(): Promise<any> {\n    return this.powerBI.embed();\n  }\n\n  /**\n   * Refreshes the embed token without re-rendering.\n   *\n   * @returns Promise resolving when the token has been refreshed\n   */\n  public refresh(): Promise<void> {\n    return this.powerBI.refresh();\n  }\n\n  /**\n   * Releases all resources held by the underlying PowerBIRef.\n   */\n  public dispose(): void {\n    this.powerBI.dispose();\n  }\n\n  /** @ignore */\n  private _parsePref(decoded: string): IPowerBIPref {\n    try {\n      return JSON.parse(decoded);\n    } catch {\n      return {};\n    }\n  }\n}\n"]}

package/esm2022/lib/version.mjs

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '2.8.0';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQkFBMkI7QUFDM0IsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdlbmVyYXRlZCBieSBnZW52ZXJzaW9uLlxuZXhwb3J0IGNvbnN0IHZlcnNpb24gPSAnMi44LjAnXG4iXX0=
+export const version = '2.10.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQkFBMkI7QUFDM0IsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLFFBQVEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdlbmVyYXRlZCBieSBnZW52ZXJzaW9uLlxuZXhwb3J0IGNvbnN0IHZlcnNpb24gPSAnMi4xMC4wJ1xuIl19

package/esm2022/public-api.mjs

@@ -6,4 +6,6 @@ export * from './lib/player-client.module';
 export * from './lib/safe-style.pipe';
 export * from './lib/datatable-ref';
 export * from './lib/interfaces/datatable.interface';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNDQUFzQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBwbGF5ZXItY2xpZW50XG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvcGxheWVyLWNsaWVudC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BsYXllci1jbGllbnQubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NhZmUtc3R5bGUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9kYXRhdGFibGUtcmVmJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2ludGVyZmFjZXMvZGF0YXRhYmxlLmludGVyZmFjZSc7Il19
+export * from './lib/powerbi-ref';
+export * from './lib/interfaces/powerbi.interface';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMsbUJBQW1CLENBQUM7QUFDbEMsY0FBYyxvQ0FBb0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBQdWJsaWMgQVBJIFN1cmZhY2Ugb2YgcGxheWVyLWNsaWVudFxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL3BsYXllci1jbGllbnQuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9wbGF5ZXItY2xpZW50Lm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zYWZlLXN0eWxlLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvZGF0YXRhYmxlLXJlZic7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9pbnRlcmZhY2VzL2RhdGF0YWJsZS5pbnRlcmZhY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcG93ZXJiaS1yZWYnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvaW50ZXJmYWNlcy9wb3dlcmJpLmludGVyZmFjZSc7Il19