@clickview/player 0.0.26 → 0.0.27-rc.1

package/dist/libs/analytics/src/interfaces/index.d.ts

@@ -1,15 +0,0 @@
-export * from './AnalyticsTypes';
-export * from './AnalyticsUser';
-export * from './Config';
-export * from './Owner';
-export * from './Folder';
-export * from './HashObject';
-export * from './Playlist';
-export * from './Resource';
-export * from './Rating';
-export * from './Region';
-export * from './RegionalUrl';
-export * from './Series';
-export * from './Subtitle';
-export * from './Video';
-export * from './primitives/BaseObject';

package/dist/libs/analytics/src/interfaces/primitives/BaseObject.d.ts

@@ -1,7 +0,0 @@
-export interface BaseObject {
-    id?: string;
-    name?: string;
-    dateCreated?: string;
-    dateModified?: string;
-    dateAssociated?: string;
-}

package/dist/libs/analytics/src/models/AnalyticsEvent.d.ts

@@ -1,49 +0,0 @@
-import { ObjectHash } from 'backbone';
-import { AnalyticsEventType, ActionContext } from 'libs/analytics/interfaces';
-import { EventVersion } from 'libs/analytics/interfaces';
-interface Enrichment {
-    [prop: string]: string;
-}
-export interface DataObjectPayload extends ObjectHash {
-}
-export interface DataCollectionPayload extends Array<ObjectHash> {
-}
-export declare type AnalyticsDataPayload = DataObjectPayload | DataCollectionPayload;
-/**
- * Base AnalyticsEvent Object.
- * Acts as a wrapper for our events, encapsulating the event type
- * and a data payload.
- */
-export declare class AnalyticsEvent<TType extends AnalyticsEventType, TPayload extends AnalyticsDataPayload> {
-    type: TType;
-    data: TPayload;
-    actionContext: ActionContext;
-    eventVersion: EventVersion;
-    constructor(type: TType, data: TPayload, actionContext?: ActionContext, eventVersion?: EventVersion);
-    /**
-     * Utility function that allows us to create type guards.
-     * @param type EventType
-     */
-    isType(type: TType): this is TType;
-    /**
-     * Mix different enrichments into the base AnalyticsEvent object
-     * to keep it as flat as possible.
-     *
-     * @param key Top level enrichment name
-     * @param value Either a string or set of KV Pairs
-     */
-    enrich(key: string, value: string | Enrichment): void;
-    get(key: string): string | Enrichment;
-    /**
-     * Check that the incoming enrichment doesn't clash with
-     * a pre-existing enrichement.
-     *
-     * @param key
-     */
-    private validateKey;
-}
-/**
- * Alias our analytics type to make our function signatures and typings a little cleaner
- */
-export declare type CoreAnalyticsType = AnalyticsEvent<AnalyticsEventType, AnalyticsDataPayload>;
-export {};

package/dist/libs/analytics/src/models/CollectionEvent.d.ts

@@ -1,61 +0,0 @@
-import { HashObject } from 'libs/analytics/interfaces/HashObject';
-import { VersionData } from 'libs/analytics/interfaces/VersionData';
-import { UserAction, EventVersion, ActionContext } from 'libs/analytics/interfaces/AnalyticsTypes';
-import { Region } from 'libs/analytics/interfaces/Region';
-import { CountryCode } from 'libs/analytics/enums/CountryCode';
-export interface IncomingEvent {
-    type: CollectionEventType;
-    data: HashObject;
-    actionContext: ActionContext;
-    eventVersion: EventVersion;
-}
-export interface RequestData {
-    url: string;
-    referrer: string;
-}
-export interface PlatformData {
-    browser: VersionData;
-    os: VersionData;
-    request: RequestData;
-    screenResolution: string;
-}
-export interface CollectionEventUserData {
-    id: string;
-    role: string;
-    userGroup: string;
-    yearGroup: string;
-    customer: {
-        id: string;
-        name: string;
-        country: CountryCode;
-        region: Region;
-        customerGuid: string;
-        crmId: string;
-        openCustomer: boolean;
-    };
-}
-export interface CollectionEventData {
-    [entity: string]: HashObject;
-    action: HashObject;
-    user: CollectionEventUserData;
-    platform: PlatformData;
-    product: VersionData;
-}
-export interface CollectionEventMetadata {
-    timestamp: string;
-    client: {
-        name: string;
-        version: string;
-        region: Region;
-    };
-    eventVersion: EventVersion;
-}
-export declare type CollectionEventType = UserAction;
-/**
- * Model to be sent to CollectionApi.
- */
-export interface CollectionEvent {
-    type: CollectionEventType;
-    data: CollectionEventData;
-    metadata: CollectionEventMetadata;
-}

package/dist/libs/analytics/src/services/ContextService.d.ts

@@ -1,19 +0,0 @@
-import { Core } from 'libs/common/core';
-interface ApplicationContext {
-    pageLoad: boolean;
-    appLink: Core.AppLink;
-}
-export interface AppContextServiceOptions {
-}
-export declare class StaticContextService extends Core.Service {
-    private static instance;
-    private contextHistory;
-    get name(): string;
-    static get Instance(): StaticContextService;
-    initialize(): void;
-    private setContext;
-    getCurrentContext(): ApplicationContext;
-    fromPageLoad(): boolean;
-}
-export declare const ContextService: StaticContextService;
-export {};

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

@@ -1,6 +0,0 @@
-import { IncomingEvent } from 'libs/analytics/models/CollectionEvent';
-import { HashObject } from 'libs/analytics/interfaces';
-export declare const CollectionApiClientHelper: {
-    shouldLog(event: IncomingEvent): boolean;
-    formatData(event: IncomingEvent): HashObject | HashObject[];
-};

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

@@ -1,14 +0,0 @@
-import { CoreAnalyticsType } from 'libs/analytics/models/AnalyticsEvent';
-import { HashObject } from 'libs/analytics/interfaces';
-declare type DataFormatter = (data: HashObject, event: CoreAnalyticsType) => HashObject;
-export interface DataFormatterHash {
-    [eventType: string]: DataFormatter;
-}
-export declare const DataFormatHelper: {
-    /**
-     * Object will be logged to sink as is
-     */
-    passthrough(data: HashObject): HashObject;
-    getEditData(data: HashObject, event: CoreAnalyticsType): HashObject;
-};
-export {};

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

@@ -1,19 +0,0 @@
-import { CoreAnalyticsType } from 'libs/analytics/models/AnalyticsEvent';
-/**
- * Manage which events we want to log
- *
- * @description
- * All events have a UserAction type, however, that same type can be used to represent
- * different types of actions. For example, `UserAction.Rename` is used for events involving
- * the renaming of folders, libraries and videos (from different parts of the product).
- *
- * So if a situation arises where we only want to collect events for a certain entity or from a
- * certain part of the product. We can add a custom callback below and filter based on the event's actionContext.
- */
-export declare const EventWhitelistHelper: {
-    allow: () => boolean;
-    restrict: () => boolean;
-};
-export interface EventWhitelistHash {
-    [eventType: string]: (event: CoreAnalyticsType) => boolean;
-}

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

@@ -1,4 +0,0 @@
-import { HashObject } from 'libs/analytics/interfaces';
-export declare const ShareFormatHelper: {
-    getShareData(data: HashObject): HashObject;
-};

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

@@ -1,4 +0,0 @@
-export declare const TypeHelper: {
-    isObject(obj: any): boolean;
-    isFunction(fn: (...args: any[]) => any): boolean;
-};

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

@@ -1,10 +0,0 @@
-import { HashObject, Subtitle, Resource } from 'libs/analytics/interfaces';
-import { CoreAnalyticsType } from 'libs/analytics/models/AnalyticsEvent';
-export declare const UploadDataFormatHelper: {
-    getUploadData(data: any, event: CoreAnalyticsType): HashObject;
-    formatVideoUpload(data: any, event: CoreAnalyticsType): HashObject[];
-    getStartVideoUploadData(files: File[]): HashObject[];
-    getDiscardVideoUploadData(uploads: HashObject | HashObject[]): HashObject[];
-    getCompleteUploadData(videos: HashObject[]): HashObject[];
-    formatResourceUpload(item: Resource | Subtitle): HashObject;
-};

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

@@ -1,3 +0,0 @@
-export declare const UrlHelper: {
-    safeUrlConcat(baseUrl: string, path: string): string;
-};

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

@@ -1,10 +0,0 @@
-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 +0,0 @@
-export declare const CommonChannels: {
-    SHELL: string;
-    ALERT: string;
-    POPUP: string;
-};

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

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

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

@@ -1,37 +0,0 @@
-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 +0,0 @@
-/// <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 +0,0 @@
-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 +0,0 @@
-/// <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 +0,0 @@
-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 +0,0 @@
-/// <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 +0,0 @@
-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 +0,0 @@
-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;
-}

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

@@ -1,27 +0,0 @@
-import * as Backbone from 'backbone';
-import { BaseCollection } from './BaseCollection';
-export declare class BaseModel extends Backbone.Model {
-    parent?: BaseModel | BaseCollection;
-    collection: BaseCollection;
-    /**
-     * Mechanism to allow properties/functions to be attached to
-     * the instance of a model at runtime.
-     * @param propertyHash
-     *
-     * I feel like this implementation is a bit naive,
-     * but it will suffice for the time being - Mike
-     */
-    private mixin;
-    /**
-     * Helper to facilitate model validation at runtime
-     * @param validation
-     */
-    addValidation(validation: any): void;
-    /**
-     * Backbone Validation mixin functions
-     */
-    preValidate: (attr: any, value: any) => any;
-    validate(attributes?: any, options?: any): 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/BaseNestedModel.d.ts

@@ -1,21 +0,0 @@
-import { ModelSetOptions, ObjectHash } from 'backbone';
-import { BaseModel } from './BaseModel';
-import { BaseCollection } from './BaseCollection';
-interface Association {
-    new (...args: any[]): (BaseCollection | BaseModel);
-}
-export interface BaseNestedModelOptions extends ModelSetOptions {
-    unset?: boolean;
-}
-export declare class BaseNestedModel extends BaseModel {
-    [name: string]: any;
-    protected associations: {
-        [name: string]: Association;
-    };
-    set(key: string | ObjectHash, value?: any | ModelSetOptions, options?: BaseNestedModelOptions): BaseNestedModel;
-    get(attributeName: string): any;
-    setAssociation(key: string, value: any, options: BaseNestedModelOptions): BaseModel | BaseCollection<BaseModel>;
-    toJSON(...args: any[]): ObjectHash;
-    toFlatJSON(...args: any[]): ObjectHash;
-}
-export {};

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

@@ -1,10 +0,0 @@
-/// <reference types="backbone" />
-import * as Marionette from 'backbone.marionette';
-export interface BaseServiceOptions extends Marionette.ObjectOptions {
-}
-export declare class BaseService extends Marionette.Object {
-    name: string;
-    constructor(options?: BaseServiceOptions);
-    listenTo(object: any, eventMap: Backbone.EventMap): this;
-    listenTo(obj: string | Backbone.Events, events: string, callback: (...args: any) => any): this;
-}