@clickview/library-editor 1.1.7 → 1.1.8

package/dist/src/shared/collections/PendingItemsCollection.d.ts

@@ -0,0 +1,8 @@
+import { Core } from '@clickview/common';
+declare class PendingItem extends Core.Model {
+    get idAttribute(): string;
+}
+export declare class PendingItemsCollection extends Core.Collection {
+    get model(): typeof PendingItem;
+}
+export {};

package/dist/src/shared/components/empty-state/EmptyStateComponent.d.ts

@@ -0,0 +1,24 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+export declare type EmptyStateImageSize = 'sm' | 'lg';
+export interface EmptyStateComponentOptions extends Core.ComponentOptions {
+    imageUrl: string;
+    heading?: string | (() => string);
+    description?: string | (() => string);
+    appLink?: Core.AppLinkHash;
+    customClass?: string;
+    customImageClass?: string;
+}
+export declare class EmptyStateComponent extends Core.Component {
+    protected options: EmptyStateComponentOptions;
+    constructor(options: EmptyStateComponentOptions);
+    get name(): string;
+    get className(): string;
+    get template(): string;
+    get defaults(): ObjectHash;
+    get appLinks(): Core.AppLinkHash;
+    private getImageClass;
+    private getHeading;
+    private getDescription;
+    viewOptions(): ObjectHash;
+}

package/dist/src/shared/components/pagination/PaginationComponent.d.ts

@@ -0,0 +1,28 @@
+import { ObjectHash } from 'backbone';
+import { Core, Cursors } from '@clickview/common';
+import { AnalyticsOptions } from '@clickview/analytics';
+interface PaginationComponentOptions extends Core.ComponentOptions {
+    cursors: Cursors;
+    appLink: Core.AppLink;
+    collectionId?: string;
+    allowFirstPageCursor?: boolean;
+    analyticsOptions?: AnalyticsOptions;
+    cursorParamName?: string;
+}
+export declare class PaginationComponent extends Core.Component {
+    options: PaginationComponentOptions;
+    constructor(options: PaginationComponentOptions);
+    get defaults(): ObjectHash;
+    get name(): string;
+    get template(): any;
+    get lang(): string;
+    get appLinks(): Core.AppLinkHash;
+    events(): ObjectHash;
+    private buildCursor;
+    private onClickPrevious;
+    private onClickNext;
+    private logAction;
+    viewOptions(): ObjectHash;
+    onBeforeRender(): boolean;
+}
+export {};

package/dist/src/shared/components/thumbnail/ThumbnailComponent.d.ts

@@ -0,0 +1,32 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+import { Video } from "../../models";
+import { ImageOptions } from "../../utils";
+export interface ThumbnailComponentOptions extends Core.ComponentOptions {
+    model: Video;
+    onClickHandler?: Function;
+    thumbnailOptions?: ImageOptions;
+    playIcon?: boolean;
+    lazyload?: boolean;
+    appLink?: Core.AppLink;
+    href?: string;
+    channelName?: string;
+}
+export declare class ThumbnailComponent extends Core.Component<Video> {
+    protected options: ThumbnailComponentOptions;
+    constructor(options: ThumbnailComponentOptions);
+    initialize(): void;
+    get name(): string;
+    get template(): string;
+    get tagName(): string;
+    get className(): string;
+    get elements(): ObjectHash;
+    events(): ObjectHash;
+    get appLinks(): Core.AppLinkHash;
+    get attributes(): ObjectHash;
+    private showPlayIcon;
+    private onClick;
+    private onImageLoad;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}

package/dist/src/shared/enums/AppLinkReferrer.d.ts

@@ -0,0 +1,3 @@
+export declare enum AppLinkReferrer {
+    Notification = "notification"
+}

package/dist/src/shared/enums/CurationStatus.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This enum maps directly to the CurationStatus enum in the
+ * NuGet package ClickView.Models from master.
+ */
+export declare enum CurationStatus {
+    Draft = 0,
+    Published = 1,
+    Archive = 2,
+    Pending = 3,
+    Rejected = 4,
+    Processing = 5
+}

package/dist/src/shared/errors/file-type/FileTypeError.d.ts

@@ -0,0 +1,15 @@
+import { DialogError } from "../primitives";
+import { DialogViewOptions } from "../../components";
+/**
+ * TODO: Create a more useful message here.
+ * Perhaps using the mime types listen on MDN
+ * https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/Complete_list_of_MIME_types
+ * or in the list of all the official mime types
+ * https://www.iana.org/assignments/media-types/media-types.xhtml
+ */
+export declare class FileTypeError extends DialogError {
+    constructor(message: string, files: File[], acceptedFiles: string);
+    get name(): string;
+    get lang(): string;
+    get dialogOptions(): DialogViewOptions;
+}

package/dist/src/shared/errors/primitives/AlertError.d.ts

@@ -0,0 +1,4 @@
+import { Core } from '@clickview/common';
+export declare class AlertError extends Core.SilentError {
+    get name(): string;
+}

package/dist/src/shared/errors/primitives/DialogError.d.ts

@@ -0,0 +1,9 @@
+import { Core } from '@clickview/common';
+import { DialogViewOptions } from "../../components";
+export declare abstract class DialogError extends Core.SilentError {
+    dialogOptions: DialogViewOptions;
+    constructor(message: string);
+    get name(): string;
+    onDone(): void;
+    onFail(): void;
+}

package/dist/src/shared/errors/primitives/ErrorPageError.d.ts

@@ -0,0 +1,7 @@
+import { Core } from '@clickview/common';
+export declare abstract class ErrorPageError extends Core.SilentError {
+    heading: string;
+    description: string;
+    appLink?: Core.AppLinkHash;
+    get name(): string;
+}

package/dist/src/shared/errors/primitives/index.d.ts

@@ -0,0 +1,3 @@
+export * from './AlertError';
+export * from './DialogError';
+export * from './ErrorPageError';

package/dist/src/shared/interfaces/CollectionIdentifier.d.ts

@@ -0,0 +1,7 @@
+import { BaseCollectionIdentifier, BaseCollectionIdentifierOptions } from '@clickview/common';
+import { SortType } from "../enums";
+export interface CollectionIdentifierOptions extends BaseCollectionIdentifierOptions<SortType> {
+}
+export declare class CollectionIdentifier extends BaseCollectionIdentifier<SortType> {
+    protected getSortTypeParam(): string;
+}

package/dist/src/shared/interfaces/Tooltip.d.ts

@@ -0,0 +1,6 @@
+export declare type TooltipPlacement = 'auto' | 'top' | 'bottom' | 'left' | 'right';
+export interface TooltipOptions {
+    selector?: string;
+    title?: string;
+    placement?: TooltipPlacement;
+}

package/dist/src/shared/services/ContextService.d.ts

@@ -0,0 +1,38 @@
+import { Core } from '@clickview/common';
+interface ApplicationContext {
+    pageLoad: boolean;
+    appLink: Core.AppLink;
+}
+export interface AppContextServiceOptions {
+}
+export declare class StaticContextService extends Core.Service {
+    private static instance;
+    private routeHistory;
+    private contextHistory;
+    get name(): string;
+    static get Instance(): StaticContextService;
+    initialize(): void;
+    /**
+     * Context specific methods.
+     * The Context History keeps track of ALL APPLINKS.
+     */
+    private setContext;
+    getCurrentContext(): ApplicationContext;
+    getPreviousContext(): ApplicationContext;
+    /**
+     * Route specific methods.
+     * The Route History works the same way as the Context History, except
+     * it will ONLY take applinks that change the route. This is useful
+     * for things like tracking state for in-application back buttons where we
+     * would not be interested in applinks that do not map to routes.
+     */
+    private updateRouteHistory;
+    getCurrentRoute(): ApplicationContext;
+    getPreviousRoute(): ApplicationContext;
+    /**
+     * Other utilities
+     */
+    fromPageLoad(): boolean;
+}
+export declare const ContextService: StaticContextService;
+export {};

package/dist/src/shared/services/LanguageDataService.d.ts

@@ -0,0 +1,12 @@
+import { ObjectHash } from 'backbone';
+import { BaseDataService } from '@clickview/common';
+interface LanguageConfig {
+    locale: string;
+    phrases: ObjectHash;
+}
+export declare class LanguageDataService extends BaseDataService {
+    get name(): string;
+    get channelName(): string;
+    getLanguageConfig(callback?: (languageConfig: LanguageConfig) => void): void;
+}
+export {};

package/dist/src/shared/services/LanguageService.d.ts

@@ -0,0 +1,16 @@
+import { Core } from '@clickview/common';
+import { LanguageConfig } from "../models/LanguageConfig";
+interface LanguageInterpolationOptions {
+    smartCount?: number;
+    [propName: string]: any;
+}
+declare class StaticLanguageService extends Core.Service {
+    private static instance;
+    private polyglot;
+    static get Instance(): StaticLanguageService;
+    get name(): string;
+    setConfig(config: LanguageConfig): void;
+    getPhrase(namespace: string, phraseKey: string, options?: LanguageInterpolationOptions): string;
+}
+export declare const LanguageService: StaticLanguageService;
+export {};

package/dist/src/shared/utils/EmptyStateHelper.d.ts

@@ -0,0 +1,4 @@
+import { Core } from '@clickview/common';
+export declare const EmptyStateHelper: {
+    isCollectionEmpty(view: Core.View<Core.Model>, collectionName?: string): boolean;
+};

package/dist/src/shared/utils/FileExtensionsHelper.d.ts

@@ -0,0 +1,9 @@
+declare const FileExtensions: {
+    IMAGES: string;
+    RESOURCES: string;
+    SUBTITLES: string;
+};
+declare const FileExtensionHelper: {
+    getResourceType(extension: string): string;
+};
+export { FileExtensions, FileExtensionHelper };

package/dist/src/shared/utils/MaskHelper.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="jquery" />
+/// <reference types="jqueryui" />
+/// <reference types="typeahead" />
+/// <reference types="bootstrap" />
+/// <reference types="dropzone" />
+export interface MaskHelperOptions {
+    targetSelector?: string;
+    additionalClasses?: string;
+    fade?: boolean;
+}
+export declare const MaskHelper: {
+    showMask(options?: MaskHelperOptions): JQuery<HTMLElement>;
+    hideMask(maskEl?: JQuery<HTMLElement>): void;
+    getTarget(targetSelector?: string): JQuery<HTMLElement>;
+};

package/dist/src/shared/utils/handlebars/LangHelper.d.ts

@@ -0,0 +1,5 @@
+import * as Handlebars from 'handlebars';
+export declare const LangHelper: {
+    register(): void;
+    isValid(key: string, options: Handlebars.HelperOptions): boolean;
+};

package/dist/src/shared/utils/handlebars/index.d.ts

@@ -0,0 +1 @@
+export * from './LangHelper';

package/dist/src/shared/utils/search/InstantSearchHelper.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="jquery" />
+import { ObjectHash } from 'backbone';
+import { RemoteSearch } from "./";
+/**
+ * Specific logic for processing responses from domain v1/search/instant endpoint
+ */
+export declare const InstantSearchHelper: {
+    prepareQuery: (query: string, settings: JQueryAjaxSettings, options?: ObjectHash) => string;
+    bloodhoundConfig(source: string, options: ObjectHash): RemoteSearch<any>;
+    handleResult(data: ObjectHash, item: any, options?: ObjectHash): any[];
+    processVideoResult(collection: any[], item: any, options: ObjectHash): any[];
+    processTagsResult(collection: any[], item: any, options: ObjectHash): any[];
+    processSeriesResult(collection: any[], item: any, options: ObjectHash): any[];
+    processFolderResult(collection: any[], item: any, options?: ObjectHash): any[];
+    /**
+     * Manipulate
+     * @param collection
+     * @param options
+     */
+    processCollection(collection: any[], options?: ObjectHash): any[];
+};

package/dist/src/shared/utils/search/RecentSearchHelper.d.ts

@@ -0,0 +1,12 @@
+import { StorageHelper } from '@clickview/common';
+export interface UpdateRecentSearchOptions<T> {
+    query: T;
+    add?: boolean;
+    remove?: boolean;
+    limit?: number;
+}
+export declare const RecentSearchHelper: {
+    getRecentSearches<T>(key: string, dataSource: StorageHelper): T[];
+    setRecentSearches<T_1>(key: string, recentSearches: T_1[], dataSource: StorageHelper): void;
+    updateRecentSearches<T_2>(key: string, dataSource: StorageHelper, options: UpdateRecentSearchOptions<T_2>): T_2[];
+};

package/dist/src/shared/utils/search/SearchTypes.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="typeahead" />
+import { ObjectHash } from 'backbone';
+import { Series, Folder, Video, Channel, Producer, Distributor } from "../../models";
+export declare type InstantSearch = Series | Folder | Video | Channel | Producer | Distributor;
+export interface RemoteSearch<T> extends Bloodhound.BloodhoundOptions<T> {
+    remote: Bloodhound.RemoteOptions<T>;
+}
+export interface LocalSearch<T> extends Bloodhound.BloodhoundOptions<T> {
+    local: T[] | (() => T[]);
+}
+export declare type TypeaheadDataSource<T> = Bloodhound<T> | ((query: string, syncResults: (result: T[]) => void, asyncResults?: (result: T[]) => void) => void);
+export interface InstantSearchBloodhound<T> {
+    bloodhound: TypeaheadDataSource<T>;
+    name: string;
+}
+export declare type TypeaheadConfig<T> = Twitter.Typeahead.Dataset<T>;
+export interface TypeaheadConfigHandler<T> {
+    (source?: InstantSearchBloodhound<T>, index?: number, options?: ObjectHash): Twitter.Typeahead.Dataset<T>;
+}
+export interface BloodhoundConfigHandler<T> {
+    (source: string, options?: ObjectHash): LocalSearch<T> | RemoteSearch<T>;
+}
+export interface TypeaheadSourceItem<T> {
+    name: string;
+    typeaheadConfig: TypeaheadConfigHandler<T>;
+    bloodhoundConfig?: BloodhoundConfigHandler<T>;
+    options?: ObjectHash;
+}

package/dist/src/shared/utils/search/TypeaheadHelper.d.ts

@@ -0,0 +1,76 @@
+/// <reference types="typeahead" />
+/// <reference types="jquery" />
+import { ObjectHash } from 'backbone';
+import * as Bloodhound from 'bloodhound';
+import { TypeaheadDataSource, LocalSearch, RemoteSearch, TypeaheadConfig } from "./";
+import { TypeaheadSourceItem } from "./SearchTypes";
+export declare const TypeaheadHelper: {
+    /**
+    * This function will only allow our typeahead to fetch results when we
+    * have exceeded our min length. The reason for doing this is that we want to the typeahead
+    * to load our recent searches immediately when we click the input, but before we perform any searches. - Mike
+    */
+    handleQuery<T>(dataSource?: TypeaheadDataSource<T>, options?: ObjectHash): TypeaheadDataSource<T>;
+    /**
+     * This function complements HandleQuery allowing us to override when and how typeahead templates are
+     * rendered. When the query doesn't meet our min length we will render a fallback template, which is
+     * essentially just an empty div. This is necessary to ensure we can display recent searchs when the
+     * typeahead is active (but less than the require length to trigger the search functionality). As we are
+     * dynamically generating the results for videos, folders and series we are deliberately using a closure
+     * to ensure we don't lose our template.
+     *
+     * It must also return <any> as the typeahead typings are shit.
+     * - Mike
+     */
+    getTemplate(template: Function, options?: ObjectHash): any;
+    /**
+     * Provides mechanism to map a single search query against multiple bloodhound sources.
+     * Sources may be remote endpoints or local in-memory collections.
+     * @param sources
+     * @param options
+     */
+    getSearchSources<T_1>(sources: TypeaheadSourceItem<T_1>[]): TypeaheadConfig<T_1>[];
+    /**
+     * Bloodhound helper
+     */
+    buildBloodhound<T_2>(options: RemoteSearch<T_2> | LocalSearch<T_2>): Bloodhound<T_2>;
+    /**
+     * This is attached as a callback to the typeahead's render event.
+     * Where there is a real suggestion from the server, we will automatically
+     * set the cursor to that item, to make it simply to add. This is to encourage the
+     * re-use of existing entities.
+     *
+     * Note: With multiple suggestion sets, the render event will also be called multiple times
+     * along with this callback.
+     */
+    selectFirstResult(e: JQueryEventObject, suggestions: any[], async: boolean, dataset: string): void;
+    /**
+    * Callback is designed to be attached to the stickit bindings for the typeahead form
+    * and emit events when a change is detected on the bound model. We do this to be
+    * able to detect whether an input has cleared from a previous selection,
+    *
+    * @param channelName
+    * @param event
+    */
+    emitEventOnInput(channelName: string, eventName: string, type: string, wrapperOptions?: ObjectHash): Function;
+    /**
+    * I hate this.
+    *
+    * Basically what this function does is curry a callback with the original association's
+    * data. Then, depending on the user's interaction with the typeahead input, it will restore that
+    * data when a blur event is triggered.
+    *
+    * @param data raw clone of original assoc model
+    *
+    * Curried callback
+    * @param channelName
+    * @param propertyName
+    */
+    resetAssociationOnBlur(data: ObjectHash): Function;
+    /**
+     * Create and render ConfirmSelection component for use as a
+     * @param options
+     */
+    getConfirmSelectionTemplate(options?: ObjectHash): Function;
+    clearInputOnBlur(channelName: string): void;
+};

package/dist/src/shared/utils/search/raw-search-components/confirm-selection/ConfirmSelectionComponent.d.ts

@@ -0,0 +1,12 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+interface ConfirmSelectionComponentOptions extends Core.ComponentOptions {
+}
+export declare class ConfirmSelectionComponent extends Core.Component {
+    constructor(options: ConfirmSelectionComponentOptions);
+    get name(): string;
+    get template(): string;
+    get className(): string;
+    viewOptions(): ObjectHash;
+}
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@clickview/library-editor",
   "description": "Library Editor",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "main": "dist/bundle.js",
   "types": "dist/src/index.d.ts",
   "scripts": {
@@ -62,7 +62,7 @@
     "@babel/polyfill": "7.4.4",
     "@clickview/analytics": "1.0.4",
     "@clickview/common": "1.0.4",
-    "@clickview/shared": "1.0.5",
+    "@clickview/shared": "1.0.6",
     "@clickview/styles": "1.0.2",
     "autotrack": "2.4.1",
     "bootstrap": "4.3.1",