@clickview/online 0.0.0-rc.0 → 0.0.0-rc.1

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

@@ -0,0 +1,33 @@
+export interface Pagination {
+    cursors: Cursors;
+    limit: number;
+}
+export interface Cursors {
+    next: string;
+    previous: string;
+}
+/**
+ * Do not extend or implement this interface.
+ * It is only exported for use within the BaseDataService.
+ *
+ * By default, the BaseDataService will convert legacy pagination
+ * objects to cursor-based pagination objects.
+ */
+export interface LegacyPagination {
+    page: number;
+    pageSize: number;
+    totalItems: number;
+    totalPages: number;
+}
+/**
+ * Do not extend or implement this interface.
+ * It is only exported for use within the BaseDataService.
+ *
+ * By default, the BaseDataService will convert legacy pagination
+ * objects to cursor-based pagination objects.
+ */
+export interface OffsetPagination {
+    offset: number;
+    pageSize: number;
+    totalItems: number;
+}

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

@@ -0,0 +1,38 @@
+/// <reference types="jquery" />
+/// <reference types="jqueryui" />
+/// <reference types="typeahead" />
+/// <reference types="bootstrap" />
+/// <reference types="dropzone" />
+import { BaseModel } from '../core/BaseModel';
+export interface StickitBinding {
+    observe: string;
+    onGet?: string | ((value: string, options: any) => string);
+    onSet?: string | ((value: string, options: any) => string);
+    getVal?: string | (($el: JQuery, event: Event, options: any) => string);
+    update?: string | (($el: JQuery, value: string, model: BaseModel, options: any) => void);
+    updateModel?: string | boolean | ((value: string, event: Event, options: any) => boolean);
+    updateView?: string | boolean | (() => boolean);
+    afterUpdate?: string | (($el: JQuery, value: string, options: any) => void);
+    updateMethod?: string;
+    escape?: boolean;
+    initialize?: string | (($el: JQuery, model: BaseModel, options: any) => void);
+    destroy?: string | (($el: JQuery, model: BaseModel, options: any) => void);
+    visible?: boolean | ((value: string, options: any) => boolean);
+    visibleFn?: string;
+    events?: string[];
+    name?: string;
+    selectOptions?: {
+        collection: string;
+        labelPath: string;
+        valuePath: string;
+        defaultOption?: string;
+    };
+    setOptions?: {
+        silent?: boolean;
+        validate?: boolean;
+    };
+    classes?: {
+        [className: string]: StickitBinding;
+    };
+    attributes?: StickitBinding[];
+}

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

@@ -0,0 +1,9 @@
+export interface Xhr extends Pick<XMLHttpRequest, 'getResponseHeader' | 'status'> {
+    responseJSON?: any;
+}
+/**
+ * We're making getResponseHeader optional for a slightly nicer API
+ */
+export interface SimulatedXhr extends Omit<Xhr, 'getResponseHeader'> {
+    getResponseHeader?: (name: string) => string;
+}

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

@@ -0,0 +1,9 @@
+export * from './BaseCollectionIdentifier';
+export * from './ChainableDataService';
+export * from './DataCache';
+export * from './DataProvider';
+export * from './DataServiceError';
+export * from './DataServiceRequests';
+export * from './Pagination';
+export * from './StickitBinding';
+export * from './Xhr';

package/dist/libs/common/src/backbone/services/BaseAlertService.d.ts

@@ -0,0 +1,69 @@
+import * as React from 'react';
+import { ObjectHash } from 'backbone';
+import { AppLink } from "../core/AppLink";
+import { BaseView } from "../core/BaseView";
+import { BaseCollectionView } from "../core/BaseCollectionView";
+import { BaseComponent } from "../core/BaseView";
+import { ViewCtor } from "../core/Types";
+import { BaseService, BaseServiceOptions } from "../core/BaseService";
+export declare enum AlertType {
+    Success = "success",
+    Warning = "warning",
+    Fail = "danger",
+    Info = "info"
+}
+export declare enum DefaultAlertHeading {
+    Success = "Success! \uD83D\uDE4C",
+    Warning = "Whoops...",
+    Fail = "Oops...",
+    Info = "FYI"
+}
+export interface BaseAlert {
+    id?: string;
+    type: AlertType;
+    heading: string;
+    message?: string;
+    appLink?: AppLink;
+    appLinkText?: string;
+    appLinkClassName?: string;
+    timeout?: number;
+}
+export interface DefaultAlertCallback {
+    (message?: string, options?: ObjectHash): void;
+}
+export interface BaseAlertOptions {
+    useXHR: boolean;
+}
+declare type View = BaseView | BaseCollectionView | BaseComponent;
+interface AlertProps {
+    alerts: BaseAlert[];
+    removeAlert: (id: string) => void;
+}
+export interface BaseAlertServiceOptions extends BaseServiceOptions {
+    maxAlerts?: number;
+    defaultSuccessAlert: BaseAlert;
+    defaultErrorAlert: BaseAlert;
+    alertViewCtor?: ViewCtor<View> | ((props: AlertProps) => React.ReactElement);
+}
+export declare class BaseAlertService extends BaseService {
+    private options;
+    private alertCollection;
+    constructor(options: BaseAlertServiceOptions);
+    initialize(): void;
+    get name(): string;
+    get defaults(): ObjectHash;
+    /**
+     * As it's not known which application is currently in scope,
+     * we emit a render event to construct the alert collection view
+     * if required. If the current application already has a alert
+     * view rendered, it will simply be ignored.
+     */
+    private showAlerts;
+    removeAlert(id: string): void;
+    createAlert(alertData: BaseAlert): void;
+    clearAllAlerts(): void;
+    success(successAlert: string | BaseAlert | BaseAlertOptions): DefaultAlertCallback;
+    error(errorAlert: string | BaseAlert | BaseAlertOptions): DefaultAlertCallback;
+    private generateUniqueAlertId;
+}
+export {};

package/dist/libs/common/src/backbone/services/BaseDataService.d.ts

@@ -0,0 +1,82 @@
+import { ObjectHash } from 'backbone';
+import { Cursors } from "../interfaces/Pagination";
+import { DataProvider } from "../interfaces/DataProvider";
+import { DataServiceGetRequest, DataServiceCreateRequest, DataServiceUpdateRequest, DataServiceDeleteRequest } from "../interfaces/DataServiceRequests";
+import { DataCache } from "../interfaces/DataCache";
+import { BaseService } from "../core/BaseService";
+import { DataServiceClearAndGetRequest } from "../interfaces/DataServiceRequests";
+import { ChainableDataService } from "../interfaces/ChainableDataService";
+import { BaseAlertService } from './BaseAlertService';
+export interface BaseDataServiceOptions {
+    dataProvider: DataProvider;
+    cache: DataCache;
+    bootstrapData?: ObjectHash;
+    defaultErrorHandler?: (...args: any[]) => any;
+    alertService: BaseAlertService;
+}
+export declare class BaseDataService extends BaseService {
+    private bootstrapData;
+    /**
+     * This is what is used to actually fetch the data.
+     * This can be an AjaxDataProvider, a SignalRDataProvider
+     * or a LocalStorageDataProvider.
+     */
+    private dataProvider;
+    /**
+     * Store fetched data.
+     */
+    private cache;
+    /**
+     * Maintain a hash of dataRequestSignatures to ensure
+     * that we only bind listeners for the first data event
+     * for a given eventprefix.
+     */
+    private dataRequestSignatures;
+    /**
+     * Default errorHandler attached as a callback to the errorEvent fired on the dataProvider's dataChannel.
+     * Will not be bound if an alternative errorHandler is passed in as an option when making a data request
+     * or if false is passed in as the errorHandler option.
+     */
+    private defaultErrorHandler;
+    /**
+     * A reference to the consuming applications alert service.
+     */
+    protected alertService: BaseAlertService;
+    /**
+     * Specify the properties you want to be
+     * taken from `options` and added to the context.
+     */
+    props: string[];
+    /**
+     * The default properties that will be taken
+     * from `options` and added to the context.
+     */
+    private get defaultProps();
+    constructor(options: BaseDataServiceOptions);
+    protected getCursors(cacheKey: string): Cursors;
+    protected clearCacheAndGet<T>(options: DataServiceClearAndGetRequest<T>): void;
+    protected get<T>(options: DataServiceGetRequest<T>): T;
+    protected create<T>(options: DataServiceCreateRequest<T>): void;
+    protected update<T>(options: DataServiceUpdateRequest<T>): void;
+    protected delete(options: DataServiceDeleteRequest): void;
+    private listenToResponse;
+    private cacheData;
+    private processPagination;
+    private formatData;
+    /**
+     * Used to syncronously execute dataService operations.
+     * This will mainly be used if we need to update a model
+     * or collection after an api call.
+     */
+    protected chain(): ChainableDataService;
+    protected invalidateCache(invalidationKeys?: string[]): void;
+    private currentTimestamp;
+    private isExpired;
+    private getEventNames;
+    private getTransportChannel;
+    private getAlertChannel;
+    private setRequestSignature;
+    private hasRequestSignature;
+    private convertOffsetPaginationToCursors;
+    private convertLegacyPaginationToCursors;
+}

package/dist/libs/common/src/backbone/services/EnvironmentVariables.d.ts

@@ -0,0 +1,13 @@
+import { ObjectHash } from 'backbone';
+declare class StaticEnvironmentVariables {
+    private static instance;
+    private variables;
+    constructor();
+    static get Instance(): StaticEnvironmentVariables;
+    get name(): string;
+    get isDevelopment(): boolean;
+    get(name: string): any;
+    setUpVariables(variables: ObjectHash): void;
+}
+export declare const EnvironmentVariables: StaticEnvironmentVariables;
+export {};

package/dist/libs/common/src/backbone/services/InstanceManager.d.ts

@@ -0,0 +1,33 @@
+import { ObjectHash } from 'backbone';
+import { BaseDataServiceOptions, BaseDataService } from "./BaseDataService";
+import { BaseService } from "../core/BaseService";
+import { BaseAlertService } from './BaseAlertService';
+interface DataServiceConstructor {
+    new (options: BaseDataServiceOptions): BaseDataService;
+}
+interface DataServiceInstanceOptions {
+    cache: string;
+    dataProvider: string;
+    bootstrapData?: ObjectHash;
+    defaultErrorHandler?: (...args: any[]) => any;
+    alertService: BaseAlertService;
+}
+declare class StaticInstanceManager extends BaseService {
+    private static instance;
+    private constructors;
+    private destructors;
+    private instances;
+    private singletonInstances;
+    private referenceCounts;
+    private constructor();
+    get name(): string;
+    static get Instance(): StaticInstanceManager;
+    registerDataService(ctor: DataServiceConstructor, options: DataServiceInstanceOptions): this;
+    registerInstance<TInstanceOptions>(ctor: new (...args: any[]) => any, options?: TInstanceOptions): this;
+    registerSingleton(instance: any): this;
+    getInstance<T>(name: string, owner?: Backbone.Events): T;
+    releaseInstance(name: string): this;
+    private validateConstructor;
+}
+export declare const InstanceManager: StaticInstanceManager;
+export {};

package/dist/libs/common/src/backbone/services/LanguageService.d.ts

@@ -0,0 +1,22 @@
+import { ObjectHash } from 'backbone';
+import { BaseService } from "../core/BaseService";
+interface LanguageInterpolationOptions {
+    smartCount?: number;
+    [propName: string]: any;
+}
+interface LanguageConfig {
+    locale: string;
+    phrases: ObjectHash;
+}
+declare class StaticLanguageService extends BaseService {
+    private static instance;
+    private polyglot;
+    private cache;
+    static get Instance(): StaticLanguageService;
+    get name(): string;
+    setConfig(config: LanguageConfig): void;
+    getPhrase(namespace: string, phraseKey: string, options?: LanguageInterpolationOptions): string;
+    encloseNamespace(namespace: string): Function;
+}
+export declare const LanguageService: StaticLanguageService;
+export {};

package/dist/libs/common/src/backbone/services/ScrollService.d.ts

@@ -0,0 +1,19 @@
+import { BaseService } from "../core/BaseService";
+export declare class ScrollService extends BaseService {
+    private preventScroll;
+    initialize(): void;
+    get name(): string;
+    /**
+     * In places of the application where we would not
+     * like an appLink to scroll to the top, call this
+     * method. This will typically be done in an `onBeforeRender`
+     * or 'onClick' handler.
+     */
+    cancelScrollTop(): void;
+    /**
+     * Once the route change has completed, we check to see
+     * if the page should scroll to the top based on the check
+     * done by validateAppLink
+     */
+    scrollTop(): void;
+}

package/dist/libs/common/src/backbone/services/ViewModelService.d.ts

@@ -0,0 +1,68 @@
+import { ObjectHash } from 'backbone';
+import { StorageType } from "../utils/LocalStorageHelper";
+import { BaseService } from "../core/BaseService";
+import { BaseModel } from "../core/BaseModel";
+import { BaseNestedModel } from "../core/BaseNestedModel";
+interface ViewModel extends BaseModel {
+}
+interface ViewNestedModel extends BaseNestedModel {
+}
+declare type ViewData = ViewModel | ViewNestedModel;
+export declare type ViewModelData = ObjectHash | ObjectHash[];
+export interface ViewModelStorage {
+    /**
+     * Auto-persist properties when a change event occurs
+     */
+    persistProps: string | string[];
+    type: StorageType;
+}
+export interface ViewModelOptions<TData> {
+    update?: boolean;
+    ctor?: {
+        new (vals: ViewModelData, options?: ObjectHash): TData;
+    };
+    storage?: ViewModelStorage;
+}
+declare class StaticViewModelService extends BaseService {
+    private static instance;
+    private viewObjects;
+    private constructor();
+    static get Instance(): StaticViewModelService;
+    get name(): string;
+    /**
+     * Update the view model attributes to include defaults, only  where they haven't already
+     * been set previously on the model.
+     *
+     * Note: Checking model instance type is deliberate for Model & NestedModel, otherwise the type system
+     * doesn't know which set() is being invoked. ¯\_(ツ)_/¯
+     */
+    private updateViewModel;
+    get<TData extends ViewData>(key: string, defaultValues?: ViewModelData, options?: ViewModelOptions<TData>): TData;
+    private set;
+    clear(key: string): boolean;
+    /**
+     * Retrieve any data we've previous stored within local storage
+     */
+    private getLocalData;
+    /**
+     * Store changed properties in local storage
+     *
+     * It is not possible to blindly save entire models, instead, specific model properties must be passed
+     * via the storage persistProps. These props will all be set together, even if only one has changed, this
+     * saves us from unncessarily polluting local storage with single props.
+     *
+     * @param key
+     * @param viewData
+     * @param value
+     * @param options
+     */
+    private setLocalData;
+    /**
+     * Setup model listeners to store changes to local storage automatically
+     */
+    private setupChangeListeners;
+    private mergeData;
+    private getStorageHelper;
+}
+export declare const ViewModelService: StaticViewModelService;
+export {};

package/dist/libs/common/src/backbone/services/caches/FifoMemoryCache.d.ts

@@ -0,0 +1,20 @@
+import { DataCache } from "../../interfaces/DataCache";
+import { BaseService } from "../../core/BaseService";
+interface FifoMemoryCacheOptions {
+    size: number;
+}
+export declare class FifoMemoryCache extends BaseService implements DataCache {
+    private size;
+    private cache;
+    private cachedkeys;
+    constructor(options: FifoMemoryCacheOptions);
+    get name(): string;
+    private removeCacheKey;
+    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(cacheKeys: string[], callback?: (cacheKey: string) => void): void;
+}
+export {};

package/dist/libs/common/src/backbone/services/data-providers/AjaxDataProvider.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="jquery" />
+import { ObjectHash } from 'backbone';
+import * as Marionette from 'backbone.marionette';
+import { DataServiceError } from "../../interfaces/DataServiceError";
+import { DataProvider, DataProviderResponseOptions } from "../../interfaces/DataProvider";
+interface MiddlewareCallback {
+    (data: any, textStatus: any, jqXHR: any): any;
+}
+interface AjaxDataProviderOptions {
+    dataServiceErrorMessageMappings: ObjectHash;
+    defaultErrorMessageKey: string;
+}
+export declare class AjaxDataProvider extends Marionette.Object implements DataProvider {
+    private successMiddleware;
+    private errorMiddleware;
+    private dataServiceErrorMessageMappings;
+    private defaultErrorMessageKey;
+    constructor(options?: AjaxDataProviderOptions);
+    get name(): string;
+    private parseUrl;
+    private makeHttps;
+    private base;
+    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;
+    useMiddleware(name: string, callback: MiddlewareCallback): void;
+    useErrorMiddleware(name: string, callback: MiddlewareCallback): void;
+    parseError(jqXHR: JQuery.jqXHR, textStatus: string, errorThrown: any): DataServiceError;
+}
+export {};

package/dist/libs/common/src/backbone/utils/ConcurrencyHelper.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Not really for concurrency 😂
+ * But useful in circumstances where we need to manually wait for
+ * a sequence of callbacks or other resources to execute and don't
+ * want the overhead of promises.
+ */
+export declare class ConcurrencyHelper {
+    private value;
+    constructor(initialValue: number);
+    increment(): void;
+    decrement(): void;
+    getValue(): number;
+}

package/dist/libs/common/src/backbone/utils/DataServiceErrorHelper.d.ts

@@ -0,0 +1,2 @@
+import { ObjectHash } from 'backbone';
+export declare const DataServiceErrorHelper: ObjectHash;

package/dist/libs/common/src/backbone/utils/FunctionHelper.d.ts

@@ -0,0 +1,8 @@
+import * as _ from 'underscore';
+export declare const FunctionHelper: {
+    debounce<T extends Function>(fn: T, wait: number, immediate?: boolean): T & _.Cancelable;
+    throttle<T_1 extends Function>(fn: T_1, wait: number, options?: _.ThrottleSettings): T_1 & _.Cancelable;
+    isFunction(object: any): object is Function;
+    useIdentity<T_2>(): (...args: any[]) => T_2;
+    memoize<T_3 = Function>(fn: T_3, hashFn?: (...args: any[]) => string): T_3;
+};

package/dist/libs/common/src/backbone/utils/LocalStorageHelper.d.ts

@@ -0,0 +1,58 @@
+export declare enum StorageType {
+    LocalStorage = "localStorage",
+    SessionStorage = "sesstionStorage"
+}
+export interface StorageHelper {
+    get(key: string): any;
+    set(key: string, data: any): boolean;
+    remove(key: string): any;
+    length(): number;
+    clear(): any;
+    cacheSet(key: string, data: any, expire?: number): any;
+    cacheGet(key: string): any;
+    cacheExists(key: string): boolean;
+    cacheRemove(key: string): any;
+    cacheFlush(): void;
+}
+interface StaticBaseStorageHelperOptions {
+    type: StorageType;
+}
+declare abstract class StaticBaseStorageHelper implements StorageHelper {
+    private cachePrefix;
+    private expireTime;
+    private hasSupport;
+    private storage;
+    protected type: StorageType;
+    protected constructor(options: StaticBaseStorageHelperOptions);
+    get(key: string): any;
+    set(key: string, data: any): boolean;
+    remove(key: string): void;
+    length(): number;
+    clear(): void;
+    /**
+     * Caching Ops
+     */
+    cacheSet(key: string, data: any, expire?: number): boolean;
+    cacheGet(key: string): any;
+    cacheExists(key: string): boolean;
+    cacheRemove(key: string): void;
+    cacheFlush(): void;
+    /**
+     * Privates
+     */
+    private cacheClean;
+    private isExpired;
+    private getCurrentTime;
+    private hasBrowserSupport;
+}
+declare class StaticLocalStorageHelper extends StaticBaseStorageHelper {
+    protected static instance: StaticLocalStorageHelper;
+    static get Instance(): StaticLocalStorageHelper;
+}
+declare class StaticSessionStorageHelper extends StaticBaseStorageHelper {
+    protected static instance: StaticSessionStorageHelper;
+    static get Instance(): StaticSessionStorageHelper;
+}
+export declare const LocalStorageHelper: StaticLocalStorageHelper;
+export declare const SessionStorageHelper: StaticSessionStorageHelper;
+export {};

package/dist/libs/common/src/backbone/utils/UrlHelper.d.ts

@@ -0,0 +1,13 @@
+import { ObjectHash } from 'backbone';
+interface FilterParams {
+    limit?: number;
+    cursor?: string;
+    before?: string;
+}
+export declare const UrlHelper: {
+    urlBuilder(base: string, queryStringObj: ObjectHash): string;
+    buildFilter(params: FilterParams): string;
+    makeHttps(url: string): string;
+    safeUrlConcat(baseUrl: string, path: string): string;
+};
+export {};

package/dist/libs/common/src/backbone/utils/UserAgentHelper.d.ts

@@ -0,0 +1,7 @@
+import { ObjectHash } from 'backbone';
+export declare const UserAgentHelper: {
+    getDeviceType(): string;
+    getOperatingSystem(): ObjectHash;
+    getBrowser(): ObjectHash;
+    isTouchScreen(): boolean;
+};

package/dist/libs/common/src/react/components/BackboneViewWrapper.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { BaseView } from "../../backbone/core/BaseView";
+import { HashObject } from "../interfaces/HashObject";
+interface BackboneViewWrapperProps {
+    view: new (options: HashObject) => BaseView;
+    options?: HashObject;
+    className?: string;
+}
+export declare function BackboneViewWrapper({ view, options, className }: BackboneViewWrapperProps): JSX.Element;
+export {};

package/dist/libs/common/src/react/core/ReactApplication.d.ts

@@ -0,0 +1,9 @@
+import { ObjectHash } from 'backbone';
+import { BaseApplication } from "../../backbone/core/BaseApplication";
+import { LayoutOptions } from "../../backbone/core/LayoutService";
+import { ReactLayoutView, ReactLayoutViewOptions } from './ReactLayoutView';
+export declare class ReactApplication extends BaseApplication {
+    protected layout: ReactLayoutView;
+    protected layoutOptions: LayoutOptions<ReactLayoutViewOptions>;
+    protected onShowAlert(options: ObjectHash): void;
+}

package/dist/libs/common/src/react/core/ReactLayoutView.d.ts

@@ -0,0 +1,13 @@
+import * as React from 'react';
+import { BaseLayoutViewOptions, BaseLayoutView } from "../../backbone/core/BaseLayoutView";
+export interface ReactLayoutViewOptions extends BaseLayoutViewOptions {
+    alertRegion?: string;
+}
+export declare class ReactLayoutView extends BaseLayoutView {
+    protected options: ReactLayoutViewOptions;
+    private isReactComponent;
+    showChildView(regionName: string, component: any): void;
+    private showChildReactComponent;
+    private renderChildReactComponent;
+    protected wrapWithStore(child: React.ReactElement): React.ReactElement;
+}

package/dist/libs/common/src/react/flight/FlightHelpers.d.ts

@@ -0,0 +1,13 @@
+import { ApplicationState } from "../interfaces/ApplicationState";
+import { Request, Response, Dispatch } from './interfaces';
+export declare function emptyResponse<T>(): Response<T>;
+export declare function getResponse<T>(state: ApplicationState, key: string): Response<T>;
+export declare function getFetch(dispatch: Dispatch, request: Request): () => void;
+export declare function fetch(dispatch: Dispatch, request: Request): void;
+export declare function useGetFetch(request: Request): () => void;
+interface GetResponseOptions {
+    optimize: boolean;
+}
+export declare function useGetResponse<T>(key: string, options?: GetResponseOptions): Response<T>;
+export declare function useBasicFetch<T>(request: Request, options?: GetResponseOptions): Response<T>;
+export {};

package/dist/libs/common/src/react/flight/FlightMiddleware.d.ts

@@ -0,0 +1,11 @@
+import { Dispatch, Middleware, AnyAction } from 'redux';
+import { HashObject } from "../interfaces/HashObject";
+import { ApplicationState } from "../interfaces/ApplicationState";
+import { HttpRequest } from './interfaces';
+interface MiddlewareOptions {
+    fetchData: HttpRequest;
+    bootstrappedData?: HashObject;
+    defaultExpiryTime?: number;
+}
+export declare function createMiddleware(options: MiddlewareOptions): Middleware<{}, ApplicationState, Dispatch<AnyAction>>;
+export {};

package/dist/libs/common/src/react/flight/FlightReducer.d.ts

@@ -0,0 +1,2 @@
+import { FlightState, Action } from './interfaces';
+export declare function FlightReducer(state: FlightState, action: Action): FlightState;

package/dist/libs/common/src/react/flight/FlightSimulator.d.ts

@@ -0,0 +1,24 @@
+import { HashObject } from "../interfaces/HashObject";
+/**
+ * This is a very basic implementation and we almost definitely will
+ * need to extend upon this, so please don't be afraid to add to it.
+ */
+export declare const Simulator: {
+    getAll(name: string, init?: HashObject<any>[]): HashObject<any>[];
+    get(name: string, id: string): HashObject<any>;
+    create(name: string, item: HashObject<any>): HashObject<any>;
+    update(name: string, item: HashObject<any>): HashObject<any>;
+    delete(name: string, ids: string | string[]): void;
+    /**
+     *
+     * @param objectName - the name your object can be found under in local storage (e.g. `classrooms`).
+     * @param objectId - the id of the object you want to associate something to.
+     * @param assocName - the field name of your assoc, which will go on your object (e.g. `students`).
+     * @param flightSimName - the name your assoc objects will be created under (e.g. `school:students`).
+     * @param assocObject - the object you're creating and associating.
+     *
+     * Having a difficult time coming up with good param names here. Feel free to update, ty
+     */
+    assoc(objectName: string, objectId: string, assocName: string, flightSimName: string, assocObjects: any): any;
+    dissoc(objectName: string, objectId: string, assocName: string, ids: string | string[]): HashObject<any>[];
+};