api-def 0.7.4 → 0.8.1

package/cjs/Api.js

@@ -42,6 +42,7 @@ var EndpointBuilder_1 = require("./EndpointBuilder");
 var Utils = require("./Utils");
 var FetchRequestBackend_1 = require("./backend/FetchRequestBackend");
 var ApiConstants_1 = require("./ApiConstants");
+var RequestConfig_1 = require("./RequestConfig");
 // use fetch as default if it is present
 var requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend_1.default() : null;
 var requestBackendIsDefault = true;
@@ -60,7 +61,7 @@ var setRequestBackend = function (backend) {
 exports.setRequestBackend = setRequestBackend;
 var HotRequestHost = /** @class */ (function () {
     function HotRequestHost(api, path, method) {
-        this.responseType = ApiConstants_1.ResponseType.Json;
+        this.responseType = undefined;
         this.api = api;
         this.method = method;
         this.path = path;
@@ -74,7 +75,10 @@ var HotRequestHost = /** @class */ (function () {
     });
     HotRequestHost.prototype.computeConfig = function (config) {
         var apiDefaults = this.api.getConfig();
-        return Utils.assign({}, apiDefaults, config);
+        return (0, RequestConfig_1.computeRequestConfig)([
+            apiDefaults,
+            config,
+        ]);
     };
     HotRequestHost.prototype.computePath = function (path, config) {
         return path.startsWith("/") ? path : "/".concat(path);

package/cjs/ApiTypes.d.ts

@@ -4,20 +4,33 @@ import { CacheSource, EventResultType, RequestEvent, RequestMethod, ResponseType
 export declare type AcceptableStatus = number | [min: number, max: number];
 export declare type Headers = Record<string, string | number | boolean | null | undefined>;
 export declare type Params = string;
-export declare type Query = Record<string, any>;
+export declare type Query = string | undefined | Record<string, any>;
 export declare type Body = string | number | Record<string, any>;
 export interface ApiResponse<T = any> {
-    status: number;
-    data: T;
-    headers: Record<string, string>;
+    readonly method: RequestMethod;
+    readonly url: string;
+    readonly status: number;
+    readonly data: T;
+    readonly headers: Record<string, string>;
+}
+export declare type RequestLock = string | false;
+export declare type QueryStringify = (query: any) => string;
+export declare type QueryParse = (query: string) => any;
+interface QueryHandling {
+    parse: QueryParse;
+    stringify: QueryStringify;
 }
 export interface BaseRequestConfig {
     cache?: number | boolean;
-    lock?: string | false;
+    lock?: RequestLock;
     retry?: number | false;
     headers?: Readonly<Headers>;
     acceptableStatus?: AcceptableStatus[];
-    queryParser?: (query: any) => string;
+    /**
+     * @deprecated use `queryHandling.stringify` instead
+     **/
+    queryParser?: QueryStringify;
+    queryHandling?: Partial<QueryHandling>;
 }
 export declare type RequestConfig<P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> = (P extends undefined ? {
     params?: never;
@@ -32,13 +45,20 @@ export declare type RequestConfig<P extends Params | undefined = Params | undefi
 } : {
     body: B;
 }) & BaseRequestConfig;
+export declare const COMPUTED_CONFIG_SYMBOL: unique symbol;
+export declare type ComputedRequestConfig<P extends Params | undefined = Params | undefined, Q extends Query | undefined = Query | undefined, B extends Body | undefined = Body | undefined> = Omit<RequestConfig<P, Q, B>, "queryParser" | "query" | "queryHandling"> & {
+    [COMPUTED_CONFIG_SYMBOL]: true;
+    queryObject: Record<string, any> | undefined;
+    queryString: string | undefined;
+    queryHandling: QueryHandling;
+};
 interface BaseEventResult<T extends EventResultType> {
     type: T;
 }
-export declare type ResponseEventResult<R> = BaseEventResult<typeof EventResultType.Respond> & {
+export declare type ResponseEventResult<R> = BaseEventResult<"respond"> & {
     response: ApiResponse<R>;
 };
-export declare type RetryEventResult<R> = BaseEventResult<typeof EventResultType.Retry>;
+export declare type RetryEventResult<R> = BaseEventResult<"retry">;
 export declare type EventResult<R> = ResponseEventResult<R> | RetryEventResult<R>;
 export declare type RequestEventHandler<R> = (context: RequestContext<R>) => EventResult<R> | void | Promise<EventResult<R> | void>;
 export declare type RequestEventHandlers<R> = {
@@ -59,8 +79,8 @@ export interface RequestHost {
     readonly api: Api;
     readonly baseUrl: string;
     readonly path: string;
-    readonly responseType: ResponseType;
-    computeConfig<P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined>(config: RequestConfig<P, Q, B>): RequestConfig<P, Q, B>;
+    readonly responseType: ResponseType | undefined;
+    computeConfig<P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined>(config: RequestConfig<P, Q, B>): ComputedRequestConfig<P, Q, B>;
     computePath(path: string, config: RequestConfig): string;
 }
 export interface CancelledRequestError extends Error {

package/cjs/ApiTypes.js

@@ -1,2 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPUTED_CONFIG_SYMBOL = void 0;
+exports.COMPUTED_CONFIG_SYMBOL = Symbol("computed");

package/cjs/ApiUtils.js

@@ -32,7 +32,7 @@ var isAcceptableStatus = function (status, acceptableStatus) {
     return (false);
 };
 exports.isAcceptableStatus = isAcceptableStatus;
-var TEXT_CONTENT_TYPES = ["text/plain"];
+var TEXT_CONTENT_TYPES = ["text/plain", "text/html", "text/xml", "application/xml"];
 var JSON_CONTENT_TYPES = ["text/json", "application/json"];
 var ARRAY_BUFFER_CONTENT_TYPES = ["application/octet-stream"];
 var inferResponseType = function (contentType) {

package/cjs/Endpoint.d.ts

@@ -1,5 +1,5 @@
 import { Api } from "./Api";
-import { ApiResponse, BaseRequestConfig, Body, Params, Query, RequestConfig, RequestHost } from "./ApiTypes";
+import { ApiResponse, BaseRequestConfig, Body, ComputedRequestConfig, Params, Query, RequestConfig, RequestHost } from "./ApiTypes";
 import * as Mocking from "./MockingTypes";
 import { RequestMethod, ResponseType } from "./ApiConstants";
 export interface EndpointConfig<R, P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined> {
@@ -37,11 +37,11 @@ export default class Endpoint<R = any, P extends Params | undefined = Params | u
     readonly description?: string;
     readonly path: string;
     readonly config?: BaseRequestConfig;
-    readonly responseType: ResponseType;
+    readonly responseType: ResponseType | undefined;
     readonly mocking?: Mocking.EndpointMockingConfig<R, P, Q, B>;
     constructor(api: Api, info: EndpointConfig<R, P, Q, B>);
     submit(config: RequestConfig<P, Q, B>): Promise<ApiResponse<R>>;
     computePath(path: string, request: RequestConfig): string;
     get baseUrl(): string;
-    computeConfig<P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined>(config: RequestConfig<P, Q, B>): RequestConfig<P, Q, B>;
+    computeConfig<P extends Params | undefined, Q extends Query | undefined, B extends Body | undefined>(config: RequestConfig<P, Q, B>): ComputedRequestConfig<P, Q, B>;
 }

package/cjs/Endpoint.js

@@ -37,8 +37,9 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var Requester = require("./Requester");
+var ApiTypes_1 = require("./ApiTypes");
 var Utils = require("./Utils");
-var ApiConstants_1 = require("./ApiConstants");
+var RequestConfig_1 = require("./RequestConfig");
 var Endpoint = /** @class */ (function () {
     function Endpoint(api, info) {
         this.api = api;
@@ -48,7 +49,7 @@ var Endpoint = /** @class */ (function () {
         this.description = info.description;
         this.path = info.path;
         this.config = info.config;
-        this.responseType = info.responseType || ApiConstants_1.ResponseType.Json;
+        this.responseType = info.responseType;
         this.mocking = info.mocking;
     }
     Endpoint.prototype.submit = function (config) {
@@ -93,13 +94,17 @@ var Endpoint = /** @class */ (function () {
         configurable: true
     });
     Endpoint.prototype.computeConfig = function (config) {
+        var _a;
         var apiDefaults = this.api.getConfig();
-        var computedConfig = Utils.assign({}, apiDefaults, this.config, config);
-        // merge other values
-        for (var _i = 0, _a = ["headers"]; _i < _a.length; _i++) {
-            var key = _a[_i];
-            computedConfig[key] = Utils.assign({}, apiDefaults[key], this.config ? this.config[key] : undefined, config[key]);
-        }
+        var computedConfig = Utils.assign((_a = {},
+            _a[ApiTypes_1.COMPUTED_CONFIG_SYMBOL] = true,
+            _a), apiDefaults, this.config, config);
+        return (0, RequestConfig_1.computeRequestConfig)([
+            apiDefaults,
+            this.config,
+            config,
+        ]);
+        delete computedConfig.queryParser;
         return computedConfig;
     };
     return Endpoint;

package/cjs/QueryHandling.d.ts

@@ -0,0 +1,3 @@
+import { QueryStringify } from "./ApiTypes";
+export declare const DEFAULT_QUERY_STRINGIFY: QueryStringify;
+export declare const DEFAULT_QUERY_PARSE: (queryString: string) => Record<string, any>;

package/cjs/QueryHandling.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_QUERY_PARSE = exports.DEFAULT_QUERY_STRINGIFY = void 0;
+var DEFAULT_QUERY_STRINGIFY = function (query) {
+    var _a, _b;
+    var queryStrings = [];
+    var queryKeys = Object.keys(query);
+    for (var i = 0; i < queryKeys.length; i++) {
+        var key = queryKeys[i];
+        queryStrings.push("".concat(key, "=").concat((_b = (_a = query[key]) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : ""));
+    }
+    return queryStrings.join("&");
+};
+exports.DEFAULT_QUERY_STRINGIFY = DEFAULT_QUERY_STRINGIFY;
+var DEFAULT_QUERY_PARSE = function (queryString) {
+    var query = {};
+    var queryStrings = queryString.split("&");
+    for (var i = 0; i < queryStrings.length; i++) {
+        var _a = queryStrings[i].split("="), key = _a[0], value = _a[1];
+        query[key] = !(value === null || value === void 0 ? void 0 : value.length) ? true : value;
+    }
+    return query;
+};
+exports.DEFAULT_QUERY_PARSE = DEFAULT_QUERY_PARSE;

package/cjs/RequestConfig.d.ts

@@ -0,0 +1,2 @@
+import { BaseRequestConfig, Body, ComputedRequestConfig, Query, RequestConfig } from "./ApiTypes";
+export declare const computeRequestConfig: <P extends string | undefined, Q extends Query, B extends Body | undefined>(configs: (BaseRequestConfig | RequestConfig<P, Q, B> | undefined)[]) => ComputedRequestConfig<P, Q, B>;

package/cjs/RequestConfig.js

@@ -0,0 +1,74 @@
+"use strict";
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeRequestConfig = void 0;
+var ApiTypes_1 = require("./ApiTypes");
+var Utils = require("./Utils");
+var QueryHandling_1 = require("./QueryHandling");
+var MERGED_CONFIG_KEYS = ["headers"];
+var computeRequestConfig = function (configs) {
+    var _a;
+    var _b, _c;
+    var computedConfig = Utils.assign.apply(Utils, __spreadArray([(_a = {},
+            _a[ApiTypes_1.COMPUTED_CONFIG_SYMBOL] = true,
+            _a)], configs, false));
+    var _loop_1 = function (key) {
+        computedConfig[key] = Utils.assign.apply(Utils, __spreadArray([{}], configs.reduce(function (acc, config) {
+            if (config === null || config === void 0 ? void 0 : config[key]) {
+                acc.push(config[key]);
+            }
+            return acc;
+        }, []), false));
+    };
+    // merge other values
+    for (var _i = 0, MERGED_CONFIG_KEYS_1 = MERGED_CONFIG_KEYS; _i < MERGED_CONFIG_KEYS_1.length; _i++) {
+        var key = MERGED_CONFIG_KEYS_1[_i];
+        _loop_1(key);
+    }
+    computedConfig.queryHandling = {
+        parse: ((_b = computedConfig.queryHandling) === null || _b === void 0 ? void 0 : _b.parse) || QueryHandling_1.DEFAULT_QUERY_PARSE,
+        stringify: ((_c = computedConfig.queryHandling) === null || _c === void 0 ? void 0 : _c.stringify) || computedConfig.queryParser || QueryHandling_1.DEFAULT_QUERY_STRINGIFY,
+    };
+    delete computedConfig.queryParser;
+    var query = computedConfig.query;
+    var queryString;
+    var queryObject;
+    if (query) {
+        Object.defineProperty(computedConfig, "queryString", {
+            get: function () {
+                if (queryString) {
+                    return queryString;
+                }
+                if (typeof query === "string") {
+                    return queryString = query;
+                }
+                return queryString = computedConfig.queryHandling.stringify(query);
+            },
+        });
+        Object.defineProperty(computedConfig, "queryObject", {
+            get: function () {
+                if (queryObject) {
+                    return queryObject;
+                }
+                if (typeof query === "string") {
+                    return queryObject = computedConfig.queryHandling.parse(query);
+                }
+                return queryObject = query;
+            },
+            set: function (value) {
+                queryObject = value;
+                queryString = computedConfig.queryHandling.stringify(value);
+            },
+        });
+    }
+    return computedConfig;
+};
+exports.computeRequestConfig = computeRequestConfig;

package/cjs/RequestContext.d.ts

@@ -1,4 +1,4 @@
-import { ApiResponse, Body, EventResult, Headers, Params, Query, RequestCacheInfo, RequestConfig, RequestContextStats, RequestEventHandlers, RequestHost } from "./ApiTypes";
+import { ApiResponse, Body, ComputedRequestConfig, EventResult, Headers, Params, Query, RequestCacheInfo, RequestContextStats, RequestEventHandlers, RequestHost } from "./ApiTypes";
 import { Api } from "./Api";
 import { RequestEvent, RequestMethod, ResponseType } from "./ApiConstants";
 import { EndpointMockingConfig } from "./MockingTypes";
@@ -17,14 +17,14 @@ export default class RequestContext<R = any, P extends Params | undefined = Para
     error: RequestError | null;
     readonly cacheInfo: RequestCacheInfo;
     cancelled: boolean;
-    readonly computedConfig: RequestConfig<P, Q, B>;
+    readonly computedConfig: ComputedRequestConfig<P, Q, B>;
     readonly mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined;
     private parsedBody;
-    constructor(backend: RequestBackend, host: RequestHost, config: RequestConfig<P, Q, B>, computedPath: string, mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined);
+    constructor(backend: RequestBackend, host: RequestHost, config: ComputedRequestConfig<P, Q, B>, computedPath: string, mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined);
     get method(): RequestMethod;
     get api(): Api;
     get baseUrl(): string;
-    get responseType(): ResponseType;
+    get responseType(): ResponseType | undefined;
     private initMiddleware;
     private generateKey;
     updateHeaders(newHeaders: Headers): this;

package/cjs/RequestContext.js

@@ -105,18 +105,9 @@ var RequestContext = /** @class */ (function () {
         }
     };
     RequestContext.prototype.generateKey = function () {
-        var computedConfig = this.computedConfig;
         var key = this.computedPath.trim();
-        var queryStrings = [];
-        if (computedConfig.query) {
-            var queryKeys = Object.keys(computedConfig.query);
-            for (var i = 0; i < queryKeys.length; i++) {
-                var queryKey = queryKeys[i];
-                queryStrings.push("".concat(queryKey, "=").concat(computedConfig.query[queryKey]));
-            }
-        }
-        if (queryStrings.length > 0) {
-            key += "?" + queryStrings.join("&");
+        if (this.computedConfig.queryString) {
+            key += "?" + this.computedConfig.queryString;
         }
         return key;
     };
@@ -151,7 +142,7 @@ var RequestContext = /** @class */ (function () {
         return this.parsedBody;
     };
     RequestContext.prototype.updateQuery = function (newQuery) {
-        this.computedConfig.query = Utils.assign(this.computedConfig.query || {}, newQuery);
+        this.computedConfig.queryObject = Utils.assign({}, this.computedConfig.queryObject, newQuery);
         return this;
     };
     RequestContext.prototype.triggerEvent = function (eventType) {
@@ -192,7 +183,6 @@ var RequestContext = /** @class */ (function () {
         }
     };
     RequestContext.prototype.getRequestUrl = function () {
-        var _a;
         var path = !this.baseUrl.endsWith("/")
             ? this.baseUrl + "/"
             : this.baseUrl;
@@ -209,17 +199,8 @@ var RequestContext = /** @class */ (function () {
             }
         }
         var url = new URL(path, origin);
-        if (this.computedConfig.query) {
-            if (this.computedConfig.queryParser) {
-                url.search = this.computedConfig.queryParser(this.computedConfig.query);
-            }
-            else {
-                var queryKeys = Object.keys(this.computedConfig.query);
-                for (var i = 0; i < queryKeys.length; i++) {
-                    var key = queryKeys[i];
-                    url.searchParams.append(key, ((_a = this.computedConfig.query[key]) === null || _a === void 0 ? void 0 : _a.toString()) || "");
-                }
-            }
+        if (this.computedConfig.queryString) {
+            url.search = this.computedConfig.queryString;
         }
         return url;
     };

package/cjs/RequestError.js

@@ -22,7 +22,7 @@ var convertToRequestError = function (config) {
         isRequestError: true,
         request: {
             url: context.getRequestUrl().href,
-            query: context.computedConfig.query,
+            query: context.computedConfig.queryObject,
             headers: context.computedConfig.headers,
             body: body,
         },

package/cjs/Requester.d.ts

@@ -1,3 +1,3 @@
 import { ApiResponse, Body, Query, RequestConfig, RequestHost } from "./ApiTypes";
 import { EndpointMockingConfig } from "./MockingTypes";
-export declare const submit: <R, P extends string | undefined, Q extends Query | undefined, B extends Body | undefined>(host: RequestHost, config: RequestConfig<P, Q, B>, mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined) => Promise<ApiResponse<R>>;
+export declare const submit: <R, P extends string | undefined, Q extends Query, B extends Body | undefined>(host: RequestHost, config: RequestConfig<P, Q, B>, mocking: EndpointMockingConfig<R, P, Q, B> | null | undefined) => Promise<ApiResponse<R>>;

package/cjs/Requester.js

@@ -73,7 +73,7 @@ var submit = function (host, config, mocking) { return __awaiter(void 0, void 0,
                 context = new RequestContext_1.default(backend, host, computedConfig, host.computePath(host.path, config), mocking);
                 key = context.key;
                 lock = (context.computedConfig || {}).lock;
-                if (lock) {
+                if (typeof lock === "string") {
                     lockedContext = locks[lock];
                     if (lockedContext && lockedContext.id !== context.id) {
                         lockedContext.cancel();
@@ -100,7 +100,7 @@ var submit = function (host, config, mocking) { return __awaiter(void 0, void 0,
                 delete runningOperations[key];
                 throw error_1;
             case 5:
-                if (lock) {
+                if (typeof lock === "string") {
                     delete locks[lock];
                 }
                 return [7 /*endfinally*/];

package/cjs/Utils.js

@@ -30,7 +30,7 @@ var padNumber = function (stringOrNumber, maxLength) {
 exports.padNumber = padNumber;
 var getGlobalFetch = function () {
     if (typeof global !== "undefined" && typeof global.fetch === "function") {
-        return global.fetch;
+        return global.fetch.bind(global);
     }
     if (typeof window === "undefined") {
         return undefined;

package/cjs/backend/AxiosRequestBackend.js

@@ -62,6 +62,8 @@ var AxiosRequestBackend = /** @class */ (function () {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 return [2 /*return*/, {
+                        method: context.method,
+                        url: response.request.res.responseUrl,
                         data: response.data,
                         headers: response.headers,
                         status: response.status,
@@ -72,19 +74,17 @@ var AxiosRequestBackend = /** @class */ (function () {
     };
     AxiosRequestBackend.prototype.makeRequest = function (context) {
         var computedConfig = context.computedConfig;
+        var url = context.getRequestUrl();
         var canceler = null;
         var promise = axios({
             method: context.method,
-            baseURL: context.baseUrl,
-            url: context.computedPath,
+            url: url.href,
             data: context.getParsedBody(),
-            params: computedConfig.query || {},
             headers: computedConfig.headers || {},
             responseType: context.responseType,
             cancelToken: new axios.CancelToken(function (cancellerFunc) {
                 canceler = cancellerFunc;
             }),
-            paramsSerializer: context.computedConfig.queryParser,
         });
         return {
             promise: promise,

package/cjs/backend/FetchRequestBackend.js

@@ -53,7 +53,6 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 var Utils = require("../Utils");
 var Utils_1 = require("../Utils");
-var ApiConstants_1 = require("../ApiConstants");
 var ApiUtils_1 = require("../ApiUtils");
 var FetchError = /** @class */ (function (_super) {
     __extends(FetchError, _super);
@@ -102,13 +101,13 @@ var FetchRequestBackend = /** @class */ (function () {
                         _b.label = 3;
                     case 3:
                         _b.trys.push([3, 7, , 8]);
-                        if (!(responseType === ApiConstants_1.ResponseType.ArrayBuffer)) return [3 /*break*/, 5];
+                        if (!(responseType === "arraybuffer")) return [3 /*break*/, 5];
                         return [4 /*yield*/, response.clone().arrayBuffer()];
                     case 4:
                         data = _b.sent();
                         return [3 /*break*/, 6];
                     case 5:
-                        if (responseType === ApiConstants_1.ResponseType.Json) {
+                        if (responseType === "json") {
                             data = JSON.parse(response.__text);
                         }
                         _b.label = 6;
@@ -125,6 +124,8 @@ var FetchRequestBackend = /** @class */ (function () {
                         });
                         return [2 /*return*/, {
                                 __lowercaseHeaders: processedHeaders,
+                                method: context.method,
+                                url: response.url,
                                 data: data,
                                 status: status,
                                 headers: processedHeaders,

package/cjs/backend/MockRequestBackend.js

@@ -80,7 +80,7 @@ var MockRequestBackend = /** @class */ (function () {
                         req = {
                             body: context.getParsedBody(),
                             params: (_b = context.computedConfig.params) !== null && _b !== void 0 ? _b : {},
-                            query: context.computedConfig.query,
+                            query: context.computedConfig.queryObject,
                             headers: (_c = context.computedConfig.headers) !== null && _c !== void 0 ? _c : {},
                             url: context.getRequestUrl().toString(),
                         };
@@ -140,6 +140,8 @@ var MockRequestBackend = /** @class */ (function () {
                             return parsedHeaders;
                         }, {});
                         return [2 /*return*/, {
+                                url: context.getRequestUrl().href,
+                                method: context.method,
                                 headers: parsedHeaders,
                                 data: res.response,
                                 status: res.statusCode,

package/esm/Api.js

@@ -7,87 +7,53 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (_) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 import * as Requester from "./Requester";
 import EndpointBuilder from "./EndpointBuilder";
 import * as Utils from "./Utils";
 import FetchRequestBackend from "./backend/FetchRequestBackend";
-import { RequestMethod, ResponseType, } from "./ApiConstants";
+import { RequestMethod, } from "./ApiConstants";
+import { computeRequestConfig } from "./RequestConfig";
 // use fetch as default if it is present
-var requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend() : null;
-var requestBackendIsDefault = true;
-export var getRequestBackend = function () {
+let requestBackend = Utils.getGlobalFetch() ? new FetchRequestBackend() : null;
+let requestBackendIsDefault = true;
+export const getRequestBackend = () => {
     return requestBackend;
 };
-export var isRequestBackendDefault = function () {
+export const isRequestBackendDefault = () => {
     return requestBackendIsDefault;
 };
-export var setRequestBackend = function (backend) {
+export const setRequestBackend = (backend) => {
     requestBackendIsDefault = false;
     requestBackend = backend;
 };
-var HotRequestHost = /** @class */ (function () {
-    function HotRequestHost(api, path, method) {
-        this.responseType = ResponseType.Json;
+class HotRequestHost {
+    constructor(api, path, method) {
+        this.responseType = undefined;
         this.api = api;
         this.method = method;
         this.path = path;
     }
-    Object.defineProperty(HotRequestHost.prototype, "baseUrl", {
-        get: function () {
-            return this.api.baseUrl;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    HotRequestHost.prototype.computeConfig = function (config) {
-        var apiDefaults = this.api.getConfig();
-        return Utils.assign({}, apiDefaults, config);
-    };
-    HotRequestHost.prototype.computePath = function (path, config) {
-        return path.startsWith("/") ? path : "/".concat(path);
-    };
-    return HotRequestHost;
-}());
-var Api = /** @class */ (function () {
-    function Api(info) {
-        var _this = this;
+    get baseUrl() {
+        return this.api.baseUrl;
+    }
+    computeConfig(config) {
+        const apiDefaults = this.api.getConfig();
+        return computeRequestConfig([
+            apiDefaults,
+            config,
+        ]);
+    }
+    computePath(path, config) {
+        return path.startsWith("/") ? path : `/${path}`;
+    }
+}
+export class Api {
+    constructor(info) {
         var _a;
         this.endpoints = {};
-        this.hotRequest = function (requestMethod) { return function (path, config) { return __awaiter(_this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, Requester.submit(new HotRequestHost(this, path, requestMethod), config, null)];
-                    case 1: return [2 /*return*/, (_a.sent())];
-                }
-            });
-        }); }; };
+        this.hotRequest = (requestMethod) => (path, config) => __awaiter(this, void 0, void 0, function* () {
+            return (yield Requester.submit(new HotRequestHost(this, path, requestMethod), config, null));
+        });
         this.get = this.hotRequest(RequestMethod.GET);
         this.post = this.hotRequest(RequestMethod.POST);
         this.put = this.hotRequest(RequestMethod.PUT);
@@ -100,13 +66,11 @@ var Api = /** @class */ (function () {
         this.config = info.config;
         this.mocking = (_a = info.mocking) !== null && _a !== void 0 ? _a : undefined;
     }
-    Api.prototype.endpoint = function () {
+    endpoint() {
         return new EndpointBuilder(this);
-    };
-    Api.prototype.getConfig = function () {
+    }
+    getConfig() {
         return ((typeof this.config === "function" ? this.config() : this.config) ||
             {});
-    };
-    return Api;
-}());
-export { Api };
+    }
+}