ng2-rest 11.0.41 → 13.0.3

package/browser/fesm2020/ng2-rest.mjs

@@ -0,0 +1,1751 @@
+import { Subject, firstValueFrom, Observable } from 'rxjs';
+import { Log, Level } from 'ng2-logger/browser';
+import { diffChars } from 'diff';
+import { Helpers as Helpers$1, _, CoreHelpers } from 'tnp-core/browser';
+import { walk } from 'lodash-walk-object/browser';
+import { CLASS, SYMBOL, Models as Models$1 } from 'typescript-class-helpers/browser';
+import { JSON10 } from 'json10/browser';
+import axios from 'axios';
+
+var Mapping;
+(function (Mapping) {
+    function decode(json, autodetect = false) {
+        Helpers$1.simulateBrowser = true;
+        // console.log('DECODE isBrowser', HelpersLog.isBrowser)
+        if (_.isUndefined(json)) {
+            return void 0;
+        }
+        let mapping = decodeFromDecorator(_.isArray(json) ? _.first(json) : json, !autodetect);
+        if (autodetect) {
+            mapping = _.merge(getMappingNaive(json), mapping);
+        }
+        Helpers$1.simulateBrowser = false;
+        return mapping;
+    }
+    Mapping.decode = decode;
+    function encode(json, mapping, circular = []) {
+        if (_.isString(json) || _.isBoolean(json) || _.isNumber(json)) {
+            return json;
+        }
+        if (mapping['']) {
+            const decoratorMapping = getModelsMapping(CLASS.getBy(mapping['']));
+            mapping = _.merge(mapping, decoratorMapping);
+        }
+        let res;
+        if (_.isArray(circular) && circular.length > 0) {
+            res = setMappingCirc(json, mapping, circular);
+        }
+        else {
+            res = setMapping(json, mapping);
+        }
+        return res;
+    }
+    Mapping.encode = encode;
+    function decodeFromDecorator(json, production = false) {
+        const entityClass = CLASS.getFromObject(json);
+        const mappings = getModelsMapping(entityClass);
+        return mappings;
+    }
+    function getModelsMapping(entity) {
+        if (!_.isFunction(entity) || entity === Object) {
+            return {};
+        }
+        const className = CLASS.getName(entity);
+        // console.log(`getMaping for: '${className}' `)
+        let enityOWnMapping = _.isArray(entity[SYMBOL.MODELS_MAPPING]) ?
+            entity[SYMBOL.MODELS_MAPPING] : [{ '': className }];
+        let res = {};
+        let parents = enityOWnMapping
+            .filter(m => !_.isUndefined(m['']) && m[''] !== className)
+            .map(m => m['']);
+        enityOWnMapping.reverse().forEach(m => {
+            m = _.cloneDeep(m);
+            // console.log(`'${className}' m:`, m)
+            Object.keys(m).forEach(key => {
+                const v = m[key];
+                const isArr = _.isArray(v);
+                const model = isArr ? _.first(v) : v;
+                if (parents.includes(model)) {
+                    m[key] = isArr ? [className] : className;
+                }
+            });
+            res = _.merge(res, m);
+        });
+        res[''] = className;
+        // console.log(`mapping for ${className} : ${JSON.stringify(res)}`)
+        return res;
+    }
+    Mapping.getModelsMapping = getModelsMapping;
+    function add(o, path, mapping = {}) {
+        if (!o || Array.isArray(o) || typeof o !== 'object')
+            return;
+        const objectClassName = CLASS.getName(Object.getPrototypeOf(o).constructor);
+        const resolveClass = CLASS.getBy(objectClassName);
+        if (!resolveClass) {
+            if (objectClassName !== 'Object') {
+                if (Helpers$1.isBrowser) {
+                    console.error(`Cannot resolve class "${objectClassName}" while mapping.`);
+                }
+            }
+            return;
+        }
+        if (!mapping[path])
+            mapping[path] = CLASS.getName(resolveClass);
+        ;
+    }
+    /**
+     * USE ONLY IN DEVELOPMENT
+     * @param c
+     * @param path
+     * @param mapping
+     * @param level
+     */
+    function getMappingNaive(c, path = '', mapping = {}, level = 0) {
+        if (Array.isArray(c)) {
+            c.forEach(c => getMappingNaive(c, path, mapping, level));
+            return mapping;
+        }
+        if (++level === 16)
+            return;
+        add(c, path, mapping);
+        for (var p in c) {
+            if (c.hasOwnProperty(p)) {
+                const v = c[p];
+                if (Array.isArray(v) && v.length > 0) { // reducer as impovement
+                    v.forEach((elem, i) => {
+                        // const currentPaht = [`path[${i}]`, p].filter(c => c.trim() != '').join('.');
+                        const currentPaht = [path, p].filter(c => c.trim() != '').join('.');
+                        getMappingNaive(elem, currentPaht, mapping, level);
+                    });
+                }
+                else if (typeof v === 'object') {
+                    const currentPaht = [path, p].filter(c => c.trim() != '').join('.');
+                    add(v, currentPaht, mapping);
+                    getMappingNaive(v, currentPaht, mapping, level);
+                }
+            }
+        }
+        return mapping;
+    }
+    function getMappingPathFrom(pathLodhas) {
+        if (!_.isString(pathLodhas)) {
+            return void 0;
+        }
+        const regex = /\[([0-9a-zA-Z]|\'|\")*\]/g;
+        pathLodhas = pathLodhas
+            .replace(regex, '')
+            .replace('..', '.');
+        if (pathLodhas.startsWith('.')) {
+            pathLodhas = pathLodhas.slice(1);
+        }
+        return pathLodhas;
+    }
+    function setMappingCirc(json, mapping = {}, circular = []) {
+        const mainClassFn = !_.isArray(json) && CLASS.getBy(mapping['']);
+        // console.log(mapping)
+        walk.Object(json, (v, lodashPath, changeValue) => {
+            if (!_.isUndefined(v) && !_.isNull(v)) {
+                const mappingPath = getMappingPathFrom(lodashPath);
+                if (!_.isUndefined(mapping[mappingPath])) {
+                    const isArray = _.isArray(mapping[mappingPath]);
+                    if (!isArray) {
+                        const className = isArray ? _.first(mapping[mappingPath]) : mapping[mappingPath];
+                        const classFN = CLASS.getBy(className);
+                        if (_.isFunction(classFN)) {
+                            // console.log(`mapping: '${mappingPath}', lp: '${lodashPath}' class: '${className}' , set `, v.location)
+                            changeValue(_.merge(new classFN(), v));
+                        }
+                    }
+                }
+            }
+        });
+        circular.forEach(c => {
+            const ref = _.get(json, c.circuralTargetPath);
+            _.set(json, c.pathToObj, ref);
+        });
+        if (_.isFunction(mainClassFn)) {
+            json = _.merge(new mainClassFn(), json);
+        }
+        return json;
+    }
+    function setMapping(json, mapping = {}) {
+        // console.log('mapping', mapping)
+        if (Array.isArray(json)) {
+            return json.map(j => {
+                return setMapping(j, mapping);
+            });
+        }
+        const mainClassFn = CLASS.getBy(mapping['']);
+        for (const key in json) {
+            if (json.hasOwnProperty(key)) {
+                // if (mainClassFn && mainClassFn.name === 'Project') {
+                //   // console.log(`OWn property: "${key}"`)
+                // }
+                if (_.isArray(json[key])) {
+                    json[key] = json[key].map(arrObj => {
+                        const objMapping = getModelsMapping(CLASS.getBy(mapping[key]));
+                        return setMapping(arrObj, objMapping);
+                    });
+                }
+                else if (_.isObject(json[key])) {
+                    const objMapping = getModelsMapping(CLASS.getBy(mapping[key]));
+                    json[key] = setMapping(json[key], objMapping);
+                }
+            }
+            // else {
+            //   if (mainClassFn && mainClassFn.name === 'Project') {
+            //     // console.log(`Not own property: "${key}"`)
+            //   }
+            // }
+        }
+        Object
+            .keys(mapping)
+            .filter(key => key !== '' && key.split('.').length >= 2)
+            .forEach(lodasPath => {
+            // console.log(`Loadsh path: ${lodasPath}`)
+            const objMapping = getModelsMapping(CLASS.getBy(mapping[lodasPath]));
+            const input = _.get(json, lodasPath);
+            if (!_.isUndefined(input)) {
+                const res = setMapping(input, objMapping);
+                _.set(json, lodasPath, res);
+            }
+        });
+        if (!mainClassFn) {
+            return json;
+        }
+        return _.merge(new mainClassFn(), json);
+    }
+    function DefaultModelWithMapping(defaultModelValues, mapping) {
+        return function (target) {
+            if (!_.isArray(target[SYMBOL.MODELS_MAPPING])) {
+                target[SYMBOL.MODELS_MAPPING] = [];
+            }
+            target[SYMBOL.MODELS_MAPPING].push({ '': CLASS.getName(target) });
+            if (_.isObject(mapping)) {
+                target[SYMBOL.MODELS_MAPPING] = target[SYMBOL.MODELS_MAPPING].concat(mapping);
+                Object.keys(mapping)
+                    .forEach(key => {
+                    const v = mapping;
+                    if (_.isUndefined(v) || _.isFunction(v)) {
+                        throw `
+
+
+            Class: '${target.name}'
+[ng2rest] Bad mapping value for path: ${key} , please use type: <string> or [<string>]
+`;
+                    }
+                });
+            }
+            if (_.isObject(defaultModelValues)) {
+                const toMerge = {};
+                const describedTarget = CLASS
+                    .describeProperites(target)
+                    .filter(prop => /^([a-zA-Z0-9]|\_|\#)+$/.test(prop));
+                // console.log(`describedTarget: ${describedTarget} for ${target.name}`)
+                describedTarget.forEach(propDefInConstr => {
+                    if (defaultModelValues[propDefInConstr]) {
+                        console.warn(`
+
+            CONFLICT: default value for property: "${propDefInConstr}"
+            in class "${target.name}" already defined as typescript
+            default class proprty value.
+
+            `);
+                    }
+                    else {
+                        toMerge[propDefInConstr] = null; // TODO from toString I can't know that
+                    }
+                });
+                // console.log(`merge "${JSON.stringify(target.prototype)}" with "${JSON.stringify(defaultModelValues)}"`)
+                target[SYMBOL.DEFAULT_MODEL] = _.merge(toMerge, defaultModelValues);
+                const propsToOmmit = Object
+                    .keys(target[SYMBOL.DEFAULT_MODEL])
+                    .filter(key => {
+                    const descriptor = Object
+                        .getOwnPropertyDescriptor(target.prototype, key);
+                    return !!descriptor;
+                });
+                _.merge(target.prototype, _.omit(target[SYMBOL.DEFAULT_MODEL], propsToOmmit));
+                // console.log(`DEFAULT VALUE MERGE for ${target.name}`)
+            }
+        };
+    }
+    Mapping.DefaultModelWithMapping = DefaultModelWithMapping;
+})(Mapping || (Mapping = {}));
+
+// @ts-ignore
+class Helpers extends CoreHelpers {
+    static get Mapping() {
+        return {
+            encode(json, mapping) {
+                return Mapping.encode(json, mapping);
+            },
+            decode(json, autodetect = false) {
+                return Mapping.decode(json, autodetect);
+            }
+        };
+    }
+    static checkValidUrl(url) {
+        let regex = /(http|https):\/\/(\w+:{0,1}\w*)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
+        return regex.test(url);
+    }
+}
+Helpers.JSON = JSON10;
+
+const log$3 = Log.create('[ng2-rest] params', Level.__NOTHING);
+/** check if string is a valid pattern */
+function isValid(pattern) {
+    return (new RegExp('\/:[a-zA-Z]*', 'g')).test(pattern.replace('://', ''));
+}
+function check(url, pattern) {
+    if (!Helpers.checkValidUrl(url)) {
+        log$3.error(`Incorrect url: ${url}`);
+        return false;
+    }
+    if (url.charAt(url.length - 1) === '/')
+        url = url.slice(0, url.length - 2);
+    if (pattern.charAt(pattern.length - 1) === '/')
+        pattern = pattern.slice(0, url.length - 2);
+    pattern = pattern.replace(/\//g, '\/');
+    pattern = pattern.replace(new RegExp('\/:[a-zA-Z]*', 'g'), '.+');
+    let reg = new RegExp(pattern, 'g');
+    return reg.test(url);
+}
+function getModels(pattern) {
+    let m = pattern.match(new RegExp('[a-z-A-Z]*\/:', 'g'));
+    return m.map(p => p.replace('/:', ''));
+}
+function getRestPramsNames(pattern) {
+    if (pattern.charAt(pattern.length - 1) !== '/')
+        pattern = `${pattern}/`;
+    let m = pattern.match(new RegExp(':[a-zA-Z]*\/', 'g'));
+    let res = m.map(p => p.replace(':', '').replace('/', ''));
+    return res.filter(p => p.trim() !== '');
+}
+function containsModels(url, models) {
+    if (url.charAt(0) !== '/')
+        url = '/' + url;
+    // url = url.replace(new RegExp('\/', 'g'), '');
+    let res = models.filter(m => {
+        let word = '/' + m;
+        // log.d('word', word)
+        let iii = url.indexOf(word);
+        // log.d('iii', iii)
+        if (iii + word.length < url.length && url.charAt(iii + word.length) !== '/') {
+            return false;
+        }
+        if (iii !== -1) {
+            url = url.replace(new RegExp('\/' + m, 'g'), '');
+            return true;
+        }
+        return false;
+    }).length;
+    // log.d('containsModels', res);
+    return res === models.length;
+}
+function stars(n) {
+    let res = '';
+    for (let i = 0; i < n; i++)
+        res += '*';
+    return res;
+}
+function getRestParams(url, pattern) {
+    let res = {};
+    let models = getRestPramsNames(pattern);
+    // log.d('models', models);
+    models.forEach(m => {
+        pattern = pattern.replace(`:${m}`, stars(m.length));
+    });
+    let currentModel = void 0;
+    diffChars(pattern, url).forEach(d => {
+        // log.d('d', d);
+        if (d.added) {
+            if (!isNaN(Number(d.value)))
+                res[currentModel] = Number(d.value);
+            else if (d.value.trim() === 'true')
+                res[currentModel] = true;
+            else if (d.value.trim() === 'false')
+                res[currentModel] = false;
+            else
+                res[currentModel] = decodeURIComponent(d.value);
+            currentModel = void 0;
+        }
+        let m = d.value.replace(':', "");
+        // log.d('model m', m)
+        if (d.removed) {
+            currentModel = models.shift();
+        }
+    });
+    return res;
+}
+const regexisPath = /[^\..]+(\.[^\..]+)+/g;
+/**
+ * Models like books/:id
+ */
+function cutUrlModel(params, models, output) {
+    if (models.length === 0)
+        return output.join('\/');
+    let m = models.pop();
+    let param = m.match(/:[a-zA-Z0-9\.]+/)[0].replace(':', '');
+    const paramIsPath = regexisPath.test(param);
+    // log.i('cut param', param)
+    let model = m.match(/[a-zA-Z0-9]+\//)[0].replace('\/', '');
+    if (params === void 0 ||
+        (paramIsPath ? _.get(params, param) === void 0 : params[param] === void 0) ||
+        param === 'undefined') {
+        output.length = 0;
+        output.unshift(model);
+        return cutUrlModel(params, models, output);
+    }
+    else {
+        if (paramIsPath) {
+            // log.i('param is path', param)
+            let mrep = m.replace(new RegExp(`:${param}`, 'g'), `${_.get(params, param)}`);
+            output.unshift(mrep);
+            return cutUrlModel(params, models, output);
+        }
+        else {
+            // log.i('param is normal', param)
+            let mrep = m.replace(new RegExp(`:${param}`, 'g'), `${params[param]}`);
+            output.unshift(mrep);
+            return cutUrlModel(params, models, output);
+        }
+    }
+}
+function interpolateParamsToUrl(params, url) {
+    const regexInt = /\[\[([^\..]+\.[^\..]+)+\]\]/g;
+    url = url.split('/').map(p => {
+        // log.d('url parts', p)
+        let isParam = p.startsWith(':');
+        if (isParam) {
+            let part = p.slice(1);
+            // log.d('url param part', p)
+            if (regexInt.test(part)) {
+                // let level = (url.split('.').length - 1)
+                part = part.replace('[[', '');
+                part = part.replace(']]', '');
+            }
+            return `:${part}`;
+        }
+        return p;
+    }).join('/');
+    // log.i('URL TO EXPOSE', url)
+    // log.i('params', params)
+    let slash = {
+        start: url.charAt(0) === '\/',
+        end: url.charAt(url.length - 1) === '\/'
+    };
+    let morePramsOnEnd = url.match(/(\/:[a-zA-Z0-9\.]+){2,10}/g);
+    if (morePramsOnEnd && (Array.isArray(morePramsOnEnd) && morePramsOnEnd.length === 1)) {
+        // log.i('morePramsOnEnd', morePramsOnEnd)
+        let m = morePramsOnEnd[0];
+        let match = m.match(/\/:[a-zA-Z0-9\.]+/g);
+        // log.i('match', match)
+        match.forEach(e => {
+            let c = e.replace('\/:', '');
+            // log.i('c', c)
+            if (regexisPath.test(c)) {
+                url = url.replace(e, `/${_.get(params, c)}`);
+            }
+            else {
+                url = url.replace(e, `/${params[c]}`);
+            }
+            // log.i('prog url', url)
+        });
+        return url;
+    }
+    let nestedParams = url.match(/[a-zA-Z0-9]+\/:[a-zA-Z0-9\.]+/g);
+    if (!nestedParams || (Array.isArray(nestedParams) && nestedParams.length === 0))
+        return url;
+    // check alone params
+    if (!slash.end)
+        url = `${url}/`;
+    let addUndefinedForAlone = (!/:[a-zA-Z0-9\.]+\/$/g.test(url) && /[a-zA-Z0-9]+\/$/g.test(url));
+    let replace = (nestedParams.length > 1 ? nestedParams.join('\/') : nestedParams[0]) +
+        (addUndefinedForAlone ? '\/' + url.match(/[a-zA-Z0-9]+\/$/g)[0] : '\/');
+    let beginHref = url.replace(replace, '');
+    if (addUndefinedForAlone) {
+        url = url.replace(/\/$/g, '/:undefined');
+        nestedParams = url.match(/[a-zA-Z0-9]+\/:[a-zA-Z0-9\.]+/g);
+        url = cutUrlModel(params, nestedParams, []);
+    }
+    else {
+        url = cutUrlModel(params, nestedParams, []);
+    }
+    url = beginHref + url;
+    if (url.charAt(url.length - 1) !== '/' && slash.end)
+        url = `${url}/`;
+    if (url.charAt(0) !== '\/' && slash.start)
+        url = `/${url}`;
+    return url;
+}
+/**
+ * Get query params from url, like 'ex' in /api/books?ex=value
+*/
+function decodeUrl(url) {
+    let regex = /[?&]([^=#]+)=([^&#]*)/g, params = {}, match;
+    while (match = regex.exec(url)) {
+        params[decodeURIComponent(match[1])] = decodeURIComponent(match[2]);
+    }
+    let paramsObject = params;
+    for (let p in paramsObject) {
+        if (paramsObject[p] === void 0) {
+            delete paramsObject[p];
+            continue;
+        }
+        if (paramsObject.hasOwnProperty(p)) {
+            // chcek if property is number
+            let n = Number(params[p]);
+            if (!isNaN(n)) {
+                params[p] = n;
+                continue;
+            }
+            if (typeof params[p] === 'string') {
+                // check if property is object
+                let json;
+                try {
+                    json = JSON.parse(params[p]);
+                }
+                catch (error) { }
+                if (json !== void 0) {
+                    params[p] = json;
+                    continue;
+                }
+                // chcek if property value is like regular rexpression
+                // let regexExpression;
+                // try {
+                //     regexExpression = new RegExp(params[p]);
+                // } catch (e) { }
+                // if (regexExpression !== undefined) params[p] = regexExpression;
+            }
+        }
+    }
+    return params;
+}
+/**
+ * Create query params string for url
+ *
+ * @export
+ * @param {UrlParams[]} params
+ * @returns {string}
+ */
+function getParamsUrl(params, doNotSerialize = false) {
+    let urlparts = [];
+    if (!params)
+        return '';
+    if (!(params instanceof Array))
+        return '';
+    if (params.length === 0)
+        return '';
+    params.forEach(urlparam => {
+        if (JSON.stringify(urlparam) !== '{}') {
+            let parameters = [];
+            let paramObject = urlparam;
+            for (let p in paramObject) {
+                if (paramObject[p] === void 0)
+                    delete paramObject[p];
+                if (paramObject.hasOwnProperty(p) && typeof p === 'string' && p !== 'regex' && !(paramObject[p] instanceof RegExp)) {
+                    if (p.length > 0 && p[0] === '/') {
+                        let newName = p.slice(1, p.length - 1);
+                        urlparam[newName] = urlparam[p];
+                        urlparam[p] = void 0;
+                        p = newName;
+                    }
+                    if (p.length > 0 && p[p.length - 1] === '/') {
+                        let newName = p.slice(0, p.length - 2);
+                        urlparam[newName] = urlparam[p];
+                        urlparam[p] = void 0;
+                        p = newName;
+                    }
+                    let v = urlparam[p];
+                    if (v instanceof Object) {
+                        urlparam[p] = JSON.stringify(urlparam[p]);
+                    }
+                    urlparam[p] = doNotSerialize ? urlparam[p] : encodeURIComponent(urlparam[p]);
+                    if (urlparam.regex !== void 0 && urlparam.regex instanceof RegExp) {
+                        if (!urlparam.regex.test(urlparam[p])) {
+                            console.warn(`Data: ${urlparam[p]} incostistent with regex ${urlparam.regex.source}`);
+                        }
+                    }
+                    parameters.push(`${p}=${urlparam[p]}`);
+                }
+            }
+            urlparts.push(parameters.join('&'));
+        }
+    });
+    let join = urlparts.join().trim();
+    if (join.trim() === '')
+        return '';
+    return `?${urlparts.join('&')}`;
+}
+function transform(o) {
+    if (typeof o === 'object') {
+        return encodeURIComponent(JSON.stringify(o));
+    }
+    return o;
+}
+function prepareUrlOldWay(params) {
+    if (!params)
+        return this.endpoint;
+    if (typeof params === 'object') {
+        params = transform(params);
+    }
+    return this.endpoint + '/' + params;
+}
+
+class RestHeaders {
+    constructor(headers) {
+        /** @internal header names are lower case */
+        this._headers = new Map();
+        /** @internal map lower case names to actual names */
+        this._normalizedNames = new Map();
+        if (headers instanceof RestHeaders) {
+            headers.forEach((values, name) => {
+                values.forEach(value => this.set(name, value));
+            });
+        }
+        else {
+            Object.keys(headers).forEach((name) => {
+                const values = (Array.isArray(headers[name]) ? headers[name] : [headers[name]]);
+                this.delete(name);
+                values.forEach(value => this.set(name, value));
+            });
+        }
+    }
+    static from(headers) {
+        if (!headers) {
+            return void 0;
+        }
+        return new RestHeaders(headers);
+    }
+    /**
+     * Returns a new RestHeaders instance from the given DOMString of Response RestHeaders
+     */
+    static fromResponseHeaderString(headersString) {
+        const headers = new RestHeaders();
+        headersString.split('\n').forEach(line => {
+            const index = line.indexOf(':');
+            if (index > 0) {
+                const name = line.slice(0, index);
+                const value = line.slice(index + 1).trim();
+                headers.set(name, value);
+            }
+        });
+        return headers;
+    }
+    /**
+     * Appends a header to existing list of header values for a given header name.
+     */
+    append(name, value) {
+        const values = this.getAll(name);
+        if (values === null) {
+            this.set(name, value);
+        }
+        else {
+            values.push(value);
+        }
+    }
+    /**
+     * Deletes all header values for the given name.
+     */
+    delete(name) {
+        const lcName = name.toLowerCase();
+        this._normalizedNames.delete(lcName);
+        this._headers.delete(lcName);
+    }
+    forEach(fn) {
+        this._headers.forEach((values, lcName) => fn(values, this._normalizedNames.get(lcName), this._headers));
+    }
+    /**
+     * Returns first header that matches given name.
+     */
+    get(name) {
+        const values = this.getAll(name);
+        if (values === null) {
+            return null;
+        }
+        return values.length > 0 ? values[0] : null;
+    }
+    /**
+     * Checks for existence of header by given name.
+     */
+    has(name) { return this._headers.has(name.toLowerCase()); }
+    /**
+     * Returns the names of the headers
+     */
+    keys() { return Array.from(this._normalizedNames.values()); }
+    /**
+     * Sets or overrides header value for given name.
+     */
+    set(name, value) {
+        if (Array.isArray(value)) {
+            if (value.length) {
+                this._headers.set(name.toLowerCase(), [value.join(',')]);
+            }
+        }
+        else {
+            this._headers.set(name.toLowerCase(), [value]);
+        }
+        this.mayBeSetNormalizedName(name);
+    }
+    /**
+     * Returns values of all headers.
+     */
+    values() { return Array.from(this._headers.values()); }
+    /**
+     * Returns string of all headers.
+     */
+    // TODO(vicb): returns {[name: string]: string[]}
+    toJSON() {
+        const serialized = {};
+        if (!this._headers) {
+            debugger;
+        }
+        this._headers.forEach((values, name) => {
+            const split = [];
+            values.forEach(v => split.push(...v.split(',')));
+            serialized[this._normalizedNames.get(name)] = split;
+        });
+        return serialized;
+    }
+    /**
+     * Returns list of header values for a given name.
+     */
+    getAll(name) {
+        return this.has(name) ? this._headers.get(name.toLowerCase()) : null;
+    }
+    mayBeSetNormalizedName(name) {
+        const lcName = name.toLowerCase();
+        if (!this._normalizedNames.has(lcName)) {
+            this._normalizedNames.set(lcName, name);
+        }
+    }
+}
+
+//#endregion
+const DEFAULT_HEADERS = {
+    'Content-Type': 'application/json',
+    'Accept': 'application/json'
+};
+class Rest {
+    constructor(endpoint, request, meta) {
+        this.request = request;
+        this.meta = meta;
+        //#endregion
+        //#region  constructor
+        this._headers = RestHeaders.from(DEFAULT_HEADERS);
+        //#endregion
+        this.array = {
+            get: (params = void 0, doNotSerializeParams) => {
+                return this.req('get', void 0, params, doNotSerializeParams, true);
+            },
+            head: (params = void 0, doNotSerializeParams) => {
+                return this.req('head', void 0, params, doNotSerializeParams, true);
+            },
+            post: (item, params, doNotSerializeParams) => {
+                return this.req('post', item, params, doNotSerializeParams, true);
+            },
+            put: (item, params, doNotSerializeParams) => {
+                return this.req('put', item, params, doNotSerializeParams, true);
+            },
+            patch: (item, params, doNotSerializeParams) => {
+                return this.req('patch', item, params, doNotSerializeParams, true);
+            },
+            delete: (params, doNotSerializeParams) => {
+                return this.req('delete', void 0, params, doNotSerializeParams, true);
+            },
+            jsonp: (params, doNotSerializeParams) => {
+                return this.req('jsonp', void 0, params, doNotSerializeParams, true);
+            }
+        };
+        this.__meta_endpoint = endpoint;
+    }
+    mock(mock) {
+        if ((typeof mock === 'function') || (typeof mock === 'object')) {
+            this.mockHttp = mock;
+        }
+        else {
+            throw `[ng2-rest]
+      .model(...)
+      .mock( < BAD MOCK DATA > )
+      ...
+      `;
+        }
+        return this;
+    }
+    get endpoint() {
+        let e = this.__meta_endpoint;
+        if (this.restQueryParams !== void 0 && this._endpointRest !== void 0
+            && typeof this._endpointRest === 'string' && this._endpointRest.trim() !== '')
+            e = this._endpointRest;
+        return e;
+    }
+    set __rest_endpoint(endpoint) {
+        this._endpointRest = endpoint;
+        if (endpoint === void 0) {
+            this.restQueryParams = void 0;
+        }
+        else {
+            this.restQueryParams = getRestParams(endpoint, this.__meta_endpoint);
+        }
+    }
+    creatUrl(params, doNotSerializeParams = false) {
+        return `${this.endpoint}${getParamsUrl(params, doNotSerializeParams)}`;
+    }
+    get headers() {
+        return this._headers;
+    }
+    //#endregion
+    //#region  req
+    req(method, item, params, doNotSerializeParams = false, isArray = false) {
+        const modelUrl = this.creatUrl(params, doNotSerializeParams);
+        const body = item ? JSON.stringify(item) : void 0;
+        const result = this.request[method.toLowerCase()](modelUrl, body, this.headers, this.meta, isArray, this.mockHttp);
+        this._headers = RestHeaders.from(DEFAULT_HEADERS);
+        this.mockHttp = void 0;
+        return result;
+    }
+    //#endregion
+    //#region http methods
+    //#region replay
+    replay(method) {
+        this.request.replay(method, this.meta);
+    }
+    get(params, doNotSerializeParams = false) {
+        return this.req('get', void 0, params, doNotSerializeParams);
+    }
+    head(params, doNotSerializeParams = false) {
+        return this.req('head', void 0, params, doNotSerializeParams);
+    }
+    post(item, params, doNotSerializeParams = false) {
+        return this.req('post', item, params, doNotSerializeParams);
+    }
+    put(item, params, doNotSerializeParams = false) {
+        return this.req('put', item, params, doNotSerializeParams);
+    }
+    patch(item, params, doNotSerializeParams = false) {
+        return this.req('patch', item, params, doNotSerializeParams);
+    }
+    delete(params, doNotSerializeParams = false) {
+        return this.req('delete', void 0, params, doNotSerializeParams);
+    }
+    jsonp(params, doNotSerializeParams = false) {
+        return this.req('jsonp', void 0, params, doNotSerializeParams);
+    }
+}
+
+class Cookie {
+    constructor() {
+    }
+    static get Instance() {
+        if (!Cookie.__instance) {
+            Cookie.__instance = new Cookie();
+        }
+        return Cookie.__instance;
+    }
+    read(name) {
+        var result = new RegExp('(?:^|; )' + encodeURIComponent(name) + '=([^;]*)').exec(document.cookie);
+        return result ? result[1] : null;
+    }
+    write(name, value, days) {
+        if (!days) {
+            days = 365 * 20;
+        }
+        var date = new Date();
+        date.setTime(date.getTime() + (days * 24 * 60 * 60 * 1000));
+        var expires = "; expires=" + date.toUTCString();
+        document.cookie = name + "=" + value + expires + "; path=/";
+    }
+    remove(name) {
+        this.write(name, "", -1);
+    }
+}
+
+const log$2 = Log.create('request-cache', Level.__NOTHING);
+class RequestCache {
+    constructor(response) {
+        this.response = response;
+    }
+    static restoreFromLocalStorage() {
+        if (Helpers$1.isNode) {
+            return;
+        }
+        if (!RequestCache.isRestoredFromLocalStorage) {
+            RequestCache.isRestoredFromLocalStorage = true;
+            const data = localStorage.getItem(RequestCache.LOCAL_STORAGE_KEY);
+            let requests = [];
+            if (data) {
+                try {
+                    requests = JSON.parse(data);
+                }
+                catch (error) {
+                }
+                const restored = requests.map(r => {
+                    let { sourceRequest, responseText, body, headers, circular, entity, isArray, cookies, statusCode } = r.response;
+                    r.response = new Models.HttpResponse(sourceRequest, responseText, RestHeaders.from(headers), statusCode, entity, circular, -1, // jobid from local storage TODO
+                    isArray);
+                    r = new RequestCache(r.response);
+                    r.response.rq = r;
+                    return r;
+                });
+                log$2.i('RESTORED FROM LOCAL STORAGE', restored);
+                RequestCache.cached = restored;
+            }
+        }
+    }
+    static findBy(sourceRequest) {
+        log$2.i('findby', sourceRequest);
+        log$2.i('RequestCache.cached', RequestCache.cached);
+        RequestCache.restoreFromLocalStorage();
+        return RequestCache.cached.find(c => {
+            const a = c.response.sourceRequest;
+            const b = sourceRequest;
+            return (a.isArray === b.isArray &&
+                a.url === b.url &&
+                a.method === b.method &&
+                a.body === b.body);
+        });
+    }
+    get containsCache() {
+        RequestCache.restoreFromLocalStorage();
+        return RequestCache.cached.includes(this);
+    }
+    persistsInLocalStorage() {
+        localStorage.setItem(RequestCache.LOCAL_STORAGE_KEY, JSON.stringify(RequestCache.cached.map(r => {
+            return {
+                response: {
+                    sourceRequest: r.response.sourceRequest,
+                    responseText: r.response.responseText,
+                    headers: r.response.headers,
+                    statusCode: r.response.statusCode,
+                    entity: r.response.entity,
+                    circular: r.response.circular,
+                    isArray: r.response.isArray,
+                }
+            };
+        })));
+    }
+    store() {
+        RequestCache.restoreFromLocalStorage();
+        if (!this.containsCache) {
+            RequestCache.cached.push(this);
+            this.persistsInLocalStorage();
+        }
+        else {
+            console.log('already stored');
+        }
+        return this;
+    }
+    remove() {
+        RequestCache.restoreFromLocalStorage();
+        const index = RequestCache.cached.indexOf(this);
+        if (index !== -1) {
+            RequestCache.cached.splice(index, 1);
+            this.persistsInLocalStorage();
+        }
+        else {
+            console.log('already removed');
+        }
+    }
+}
+RequestCache.LOCAL_STORAGE_KEY = 'ng2restrequestcache';
+RequestCache.cached = [];
+RequestCache.isRestoredFromLocalStorage = false;
+
+// const log = Log.create('rest namespace', Level.__NOTHING)
+var Models;
+(function (Models) {
+    Models.MethodConfig = Models$1.MethodConfig;
+    Models.ClassConfig = Models$1.ClassConfig;
+    Models.ParamConfig = Models$1.ParamConfig;
+    ;
+    ;
+    [];
+    class BaseBody {
+        toJSON(data, isJSONArray = false) {
+            let r = isJSONArray ? [] : {};
+            if (typeof data === 'string') {
+                try {
+                    r = JSON.parse(data);
+                }
+                catch (e) { }
+            }
+            else if (typeof data === 'object') {
+                return data;
+            }
+            return r;
+        }
+    }
+    Models.BaseBody = BaseBody;
+    class HttpBody extends BaseBody {
+        constructor(body, isArray = false, entity, circular) {
+            super();
+            this.body = body;
+            this.isArray = isArray;
+            this.entity = entity;
+            this.circular = circular;
+        }
+        get booleanValue() {
+            return ['ok', 'true'].includes(this.body.trim());
+        }
+        get json() {
+            if (this.entity && typeof this.entity === 'object') {
+                const json = this.toJSON(this.body, this.isArray);
+                return Mapping.encode(json, this.entity, this.circular);
+            }
+            let res = this.toJSON(this.body, this.isArray);
+            if (this.circular && Array.isArray(this.circular)) {
+                res = JSON10.parse(JSON.stringify(res), this.circular);
+            }
+            return res;
+        }
+        get text() {
+            return this.body.replace(/^\"/, '').replace(/\"$/, '');
+        }
+    }
+    Models.HttpBody = HttpBody;
+    class ErrorBody extends BaseBody {
+        constructor(data) {
+            super();
+            this.data = data;
+        }
+        get json() {
+            return this.toJSON(this.data);
+        }
+        get text() {
+            return this.data;
+        }
+    }
+    Models.ErrorBody = ErrorBody;
+    class BaseResponse {
+        constructor(responseText, headers, statusCode, isArray = false) {
+            this.responseText = responseText;
+            this.headers = headers;
+            this.statusCode = statusCode;
+            this.isArray = isArray;
+        }
+        get cookies() {
+            return BaseResponse.cookies;
+        }
+    }
+    BaseResponse.cookies = Cookie.Instance;
+    Models.BaseResponse = BaseResponse;
+    class HttpResponse extends BaseResponse {
+        constructor(sourceRequest, responseText, headers, statusCode, entity, circular, jobid, isArray = false) {
+            super(responseText, headers, statusCode, isArray);
+            this.sourceRequest = sourceRequest;
+            this.responseText = responseText;
+            this.headers = headers;
+            this.statusCode = statusCode;
+            this.entity = entity;
+            this.circular = circular;
+            this.jobid = jobid;
+            this.isArray = isArray;
+            this.init();
+        }
+        init() {
+            if (typeof this.entity === 'string') {
+                // const headerWithMapping = headers.get(entity);
+                let entityJSON = this.headers.getAll(this.entity);
+                if (!!entityJSON) {
+                    this.entity = JSON.parse(entityJSON.join());
+                }
+            }
+            if (typeof this.circular === 'string') {
+                // const headerWithMapping = headers.get(circular);
+                let circuralJSON = this.headers.getAll(this.circular);
+                if (!!circuralJSON) {
+                    this.circular = JSON.parse(circuralJSON.join());
+                }
+            }
+            this.body = new HttpBody(this.responseText, this.isArray, this.entity, this.circular);
+        }
+        get cache() {
+            if (_.isUndefined(this.rq)) {
+                this.rq = new RequestCache(this);
+            }
+            return new RequestCache(this);
+        }
+    }
+    Models.HttpResponse = HttpResponse;
+    class HttpResponseError extends BaseResponse {
+        // public tryRecconect() {
+        // }
+        constructor(message, responseText, headers, statusCode, jobid) {
+            super(responseText, headers, statusCode);
+            this.message = message;
+            this.jobid = jobid;
+            this.body = new ErrorBody(responseText);
+        }
+    }
+    Models.HttpResponseError = HttpResponseError;
+})(Models || (Models = {}));
+
+const log$1 = Log.create('[ng2-rest] rest-request', Level.__NOTHING);
+const jobIDkey = 'jobID';
+//#region mock request
+//#endregion
+class RestRequest {
+    constructor() {
+        this.subjectInuUse = {};
+        this.meta = {};
+        //#endregion
+        this.replaySubjects = {};
+    }
+    handlerResult(options, sourceRequest) {
+        if (_.isUndefined(options)) {
+            options = {};
+        }
+        // log.d(`HANDLE RESULT (jobid:${options.jobid}) ${sourceRequest.url}`);
+        const { res, jobid, isArray, method } = options;
+        // if (this.endedJobs[jobid]) {
+        //   debugger
+        // }
+        // this.endedJobs[jobid] = true;
+        // log.i(`handle jobid ${jobid}`)
+        if (typeof res !== 'object') {
+            throw new Error('No resposnse for request. ');
+        }
+        if (Helpers$1.isBrowser) {
+            res.headers = RestHeaders.from(res.headers);
+        }
+        // error no internet
+        if (res.error) {
+            this.subjectInuUse[jobid].error(new Models.HttpResponseError(res.error, res.data, res.headers, res.code, jobid));
+            return;
+        }
+        const entity = this.meta[jobid].entity;
+        const circular = this.meta[jobid].circular;
+        this.subjectInuUse[jobid].next(new Models.HttpResponse(sourceRequest, res.data, res.headers, res.code, entity, circular, jobid, isArray));
+        this.meta[jobid] = void 0;
+        return;
+    }
+    checkCache(sourceRequest, jobid) {
+        const existedInCache = RequestCache.findBy(sourceRequest);
+        if (existedInCache) {
+            log$1.i('cache exists', existedInCache);
+            this.subjectInuUse[jobid].next(existedInCache);
+            return true;
+        }
+        // log.i(`cache not exists for jobid ${jobid}`)
+        return false;
+    }
+    async req(url, method, headers, body, jobid, isArray = false, mockHttp) {
+        if (this.checkCache({
+            url,
+            body,
+            isArray,
+            method
+        }, jobid)) {
+            return;
+        }
+        var response;
+        if (mockHttp) {
+            if (typeof mockHttp === 'object') {
+                response = {
+                    data: mockHttp.data,
+                    status: mockHttp.code,
+                    headers: mockHttp.headers,
+                    statusText: mockHttp.error,
+                    config: {}
+                };
+            }
+            else if (typeof mockHttp === 'function') {
+                const r = mockHttp(url, method, headers, body);
+                response = {
+                    data: r.data,
+                    status: r.code,
+                    headers: r.headers,
+                    statusText: r.error,
+                    config: {}
+                };
+            }
+        }
+        try {
+            if (!response) {
+                log$1.d(`[${method}] (jobid=${jobid}) request to:  ${url}`);
+                response = await axios({
+                    url,
+                    method,
+                    data: body,
+                    responseType: 'text',
+                    headers: headers.toJSON()
+                });
+                // log.d(`after response of jobid: ${jobid}`);
+            }
+            this.handlerResult({
+                res: {
+                    code: response.status,
+                    data: JSON.stringify(response.data),
+                    isArray,
+                    jobid,
+                    headers: RestHeaders.from(response.headers)
+                },
+                method,
+                jobid,
+                isArray
+            }, {
+                url,
+                body,
+                method,
+                isArray,
+            });
+        }
+        catch (catchedError) {
+            // console.log('ERROR RESPONESE catchedError typeof ', typeof catchedError)
+            // console.log('ERROR RESPONESE catchedError', catchedError)
+            if (typeof catchedError === 'object' && catchedError.response && catchedError.response.data) {
+                const err = catchedError.response.data;
+                const msg = catchedError.response.data.message || '';
+                let stack = (err.stack || '').split('\n');
+                Resource['_listenErrors'].next({
+                    msg,
+                    stack,
+                    data: catchedError.response.data
+                });
+            }
+            const error = (catchedError && catchedError.response) ? `[${catchedError.response.statusText}]: ` : '';
+            this.handlerResult({
+                res: {
+                    code: (catchedError && catchedError.response) ? catchedError.response.status : void 0,
+                    error: `${error}${catchedError.message}`,
+                    data: (catchedError && catchedError.response) ? JSON.stringify(catchedError.response.data) : void 0,
+                    isArray,
+                    jobid,
+                    headers: RestHeaders.from(catchedError && catchedError.response && catchedError.response.headers)
+                },
+                method,
+                jobid,
+                isArray
+            }, {
+                url,
+                body,
+                isArray,
+                method
+            });
+        }
+    }
+    getReplay(method, meta, onlyGetLastReplayForMethod) {
+        let replay;
+        //#region prevent empty tree
+        if (_.isUndefined(this.replaySubjects[meta.endpoint])) {
+            // log.i(`(${meta.endpoint}) `);
+            this.replaySubjects[meta.endpoint] = {};
+        }
+        if (_.isUndefined(this.replaySubjects[meta.endpoint][meta.path])) {
+            // log.i(`(${meta.endpoint})(${meta.path}) `);
+            this.replaySubjects[meta.endpoint][meta.path] = {};
+        }
+        if (_.isUndefined(this.replaySubjects[meta.endpoint][meta.path][method])) {
+            // log.i(`(${meta.endpoint})(${meta.path}) `);
+            this.replaySubjects[meta.endpoint][meta.path][method] = {};
+        }
+        //#endregion
+        const objectIDToCreateOrLast = (Object.keys(this.replaySubjects[meta.endpoint][meta.path][method]).length) +
+            (onlyGetLastReplayForMethod ? 0 : 1);
+        if (onlyGetLastReplayForMethod && (objectIDToCreateOrLast === 0)) {
+            return replay;
+        }
+        if (_.isUndefined(this.replaySubjects[meta.endpoint][meta.path][method][objectIDToCreateOrLast])) {
+            // log.i(`(${meta.endpoint})(${meta.path})(${method}) `);
+            this.replaySubjects[meta.endpoint][meta.path][method][objectIDToCreateOrLast] = {
+                subject: new Subject(),
+                data: void 0,
+            };
+        }
+        replay = this.replaySubjects[meta.endpoint][meta.path][method][objectIDToCreateOrLast];
+        if (!_.isNumber(replay.id)) {
+            const jobid = RestRequest.jobId++;
+            replay.id = jobid;
+            const subject = replay.subject;
+            subject[jobIDkey] = jobid; // modify internal rxjs subject obj
+            this.meta[jobid] = meta;
+            this.subjectInuUse[jobid] = subject;
+            //#region DISPOSE  @UNCOMMENT AFTER TESTS
+            // if (objectIDToCreateOrLast > 2) {
+            //   const oldReq: Models.ReplayData = this.replaySubjects[meta.endpoint][meta.path][method][(objectIDToCreateOrLast - 2)];
+            //   if (_.isUndefined(this.meta[oldReq.id])) {
+            //     // cant delete this - for counter purpose
+            //     this.replaySubjects[meta.endpoint][meta.path][method][(objectIDToCreateOrLast - 2)] = {};
+            //     delete this.subjectInuUse[oldReq.id];
+            //     delete this.meta[oldReq.id];
+            //   }
+            // }
+            //#endregion
+        }
+        return replay;
+    }
+    //#region http methods
+    generalReq(method, url, body, headers, meta, isArray, mockHttp) {
+        const replay = this.getReplay(method, meta, false);
+        replay.data = { url, body, headers, isArray };
+        ((pthis, purl, pmethod, pheaders, pbody, pid, pisArray, pmockHttp) => {
+            // log.d(`for ${purl} jobid ${pid}`);
+            setTimeout(() => pthis.req(purl, pmethod, pheaders, pbody, pid, pisArray, pmockHttp));
+        })(this, url, method, headers, body, replay.id, isArray, mockHttp);
+        const resp = firstValueFrom(replay.subject.asObservable());
+        resp.observable = replay.subject.asObservable();
+        resp.cache = RequestCache.findBy({
+            body,
+            isArray,
+            method,
+            url
+        });
+        return resp;
+    }
+    get(url, body, headers, meta, isArray, mockHttp) {
+        return this.generalReq('get', url, body, headers, meta, isArray, mockHttp);
+    }
+    head(url, body, headers, meta, isArray, mockHttp) {
+        return this.generalReq('head', url, body, headers, meta, isArray, mockHttp);
+    }
+    delete(url, body, headers, meta, isArray, mockHttp) {
+        return this.generalReq('delete', url, body, headers, meta, isArray, mockHttp);
+    }
+    post(url, body, headers, meta, isArray, mockHttp) {
+        return this.generalReq('post', url, body, headers, meta, isArray, mockHttp);
+    }
+    put(url, body, headers, meta, isArray, mockHttp) {
+        return this.generalReq('put', url, body, headers, meta, isArray, mockHttp);
+    }
+    patch(url, body, headers, meta, isArray, mockHttp) {
+        return this.generalReq('patch', url, body, headers, meta, isArray, mockHttp);
+    }
+    jsonp(url, body, headers, meta, isArray, mockHttp) {
+        const replay = this.getReplay('jsonp', meta, false);
+        const jobid = replay.id;
+        const method = 'jsonp';
+        setTimeout(() => {
+            if (url.endsWith('/'))
+                url = url.slice(0, url.length - 1);
+            let num = Math.round(10000 * Math.random());
+            let callbackMethodName = "cb_" + num;
+            window[callbackMethodName] = (data) => {
+                if (this.checkCache({
+                    url,
+                    body,
+                    isArray,
+                    method
+                }, jobid)) {
+                    return;
+                }
+                this.handlerResult({
+                    res: {
+                        data, isArray
+                    },
+                    method,
+                    jobid,
+                    isArray
+                }, {
+                    url,
+                    body,
+                    isArray,
+                    method,
+                });
+            };
+            let sc = document.createElement('script');
+            sc.src = `${url}?callback=${callbackMethodName}`;
+            document.body.appendChild(sc);
+            document.body.removeChild(sc);
+        });
+        // return replay.subject.asObservable();
+        const resp = firstValueFrom(replay.subject.asObservable());
+        resp.observable = replay.subject.asObservable();
+        resp.cache = RequestCache.findBy({
+            body,
+            isArray,
+            method,
+            url
+        });
+        return resp;
+    }
+    replay(method, meta) {
+        const replay = this.getReplay(method, meta, true);
+        if (!replay || !replay.data) {
+            console.warn(`Canno replay first ${method} request from ${meta.endpoint}/${meta.path}`);
+            return;
+        }
+        ;
+        if (replay && replay.subject && Array.isArray(replay.subject.observers) &&
+            replay.subject.observers.length === 0) {
+            console.warn(`No observators for ${method} request from ${meta.endpoint}/${meta.path}`);
+            return;
+        }
+        const url = replay.data.url;
+        const headers = replay.data.headers;
+        const body = replay.data.body;
+        const isArray = replay.data.isArray;
+        setTimeout(() => this.req(url, method, headers, body, replay.id, isArray));
+    }
+}
+RestRequest.jobId = 0;
+
+const log = Log.create('resouce-service', Level.__NOTHING);
+class Resource {
+    //#endregion
+    //#region constructor
+    constructor() {
+        setTimeout(() => {
+            const zone = this.getZone();
+            if (!RestRequest.zone) {
+                RestRequest.zone = zone;
+            }
+            ;
+        });
+    }
+    static get listenErrors() {
+        return this._listenErrors.asObservable();
+    }
+    //#region private mthods and fields
+    getZone() {
+        const isNode = (typeof window === 'undefined');
+        if (isNode) {
+            return;
+        }
+        ;
+        const ng = window['ng'];
+        const getAllAngularRootElements = window['getAllAngularRootElements'];
+        if (!ng || !getAllAngularRootElements) {
+            return;
+        }
+        const probe = ng.probe;
+        const coreTokens = ng.coreTokens;
+        if (!coreTokens || !coreTokens.NgZone) {
+            return;
+        }
+        const zoneClass = coreTokens.NgZone;
+        if (!probe || typeof probe !== 'function' || !getAllAngularRootElements) {
+            return;
+        }
+        const angularElements = getAllAngularRootElements();
+        if (!Array.isArray(angularElements) || angularElements.length === 0) {
+            return;
+        }
+        const rootElement = ng.probe(angularElements[0]);
+        if (!rootElement) {
+            return;
+        }
+        const injector = rootElement.injector;
+        if (!injector || !injector.get || typeof injector.get !== 'function') {
+            return;
+        }
+        const zone = injector.get(zoneClass);
+        return zone;
+    }
+    static initAngularNgZone(zone) {
+        RestRequest.zone = zone;
+    }
+    checkNestedModels(model, allModels) {
+        // if (model.indexOf('/') !== -1) { //TODO make this better, becouse now I unecesary checking shit
+        for (let p in allModels) {
+            if (allModels.hasOwnProperty(p)) {
+                let m = allModels[p];
+                if (isValid(p)) {
+                    let urlModels = getModels(p);
+                    if (containsModels(model, urlModels)) {
+                        model = p;
+                        break;
+                    }
+                }
+            }
+        }
+        // }
+        return model;
+    }
+    static getModel(endpoint, model) {
+        model = Resource.prepareModel(model);
+        const e = Resource.endpoints[endpoint];
+        if (!e) {
+            return void 0;
+        }
+        const r = Resource.endpoints[endpoint].models[model];
+        return Resource.endpoints[endpoint].models[model];
+    }
+    //#endregion
+    //#region create
+    static create(e, model, entityMapping, circular) {
+        const badRestRegEX = new RegExp('((\/:)[a-z]+)+', 'g');
+        const matchArr = model.match(badRestRegEX) || [];
+        const badModelsNextToEachOther = matchArr.join();
+        const atleas2DoubleDots = ((badModelsNextToEachOther.match(new RegExp(':', 'g')) || []).length >= 2);
+        if (atleas2DoubleDots && model.search(badModelsNextToEachOther) !== -1) {
+            throw new Error(`
+
+Bad rest model: ${model}
+
+Do not create rest models like this:    /book/author/:bookid/:authorid
+Instead use nested approach:            /book/:bookid/author/:authorid
+            `);
+        }
+        ;
+        Resource.map(e, e);
+        Resource.instance.add(e, model ? model : '', entityMapping, circular);
+        // if (model.charAt(model.length - 1) !== '/') model = `${model}/`;
+        return {
+            model: (params) => Resource.instance.api(e, interpolateParamsToUrl(params, model)),
+            replay: (method) => {
+                Resource.getModel(e, model).replay(method);
+            },
+            get headers() {
+                return Resource.getModel(e, model).headers;
+            }
+        };
+    }
+    //#endregion
+    //#region reset
+    static reset() {
+        Resource.endpoints = {};
+    }
+    //#region map
+    static map(endpoint, url) {
+        log.i('url', url);
+        let regex = /(http|https):\/\/(\w+:{0,1}\w*)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%!\-\/]))?/;
+        let e = endpoint;
+        if (!regex.test(url)) {
+            throw `Url address is not correct: ${url}`;
+        }
+        if (url.charAt(url.length - 1) === '/')
+            url = url.slice(0, url.length - 1);
+        log.i('url after', url);
+        if (Resource.endpoints[e] !== void 0) {
+            !global.hideLog && console.warn('Cannot use map function at the same API endpoint again ('
+                + Resource.endpoints[e].url + ')');
+            return false;
+        }
+        Resource.endpoints[e] = {
+            url: url,
+            models: {},
+            entity: null
+        };
+        log.i('enpoints', Resource.endpoints);
+        return true;
+    }
+    //#endregion
+    static prepareModel(model) {
+        if (model.charAt(model.length - 1) === '/')
+            model = model.slice(0, model.length - 1);
+        if (model.charAt(0) === '/')
+            model = model.slice(1, model.length);
+        return model;
+    }
+    //#region add
+    /**
+     * And enipoint to application
+     *
+     * @param {E} endpoint
+     * @param {string} model
+     * @returns {boolean}
+     */
+    add(endpoint, model, entity, circular) {
+        log.i(`I am maping ${model} on ${endpoint}`);
+        model = Resource.prepareModel(model);
+        let e;
+        e = (endpoint).toString();
+        if (Resource.endpoints[e] === void 0) {
+            console.error('Endpoint is not mapped ! Cannot add model ' + model);
+            return;
+        }
+        if (Resource.endpoints[e].models[model] !== void 0) {
+            if (Resource.enableWarnings)
+                console.warn(`Model '${model}' is already defined in endpoint: `
+                    + Resource.endpoints[e].url);
+            return;
+        }
+        Resource.endpoints[e].models[model] =
+            new Rest(Resource.endpoints[e].url
+                + '/' + model, Resource.request, {
+                endpoint: e,
+                path: model,
+                entity,
+                circular
+            });
+        return;
+    }
+    //#endregion
+    //#region api
+    /**
+     * Access api throught endpoint
+     *
+     * @param {E} endpoint
+     * @param {string} model
+     * @returns {Rest<T, TA>}
+     */
+    api(endpoint, model) {
+        // log.i(`[api]
+        // creating for endpoint: "${endpoint}"
+        // model: "${model}"
+        // `)
+        if (model.charAt(0) === '/')
+            model = model.slice(1, model.length);
+        let e = (endpoint).toString();
+        if (Resource.endpoints[e] === void 0) {
+            throw `Endpoint: ${endpoint} is not mapped ! Cannot add model: ${model}`;
+        }
+        let allModels = Resource.endpoints[e].models;
+        let orgModel = model;
+        model = this.checkNestedModels(model, allModels);
+        if (Resource.endpoints[e].models[model] === void 0) {
+            // log.d('Resource.endpoints', Resource.endpoints);
+            throw `Model '${model}' is undefined in endpoint: ${Resource.endpoints[e].url} `;
+        }
+        let res = Resource.endpoints[(endpoint).toString()].models[model];
+        // log.d(`
+        // orgModel: ${orgModel}
+        // model: ${model}
+        // `)
+        if (orgModel !== model) {
+            let baseUrl = Resource.endpoints[(endpoint).toString()].url;
+            // log.d('base', Resource.endpoints[<string>(endpoint).toString()])
+            // log.d('baseUrl', baseUrl)
+            // log.d('orgModel', orgModel)
+            res.__rest_endpoint = `${baseUrl}/${orgModel}`;
+        }
+        else {
+            res.__rest_endpoint = void 0;
+        }
+        ;
+        // log.i(`Resource.endpoints`, Resource.endpoints)
+        return res;
+    }
+}
+Resource.DEFAULT_HEADERS = RestHeaders.from({
+    'Content-Type': 'application/json',
+    'Accept': 'application/json'
+});
+Resource._listenErrors = new Subject();
+Resource.enableWarnings = true;
+Resource.instance = new Resource();
+Resource.endpoints = {};
+Resource.request = new RestRequest();
+//#endregion
+Resource.Cookies = Cookie.Instance;
+// const res = Resource.create('')
+// res.model()
+//   .mock({
+//     code: 500,
+//     data: {},
+//     isArray: true
+//   })
+//   .array.
+
+/**
+ *
+ * @export
+ * @abstract
+ * @class SimpleResource
+ * @extends {Resource<T, A, TA>}
+ * @template E  Endpoint type
+ * @template A Single modle type
+ * @template TA Array Model Type
+ * @template RP rest url parameters type
+ * @template QP query parameter type
+ */
+class ExtendedResource {
+    // add(endpoint: E, model: string, group?: string, name?: string, description?: string) { }
+    constructor(endpoint, path_model) {
+        this.endpoint = endpoint;
+        this.path_model = path_model;
+        /**
+         * Get model by rest params
+        */
+        this.model = (restParams) => {
+            return {
+                get: (queryPrams) => {
+                    return Observable.create((observer) => {
+                        ExtendedResource.handlers.push(this.rest.model(restParams)
+                            .get([queryPrams], ExtendedResource.doNotSerializeQueryParams)
+                            .observable
+                            .subscribe(data => observer.next(data.body.json), err => observer.error(err), () => observer.complete()));
+                    });
+                },
+                patch: (item, queryParams) => {
+                    return Observable.create((observer) => {
+                        ExtendedResource.handlers.push(this.rest.model(restParams)
+                            .put(item, [queryParams], ExtendedResource.doNotSerializeQueryParams)
+                            .observable
+                            .subscribe(data => observer.next(data.body.json), err => observer.error(err), () => observer.complete()));
+                    });
+                },
+                head: (queryPrams) => {
+                    return Observable.create((observer) => {
+                        ExtendedResource.handlers.push(this.rest.model(restParams)
+                            .head([queryPrams], ExtendedResource.doNotSerializeQueryParams)
+                            .observable
+                            .subscribe(data => observer.next(data.body.json), err => observer.error(err), () => observer.complete()));
+                    });
+                },
+                query: (queryPrams) => {
+                    return Observable.create((observer) => {
+                        ExtendedResource.handlers.push(this.rest.model(restParams).
+                            array
+                            .get([queryPrams], ExtendedResource.doNotSerializeQueryParams)
+                            .observable
+                            .subscribe(data => observer.next(data.body.json), err => observer.error(err), () => observer.complete()));
+                    });
+                },
+                post: (item, queryParams) => {
+                    return Observable.create((observer) => {
+                        ExtendedResource.handlers.push(this.rest.model(restParams)
+                            .post(item, [queryParams], ExtendedResource.doNotSerializeQueryParams)
+                            .observable
+                            .subscribe(data => observer.next(data.body.json), err => observer.error(err), () => observer.complete()));
+                    });
+                },
+                put: (item, queryParams) => {
+                    return Observable.create((observer) => {
+                        ExtendedResource.handlers.push(this.rest.model(restParams)
+                            .put(item, [queryParams], ExtendedResource.doNotSerializeQueryParams)
+                            .observable
+                            .subscribe(data => observer.next(data.body.json), err => observer.error(err), () => observer.complete()));
+                    });
+                },
+                delete: (queryPrams) => {
+                    return Observable.create((observer) => {
+                        ExtendedResource.handlers.push(this.rest.model(restParams)
+                            .delete([queryPrams], ExtendedResource.doNotSerializeQueryParams)
+                            .observable
+                            .subscribe(data => observer.next(data.body.json), err => observer.error(err), () => observer.complete()));
+                    });
+                }
+            };
+        };
+        this.rest = Resource.create(endpoint, path_model);
+    }
+}
+ExtendedResource.doNotSerializeQueryParams = false;
+ExtendedResource.handlers = [];
+/**
+ *
+ * @export
+ * @class SimpleResource
+ * @template A single model type
+ * @template TA array model type
+ * @template RP rest parameters type
+ * @template QP query parameters type
+ */
+class SimpleResource {
+    constructor(endpoint, model) {
+        let rest = new ExtendedResource(endpoint, model);
+        this.model = rest.model;
+    }
+    static set doNotSerializeQueryParams(value) {
+        if (!SimpleResource._isSetQueryParamsSerialization) {
+            SimpleResource._isSetQueryParamsSerialization = true;
+            ExtendedResource.doNotSerializeQueryParams = value;
+            return;
+        }
+        console.warn(`Query params serialization already set as
+        ${ExtendedResource.doNotSerializeQueryParams},`);
+    }
+    static __destroy() {
+        ExtendedResource.handlers.forEach(h => h.unsubscribe());
+    }
+}
+SimpleResource._isSetQueryParamsSerialization = false;
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DEFAULT_HEADERS, Helpers, Mapping, Models, RequestCache, Resource, Rest, RestHeaders, SimpleResource, interpolateParamsToUrl };
+//# sourceMappingURL=ng2-rest.mjs.map