@clickview/player 0.0.26-dev.0 → 0.0.26

package/dist/libs/analytics/src/utils/UserAgentHelper.d.ts

@@ -1,10 +1,10 @@
-import { VersionData } from 'libs/analytics/interfaces/VersionData';
-/**
- * Test order is important for all UARegex tests. Reordering them will break functionality.
- */
-export declare const UserAgentHelper: {
-    getDeviceType(): string;
-    getOperatingSystem(): VersionData;
-    getBrowser(): VersionData;
-    isTouchScreen(): boolean;
-};
+import { VersionData } from 'libs/analytics/interfaces/VersionData';
+/**
+ * Test order is important for all UARegex tests. Reordering them will break functionality.
+ */
+export declare const UserAgentHelper: {
+    getDeviceType(): string;
+    getOperatingSystem(): VersionData;
+    getBrowser(): VersionData;
+    isTouchScreen(): boolean;
+};

package/dist/libs/common/src/backbone/constants/CommonChannels.d.ts

@@ -1,5 +1,5 @@
-export declare const CommonChannels: {
-    SHELL: string;
-    ALERT: string;
-    POPUP: string;
-};
+export declare const CommonChannels: {
+    SHELL: string;
+    ALERT: string;
+    POPUP: string;
+};

package/dist/libs/common/src/backbone/constants/CommonServices.d.ts

@@ -1,4 +1,4 @@
-export declare const CommonServices: {
-    ALERT: string;
-    LANGUAGE: string;
-};
+export declare const CommonServices: {
+    ALERT: string;
+    LANGUAGE: string;
+};

package/dist/libs/common/src/backbone/core/AppLink.d.ts

@@ -1,37 +1,37 @@
-import { ObjectHash } from 'backbone';
-export interface AppLink {
-    application: string;
-    action: string;
-    args?: (string | number)[];
-    params?: string | ObjectHash;
-}
-export interface AppLinkHash {
-    [selector: string]: AppLink;
-}
-export interface AppLinkOptions {
-    replace?: boolean;
-}
-export declare const AppLinkUtility: {
-    routingStarted(): void;
-    routingEnded(): void;
-    hasActiveRoute(): boolean;
-};
-export declare const AppLinkHelper: {
-    /**
-     * Build a href string from an AppLink object
-     * @param appLink
-     */
-    getHref(appLink: AppLink): string;
-    /**
-     * This is the reverse process of extracting params out of a route.
-     * (e.g. Will take the route '/videos/:id' and an array of args = [123]
-     *  and return '/videos/123')
-     */
-    buildRoute(route: string, appLink: AppLink): string;
-    /**
-     * Manually trigger an AppLink
-     * @param appLink
-     */
-    trigger(appLink: AppLink, options?: AppLinkOptions): void;
-    getCurrentAppLink(): AppLink;
-};
+import { ObjectHash } from 'backbone';
+export interface AppLink {
+    application: string;
+    action: string;
+    args?: (string | number)[];
+    params?: string | ObjectHash;
+}
+export interface AppLinkHash {
+    [selector: string]: AppLink;
+}
+export interface AppLinkOptions {
+    replace?: boolean;
+}
+export declare const AppLinkUtility: {
+    routingStarted(): void;
+    routingEnded(): void;
+    hasActiveRoute(): boolean;
+};
+export declare const AppLinkHelper: {
+    /**
+     * Build a href string from an AppLink object
+     * @param appLink
+     */
+    getHref(appLink: AppLink): string;
+    /**
+     * This is the reverse process of extracting params out of a route.
+     * (e.g. Will take the route '/videos/:id' and an array of args = [123]
+     *  and return '/videos/123')
+     */
+    buildRoute(route: string, appLink: AppLink): string;
+    /**
+     * Manually trigger an AppLink
+     * @param appLink
+     */
+    trigger(appLink: AppLink, options?: AppLinkOptions): void;
+    getCurrentAppLink(): AppLink;
+};

package/dist/libs/common/src/backbone/core/BaseAppRouter.d.ts

@@ -1,104 +1,104 @@
-/// <reference types="backbone" />
-import * as Marionette from 'backbone.marionette';
-import { Shell } from './Shell';
-import { BaseApplication, BaseApplicationOptions } from './BaseApplication';
-import { AppLink } from './AppLink';
-import { MiddlewareFunction } from './Middleware';
-export interface ExecuteRouteOptions {
-    isAppRoute: boolean;
-}
-export interface FilterOptions {
-    appLink: AppLink;
-    shell: Shell;
-}
-/**
- * This should only ever be used by the shell
- * creating a new instance of the AppRoute
- */
-export interface BaseAppRouterOptions extends Marionette.AppRouterOptions {
-    appConstructor: typeof BaseApplication;
-    /**
-     * These will be passed into the appConstructor
-     * when creating an instance of the Application
-     */
-    appOptions?: BaseApplicationOptions;
-    shell: Shell;
-}
-/**
- * Every Application must have an AppRouter
- */
-export declare class BaseAppRouter extends Marionette.AppRouter {
-    /**
-     * A hash of urls to method names on the Application.
-     * Exactly the same implementation as Backbone Router routes
-     * except the methods exist on the Application.
-     * See http://backbonejs.org/#Router-routes
-     */
-    protected appRoutes?: Marionette.AppRoutes;
-    protected appLinks?: string[];
-    protected externalRoutes?: Marionette.AppRoutes;
-    /**
-     * The channelName used to trigger the appLinks
-     * on backbone.radio. This will match the Application's
-     * channelName.
-     */
-    protected channelName?: string;
-    /**
-     * These are async middleware functions that are run
-     * before any route on this router is executed.
-     *
-     * They can be used to prevent access to a router using
-     * asyncronous code.
-     */
-    protected filters: MiddlewareFunction<FilterOptions>[];
-    /**
-     * See BaseAppRouterOptions above.
-     */
-    protected options?: BaseAppRouterOptions;
-    constructor(options?: BaseAppRouterOptions);
-    private bindDisposal;
-    private addRouteLookup;
-    /**
-     * Creates all the reverse route lookups
-     * and binds all the appLinks to the radio channel
-     */
-    private processInternalRoutes;
-    private triggerNavLocked;
-    private processExternalRoutes;
-    private processAppLinks;
-    /**
-     * This is the heart of the AppRouter. Every single route both page loads
-     * and appLinks will go through this method.
-     *
-     * This will return false if onBeforeAction returns false
-     * and the window history will not be altered.
-     */
-    private executeRoute;
-    /**
-     * Instantiates and starts the application if there was
-     * not already an instance.
-     *
-     * Why is the application stores on this.controller?
-     * In Marionette AppRouters hold reference to a controller
-     * which in turn is responsibile for maintaining reference to an application.
-     * We've restructured this architecture so that AppRouters directly hold
-     * the instance of the Application, but are still leveraging Marionette's
-     * use of appRoutes on the controller.
-     */
-    private createApp;
-    private destroyApp;
-    /**
-     * Overriding Marionette.AppRouter's _addAppRoute so that
-     * execute route is called instead of the method directly.
-     *
-     * We do this so that executeRoute can be called for every single
-     * route, whether it's a page load or an appLink. This will make it easier
-     * to modify the action
-     */
-    private _addAppRoute;
-    private toEventName;
-    private toMethodName;
-    private validateAppLink;
-    listenTo(object: any, eventMap: Backbone.EventMap): this;
-    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
-}
+/// <reference types="backbone" />
+import * as Marionette from 'backbone.marionette';
+import { Shell } from './Shell';
+import { BaseApplication, BaseApplicationOptions } from './BaseApplication';
+import { AppLink } from './AppLink';
+import { MiddlewareFunction } from './Middleware';
+export interface ExecuteRouteOptions {
+    isAppRoute: boolean;
+}
+export interface FilterOptions {
+    appLink: AppLink;
+    shell: Shell;
+}
+/**
+ * This should only ever be used by the shell
+ * creating a new instance of the AppRoute
+ */
+export interface BaseAppRouterOptions extends Marionette.AppRouterOptions {
+    appConstructor: typeof BaseApplication;
+    /**
+     * These will be passed into the appConstructor
+     * when creating an instance of the Application
+     */
+    appOptions?: BaseApplicationOptions;
+    shell: Shell;
+}
+/**
+ * Every Application must have an AppRouter
+ */
+export declare class BaseAppRouter extends Marionette.AppRouter {
+    /**
+     * A hash of urls to method names on the Application.
+     * Exactly the same implementation as Backbone Router routes
+     * except the methods exist on the Application.
+     * See http://backbonejs.org/#Router-routes
+     */
+    protected appRoutes?: Marionette.AppRoutes;
+    protected appLinks?: string[];
+    protected externalRoutes?: Marionette.AppRoutes;
+    /**
+     * The channelName used to trigger the appLinks
+     * on backbone.radio. This will match the Application's
+     * channelName.
+     */
+    protected channelName?: string;
+    /**
+     * These are async middleware functions that are run
+     * before any route on this router is executed.
+     *
+     * They can be used to prevent access to a router using
+     * asyncronous code.
+     */
+    protected filters: MiddlewareFunction<FilterOptions>[];
+    /**
+     * See BaseAppRouterOptions above.
+     */
+    protected options?: BaseAppRouterOptions;
+    constructor(options?: BaseAppRouterOptions);
+    private bindDisposal;
+    private addRouteLookup;
+    /**
+     * Creates all the reverse route lookups
+     * and binds all the appLinks to the radio channel
+     */
+    private processInternalRoutes;
+    private triggerNavLocked;
+    private processExternalRoutes;
+    private processAppLinks;
+    /**
+     * This is the heart of the AppRouter. Every single route both page loads
+     * and appLinks will go through this method.
+     *
+     * This will return false if onBeforeAction returns false
+     * and the window history will not be altered.
+     */
+    private executeRoute;
+    /**
+     * Instantiates and starts the application if there was
+     * not already an instance.
+     *
+     * Why is the application stores on this.controller?
+     * In Marionette AppRouters hold reference to a controller
+     * which in turn is responsibile for maintaining reference to an application.
+     * We've restructured this architecture so that AppRouters directly hold
+     * the instance of the Application, but are still leveraging Marionette's
+     * use of appRoutes on the controller.
+     */
+    private createApp;
+    private destroyApp;
+    /**
+     * Overriding Marionette.AppRouter's _addAppRoute so that
+     * execute route is called instead of the method directly.
+     *
+     * We do this so that executeRoute can be called for every single
+     * route, whether it's a page load or an appLink. This will make it easier
+     * to modify the action
+     */
+    private _addAppRoute;
+    private toEventName;
+    private toMethodName;
+    private validateAppLink;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
+}

package/dist/libs/common/src/backbone/core/BaseApplication.d.ts

@@ -1,76 +1,76 @@
-import { ObjectHash } from 'backbone';
-import * as Marionette from 'backbone.marionette';
-import { Shell } from './Shell';
-import { BaseLayoutView, BaseLayoutViewOptions } from './BaseLayoutView';
-import { LayoutService, LayoutOptions } from './LayoutService';
-import { BaseAppRouter } from './BaseAppRouter';
-export interface BaseApplicationOptions extends Marionette.ApplicationOptions {
-    shell: Shell;
-    layoutService: LayoutService;
-    channelName?: string;
-}
-export declare class BaseApplication extends Marionette.Application {
-    /**
-     * Layout service is used to retreive the layout on each route
-     */
-    private layoutService;
-    /**
-     * The layout that should be used to render all content into the DOM
-     */
-    protected layout?: BaseLayoutView;
-    /**
-     * This is specified by all children of Core.Application
-     * to determine which layout to load in from layout service,
-     * and what options to instantiate it with.
-     */
-    protected layoutOptions: LayoutOptions<BaseLayoutViewOptions>;
-    /**
-     * A reference to the shell is always kept as a
-     * way to both render the layout into the dom
-     * and keep reference to global services
-     */
-    protected shell: Shell;
-    /**
-     * An instance of the Core.AppRouter is created
-     * for each Application in order to listen to applink
-     * events. The application instance is only then instantiated
-     * when the Application route is hit
-     */
-    static router: typeof BaseAppRouter;
-    /**
-     * Provides the ability to define useful error messages.
-     */
-    name: string;
-    /** When overridden determines which options are
-     * mixed into the instance */
-    props: string[];
-    /**
-     * Used by application actions to set default options.
-     */
-    private defaultQueryParams;
-    /**
-     * Shell and layoutService will be mixed into each instance
-     * of Core.Applicataion
-     */
-    get defaultProps(): string[];
-    /**
-     * The constructor will merge in props and ensure any required properties
-     * are defined
-     * @constructor
-     */
-    constructor(options?: BaseApplicationOptions);
-    private getGlobalRadioChannel;
-    /**
-     * This method is triggered by Core.AppRouter when it loads
-     * in a route for this application. It will swap in the appropriate
-     * layout before hitting the application's action.
-     *
-     */
-    private onLoadLayout;
-    private onShowPopup;
-    protected onShowAlert(options: ObjectHash): void;
-    protected setDefaultQueryParams(params: ObjectHash): void;
-    getAndClearDefaultQueryParams(): ObjectHash;
-    listenTo(object: any, eventMap: Backbone.EventMap): this;
-    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
-}
+import { ObjectHash } from 'backbone';
+import * as Marionette from 'backbone.marionette';
+import { Shell } from './Shell';
+import { BaseLayoutView, BaseLayoutViewOptions } from './BaseLayoutView';
+import { LayoutService, LayoutOptions } from './LayoutService';
+import { BaseAppRouter } from './BaseAppRouter';
+export interface BaseApplicationOptions extends Marionette.ApplicationOptions {
+    shell: Shell;
+    layoutService: LayoutService;
+    channelName?: string;
+}
+export declare class BaseApplication extends Marionette.Application {
+    /**
+     * Layout service is used to retreive the layout on each route
+     */
+    private layoutService;
+    /**
+     * The layout that should be used to render all content into the DOM
+     */
+    protected layout?: BaseLayoutView;
+    /**
+     * This is specified by all children of Core.Application
+     * to determine which layout to load in from layout service,
+     * and what options to instantiate it with.
+     */
+    protected layoutOptions: LayoutOptions<BaseLayoutViewOptions>;
+    /**
+     * A reference to the shell is always kept as a
+     * way to both render the layout into the dom
+     * and keep reference to global services
+     */
+    protected shell: Shell;
+    /**
+     * An instance of the Core.AppRouter is created
+     * for each Application in order to listen to applink
+     * events. The application instance is only then instantiated
+     * when the Application route is hit
+     */
+    static router: typeof BaseAppRouter;
+    /**
+     * Provides the ability to define useful error messages.
+     */
+    name: string;
+    /** When overridden determines which options are
+     * mixed into the instance */
+    props: string[];
+    /**
+     * Used by application actions to set default options.
+     */
+    private defaultQueryParams;
+    /**
+     * Shell and layoutService will be mixed into each instance
+     * of Core.Applicataion
+     */
+    get defaultProps(): string[];
+    /**
+     * The constructor will merge in props and ensure any required properties
+     * are defined
+     * @constructor
+     */
+    constructor(options?: BaseApplicationOptions);
+    private getGlobalRadioChannel;
+    /**
+     * This method is triggered by Core.AppRouter when it loads
+     * in a route for this application. It will swap in the appropriate
+     * layout before hitting the application's action.
+     *
+     */
+    private onLoadLayout;
+    private onShowPopup;
+    protected onShowAlert(options: ObjectHash): void;
+    protected setDefaultQueryParams(params: ObjectHash): void;
+    getAndClearDefaultQueryParams(): ObjectHash;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
+}

package/dist/libs/common/src/backbone/core/BaseBehavior.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="backbone" />
-import * as Marionette from 'backbone.marionette';
-export declare class BaseBehavior extends Marionette.Behavior {
-    listenTo(object: any, eventMap: Backbone.EventMap): this;
-    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
-}
+/// <reference types="backbone" />
+import * as Marionette from 'backbone.marionette';
+export declare class BaseBehavior extends Marionette.Behavior {
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
+}

package/dist/libs/common/src/backbone/core/BaseCollection.d.ts

@@ -1,7 +1,7 @@
-import * as Backbone from 'backbone';
-import { BaseModel } from './BaseModel';
-export declare class BaseCollection<TModel extends BaseModel = BaseModel> extends Backbone.Collection<TModel> {
-    parent?: BaseModel | BaseCollection;
-    listenTo(object: any, eventMap: Backbone.EventMap): this;
-    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
-}
+import * as Backbone from 'backbone';
+import { BaseModel } from './BaseModel';
+export declare class BaseCollection<TModel extends BaseModel = BaseModel> extends Backbone.Collection<TModel> {
+    parent?: BaseModel | BaseCollection;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
+}

package/dist/libs/common/src/backbone/core/BaseCollectionView.d.ts

@@ -1,16 +1,16 @@
-/// <reference types="backbone" />
-import * as Marionette from 'backbone.marionette';
-import { BaseCollection } from './BaseCollection';
-import { CoreView } from './BaseView';
-import { BaseModel } from './BaseModel';
-export interface BaseCollectionViewOptions<TModel extends BaseModel = BaseModel> extends Marionette.CollectionViewOptions<TModel> {
-    channelName?: string;
-}
-export declare class BaseCollectionView<TModel extends BaseModel = BaseModel, TView extends CoreView<TModel> = CoreView<TModel>, TCollection extends BaseCollection<TModel> = BaseCollection<TModel>> extends Marionette.CollectionView<TModel, TView, TCollection> {
-    protected options: BaseCollectionViewOptions<TModel>;
-    constructor(options?: BaseCollectionViewOptions<TModel>);
-    serializeModel(): any;
-    serializeCollection(): any[];
-    listenTo(object: any, eventMap: Backbone.EventMap): this;
-    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
-}
+/// <reference types="backbone" />
+import * as Marionette from 'backbone.marionette';
+import { BaseCollection } from './BaseCollection';
+import { CoreView } from './BaseView';
+import { BaseModel } from './BaseModel';
+export interface BaseCollectionViewOptions<TModel extends BaseModel = BaseModel> extends Marionette.CollectionViewOptions<TModel> {
+    channelName?: string;
+}
+export declare class BaseCollectionView<TModel extends BaseModel = BaseModel, TView extends CoreView<TModel> = CoreView<TModel>, TCollection extends BaseCollection<TModel> = BaseCollection<TModel>> extends Marionette.CollectionView<TModel, TView, TCollection> {
+    protected options: BaseCollectionViewOptions<TModel>;
+    constructor(options?: BaseCollectionViewOptions<TModel>);
+    serializeModel(): any;
+    serializeCollection(): any[];
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
+}

package/dist/libs/common/src/backbone/core/BaseError.d.ts

@@ -1,28 +1,28 @@
-import { HttpStatus } from 'libs/common/backbone/enums/HttpStatus';
-export declare class BaseError extends Error {
-    name: string;
-    constructor(message: string);
-}
-/**
- * You can use these if you want to leverage the convenience
- * of the error set up without actually throwing the error
- */
-export declare abstract class SilentError extends BaseError {
-    get name(): string;
-}
-export declare class CoreError extends Error {
-    get name(): string;
-}
-declare const ErrorHelper: {
-    throw(error: BaseError): void;
-    /**
-     * Will throw the error after a timeout, ignoring all other errors using the same
-     * key thrown within the allocated timeout window
-     *
-     * Note: ATM this is only used for our OldVersionError and can most likely be
-     * removed when we come up with a more elegant solution to that problem - Sha
-     */
-    delayedThrow(key: string, error: BaseError, timeout: number): void;
-    isStatusCodeError(statusCode: HttpStatus): boolean;
-};
-export { ErrorHelper };
+import { HttpStatus } from 'libs/common/backbone/enums/HttpStatus';
+export declare class BaseError extends Error {
+    name: string;
+    constructor(message: string);
+}
+/**
+ * You can use these if you want to leverage the convenience
+ * of the error set up without actually throwing the error
+ */
+export declare abstract class SilentError extends BaseError {
+    get name(): string;
+}
+export declare class CoreError extends Error {
+    get name(): string;
+}
+declare const ErrorHelper: {
+    throw(error: BaseError): void;
+    /**
+     * Will throw the error after a timeout, ignoring all other errors using the same
+     * key thrown within the allocated timeout window
+     *
+     * Note: ATM this is only used for our OldVersionError and can most likely be
+     * removed when we come up with a more elegant solution to that problem - Sha
+     */
+    delayedThrow(key: string, error: BaseError, timeout: number): void;
+    isStatusCodeError(statusCode: HttpStatus): boolean;
+};
+export { ErrorHelper };

package/dist/libs/common/src/backbone/core/BaseLayoutView.d.ts

@@ -1,11 +1,11 @@
-import { BaseView, BaseViewOptions } from './BaseView';
-import { Store } from 'redux';
-export interface BaseLayoutViewOptions extends BaseViewOptions {
-    store?: Store;
-}
-export declare class BaseLayoutView extends BaseView {
-    protected options: BaseLayoutViewOptions;
-    constructor(options: BaseLayoutViewOptions);
-    static getCacheKey(options?: BaseLayoutViewOptions): string;
-    unmountRegion(regionName: string): void;
-}
+import { BaseView, BaseViewOptions } from './BaseView';
+import { Store } from 'redux';
+export interface BaseLayoutViewOptions extends BaseViewOptions {
+    store?: Store;
+}
+export declare class BaseLayoutView extends BaseView {
+    protected options: BaseLayoutViewOptions;
+    constructor(options: BaseLayoutViewOptions);
+    static getCacheKey(options?: BaseLayoutViewOptions): string;
+    unmountRegion(regionName: string): void;
+}