@mello-labs/api-tools/index.js

import { ChangeDetectionStrategy, Component, Injectable, Input, NgModule } from '@angular/core';
import { CommonModule } from '@angular/common';
import { NgbModule } from '@ng-bootstrap/ng-bootstrap';
import { HttpClient } from '@angular/common/http';
import { Router } from '@angular/router';
import { Store } from '@ngrx/store';
import { Observable } from 'rxjs';
import 'rxjs/add/operator/share';

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * <api-error *ngIf="state.modifyError" [error]="state.modifyError"></api-error>
 * @record
 */

var ApiErrorComponent = (function () {
    function ApiErrorComponent() {
        /**
         * An error response passed by the API or the application
         */
        this.message = 'An unknown error occured';
        /**
         * Whether or not to show all the error details passed by the API. If false will only show the error.msg
         */
        this.showDetails = true;
        /**
         * API response keys to ignore
         */
        this.ignoreProps = ['headers', 'errorMsg'];
    }
    /**
     * @return {?}
     */
    ApiErrorComponent.prototype.ngOnInit = /**
     * @return {?}
     */
    function () {
    };
    /**
     * @return {?}
     */
    ApiErrorComponent.prototype.ngOnChanges = /**
     * @return {?}
     */
    function () {
        if (this.error) {
            this.createError();
        }
    };
    /**
     * @return {?}
     */
    ApiErrorComponent.prototype.createError = /**
     * @return {?}
     */
    function () {
        var _this = this;
        // Create an array of keys to loop through and filter out anything on the ignore list
        this.errorOfKeys = Object.keys(this.error).filter(function (key) {
            if (_this.ignoreProps.indexOf(key) == -1) {
                return key;
            }
        });
        // If errorMsg was not set and an error message was found in the server response, use the server message instead
        //if (!this.errorMessage && this.error && this.error._body && this.error._body.message) {
        //	this.errorMessage = JSON.parse(this.error._body).message;
        //}
        // If 404
        if (!this.errorMessage && this.error.status == 404) {
            this.errorMessage = '404 Error. Unable to connect to the Api.';
        }
        else if (!this.errorMessage) {
            this.errorMessage = 'Unknown error. Please see error details for more information.';
        }
    };
    /**
     * Hide alert message
     * @return {?}
     */
    ApiErrorComponent.prototype.closeAlert = /**
     * Hide alert message
     * @return {?}
     */
    function () {
        this.error = null;
    };
    ApiErrorComponent.decorators = [
        { type: Component, args: [{
                    selector: 'error',
                    template: "<div class=\"alert alert-danger icon p-2 pl-3 pr-3\" *ngIf=\"error\"> <button type=\"button\" class=\"close\" aria-label=\"Close\" (click)=\"closeAlert()\"> <span aria-hidden=\"true\">&times;</span> </button> <i class=\"fa fa-alert\"></i>  {{message}} <ng-container *ngIf=\"showDetails && errorOfKeys.length\"> <hr class=\"mt-2 mb-2\"/> <ngb-accordion #acc=\"ngbAccordion\" class=\"accordion-inline\"> <ngb-panel> <ng-template ngbPanelTitle> <span>See error details:</span> </ng-template> <ng-template ngbPanelContent> <table class=\"table table-sm\"> <tbody> <tr *ngFor=\"let key of errorOfKeys\"> <td><strong>{{key}}</strong></td> <td style=\"word-break: break-all;\">{{error[key]}}</td> </tr> </tbody> </table> </ng-template> </ngb-panel> </ngb-accordion> </ng-container> </div> ",
                    changeDetection: ChangeDetectionStrategy.OnPush
                },] },
    ];
    /** @nocollapse */
    ApiErrorComponent.ctorParameters = function () { return []; };
    ApiErrorComponent.propDecorators = {
        "error": [{ type: Input },],
        "message": [{ type: Input },],
        "showDetails": [{ type: Input },],
    };
    return ApiErrorComponent;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * <api-state [state]="conditions.state" ignore="modifying" [hover]="true" *ngIf="conditionsState$ | async as conditions">
 * Transcluded content here
 * </api-state>
 * @record
 */

var ApiStateComponent = (function () {
    function ApiStateComponent() {
        /**
         * Should the success/loading/error messages appear inline or as a toaster pop in the lower right of the screen
         */
        this.toaster = true;
        /**
         * Should the success message be visible or not
         */
        this.showSuccess = true;
        /**
         * Set this flag after the initial load of data
         */
        this.initialLoadComplete = false;
        /**
         * Toggle the visibility of the success message
         */
        this.successVisible = true;
    }
    /**
     * @return {?}
     */
    ApiStateComponent.prototype.ngOnInit = /**
     * @return {?}
     */
    function () { };
    /**
     * @return {?}
     */
    ApiStateComponent.prototype.ngOnChanges = /**
     * @return {?}
     */
    function () {
        if (this.state.loaded) {
            this.initialLoadComplete = true;
        }
        this.successVisible = true;
    };
    /**
     * Close the alert and clear success state
     * @return {?}
     */
    ApiStateComponent.prototype.closeSuccess = /**
     * Close the alert and clear success state
     * @return {?}
     */
    function () {
        this.successVisible = false;
        //this.api.resetSuccess();
    };
    /**
     * @return {?}
     */
    ApiStateComponent.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () { };
    ApiStateComponent.decorators = [
        { type: Component, args: [{
                    selector: 'api-state',
                    template: "<ng-container *ngIf=\"state\"> <!--GET/loading --> <div *ngIf=\"state.loading && !initialLoadComplete\" class=\"p-3\"><i class=\"fa fa-spinner fa-spin\"></i> Loading data from server...</div> <div *ngIf=\"state.loading && initialLoadComplete\" class=\"p-3\" [ngClass]=\"{'toaster': toaster }\"> <i class=\"fa fa-spinner fa-spin\" [ngClass]=\"{'toaster-lg': toaster }\"></i> <ng-container *ngIf=\"!toaster\"> Refreshing data from server... </ng-container> </div> <error *ngIf=\"state.loadError\" [error]=\"state.loadError\" [ngClass]=\"{'toaster': toaster && initialLoadComplete }\"></error> <!-- Create/Update/Delete --> <div *ngIf=\"state.modified && showSuccess && successVisible\" class=\"alert alert-success icon p-2\" [ngClass]=\"{'toaster': toaster }\"> <button type=\"button\" class=\"close\" aria-label=\"Close\" (click)=\"closeSuccess()\" *ngIf=\"!toaster\"> <span aria-hidden=\"true\">&times;</span> </button> Success! </div> <error *ngIf=\"state.modifyError\" [error]=\"state.modifyError\" [ngClass]=\"{'toaster': toaster }\"></error> <!-- Content --> <ng-container *ngIf=\"state.loaded || (initialLoadComplete && toaster)\"> <ng-content></ng-content> </ng-container> </ng-container> ",
                    styles: ["\n        .toaster{position:fixed;bottom:10px;right:20px;z-index:1000;}\n        .toaster-lg{font-size:3rem;}\n    "],
                    changeDetection: ChangeDetectionStrategy.OnPush
                },] },
    ];
    /** @nocollapse */
    ApiStateComponent.ctorParameters = function () { return []; };
    ApiStateComponent.propDecorators = {
        "state": [{ type: Input },],
        "toaster": [{ type: Input },],
        "showSuccess": [{ type: Input },],
    };
    return ApiStateComponent;
}());

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/** @enum {string} */
var ApiActions = {
    RESET: 'RESET',
    STATE_CHANGE: 'STATE_CHANGE',
    RESET_ERRORS: 'RESET_ERRORS',
    RESET_SUCCESS: 'RESET_SUCCESS',
    GET_COMPLETE: 'GET_COMPLETE',
    POST_COMPLETE: 'POST_COMPLETE',
    PUT_COMPLETE: 'PUT_COMPLETE',
    DELETE_COMPLETE: 'DELETE_COMPLETE',
};

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var ApiHttpService = (function () {
    function ApiHttpService(httpSvc, storeSvc, routerSvc) {
        this.httpSvc = httpSvc;
        this.storeSvc = storeSvc;
        this.routerSvc = routerSvc;
        /**
         * Hold GET requests from an API using the URL as a primary key
         */
        this.cache = {};
    }
    /**
     * Make a GET request with simple caching
     * @template T
     * @param {?} url - The URL location of the webapi
     * @param {?=} updateCache - Refresh the version in the cache
     * @return {?}
     */
    ApiHttpService.prototype.get = /**
     * Make a GET request with simple caching
     * @template T
     * @param {?} url - The URL location of the webapi
     * @param {?=} updateCache - Refresh the version in the cache
     * @return {?}
     */
    function (url, updateCache) {
        if (updateCache === void 0) { updateCache = false; }
        // If this request is not in the cache or updateCache was requested (default behavior), load content into cache
        if (!this.cache[url] || updateCache) {
            this.cache[url] = this.httpSvc.get(url)
                .publishReplay(1)
                .refCount();
        }
        return this.cache[url];
    };
    /**
    * Make a GET request and load the results into the store
    * @param url - The URL location of the webapi
    * @param id - The location to put the results in the store
    * @param updateCache - Refresh the version in the cache
    */
    /**
     * Make a GET request and load the results into the store
     * @template T
     * @param {?} url - The URL location of the webapi
     * @param {?=} apiMap
     * @param {?=} updateCache - Refresh the version in the cache
     * @return {?}
     */
    ApiHttpService.prototype.getStore = /**
     * Make a GET request and load the results into the store
     * @template T
     * @param {?} url - The URL location of the webapi
     * @param {?=} apiMap
     * @param {?=} updateCache - Refresh the version in the cache
     * @return {?}
     */
    function (url, apiMap, updateCache) {
        var _this = this;
        if (updateCache === void 0) { updateCache = false; }
        // If this request is not in the cache or updateCache was requested (default behavior), load content into cache
        if (this.cache[url] == null || updateCache) {
            // Set status to waiting
            var /** @type {?} */ newState_1 = { loading: true, loadError: false, loaded: false };
            this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState_1 } }); // Update store with new state
            this.cache[url] = this.httpSvc.get(url)
                .share()
                .map(function (res) {
                //Set status to success
                //Set status to success
                newState_1 = { loading: false, loadError: false, loaded: true };
                _this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState_1 } }); // Update store with new state
                var /** @type {?} */ data = apiMap.map ? apiMap.map(res) : res;
                _this.storeSvc.dispatch({ type: ApiActions.GET_COMPLETE, payload: { apiMap: apiMap, data: data } }); // Load content into store
                return data;
            }).catch(function (error) {
                if (error.status == 401 || error.status == 403) {
                    error.errorMsg = 'Please log in ';
                    return _this.endSession(error);
                }
                else {
                    newState_1 = { loading: false, loadError: error, loaded: false };
                    _this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState_1 } }); // Update store with new state
                    return Observable.throw(error);
                }
            });
            return this.cache[url];
        }
        else {
            return Observable.of(/** @type {?} */ (true));
        }
        //return this.cache[url];
    };
    /**
    * Make a POST request and load the results into the store
    * @param url - The URL location of the endpoint
    * @param id - The location to put the results in the store
    * @param data - The data to pass to the server
    */
    /**
     * Make a POST request and load the results into the store
     * @template T
     * @param {?} url - The URL location of the endpoint
     * @param {?} apiMap
     * @param {?} data - The data to pass to the server
     * @return {?}
     */
    ApiHttpService.prototype.postStore = /**
     * Make a POST request and load the results into the store
     * @template T
     * @param {?} url - The URL location of the endpoint
     * @param {?} apiMap
     * @param {?} data - The data to pass to the server
     * @return {?}
     */
    function (url, apiMap, data) {
        var _this = this;
        // Set status to modifying
        var /** @type {?} */ newState = { modifying: true, modified: false, modifyError: false };
        this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState } }); // Update store with new state
        return this.httpSvc.post(url, data)
            .map(function (res) {
            // Set status to complete
            var /** @type {?} */ newState = { modifying: false, modified: true, modifyError: false };
            _this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState } }); // Update store with new state
            // Check if the response has a payload or not
            var /** @type {?} */ dataNew = res ? res : data;
            _this.storeSvc.dispatch({ type: ApiActions.POST_COMPLETE, payload: { apiMap: apiMap, data: dataNew } }); // Load content into store
            return Observable.of(res);
        }).catch(function (error) {
            if (error.status == 401 || error.status == 403) {
                error.errorMsg = 'Please log in ';
                return _this.endSession(error);
            }
            else {
                error.errorMsg = 'Unable to create ' + apiMap.storeProperty;
                // Set status to error
                var /** @type {?} */ newState_2 = { modifying: false, modified: false, modifyError: error };
                _this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState_2 } }); // Update store with new state
                return Observable.throw(error);
            }
        });
    }; // end post
    /**
    * Make a PUT request
    * @param url - The URL location of the webapi
    * @param data - The data to pass to the server
    */
    /**
     * Make a PUT request
     * @template T
     * @param {?} url - The URL location of the webapi
     * @param {?} apiMap
     * @param {?} data - The data to pass to the server
     * @return {?}
     */
    ApiHttpService.prototype.putStore = /**
     * Make a PUT request
     * @template T
     * @param {?} url - The URL location of the webapi
     * @param {?} apiMap
     * @param {?} data - The data to pass to the server
     * @return {?}
     */
    function (url, apiMap, data) {
        var _this = this;
        //console.warn('Putting ', url, apiMap, data);
        // Set status to modifying
        var /** @type {?} */ newState = { modifying: true, modified: false, modifyError: false };
        this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState } }); // Update store with new state
        return this.httpSvc.put(url, data)
            .map(function (res) {
            // Set status to complete
            var /** @type {?} */ newState = { modifying: false, modified: true, modifyError: false };
            _this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState } }); // Update store with new state
            // Check if the response has a payload or not, if not then this is an upSert
            var /** @type {?} */ dataNew = res ? res : data;
            _this.storeSvc.dispatch({ type: ApiActions.PUT_COMPLETE, payload: { apiMap: apiMap, data: dataNew } }); // Load content into store
            return Observable.of(res);
        }).catch(function (error) {
            console.warn('PUT Error, handle 403 unauth errors here', error);
            if (error.status == 401 || error.status == 403) {
                error.errorMsg = 'Please log in ';
                return _this.endSession(error);
            }
            else {
                error.errorMsg = 'Unable to update ' + apiMap.storeProperty;
                // Set status to error
                var /** @type {?} */ newState_3 = { modifying: false, modified: false, modifyError: error };
                _this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState_3 } }); // Update store with new state
                return Observable.throw(error);
            }
        });
    }; // end put
    /**
    * Make a DELETE request
    * @param url - The URL location of the webapi
    * @param apiMap - The ApiMap object
    * @param element - The element or collection of elements being deleted
    */
    /**
     * Make a DELETE request
     * @template T
     * @param {?} url - The URL location of the webapi
     * @param {?} apiMap - The ApiMap object
     * @param {?} element - The element or collection of elements being deleted
     * @return {?}
     */
    ApiHttpService.prototype.deleteStore = /**
     * Make a DELETE request
     * @template T
     * @param {?} url - The URL location of the webapi
     * @param {?} apiMap - The ApiMap object
     * @param {?} element - The element or collection of elements being deleted
     * @return {?}
     */
    function (url, apiMap, element) {
        var _this = this;
        // Set status to modifying
        var /** @type {?} */ newState = { modifying: true, modified: false, modifyError: false };
        this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState } }); // Update store with new state
        // Delete doesn't natively support a body so this adds it in for deleting collections or other uncommon operations
        return this.httpSvc.request('delete', url, { body: element })
            .map(function (res) {
            // Set status to complete
            var /** @type {?} */ newState = { modifying: false, modified: true, modifyError: false };
            _this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState } }); // Update store with new state
            _this.storeSvc.dispatch({ type: ApiActions.DELETE_COMPLETE, payload: { apiMap: apiMap, data: element } }); // Load content into store
            return Observable.of(res);
        }).catch(function (error) {
            console.warn('DELETE Error, handle 403 unauth errors here', error);
            if (error.status == 401 || error.status == 403) {
                error.errorMsg = 'Please log in ';
                return _this.endSession(error);
            }
            else {
                error.errorMsg = 'Unable to delete ' + apiMap.storeProperty;
                // Set status to error
                var /** @type {?} */ newState_4 = { modifying: false, modified: false, modifyError: error };
                _this.storeSvc.dispatch({ type: ApiActions.STATE_CHANGE, payload: { apiMap: apiMap, newState: newState_4 } }); // Update store with new state
                return Observable.throw(error);
            }
        });
    }; // end post
    /**
     * When an authentication check fails
     * @param {?} error
     * @return {?}
     */
    ApiHttpService.prototype.endSession = /**
     * When an authentication check fails
     * @param {?} error
     * @return {?}
     */
    function (error) {
        this.cache = {};
        window.localStorage.removeItem('token');
        window.sessionStorage.clear();
        this.routerSvc.navigate(['/login'], { queryParams: { session: 'expired' } });
        return Observable.throw(error);
    };
    ApiHttpService.decorators = [
        { type: Injectable },
    ];
    /** @nocollapse */
    ApiHttpService.ctorParameters = function () { return [
        { type: HttpClient, },
        { type: Store, },
        { type: Router, },
    ]; };
    return ApiHttpService;
}());

var __assign = (undefined && undefined.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
/**
 * @param {?=} state
 * @param {?=} __1
 * @return {?}
 */
function ApiReducer(state, _a) {
    if (state === void 0) { state = {}; }
    var type = _a.type, payload = _a.payload;
    //console.log('STORE REDUCER:', type, payload);
    var /** @type {?} */ srcData;
    switch (type) {
        // Reset State
        case ApiActions.RESET:
            return {};
        // Get response
        case ApiActions.GET_COMPLETE:
            // If response is an array
            if (Array.isArray(payload.data)) {
                state[payload.apiMap.storeProperty] = payload.data.slice();
            }
            else if (typeof payload.data == 'object') {
                state[payload.apiMap.storeProperty] = __assign({}, payload.data);
            }
            else if (typeof payload.data == 'string') {
                state[payload.apiMap.storeProperty][payload.apiMap.data] = payload.data;
            }
            else {
                console.error('GET_COMPLETE was not an object/array/string, please write a condition for this in the api.reducer', type, payload);
            }
            break;
        // Post response
        case ApiActions.POST_COMPLETE:
            // If a map and mapSrc element are present, grab the unfiltered content from the mapSrc property. Otherwise just get data straight out of the store
            srcData = (payload.apiMap.map && payload.apiMap.mapSrc) ? state[payload.apiMap.storeProperty][payload.apiMap.mapSrc] : state[payload.apiMap.storeProperty];
            // If destination is an array and response is an array, concat with new data up front
            if (Array.isArray(srcData) && Array.isArray(payload.data)) {
                srcData = payload.data.concat(srcData);
            }
            else if (srcData && typeof payload.data === 'object') {
                /* TODO: Figure out how to do upserts. Maybe pass an additional prop
                                if (payload.data[payload.apiMap.uniqueId]) {
                
                                } else {
                                    srcData = [payload.data, ...srcData];
                                }
                                */
                srcData = [payload.data].concat(srcData);
            }
            else if (typeof srcData === 'object' && typeof payload.data === 'object') {
                srcData = __assign({}, payload.data);
            }
            else {
                console.error('POST_COMPLETE was not an object or an array, please write a condition for this in the api.reducer');
            }
            // If map and mapSrc are present, remap the data before returning it to the store, otherwise just return the store data
            state[payload.apiMap.storeProperty] = (payload.apiMap.map && payload.apiMap.mapSrc) ? payload.apiMap.map(srcData) : srcData;
            break;
        // PUT response
        case ApiActions.PUT_COMPLETE:
            //console.warn('PUT_COMPLETE', payload)
            // If a map and mapSrc element are present, grab the unfiltered content from the mapSrc property. Otherwise just get data straight out of the store
            srcData = (payload.apiMap.map && payload.apiMap.mapSrc) ? state[payload.apiMap.storeProperty][payload.apiMap.mapSrc] : state[payload.apiMap.storeProperty];
            // If destination is an array and response is an array, loop through the destination array and update all entries with the new ones
            if (Array.isArray(srcData) && Array.isArray(payload.data)) {
                //console.warn('Array into array')
                for (var /** @type {?} */ i = 0; i < payload.data.length; i++) {
                    // Loop through payload
                    for (var /** @type {?} */ j = 0; j < srcData.length; j++) {
                        // Loop through response object
                        if (payload.data[i][payload.apiMap.uniqueId] == srcData[j][payload.apiMap.uniqueId]) {
                            srcData[j] = payload.data[i];
                            srcData = srcData.slice();
                            j = srcData.length + 1; // Cheap way to break the second for loop
                        }
                    }
                }
            }
            else if (Array.isArray(srcData) && typeof payload.data === 'object') {
                //console.warn('Object into array')
                // Loop through the destination array and when the unique ID is found, update the entry
                for (var /** @type {?} */ i = 0; i < srcData.length; i++) {
                    if (srcData[i][payload.apiMap.uniqueId] == payload.data[payload.apiMap.uniqueId]) {
                        srcData[i] = payload.data;
                        srcData = srcData.slice();
                        break;
                    }
                }
            }
            else if (typeof srcData === 'object' && typeof payload.data === 'object') {
                //console.warn('Replace object')
                srcData = __assign({}, payload.data);
            }
            else {
                console.error('PUT_COMPLETE was not an object or an array, please write a condition for this in the api.reducer');
            }
            // If map and mapSrc are present, remap the data before returning it to the store, otherwise just return the store data
            state[payload.apiMap.storeProperty] = (payload.apiMap.map && payload.apiMap.mapSrc) ? payload.apiMap.map(srcData) : srcData;
            break;
        // Delete response
        case ApiActions.DELETE_COMPLETE:
            //console.warn('Delete Reducer ', payload)
            // If a map and mapSrc element are present, grab the unfiltered content from the mapSrc property. Otherwise just get data straight out of the store
            srcData = (payload.apiMap.map && payload.apiMap.mapSrc) ? state[payload.apiMap.storeProperty][payload.apiMap.mapSrc] : state[payload.apiMap.storeProperty];
            // If destination is an array and response is an array, loop through the destination array and update all entries with the new ones
            if (Array.isArray(srcData) && Array.isArray(payload.data)) {
                //console.warn('Delete array from array')
                for (var /** @type {?} */ i = 0; i < payload.data.length; i++) {
                    // Loop through payload
                    for (var /** @type {?} */ j = 0; j < srcData.length; j++) {
                        // Loop through response object
                        //console.warn('Looping 2', payload.data[i][payload.apiMap.uniqueId], srcData[j][payload.apiMap.uniqueId]);
                        if (payload.data[i][payload.apiMap.uniqueId] == srcData[j][payload.apiMap.uniqueId]) {
                            srcData.splice(j, 1);
                            srcData = srcData.slice();
                            j = srcData.length + 1; // Cheap way to break the second for loop
                        }
                    }
                }
            }
            else if (Array.isArray(srcData)) {
                // If this delete operation only has a single unique ID
                if (typeof payload.apiMap.uniqueId == 'string') {
                    srcData = srcData.filter(function (element) { return element[payload.apiMap.uniqueId] != payload.data[payload.apiMap.uniqueId]; });
                }
                else if (payload.apiMap.uniqueId.length) {
                    srcData = srcData.filter(function (element, index) {
                        // Loop through the uniqueID's list. If the number of unique ID's match what is in the API Map then relete it
                        var /** @type {?} */ hasMatches = 0;
                        payload.apiMap.uniqueId.forEach(function (id) {
                            if (element[id] == payload.data[id]) {
                                hasMatches++;
                            }
                        });
                        return hasMatches != payload.apiMap.uniqueId.length ? true : false;
                    });
                }
            }
            else if (typeof srcData === 'object' && typeof payload.data === 'object') {
                delete srcData[payload.data];
            }
            else {
                console.error('DELETE_COMPLETE was not an object or an array, please write a condition for this in the api.reducer');
            }
            // If map and mapSrc are present, remap the data before returning it to the store, otherwise just return the store data
            state[payload.apiMap.storeProperty] = (payload.apiMap.map && payload.apiMap.mapSrc) ? payload.apiMap.map(srcData) : srcData;
            break;
    }
    return state;
}

var __assign$1 = (undefined && undefined.__assign) || Object.assign || function(t) {
    for (var s, i = 1, n = arguments.length; i < n; i++) {
        s = arguments[i];
        for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
            t[p] = s[p];
    }
    return t;
};
/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var ApiStatusStore = {};
/**
 * @param {?=} state
 * @param {?=} __1
 * @return {?}
 */
function ApiStatusReducer(state, _a) {
    if (state === void 0) { state = ApiStatusStore; }
    var type = _a.type, payload = _a.payload;
    //console.log('STORE REDUCER: ApiStatusReducer', type, payload);
    switch (type) {
        // Reset State
        case ApiActions.RESET:
            return ApiStatusStore;
        // State change
        case ApiActions.STATE_CHANGE:
            state[payload.apiMap.storeProperty] = __assign$1({}, state[payload.apiMap.storeProperty], payload.newState);
            break;
        // Reset API errors
        case ApiActions.RESET_ERRORS:
            Object.keys(state).forEach(function (key) {
                state[key].modifyError = false;
                state[key] = __assign$1({}, state[key]);
            });
            break;
        // Reset API errors
        case ApiActions.RESET_SUCCESS:
            Object.keys(state).forEach(function (key) {
                state[key].modified = false;
                state[key] = __assign$1({}, state[key]);
            });
            break;
    }
    return state;
}

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes} checked by tsc
 */
var ApiToolsModule = (function () {
    function ApiToolsModule() {
    }
    /**
     * @return {?}
     */
    ApiToolsModule.forRoot = /**
     * @return {?}
     */
    function () {
        return {
            ngModule: ApiToolsModule,
            providers: []
        };
    };
    ApiToolsModule.decorators = [
        { type: NgModule, args: [{
                    imports: [
                        CommonModule,
                        NgbModule.forRoot()
                    ],
                    declarations: [
                        ApiErrorComponent,
                        ApiStateComponent
                    ],
                    exports: [
                        ApiErrorComponent,
                        ApiStateComponent
                    ]
                },] },
    ];
    /** @nocollapse */
    ApiToolsModule.ctorParameters = function () { return []; };
    return ApiToolsModule;
}());

export { ApiToolsModule, ApiErrorComponent, ApiStateComponent, ApiActions, ApiHttpService, ApiReducer, ApiStatusReducer };