@crnk/angular-ngrx/binding/crnk.binding.utils.js

Angular helper library for ngrx-json-api and crnk:

var __extends = (this && this.__extends) || (function () {
    var extendStatics = Object.setPrototypeOf ||
        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
import { Injectable } from '@angular/core';
import 'rxjs/add/operator/zip';
import 'rxjs/add/operator/do';
import 'rxjs/add/operator/debounceTime';
import 'rxjs/add/operator/distinct';
import 'rxjs/add/operator/switch';
import 'rxjs/add/operator/filter';
import { NgrxJsonApiStore, NgrxJsonApiStoreData, Query, QueryParams, QueryResult, ResourceError, ResourceIdentifier, StoreResource } from 'ngrx-json-api';
import * as _ from 'lodash';
import { Observable } from 'rxjs/Observable';
import { Store } from '@ngrx/store';
import { Expression } from '../expression';
export var getNgrxJsonApiStore$ = function (state$) {
    return state$.select('NgrxJsonApi').map(function (it) { return it ? it['api'] : undefined; });
};
export var getStoreData$ = function (state$) {
    return state$.select('data');
};
export var waitWhileLoading = function () {
    return function (result$) {
        return result$.filter(function (it) { return !it.loading; });
    };
};
export var assumeNoError = function () {
    return function (result$) {
        return result$.do(function (it) {
            if (!_.isEmpty(it.errors)) {
                throw new QueryError(it.errors);
            }
        });
    };
};
export var applyQueryParams = function (baseQuery, additionalParams) {
    if (!baseQuery.params) {
        baseQuery.params = {};
    }
    baseQuery.params.limit = additionalParams.limit;
    baseQuery.params.offset = additionalParams.offset;
    if (!_.isEmpty(additionalParams.include)) {
        // combine inclusions
        if (!baseQuery.params.include) {
            baseQuery.params.include = [];
        }
        baseQuery.params.include = _.union(baseQuery.params.include, additionalParams.include);
    }
    if (!_.isEmpty(additionalParams.fields)) {
        // combine fields
        if (!baseQuery.params.fields) {
            baseQuery.params.fields = [];
        }
        baseQuery.params.fields = _.union(baseQuery.params.fields, additionalParams.fields);
    }
    if (additionalParams.sorting != null) {
        // replace sort (additionalParams.sorting != null check to allow to clear sorting)
        // unlikely to be a use case to merge sorting params
        if (!baseQuery.params.sorting) {
            baseQuery.params.sorting = [];
        }
        baseQuery.params.sorting = additionalParams.sorting.slice();
    }
    if (!_.isEmpty(additionalParams.filtering)) {
        // combine filters by replacing duplicates on same attribute
        if (!baseQuery.params.filtering) {
            baseQuery.params.filtering = [];
        }
        var filterMap = _.keyBy(baseQuery.params.filtering, 'path');
        var addFilterMap = _.keyBy(additionalParams.filtering, 'path');
        Object.assign(filterMap, addFilterMap);
        baseQuery.params.filtering = _.values(filterMap);
    }
};
export var toQueryPath = function (attributePath) {
    var strAttributePath = attributePath.toString();
    var pathElements = strAttributePath.split('.');
    var searchPath = [];
    for (var i = 0; i < pathElements.length; i++) {
        if (pathElements[i] === 'attributes') {
            // nothing to do
        }
        else if (pathElements[i] === 'relationships' && i < pathElements.length - 2) {
            var relationshipName = pathElements[i + 1];
            var dataType = pathElements[i + 2];
            if (dataType === 'data' || dataType === 'reference') {
                searchPath.push(relationshipName);
                i += 2;
            }
            else {
                throw new Error('cannot map relationship path in ' + attributePath + ', got ' + dataType +
                    ' but expected data or reference');
            }
        }
        else {
            searchPath.push(pathElements[i]);
        }
    }
    return _.join(searchPath, '.');
};
var QueryError = /** @class */ (function (_super) {
    __extends(QueryError, _super);
    function QueryError(errors) {
        var _this = _super.call(this) || this;
        _this.errors = errors;
        return _this;
    }
    return QueryError;
}(Error));
export { QueryError };
var CrnkBindingUtils = /** @class */ (function () {
    function CrnkBindingUtils() {
    }
    CrnkBindingUtils.prototype.toResourceIdentifier = function (resource) {
        return { type: resource.type, id: resource.id };
    };
    ;
    CrnkBindingUtils.prototype.toResourceIdentifiers = function (resources) {
        var results = [];
        for (var _i = 0, resources_1 = resources; _i < resources_1.length; _i++) {
            var resource = resources_1[_i];
            results.push(this.toResourceIdentifier(resource));
        }
        return results;
    };
    CrnkBindingUtils.prototype.applyQueryParams = function (baseQuery, additionalParams) {
        return applyQueryParams(baseQuery, additionalParams);
    };
    CrnkBindingUtils.prototype.toSearchPath = function (attributePath) {
        return toQueryPath(attributePath);
    };
    CrnkBindingUtils.decorators = [
        { type: Injectable },
    ];
    /** @nocollapse */
    CrnkBindingUtils.ctorParameters = function () { return []; };
    return CrnkBindingUtils;
}());
export { CrnkBindingUtils };
//# sourceMappingURL=crnk.binding.utils.js.map