ng2-rest 21.0.49 → 21.0.52

package/lib-esm/lib/ng2-rest.js

@@ -0,0 +1,998 @@
+//#region imports
+import { URL } from 'url'; // @backend
+import axios from 'axios';
+import { JSON10 } from 'json10/lib';
+import { Level, Log } from 'ng2-logger/lib';
+import { firstValueFrom, from, Observable, shareReplay, Subject, } from 'rxjs';
+import { CoreModels, Helpers, _ } from 'tnp-core/lib';
+import { CLASS } from 'typescript-class-helpers/lib';
+import { encodeMapping } from './new-mapping';
+// import { Mapping } from './mapping';
+//#endregion
+const log = Log.create('ng2-rest', Level.WARN, Level.ERROR);
+const listenErrorsSrc = new Subject();
+//#region cookie
+// TODO do it for nodejs
+// import { CookieJar } from 'tough-cookie';
+// const jar = new CookieJar();
+// const rest = Resource.create('http://my-website.pl', 'api/v3/user/:userId', {
+//   cookieJar: jar,
+// });
+// await rest.model({ userId: 1 }).get(); // cookies persist across requests
+// import type { CookieJar } from 'tough-cookie';
+// interface ResourceOptions {
+//   // ...
+//   cookieJar?: CookieJar;
+// }
+// export class CookieJarInterceptor implements TaonAxiosClientInterceptor<any> {
+//   constructor(private readonly jar: CookieJar) {}
+//   intercept({ req, next }: TaonClientMiddlewareInterceptOptions<any>) {
+//     return new Observable<AxiosResponse<any>>(subscriber => {
+//       const url = req.url || '';
+//       // 1) attach Cookie header from jar
+//       this.jar.getCookieString(url, (err, cookieString) => {
+//         if (err) {
+//           subscriber.error(err);
+//           return;
+//         }
+//         if (cookieString) {
+//           req.headers = req.headers || {};
+//           // axios headers can be plain object or AxiosHeaders
+//           if (req.headers instanceof AxiosHeaders) {
+//             req.headers.set('Cookie', cookieString);
+//           } else {
+//             (req.headers as any)['Cookie'] = cookieString;
+//           }
+//         }
+//         // 2) proceed
+//         const sub = next.handle(req).subscribe({
+//           next: res => {
+//             // 3) store Set-Cookie back into jar
+//             const setCookie = (res.headers as any)?.['set-cookie'];
+//             const cookies: string[] =
+//               typeof setCookie === 'string'
+//                 ? [setCookie]
+//                 : Array.isArray(setCookie)
+//                   ? setCookie
+//                   : [];
+//             if (!cookies.length) {
+//               subscriber.next(res);
+//               return;
+//             }
+//             let pending = cookies.length;
+//             for (const c of cookies) {
+//               this.jar.setCookie(c, url, () => {
+//                 pending--;
+//                 if (pending === 0) {
+//                   subscriber.next(res);
+//                 }
+//               });
+//             }
+//           },
+//           error: e => subscriber.error(e),
+//           complete: () => subscriber.complete(),
+//         });
+//         return () => sub.unsubscribe();
+//       });
+//     });
+//   }
+// }
+export class Cookie {
+    static get Instance() {
+        if (!Cookie.__instance) {
+            Cookie.__instance = new Cookie();
+        }
+        return Cookie.__instance;
+    }
+    static __instance;
+    constructor() { }
+    read(name) {
+        if (typeof document === 'undefined')
+            return null;
+        var result = new RegExp('(?:^|; )' + encodeURIComponent(name) + '=([^;]*)').exec(document.cookie);
+        return result ? result[1] : null;
+    }
+    write(name, value, days) {
+        if (typeof document === 'undefined')
+            return null;
+        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) {
+        if (typeof document === 'undefined')
+            return null;
+        this.write(name, '', -1);
+    }
+}
+//#endregion
+//#region get params url
+/**
+ * Create query params string for url
+ *
+ * @export
+ * @param {UrlParams[]} params
+ * @returns {string}
+ */
+export function getParamsUrl(params, doNotSerialize = false) {
+    params = _.cloneDeep(params); // TODO refactor it
+    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('&')}`;
+}
+//#endregion
+//#region interpolate utils
+export const regexisPath = /[^\..]+(\.[^\..]+)+/g;
+/**
+ * Models like books/:id
+ */
+const 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);
+        }
+    }
+};
+/**
+ * let pattern = '/books/:bookid';
+ * let url = `/books/34`;
+ */
+export 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;
+}
+// Optional helper for passing around context (browser/client)
+// === Backend handler (last in chain) ===
+export class AxiosBackendHandler {
+    handle(req) {
+        // axios returns a Promise; wrap as Observable
+        return from(axios.request(req));
+    }
+}
+// === Chain builder (request: forward order, response: reverse order) ===
+export const buildInterceptorChain = (globalInterceptors, backend) => {
+    return globalInterceptors.reduceRight((next, interceptor) => ({
+        handle: req => interceptor.intercept({ req, next }),
+    }), backend);
+};
+export class RestHeaders {
+    /** @internal header names are lower case */
+    _headers = new Map();
+    /** @internal map lower case names to actual names */
+    _normalizedNames = new Map();
+    static from(headers) {
+        return new RestHeaders(headers || {});
+    }
+    apply(headers) {
+        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));
+            });
+        }
+        return this;
+    }
+    constructor(headers) {
+        this.apply(headers);
+    }
+    /**
+     * Returns a new RestHeaders instance from the given DOMString of Response RestHeaders
+     */
+    static fromResponseHeaderString(headersString) {
+        const headers = new RestHeaders();
+        // console.log({
+        //   headersString
+        // })
+        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
+        }
+        // console.log('serializing headers',this._headers)
+        this._headers.forEach((values, name) => {
+            const split = [];
+            values.forEach(v => split.push(...v.split(',')));
+            // console.log({
+            //   values
+            // })
+            // values.forEach(v => split.push(...(v ? 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
+//#region handle result source request options
+class RestCommonHttpResponseWrapper {
+}
+export class RestResponseWrapper extends RestCommonHttpResponseWrapper {
+}
+export class RestErrorResponseWrapper extends RestCommonHttpResponseWrapper {
+}
+//#endregion
+//#region base body
+export class BaseBody {
+    toJSON(data, opt) {
+        opt = opt || { isJSONArray: false };
+        let r = opt.isJSONArray ? [] : {};
+        if (typeof data === 'string') {
+            try {
+                let parsed = JSON.parse(data);
+                if (typeof parsed === 'string' && parsed.trim().startsWith('{')) {
+                    parsed = JSON.parse(parsed);
+                }
+                if (opt.parsingError && parsed[CoreModels.TaonHttpErrorCustomProp]) {
+                    return _.merge(new RestErrorResponseWrapper(), parsed);
+                }
+                return parsed;
+            }
+            catch (e) { }
+        }
+        else if (typeof data === 'object') {
+            return data;
+        }
+        return r;
+    }
+}
+export class HttpBody extends BaseBody {
+    url;
+    method;
+    headers;
+    responseText;
+    options;
+    isArray;
+    constructor(url, method, headers, responseText, options, isArray) {
+        super();
+        this.url = url;
+        this.method = method;
+        this.headers = headers;
+        this.responseText = responseText;
+        this.options = options;
+        this.isArray = isArray;
+    }
+    get entity() {
+        if (typeof this.options.responseMapping?.entity === 'string') {
+            // const headerWithMapping = headers.get(entity);
+            // console.log('header key ',this.options.responseMapping?.entity);
+            // console.log(this.headers)
+            let entityJSON = this.headers?.getAll(this.options.responseMapping?.entity);
+            if (!!entityJSON) {
+                return JSON.parse(entityJSON.join());
+            }
+        }
+        const entityAsResolvableFn = this.options?.responseMapping?.entity;
+        if (typeof entityAsResolvableFn === 'function') {
+            const mappingFromFunction = entityAsResolvableFn();
+            // console.log({ mappingFromFunction });
+            return mappingFromFunction;
+        }
+        return this.options.responseMapping?.entity;
+    }
+    get circular() {
+        if (typeof this.options.responseMapping?.circular === 'string') {
+            // const headerWithMapping = headers.get(circular);
+            let circuralJSON = this.headers?.getAll(this.options.responseMapping.circular);
+            if (!!circuralJSON) {
+                return JSON.parse(circuralJSON.join());
+            }
+        }
+        return (this.options.responseMapping?.circular || []);
+    }
+    get blob() {
+        return this.responseText;
+    }
+    get booleanValue() {
+        if (!Helpers.isBlob(this.responseText)) {
+            return ['ok', 'true'].includes(this.responseText?.trim());
+        }
+    }
+    get numericValue() {
+        if (!Helpers.isBlob(this.responseText)) {
+            return Number(this.responseText?.trim());
+        }
+    }
+    get rawJson() {
+        if (!Helpers.isBlob(this.responseText)) {
+            let res = this.toJSON(this.responseText, { isJSONArray: this.isArray });
+            if (this.circular && Array.isArray(this.circular)) {
+                res = JSON10.parse(JSON.stringify(res), this.circular);
+            }
+            return res;
+        }
+    }
+    get json() {
+        const isBlob = Helpers.isBlob(this.responseText);
+        if (isBlob) {
+            return void 0;
+        }
+        if (this.entity && typeof this.entity === 'object') {
+            const json = this.toJSON(this.responseText, {
+                isJSONArray: this.isArray,
+            });
+            // console.log({ entityMapping: this.entity })
+            const resEntityMapping = encodeMapping(json, this.entity, this.circular);
+            // console.log({ resEntityMapping })
+            this.displayWarningWhenNotUsingProperAPI(resEntityMapping);
+            return resEntityMapping;
+        }
+        let res = this.toJSON(this.responseText, { isJSONArray: this.isArray });
+        if (this.circular && Array.isArray(this.circular)) {
+            res = JSON10.parse(JSON.stringify(res), this.circular);
+        }
+        this.displayWarningWhenNotUsingProperAPI(res);
+        return res;
+    }
+    displayWarningWhenNotUsingProperAPI(res) {
+        if (!this.options.useArrayApiWarning) {
+            return;
+        }
+        if (this.isArray) {
+            Helpers.warn(`[${this.method}: ${this.url}]
+Your api response is object, but you are using .array api`);
+        }
+        else {
+            if (Array.isArray(res)) {
+                Helpers.warn(`[${this.method}: ${this.url}]
+Your api response is array, but you are using object api instread .arrray.`);
+            }
+        }
+    }
+    /**
+     * undefined when blob
+     */
+    get text() {
+        if (!Helpers.isBlob(this.responseText)) {
+            return this.responseText
+                .replace(/^\"/, '')
+                .replace(/\"$/, '');
+        }
+    }
+}
+export class ErrorBody extends BaseBody {
+    url;
+    data;
+    constructor(url, data) {
+        super();
+        this.url = url;
+        this.data = data;
+    }
+    get json() {
+        return this.toJSON(this.data, { parsingError: true });
+    }
+    get text() {
+        return this.data;
+    }
+}
+export class BaseResponse {
+    responseText;
+    options;
+    statusCode;
+    headers;
+    isArray;
+    constructor(responseText, options, statusCode, headers, isArray) {
+        this.responseText = responseText;
+        this.options = options;
+        this.statusCode = statusCode;
+        this.headers = headers;
+        this.isArray = isArray;
+    }
+}
+//#endregion
+//#region http response
+export class HttpResponse extends BaseResponse {
+    url;
+    method;
+    responseText;
+    headers;
+    statusCode;
+    options;
+    isArray;
+    body;
+    constructor(url, method, responseText, headers, statusCode, options, isArray) {
+        super(responseText, options, statusCode, headers, isArray);
+        this.url = url;
+        this.method = method;
+        this.responseText = responseText;
+        this.headers = headers;
+        this.statusCode = statusCode;
+        this.options = options;
+        this.isArray = isArray;
+        this.body = new HttpBody(url, method, headers, responseText, options, isArray);
+    }
+}
+export class HttpResponseError extends BaseResponse {
+    url;
+    method;
+    responseText;
+    options;
+    headers;
+    statusCode;
+    isArray;
+    body;
+    constructor(url, method, responseText, options, headers, statusCode, isArray) {
+        super(responseText, options, statusCode, headers, isArray);
+        this.url = url;
+        this.method = method;
+        this.responseText = responseText;
+        this.options = options;
+        this.headers = headers;
+        this.statusCode = statusCode;
+        this.isArray = isArray;
+        this.body = new ErrorBody(url, responseText);
+    }
+}
+//#region default headers
+export const HeaderKeyContentType = 'Content-Type';
+export const HeaderKeyAccept = 'Accept';
+export const DEFAULT_HEADERS = {
+    // JSON (most APIs)
+    APPLICATION_JSON: RestHeaders.from({
+        [HeaderKeyContentType]: 'application/json',
+        [HeaderKeyAccept]: 'application/json',
+    }),
+    // JSON:API (you already have)
+    APPLICATION_VND_API_JSON: RestHeaders.from({
+        [HeaderKeyContentType]: 'application/vnd.api+json',
+        [HeaderKeyAccept]: 'application/vnd.api+json',
+    }),
+    // Form URL encoded (old APIs, OAuth token endpoints)
+    APPLICATION_X_WWW_FORM_URLENCODED: RestHeaders.from({
+        [HeaderKeyContentType]: 'application/x-www-form-urlencoded',
+        [HeaderKeyAccept]: 'application/json',
+    }),
+    // Multipart form-data (file uploads) — note: boundary will be set by FormData in Node
+    MULTIPART_FORM_DATA: RestHeaders.from({
+        [HeaderKeyContentType]: 'multipart/form-data',
+        [HeaderKeyAccept]: 'application/json',
+    }),
+    // Plain text request/response (health checks, simple endpoints)
+    TEXT_PLAIN: RestHeaders.from({
+        [HeaderKeyContentType]: 'text/plain; charset=utf-8',
+        [HeaderKeyAccept]: 'text/plain',
+    }),
+    // Accept anything (downloads, weird backends)
+    ACCEPT_ANY: RestHeaders.from({
+        [HeaderKeyAccept]: '*/*',
+    }),
+    // Binary download (still just headers; axios responseType controls actual handling)
+    OCTET_STREAM: RestHeaders.from({
+        [HeaderKeyAccept]: 'application/octet-stream',
+    }),
+};
+//#endregion
+//#region abstract resource reponse class
+export class ResourceResponse {
+    httpMethodName;
+    urlOrigin;
+    urlPathname;
+    options;
+    body;
+    urlParams;
+    axiosOptions;
+    isArray;
+    headers;
+    globalInterceptors;
+    methodsInterceptors;
+    [Symbol.toStringTag] = 'Promise';
+    _promise;
+    _promiseAbort;
+    _observable;
+    //#region constructor
+    constructor(httpMethodName, urlOrigin, urlPathname, options, body, urlParams, axiosOptions, isArray, headers, globalInterceptors, methodsInterceptors) {
+        this.httpMethodName = httpMethodName;
+        this.urlOrigin = urlOrigin;
+        this.urlPathname = urlPathname;
+        this.options = options;
+        this.body = body;
+        this.urlParams = urlParams;
+        this.axiosOptions = axiosOptions;
+        this.isArray = isArray;
+        this.headers = headers;
+        this.globalInterceptors = globalInterceptors;
+        this.methodsInterceptors = methodsInterceptors;
+    }
+    /**
+     * ✅ Explicit cancel (useful for "promise style")
+     */
+    cancel(reason) {
+        this._promiseAbort?.abort(reason);
+    }
+    /**
+     * Promise API (cannot be auto-cancelled by consumer, so we expose cancel())
+     */
+    get promise() {
+        if (!this._promise) {
+            this._promiseAbort = new AbortController();
+            this._promise = this.makeRequest(this._promiseAbort.signal);
+        }
+        return this._promise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.promise.then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.promise.catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.promise.finally(onfinally);
+    }
+    /**
+     * ✅ Observable owns AbortController:
+     * - subscribe starts request
+     * - unsubscribe aborts request
+     * - shareReplay shares the same in-flight request among subscribers
+     */
+    get observable() {
+        if (!this._observable) {
+            this._observable = new Observable(subscriber => {
+                const ac = new AbortController();
+                this.makeRequest(ac.signal)
+                    .then(res => {
+                    if (res instanceof HttpResponseError) {
+                        subscriber.error(res);
+                        return;
+                    }
+                    subscriber.next(res);
+                    subscriber.complete();
+                })
+                    .catch(err => subscriber.error(err));
+                return () => ac.abort('rxjs-unsubscribe');
+            }).pipe(shareReplay({ bufferSize: 1, refCount: true }));
+        }
+        return this._observable;
+    }
+    // -------------------------
+    // Internals
+    // -------------------------
+    creatUrl(params, doNotSerializeParams = false) {
+        const origin = (this.urlOrigin || '').replace(/\/+$/, '');
+        const path = (this.urlPathname || '').replace(/^\/+/, '');
+        const endpoint = `${origin}/${path}`;
+        return `${endpoint}${getParamsUrl(params, doNotSerializeParams)}`;
+    }
+}
+//#endregion
+//#region resource reponse http strategy
+class ResourceResponseHttp extends ResourceResponse {
+    async makeRequest(abortSignal) {
+        const url = this.creatUrl(this.urlParams, !!this.axiosOptions?.doNotSerializeParams);
+        const method = this.httpMethodName;
+        log.d(`Requesting ${method} ${url}`);
+        const isFormData = CLASS.getNameFromObject(this.body) === 'FormData';
+        const formData = isFormData ? this.body : void 0;
+        //#region @backend
+        if (formData) {
+            const headersForm = formData.getHeaders();
+            headersForm['Content-Length'] = formData.getLengthSync();
+            for (const [key, value] of Object.entries(headersForm)) {
+                this.headers.set(key, value?.toString());
+            }
+        }
+        //#endregion
+        const responseType = this.headers.get('responsetypeaxios')?.toString() || 'text';
+        const headersObj = Object.fromEntries(Object.entries(this.headers.toJSON()).map(([k, v]) => [
+            k,
+            Array.isArray(v) ? v.join(',') : v,
+        ]));
+        const axiosConfig = {
+            url,
+            method,
+            data: this.body,
+            responseType,
+            headers: headersObj,
+            signal: abortSignal, // ✅ this is the key
+            ...this.axiosOptions,
+        };
+        if (isFormData) {
+            axiosConfig.maxBodyLength = Infinity;
+        }
+        try {
+            const uri = new URL(url);
+            const backend = new AxiosBackendHandler();
+            const globalInterceptors = Array.from(this.globalInterceptors.values());
+            const methodInterceptors = Array.from(this.methodsInterceptors.entries())
+                .filter(([key]) => key.endsWith(`-${method?.toUpperCase()}-${uri.pathname}`))
+                .map(([_, interceptor]) => interceptor);
+            const handler = buildInterceptorChain([...globalInterceptors, ...methodInterceptors], backend);
+            const response = await firstValueFrom(handler.handle(axiosConfig));
+            return new HttpResponse(url, method, response.data, RestHeaders.from(response.headers), response.status, this.options, this.isArray);
+        }
+        catch (catchedError) {
+            // ✅ treat cancellation separately (nice UX)
+            if (catchedError?.code === 'ERR_CANCELED' ||
+                catchedError?.name === 'CanceledError') {
+                throw new HttpResponseError(url, method, JSON.stringify({ message: 'Request canceled' }), this.options, RestHeaders.from(), 0, this.isArray);
+            }
+            //#region handle global error listener for notificaitons
+            if (typeof catchedError === 'object' &&
+                catchedError.response &&
+                catchedError.response.data) {
+                const err = catchedError.response.data;
+                const msg = catchedError.response.data.message || '';
+                // console.log({
+                //   'err.stack': err?.stack
+                // })
+                let stack = (err.stack || '').split('\n');
+                listenErrorsSrc.next({
+                    msg,
+                    stack,
+                    data: catchedError.response.data,
+                });
+            }
+            //#endregion
+            const status = catchedError?.response?.status ?? 0; // ✅ FIX: you used "status" before defining it
+            const data = catchedError?.response?.data ?? catchedError?.message ?? catchedError;
+            const responseText = typeof data === 'string' ? data : JSON.stringify(data);
+            throw new HttpResponseError(url, method, responseText, this.options, RestHeaders.from(catchedError?.response?.headers), status, this.isArray);
+        }
+    }
+}
+[];
+//#endregion
+//#region resource namespace
+export var Resource;
+(function (Resource) {
+    Resource.globalInterceptors = new Map();
+    Resource.methodsInterceptors = new Map();
+    Resource.listenErrors = listenErrorsSrc.asObservable();
+    Resource.Cookies = Cookie.Instance;
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    function create(originUrl, pathnameModel, resourceOptions) {
+        return {
+            model: (interpolateParams, overrideOptions) => {
+                const methods = (isArray = false) => {
+                    const methodsObj = {};
+                    for (const methodName of CoreModels.HttpMethodArr) {
+                        methodsObj[methodName] = (body, urlParams, axiosOptions) => {
+                            let localPathname = pathnameModel;
+                            if (!localPathname.startsWith('/')) {
+                                localPathname = `/${localPathname}`;
+                            }
+                            let localOriginUrl = originUrl;
+                            if (localOriginUrl.endsWith('/')) {
+                                localOriginUrl = localOriginUrl.replace(/\/$/, '');
+                            }
+                            let localUrl = new URL(`${localOriginUrl}${localPathname}`);
+                            //#region validate pathname model
+                            const badRestRegEX = new RegExp('((\/:)[a-z]+)+', 'g');
+                            const matchArr = localPathname.match(badRestRegEX) || [];
+                            const badModelsNextToEachOther = matchArr.join();
+                            const atleas2DoubleDots = (badModelsNextToEachOther.match(new RegExp(':', 'g')) || [])
+                                .length >= 2;
+                            if (atleas2DoubleDots &&
+                                localPathname.search(badModelsNextToEachOther) !== -1) {
+                                throw new Error(`
+
+Bad rest model: ${localPathname}
+
+Do not create rest models like this:    /book/author/:bookid/:authorid
+Instead use nested approach:            /book/:bookid/author/:authorid
+            `);
+                            }
+                            //#endregion
+                            let options = resourceOptions;
+                            options = options || {};
+                            options.responseMapping = options.responseMapping || {};
+                            options = {
+                                ...options,
+                                ...(_.isFunction(overrideOptions)
+                                    ? overrideOptions(options)
+                                    : overrideOptions || {}),
+                            };
+                            if (interpolateParams) {
+                                // console.log({ interpolateParams });
+                                // interpolate args
+                                let pathNameInterpolated = interpolateParamsToUrl(interpolateParams, localUrl.pathname);
+                                // console.log(
+                                //   `interpolated ${pathNameInterpolated}, url ${url.toString()}`,
+                                // );
+                                localUrl = new URL(`${localUrl.origin}/${pathNameInterpolated}`);
+                            }
+                            const headers = RestHeaders.from(options.headers);
+                            options.strategy = options.strategy || 'http';
+                            options.defaultHeadersProfile =
+                                options.defaultHeadersProfile || 'APPLICATION_JSON';
+                            if (options.defaultHeadersProfile) {
+                                DEFAULT_HEADERS[options.defaultHeadersProfile].forEach((values, name) => {
+                                    values.forEach(headerValue => headers.set(name, headerValue));
+                                });
+                            }
+                            if (options.strategy === 'http') {
+                                return new ResourceResponseHttp(methodName, localUrl.origin, localUrl.pathname, options, body, urlParams, axiosOptions, isArray, headers, Resource.globalInterceptors, Resource.methodsInterceptors);
+                            }
+                            else if (options.strategy === 'ipc-electron') {
+                                // TODO later
+                            }
+                            else if (options.strategy === 'js-mock') {
+                                // TODO later
+                            }
+                        };
+                    }
+                    return methodsObj;
+                };
+                const methodsRes = methods();
+                const methodsArrayRes = methods(true);
+                const res = {
+                    get array() {
+                        return methodsArrayRes;
+                    },
+                    ...methodsRes,
+                };
+                return res;
+            },
+        };
+    }
+    Resource.create = create;
+})(Resource || (Resource = {}));
+//#endregion
+//#region exmaple usage
+/**
+ * EXample useage
+ */
+class ExampleBook {
+    title;
+}
+async function example() {
+    const rest = Resource.create('http://my-website.pl', 'api/v3/user/:userId', {
+        responseMapping: {
+            entity: () => ({ '': ExampleBook }),
+        },
+    });
+    const response = await rest.model({ userId: 1 }).get();
+    response; // type of response should be HttpResponse
+    const responseObservable = rest
+        .model({ userId: 1 })
+        .array.post([new ExampleBook()], [{ 'location-id': 123 }]).observable;
+    const responseObservableOnlyONe = rest
+        .model({ userId: 1 })
+        .post(new ExampleBook(), [{ 'location-id': 123 }]).observable;
+    responseObservable.subscribe(data => {
+        data; // HttpResponse<ExampleBook>
+    });
+}
+//#endregion
+//# sourceMappingURL=ng2-rest.js.map