@reveldigital/player-client 1.0.9 → 1.0.11

package/esm2020/lib/interfaces/client.interface.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LmludGVyZmFjZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9saWIvaW50ZXJmYWNlcy9jbGllbnQuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogQGlnbm9yZSAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIElDbGllbnQge1xyXG5cclxuICAgIGNhbGxiYWNrKC4uLmFyZ3M6IGFueVtdKTogdm9pZDtcclxuXHJcbiAgICBnZXREZXZpY2VUaW1lKGRhdGU/OiBEYXRlKTogUHJvbWlzZTxzdHJpbmc+O1xyXG5cclxuICAgIGdldERldmljZVRpbWVab25lTmFtZSgpOiBQcm9taXNlPHN0cmluZz47XHJcblxyXG4gICAgZ2V0RGV2aWNlVGltZVpvbmVJRCgpOiBQcm9taXNlPHN0cmluZz47XHJcblxyXG4gICAgZ2V0RGV2aWNlVGltZVpvbmVPZmZzZXQoKTogUHJvbWlzZTxudW1iZXI+O1xyXG5cclxuICAgIGdldExhbmd1YWdlQ29kZSgpOiBQcm9taXNlPHN0cmluZz47XHJcblxyXG4gICAgZ2V0RGV2aWNlS2V5KCk6IFByb21pc2U8c3RyaW5nPjtcclxuXHJcbiAgICBzZW5kQ29tbWFuZChuYW1lOiBzdHJpbmcsIGFyZzogc3RyaW5nKTogdm9pZDtcclxuXHJcbiAgICBzZW5kUmVtb3RlQ29tbWFuZChkZXZpY2VLZXlzOiBzdHJpbmdbXSwgbmFtZTogc3RyaW5nLCBhcmc6IHN0cmluZyk6IHZvaWQ7XHJcblxyXG4gICAgdHJhY2soZXZlbnROYW1lOiBzdHJpbmcsIHByb3BlcnRpZXM/OiBzdHJpbmcpOiB2b2lkO1xyXG5cclxuICAgIHRpbWVFdmVudChldmVudE5hbWU6IHN0cmluZyk6IHZvaWQ7XHJcblxyXG4gICAgbmV3RXZlbnRTZXNzaW9uKGlkPzogc3RyaW5nKTogdm9pZDtcclxuXHJcbiAgICBnZXRSZXZlbFJvb3QoKTogUHJvbWlzZTxzdHJpbmc+O1xyXG5cclxuICAgIGdldENvbW1hbmRNYXAoKTogUHJvbWlzZTxzdHJpbmc+O1xyXG5cclxuICAgIGdldERldmljZSgpOiBQcm9taXNlPHN0cmluZz47XHJcblxyXG4gICAgZmluaXNoKCk6IHZvaWQ7XHJcbn1cclxuIl19
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -1,6 +1,7 @@
 import { Injectable } from '@angular/core';
 import { BehaviorSubject, fromEvent, Subject } from 'rxjs';
 import { map, share, tap } from 'rxjs/operators';
+import { version } from './version';
 import * as i0 from "@angular/core";
 export class PlayerClientService {
     // private onPostMessageSub: Subscription;
@@ -316,6 +317,60 @@ export class PlayerClientService {
         });
         return device[0];
     }
+    /**
+     * Returns the width of the visualization area.
+     *
+     * @returns Width of the visualization area
+     */
+    async getWidth() {
+        const client = await this.getClient();
+        return client.getWidth();
+    }
+    /**
+     * Returns the height of the visualization area.
+     *
+     * @returns Height of the visualization area
+     */
+    async getHeight() {
+        const client = await this.getClient();
+        return client.getHeight();
+    }
+    /**
+     * Returns the duration of the currently playing source.
+     * (only applicable when associated with a playlist)
+     *
+     * @returns Duration of the current item in milliseconds
+     */
+    async getDuration() {
+        const client = await this.getClient();
+        return client.getDuration();
+    }
+    /**
+     * Returns the current SDK version.
+     *
+     * @returns SDK version
+     */
+    async getSdkVersion() {
+        return Promise.resolve(version);
+    }
+    /**
+     * Set a preference value.
+     *
+     * Provides the ability to have the gadget present a UI for setting preferences.
+     * Only available during design time.
+     *
+     * @param key Prefernce key
+     * @param value Preference value
+     */
+    async setPreference(key, value) {
+        if (await this.isPreviewMode()) {
+            const client = await this.getClient();
+            client.setPreference(key, value);
+        }
+        else {
+            console.log('%csetPreference() is only available in preview mode.', 'background-color:blue; color:yellow;');
+        }
+    }
     // ---
     // PRIVATE METHODS.
     // ---
@@ -413,11 +468,32 @@ class NoopClient {
     async getCommandMap() {
         return Promise.resolve('{}');
     }
+    finish() {
+        // NOOP implement, nothing to do....
+    }
     async getDevice() {
         return Promise.resolve(null);
     }
-    finish() {
-        // NOOP implement, nothing to do....
+    async getWidth() {
+        return Promise.resolve(null);
+    }
+    async getHeight() {
+        return Promise.resolve(null);
+    }
+    async getDuration() {
+        return Promise.resolve(null);
+    }
+    async getSdkVersion() {
+        return Promise.resolve(version);
+    }
+    setPreference(key, value) {
+        //if (window.parent !== window.top) {
+        window.parent.postMessage(JSON.stringify({
+            type: 'setPreference',
+            key: key,
+            value: value
+        }), '*');
+        //}
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"player-client.service.js","sourceRoot":"","sources":["../../../../../projects/reveldigital/player-client/src/lib/player-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, OnDestroy } from '@angular/core';\r\nimport { gadgets } from '@reveldigital/gadget-types';\r\nimport { BehaviorSubject, fromEvent, Subject, Subscription } from 'rxjs';\r\nimport { map, share, tap } from 'rxjs/operators';\r\nimport { ICommand } from './interfaces/command.interface';\r\nimport { IDevice } from './interfaces/device.interface';\r\nimport { IEventProperties } from './interfaces/event-properties.interface';\r\nimport { IClient } from './interfaces/client.interface';\r\n\r\n\r\n// So that TypeScript doesn't complain, we're going to augment the GLOBAL / WINDOW \r\n// name-space definition to include the Tracker API. This also provides us with a place\r\n// to actually DOCUMENT the API so that our developers aren't guessing about what's\r\n// available on the library.\r\n\r\n/** @ignore */\r\ndeclare global {\r\n  var Client: IClient;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PlayerClientService implements OnDestroy {\r\n\r\n  /** @ignore */\r\n  private clientPromise: Promise<IClient> | null;\r\n\r\n  /**\r\n   * Commands sent to this player.\r\n   */\r\n  public onCommand$ = new Subject<ICommand>();\r\n  /**\r\n   * Signals the gadget has been loaded and is ready to start.\r\n   */\r\n  public onReady$ = new BehaviorSubject(false);\r\n  /**\r\n   * Signals the gadget has been started by the player.\r\n   */\r\n  public onStart$ = new Subject();\r\n  /**\r\n   * Signals the gadgets has been stopped by the player.\r\n   */\r\n  public onStop$ = new Subject();\r\n\r\n  //\r\n  // Two methods available for calling into the library:\r\n  //\r\n  // 1) Using dispatchEvent() with the following custom events\r\n  // 2) Using the window scoped RevelDigital object as defined in the constructor\r\n  //\r\n  /** @ignore */\r\n  private onStartSub: Subscription;\r\n  /** @ignore */\r\n  private onStartEvt$ = fromEvent(document, 'RevelDigital.Start').pipe(\r\n    share(),\r\n    tap(this.onStart$)\r\n  );\r\n  /** @ignore */\r\n  private onStopSub: Subscription;\r\n  /** @ignore */\r\n  private onStopEvt$ = fromEvent(document, 'RevelDigital.Stop').pipe(\r\n    share(),\r\n    tap(this.onStop$)\r\n  );\r\n  /** @ignore */\r\n  private onCommandSub: Subscription;\r\n  /** @ignore */\r\n  private onCommandEvt$ = fromEvent<ICommand>(document, 'RevelDigital.Command').pipe(\r\n    map((e: any) => { return { name: e.detail.name, arg: e.detail.arg } as ICommand }),\r\n    share(),\r\n    tap(this.onCommand$)\r\n  );\r\n\r\n  // private onPostMessageSub: Subscription;\r\n  // private onPostMessageEvt$ = fromEvent(window, 'message').pipe(\r\n  //   filter((messageEvent: MessageEvent) =>\r\n  //     messageEvent.source !== window.parent &&\r\n  //     typeof messageEvent.data === 'string' &&\r\n  //     messageEvent.data.startsWith('reveldigital:')),\r\n  //   map((e: any) => { return JSON.parse(e.substring(13)) as Command }),\r\n  //   share(),\r\n  //   tap(this.onCommand$)\r\n  // );\r\n\r\n  /** @ignore */\r\n  constructor(zone: NgZone) {\r\n\r\n    let self = this;\r\n    (window as any).RevelDigital = {\r\n      Controller: {\r\n        onCommand: function (name: string, arg: string) {\r\n          zone.run(() => {\r\n            self.onCommand$.next({ name: name, arg: arg });\r\n          });\r\n        },\r\n        onStart: function () {\r\n          zone.run(() => {\r\n            self.onStart$.next(null);\r\n          });\r\n        },\r\n        onStop: function () {\r\n          zone.run(() => {\r\n            self.onStop$.next(null);\r\n          });\r\n        }\r\n      }\r\n    }\r\n\r\n    this.onStartSub = this.onStartEvt$.subscribe(() => { });\r\n    this.onStopSub = this.onStopEvt$.subscribe(() => { });\r\n    this.onCommandSub = this.onCommandEvt$.subscribe(() => { });\r\n\r\n    this.clientPromise = null;\r\n\r\n    this.onReady$.next(true);\r\n  }\r\n\r\n  /** @ignore */\r\n  ngOnDestroy(): void {\r\n\r\n    this.onStartSub?.unsubscribe();\r\n    this.onStopSub?.unsubscribe();\r\n    this.onCommandSub?.unsubscribe();\r\n\r\n    this.onReady$.next(false);\r\n  }\r\n\r\n  /** @ignore */\r\n  public static init(data: any) {\r\n\r\n    console.log(\r\n      '%c⚙️ Initializing Revel Digital client library',\r\n      'background-color:blue; color:yellow;'\r\n    );\r\n  }\r\n\r\n  /**\r\n   * This method allows the gadget to communicate with player scripting.\r\n   * If the appropriate scripting is in place in the currently running template, calling this method\r\n   * will initiate a callback which can be acted upon in player script.\r\n   * \r\n   * @example\r\n   * client.callback('test', 'this');\r\n   * \r\n   * @param args variable number of arguments\r\n   */\r\n  public callback(...args: any[]): void {\r\n\r\n    this.getClient().then((client) => {\r\n\r\n      switch (args.length) {\r\n        case 0:\r\n          client.callback();\r\n          break;\r\n        case 1:\r\n          client.callback(args[0]);\r\n          break;\r\n        case 2:\r\n          client.callback(args[1]);\r\n          break;\r\n        case 3:\r\n          client.callback(args[2]);\r\n          break;\r\n        case 4:\r\n          client.callback(args[3]);\r\n          break;\r\n        case 5:\r\n          client.callback(args[4]);\r\n          break;\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Accessor method for the user preferences interface exposed by the Gadgets API.\r\n   * \r\n   * See {@link https://developers.google.com/gadgets/docs/basic} for more details on the Gadgets API.\r\n   * \r\n   * @example\r\n   * constructor(public client: PlayerClientService) {\r\n   *            let prefs = client.getPrefs();\r\n   *            let myString = prefs.getString('myStringPref');\r\n   * }\r\n   * @returns {gadgets.Prefs} Gadget API Prefs object\r\n   */\r\n  public getPrefs(): gadgets.Prefs {\r\n\r\n    return new window['gadgets']['Prefs']();\r\n  }\r\n\r\n  /**\r\n   * Returns the current device time in ISO8601 format.\r\n   * Current device time is determined by the device timezone assigned to the device in the CMS.\r\n   * \r\n   * @param date Optional. If supplied will translate the supplied date/time to device time based on respective timezones.\r\n   * @returns Date/time in ISO8601 format\r\n   */\r\n  public async getDeviceTime(date?: Date): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    if (date !== undefined) {\r\n      return client.getDeviceTime(date);\r\n    }\r\n    return client.getDeviceTime();\r\n  }\r\n\r\n  /**\r\n   * Returns the timezone name currently assigned to the device.\r\n   * \r\n   * @returns Timezone Name\r\n   */\r\n  public async getDeviceTimeZoneName(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneName();\r\n  }\r\n\r\n  /**\r\n   * Returns the timezone ID currently assigned to the device.\r\n   * \r\n   * @returns Timezone ID\r\n   */\r\n  public async getDeviceTimeZoneID(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneID();\r\n  }\r\n\r\n  /**\r\n   * Returns the numerical offset from GMT of the timezone currently assigned to the device.\r\n   * \r\n   * @returns Timezone offset\r\n   */\r\n  public async getDeviceTimeZoneOffset(): Promise<number> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneOffset();\r\n  }\r\n\r\n  /**\r\n   * Returns the language code of the language currently assigned to the device.\r\n   * \r\n   * @returns Language code\r\n   */\r\n  public async getLanguageCode(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getLanguageCode();\r\n  }\r\n\r\n  /**\r\n   * Returns the unique Revel Digital device key associated with the device.\r\n   * \r\n   * @returns Device key\r\n   */\r\n  public async getDeviceKey(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceKey();\r\n  }\r\n\r\n  /**\r\n   * Send a command to the player device.\r\n   * \r\n   * @param name Command name\r\n   * @param arg Command argument\r\n   */\r\n  public sendCommand(name: string, arg: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.sendCommand(name, arg);\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Send a command to any remote player with the supplied device key(s).\r\n   * Note: Remote commands can only be delivered to devices within the same account as the sender device.\r\n   * \r\n   * @param deviceKeys Array of remote device keys\r\n   * @param name Command name\r\n   * @param arg Command arg\r\n   */\r\n  public sendRemoteCommand(deviceKeys: string[], name: string, arg: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.sendRemoteCommand(deviceKeys, name, arg);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Log an event for use with AdHawk analytics.\r\n   * Events are used for tracking various metrics including usage statistics, player condition, state changes, etc.\r\n   * \r\n   * @param eventName Unique name for this event\r\n   * @param properties A map of user defined properties to associate with this event\r\n   */\r\n  public track(eventName: string, properties?: IEventProperties): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.track(eventName, JSON.stringify(properties));\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Method for initiating a timed event.\r\n   * Timed events are useful for tracking the duration of an event and must be proceeded with a call to track().\r\n   * \r\n   * @example\r\n   * client.timeEvent('testEvent');\r\n   * client.track(\"test\", { \"a\": \"b\" });\r\n   * @param eventName Unique name for this event\r\n   */\r\n  public timeEvent(eventName: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.timeEvent(eventName);\r\n    })\r\n  }\r\n\r\n  /**\r\n   * A session is a way of grouping events together. Each event has an associated session ID.\r\n   * Session ID's are randomly generated and reset by subsequent calls to newEventSession().\r\n   * \r\n   * Each call to track() will utilize the same session ID, until another call to newEventSession().\r\n   * @param id Optional. User supplied session ID. If not supplied a random session ID will be generated.\r\n   */\r\n  public newEventSession(id?: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      if (id !== undefined) {\r\n        client.newEventSession();\r\n      } else {\r\n        client.newEventSession(id);\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Returns the root folder utilized by this player device.\r\n   * \r\n   * @returns Path to the root folder\r\n   */\r\n  public async getRevelRoot(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getRevelRoot();\r\n  }\r\n\r\n  /**\r\n   * Returns a map of commands currently active for this device.\r\n   * \r\n   * @returns Map of commands currently active for this device.\r\n   */\r\n  public async getCommandMap(): Promise<any> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return JSON.parse(await client.getCommandMap());\r\n  }\r\n\r\n  /**\r\n   * Indicate to the player that this gadget has finished it's visualization.\r\n   * This allows the player to proceed with the next item in a playlist if applicable.\r\n   */\r\n  public finish(): void {\r\n\r\n    this.getClient().then((client) => {\r\n\r\n      client.finish();\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Check is the gadget is running in preview mode. Preview mode is enabled when the gadget is\r\n   * being edited in the CMS, or otherwise not running in a normal player environment.\r\n   * \r\n   * @returns True if the gadget is running in preview mode, false otherwise.\r\n   */\r\n  public async isPreviewMode(): Promise<boolean> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client instanceof NoopClient;\r\n  }\r\n\r\n  /**\r\n * Returns the device details associated with the player running the gadget or web app.\r\n * \r\n * @returns Device details.\r\n */\r\n  public async getDevice(): Promise<IDevice | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    let obj: any = JSON.parse(<string>await client.getDevice());\r\n\r\n    const device: IDevice[] = [obj].map((device: any) => {\r\n\r\n      return {\r\n        name: device.name,\r\n        registrationKey: device.key,\r\n        deviceType: device.devicetype,\r\n        enteredService: new Date(device.enteredservice),\r\n        langCode: device.langcode,\r\n        timeZone: device.timezone,\r\n        tags: device.description?.split('\\n'),\r\n        location: {\r\n          city: device.location?.city,\r\n          state: device.location?.state,\r\n          country: device.location?.country,\r\n          postalCode: device.location?.postalcode,\r\n          address: device.location?.address,\r\n          latitude: device.location?.latitude,\r\n          longitude: device.location?.longitude\r\n        }\r\n      }\r\n    });\r\n    return device[0];\r\n  }\r\n\r\n  // ---\r\n  // PRIVATE METHODS.\r\n  // ---\r\n  /** @ignore */\r\n  private getClient(): Promise<IClient> {\r\n\r\n    if (this.clientPromise) {\r\n\r\n      return (this.clientPromise);\r\n    }\r\n\r\n    if (window.Client) {\r\n\r\n      return (this.clientPromise = Promise.resolve(window.Client));\r\n    }\r\n\r\n    // A \"complete\" status indicates that the \"load\" event has been fired on the\r\n    // window; and, that all sub-resources such as Scripts, Images, and Frames have\r\n    // been loaded.\r\n    if (window.document.readyState === \"complete\") {\r\n\r\n      // If this event has fired AND the 3rd-party script isn't available (see IF-\r\n      // condition BEFORE this one), it means that the 3rd-party script either\r\n      // failed on the network or was BLOCKED by an ad-blocker. As such, we have to\r\n      // fall-back to using a mock API.\r\n      return (this.clientPromise = Promise.resolve(new NoopClient()));\r\n    }\r\n\r\n    // ASSERT: If we made it this far, the document has not completed loading (but it\r\n    // may be in an \"interactive\" state which is when I believe that the Angular app\r\n    // gets bootstrapped). As such, we need bind to the LOAD event to wait for our\r\n    // third-party scripts to load (or fail to load, or be blocked).\r\n    this.clientPromise = new Promise<IClient>(\r\n      (resolve) => {\r\n\r\n        window.addEventListener(\r\n          \"load\",\r\n          function handleWindowLoad() {\r\n\r\n            // At this point, the 3rd-party library is either available or\r\n            // it's not - there's no further loading to do. If it's not\r\n            // present on the global scope, we're going to fall-back to using\r\n            // a mock API.\r\n            resolve(window.Client || new NoopClient());\r\n          }\r\n        );\r\n\r\n      }\r\n    );\r\n\r\n    return (this.clientPromise);\r\n  }\r\n\r\n}\r\n\r\n\r\n\r\n// ----------------------------------------------------------------------------------- //\r\n// ----------------------------------------------------------------------------------- //\r\n\r\n// I provide a mock API for the 3rd-party script. This just allows the consuming code to\r\n// act as though the library is available even if it failed to load (example, it was\r\n// blocked by an ad-blocker).\r\n\r\n/** @ignore */\r\nclass NoopClient implements IClient {\r\n\r\n  constructor() {\r\n\r\n    console.log(\r\n      '%cClient API not available, falling back to mock API',\r\n      'background-color:blue; color:yellow;'\r\n    );\r\n  }\r\n\r\n  public callback(...args: any[]): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public getDeviceTime(date?: Date): Promise<string> {\r\n\r\n    return Promise.resolve(new Date().toISOString());\r\n  }\r\n\r\n  public async getDeviceTimeZoneName(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceTimeZoneID(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceTimeZoneOffset(): Promise<number> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getLanguageCode(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceKey(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public sendCommand(name: string, arg: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public sendRemoteCommand(deviceKeys: string[], name: string, arg: string) {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public track(eventName: string, properties?: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public timeEvent(eventName: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public newEventSession(id?: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public async getRevelRoot(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getCommandMap(): Promise<string> {\r\n\r\n    return Promise.resolve('{}');\r\n  }\r\n\r\n  public async getDevice(): Promise<string | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public finish(): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"player-client.service.js","sourceRoot":"","sources":["../../../../../projects/reveldigital/player-client/src/lib/player-client.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, NgZone, OnDestroy } from '@angular/core';\r\nimport { gadgets } from '@reveldigital/gadget-types';\r\nimport { BehaviorSubject, fromEvent, Subject, Subscription } from 'rxjs';\r\nimport { map, share, tap } from 'rxjs/operators';\r\nimport { ICommand } from './interfaces/command.interface';\r\nimport { IDevice } from './interfaces/device.interface';\r\nimport { IEventProperties } from './interfaces/event-properties.interface';\r\nimport { IClient } from './interfaces/client.interface';\r\nimport { version } from './version';\r\n\r\n//import { version } from './version.js';\r\n\r\n// So that TypeScript doesn't complain, we're going to augment the GLOBAL / WINDOW \r\n// name-space definition to include the Tracker API. This also provides us with a place\r\n// to actually DOCUMENT the API so that our developers aren't guessing about what's\r\n// available on the library.\r\n\r\n/** @ignore */\r\ndeclare global {\r\n  var Client: IClient;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PlayerClientService implements OnDestroy {\r\n\r\n  /** @ignore */\r\n  private clientPromise: Promise<IClient> | null;\r\n\r\n  /**\r\n   * Commands sent to this player.\r\n   */\r\n  public onCommand$ = new Subject<ICommand>();\r\n  /**\r\n   * Signals the gadget has been loaded and is ready to start.\r\n   */\r\n  public onReady$ = new BehaviorSubject(false);\r\n  /**\r\n   * Signals the gadget has been started by the player.\r\n   */\r\n  public onStart$ = new Subject();\r\n  /**\r\n   * Signals the gadgets has been stopped by the player.\r\n   */\r\n  public onStop$ = new Subject();\r\n\r\n  //\r\n  // Two methods available for calling into the library:\r\n  //\r\n  // 1) Using dispatchEvent() with the following custom events\r\n  // 2) Using the window scoped RevelDigital object as defined in the constructor\r\n  //\r\n  /** @ignore */\r\n  private onStartSub: Subscription;\r\n  /** @ignore */\r\n  private onStartEvt$ = fromEvent(document, 'RevelDigital.Start').pipe(\r\n    share(),\r\n    tap(this.onStart$)\r\n  );\r\n  /** @ignore */\r\n  private onStopSub: Subscription;\r\n  /** @ignore */\r\n  private onStopEvt$ = fromEvent(document, 'RevelDigital.Stop').pipe(\r\n    share(),\r\n    tap(this.onStop$)\r\n  );\r\n  /** @ignore */\r\n  private onCommandSub: Subscription;\r\n  /** @ignore */\r\n  private onCommandEvt$ = fromEvent<ICommand>(document, 'RevelDigital.Command').pipe(\r\n    map((e: any) => { return { name: e.detail.name, arg: e.detail.arg } as ICommand }),\r\n    share(),\r\n    tap(this.onCommand$)\r\n  );\r\n\r\n  // private onPostMessageSub: Subscription;\r\n  // private onPostMessageEvt$ = fromEvent(window, 'message').pipe(\r\n  //   filter((messageEvent: MessageEvent) =>\r\n  //     messageEvent.source !== window.parent &&\r\n  //     typeof messageEvent.data === 'string' &&\r\n  //     messageEvent.data.startsWith('reveldigital:')),\r\n  //   map((e: any) => { return JSON.parse(e.substring(13)) as Command }),\r\n  //   share(),\r\n  //   tap(this.onCommand$)\r\n  // );\r\n\r\n  /** @ignore */\r\n  constructor(zone: NgZone) {\r\n\r\n    let self = this;\r\n    (window as any).RevelDigital = {\r\n      Controller: {\r\n        onCommand: function (name: string, arg: string) {\r\n          zone.run(() => {\r\n            self.onCommand$.next({ name: name, arg: arg });\r\n          });\r\n        },\r\n        onStart: function () {\r\n          zone.run(() => {\r\n            self.onStart$.next(null);\r\n          });\r\n        },\r\n        onStop: function () {\r\n          zone.run(() => {\r\n            self.onStop$.next(null);\r\n          });\r\n        }\r\n      }\r\n    }\r\n\r\n    this.onStartSub = this.onStartEvt$.subscribe(() => { });\r\n    this.onStopSub = this.onStopEvt$.subscribe(() => { });\r\n    this.onCommandSub = this.onCommandEvt$.subscribe(() => { });\r\n\r\n    this.clientPromise = null;\r\n\r\n    this.onReady$.next(true);\r\n  }\r\n\r\n  /** @ignore */\r\n  ngOnDestroy(): void {\r\n\r\n    this.onStartSub?.unsubscribe();\r\n    this.onStopSub?.unsubscribe();\r\n    this.onCommandSub?.unsubscribe();\r\n\r\n    this.onReady$.next(false);\r\n  }\r\n\r\n  /** @ignore */\r\n  public static init(data: any) {\r\n\r\n    console.log(\r\n      '%c⚙️ Initializing Revel Digital client library',\r\n      'background-color:blue; color:yellow;'\r\n    );\r\n  }\r\n\r\n  /**\r\n   * This method allows the gadget to communicate with player scripting.\r\n   * If the appropriate scripting is in place in the currently running template, calling this method\r\n   * will initiate a callback which can be acted upon in player script.\r\n   * \r\n   * @example\r\n   * client.callback('test', 'this');\r\n   * \r\n   * @param args variable number of arguments\r\n   */\r\n  public callback(...args: any[]): void {\r\n\r\n    this.getClient().then((client) => {\r\n\r\n      switch (args.length) {\r\n        case 0:\r\n          client.callback();\r\n          break;\r\n        case 1:\r\n          client.callback(args[0]);\r\n          break;\r\n        case 2:\r\n          client.callback(args[1]);\r\n          break;\r\n        case 3:\r\n          client.callback(args[2]);\r\n          break;\r\n        case 4:\r\n          client.callback(args[3]);\r\n          break;\r\n        case 5:\r\n          client.callback(args[4]);\r\n          break;\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Accessor method for the user preferences interface exposed by the Gadgets API.\r\n   * \r\n   * See {@link https://developers.google.com/gadgets/docs/basic} for more details on the Gadgets API.\r\n   * \r\n   * @example\r\n   * constructor(public client: PlayerClientService) {\r\n   *            let prefs = client.getPrefs();\r\n   *            let myString = prefs.getString('myStringPref');\r\n   * }\r\n   * @returns {gadgets.Prefs} Gadget API Prefs object\r\n   */\r\n  public getPrefs(): gadgets.Prefs {\r\n\r\n    return new window['gadgets']['Prefs']();\r\n  }\r\n\r\n  /**\r\n   * Returns the current device time in ISO8601 format.\r\n   * Current device time is determined by the device timezone assigned to the device in the CMS.\r\n   * \r\n   * @param date Optional. If supplied will translate the supplied date/time to device time based on respective timezones.\r\n   * @returns Date/time in ISO8601 format\r\n   */\r\n  public async getDeviceTime(date?: Date): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    if (date !== undefined) {\r\n      return client.getDeviceTime(date);\r\n    }\r\n    return client.getDeviceTime();\r\n  }\r\n\r\n  /**\r\n   * Returns the timezone name currently assigned to the device.\r\n   * \r\n   * @returns Timezone Name\r\n   */\r\n  public async getDeviceTimeZoneName(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneName();\r\n  }\r\n\r\n  /**\r\n   * Returns the timezone ID currently assigned to the device.\r\n   * \r\n   * @returns Timezone ID\r\n   */\r\n  public async getDeviceTimeZoneID(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneID();\r\n  }\r\n\r\n  /**\r\n   * Returns the numerical offset from GMT of the timezone currently assigned to the device.\r\n   * \r\n   * @returns Timezone offset\r\n   */\r\n  public async getDeviceTimeZoneOffset(): Promise<number> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceTimeZoneOffset();\r\n  }\r\n\r\n  /**\r\n   * Returns the language code of the language currently assigned to the device.\r\n   * \r\n   * @returns Language code\r\n   */\r\n  public async getLanguageCode(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getLanguageCode();\r\n  }\r\n\r\n  /**\r\n   * Returns the unique Revel Digital device key associated with the device.\r\n   * \r\n   * @returns Device key\r\n   */\r\n  public async getDeviceKey(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDeviceKey();\r\n  }\r\n\r\n  /**\r\n   * Send a command to the player device.\r\n   * \r\n   * @param name Command name\r\n   * @param arg Command argument\r\n   */\r\n  public sendCommand(name: string, arg: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.sendCommand(name, arg);\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Send a command to any remote player with the supplied device key(s).\r\n   * Note: Remote commands can only be delivered to devices within the same account as the sender device.\r\n   * \r\n   * @param deviceKeys Array of remote device keys\r\n   * @param name Command name\r\n   * @param arg Command arg\r\n   */\r\n  public sendRemoteCommand(deviceKeys: string[], name: string, arg: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.sendRemoteCommand(deviceKeys, name, arg);\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Log an event for use with AdHawk analytics.\r\n   * Events are used for tracking various metrics including usage statistics, player condition, state changes, etc.\r\n   * \r\n   * @param eventName Unique name for this event\r\n   * @param properties A map of user defined properties to associate with this event\r\n   */\r\n  public track(eventName: string, properties?: IEventProperties): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.track(eventName, JSON.stringify(properties));\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Method for initiating a timed event.\r\n   * Timed events are useful for tracking the duration of an event and must be proceeded with a call to track().\r\n   * \r\n   * @example\r\n   * client.timeEvent('testEvent');\r\n   * client.track(\"test\", { \"a\": \"b\" });\r\n   * @param eventName Unique name for this event\r\n   */\r\n  public timeEvent(eventName: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.timeEvent(eventName);\r\n    })\r\n  }\r\n\r\n  /**\r\n   * A session is a way of grouping events together. Each event has an associated session ID.\r\n   * Session ID's are randomly generated and reset by subsequent calls to newEventSession().\r\n   * \r\n   * Each call to track() will utilize the same session ID, until another call to newEventSession().\r\n   * @param id Optional. User supplied session ID. If not supplied a random session ID will be generated.\r\n   */\r\n  public newEventSession(id?: string): void {\r\n\r\n    this.getClient().then((client) => {\r\n      if (id !== undefined) {\r\n        client.newEventSession();\r\n      } else {\r\n        client.newEventSession(id);\r\n      }\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Returns the root folder utilized by this player device.\r\n   * \r\n   * @returns Path to the root folder\r\n   */\r\n  public async getRevelRoot(): Promise<string> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getRevelRoot();\r\n  }\r\n\r\n  /**\r\n   * Returns a map of commands currently active for this device.\r\n   * \r\n   * @returns Map of commands currently active for this device.\r\n   */\r\n  public async getCommandMap(): Promise<any> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return JSON.parse(await client.getCommandMap());\r\n  }\r\n\r\n  /**\r\n   * Indicate to the player that this gadget has finished it's visualization.\r\n   * This allows the player to proceed with the next item in a playlist if applicable.\r\n   */\r\n  public finish(): void {\r\n\r\n    this.getClient().then((client) => {\r\n\r\n      client.finish();\r\n    })\r\n  }\r\n\r\n  /**\r\n   * Check is the gadget is running in preview mode. Preview mode is enabled when the gadget is\r\n   * being edited in the CMS, or otherwise not running in a normal player environment.\r\n   * \r\n   * @returns True if the gadget is running in preview mode, false otherwise.\r\n   */\r\n  public async isPreviewMode(): Promise<boolean> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client instanceof NoopClient;\r\n  }\r\n\r\n  /**\r\n * Returns the device details associated with the player running the gadget or web app.\r\n * \r\n * @returns Device details.\r\n */\r\n  public async getDevice(): Promise<IDevice | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    let obj: any = JSON.parse(<string>await client.getDevice());\r\n\r\n    const device: IDevice[] = [obj].map((device: any) => {\r\n\r\n      return {\r\n        name: device.name,\r\n        registrationKey: device.key,\r\n        deviceType: device.devicetype,\r\n        enteredService: new Date(device.enteredservice),\r\n        langCode: device.langcode,\r\n        timeZone: device.timezone,\r\n        tags: device.description?.split('\\n'),\r\n        location: {\r\n          city: device.location?.city,\r\n          state: device.location?.state,\r\n          country: device.location?.country,\r\n          postalCode: device.location?.postalcode,\r\n          address: device.location?.address,\r\n          latitude: device.location?.latitude,\r\n          longitude: device.location?.longitude\r\n        }\r\n      }\r\n    });\r\n    return device[0];\r\n  }\r\n\r\n  /**\r\n   * Returns the width of the visualization area.\r\n   * \r\n   * @returns Width of the visualization area\r\n   */\r\n  public async getWidth(): Promise<number | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getWidth();\r\n  }\r\n\r\n  /**\r\n   * Returns the height of the visualization area.\r\n   * \r\n   * @returns Height of the visualization area\r\n   */\r\n  public async getHeight(): Promise<number | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getHeight();\r\n  }\r\n\r\n  /**\r\n   * Returns the duration of the currently playing source.\r\n   * (only applicable when associated with a playlist)\r\n   * \r\n   * @returns Duration of the current item in milliseconds\r\n   */\r\n  public async getDuration(): Promise<number | null> {\r\n\r\n    const client = await this.getClient();\r\n\r\n    return client.getDuration();\r\n  }\r\n\r\n  /**\r\n   * Returns the current SDK version.\r\n   * \r\n   * @returns SDK version\r\n   */\r\n  public async getSdkVersion(): Promise<string> {\r\n\r\n    return Promise.resolve(version);\r\n  }\r\n\r\n  /**\r\n   * Set a preference value.\r\n   * \r\n   * Provides the ability to have the gadget present a UI for setting preferences.\r\n   * Only available during design time.\r\n   * \r\n   * @param key Prefernce key\r\n   * @param value Preference value\r\n   */\r\n  public async setPreference(key: string, value: string | number | boolean) {\r\n\r\n    if (await this.isPreviewMode()) {\r\n      const client = await this.getClient();\r\n      client.setPreference(key, value);\r\n    } else {\r\n      console.log(\r\n        '%csetPreference() is only available in preview mode.',\r\n        'background-color:blue; color:yellow;'\r\n      );\r\n    }\r\n  }\r\n\r\n  // ---\r\n  // PRIVATE METHODS.\r\n  // ---\r\n  /** @ignore */\r\n  private getClient(): Promise<IClient> {\r\n\r\n    if (this.clientPromise) {\r\n\r\n      return (this.clientPromise);\r\n    }\r\n\r\n    if (window.Client) {\r\n\r\n      return (this.clientPromise = Promise.resolve(window.Client));\r\n    }\r\n\r\n    // A \"complete\" status indicates that the \"load\" event has been fired on the\r\n    // window; and, that all sub-resources such as Scripts, Images, and Frames have\r\n    // been loaded.\r\n    if (window.document.readyState === \"complete\") {\r\n\r\n      // If this event has fired AND the 3rd-party script isn't available (see IF-\r\n      // condition BEFORE this one), it means that the 3rd-party script either\r\n      // failed on the network or was BLOCKED by an ad-blocker. As such, we have to\r\n      // fall-back to using a mock API.\r\n      return (this.clientPromise = Promise.resolve(new NoopClient()));\r\n    }\r\n\r\n    // ASSERT: If we made it this far, the document has not completed loading (but it\r\n    // may be in an \"interactive\" state which is when I believe that the Angular app\r\n    // gets bootstrapped). As such, we need bind to the LOAD event to wait for our\r\n    // third-party scripts to load (or fail to load, or be blocked).\r\n    this.clientPromise = new Promise<IClient>(\r\n      (resolve) => {\r\n\r\n        window.addEventListener(\r\n          \"load\",\r\n          function handleWindowLoad() {\r\n\r\n            // At this point, the 3rd-party library is either available or\r\n            // it's not - there's no further loading to do. If it's not\r\n            // present on the global scope, we're going to fall-back to using\r\n            // a mock API.\r\n            resolve(window.Client || new NoopClient());\r\n          }\r\n        );\r\n\r\n      }\r\n    );\r\n\r\n    return (this.clientPromise);\r\n  }\r\n}\r\n\r\n\r\n\r\n// ----------------------------------------------------------------------------------- //\r\n// ----------------------------------------------------------------------------------- //\r\n\r\n// I provide a mock API for the 3rd-party script. This just allows the consuming code to\r\n// act as though the library is available even if it failed to load (example, it was\r\n// blocked by an ad-blocker).\r\n\r\n/** @ignore */\r\nclass NoopClient implements IClient {\r\n\r\n  constructor() {\r\n\r\n    console.log(\r\n      '%cClient API not available, falling back to mock API',\r\n      'background-color:blue; color:yellow;'\r\n    );\r\n  }\r\n\r\n  public callback(...args: any[]): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public getDeviceTime(date?: Date): Promise<string> {\r\n\r\n    return Promise.resolve(new Date().toISOString());\r\n  }\r\n\r\n  public async getDeviceTimeZoneName(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceTimeZoneID(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceTimeZoneOffset(): Promise<number> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getLanguageCode(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDeviceKey(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public sendCommand(name: string, arg: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public sendRemoteCommand(deviceKeys: string[], name: string, arg: string) {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public track(eventName: string, properties?: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public timeEvent(eventName: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public newEventSession(id?: string): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public async getRevelRoot(): Promise<string> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getCommandMap(): Promise<string> {\r\n\r\n    return Promise.resolve('{}');\r\n  }\r\n\r\n  public finish(): void {\r\n\r\n    // NOOP implement, nothing to do....\r\n  }\r\n\r\n  public async getDevice(): Promise<string | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getWidth(): Promise<number | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getHeight(): Promise<number | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getDuration(): Promise<number | null> {\r\n\r\n    return Promise.resolve(null);\r\n  }\r\n\r\n  public async getSdkVersion(): Promise<string> {\r\n\r\n    return Promise.resolve(version);\r\n  }\r\n\r\n  public setPreference(key: string, value: string | number | boolean) {\r\n\r\n    //if (window.parent !== window.top) {\r\n\r\n      window.parent.postMessage(\r\n        JSON.stringify({\r\n          type: 'setPreference',\r\n          key: key,\r\n          value: value\r\n        }),\r\n        '*'\r\n      );\r\n    //}\r\n  }\r\n}\r\n"]}

package/esm2020/lib/version.mjs

@@ -0,0 +1,3 @@
+// Generated by genversion.
+export const version = '1.0.11';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQkFBMkI7QUFDM0IsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLFFBQVEsQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdlbmVyYXRlZCBieSBnZW52ZXJzaW9uLlxuZXhwb3J0IGNvbnN0IHZlcnNpb24gPSAnMS4wLjExJ1xuIl19

package/fesm2015/reveldigital-player-client.mjs

@@ -12,6 +12,9 @@ import { RouterModule } from '@angular/router';
 import { APP_BASE_HREF } from '@angular/common';
 import * as i1$1 from '@angular/platform-browser';
 
+// Generated by genversion.
+const version = '1.0.11';
+
 class PlayerClientService {
     // private onPostMessageSub: Subscription;
     // private onPostMessageEvt$ = fromEvent(window, 'message').pipe(
@@ -348,6 +351,70 @@ class PlayerClientService {
             return device[0];
         });
     }
+    /**
+     * Returns the width of the visualization area.
+     *
+     * @returns Width of the visualization area
+     */
+    getWidth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.getClient();
+            return client.getWidth();
+        });
+    }
+    /**
+     * Returns the height of the visualization area.
+     *
+     * @returns Height of the visualization area
+     */
+    getHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.getClient();
+            return client.getHeight();
+        });
+    }
+    /**
+     * Returns the duration of the currently playing source.
+     * (only applicable when associated with a playlist)
+     *
+     * @returns Duration of the current item in milliseconds
+     */
+    getDuration() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const client = yield this.getClient();
+            return client.getDuration();
+        });
+    }
+    /**
+     * Returns the current SDK version.
+     *
+     * @returns SDK version
+     */
+    getSdkVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(version);
+        });
+    }
+    /**
+     * Set a preference value.
+     *
+     * Provides the ability to have the gadget present a UI for setting preferences.
+     * Only available during design time.
+     *
+     * @param key Prefernce key
+     * @param value Preference value
+     */
+    setPreference(key, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.isPreviewMode()) {
+                const client = yield this.getClient();
+                client.setPreference(key, value);
+            }
+            else {
+                console.log('%csetPreference() is only available in preview mode.', 'background-color:blue; color:yellow;');
+            }
+        });
+    }
     // ---
     // PRIVATE METHODS.
     // ---
@@ -459,13 +526,42 @@ class NoopClient {
             return Promise.resolve('{}');
         });
     }
+    finish() {
+        // NOOP implement, nothing to do....
+    }
     getDevice() {
         return __awaiter(this, void 0, void 0, function* () {
             return Promise.resolve(null);
         });
     }
-    finish() {
-        // NOOP implement, nothing to do....
+    getWidth() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(null);
+        });
+    }
+    getHeight() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(null);
+        });
+    }
+    getDuration() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(null);
+        });
+    }
+    getSdkVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Promise.resolve(version);
+        });
+    }
+    setPreference(key, value) {
+        //if (window.parent !== window.top) {
+        window.parent.postMessage(JSON.stringify({
+            type: 'setPreference',
+            key: key,
+            value: value
+        }), '*');
+        //}
     }
 }
 
@@ -571,7 +667,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImpo
             args: [{
                     providedIn: 'root'
                 }]
-        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ActivatedRoute }, { type: i2.Router }]; } });
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ActivatedRoute }, { type: i2.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"app-init.service.js","sourceRoot":"","sources":["../../../../../projects/reveldigital/player-client/src/lib/app-init.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, enableProdMode, isDevMode } from '@angular/core';\r\nimport { HttpClient } from \"@angular/common/http\";\r\nimport { ActivatedRoute, Router } from \"@angular/router\";\r\nimport * as yaml from \"js-yaml\";\r\nimport * as WebFont from 'webfontloader';\r\n\r\nconst isLocal: boolean = /localhost/.test(document.location.host);\r\n!isLocal && enableProdMode();\r\n\r\n\r\n/** @ignore */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class AppInitService {\r\n\r\n  constructor(\r\n    public http: HttpClient,\r\n    private _route: ActivatedRoute,\r\n    private _router: Router) {\r\n  }\r\n\r\n  init(): Promise<any> {\r\n\r\n    return new Promise<void>(async (resolve) => {\r\n\r\n      this.loadFonts();\r\n\r\n      if (isDevMode()) {\r\n        console.log(\r\n          '%cRunning in development mode',\r\n          'background-color:blue; color:yellow;'\r\n        );\r\n\r\n        /**\r\n         * Shim the shindig prefs functionality for dev mode\r\n         */\r\n        (<any>window).gadgets = {\r\n\r\n          Prefs: class {\r\n            getString(key: string) { return this.getParameterByName(key) }\r\n\r\n            getArray(key: string) { return this.getParameterByName(key).split(',') }\r\n\r\n            getBool(key: string) { return this.getParameterByName(key) === 'true' }\r\n\r\n            getCountry() { }\r\n\r\n            getFloat(key: string) { return parseFloat(this.getParameterByName(key)) }\r\n\r\n            getInt(key: string) { return parseInt(this.getParameterByName(key)) }\r\n\r\n            getLang() { return this.getParameterByName('lang') === '' ? 'en' : this.getParameterByName('lang'); }\r\n\r\n            getParameterByName(name: string, search = window.location.href): string {\r\n\r\n              name = name.replace(/[\\[\\]]/g, '\\\\$&');\r\n              let regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),\r\n                results = regex.exec(search);\r\n              if (!results) return '';\r\n              if (!results[2]) return '';\r\n              return decodeURIComponent(results[2].replace(/\\+/g, ' '));\r\n            }\r\n          }\r\n        };\r\n\r\n        this.http.get('assets/gadget.yaml', {\r\n          responseType: 'text'\r\n        }).subscribe(data => {\r\n          const doc: any = yaml.load(data);\r\n          let params: any = {}\r\n          for (const val of doc.prefs) {\r\n            params[val.name] = val.default_value\r\n          }\r\n\r\n          this._router.navigate([], {\r\n            relativeTo: this._route,\r\n            queryParams: params,\r\n          });\r\n\r\n          console.log(\r\n            `%cUser prefs loaded successfully`,\r\n            'background-color:blue; color:yellow;'\r\n          );\r\n        }, (err) => {\r\n          console.log(\r\n            `%cUnable to load user preferences YAML definition file: ${err}`,\r\n            'background-color:blue; color:yellow;'\r\n          );\r\n          console.log(\r\n            `%cPlease see our developer documentation for help with your app configuration: https://developer.reveldigital.com`,\r\n            'background-color:red; color:yellow;'\r\n          )\r\n        })\r\n      }\r\n      resolve();\r\n    });\r\n  }\r\n\r\n\r\n  private getFamilyName(css) {\r\n\r\n    let FONT_FAMILY_REGEX = /font-family:\\s*(?:[&#39;&#34;])*['\"]*(.+?)['\"]*(?:[&#39;&#34;])*\\s*;/i;\r\n    if (FONT_FAMILY_REGEX.test(css)) {\r\n      var matches = css.match(FONT_FAMILY_REGEX);\r\n      return matches[1].split(',')[0];\r\n    } else {\r\n      return '';\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Loads the given font from Google Web Fonts.\r\n   */\r\n  private loadFonts(): void {\r\n\r\n    const parameters = new URLSearchParams(window.location.search);\r\n    parameters.forEach((val, key) => {\r\n      try {\r\n        let fontFamily = this.getFamilyName(val);\r\n        if (fontFamily !== '') {\r\n          WebFont.load({\r\n            google: {\r\n              families: [fontFamily]\r\n            },\r\n            fontactive: (familyName) => {\r\n              console.log(`%cActivating font: ${familyName}`,\r\n                'background-color:blue; color:yellow;');\r\n            },\r\n            fontinactive: (familyName) => {\r\n              console.log(`%cFont inactive: ${familyName}`,\r\n                'background-color:red; color:yellow;');\r\n            }\r\n          });\r\n        }\r\n      } catch (e) {\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}
+//# sourceMappingURL=C:/Users/mike_/Documents/GitHub/reveldigital-client-library/dist/reveldigital/player-client/esm2020/lib/module.js.map
 
 /**
  * The safe style pipe is used when custom styles are defined for a gadget and must be applied to an Angular
@@ -607,7 +705,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImpo
                     declarations: [SafeStylePipe],
                     exports: [SafeStylePipe],
                 }]
-        }] });
+        }] });
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=C:/Users/mike_/Documents/GitHub/reveldigital-client-library/dist/reveldigital/player-client/esm2020/lib/module.js.map
 
 class PlayerClientModule {
 }
@@ -671,15 +771,21 @@ function initializeApp(appInitService) {
         PlayerClientService.init({});
         yield appInitService.init();
     });
-}
+}
+//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=C:/Users/mike_/Documents/GitHub/reveldigital-client-library/dist/reveldigital/player-client/esm2020/lib/module.js.map
 
 /*
  * Public API Surface of player-client
- */
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDRCQUE0QixDQUFDO0FBQzNDLGNBQWMsdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIHBsYXllci1jbGllbnRcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2xpYi9wbGF5ZXItY2xpZW50LnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvcGxheWVyLWNsaWVudC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2FmZS1zdHlsZS5waXBlJzsiXX0=
+//# sourceMappingURL=C:/Users/mike_/Documents/GitHub/reveldigital-client-library/dist/reveldigital/player-client/esm2020/module.js.map
 
 /**
  * Generated bundle index. Do not edit.
- */
+ */
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV2ZWxkaWdpdGFsLXBsYXllci1jbGllbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9yZXZlbGRpZ2l0YWwvcGxheWVyLWNsaWVudC9zcmMvcmV2ZWxkaWdpdGFsLXBsYXllci1jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==
+//# sourceMappingURL=C:/Users/mike_/Documents/GitHub/reveldigital-client-library/dist/reveldigital/player-client/esm2020/module.js.map
 
 export { NgSafeStylePipeModule, PlayerClientModule, PlayerClientService, SafeStylePipe };
 //# sourceMappingURL=reveldigital-player-client.mjs.map