@reveldigital/player-client 2.1.0 → 2.2.0

package/esm2022/lib/datatable-ref.mjs

@@ -32,21 +32,13 @@ export class DataTableRef {
         this.rowCreated$ = new Subject();
         /** Emits when a row is removed. */
         this.rowDeleted$ = new Subject();
-        /** @ignore */
-        this._onRowUpdated = (change) => this.rowUpdated$.next(change);
-        /** @ignore */
-        this._onRowCreated = (change) => this.rowCreated$.next(change);
-        /** @ignore */
-        this._onRowDeleted = (change) => this.rowDeleted$.next(change);
         const lib = window.gadgets?.['reveldigital.datatable'];
         if (!lib || typeof lib.create !== 'function') {
             throw new Error('RevelDigital DataTable library is not available. ' +
                 'Ensure the datatable feature is enabled for this gadget.');
         }
         this._instance = lib.create(tableId, options);
-        this._instance.on('rowUpdated', this._onRowUpdated);
-        this._instance.on('rowCreated', this._onRowCreated);
-        this._instance.on('rowDeleted', this._onRowDeleted);
+        this._wireEvents();
     }
     /**
      * Fetches rows from the data table.
@@ -119,5 +111,86 @@ export class DataTableRef {
         this.rowCreated$.complete();
         this.rowDeleted$.complete();
     }
+    /** @ignore */
+    static _fromInstance(instance) {
+        const ref = Object.create(DataTableRef.prototype);
+        ref.rowUpdated$ = new Subject();
+        ref.rowCreated$ = new Subject();
+        ref.rowDeleted$ = new Subject();
+        ref._instance = instance;
+        ref._wireEvents();
+        return ref;
+    }
+    /** @ignore */
+    _wireEvents() {
+        this._onRowUpdated = (change) => this.rowUpdated$.next(change);
+        this._onRowCreated = (change) => this.rowCreated$.next(change);
+        this._onRowDeleted = (change) => this.rowDeleted$.next(change);
+        this._instance.on('rowUpdated', this._onRowUpdated);
+        this._instance.on('rowCreated', this._onRowCreated);
+        this._instance.on('rowDeleted', this._onRowDeleted);
+    }
+}
+/**
+ * Wrapper around a data table created from a gadget preference value.
+ *
+ * Automatically configures filter and sort settings from the preference,
+ * and provides a `getFilteredRows()` convenience method that applies them.
+ *
+ * ```typescript
+ * const cfg = this.client.createDataTableFromPref(prefs.getString('rdDataTable'));
+ *
+ * // Fetch rows with auto-wired filter + sort from the preference
+ * const result = await cfg.getFilteredRows();
+ *
+ * // Access the underlying DataTableRef for schema, events, etc.
+ * cfg.dataTable.rowUpdated$.subscribe(change => console.log(change));
+ *
+ * // Cleanup
+ * cfg.dispose();
+ * ```
+ */
+export class DataTablePrefRef {
+    /**
+     * Creates a new DataTablePrefRef from a gadget preference JSON string.
+     *
+     * @param prefValue - The raw gadget preference string (JSON)
+     * @param options - Optional configuration overrides
+     * @throws Error if the global datatable library is not loaded
+     */
+    constructor(prefValue, options) {
+        const lib = window.gadgets?.['reveldigital.datatable'];
+        if (!lib || typeof lib.createFromPref !== 'function') {
+            throw new Error('RevelDigital DataTable library is not available. ' +
+                'Ensure the datatable feature is enabled for this gadget.');
+        }
+        this._config = lib.createFromPref(prefValue, options);
+        this.pref = this._config.pref;
+        this.dataTable = DataTableRef._fromInstance(this._config.dt);
+    }
+    /**
+     * Fetches rows with the filter and sort settings from the preference automatically applied.
+     * Additional query parameters can override or supplement the preference settings.
+     *
+     * @param params - Optional additional query parameters
+     * @returns Promise resolving to the result set
+     *
+     * ```typescript
+     * // Use preference defaults
+     * const result = await cfg.getFilteredRows();
+     *
+     * // Override page size
+     * const page = await cfg.getFilteredRows({ pageSize: 10 });
+     * ```
+     */
+    getFilteredRows(params) {
+        return this._config.getFilteredRows(params);
+    }
+    /**
+     * Releases all resources held by the underlying DataTableRef.
+     */
+    dispose() {
+        this.dataTable.dispose();
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-ref.js","sourceRoot":"","sources":["../../../../../projects/reveldigital/player-client/src/lib/datatable-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject } from 'rxjs';\nimport {\n  IDataTableChangeEvent,\n  IDataTableColumn,\n  IDataTableOptions,\n  IDataTableQueryParams,\n  IDataTableResult,\n  IDataTableSchema\n} from './interfaces/datatable.interface';\n\n/**\n * Angular-friendly wrapper around the global `gadgets.reveldigital.datatable` library.\n *\n * Provides typed Promise-based methods and RxJS Observables for real-time events.\n *\n * ```typescript\n * const dt = this.client.createDataTable('tbl_menu_items');\n *\n * // Fetch rows\n * const result = await dt.getRows({ sort: 'price', sortDir: 'asc' });\n *\n * // Real-time updates\n * dt.rowUpdated$.subscribe(change => console.log('Updated:', change));\n *\n * // Cleanup\n * dt.dispose();\n * ```\n */\nexport class DataTableRef {\n\n  /** Emits when an existing row is modified. */\n  public rowUpdated$ = new Subject<IDataTableChangeEvent>();\n\n  /** Emits when a new row is added. */\n  public rowCreated$ = new Subject<IDataTableChangeEvent>();\n\n  /** Emits when a row is removed. */\n  public rowDeleted$ = new Subject<IDataTableChangeEvent>();\n\n  /** @ignore */\n  private _instance: any;\n\n  /** @ignore */\n  private _onRowUpdated = (change: IDataTableChangeEvent) => this.rowUpdated$.next(change);\n  /** @ignore */\n  private _onRowCreated = (change: IDataTableChangeEvent) => this.rowCreated$.next(change);\n  /** @ignore */\n  private _onRowDeleted = (change: IDataTableChangeEvent) => this.rowDeleted$.next(change);\n\n  /**\n   * Creates a new DataTableRef.\n   *\n   * @param tableId - The data table ID (e.g. 'tbl_menu_items')\n   * @param options - Optional configuration overrides\n   * @throws Error if the global datatable library is not loaded\n   */\n  constructor(tableId: string, options?: IDataTableOptions) {\n\n    const lib = (window as any).gadgets?.['reveldigital.datatable'];\n\n    if (!lib || typeof lib.create !== 'function') {\n      throw new Error(\n        'RevelDigital DataTable library is not available. ' +\n        'Ensure the datatable feature is enabled for this gadget.'\n      );\n    }\n\n    this._instance = lib.create(tableId, options);\n\n    this._instance.on('rowUpdated', this._onRowUpdated);\n    this._instance.on('rowCreated', this._onRowCreated);\n    this._instance.on('rowDeleted', this._onRowDeleted);\n  }\n\n  /**\n   * Fetches rows from the data table.\n   *\n   * @param params - Optional query parameters (filter, sort, pagination)\n   * @returns Promise resolving to the result set\n   *\n   * ```typescript\n   * const result = await dt.getRows({\n   *   filter: { category: 'Entree', price: { op: 'lte', value: 25 } },\n   *   sort: 'itemName',\n   *   sortDir: 'asc',\n   *   pageSize: 20\n   * });\n   * ```\n   */\n  public getRows(params?: IDataTableQueryParams): Promise<IDataTableResult> {\n    return this._instance.getRows(params);\n  }\n\n  /**\n   * Fetches the table schema (column definitions and metadata).\n   *\n   * @returns Promise resolving to the table schema\n   */\n  public getSchema(): Promise<IDataTableSchema> {\n    return this._instance.getSchema();\n  }\n\n  /**\n   * Gets visible (non-hidden) columns from the table schema.\n   *\n   * @returns Promise resolving to an array of visible column definitions\n   */\n  public getVisibleColumns(): Promise<IDataTableColumn[]> {\n    return this._instance.getVisibleColumns();\n  }\n\n  /**\n   * Fetches rows with hidden column data stripped.\n   *\n   * @param params - Optional query parameters (same as getRows)\n   * @returns Promise resolving to the result set with hidden fields removed\n   */\n  public getVisibleRows(params?: IDataTableQueryParams): Promise<IDataTableResult> {\n    return this._instance.getVisibleRows(params);\n  }\n\n  /**\n   * Starts polling for changes at the given interval.\n   * Emits on `rowUpdated$` when new data is detected.\n   *\n   * @param intervalMs - Polling interval in milliseconds (default 30000)\n   */\n  public startPolling(intervalMs?: number): void {\n    this._instance.startPolling(intervalMs);\n  }\n\n  /**\n   * Stops polling for changes.\n   */\n  public stopPolling(): void {\n    this._instance.stopPolling();\n  }\n\n  /**\n   * Releases all resources: stops polling, closes the real-time connection,\n   * removes event listeners, and completes all RxJS observables.\n   */\n  public dispose(): void {\n    this._instance.off('rowUpdated', this._onRowUpdated);\n    this._instance.off('rowCreated', this._onRowCreated);\n    this._instance.off('rowDeleted', this._onRowDeleted);\n\n    this._instance.dispose();\n\n    this.rowUpdated$.complete();\n    this.rowCreated$.complete();\n    this.rowDeleted$.complete();\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable-ref.js","sourceRoot":"","sources":["../../../../../projects/reveldigital/player-client/src/lib/datatable-ref.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject } from 'rxjs';\nimport {\n  IDataTableChangeEvent,\n  IDataTableColumn,\n  IDataTableOptions,\n  IDataTablePref,\n  IDataTableQueryParams,\n  IDataTableResult,\n  IDataTableSchema\n} from './interfaces/datatable.interface';\n\n/**\n * Angular-friendly wrapper around the global `gadgets.reveldigital.datatable` library.\n *\n * Provides typed Promise-based methods and RxJS Observables for real-time events.\n *\n * ```typescript\n * const dt = this.client.createDataTable('tbl_menu_items');\n *\n * // Fetch rows\n * const result = await dt.getRows({ sort: 'price', sortDir: 'asc' });\n *\n * // Real-time updates\n * dt.rowUpdated$.subscribe(change => console.log('Updated:', change));\n *\n * // Cleanup\n * dt.dispose();\n * ```\n */\nexport class DataTableRef {\n\n  /** Emits when an existing row is modified. */\n  public rowUpdated$ = new Subject<IDataTableChangeEvent>();\n\n  /** Emits when a new row is added. */\n  public rowCreated$ = new Subject<IDataTableChangeEvent>();\n\n  /** Emits when a row is removed. */\n  public rowDeleted$ = new Subject<IDataTableChangeEvent>();\n\n  /** @ignore */\n  private _instance: any;\n\n  /** @ignore */\n  private _onRowUpdated!: (change: IDataTableChangeEvent) => void;\n  /** @ignore */\n  private _onRowCreated!: (change: IDataTableChangeEvent) => void;\n  /** @ignore */\n  private _onRowDeleted!: (change: IDataTableChangeEvent) => void;\n\n  /**\n   * Creates a new DataTableRef.\n   *\n   * @param tableId - The data table ID (e.g. 'tbl_menu_items')\n   * @param options - Optional configuration overrides\n   * @throws Error if the global datatable library is not loaded\n   */\n  constructor(tableId: string, options?: IDataTableOptions) {\n\n    const lib = (window as any).gadgets?.['reveldigital.datatable'];\n\n    if (!lib || typeof lib.create !== 'function') {\n      throw new Error(\n        'RevelDigital DataTable library is not available. ' +\n        'Ensure the datatable feature is enabled for this gadget.'\n      );\n    }\n\n    this._instance = lib.create(tableId, options);\n    this._wireEvents();\n  }\n\n  /**\n   * Fetches rows from the data table.\n   *\n   * @param params - Optional query parameters (filter, sort, pagination)\n   * @returns Promise resolving to the result set\n   *\n   * ```typescript\n   * const result = await dt.getRows({\n   *   filter: { category: 'Entree', price: { op: 'lte', value: 25 } },\n   *   sort: 'itemName',\n   *   sortDir: 'asc',\n   *   pageSize: 20\n   * });\n   * ```\n   */\n  public getRows(params?: IDataTableQueryParams): Promise<IDataTableResult> {\n    return this._instance.getRows(params);\n  }\n\n  /**\n   * Fetches the table schema (column definitions and metadata).\n   *\n   * @returns Promise resolving to the table schema\n   */\n  public getSchema(): Promise<IDataTableSchema> {\n    return this._instance.getSchema();\n  }\n\n  /**\n   * Gets visible (non-hidden) columns from the table schema.\n   *\n   * @returns Promise resolving to an array of visible column definitions\n   */\n  public getVisibleColumns(): Promise<IDataTableColumn[]> {\n    return this._instance.getVisibleColumns();\n  }\n\n  /**\n   * Fetches rows with hidden column data stripped.\n   *\n   * @param params - Optional query parameters (same as getRows)\n   * @returns Promise resolving to the result set with hidden fields removed\n   */\n  public getVisibleRows(params?: IDataTableQueryParams): Promise<IDataTableResult> {\n    return this._instance.getVisibleRows(params);\n  }\n\n  /**\n   * Starts polling for changes at the given interval.\n   * Emits on `rowUpdated$` when new data is detected.\n   *\n   * @param intervalMs - Polling interval in milliseconds (default 30000)\n   */\n  public startPolling(intervalMs?: number): void {\n    this._instance.startPolling(intervalMs);\n  }\n\n  /**\n   * Stops polling for changes.\n   */\n  public stopPolling(): void {\n    this._instance.stopPolling();\n  }\n\n  /**\n   * Releases all resources: stops polling, closes the real-time connection,\n   * removes event listeners, and completes all RxJS observables.\n   */\n  public dispose(): void {\n    this._instance.off('rowUpdated', this._onRowUpdated);\n    this._instance.off('rowCreated', this._onRowCreated);\n    this._instance.off('rowDeleted', this._onRowDeleted);\n\n    this._instance.dispose();\n\n    this.rowUpdated$.complete();\n    this.rowCreated$.complete();\n    this.rowDeleted$.complete();\n  }\n\n  /** @ignore */\n  static _fromInstance(instance: any): DataTableRef {\n    const ref = Object.create(DataTableRef.prototype) as DataTableRef;\n    ref.rowUpdated$ = new Subject<IDataTableChangeEvent>();\n    ref.rowCreated$ = new Subject<IDataTableChangeEvent>();\n    ref.rowDeleted$ = new Subject<IDataTableChangeEvent>();\n    ref._instance = instance;\n    ref._wireEvents();\n    return ref;\n  }\n\n  /** @ignore */\n  private _wireEvents(): void {\n    this._onRowUpdated = (change: IDataTableChangeEvent) => this.rowUpdated$.next(change);\n    this._onRowCreated = (change: IDataTableChangeEvent) => this.rowCreated$.next(change);\n    this._onRowDeleted = (change: IDataTableChangeEvent) => this.rowDeleted$.next(change);\n\n    this._instance.on('rowUpdated', this._onRowUpdated);\n    this._instance.on('rowCreated', this._onRowCreated);\n    this._instance.on('rowDeleted', this._onRowDeleted);\n  }\n}\n\n\n/**\n * Wrapper around a data table created from a gadget preference value.\n *\n * Automatically configures filter and sort settings from the preference,\n * and provides a `getFilteredRows()` convenience method that applies them.\n *\n * ```typescript\n * const cfg = this.client.createDataTableFromPref(prefs.getString('rdDataTable'));\n *\n * // Fetch rows with auto-wired filter + sort from the preference\n * const result = await cfg.getFilteredRows();\n *\n * // Access the underlying DataTableRef for schema, events, etc.\n * cfg.dataTable.rowUpdated$.subscribe(change => console.log(change));\n *\n * // Cleanup\n * cfg.dispose();\n * ```\n */\nexport class DataTablePrefRef {\n\n  /** The underlying DataTableRef with full access to schema, events, polling, etc. */\n  public readonly dataTable: DataTableRef;\n\n  /** The parsed preference object. */\n  public readonly pref: IDataTablePref;\n\n  /** @ignore */\n  private _config: any;\n\n  /**\n   * Creates a new DataTablePrefRef from a gadget preference JSON string.\n   *\n   * @param prefValue - The raw gadget preference string (JSON)\n   * @param options - Optional configuration overrides\n   * @throws Error if the global datatable library is not loaded\n   */\n  constructor(prefValue: string, options?: IDataTableOptions) {\n\n    const lib = (window as any).gadgets?.['reveldigital.datatable'];\n\n    if (!lib || typeof lib.createFromPref !== 'function') {\n      throw new Error(\n        'RevelDigital DataTable library is not available. ' +\n        'Ensure the datatable feature is enabled for this gadget.'\n      );\n    }\n\n    this._config = lib.createFromPref(prefValue, options);\n    this.pref = this._config.pref;\n    this.dataTable = DataTableRef._fromInstance(this._config.dt);\n  }\n\n  /**\n   * Fetches rows with the filter and sort settings from the preference automatically applied.\n   * Additional query parameters can override or supplement the preference settings.\n   *\n   * @param params - Optional additional query parameters\n   * @returns Promise resolving to the result set\n   *\n   * ```typescript\n   * // Use preference defaults\n   * const result = await cfg.getFilteredRows();\n   *\n   * // Override page size\n   * const page = await cfg.getFilteredRows({ pageSize: 10 });\n   * ```\n   */\n  public getFilteredRows(params?: IDataTableQueryParams): Promise<IDataTableResult> {\n    return this._config.getFilteredRows(params);\n  }\n\n  /**\n   * Releases all resources held by the underlying DataTableRef.\n   */\n  public dispose(): void {\n    this.dataTable.dispose();\n  }\n}\n"]}

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

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable.interface.js","sourceRoot":"","sources":["../../../../../../projects/reveldigital/player-client/src/lib/interfaces/datatable.interface.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Filter operators supported by data table queries.\n *\n * - Simple equality: `{ columnKey: 'value' }`\n * - Operator-based: `{ columnKey: { op: 'contains', value: 'search' } }`\n * - Range: `{ columnKey: { op: 'inRange', from: 5, to: 20 } }`\n */\nexport type DataTableFilterOp =\n  | 'eq'\n  | 'neq'\n  | 'isEmpty'\n  | 'isNotEmpty'\n  | 'contains'\n  | 'notContains'\n  | 'gt'\n  | 'gte'\n  | 'lt'\n  | 'lte'\n  | 'positive'\n  | 'negative'\n  | 'inRange'\n  | 'outOfRange';\n\n/**\n * Operator-based filter expression for a single column.\n */\nexport interface IDataTableFilterOperator {\n  op: DataTableFilterOp;\n  value?: any;\n  from?: any;\n  to?: any;\n}\n\n/**\n * Filter value for a single column.\n * Can be a simple equality value (string/number/boolean) or an operator expression.\n */\nexport type DataTableFilterValue = string | number | boolean | IDataTableFilterOperator;\n\n/**\n * Filter map keyed by column key.\n *\n * Supports logical combinations:\n * - **AND** (default): multiple properties in a single object\n *   `{ status: 'active', price: { op: 'lte', value: 25 } }`\n * - **OR**: wrap each condition in a `$or` array\n *   `{ $or: [{ status: 'active' }, { status: 'pending' }] }`\n * - **Mixed**: AND conditions alongside an OR group\n *   `{ $or: [{ status: 'active' }, { status: 'pending' }], price: { op: 'gt', value: 0 } }`\n */\nexport interface IDataTableFilter {\n  /** OR group: rows matching any condition in the array. */\n  $or?: Array<{ [columnKey: string]: DataTableFilterValue }>;\n  [columnKey: string]: DataTableFilterValue | Array<{ [columnKey: string]: DataTableFilterValue }> | undefined;\n}\n\n/**\n * Column data types returned by the table schema.\n */\nexport type DataTableColumnType = 'text' | 'number' | 'boolean' | 'date' | 'image' | 'hidden';\n\n/**\n * Options for creating a DataTable instance.\n */\nexport interface IDataTableOptions {\n  /** Override auto-resolved device registration key. */\n  registrationKey?: string;\n  /** Override the API base URL. */\n  baseUrl?: string;\n  /** SignalR hub URL. Set to `null` to disable real-time updates. */\n  signalRUrl?: string | null;\n}\n\n/**\n * Query parameters for fetching rows from a data table.\n */\nexport interface IDataTableQueryParams {\n  /** Filter rules keyed by column key. */\n  filter?: IDataTableFilter;\n  /** Column key to sort by. */\n  sort?: string;\n  /** Sort direction. */\n  sortDir?: 'asc' | 'desc';\n  /** Results per page (max 100). */\n  pageSize?: number;\n  /** Pagination cursor from a previous result. */\n  continuationToken?: string;\n  /** Comma-separated column keys to include. */\n  fields?: string;\n}\n\n/**\n * A single row returned from the data table API.\n */\nexport interface IDataTableRow {\n  /** Row ID. */\n  id: string;\n  /** Sort order value. */\n  sortOrder: number;\n  /** Column key-value pairs. */\n  data: { [key: string]: any };\n  /** ISO 8601 last-modified timestamp. */\n  updatedAt: string;\n}\n\n/**\n * Result set returned by `getRows()` and `getVisibleRows()`.\n */\nexport interface IDataTableResult {\n  /** Row objects. */\n  data: IDataTableRow[];\n  /** Total matching rows across all pages. */\n  totalCount: number;\n  /** Token for fetching the next page, or `null` if no more pages. */\n  continuationToken: string | null;\n  /** ISO 8601 cache expiry timestamp. */\n  cacheUntil: string;\n  /** `true` when data is unchanged since the last fetch (ETag match). */\n  notModified?: boolean;\n}\n\n/**\n * Column definition returned by the table schema.\n */\nexport interface IDataTableColumn {\n  /** Column ID. */\n  id: string;\n  /** Display name. */\n  name: string;\n  /** Data key used in `row.data`. */\n  key: string;\n  /** Column data type. */\n  type: DataTableColumnType;\n  /** Whether the column is required. */\n  required: boolean;\n  /** Whether the column supports sorting. */\n  sortable: boolean;\n  /** Column-specific options. */\n  options: any;\n}\n\n/**\n * Table schema including column definitions and metadata.\n */\nexport interface IDataTableSchema {\n  /** Table ID. */\n  id: string;\n  /** Table name. */\n  name: string;\n  /** Table description. */\n  description: string;\n  /** Column definitions. */\n  columns: IDataTableColumn[];\n  /** Total rows in the table. */\n  rowCount: number;\n  /** ISO 8601 last-modified timestamp. */\n  updatedAt: string;\n}\n\n/**\n * Change event emitted for real-time data table updates.\n */\nexport interface IDataTableChangeEvent {\n  /** The table that changed. */\n  tableId: string;\n  /** The affected row ID. */\n  rowId: string;\n  /** Row data (present for created/updated events). */\n  data?: any;\n  /** The type of change. */\n  action: 'update' | 'create' | 'delete' | 'poll';\n}\n\n/**\n * A single filter rule within a datatable preference.\n */\nexport interface IDataTablePrefFilterRule {\n  /** Column key to filter on. */\n  columnKey: string;\n  /** Filter operator (defaults to 'eq'). */\n  operator?: DataTableFilterOp;\n  /** Value to compare against. */\n  value?: any;\n}\n\n/**\n * Parsed datatable gadget preference as serialized by the template editor.\n */\nexport interface IDataTablePref {\n  /** The data table ID. */\n  tableId?: string;\n  /** Primary column key. */\n  columnKey?: string;\n  /** Filter rules (new multi-filter format). */\n  filters?: IDataTablePrefFilterRule[];\n  /** Logical combination for filters. */\n  filterLogic?: 'and' | 'or';\n  /** Column key to sort by. */\n  sortColumnKey?: string;\n  /** Sort direction. */\n  sortDirection?: 'asc' | 'desc';\n  /** @deprecated Legacy single-filter column key. Use `filters` instead. */\n  filterColumnKey?: string;\n  /** @deprecated Legacy single-filter operator. Use `filters` instead. */\n  filterOperator?: DataTableFilterOp;\n  /** @deprecated Legacy single-filter value. Use `filters` instead. */\n  filterValue?: any;\n}\n"]}

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

@@ -1,7 +1,7 @@
 import { Injectable } from '@angular/core';
 import { BehaviorSubject, fromEvent, Subject } from 'rxjs';
 import { filter, map, share, tap } from 'rxjs/operators';
-import { DataTableRef } from './datatable-ref';
+import { DataTableRef, DataTablePrefRef } from './datatable-ref';
 import { version } from './version';
 import * as i0 from "@angular/core";
 /**
@@ -824,6 +824,35 @@ export class PlayerClientService {
     createDataTable(tableId, options) {
         return new DataTableRef(tableId, options);
     }
+    /**
+     * Creates a typed data table wrapper from a gadget preference value.
+     *
+     * The preference JSON string (as serialized by the template editor's datatable
+     * option) is parsed and used to auto-configure filter, sort, and logic settings.
+     * The returned {@link DataTablePrefRef} provides a `getFilteredRows()` convenience
+     * method that applies these settings automatically.
+     *
+     * @param prefValue - The raw gadget preference string (JSON)
+     * @param options - Optional configuration overrides
+     * @returns A {@link DataTablePrefRef} instance
+     * @throws Error if the global datatable library is not loaded
+     *
+     * ```typescript
+     * const cfg = this.client.createDataTableFromPref(prefs.getString('rdDataTable'));
+     *
+     * // Fetch rows with auto-wired filter + sort
+     * const result = await cfg.getFilteredRows();
+     *
+     * // Access the underlying DataTableRef for events, schema, etc.
+     * cfg.dataTable.rowUpdated$.subscribe(change => console.log(change));
+     *
+     * // Cleanup when done
+     * cfg.dispose();
+     * ```
+     */
+    createDataTableFromPref(prefValue, options) {
+        return new DataTablePrefRef(prefValue, options);
+    }
     // ---
     // PRIVATE METHODS.
     // ---
@@ -959,4 +988,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":"AAAA,OAAO,EAAE,UAAU,EAAqB,MAAM,eAAe,CAAC;AAE9D,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,OAAO,EAAgB,MAAM,MAAM,CAAC;AACzE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAOzD,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAC/C,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;;AAcpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAIH,MAAM,OAAO,mBAAmB;IAmK9B,cAAc;IACd,YAAY,IAAY;QA/JxB;;;;;;;;;;;WAWG;QACI,eAAU,GAAG,IAAI,OAAO,EAAY,CAAC;QAE5C;;;;;;;;;;;;WAYG;QACI,aAAQ,GAAG,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC;QAE7C;;;;;;;;;;WAUG;QACI,aAAQ,GAAG,IAAI,OAAO,EAAE,CAAC;QAEhC;;;;;;;;;;;WAWG;QACI,YAAO,GAAG,IAAI,OAAO,EAAE,CAAC;QAE/B;;;;;;;;;WASG;QACI,cAAS,GAAG,IAAI,OAAO,EAAE,CAAC;QAEjC;;;;;;;;;;WAUG;QACI,mBAAc,GAAG,IAAI,OAAO,EAAE,CAAC;QAUtC,cAAc;QACN,gBAAW,GAAG,SAAS,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,IAAI,CAChE,KAAK,EAAE,EACP,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CACnB,CAAC;QAGF,cAAc;QACN,eAAU,GAAG,SAAS,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,IAAI,CAC9D,KAAK,EAAE,EACP,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,CAClB,CAAC;QAGF,cAAc;QACN,kBAAa,GAAG,SAAS,CAAW,MAAM,EAAE,sBAAsB,CAAC,CAAC,IAAI,CAC9E,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,GAAG,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC,GAAG,EAAc,CAAA,CAAC,CAAC,CAAC,EAClF,KAAK,EAAE,EACP,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,CACrB,CAAC;QA4BM,sBAAiB,GAAG,SAAS,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC,IAAI,CAC3D,MAAM,CAAC,CAAC,YAA0B,EAAE,EAAE;QACpC,0CAA0C;QAC1C,OAAO,YAAY,CAAC,IAAI,KAAK,QAAQ,CAAC,EACxC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,EACnC,KAAK,EAAE,EACP,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE;YACb,IAAI,CAAC,CAAC,IAAI,KAAK,aAAa,IAAI,CAAC,CAAC,QAAQ,EAAE,CAAC;gBAC3C,CAAC,CAAC,QAAQ,GAAG,KAAK,CAAC;gBACnB,0DAA0D;gBAC1D,MAAM,CAAC,MAAM,CAAC,WAAW,CACvB,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EACjB,GAAG,CACJ,CAAC;YACJ,CAAC;iBAAM,IAAI,CAAC,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;gBACnC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAC5B,CAAC;QACH,CAAC,CAAC,EACF,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CACtC,CAAC;QAMC,MAAc,CAAC,YAAY,GAAG;YAC7B,UAAU,EAAE;gBACV,SAAS,EAAE,CAAC,IAAY,EAAE,GAAW,EAAE,EAAE;oBACvC,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;wBACZ,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;oBACjD,CAAC,CAAC,CAAC;gBACL,CAAC;gBACD,OAAO,EAAE,GAAG,EAAE;oBACZ,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;wBACZ,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC3B,CAAC,CAAC,CAAC;gBACL,CAAC;gBACD,MAAM,EAAE,GAAG,EAAE;oBACX,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE;wBACZ,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;oBAC1B,CAAC,CAAC,CAAC;gBACL,CAAC;aACF;SACF,CAAA;QAED,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QACxD,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QACtD,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QAC5D,4DAA4D;QAC5D,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;QAEpE,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC;QAE1B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3B,CAAC;IAED,cAAc;IACd,WAAW;QAET,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;QAC/B,IAAI,CAAC,SAAS,EAAE,WAAW,EAAE,CAAC;QAC9B,IAAI,CAAC,YAAY,EAAE,WAAW,EAAE,CAAC;QACjC,kCAAkC;QAClC,IAAI,CAAC,gBAAgB,EAAE,WAAW,EAAE,CAAC;QAErC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC5B,CAAC;IAED,cAAc;IACP,MAAM,CAAC,IAAI,CAAC,IAAS;QAE1B,OAAO,CAAC,GAAG,CACT,gDAAgD,EAChD,sCAAsC,CACvC,CAAC;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;OAgBG;IACI,QAAQ,CAAC,GAAG,IAAW;QAE5B,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAE/B,QAAQ,IAAI,CAAC,MAAM,EAAE,CAAC;gBACpB,KAAK,CAAC;oBACJ,MAAM,CAAC,QAAQ,EAAE,CAAC;oBAClB,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oBACzB,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oBACzB,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oBACzB,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oBACzB,MAAM;gBACR,KAAK,CAAC;oBACJ,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;oBACzB,MAAM;YACV,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACI,QAAQ;QAEb,OAAO,IAAI,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,EAAE,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACI,KAAK,CAAC,aAAa,CAAC,IAAW;QAEpC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,OAAO,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QACpC,CAAC;QACD,OAAO,MAAM,CAAC,aAAa,EAAE,CAAC;IAChC,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CAAC,qBAAqB;QAEhC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC,qBAAqB,EAAE,CAAC;IACxC,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CAAC,mBAAmB;QAE9B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC,mBAAmB,EAAE,CAAC;IACtC,CAAC;IAED;;;;;;;;;OASG;IACI,KAAK,CAAC,uBAAuB;QAElC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC,uBAAuB,EAAE,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;OAWG;IACI,KAAK,CAAC,eAAe;QAE1B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC,eAAe,EAAE,CAAC;IAClC,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,KAAK,CAAC,YAAY;QAEvB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC,YAAY,EAAE,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACI,WAAW,CAAC,IAAY,EAAE,GAAW;QAE1C,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC/B,MAAM,CAAC,WAAW,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAChC,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACI,iBAAiB,CAAC,UAAoB,EAAE,IAAY,EAAE,GAAW;QAEtE,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC/B,MAAM,CAAC,iBAAiB,CAAC,UAAU,EAAE,IAAI,EAAE,GAAG,CAAC,CAAC;QAClD,CAAC,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACI,KAAK,CAAC,SAAiB,EAAE,UAA6B;QAE3D,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC/B,MAAM,CAAC,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;QACtD,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACI,SAAS,CAAC,SAAiB;QAEhC,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC/B,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;QAC9B,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACI,eAAe,CAAC,EAAW;QAEhC,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAC/B,IAAI,EAAE,KAAK,SAAS,EAAE,CAAC;gBACrB,MAAM,CAAC,eAAe,EAAE,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACN,MAAM,CAAC,eAAe,CAAC,EAAE,CAAC,CAAC;YAC7B,CAAC;QACH,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;;OAaG;IACI,KAAK,CAAC,YAAY;QAEvB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC,YAAY,EAAE,CAAC;IAC/B,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACI,KAAK,CAAC,aAAa;QAExB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,MAAM,CAAC,aAAa,EAAE,CAAC,CAAC;IAClD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACI,MAAM;QAEX,IAAI,CAAC,SAAS,EAAE,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;YAE/B,MAAM,CAAC,MAAM,EAAE,CAAC;QAClB,CAAC,CAAC,CAAA;IACJ,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACI,KAAK,CAAC,aAAa;QAExB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,YAAY,UAAU,CAAC;IACtC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACI,KAAK,CAAC,SAAS;QAEpB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,MAAM,GAAG,GAAQ,IAAI,CAAC,KAAK,CAAS,MAAM,MAAM,CAAC,SAAS,EAAE,CAAC,CAAC;QAE9D,MAAM,MAAM,GAAc,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,MAAW,EAAE,EAAE;YAElD,OAAO;gBACL,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,eAAe,EAAE,MAAM,CAAC,GAAG;gBAC3B,UAAU,EAAE,MAAM,CAAC,UAAU;gBAC7B,cAAc,EAAE,IAAI,IAAI,CAAC,MAAM,CAAC,cAAc,CAAC;gBAC/C,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,IAAI,EAAE,MAAM,CAAC,WAAW,EAAE,KAAK,CAAC,IAAI,CAAC;gBACrC,QAAQ,EAAE;oBACR,IAAI,EAAE,MAAM,CAAC,QAAQ,EAAE,IAAI;oBAC3B,KAAK,EAAE,MAAM,CAAC,QAAQ,EAAE,KAAK;oBAC7B,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,OAAO;oBACjC,UAAU,EAAE,MAAM,CAAC,QAAQ,EAAE,UAAU;oBACvC,OAAO,EAAE,MAAM,CAAC,QAAQ,EAAE,OAAO;oBACjC,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,QAAQ;oBACnC,SAAS,EAAE,MAAM,CAAC,QAAQ,EAAE,SAAS;iBACtC;aACF,CAAA;QACH,CAAC,CAAC,CAAC;QACH,OAAO,MAAM,CAAC,CAAC,CAAC,CAAC;IACnB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACI,KAAK,CAAC,QAAQ;QAEnB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC,QAAQ,EAAE,CAAC;IAC3B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,KAAK,CAAC,SAAS;QAEpB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC,SAAS,EAAE,CAAC;IAC5B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACI,KAAK,CAAC,WAAW;QAEtB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QAEtC,OAAO,MAAM,CAAC,WAAW,EAAE,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;;;OAYG;IACI,KAAK,CAAC,aAAa;QAExB,OAAO,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACI,KAAK,CAAC,WAAW,CAAC,KAAuB;QAE9C,IAAI,MAAM,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC;YAC/B,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;YACtC,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;QAC5B,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CACT,oDAAoD,EACpD,sCAAsC,CACvC,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACI,eAAe,CAAC,OAAe,EAAE,OAA2B;QACjE,OAAO,IAAI,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;IAED,MAAM;IACN,mBAAmB;IACnB,MAAM;IACN,cAAc;IACN,SAAS;QAEf,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YAEvB,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAC9B,CAAC;QAED,IAAK,MAAc,CAAC,MAAM,EAAE,CAAC;YAE3B,OAAO,CAAC,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,OAAO,CAAE,MAAc,CAAC,MAAM,CAAC,CAAC,CAAC;QACxE,CAAC;QAED,4EAA4E;QAC5E,+EAA+E;QAC/E,eAAe;QACf,IAAI,MAAM,CAAC,QAAQ,CAAC,UAAU,KAAK,UAAU,EAAE,CAAC;YAE9C,4EAA4E;YAC5E,wEAAwE;YACxE,6EAA6E;YAC7E,iCAAiC;YACjC,OAAO,CAAC,IAAI,CAAC,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,UAAU,EAAE,CAAC,CAAC,CAAC;QAClE,CAAC;QAED,iFAAiF;QACjF,gFAAgF;QAChF,8EAA8E;QAC9E,gEAAgE;QAChE,IAAI,CAAC,aAAa,GAAG,IAAI,OAAO,CAC9B,CAAC,OAAO,EAAE,EAAE;YAEV,MAAM,CAAC,gBAAgB,CACrB,MAAM,EACN,SAAS,gBAAgB;gBAEvB,8DAA8D;gBAC9D,2DAA2D;gBAC3D,iEAAiE;gBACjE,cAAc;gBACd,OAAO,CAAE,MAAc,CAAC,MAAM,IAAI,IAAI,UAAU,EAAE,CAAC,CAAC;YACtD,CAAC,CACF,CAAC;QAEJ,CAAC,CACF,CAAC;QAEF,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;IAC9B,CAAC;+GAv9BU,mBAAmB;mHAAnB,mBAAmB,cAFlB,MAAM;;4FAEP,mBAAmB;kBAH/B,UAAU;mBAAC;oBACV,UAAU,EAAE,MAAM;iBACnB;;AA69BD,yFAAyF;AACzF,yFAAyF;AAEzF;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU;IAEd;QAEE,OAAO,CAAC,GAAG,CACT,sDAAsD,EACtD,sCAAsC,CACvC,CAAC;IACJ,CAAC;IAEM,QAAQ,CAAC,GAAG,IAAW;QAE5B,oCAAoC;IACtC,CAAC;IAEM,aAAa,CAAC,IAAW;QAE9B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC,CAAC;IACnD,CAAC;IAEM,KAAK,CAAC,qBAAqB;QAEhC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,mBAAmB;QAE9B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,uBAAuB;QAElC,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,eAAe;QAE1B,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,YAAY;QAEvB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,WAAW,CAAC,IAAY,EAAE,GAAW;QAE1C,oCAAoC;IACtC,CAAC;IAEM,iBAAiB,CAAC,UAAoB,EAAE,IAAY,EAAE,GAAW;QAEtE,oCAAoC;IACtC,CAAC;IAEM,KAAK,CAAC,SAAiB,EAAE,UAAmB;QAEjD,oCAAoC;IACtC,CAAC;IAEM,SAAS,CAAC,SAAiB;QAEhC,oCAAoC;IACtC,CAAC;IAEM,eAAe,CAAC,EAAW;QAEhC,oCAAoC;IACtC,CAAC;IAEM,KAAK,CAAC,YAAY;QAEvB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,aAAa;QAExB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,MAAM;QAEX,oCAAoC;IACtC,CAAC;IAEM,KAAK,CAAC,SAAS;QAEpB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,QAAQ;QAEnB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,SAAS;QAEpB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,WAAW;QAEtB,OAAO,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,CAAC;IAEM,KAAK,CAAC,aAAa;QAExB,OAAO,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAEM,WAAW,CAAC,KAAuB;QAExC,MAAM,GAAG,GAAG,EAAE,IAAI,EAAE,aAAa,EAAE,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;QAEpF,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAClB,MAAM,CAAC,MAAM,CAAC,WAAW,CACvB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EACnB,GAAG,CACJ,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,MAAM,CAAC,MAAM,CAAC,WAAW,CACvB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,EACnB,GAAG,CACJ,CAAC;QACJ,CAAC;IACH,CAAC;CACF","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 } 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 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    (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, 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 { 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 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    (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, 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, 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"]}

package/esm2022/lib/version.mjs

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '2.1.0';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQkFBMkI7QUFDM0IsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdlbmVyYXRlZCBieSBnZW52ZXJzaW9uLlxuZXhwb3J0IGNvbnN0IHZlcnNpb24gPSAnMi4xLjAnXG4iXX0=
+export const version = '2.2.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3JldmVsZGlnaXRhbC9wbGF5ZXItY2xpZW50L3NyYy9saWIvdmVyc2lvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSwyQkFBMkI7QUFDM0IsTUFBTSxDQUFDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8vIEdlbmVyYXRlZCBieSBnZW52ZXJzaW9uLlxuZXhwb3J0IGNvbnN0IHZlcnNpb24gPSAnMi4yLjAnXG4iXX0=