@playkit-js/playkit-js-providers 2.40.1 → 2.40.2-canary.0-c7a43ae

package/src/types/media-config-metadata.ts

@@ -0,0 +1,13 @@
+export type ProviderMediaConfigMetadataObject = {
+  name: string;
+  description?: string;
+  mediaType?: string;
+  contextType?: string;
+  metas?: any;
+  tags?: any;
+  epgId?: string;
+  recordingId?: string;
+  updatedAt?: number;
+  creatorId?: string;
+  views?: number;
+};

package/src/types/media-config-session.ts

@@ -0,0 +1,6 @@
+export type ProviderMediaConfigSessionObject = {
+  partnerId: number;
+  uiConfId?: number;
+  ks?: string;
+  isAnonymous?: boolean;
+};

package/src/types/media-config-sources.ts

@@ -0,0 +1,20 @@
+import {ImageSource} from '../entities/image-source';
+import {ProviderMediaConfigMetadataObject} from './media-config-metadata';
+import {PKExternalCaptionObject} from './external-caption-object';
+import {ProviderMediaSourceObject} from './media-source';
+
+export type ProviderMediaConfigSourcesObject = {
+  dash: Array<ProviderMediaSourceObject>;
+  hls: Array<ProviderMediaSourceObject>;
+  progressive: Array<ProviderMediaSourceObject>;
+  image: Array<ImageSource>;
+  duration?: number;
+  type: string;
+  id?: string;
+  poster?: string | Array<any>;
+  dvr: boolean;
+  vr?: any;
+  metadata: ProviderMediaConfigMetadataObject;
+  captions?: Array<PKExternalCaptionObject>;
+  downloadUrl?: string;
+};

package/src/types/media-config.ts

@@ -0,0 +1,8 @@
+import {ProviderMediaConfigSessionObject} from './media-config-session';
+import {ProviderMediaConfigSourcesObject} from './media-config-sources';
+
+export type ProviderMediaConfigObject = {
+  session: ProviderMediaConfigSessionObject;
+  sources: ProviderMediaConfigSourcesObject;
+  plugins: {[plugin: string]: any};
+};

package/src/types/media-entry.ts

@@ -0,0 +1,16 @@
+import {ProviderMediaSourcesObject} from './media-sources';
+import {Poster} from './poster';
+
+export type ProviderMediaEntryObject = {
+  id?: string;
+  name?: string;
+  sources: ProviderMediaSourcesObject;
+  duration?: number;
+  dvrStatus?: number;
+  status?: number;
+  metadata: any;
+  type: string;
+  poster?: string | Poster[];
+  downloadUrl?: string;
+  assetReferenceType?: string;
+};

package/src/types/media-format.ts

@@ -0,0 +1,5 @@
+export type ProviderMediaFormatType = {
+  name: string;
+  mimeType: string;
+  pathExt: string;
+};

package/src/types/media-info.ts

@@ -0,0 +1,21 @@
+import {AdapterDataConfig} from './adapter-data-config';
+
+export type OVPProviderMediaInfoObject = {
+  entryId?: string;
+  referenceId?: string;
+  ks?: string;
+};
+
+export type OTTProviderMediaInfoObject = OVPProviderMediaInfoObject & {
+  mediaType: string;
+  contextType: string;
+  protocol?: string;
+  fileIds?: string;
+  streamerType?: string;
+  urlType?: string;
+  adapterData?: AdapterDataConfig;
+  assetReferenceType?: string;
+  formats?: Array<string>;
+};
+
+export type ProviderMediaInfoObject = OVPProviderMediaInfoObject | OTTProviderMediaInfoObject;

package/src/types/media-source.ts

@@ -0,0 +1,12 @@
+import {ProviderDrmDataObject} from './drm-data';
+
+export type ProviderMediaSourceObject = {
+  id: string;
+  url: string;
+  mimetype: string;
+  bandwidth?: number;
+  width?: number;
+  height?: number;
+  label?: string;
+  drmData?: Array<ProviderDrmDataObject>;
+};

package/src/types/media-sources.ts

@@ -0,0 +1,11 @@
+import {ImageSource} from '../entities/image-source';
+import {ProviderMediaSourceObject} from './media-source';
+import {PKExternalCaptionObject} from './external-caption-object';
+
+export type ProviderMediaSourcesObject = {
+  progressive: Array<ProviderMediaSourceObject>;
+  dash: Array<ProviderMediaSourceObject>;
+  hls: Array<ProviderMediaSourceObject>;
+  image: Array<ImageSource>;
+  captions?: Array<PKExternalCaptionObject>;
+};

package/src/types/network-retry-parameters.ts

@@ -0,0 +1,5 @@
+export type ProviderNetworkRetryParameters = {
+  async: boolean;
+  timeout?: number;
+  maxAttempts?: number;
+};

package/src/types/playback-context.ts

@@ -0,0 +1,10 @@
+import {AdapterDataConfig} from './adapter-data-config';
+
+export type ProviderPlaybackContextOptions = {
+  mediaProtocol?: string;
+  assetFileIds?: string;
+  context?: string;
+  streamerType?: string;
+  urlType?: string;
+  adapterData?: AdapterDataConfig;
+};

package/src/types/playlist-info.ts

@@ -0,0 +1,4 @@
+export type ProviderPlaylistInfoObject = {
+  playlistId: string;
+  ks?: string;
+};

package/src/types/playlist-item.ts

@@ -0,0 +1,5 @@
+import {ProviderMediaConfigSourcesObject} from './media-config-sources';
+
+export type ProviderPlaylistItemObject = {
+  sources: ProviderMediaConfigSourcesObject;
+};

package/src/types/playlist-metadata.ts

@@ -0,0 +1,4 @@
+export type ProviderPlaylistMetadataObject = {
+  name: string;
+  description: string;
+};

package/src/types/playlist.ts

@@ -0,0 +1,10 @@
+import {ProviderPlaylistMetadataObject} from './playlist-metadata';
+import {ProviderPlaylistItemObject} from './playlist-item';
+
+export type ProviderPlaylistObject = {
+  id: string;
+  metadata: ProviderPlaylistMetadataObject;
+  poster: string;
+  items: Array<ProviderPlaylistItemObject>;
+  playlistLastEntryId?: string;
+};

package/src/types/poster.ts

@@ -0,0 +1,5 @@
+export interface Poster {
+  width: number;
+  height: number;
+  url: string;
+}

package/src/types/provider-options.ts

@@ -0,0 +1,17 @@
+import {LoggerType} from '../util/logger';
+import {ProviderEnvConfigObject} from './env-config';
+import {ProviderNetworkRetryParameters} from './network-retry-parameters';
+import {ProviderFilterOptionsObject} from './filter-options';
+
+export type ProviderOptionsObject = {
+  partnerId: number;
+  widgetId?: string;
+  logger?: LoggerType;
+  ks?: string;
+  uiConfId?: number;
+  env?: ProviderEnvConfigObject;
+  networkRetryParameters?: ProviderNetworkRetryParameters;
+  filterOptions?: ProviderFilterOptionsObject;
+  ignoreServerConfig?: boolean;
+  loadThumbnailWithKs?: boolean;
+};

package/src/types/request-loader.ts

@@ -0,0 +1,6 @@
+import {ILoader} from './loader';
+
+export type RequestLoader = {
+  loader: ILoader;
+  params: any;
+};

package/src/util/clone.ts

@@ -0,0 +1,23 @@
+const clone = (data): any => {
+  let node;
+  if (Array.isArray(data)) {
+    node = data.length > 0 ? data.slice(0) : [];
+    node.forEach((e, i) => {
+      if ((typeof e === 'object') || (Array.isArray(e) && e.length > 0)) {
+        node[i] = clone(e);
+      }
+    });
+  } else if (typeof data === 'object') {
+    node = Object.assign({}, data);
+    Object.keys(node).forEach(key => {
+      if ((typeof node[key] === 'object') || (Array.isArray(node[key]) && node[key].length > 0)) {
+        node[key] = clone(node[key]);
+      }
+    });
+  } else {
+    node = data;
+  }
+  return node;
+};
+
+export {clone};

package/src/util/error/category.ts

@@ -0,0 +1,11 @@
+type CategoryType = {[category: string]: number};
+
+const Category: CategoryType = {
+  /** Errors from the network stack. */
+  NETWORK: 1,
+  SERVICE: 2,
+  PROVIDER: 3
+};
+
+export {Category};
+export type {CategoryType};

package/src/util/error/code.ts

@@ -0,0 +1,77 @@
+type CodeType = {[code: string]: number};
+
+const Code: CodeType = {
+  /**
+   * A network request was made using an unsupported URI scheme.
+   */
+  UNSUPPORTED_SCHEME: 1000,
+
+  /**
+   * An HTTP network request returned an HTTP status that indicated a failure.
+   */
+  BAD_HTTP_STATUS: 1001,
+
+  /**
+   * An HTTP network request failed with an error, but not from the server.
+   */
+  HTTP_ERROR: 1002,
+
+  /**
+   * A network request timed out.
+   */
+  TIMEOUT: 1003,
+
+  /**
+   * A network request was made with a malformed data URI.
+   */
+  MALFORMED_DATA_URI: 1004,
+
+  /**
+   * The server responsded with 2xx response, but it couldn't be parsed
+   */
+  BAD_SERVER_RESPONSE: 1005,
+
+  /**
+   * The server response had a valid structure but contained an error from the API
+   */
+  MULTIREQUEST_API_ERROR: 1006,
+
+  /**
+   * The server response had a valid structure and valid API result, but it did not match the request
+   */
+  API_RESPONSE_MISMATCH: 1007,
+
+  /**
+   * The server responded with an error
+   */
+  ERROR: 2000,
+
+  /**
+   * The server responded with a block action
+   */
+  BLOCK_ACTION: 2001,
+
+  /**
+   * The server responded with status import or pre convert
+   */
+  MEDIA_STATUS_NOT_READY: 2002,
+
+  /**
+   * The provider is missing mandatory parameter/s
+   */
+
+  MISSING_MANDATORY_PARAMS: 3000,
+
+  /**
+   * The server responded with empty sources objects (for HLS, Dash and progressive)
+   */
+  MISSING_PLAY_SOURCE: 3001,
+
+  /**
+   * The provider doesn't implement the called api
+   */
+  METHOD_NOT_IMPLEMENTED: 3002
+};
+
+export {Code};
+export type {CodeType};

package/src/util/error/error.ts

@@ -0,0 +1,47 @@
+import getLogger from '../logger';
+import {Severity} from './severity';
+import type {SeverityType} from './severity';
+import {Code} from './code';
+import type {CodeType} from './code';
+import {Category} from './category';
+import type {CategoryType} from './category';
+
+const CLASS_NAME: string = 'Error';
+
+/**
+ * @classdesc This is a description of the error class.
+ */
+export default class Error {
+  public severity: number;
+  public category: number;
+  public code: number;
+  public data: any;
+  /**
+   * @enum {number}
+   */
+  public static Severity: SeverityType = Severity;
+  /**
+   * @enum {number}
+   */
+  public static Category: CategoryType = Category;
+  /**
+   * @enum {number}
+   */
+  public static Code: CodeType = Code;
+  private static _logger: any = getLogger(CLASS_NAME);
+
+  /**
+   * @constructor
+   * @param {number} severity - error's severity
+   * @param {number} category - error's category.
+   * @param {number} code - error's code.
+   * @param {any} data - additional data for the error.
+   */
+  constructor(severity: number, category: number, code: number, data: any = {}) {
+    this.severity = severity;
+    this.category = category;
+    this.code = code;
+    this.data = data;
+    Error._logger.error(`Category:${category} | Code:${code} |`, data);
+  }
+}

package/src/util/error/severity.ts

@@ -0,0 +1,21 @@
+type SeverityType = {[severity: string]: number};
+
+const Severity: SeverityType = {
+  /**
+   * An error occurred, but the Player is attempting to recover from the error.
+   *
+   * If the Player cannot ultimately recover, it still may not throw a CRITICAL
+   * error.  For example, retrying for a media segment will never result in
+   * a CRITICAL error (the Player will just retry forever).
+   */
+  RECOVERABLE: 1,
+  /**
+   * A critical error that the library cannot recover from.  These usually cause
+   * the Player to stop loading or updating.  A new manifest must be loaded
+   * to reset the library.
+   */
+  CRITICAL: 2
+};
+
+export {Severity};
+export type {SeverityType};

package/src/util/logger.ts

@@ -0,0 +1,108 @@
+export type LogLevelObject = {value: number, name: string};
+export type LogLevelType = {[level: string]: LogLevelObject};
+export type loggerFunctionType = {
+  VERSION: string,
+  DEBUG: LogLevelObject,
+  ERROR: LogLevelObject,
+  INFO: LogLevelObject,
+  OFF: LogLevelObject,
+  TIME: LogLevelObject,
+  TRACE: LogLevelObject,
+  WARN: LogLevelObject,
+  createDefaultHandler: () => any
+  debug: () => any
+  enabledFor: () => any
+  error: () => any
+  get: () => any
+  getLevel: () => any
+  info: () => any
+  log: () => any
+  setHandler: () => any
+  setLevel: () => any
+  time: () => any
+  timeEnd: () => any
+  trace: () => any
+  useDefaults: () => any
+  warn: () => any
+};
+
+type LoggerType = {
+  getLogger: loggerFunctionType,
+  LogLevel: LogLevelType
+};
+
+const JsLogger = {
+  get: (): any => ({
+    VERSION: '',
+    DEBUG: {value: '', name: ''},
+    ERROR: {value: '', name: ''},
+    INFO: {value: '', name: ''},
+    OFF: {value: '', name: ''},
+    TIME: {value: '', name: ''},
+    TRACE: {value: '', name: ''},
+    WARN: {value: '', name: ''},
+    createDefaultHandler: (): any => {},
+    debug: (): any => {},
+    enabledFor: (): any => {},
+    error: (): any => {},
+    get: (): any => {},
+    getLevel: (): any => {},
+    info: (): any => {},
+    log: (): any => {},
+    setHandler: (): any => {},
+    setLevel: (): any => {},
+    time: (): any => {},
+    timeEnd: (): any => {},
+    trace: (): any => {},
+    useDefaults: (): any => {},
+    warn: (): any => {}
+  })
+};
+
+let LogLevel: LogLevelType = {};
+/**
+ * set logger
+ * @param {LoggerType} logger - the logger
+ * @returns {void}
+ */
+function setLogger(logger?: LoggerType): void {
+  if (logger && typeof logger.getLogger === 'function') {
+    JsLogger.get = logger.getLogger;
+  }
+  if (logger && logger.LogLevel) {
+    LogLevel = logger.LogLevel;
+  }
+}
+
+/**
+ * get a logger
+ * @param {?string} name - the logger name
+ * @returns {Object} - the logger class
+ */
+function getLogger(name?: string): any {
+  // eslint-disable-next-line  @typescript-eslint/ban-ts-comment
+  //@ts-ignore
+  return JsLogger.get(name);
+}
+
+/**
+ * get the log level
+ * @param {?string} name - the logger name
+ * @returns {LogLevelObject} - the log level
+ */
+function getLogLevel(name?: string): LogLevelObject {
+  return getLogger(name).getLevel();
+}
+
+/**
+ * sets the logger level
+ * @param {LogLevelObject} level - the log level
+ * @param {?string} name - the logger name
+ * @returns {void}
+ */
+function setLogLevel(level: LogLevelObject, name?: string): void {
+  getLogger(name).setLevel(level);
+}
+
+export default getLogger;
+export {getLogLevel, setLogLevel, setLogger, LogLevel, LoggerType};

package/src/util/param.ts

@@ -0,0 +1,45 @@
+const param = (a): any => {
+  const s: string[] = [],
+    rbracket = /\[\]$/,
+    isArray = function (obj): boolean {
+      return Object.prototype.toString.call(obj) === '[object Array]';
+    },
+    add = function (k, v): any {
+      v = typeof v === 'function' ? v() : v === null ? '' : v === undefined ? '' : v;
+      s[s.length] = encodeURIComponent(k) + '=' + encodeURIComponent(v);
+    },
+    buildParams = function (prefix, obj): any {
+      let i, len, key;
+
+      if (prefix) {
+        if (isArray(obj)) {
+          for (i = 0, len = obj.length; i < len; i++) {
+            if (rbracket.test(prefix)) {
+              add(prefix, obj[i]);
+            } else {
+              buildParams(prefix + ':' + (typeof obj[i] === 'object' ? i : ''), obj[i]);
+            }
+          }
+        } else if (obj && String(obj) === '[object Object]') {
+          for (key in obj) {
+            buildParams(prefix + ':' + key, obj[key]);
+          }
+        } else {
+          add(prefix, obj);
+        }
+      } else if (isArray(obj)) {
+        for (i = 0, len = obj.length; i < len; i++) {
+          add(obj[i].name, obj[i].value);
+        }
+      } else {
+        for (key in obj) {
+          buildParams(key, obj[key]);
+        }
+      }
+      return s;
+    };
+
+  return buildParams('', a).join('&').replace(/%20/g, '+');
+};
+
+export {param};