@reveldigital/player-client 0.0.16-beta.0 → 0.0.16-beta.2

package/esm2020/lib/app-init.service.mjs

@@ -0,0 +1,73 @@
+import { Injectable, isDevMode } from '@angular/core';
+import * as yaml from "js-yaml";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/router";
+export class AppInitService {
+    constructor(http, _route, _router) {
+        this.http = http;
+        this._route = _route;
+        this._router = _router;
+    }
+    init() {
+        return new Promise(async (resolve) => {
+            if (isDevMode()) {
+                console.log('%cRunning in development mode', 'background-color: yellow; color:red;');
+                /**
+                 * Shim the shindig prefs functionality for dev mode
+                 */
+                window.gadgets = {
+                    Prefs: class {
+                        getString(key) { return this.getParameterByName(key); }
+                        getArray(key) { return this.getParameterByName(key).split(','); }
+                        getBool(key) { return !!this.getParameterByName(key); }
+                        getCountry() { }
+                        getFloat(key) { return parseFloat(this.getParameterByName(key)); }
+                        getInt(key) { return parseInt(this.getParameterByName(key)); }
+                        getLang() { return this.getParameterByName('lang') === '' ? 'en' : this.getParameterByName('lang'); }
+                        getParameterByName(name, search = window.location.href) {
+                            const urlParams = new URLSearchParams(search);
+                            return urlParams.has(name) ? urlParams.get(name) : '';
+                            // name = name.replace(/[\[\]]/g, '\\$&');
+                            // let regex = new RegExp('[?&]' + name + '(=([^&#]*)|&|#|$)'),
+                            //   results = regex.exec(search);
+                            // if (!results) return '';
+                            // if (!results[2]) return '';
+                            // return decodeURIComponent(results[2].replace(/\+/g, ' '));
+                        }
+                    }
+                };
+                this.http.get('assets/user-prefs.yml', {
+                    responseType: 'text'
+                }).subscribe(data => {
+                    try {
+                        const doc = yaml.load(data);
+                        let params = {};
+                        for (const val of doc.prefs) {
+                            params[val.name] = val.default_value;
+                        }
+                        this._router.navigate([], {
+                            relativeTo: this._route,
+                            queryParams: params,
+                        });
+                        console.log(`%cUser prefs loaded successfully`, 'background-color: yellow; color:red;');
+                    }
+                    catch (e) {
+                        console.log(`Unable to load user preferences YAML definition file: ${e}`, 'background-color: yellow; color:red;');
+                        console.log(`Please see our developer documentation for help with your app configuration: https://developer.reveldigital.com`, 'background-color: yellow; color:red;');
+                    }
+                });
+            }
+            resolve();
+        });
+    }
+}
+AppInitService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AppInitService, deps: [{ token: i1.HttpClient }, { token: i2.ActivatedRoute }, { token: i2.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+AppInitService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AppInitService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: AppInitService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ActivatedRoute }, { type: i2.Router }]; } });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,42 @@
+import { APP_INITIALIZER, NgModule } from '@angular/core';
+import { PlayerClientService } from './player-client.service';
+import { AppInitService } from './app-init.service';
+import { HttpClientModule } from '@angular/common/http';
+import { RouterModule } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+export class PlayerClientModule {
+}
+PlayerClientModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: PlayerClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+PlayerClientModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: PlayerClientModule, imports: [HttpClientModule, i1.RouterModule] });
+PlayerClientModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: PlayerClientModule, providers: [{
+            provide: APP_INITIALIZER,
+            useFactory: initializeApp,
+            deps: [AppInitService, PlayerClientService],
+            multi: true
+        }], imports: [[
+            HttpClientModule,
+            RouterModule.forRoot([])
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: PlayerClientModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        HttpClientModule,
+                        RouterModule.forRoot([])
+                    ],
+                    providers: [{
+                            provide: APP_INITIALIZER,
+                            useFactory: initializeApp,
+                            deps: [AppInitService, PlayerClientService],
+                            multi: true
+                        }]
+                }]
+        }] });
+function initializeApp(appInitService) {
+    return async () => {
+        PlayerClientService.init({});
+        await appInitService.init();
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxheWVyLWNsaWVudC5tb2R1bGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9yZXZlbGRpZ2l0YWwvcGxheWVyLWNsaWVudC9zcmMvbGliL3BsYXllci1jbGllbnQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxlQUFlLEVBQUUsUUFBUSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzFELE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQzlELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNwRCxPQUFPLEVBQUUsZ0JBQWdCLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUN4RCxPQUFPLEVBQUUsWUFBWSxFQUFVLE1BQU0saUJBQWlCLENBQUM7OztBQWV2RCxNQUFNLE9BQU8sa0JBQWtCOztnSEFBbEIsa0JBQWtCO2lIQUFsQixrQkFBa0IsWUFWM0IsZ0JBQWdCO2lIQVVQLGtCQUFrQixhQVBsQixDQUFDO1lBQ1YsT0FBTyxFQUFFLGVBQWU7WUFDeEIsVUFBVSxFQUFFLGFBQWE7WUFDekIsSUFBSSxFQUFFLENBQUMsY0FBYyxFQUFFLG1CQUFtQixDQUFDO1lBQzNDLEtBQUssRUFBRSxJQUFJO1NBQ1osQ0FBQyxZQVRPO1lBQ1AsZ0JBQWdCO1lBQ2hCLFlBQVksQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDO1NBQ3pCOzRGQVFVLGtCQUFrQjtrQkFaOUIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUU7d0JBQ1AsZ0JBQWdCO3dCQUNoQixZQUFZLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQztxQkFDekI7b0JBQ0QsU0FBUyxFQUFFLENBQUM7NEJBQ1YsT0FBTyxFQUFFLGVBQWU7NEJBQ3hCLFVBQVUsRUFBRSxhQUFhOzRCQUN6QixJQUFJLEVBQUUsQ0FBQyxjQUFjLEVBQUUsbUJBQW1CLENBQUM7NEJBQzNDLEtBQUssRUFBRSxJQUFJO3lCQUNaLENBQUM7aUJBQ0g7O0FBR0QsU0FBUyxhQUFhLENBQUMsY0FBOEI7SUFDbkQsT0FBTyxLQUFLLElBQUksRUFBRTtRQUNoQixtQkFBbUIsQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7UUFDN0IsTUFBTSxjQUFjLENBQUMsSUFBSSxFQUFFLENBQUM7SUFDOUIsQ0FBQyxDQUFBO0FBQ0gsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEFQUF9JTklUSUFMSVpFUiwgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IFBsYXllckNsaWVudFNlcnZpY2UgfSBmcm9tICcuL3BsYXllci1jbGllbnQuc2VydmljZSc7XG5pbXBvcnQgeyBBcHBJbml0U2VydmljZSB9IGZyb20gJy4vYXBwLWluaXQuc2VydmljZSc7XG5pbXBvcnQgeyBIdHRwQ2xpZW50TW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuaW1wb3J0IHsgUm91dGVyTW9kdWxlLCBSb3V0ZXMgfSBmcm9tICdAYW5ndWxhci9yb3V0ZXInO1xuXG5cbkBOZ01vZHVsZSh7XG4gIGltcG9ydHM6IFtcbiAgICBIdHRwQ2xpZW50TW9kdWxlLFxuICAgIFJvdXRlck1vZHVsZS5mb3JSb290KFtdKVxuICBdLFxuICBwcm92aWRlcnM6IFt7XG4gICAgcHJvdmlkZTogQVBQX0lOSVRJQUxJWkVSLFxuICAgIHVzZUZhY3Rvcnk6IGluaXRpYWxpemVBcHAsXG4gICAgZGVwczogW0FwcEluaXRTZXJ2aWNlLCBQbGF5ZXJDbGllbnRTZXJ2aWNlXSxcbiAgICBtdWx0aTogdHJ1ZVxuICB9XVxufSlcbmV4cG9ydCBjbGFzcyBQbGF5ZXJDbGllbnRNb2R1bGUgeyB9XG5cbmZ1bmN0aW9uIGluaXRpYWxpemVBcHAoYXBwSW5pdFNlcnZpY2U6IEFwcEluaXRTZXJ2aWNlKSB7XG4gIHJldHVybiBhc3luYyAoKSA9PiB7XG4gICAgUGxheWVyQ2xpZW50U2VydmljZS5pbml0KHt9KTtcbiAgICBhd2FpdCBhcHBJbml0U2VydmljZS5pbml0KCk7XG4gIH1cbn1cbiJdfQ==

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

@@ -0,0 +1,258 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, fromEvent, Subject } from 'rxjs';
+import { map, share, tap } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export class PlayerClientService {
+    // private onPostMessageSub: Subscription;
+    // private onPostMessageEvt$ = fromEvent(window, 'message').pipe(
+    //   filter((messageEvent: MessageEvent) =>
+    //     messageEvent.source !== window.parent &&
+    //     typeof messageEvent.data === 'string' &&
+    //     messageEvent.data.startsWith('reveldigital:')),
+    //   map((e: any) => { return JSON.parse(e.substring(13)) as Command }),
+    //   share(),
+    //   tap(this.onCommand$)
+    // );
+    constructor(zone) {
+        this.onCommand$ = new Subject();
+        this.onReady$ = new BehaviorSubject(false);
+        this.onStart$ = new Subject();
+        this.onStop$ = new Subject();
+        this.onStartEvt$ = fromEvent(document, 'RevelDigital.Start').pipe(share(), tap(this.onStart$));
+        this.onStopEvt$ = fromEvent(document, 'RevelDigital.Stop').pipe(share(), tap(this.onStop$));
+        this.onCommandEvt$ = fromEvent(document, 'RevelDigital.Command').pipe(map((e) => { return { name: e.detail.name, arg: e.detail.arg }; }), share(), tap(this.onCommand$));
+        let self = this;
+        window.RevelDigital = {
+            Controller: {
+                onCommand: function (name, arg) {
+                    zone.run(() => {
+                        self.onCommand$.next({ name: name, arg: arg });
+                    });
+                },
+                onStart: function () {
+                    zone.run(() => {
+                        self.onStart$.next();
+                    });
+                },
+                onStop: function () {
+                    zone.run(() => {
+                        self.onStop$.next();
+                    });
+                }
+            }
+        };
+        this.onStartSub = this.onStartEvt$.subscribe(() => { });
+        this.onStopSub = this.onStopEvt$.subscribe(() => { });
+        this.onCommandSub = this.onCommandEvt$.subscribe(() => { });
+        this.clientPromise = null;
+        this.onReady$.next(true);
+    }
+    ngOnDestroy() {
+        this.onStartSub?.unsubscribe();
+        this.onStopSub?.unsubscribe();
+        this.onCommandSub?.unsubscribe();
+        this.onReady$.next(false);
+    }
+    static init(data) {
+        console.log('%cInitializing Revel Digital client library', 'background-color: yellow; color:red;');
+    }
+    callback(...args) {
+        this.getClient().then((client) => {
+            switch (args.length) {
+                case 0:
+                    client.callback();
+                    break;
+                case 1:
+                    client.callback(args[0]);
+                    break;
+                case 2:
+                    client.callback(args[1]);
+                    break;
+                case 3:
+                    client.callback(args[2]);
+                    break;
+                case 4:
+                    client.callback(args[3]);
+                    break;
+                case 5:
+                    client.callback(args[4]);
+                    break;
+            }
+        });
+    }
+    async getDeviceTime(date) {
+        const client = await this.getClient();
+        if (date !== undefined) {
+            return client.getDeviceTime(date);
+        }
+        return client.getDeviceTime();
+    }
+    async getDeviceTimeZoneName() {
+        const client = await this.getClient();
+        return client.getDeviceTimeZoneName();
+    }
+    async getDeviceTimeZoneID() {
+        const client = await this.getClient();
+        return client.getDeviceTimeZoneID();
+    }
+    async getDeviceTimeZoneOffset() {
+        const client = await this.getClient();
+        return client.getDeviceTimeZoneOffset();
+    }
+    async getLanguageCode() {
+        const client = await this.getClient();
+        return client.getLanguageCode();
+    }
+    async getDeviceKey() {
+        const client = await this.getClient();
+        return client.getDeviceKey();
+    }
+    sendCommand(name, arg) {
+        this.getClient().then((client) => {
+            client.sendCommand(name, arg);
+        });
+    }
+    sendRemoteCommand(deviceKeys, name, arg) {
+        this.getClient().then((client) => {
+            client.sendRemoteCommand(deviceKeys, name, arg);
+        });
+    }
+    track(eventName, properties) {
+        this.getClient().then((client) => {
+            client.track(eventName, JSON.stringify(properties));
+        });
+    }
+    timeEvent(eventName) {
+        this.getClient().then((client) => {
+            client.timeEvent(eventName);
+        });
+    }
+    newEventSession(id) {
+        this.getClient().then((client) => {
+            if (id !== undefined) {
+                client.newEventSession();
+            }
+            else {
+                client.newEventSession(id);
+            }
+        });
+    }
+    async getRevelRoot() {
+        const client = await this.getClient();
+        return client.getRevelRoot();
+    }
+    async getCommandMap() {
+        const client = await this.getClient();
+        return JSON.parse(await client.getCommandMap());
+        // let map = new Map<string, any>();
+        // let obj = JSON.parse(await client.getCommandMap());
+        // for (let key in obj) {
+        //   map.set(key, obj[key]);
+        // }
+        // return map;
+    }
+    finish() {
+        this.getClient().then((client) => {
+            client.finish();
+        });
+    }
+    // ---
+    // PRIVATE METHODS.
+    // ---
+    getClient() {
+        if (this.clientPromise) {
+            return (this.clientPromise);
+        }
+        if (window.Client) {
+            return (this.clientPromise = Promise.resolve(window.Client));
+        }
+        // A "complete" status indicates that the "load" event has been fired on the
+        // window; and, that all sub-resources such as Scripts, Images, and Frames have
+        // been loaded.
+        if (window.document.readyState === "complete") {
+            // If this event has fired AND the 3rd-party script isn't available (see IF-
+            // condition BEFORE this one), it means that the 3rd-party script either
+            // failed on the network or was BLOCKED by an ad-blocker. As such, we have to
+            // fall-back to using a mock API.
+            return (this.clientPromise = Promise.resolve(new NoopClient()));
+        }
+        // ASSERT: If we made it this far, the document has not completed loading (but it
+        // may be in an "interactive" state which is when I believe that the Angular app
+        // gets bootstrapped). As such, we need bind to the LOAD event to wait for our
+        // third-party scripts to load (or fail to load, or be blocked).
+        this.clientPromise = new Promise((resolve) => {
+            window.addEventListener("load", function handleWindowLoad() {
+                // At this point, the 3rd-party library is either available or
+                // it's not - there's no further loading to do. If it's not
+                // present on the global scope, we're going to fall-back to using
+                // a mock API.
+                resolve(window.Client || new NoopClient());
+            });
+        });
+        return (this.clientPromise);
+    }
+}
+PlayerClientService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: PlayerClientService, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Injectable });
+PlayerClientService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: PlayerClientService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: PlayerClientService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; } });
+// ----------------------------------------------------------------------------------- //
+// ----------------------------------------------------------------------------------- //
+// I provide a mock API for the 3rd-party script. This just allows the consuming code to
+// act as though the library is available even if it failed to load (example, it was
+// blocked by an ad-blocker).
+class NoopClient {
+    constructor() {
+        console.log('%cClient API not available, falling back to mock API', 'background-color: yellow; color:red;');
+    }
+    callback(...args) {
+        // NOOP implement, nothing to do....
+    }
+    getDeviceTime(date) {
+        return Promise.resolve(new Date().toISOString());
+    }
+    async getDeviceTimeZoneName() {
+        return Promise.resolve(null);
+    }
+    async getDeviceTimeZoneID() {
+        return Promise.resolve(null);
+    }
+    async getDeviceTimeZoneOffset() {
+        return Promise.resolve(null);
+    }
+    async getLanguageCode() {
+        return Promise.resolve(null);
+    }
+    async getDeviceKey() {
+        return Promise.resolve(null);
+    }
+    sendCommand(name, arg) {
+        // NOOP implement, nothing to do....
+    }
+    sendRemoteCommand(deviceKeys, name, arg) {
+        // NOOP implement, nothing to do....
+    }
+    track(eventName, properties) {
+        // NOOP implement, nothing to do....
+    }
+    timeEvent(eventName) {
+        // NOOP implement, nothing to do....
+    }
+    newEventSession(id) {
+        // NOOP implement, nothing to do....
+    }
+    async getRevelRoot() {
+        return Promise.resolve(null);
+    }
+    async getCommandMap() {
+        return Promise.resolve('{}');
+    }
+    finish() {
+        // NOOP implement, nothing to do....
+    }
+}
+//# 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, OnInit } from '@angular/core';\r\nimport { BehaviorSubject, fromEvent, Subject, Subscription } from 'rxjs';\r\nimport { filter, map, share, tap } from 'rxjs/operators';\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\ndeclare global {\r\n  var Client: Client;\r\n}\r\n\r\nexport interface Client {\r\n\r\n  callback(...args: any[]): void;\r\n\r\n  getDeviceTime(date?: Date): Promise<string>;\r\n\r\n  getDeviceTimeZoneName(): Promise<string>;\r\n\r\n  getDeviceTimeZoneID(): Promise<string>;\r\n\r\n  getDeviceTimeZoneOffset(): Promise<number>;\r\n\r\n  getLanguageCode(): Promise<string>;\r\n\r\n  getDeviceKey(): Promise<string>;\r\n\r\n  sendCommand(name: string, arg: string): void;\r\n\r\n  sendRemoteCommand(deviceKeys: string[], name: string, arg: string): void;\r\n\r\n  track(eventName: string, properties?: string): void;\r\n\r\n  timeEvent(eventName: string): void;\r\n\r\n  newEventSession(id?: string): void;\r\n\r\n  getRevelRoot(): Promise<string>;\r\n\r\n  getCommandMap(): Promise<string>;\r\n\r\n  finish(): void;\r\n}\r\n\r\nexport interface EventProperties {\r\n  [key: string]: any;\r\n}\r\n\r\nexport interface Command {\r\n  name: string;\r\n  arg: string;\r\n}\r\n\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class PlayerClientService implements OnDestroy {\r\n\r\n  private clientPromise: Promise<Client> | null;\r\n\r\n  public onCommand$ = new Subject<Command>();\r\n  public onReady$ = new BehaviorSubject(false);\r\n  public onStart$ = new Subject();\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  private onStartSub: Subscription;\r\n  private onStartEvt$ = fromEvent(document, 'RevelDigital.Start').pipe(\r\n    share(),\r\n    tap(this.onStart$)\r\n  );\r\n  private onStopSub: Subscription;\r\n  private onStopEvt$ = fromEvent(document, 'RevelDigital.Stop').pipe(\r\n    share(),\r\n    tap(this.onStop$)\r\n  );\r\n  private onCommandSub: Subscription;\r\n  private onCommandEvt$ = fromEvent<Command>(document, 'RevelDigital.Command').pipe(\r\n    map((e: any) => { return { name: e.detail.name, arg: e.detail.arg } as Command }),\r\n    share(),\r\n    tap(this.onCommand$)\r\n  );\r\n\r\n  // private onPostMessageSub: Subscription;\r\n  // private onPostMessageEvt$ = fromEvent(window, 'message').pipe(\r\n  //   filter((messageEvent: MessageEvent) =>\r\n  //     messageEvent.source !== window.parent &&\r\n  //     typeof messageEvent.data === 'string' &&\r\n  //     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\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();\r\n          });\r\n        },\r\n        onStop: function () {\r\n          zone.run(() => {\r\n            self.onStop$.next();\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  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  public static init(data: any) {\r\n\r\n    console.log(\r\n      '%cInitializing Revel Digital client library',\r\n      'background-color: yellow; color:red;'\r\n    );\r\n  }\r\n\r\n  public callback(...args: any[]): void {\r\n\r\n    this.getClient().then((client) => {\r\n\r\n      switch (args.length) {\r\n        case 0:\r\n          client.callback();\r\n          break;\r\n        case 1:\r\n          client.callback(args[0]);\r\n          break;\r\n        case 2:\r\n          client.callback(args[1]);\r\n          break;\r\n        case 3:\r\n          client.callback(args[2]);\r\n          break;\r\n        case 4:\r\n          client.callback(args[3]);\r\n          break;\r\n        case 5:\r\n          client.callback(args[4]);\r\n          break;\r\n      }\r\n    })\r\n  }\r\n\r\n  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  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  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  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  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  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  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  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  public track(eventName: string, properties?: EventProperties): 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  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  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  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  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    // let map = new Map<string, any>();\r\n\r\n    // let obj = JSON.parse(await client.getCommandMap());\r\n    // for (let key in obj) {\r\n    //   map.set(key, obj[key]);\r\n    // }\r\n    // return map;\r\n  }\r\n\r\n  public finish(): void {\r\n\r\n    this.getClient().then((client) => {\r\n      client.finish();\r\n    })\r\n  }\r\n\r\n  // ---\r\n  // PRIVATE METHODS.\r\n  // ---\r\n\r\n  private getClient(): Promise<Client> {\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<Client>(\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\nclass NoopClient implements Client {\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: yellow; color:red;'\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"]}

package/esm2020/public-api.mjs

@@ -0,0 +1,6 @@
+/*
+ * Public API Surface of player-client
+ */
+export * from './lib/player-client.service';
+export * from './lib/player-client.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBwbGF5ZXItY2xpZW50XG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvcGxheWVyLWNsaWVudC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3BsYXllci1jbGllbnQubW9kdWxlJztcbiJdfQ==

package/esm2020/reveldigital-player-client.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV2ZWxkaWdpdGFsLXBsYXllci1jbGllbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy9yZXZlbGRpZ2l0YWwvcGxheWVyLWNsaWVudC9zcmMvcmV2ZWxkaWdpdGFsLXBsYXllci1jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==