@clickview/library-editor 1.1.18-rc.0 → 1.1.19-dev.0

package/dist/projects/library-editor/src/shared/components/edit-video/select-rating/SelectRatingItemComponent.d.ts

@@ -0,0 +1,20 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../../libs/common/src/backbone";
+import { Rating } from "../../../models/Rating";
+export interface SelectRatingItemComponentOptions extends Core.ComponentOptions<Rating> {
+    currentRatingId?: number;
+    editable?: boolean;
+}
+export declare class SelectRatingItemComponent extends Core.Component<Rating> {
+    options: SelectRatingItemComponentOptions;
+    constructor(options: SelectRatingItemComponentOptions);
+    get name(): string;
+    get template(): any;
+    get tagName(): string;
+    get attributes(): any;
+    get className(): string;
+    events(): ObjectHash;
+    get behaviors(): any[];
+    onClick(event: Event): void;
+    onRender(): void;
+}

package/dist/projects/library-editor/src/shared/components/fields/FieldsComponent.d.ts

@@ -0,0 +1,9 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+export declare class FieldsComponent extends Core.Component {
+    get name(): string;
+    get template(): any;
+    get className(): string;
+    regions(): ObjectHash;
+    onRender(): void;
+}

package/dist/projects/library-editor/src/shared/components/image-cropper/ImageCropperComponent.d.ts

@@ -0,0 +1,34 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { Image } from "../../models/Image";
+import { ImageType } from "../../enums";
+export declare enum CropEventNames {
+    ClickCrop = "click:crop",
+    CropImage = "crop:image",
+    ImageCropped = "image:cropped"
+}
+export interface ImageCropperComponentOptions extends Core.ComponentOptions {
+    channelName: string;
+    imageType: ImageType;
+    minHeight: number;
+    minWidth: number;
+    getCropRegionWidth: Function;
+}
+export declare class ImageCropperComponent extends Core.Component<Image> {
+    options: ImageCropperComponentOptions;
+    private cropper;
+    constructor(options: ImageCropperComponentOptions);
+    initialize(): void;
+    get name(): string;
+    get template(): string;
+    get className(): string;
+    get elements(): ObjectHash;
+    private getMinCropBoxWidth;
+    private getMinCropBoxHeight;
+    private getViewportToImageRatio;
+    private crop;
+    private getImageMimeType;
+    private renderCropper;
+    onRender(): void;
+    onBeforeDestroy(): void;
+}

package/dist/projects/library-editor/src/shared/components/left-nav/LeftNavComponent.d.ts

@@ -0,0 +1,30 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { AnalyticsOptions } from "../../../../../../libs/analytics/src/interfaces";
+export interface LeftNavComponentOptions extends Core.ComponentOptions {
+    styles?: any;
+    channelName: string;
+    childrenProperty?: string;
+    textProperty?: string;
+    appLink?: Core.AppLink;
+    linkArgs?: (model: Core.Model) => any[];
+    linkParams?: (model: Core.Model) => string | ObjectHash;
+    actions?: new (...args: any[]) => Core.Component;
+    extraClasses?: string;
+    extraClass?: string;
+    folderTreeId: string;
+    analyticsOptions?: AnalyticsOptions;
+    isSelector?: boolean;
+    disabledIds?: ObjectHash;
+}
+export declare class LeftNavComponent extends Core.ComponentCollection {
+    protected options: LeftNavComponentOptions;
+    private disabledIds;
+    constructor(options?: LeftNavComponentOptions);
+    get name(): string;
+    get tagName(): string;
+    get childView(): any;
+    get className(): string;
+    get viewComparator(): string;
+    get childViewOptions(): LeftNavComponentOptions;
+}

package/dist/projects/library-editor/src/shared/components/left-nav/LeftNavNodeComponent.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="jquery" />
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { LeftNavComponentOptions } from "./LeftNavComponent";
+export declare class LeftNavNodeComponent extends Core.Component {
+    options: LeftNavComponentOptions;
+    /**
+     * This is used to not re-render the sub children during drag and drop
+     */
+    private renderedSubChildren;
+    constructor(options?: LeftNavComponentOptions);
+    initialize(): void;
+    get name(): string;
+    get elements(): ObjectHash;
+    get tagName(): string;
+    get className(): string;
+    get behaviors(): any[];
+    get appLinks(): Core.AppLinkHash;
+    events(): ObjectHash;
+    regions(): ObjectHash;
+    get template(): any;
+    hasChildren(): boolean;
+    getChildren(): Core.Collection;
+    getText(): string;
+    private isSelected;
+    private isParent;
+    private isDisabled;
+    private getAnchorClass;
+    private getAppLink;
+    /**
+     * Clicking on a folder can result in one of three outcomes, depending on the
+     * current state of the folder and the user's intent;
+     *
+     * 1. Where the folder isn't selected, navigate to that folder, select it and open any children.
+     * 2. Where the folder is already selected and we *aren't* already on the target route,
+     *    navigate to the target route.
+     * 3. Where the folder is already selected and we *are* on the same route as the target route,
+     *    we will only toggle the open/closed state of any children (no route change will occur).
+     */
+    onClick(event: JQuery.Event): void;
+    private isCurrentPath;
+    private closeChildren;
+    private openChildren;
+    private onOpenSubFolders;
+    private renderChildren;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}

package/dist/projects/library-editor/src/shared/components/page-footer/PageFooterComponent.d.ts

@@ -0,0 +1,15 @@
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { ObjectHash } from 'backbone';
+interface PageFooterComponentOptions extends Core.ComponentOptions {
+    version: string;
+}
+export declare class PageFooterComponent extends Core.Component {
+    options: PageFooterComponentOptions;
+    constructor(options: PageFooterComponentOptions);
+    get name(): string;
+    get template(): any;
+    get lang(): string;
+    get className(): string;
+    viewOptions(): ObjectHash;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/page-header/PageHeaderComponent.d.ts

@@ -0,0 +1,25 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+interface PageHeaderComponentOptions extends Core.ComponentOptions {
+    onlyShowProfile?: boolean;
+}
+export declare class PageHeaderComponent extends Core.Component {
+    protected options: PageHeaderComponentOptions;
+    constructor(options?: PageHeaderComponentOptions);
+    get name(): string;
+    get template(): any;
+    get tagName(): string;
+    get className(): string;
+    regions(): ObjectHash;
+    events(): ObjectHash;
+    private onClick;
+    private logAction;
+    private getSearchModel;
+    private renderSearchBar;
+    private renderUpload;
+    private renderNotificationsStatus;
+    private renderUserDropdown;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/partial-loading/PartialLoadingComponent.d.ts

@@ -0,0 +1,16 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+export interface PartialLoadingComponentOptions extends Core.ComponentOptions {
+    template: string;
+    tagName?: keyof HTMLElementTagNameMap;
+    className?: string;
+    viewOptions?: ObjectHash;
+}
+export declare class PartialLoadingComponent extends Core.Component {
+    protected options: PartialLoadingComponentOptions;
+    constructor(options?: PartialLoadingComponentOptions);
+    get name(): string;
+    get tagName(): string;
+    get className(): string;
+    viewOptions(): ObjectHash;
+}

package/dist/projects/library-editor/src/shared/components/partial-loading/PartialLoadingComponentCollection.d.ts

@@ -0,0 +1,20 @@
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { PartialLoadingComponent, PartialLoadingComponentOptions } from "./PartialLoadingComponent";
+interface PartialLoadingComponentCollectionOptions extends Core.ComponentCollectionOptions {
+    tagName?: keyof HTMLElementTagNameMap;
+    className?: string;
+    noExtraClass?: boolean;
+    collectionLength?: number;
+    childOptions: PartialLoadingComponentOptions;
+}
+export declare class PartialLoadingComponentCollection extends Core.ComponentCollection {
+    options: PartialLoadingComponentCollectionOptions;
+    constructor(options?: PartialLoadingComponentCollectionOptions);
+    initialize(): void;
+    get name(): string;
+    get tagName(): string;
+    get className(): string;
+    get childView(): typeof PartialLoadingComponent;
+    get childViewOptions(): PartialLoadingComponentOptions;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/resizing-text-area/ResizingTextAreaComponent.d.ts

@@ -0,0 +1,23 @@
+import { Core } from "../../../../../../libs/common/src/backbone";
+interface ResizingTextAreaComponentOptions extends Core.ComponentOptions {
+    name?: string;
+    id?: string;
+    class?: string;
+    placeholder?: string;
+    required?: boolean;
+    readonly?: boolean;
+    disabled?: boolean;
+}
+export declare class ResizingTextAreaComponent extends Core.Component {
+    options: ResizingTextAreaComponentOptions;
+    constructor(options: ResizingTextAreaComponentOptions);
+    get name(): string;
+    get template(): string;
+    events(): any;
+    /**
+     * https://gomakethings.com/automatically-expand-a-textarea-as-the-user-types-using-vanilla-javascript/
+     */
+    private onInput;
+    viewOptions(): ResizingTextAreaComponentOptions;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/select/SelectComponent.d.ts

@@ -0,0 +1,54 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { DropdownAnalyticsHelper } from "../dropdown/DropdownComponentCollection";
+export interface SelectChildOptions {
+    channelName?: string;
+    titleProperty?: string;
+    eventName: string;
+    extraClasses?: string;
+    prefixHandler?: () => string;
+    currentSelectedMessage?: string;
+    isDisabled?: (model: Core.Model) => boolean;
+    truncateOptionNames?: boolean;
+}
+export interface SelectComponentOptions extends Core.ComponentCollectionOptions {
+    channelName: string;
+    childOptions: SelectChildOptions;
+    placeholderText: string;
+    noOptionsText?: string;
+    inputName?: string;
+    disabled?: boolean;
+    displayProperty?: string;
+    analyticsHelper: DropdownAnalyticsHelper;
+}
+export declare class SelectComponent extends Core.Component {
+    collection: Core.Collection;
+    options: SelectComponentOptions;
+    private selectSearch;
+    private sameCharIndex;
+    private scopedTimerIndex;
+    private optionStep;
+    constructor(options: SelectComponentOptions);
+    initialize(): void;
+    get name(): string;
+    get template(): any;
+    regions(): ObjectHash;
+    events(): ObjectHash;
+    get defaults(): ObjectHash;
+    get elements(): ObjectHash;
+    private bindListeners;
+    private onShowDropdown;
+    private onKeydown;
+    private onArrowKeyDown;
+    private onType;
+    onSelect(model: Core.Model): void;
+    setModel(): void;
+    private getNextModel;
+    private getModelMatch;
+    private handleSameCharIndex;
+    private runTimer;
+    private isDisabled;
+    private getButtonText;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}

package/dist/projects/library-editor/src/shared/components/spinner-button/SpinnerButtonComponent.d.ts

@@ -0,0 +1,73 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { TooltipOptions } from "../../../../../../libs/shared/src/legacy/behaviors/tooltip/TooltipBehavior";
+import { SpinnerOptions } from "../../utils";
+export declare const SpinnerButtonEvents: {
+    ShowSpinner: string;
+    HideSpinner: string;
+    ToggleSpinner: string;
+    Enable: string;
+    Disable: string;
+    ManageDimensions: string;
+};
+export declare const SpinnerButtonModelAttributes: {
+    ShowSpinner: string;
+    Disabled: string;
+};
+export interface SpinnerButtonComponentOptions extends Core.ViewOptions {
+    saveEvent: string;
+    channelName?: string;
+    showSpinner?: boolean;
+    extraButtonClass?: string;
+    buttonText?: string | Function;
+    buttonType?: 'submit' | 'reset' | 'button';
+    detectWidth?: boolean;
+    detectHeight?: true;
+    preventMultiClick?: boolean;
+    tooltip?: TooltipOptions | (() => TooltipOptions);
+    spinnerOptions?: SpinnerOptions;
+    disabled?: boolean;
+}
+export declare class SpinnerButtonComponent extends Core.Component {
+    protected options: SpinnerButtonComponentOptions;
+    constructor(options?: SpinnerButtonComponentOptions);
+    get name(): string;
+    get tagName(): string;
+    /**
+     * TODO: Use the Tooltip behaviour once we allow it to be toggleable within
+     * the behaviour itself.
+     */
+    get attributes(): ObjectHash;
+    get template(): any;
+    get className(): string;
+    events(): ObjectHash;
+    get defaults(): ObjectHash;
+    initialize(): void;
+    private bindSpinnerListeners;
+    private bindDisableListeners;
+    private getButtonText;
+    private getTooltipOptions;
+    private onClick;
+    private toggleSpinner;
+    private showSpinner;
+    private hideSpinner;
+    private enableButton;
+    private disableButton;
+    private manageDimensions;
+    /**
+     * Store current dimensions of button
+     * This will only execute after an initial render event as it's triggered in the
+     * onBeforeRender handler.
+     */
+    private storeDimensions;
+    /**
+     * Apply the stored dimention state
+     * Only applied if we already have stored some dimensions
+     */
+    private applyDimensions;
+    private renderTooltip;
+    viewOptions(): ObjectHash;
+    onAttach(): void;
+    onRender(): void;
+    onBeforeDestroy(): void;
+}

package/dist/projects/library-editor/src/shared/components/tabs/TabsComponent.d.ts

@@ -0,0 +1,28 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+interface TabAppLink {
+    selector: string;
+    appLink: Object;
+}
+export interface Tab {
+    name: string | (() => string);
+    active?: boolean;
+    link: TabAppLink;
+    hide?: boolean;
+}
+interface TabsComponentOptions extends Core.ComponentOptions {
+    tabs: Array<Tab>;
+    activeTab: string;
+}
+export declare class TabsComponent extends Core.Component {
+    options: TabsComponentOptions;
+    constructor(options: TabsComponentOptions);
+    get name(): string;
+    get className(): string;
+    get template(): any;
+    get appLinks(): ObjectHash;
+    viewOptions(): ObjectHash;
+    private setActiveTab;
+    onBeforeRender(): void;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/top-navigation/TopNavigationComponentCollection.d.ts

@@ -0,0 +1,29 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+interface TopNavigationItemComponentOptions extends Core.ComponentOptions {
+    selected: Core.AppLink;
+}
+declare class TopNavigationItemComponent extends Core.Component {
+    options: TopNavigationItemComponentOptions;
+    constructor(options: TopNavigationItemComponentOptions);
+    get name(): string;
+    get tagName(): string;
+    get className(): string;
+    private isSelected;
+    get appLinks(): Core.AppLinkHash;
+    get template(): any;
+    private getCount;
+    viewOptions(): ObjectHash;
+}
+interface TopNavigationComponentCollectionOptions extends Core.ComponentCollectionOptions {
+    selected?: Core.AppLink;
+}
+export declare class TopNavigationComponentCollection extends Core.ComponentCollection {
+    options: TopNavigationComponentCollectionOptions;
+    constructor(options?: TopNavigationComponentCollectionOptions);
+    get name(): string;
+    get className(): string;
+    get childView(): typeof TopNavigationItemComponent;
+    get childViewOptions(): TopNavigationItemComponentOptions;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/tree-dropdown/TreeDropdownComponent.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="jquery" />
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { FolderCollection } from "../../collections/FolderCollection";
+interface TreeDropdownComponentOptions extends Core.ComponentOptions {
+    folderTreeKey: string;
+    canCreateNew?: boolean;
+    disabledIds?: string[];
+    name?: string;
+}
+export declare class TreeDropdownComponent extends Core.Component {
+    options: TreeDropdownComponentOptions;
+    collection: FolderCollection;
+    private buttonText;
+    private disabledIds;
+    constructor(options: TreeDropdownComponentOptions);
+    initialize(): void;
+    get name(): string;
+    get template(): string;
+    get className(): string;
+    get lang(): string;
+    regions(): ObjectHash;
+    events(): ObjectHash;
+    get defaults(): ObjectHash;
+    get elements(): ObjectHash;
+    onClickCreateNew(e: JQuery.Event): void;
+    private setButtonText;
+    private renderSelector;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/typeahead-input/SearchTypeaheadComponent.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="typeahead" />
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { TypeaheadConfigHandler, TypeaheadSourceItem } from "../../../../../../libs/shared/src/apps/search/interfaces";
+interface TypeaheadCallbacks {
+    onRender?: Function;
+    onInput?: Function;
+    onBlur?: Function;
+}
+interface TypeaheadActionOptions {
+    clearOnSelect?: boolean;
+}
+interface SearchTypeaheadComponentOptions<TSearchType> extends Core.ComponentOptions {
+    parentChannelName: string;
+    inputId: string;
+    selectEvent: string;
+    typeaheadConfigs: TypeaheadSourceItem<TSearchType> | TypeaheadSourceItem<TSearchType>[];
+    stickItProperty?: string;
+    inputName?: string;
+    placeholderText?: string;
+    callbacks?: TypeaheadCallbacks;
+    typeaheadOptions?: ObjectHash;
+    actionOptions?: TypeaheadActionOptions;
+    editable?: boolean;
+    additionalClasses?: string;
+    removeEvent?: string;
+    forceShowRemoveButton?: boolean;
+}
+export declare class SearchTypeaheadComponent<TSearchType> extends Core.Component {
+    options: SearchTypeaheadComponentOptions<TSearchType>;
+    private parentChannel;
+    constructor(options?: SearchTypeaheadComponentOptions<TSearchType>);
+    get name(): string;
+    get template(): any;
+    get className(): string;
+    get channelName(): string;
+    get elements(): ObjectHash;
+    get defaults(): ObjectHash;
+    events(): ObjectHash;
+    initialize(): void;
+    protected bindListeners(): void;
+    get bindings(): ObjectHash;
+    clearInput(): void;
+    setInput(newVal: string): void;
+    /**
+     * TODO: Add submit on enter support
+     */
+    protected onTypeaheadSelect(event: any, suggestion: string | ObjectHash, source: any): void;
+    private onSubmit;
+    private onClickRemove;
+    protected getSources(): TypeaheadConfigHandler<TSearchType>[] | Twitter.Typeahead.Dataset<TSearchType>[];
+    private getTypeaheadOptions;
+    private getTypeaheadActionOptions;
+    private bindOptionalCallbacks;
+    protected initTypeahead(): void;
+    protected initTypeaheadListeners(): void;
+    private toggleRemove;
+    /**
+     * Show the remove button if:
+     *
+     * Content is editable
+     * We have a value
+     * We have a remove event to trigger
+     *
+     * OR
+     *
+     * We're being force to show the remove button (Used by PPDD)
+     */
+    private shouldShowRemove;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+    onClose(): void;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/typeahead-list/TypeaheadListComponent.d.ts

@@ -0,0 +1,33 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+interface TypeaheadListComponentOptions extends Core.ComponentCollectionOptions {
+    collection: Core.Collection;
+    channelName: string;
+    typeaheadConfig: any;
+    selectEvent: string;
+    inputId: string;
+    placeholderText: string;
+    modelType: string;
+    removeEvent?: string;
+    editable?: boolean;
+}
+export declare class TypeaheadListComponentCollection extends Core.ComponentCollection {
+    options: TypeaheadListComponentOptions;
+    constructor(options: TypeaheadListComponentOptions);
+    get name(): string;
+    get childViewOptions(): TypeaheadListComponentOptions;
+    get childView(): typeof TypeaheadListComponent;
+}
+declare class TypeaheadListComponent extends Core.Component {
+    options: TypeaheadListComponentOptions;
+    constructor(options: TypeaheadListComponentOptions);
+    get name(): string;
+    get template(): string;
+    get modelId(): string;
+    get bindings(): ObjectHash;
+    regions(): ObjectHash;
+    private renderTypeahead;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/user-options-dropdown/UserOptionsDropdownComponent.d.ts

@@ -0,0 +1,20 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+import { DropdownChildOptions, DropdownDisplayOptions } from "../dropdown/DropdownComponentCollection";
+import { User } from "../../models/User";
+interface UserOptionsDropdownComponentOptions extends Core.ComponentOptions<User> {
+    childOptions?: DropdownChildOptions;
+    displayOptions?: DropdownDisplayOptions;
+}
+export declare class UserOptionsDropdownComponent extends Core.Component<User> {
+    protected options: UserOptionsDropdownComponentOptions;
+    constructor(options: UserOptionsDropdownComponentOptions);
+    get name(): string;
+    get className(): string;
+    get template(): string;
+    regions(): ObjectHash;
+    private getExtraClasses;
+    viewOptions(): ObjectHash;
+    onRender(): void;
+}
+export {};

package/dist/projects/library-editor/src/shared/components/video-actions/VideoActionComponentCollection.d.ts

@@ -0,0 +1,31 @@
+import { ObjectHash } from 'backbone';
+import { Core } from "../../../../../../libs/common/src/backbone";
+interface VideoActionItemComponentOptions extends Core.ComponentOptions {
+    showLabel?: boolean;
+}
+declare class VideoActionItemComponent extends Core.Component {
+    options: VideoActionItemComponentOptions;
+    constructor(options: VideoActionItemComponentOptions);
+    get name(): string;
+    get template(): any;
+    get tagName(): string;
+    get attributes(): ObjectHash;
+    get className(): string;
+    events(): ObjectHash;
+    get behaviors(): any[];
+    get appLinks(): Core.AppLinkHash;
+    private onClick;
+    private logAction;
+    viewOptions(): ObjectHash;
+}
+interface VideoActionComponentCollectionOptions extends Core.ComponentCollectionOptions {
+    showActionLabels?: boolean;
+}
+export declare class VideoActionComponentCollection extends Core.ComponentCollection {
+    options: VideoActionComponentCollectionOptions;
+    constructor(options: VideoActionComponentCollectionOptions);
+    get name(): string;
+    get childView(): typeof VideoActionItemComponent;
+    get childViewOptions(): ObjectHash;
+}
+export {};