@clickview/lite 0.0.17-rc.0 → 0.0.18-dev.0

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

@@ -0,0 +1,18 @@
+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;
+};
+export { ErrorHelper };

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

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

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

@@ -0,0 +1,27 @@
+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: Function): this;
+}

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

@@ -0,0 +1,21 @@
+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 | object, 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

@@ -0,0 +1,10 @@
+/// <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: Function): this;
+}

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

@@ -0,0 +1,127 @@
+import * as Backbone from 'backbone';
+import * as Marionette from 'backbone.marionette';
+import { StickitBinding } from "../interfaces/StickitBinding";
+import { BaseModel } from './BaseModel';
+import { AppLinkHash } from './AppLink';
+interface UIHash {
+    [selector: string]: any;
+}
+export interface RequiredResourceHash {
+    [propName: string]: RequiredResourceDefinition;
+}
+export interface RequiredResourceDefinition<T = any> {
+    dataServiceName: string;
+    eventName: string;
+    getData: (instance: any) => T;
+    getInstance: (context: Backbone.Events) => any;
+    beforeOnBeforeRender: boolean;
+}
+export interface BaseViewOptions<TModel extends BaseModel = BaseModel> extends Marionette.ViewOptions<TModel> {
+    channelName?: string;
+}
+export declare class CoreView<TModel extends BaseModel = BaseModel> extends Marionette.View<TModel> {
+    /**
+     * This is of the name class. It should be used on
+     * all warnings and errors to make debugging easier.
+     */
+    name: string;
+    /**
+     * Takes a Handlebars template function.
+     */
+    template: any;
+    /**
+     * Specify the properties you want to be
+     * taken from `options` and added to the context.
+     */
+    props: string[];
+    /**
+     * This is what the page title will be set to
+     * when this view is rendered.
+     */
+    title: string | boolean;
+    /**
+     * The default properties that will be taken
+     * from `options` and added to the context.
+     */
+    private get defaultProps();
+    viewModel: BaseModel;
+    private static ViewDataExtensions;
+    /**
+     * Update instance options to include defaults. Passing options
+     * to the view via the ctor will always override defaults.
+     * @param options
+     */
+    private _setOptions;
+    /**
+     * Mix in the class name into the dom attributes to
+     * help us out with debugging
+     */
+    private _setAttributes;
+    private uiStorage;
+    get ui(): Backbone.ObjectHash;
+    set ui(value: Backbone.ObjectHash);
+    get elements(): Backbone.ObjectHash;
+    protected defaults: Backbone.ObjectHash;
+    protected options: BaseViewOptions<TModel>;
+    /**
+     * Base class for all views to inherit from.
+     * @constructor
+     */
+    constructor(options?: BaseViewOptions<TModel>);
+    appLinks: AppLinkHash;
+    normalizeUIKeys: (hash: UIHash) => UIHash;
+    static AddViewDataExtension(ext: Function | Backbone.ObjectHash): void;
+    serializeModel(): any;
+    serializeCollection(): any[];
+    /**
+     * This is a utility that can be used if your
+     * className is dynamic between renders.
+     * Simply call this.resetClassName() in
+     * onRender()
+     */
+    protected resetClassName(): void;
+    serializeData(): any;
+    protected viewOptions(): Backbone.ObjectHash;
+    /**
+     * Ensures that multiple click events arent bound
+     * if the view is getting re-rendered.
+     */
+    private undelegateAppLinks;
+    /**
+     * This will take the appLinks hash defined on a view and used it to add
+     * hrefs to the anchor tags and provide the application linking.
+     */
+    protected renderAppLinks(): void;
+    private hasPartialLoadingRegions;
+    protected renderPartialLoading(region?: string): void;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+    render(): CoreView<TModel>;
+    /** backbone.stickit stuff that is mixed in at run time.
+     *
+     * TODO: This should ideally be handled higher up that BaseView,
+     * (yet another one of those TODOs that is likely
+     *  to sit here till the end of time. - Sha)
+     */
+    bindings: {
+        [selector: string]: StickitBinding;
+    };
+    stickit: (model?: BaseModel, options?: any) => void;
+    addbinding: (model: BaseModel, selector: string, configuration: any) => void;
+    unstickit: (model?: BaseModel, options?: any) => void;
+    protected processRequriedResources(beforeOnBeforeRender: boolean): boolean;
+    protected setTitle(): void;
+}
+export declare class BaseView<TModel extends BaseModel = BaseModel> extends CoreView<TModel> {
+    private boundListeners;
+    private resourceInstances;
+    requiredResources: {
+        [propName: string]: RequiredResourceDefinition;
+    };
+    constructor(options?: BaseViewOptions<TModel>);
+    protected processRequriedResources(beforeOnBeforeRender: boolean): boolean;
+    setTitle(): void;
+}
+export declare class BaseComponent<TModel extends BaseModel = BaseModel> extends CoreView<TModel> {
+}
+export {};

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

@@ -0,0 +1,16 @@
+declare const EventNames: {
+    SHOW_POPUP: string;
+    ROUTE: string;
+    LOCK_NAV: string;
+    UNLOCK_NAV: string;
+    NAV_IS_LOCKED: string;
+    NAV_UNLOCKED_BY_USER: string;
+    ROUTING_START: string;
+    ROUTING_END: string;
+    HAS_ACTIVE_ROUTE: string;
+    ROUTE_LOOKUP: string;
+    URL_CHANGE: string;
+    ERROR: string;
+    CURRENT_ROUTE: string;
+};
+export { EventNames };

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

@@ -0,0 +1,31 @@
+/// <reference types="backbone" />
+import * as Marionette from 'backbone.marionette';
+import { BaseLayoutView, BaseLayoutViewOptions } from './BaseLayoutView';
+export interface LayoutOptions<T extends BaseLayoutViewOptions> {
+    name: string;
+    options?: T;
+}
+export interface LayoutServiceOptions extends Marionette.ObjectOptions {
+    requiredRegions?: string[];
+}
+export declare class LayoutService extends Marionette.Object {
+    private layouts;
+    private currentLayout;
+    private currentLayoutCacheKey;
+    private requiredRegions;
+    options: LayoutServiceOptions;
+    constructor(options: LayoutServiceOptions);
+    private clearLayout;
+    registerLayout(name: string, layout: typeof BaseLayoutView): this;
+    /**
+     * Either return the existing instance of a layout
+     * or create the layout and cache it before returning.
+     */
+    getLayout<T extends BaseLayoutViewOptions>(layoutOptions: LayoutOptions<T>): BaseLayoutView;
+    /**
+     * Every layout that is registered must have all required/mandatory regions
+     */
+    private checkRequiredRegions;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}

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

@@ -0,0 +1,3 @@
+/// <reference types="backbone" />
+declare function ListenToRadio(obj: string | Backbone.Events, events: string, callback: Function, originalListenTo: Function): any;
+export { ListenToRadio };

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

@@ -0,0 +1,23 @@
+import * as Backbone from 'backbone';
+import { AppLink } from './AppLink';
+/**
+ * This is the only file in the entire project
+ * that should ever reference window.location.
+ */
+declare const LocationUtils: {
+    GetQuery(): Backbone.ObjectHash;
+    UpdateQuery(params: Backbone.ObjectHash): void;
+    UpdateUrl(route: string, appLink: AppLink, options?: Backbone.ObjectHash): void;
+    SerializeQueryParams(params: string | Backbone.ObjectHash): string;
+    DeserializeQueryParams(params: string): Backbone.ObjectHash;
+    StartHistory(): void;
+    PageLoad(href: string, newTab?: boolean): void;
+    Redirect(href: string, replace?: boolean): void;
+    Reload(force?: boolean): void;
+    GetCurrentPath(): string;
+    GetCurrentQueryString(): string;
+    GetCurrentUrl(): string;
+    GetCurrentReferrer(): string;
+    SetPageTitle(title: string): void;
+};
+export { LocationUtils };

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

@@ -0,0 +1,10 @@
+export interface MiddlewareNext<T> {
+    (options: T): void;
+}
+export interface MiddlewareFunction<T> {
+    (options: T, next: MiddlewareNext<T>): void;
+}
+export declare class Middleware<T> {
+    use(fn: MiddlewareFunction<T>): void;
+    go(options: T, next: MiddlewareNext<T>): void;
+}

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

@@ -0,0 +1,79 @@
+import { ObjectHash } from 'backbone';
+import * as Marionette from 'backbone.marionette';
+import { BaseApplication } from './BaseApplication';
+import { BaseError } from './BaseError';
+import { BaseLayoutView } from './BaseLayoutView';
+import { Store } from 'redux';
+interface InitializationStep {
+    (shell: Shell, next: InitializationStep): void;
+}
+interface StartUpSet {
+    (shell: Shell, options: any, next: StartUpSet): void;
+}
+export interface ShellOptions extends Marionette.ApplicationOptions {
+}
+export declare class Shell extends Marionette.Application {
+    /**
+     * Used to retreive and cache layout views.
+     */
+    private layoutService;
+    private applications;
+    private routeLookup;
+    private shellState;
+    initialize(options?: ShellOptions): void;
+    private bindListeners;
+    private bindNavLockListeners;
+    private bindAppLinkListeners;
+    private bindErrorHandlers;
+    private bindErrorListener;
+    /**
+     * Using all the routeLookups passed in during AppRouter initialization
+     * we create a bunch of channel replies on the shell channel.
+     *
+     * Both Core.AppRouter and Core.View use this to reverse engineer
+     * the application routes and regenerate urls with a list of arguments.
+     *
+     * These need to exist on the shell rather than on the Core.AppRouter
+     * because consumers of this reply wont know which instance of Core.AppRoute
+     * to call.
+     */
+    private bindRouteLookup;
+    addRouteLookup(name: string, func: () => string): void;
+    registerApplication(application: typeof BaseApplication, options?: ObjectHash): this;
+    getGlobalRadioChannels(): ObjectHash;
+    isNavLocked(): boolean;
+    start(options?: any): void;
+    hasActiveRoute(): boolean;
+    /**
+     * On Shell start up an instance of each Applications router is instantiated
+     * so that it can listen to application events or route in the current page
+     */
+    onStart(): void;
+    /**
+     * these are based on node/express middleware:
+     * https://gist.github.com/darrenscerri/5c3b3dcbe4d370435cfa
+     *
+     * Initialization steps should be used to do stuff like register
+     * services with the instance manager, register analytics clients
+     * and enrichers, add any data provider middle ware and register layouts
+     */
+    addInitializationStep(fn: InitializationStep): Shell;
+    private runInitializationSteps;
+    addStartUpStep(fn: StartUpSet): Shell;
+    /**
+     * Start up steps should be used to inject options into the shell
+     * or run any other code that we want to run just before the application starts
+     */
+    private runStartUpSteps;
+    registerLayout(name: string, layout: typeof BaseLayoutView): Shell;
+    private errorHandlers;
+    registerErrorHandler<T extends BaseError>(errorType: Function & {
+        prototype: T;
+    }, handler: (error: T) => void): Shell;
+    handleError(error: BaseError): void;
+    store: Store;
+    registerStore(store: Store): void;
+    listenTo(object: any, eventMap: Backbone.EventMap): this;
+    listenTo(obj: string | Backbone.Events, events: string, callback: Function): this;
+}
+export {};

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

@@ -0,0 +1,12 @@
+export declare type ModelCtor<T> = {
+    new (vals: any, options?: any): T;
+};
+export declare type CollectionCtor<T> = {
+    new (models?: any[], options?: any): T;
+};
+export declare type ViewCtor<T> = {
+    new (options: any): T;
+};
+export declare type ErrorCtor<T> = {
+    new (...args: any[]): T;
+};

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

@@ -0,0 +1,18 @@
+export { AppLink, AppLinkOptions, AppLinkHash, AppLinkHelper, AppLinkUtility } from './AppLink';
+export { BaseApplication as Application } from './BaseApplication';
+export { BaseAppRouter as AppRouter, ExecuteRouteOptions } from './BaseAppRouter';
+export { BaseBehavior as Behavior } from './BaseBehavior';
+export { BaseCollection as Collection } from './BaseCollection';
+export { BaseCollectionView as CollectionView, BaseCollectionViewOptions as CollectionViewOptions, BaseCollectionView as ComponentCollection, BaseCollectionViewOptions as ComponentCollectionOptions, } from './BaseCollectionView';
+export { BaseError as Error, ErrorHelper, SilentError } from './BaseError';
+export { BaseLayoutView as LayoutView, BaseLayoutViewOptions as LayoutViewOptions } from './BaseLayoutView';
+export { BaseNestedModel as NestedModel, BaseNestedModelOptions as NestedModelOptions } from './BaseNestedModel';
+export { BaseService as Service, BaseServiceOptions as ServiceOptions } from './BaseService';
+export { BaseModel as Model } from './BaseModel';
+export { BaseView as View, BaseViewOptions as ViewOptions, BaseComponent as Component, BaseViewOptions as ComponentOptions, RequiredResourceDefinition, RequiredResourceHash } from './BaseView';
+export { EventNames } from './EventNames';
+export { LayoutService, LayoutOptions } from './LayoutService';
+export { Middleware, MiddlewareFunction, MiddlewareNext } from './Middleware';
+export { LocationUtils } from './LocationUtils';
+export { Shell } from './Shell';
+export * from './Types';

package/dist/libs/common/src/backbone/enums/DataServiceErrorType.d.ts

@@ -0,0 +1,8 @@
+export declare enum DataServiceErrorType {
+    Unknown = 0,
+    BadRequest = 1,
+    Unauthorized = 2,
+    Forbidden = 3,
+    NotFound = 4,
+    InternalServer = 5
+}

package/dist/libs/common/src/backbone/enums/HttpStatus.d.ts

@@ -0,0 +1,10 @@
+export declare enum HttpStatus {
+    Ok = 200,
+    NoContent = 204,
+    BadRequest = 400,
+    Unauthorized = 401,
+    Forbidden = 403,
+    NotFound = 404,
+    Conflict = 409,
+    InternalServer = 500
+}

package/dist/libs/common/src/backbone/enums/HttpVerbs.d.ts

@@ -0,0 +1,6 @@
+export declare enum HttpVerbs {
+    GET = "GET",
+    POST = "POST",
+    PUT = "PUT",
+    DELETE = "DELETE"
+}

package/dist/libs/common/src/backbone/errors/DevError.d.ts

@@ -0,0 +1,4 @@
+import { BaseError } from "../core/BaseError";
+export declare class DevError extends BaseError {
+    get name(): string;
+}

package/dist/libs/common/src/backbone/errors/NotImplementedError.d.ts

@@ -0,0 +1,5 @@
+import { BaseError } from "../core/BaseError";
+export declare class NotImplementedError extends BaseError {
+    constructor();
+    get name(): string;
+}

package/dist/libs/common/src/backbone/index.d.ts

@@ -0,0 +1,2 @@
+import * as Core from './core';
+export { Core };

package/dist/libs/common/src/backbone/interfaces/BaseCollectionIdentifier.d.ts

@@ -0,0 +1,18 @@
+import { ObjectHash } from 'backbone';
+export interface BaseCollectionIdentifierOptions<T> {
+    collectionPrefix?: string;
+    id?: string;
+    sort?: T;
+    cursor?: string;
+}
+export declare class BaseCollectionIdentifier<T = {}> {
+    id: string;
+    sort: T;
+    cursor: string;
+    collectionPrefix: string;
+    constructor(options: BaseCollectionIdentifierOptions<T>);
+    protected setData(options: BaseCollectionIdentifierOptions<T>): void;
+    toString(): string;
+    toParams(): ObjectHash;
+    protected getSortTypeParam(): string;
+}

package/dist/libs/common/src/backbone/interfaces/ChainableDataService.d.ts

@@ -0,0 +1,9 @@
+import { DataServiceGetRequest, DataServiceCreateRequest, DataServiceUpdateRequest, DataServiceDeleteRequest } from "./DataServiceRequests";
+export interface ChainableDataService {
+    func(callback: (callback: () => any) => void): ChainableDataService;
+    get<T>(options: DataServiceGetRequest<T>): ChainableDataService;
+    create<T>(options: DataServiceCreateRequest<T>): ChainableDataService;
+    update<T>(options: DataServiceUpdateRequest<T>): ChainableDataService;
+    delete(options: DataServiceDeleteRequest): ChainableDataService;
+    run(): void;
+}

package/dist/libs/common/src/backbone/interfaces/DataCache.d.ts

@@ -0,0 +1,8 @@
+export interface DataCache extends Marionette.Object {
+    has(cacheKey: string): boolean;
+    get(cacheKey: string): any;
+    set(cacheKey: string, value: any): void;
+    getOrSet(cacheKey: string, getter: () => any): any;
+    remove(cacheKey: string): boolean;
+    invalidate(cacheKey: string[], callback?: (cacheKey: string) => void): void;
+}

package/dist/libs/common/src/backbone/interfaces/DataProvider.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="backbone.radio" />
+import { Radio } from 'backbone';
+import { DataServiceError } from "./DataServiceError";
+export interface DataProviderResponseOptions {
+    channel: Radio.Channel;
+    successEvent: string;
+    errorEvent: string;
+}
+export interface DataProvider extends Marionette.Object {
+    parseError(...args: any[]): DataServiceError;
+    create<T>(resource: string, obj: T, options: DataProviderResponseOptions): void;
+    read<T>(resource: string, options: DataProviderResponseOptions): void;
+    update<T>(resource: string, obj: T, options: DataProviderResponseOptions): void;
+    delete(resource: string, options: DataProviderResponseOptions): void;
+}

package/dist/libs/common/src/backbone/interfaces/DataServiceError.d.ts

@@ -0,0 +1,7 @@
+import { DataServiceErrorType } from "../enums/DataServiceErrorType";
+export interface DataServiceError {
+    type: DataServiceErrorType;
+    message: string;
+    code: number;
+}
+export declare const DefaultDataServiceError: DataServiceError;