@clickview/library-editor 1.1.2 → 1.1.3-rc.0

package/dist/src/apps/search/components/search-context/SearchContextComponent.d.ts

@@ -0,0 +1,18 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+export declare class SearchContextComponent extends Core.Component {
+    initialize(): void;
+    get name(): string;
+    get template(): string;
+    get tagName(): string;
+    get className(): string;
+    get behaviors(): any[];
+    get elements(): ObjectHash;
+    events(): ObjectHash;
+    private onClick;
+    private onMouseEnter;
+    private onMouseLeave;
+    private toggleFocus;
+    viewOptions(): ObjectHash;
+    onBeforeRender(): boolean;
+}

package/dist/src/apps/search/components/search-tips/SearchTipsComponent.d.ts

@@ -0,0 +1,11 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+export declare class SearchTipsComponent extends Core.Component {
+    initialize(): void;
+    get name(): string;
+    get template(): string;
+    get lang(): string;
+    get behaviors(): any[];
+    private renderTips;
+    viewOptions(): ObjectHash;
+}

package/dist/src/apps/search/services/ContextualSearchService.d.ts

@@ -0,0 +1,37 @@
+import { Core } from '@clickview/common';
+export interface SearchContext {
+    appLink: Core.AppLink;
+    searchTag: string;
+    title?: string;
+    filterParam: string;
+    filterValue?: string;
+    setFilterValue: (context: SearchContext, self: any) => void;
+}
+declare class StaticContextualSearchService extends Core.Service {
+    private static instance;
+    private searchContext;
+    static get Instance(): StaticContextualSearchService;
+    initialize(): void;
+    get name(): string;
+    get lang(): string;
+    getSearchContext(): Core.Model;
+    /**
+     * Event listeners
+     */
+    private onRouteChange;
+    private onTypeaheadToggle;
+    /**
+     * Context mutation methods
+     */
+    private setSearchContext;
+    private updateSearchContext;
+    private setFilterValue;
+    private resetSearchContext;
+    /**
+     * Validation methods
+     */
+    private isValidSearchContext;
+    private inSearchView;
+}
+export declare const ContextualSearchService: StaticContextualSearchService;
+export {};

package/dist/src/apps/search/views/search-bar/SearchBarView.d.ts

@@ -0,0 +1,102 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+export interface SearchBarViewOptions extends Core.ViewOptions {
+    showRecentSearch?: boolean;
+}
+export declare class SearchBarView extends Core.View {
+    protected options: SearchBarViewOptions;
+    private currentUser;
+    private libraryCollection;
+    private storageHelper;
+    private recentSearchEngine;
+    private viewCache;
+    private searchInput;
+    private searchContext;
+    private preventToggleEvent;
+    constructor(options: SearchBarViewOptions);
+    initialize(): void;
+    get name(): string;
+    get title(): boolean;
+    get tagName(): string;
+    get template(): any;
+    get lang(): string;
+    get channelName(): string;
+    get className(): string;
+    get defaults(): ObjectHash;
+    get elements(): ObjectHash;
+    events(): ObjectHash;
+    get bindings(): ObjectHash;
+    regions(): ObjectHash;
+    private get recentSearchKey();
+    private bindListeners;
+    /**
+     * View Cache management
+     */
+    private getOrCacheView;
+    private clearViewCache;
+    private getDynamicTemplate;
+    private getLimits;
+    /**
+     * Recent search logic
+     */
+    private updateSearchHistory;
+    private handleRecentSearch;
+    private onDeleteRecentSearch;
+    private getInstantSearchAppLink;
+    /**
+     * Typeahead event handlers
+     */
+    private onTypeaheadSelect;
+    private onClickSearch;
+    private onSubmit;
+    private submitQuery;
+    private resetQuery;
+    private updateInitialQuery;
+    private logSearch;
+    /**
+    * When the user clicks away from the typeahead, the close event will be fired, unbinding the delete
+    * event for recent search. Re-selecting the typehead will open it BUT it won't re-fetch the results and
+    * render event won't be fired. We need to manually re-bind the click handlers to ensure the delete
+    * functionality is retained.
+    */
+    private onTypeaheadOpen;
+    private onBeforeTypeaheadClose;
+    private onTypeaheadClose;
+    private showMask;
+    private hideMask;
+    private alignTypeahead;
+    private onTypeaheadRender;
+    private initTypeaheadListeners;
+    private initNoLibrariesTypeaheadListeners;
+    private onKeydown;
+    private onResetSearchContext;
+    /**
+     * Bloodhound & Typeadhead configs
+     */
+    private getRecentSearchBloodhound;
+    private getDynamicBloodhoundConfig;
+    private getDynamicTypeaheadConfig;
+    private getDynamicOptions;
+    /**
+     * Typeahead sources
+     */
+    private getRecentSearchSources;
+    private getDirectSearchSources;
+    private getDynamicSearchSources;
+    private getSources;
+    private getNoLibrariesSource;
+    private initializeTypeahead;
+    private hasLibraries;
+    private getLibraryIds;
+    /**
+     * Render methods
+     */
+    viewOptions(): ObjectHash;
+    get requiredResources(): Core.RequiredResourceHash;
+    private renderSearchTips;
+    private renderSearch;
+    private renderPartialSearch;
+    private renderSearchContext;
+    onRender(): void;
+    onClose(): void;
+}

package/dist/src/apps/search/views/search-bar/templates/index.d.ts

@@ -0,0 +1,9 @@
+import FolderResult from './FolderResult.hbs';
+import DirectSearchResult from './DirectSearchResult.hbs';
+import Loading from './Loading.hbs';
+import NotFound from './NotFound.hbs';
+import ResultFooter from './ResultFooter.hbs';
+import ResultHeader from './ResultHeader.hbs';
+import RecentSearchHeader from './RecentSearchHeader.hbs';
+import NoLibraries from './NoLibraries.hbs';
+export { FolderResult, DirectSearchResult, Loading, NotFound, ResultFooter, ResultHeader, RecentSearchHeader, NoLibraries };

package/dist/src/shared/behaviors/popover/PopoverBehavior.d.ts

@@ -0,0 +1,40 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+export declare enum PopoverPlacement {
+    auto = "auto",
+    top = "top",
+    bottom = "bottom",
+    left = "left",
+    right = "right"
+}
+export declare type PopoverSize = 'popover-sm' | 'popover-md' | 'popover-lg';
+export interface PopoverBehaviorOptions {
+    toggleEventName?: string;
+    renderContent: (region: string) => void;
+    placement?: PopoverPlacement;
+    title?: string;
+    containerSelector?: string;
+    size?: PopoverSize;
+    boundary?: any;
+    customClasses?: string;
+}
+export declare class PopoverBehavior extends Core.Behavior {
+    options: PopoverBehaviorOptions;
+    private popoverInitialized;
+    get defaults(): ObjectHash;
+    set defaults(defaults: ObjectHash);
+    get ui(): ObjectHash;
+    set ui(ui: ObjectHash);
+    events(): ObjectHash;
+    private bindListeners;
+    private bindBodyClickListener;
+    private bindDropdownListener;
+    private onPopoverInserted;
+    private onPopoverHidden;
+    private toggle;
+    private hide;
+    private onClickPopover;
+    private onClickOutside;
+    private getTrigger;
+    private onAttach;
+}

package/dist/src/shared/behaviors/tooltip/TooltipBehavior.d.ts

@@ -0,0 +1,12 @@
+import { ObjectHash } from 'backbone';
+import { Core } from '@clickview/common';
+export declare class TooltipBehavior extends Core.Behavior {
+    get defaults(): ObjectHash;
+    set defaults(defaults: ObjectHash);
+    get ui(): ObjectHash;
+    set ui(ui: ObjectHash);
+    private getElement;
+    private getOptions;
+    onRender(): void;
+    onBeforeDetach(): void;
+}

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/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/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/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/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 {};