ng2-rest 13.2.9 → 16.0.11

package/client/esm2022/lib/resource.service.mjs

@@ -0,0 +1,221 @@
+import { Subject } from 'rxjs';
+import { Log, Level } from 'ng2-logger/browser';
+const log = Log.create('resouce-service', Level.__NOTHING);
+import { Rest } from './rest.class';
+import { RestRequest } from './rest-request';
+import { Cookie } from './cookie';
+import { interpolateParamsToUrl, isValid, containsModels, getModels } from './params';
+import { Helpers } from 'tnp-core/browser';
+class Resource {
+    static { this._listenErrors = new Subject(); }
+    static { this._listenSuccess = new Subject(); }
+    static get listenErrors() {
+        return this._listenErrors.asObservable();
+    }
+    static get listenSuccessOperations() {
+        return this._listenSuccess.asObservable();
+    }
+    static { this.enableWarnings = true; }
+    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) {
+        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 { this.instance = new Resource(); }
+    static { this.endpoints = {}; }
+    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];
+    }
+    static { this.request = new RestRequest(); }
+    static create(e, model, entityMapping, circular, customContentType) {
+        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, customContentType);
+        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;
+            }
+        };
+    }
+    static reset() {
+        Resource.endpoints = {};
+    }
+    constructor() {
+        setTimeout(() => {
+            const zone = this.getZone();
+            if (!RestRequest.zone) {
+                RestRequest.zone = zone;
+            }
+            ;
+        });
+    }
+    static { this.Cookies = Cookie.Instance; }
+    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) {
+            Helpers.log('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;
+    }
+    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;
+    }
+    /**
+     * And enipoint to application
+     *
+     * @param {E} endpoint
+     * @param {string} model
+     * @returns {boolean}
+     */
+    add(endpoint, model, entity, circular, customContentType) {
+        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,
+            }, customContentType); // TODO put custom content type in meta ?
+        return;
+    }
+    /**
+     * Access api throught endpoint
+     *
+     * @param {E} endpoint
+     * @param {string} model
+     * @returns {Rest<T, TA>}
+     */
+    api(endpoint, 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) {
+            throw `Model '${model}' is undefined in endpoint: ${Resource.endpoints[e].url} `;
+        }
+        let res = Resource.endpoints[(endpoint).toString()].models[model];
+        if (orgModel !== model) {
+            let baseUrl = Resource.endpoints[(endpoint).toString()].url;
+            res.__rest_endpoint = `${baseUrl}/${orgModel}`;
+        }
+        else {
+            res.__rest_endpoint = void 0;
+        }
+        ;
+        return res;
+    }
+}
+export { Resource };
+;
+({}); // @--end-of-file-for-module=ng2-rest lib/resource.service.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"resource.service.js","sourceRoot":"","sources":["../../../../tmp-libs-for-bundle/ng2-rest/projects/ng2-rest/src/lib/resource.service.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { Observable } from 'rxjs';\nimport { Subject } from 'rxjs';\nimport { Log, Level } from 'ng2-logger/browser';\nconst log = Log.create('resouce-service',\n  Level.__NOTHING\n)\n\nimport { Rest } from './rest.class';\nimport { RestRequest } from './rest-request';\nimport { RestHeaders } from './rest-headers';\nimport { Cookie } from './cookie';\nimport { Mapping } from './mapping';\nimport { Models } from './models';\nimport { interpolateParamsToUrl, isValid, containsModels, getModels } from './params';\nimport { Circ } from 'json10/browser';\nimport { Helpers } from 'tnp-core/browser'\n\n\ndeclare const global: any;\n\n\nexport class Resource<E, T, TA> {\n  protected static _listenErrors = new Subject<Models.BackendError>();\n  protected static _listenSuccess = new Subject<Models.HttpResponse<any>>();\n  public static get listenErrors() {\n    return this._listenErrors.asObservable();\n  }\n\n  public static get listenSuccessOperations() {\n    return this._listenSuccess.asObservable();\n  }\n  public static enableWarnings: boolean = true;\n\n\n  private getZone() {\n    const isNode = (typeof window === 'undefined')\n    if (isNode) { return };\n    const ng = window['ng'];\n    const getAllAngularRootElements = window['getAllAngularRootElements'];\n    if (!ng || !getAllAngularRootElements) { return; }\n    const probe = ng.probe;\n    const coreTokens = ng.coreTokens;\n    if (!coreTokens || !coreTokens.NgZone) { return; }\n    const zoneClass = coreTokens.NgZone;\n    if (!probe || typeof probe !== 'function' || !getAllAngularRootElements) { return; }\n    const angularElements: any[] = getAllAngularRootElements();\n    if (!Array.isArray(angularElements) || angularElements.length === 0) { return; }\n    const rootElement = ng.probe(angularElements[0]);\n    if (!rootElement) { return; }\n    const injector = rootElement.injector;\n    if (!injector || !injector.get || typeof injector.get !== 'function') { return; }\n    const zone = injector.get(zoneClass)\n    return zone;\n  }\n\n\n  public static initAngularNgZone(zone) {\n    RestRequest.zone = zone;\n  }\n\n  private checkNestedModels(model: string, allModels: Object) {\n\n    for (let p in allModels) {\n      if (allModels.hasOwnProperty(p)) {\n        let m = allModels[p];\n        if (isValid(p)) {\n          let urlModels = getModels(p);\n          if (containsModels(model, urlModels)) {\n            model = p;\n            break;\n          }\n        }\n      }\n    }\n\n    return model;\n  }\n\n  private static instance = new Resource<string, any, any>();\n  private static endpoints = {};\n  public static getModel(endpoint: string, model: string): Rest<any> {\n    model = Resource.prepareModel(model);\n    const e = Resource.endpoints[endpoint];\n    if (!e) { return void 0; }\n    const r = Resource.endpoints[endpoint].models[model];\n    return Resource.endpoints[endpoint].models[model];\n  }\n  private static request: RestRequest = new RestRequest();\n\n\n\n\n  public static create<A, TA = A[]>(\n    e: string,\n    model?: string,\n    entityMapping?: Mapping.Mapping,\n    circular?: Circ[],\n    customContentType?: RestHeaders,\n  ): Models.ResourceModel<A, TA> {\n    const badRestRegEX = new RegExp('((\\/:)[a-z]+)+', 'g');\n    const matchArr = model.match(badRestRegEX) || [];\n    const badModelsNextToEachOther = matchArr.join();\n    const atleas2DoubleDots = ((badModelsNextToEachOther.match(new RegExp(':', 'g')) || []).length >= 2);\n    if (atleas2DoubleDots && model.search(badModelsNextToEachOther) !== -1) {\n      throw new Error(`\n\nBad rest model: ${model}\n\nDo not create rest models like this:    /book/author/:bookid/:authorid\nInstead use nested approach:            /book/:bookid/author/:authorid\n            `)\n    };\n    Resource.map(e, e);\n    Resource.instance.add(e, model ? model : '', entityMapping, circular, customContentType);\n\n    return {\n      model: (params?: Object) => Resource.instance.api(\n        e,\n        interpolateParamsToUrl(params, model)\n      ),\n      replay: (method: Models.HttpMethod) => {\n        Resource.getModel(e, model).replay(method);\n      },\n      get headers() {\n        return Resource.getModel(e, model).headers;\n      }\n    }\n  }\n\n\n\n  public static reset() {\n    Resource.endpoints = {};\n  }\n\n\n\n  private constructor() {\n    setTimeout(() => {\n      const zone = this.getZone();\n      if (!RestRequest.zone) { RestRequest.zone = zone };\n    })\n  }\n\n\n  public static Cookies = Cookie.Instance;\n\n\n  private static map(endpoint: string, url: string): boolean {\n\n    log.i('url', url)\n    let regex = /(http|https):\\/\\/(\\w+:{0,1}\\w*)?(\\S+)(:[0-9]+)?(\\/|\\/([\\w#!:.?+=&%!\\-\\/]))?/;\n    let e = endpoint;\n    if (!regex.test(url)) {\n      throw `Url address is not correct: ${url}`;\n    }\n    if (url.charAt(url.length - 1) === '/') url = url.slice(0, url.length - 1);\n    log.i('url after', url)\n    if (Resource.endpoints[e] !== void 0) {\n      Helpers.log('Cannot use map function at the same API endpoint again ('\n        + Resource.endpoints[e].url + ')');\n      return false;\n    }\n    Resource.endpoints[e] = {\n      url: url,\n      models: {},\n      entity: null\n    };\n    log.i('enpoints', Resource.endpoints)\n    return true;\n  }\n\n\n  private static prepareModel(model) {\n    if (model.charAt(model.length - 1) === '/') model = model.slice(0, model.length - 1);\n    if (model.charAt(0) === '/') model = model.slice(1, model.length);\n    return model;\n  }\n\n\n\n  /**\n   * And enipoint to application\n   *\n   * @param {E} endpoint\n   * @param {string} model\n   * @returns {boolean}\n   */\n  private add(endpoint: E, model: string, entity: Mapping.Mapping, circular?: Circ[], customContentType?: RestHeaders) {\n    log.i(`I am maping ${model} on ${<any>endpoint}`);\n    model = Resource.prepareModel(model);\n\n    let e: string;\n    e = <string>(endpoint).toString();\n\n    if (Resource.endpoints[e] === void 0) {\n      console.error('Endpoint is not mapped ! Cannot add model ' + model);\n      return;\n    }\n    if (Resource.endpoints[e].models[model] !== void 0) {\n      if (Resource.enableWarnings) console.warn(`Model '${model}' is already defined in endpoint: `\n        + Resource.endpoints[e].url);\n      return;\n    }\n    Resource.endpoints[e].models[model] =\n      new Rest<T, TA>(Resource.endpoints[e].url\n        + '/' + model, Resource.request, {\n        endpoint: e,\n        path: model,\n        entity,\n        circular,\n      }, customContentType); // TODO put custom content type in meta ?\n    return;\n  }\n\n\n\n  /**\n   * Access api throught endpoint\n   *\n   * @param {E} endpoint\n   * @param {string} model\n   * @returns {Rest<T, TA>}\n   */\n  private api(endpoint: E, model: string): Rest<T, TA> {\n\n\n\n\n\n\n    if (model.charAt(0) === '/') model = model.slice(1, model.length);\n    let e = <string>(endpoint).toString();\n    if (Resource.endpoints[e] === void 0) {\n      throw `Endpoint: ${<any>endpoint} is not mapped ! Cannot add model: ${model}`;\n    }\n    let allModels: Object = Resource.endpoints[e].models;\n    let orgModel = model;\n    model = this.checkNestedModels(model, allModels);\n\n    if (Resource.endpoints[e].models[model] === void 0) {\n\n      throw `Model '${model}' is undefined in endpoint: ${Resource.endpoints[e].url} `;\n    }\n\n    let res: Rest<T, TA> = Resource.endpoints[<string>(endpoint).toString()].models[model];\n\n\n\n\n\n\n    if (orgModel !== model) {\n      let baseUrl = Resource.endpoints[<string>(endpoint).toString()].url;\n\n\n\n      res.__rest_endpoint = `${baseUrl}/${orgModel}`;\n    } else {\n      res.__rest_endpoint = void 0;\n    };\n\n\n    return res;\n  }\n\n\n}\n\n\n\n\n\n\n\n\n\n\n\n\n ;({}); // @--end-of-file-for-module=ng2-rest lib/resource.service.ts"]}

package/client/esm2022/lib/rest-headers.mjs

@@ -0,0 +1,129 @@
+export class RestHeaders {
+    static from(headers) {
+        if (!headers) {
+            return void 0;
+        }
+        return new RestHeaders(headers);
+    }
+    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));
+            });
+        }
+    }
+    /**
+     * 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.
+     */
+    toJSON() {
+        const serialized = {};
+        if (!this._headers) {
+        }
+        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);
+        }
+    }
+}
+;
+({}); // @--end-of-file-for-module=ng2-rest lib/rest-headers.ts
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rest-headers.js","sourceRoot":"","sources":["../../../../tmp-libs-for-bundle/ng2-rest/projects/ng2-rest/src/lib/rest-headers.ts"],"names":[],"mappings":"AAKA,MAAM,OAAO,WAAW;IAOf,MAAM,CAAC,IAAI,CAAC,OAA4B;QAC7C,IAAI,CAAC,OAAO,EAAE;YACZ,OAAO,KAAK,CAAC,CAAC;SACf;QACD,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC;IAClC,CAAC;IAED,YAAoB,OAA+D;QAbnF,4CAA4C;QAC5C,aAAQ,GAA0B,IAAI,GAAG,EAAE,CAAC;QAC5C,qDAAqD;QACrD,qBAAgB,GAAwB,IAAI,GAAG,EAAE,CAAC;QAWhD,IAAI,OAAO,YAAY,WAAW,EAAE;YAClC,OAAO,CAAC,OAAO,CAAC,CAAC,MAAgB,EAAE,IAAY,EAAE,EAAE;gBACjD,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;YACjD,CAAC,CAAC,CAAC;SACJ;aAAM;YACL,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,OAAO,CAAC,CAAC,IAAY,EAAE,EAAE;gBAC5C,MAAM,MAAM,GAAa,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAQ,CAAC;gBACjG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;gBAClB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;YACjD,CAAC,CAAC,CAAC;SACJ;IACH,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,wBAAwB,CAAC,aAAqB;QACnD,MAAM,OAAO,GAAG,IAAI,WAAW,EAAE,CAAC;QAIlC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACvC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAChC,IAAI,KAAK,GAAG,CAAC,EAAE;gBACb,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;gBAClC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;gBAC3C,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;aAC1B;QACH,CAAC,CAAC,CAAC;QAEH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAY,EAAE,KAAa;QAChC,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAEjC,IAAI,MAAM,KAAK,IAAI,EAAE;YACnB,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;SACvB;aAAM;YACL,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;SACpB;IACH,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAY;QACjB,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAClC,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QACrC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IAC/B,CAAC;IAED,OAAO,CAAC,EAA4E;QAClF,IAAI,CAAC,QAAQ,CAAC,OAAO,CACnB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;IACtF,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,IAAY;QACd,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAEjC,IAAI,MAAM,KAAK,IAAI,EAAE;YACnB,OAAO,IAAI,CAAC;SACb;QAED,OAAO,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IAC9C,CAAC;IAED;;OAEG;IACH,GAAG,CAAC,IAAY,IAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;IAE5E;;OAEG;IACH,IAAI,KAAe,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAEvE;;OAEG;IACH,GAAG,CAAC,IAAY,EAAE,KAAwB;QACxC,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE;YACxB,IAAI,KAAK,CAAC,MAAM,EAAE;gBAChB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;aAC1D;SACF;aAAM;YACL,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;SAChD;QACD,IAAI,CAAC,sBAAsB,CAAC,IAAI,CAAC,CAAC;IACpC,CAAC;IAED;;OAEG;IACH,MAAM,KAAiB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;IAEnE;;OAEG;IAEH,MAAM;QACJ,MAAM,UAAU,GAAiC,EAAE,CAAC;QACpD,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE;SAGnB;QAED,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,MAAgB,EAAE,IAAY,EAAE,EAAE;YACvD,MAAM,KAAK,GAAa,EAAE,CAAC;YAC3B,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;YAKjD,UAAU,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,GAAG,KAAK,CAAC;QACtD,CAAC,CAAC,CAAC;QAEH,OAAO,UAAU,CAAC;IACpB,CAAC;IAED;;OAEG;IACH,MAAM,CAAC,IAAY;QACjB,OAAO,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;IACvE,CAAC;IAEO,sBAAsB,CAAC,IAAY;QACzC,MAAM,MAAM,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;QAElC,IAAI,CAAC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE;YACtC,IAAI,CAAC,gBAAgB,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;SACzC;IACH,CAAC;CACF;AAGA,CAAC;AAAA,CAAC,EAAE,CAAC,CAAC,CAAC,yDAAyD","sourcesContent":["/**\n * Based on Headers from https://github.com/angular/angular/blob/master/packages/http/src/headers.ts\n */\nexport type RestHeadersOptions = RestHeaders | { [name: string]: (string | string[]) }\n\nexport class RestHeaders {\n  /** @internal header names are lower case */\n  _headers: Map<string, string[]> = new Map();\n  /** @internal map lower case names to actual names */\n  _normalizedNames: Map<string, string> = new Map();\n\n\n  public static from(headers?: RestHeadersOptions) {\n    if (!headers) {\n      return void 0;\n    }\n    return new RestHeaders(headers);\n  }\n\n  private constructor(headers?: RestHeaders | { [name: string]: (string | string[]) }) {\n    if (headers instanceof RestHeaders) {\n      headers.forEach((values: string[], name: string) => {\n        values.forEach(value => this.set(name, value));\n      });\n    } else {\n      Object.keys(headers).forEach((name: string) => {\n        const values: string[] = (Array.isArray(headers[name]) ? headers[name] : [headers[name]]) as any;\n        this.delete(name);\n        values.forEach(value => this.set(name, value));\n      });\n    }\n  }\n\n  /**\n   * Returns a new RestHeaders instance from the given DOMString of Response RestHeaders\n   */\n  static fromResponseHeaderString(headersString: string): RestHeaders {\n    const headers = new RestHeaders();\n\n\n\n    headersString.split('\\n').forEach(line => {\n      const index = line.indexOf(':');\n      if (index > 0) {\n        const name = line.slice(0, index);\n        const value = line.slice(index + 1).trim();\n        headers.set(name, value);\n      }\n    });\n\n    return headers;\n  }\n\n  /**\n   * Appends a header to existing list of header values for a given header name.\n   */\n  append(name: string, value: string): void {\n    const values = this.getAll(name);\n\n    if (values === null) {\n      this.set(name, value);\n    } else {\n      values.push(value);\n    }\n  }\n\n  /**\n   * Deletes all header values for the given name.\n   */\n  delete(name: string): void {\n    const lcName = name.toLowerCase();\n    this._normalizedNames.delete(lcName);\n    this._headers.delete(lcName);\n  }\n\n  forEach(fn: (values: string[], name: string, headers: Map<string, string[]>) => void): void {\n    this._headers.forEach(\n      (values, lcName) => fn(values, this._normalizedNames.get(lcName), this._headers));\n  }\n\n  /**\n   * Returns first header that matches given name.\n   */\n  get(name: string): string {\n    const values = this.getAll(name);\n\n    if (values === null) {\n      return null;\n    }\n\n    return values.length > 0 ? values[0] : null;\n  }\n\n  /**\n   * Checks for existence of header by given name.\n   */\n  has(name: string): boolean { return this._headers.has(name.toLowerCase()); }\n\n  /**\n   * Returns the names of the headers\n   */\n  keys(): string[] { return Array.from(this._normalizedNames.values()); }\n\n  /**\n   * Sets or overrides header value for given name.\n   */\n  set(name: string, value: string | string[]): void {\n    if (Array.isArray(value)) {\n      if (value.length) {\n        this._headers.set(name.toLowerCase(), [value.join(',')]);\n      }\n    } else {\n      this._headers.set(name.toLowerCase(), [value]);\n    }\n    this.mayBeSetNormalizedName(name);\n  }\n\n  /**\n   * Returns values of all headers.\n   */\n  values(): string[][] { return Array.from(this._headers.values()); }\n\n  /**\n   * Returns string of all headers.\n   */\n\n  toJSON(): { [name: string]: any } {\n    const serialized: { [name: string]: string[] } = {};\n    if (!this._headers) {\n\n\n    }\n\n    this._headers.forEach((values: string[], name: string) => {\n      const split: string[] = [];\n      values.forEach(v => split.push(...v.split(',')));\n\n\n\n\n      serialized[this._normalizedNames.get(name)] = split;\n    });\n\n    return serialized;\n  }\n\n  /**\n   * Returns list of header values for a given name.\n   */\n  getAll(name: string): string[] {\n    return this.has(name) ? this._headers.get(name.toLowerCase()) : null;\n  }\n\n  private mayBeSetNormalizedName(name: string): void {\n    const lcName = name.toLowerCase();\n\n    if (!this._normalizedNames.has(lcName)) {\n      this._normalizedNames.set(lcName, name);\n    }\n  }\n}\n\n\n ;({}); // @--end-of-file-for-module=ng2-rest lib/rest-headers.ts"]}