jordy 0.12.0 → 0.13.0

package/esm5/http-api/BaseInterceptorHttpApi.js

@@ -0,0 +1,53 @@
+import { __assign } from "tslib";
+var BaseInterceptorHttpApi = (function () {
+    function BaseInterceptorHttpApi(paramsSerializer) {
+        var _this = this;
+        this.paramsSerializer = paramsSerializer;
+        this._interceptor = {};
+        this.mergeParams = function (method, url, paramsOriginal) {
+            if (_this._interceptor.params) {
+                var paramsAdditional = _this._interceptor.params(method, url, paramsOriginal);
+                if (paramsAdditional) {
+                    if (paramsOriginal) {
+                        return __assign(__assign({}, paramsOriginal), paramsAdditional);
+                    }
+                    return paramsAdditional;
+                }
+            }
+            return paramsOriginal;
+        };
+        this.mergeQueries = function (method, url, paramsOriginal) {
+            if (_this._interceptor.params) {
+                var paramsAdditional = _this._interceptor.params(method, url, paramsOriginal);
+                if (!paramsAdditional) {
+                    return url;
+                }
+                return (url +
+                    (url.includes('?') ? '&' : '?') +
+                    _this.paramsSerializer(paramsAdditional));
+            }
+            return url;
+        };
+        this.throwWithInterceptor = function (err) {
+            if (_this._interceptor.error) {
+                var nextError = _this._interceptor.error(err);
+                if (nextError) {
+                    throw nextError;
+                }
+            }
+            throw err;
+        };
+    }
+    Object.defineProperty(BaseInterceptorHttpApi.prototype, "interceptor", {
+        get: function () {
+            return this._interceptor;
+        },
+        set: function (value) {
+            this._interceptor = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return BaseInterceptorHttpApi;
+}());
+export { BaseInterceptorHttpApi };

package/esm5/http-api/BasicHttpApi.js

@@ -0,0 +1,155 @@
+import { __awaiter, __extends, __generator } from "tslib";
+import { getFileName } from '../util';
+import { BaseInterceptorHttpApi } from './BaseInterceptorHttpApi';
+var BasicHttpApi = (function (_super) {
+    __extends(BasicHttpApi, _super);
+    function BasicHttpApi(provider, baseUrl, headersCreator, paramsSerializer, withCredentials) {
+        if (withCredentials === void 0) { withCredentials = true; }
+        var _this = _super.call(this, paramsSerializer) || this;
+        _this.provider = provider;
+        _this.baseUrl = baseUrl;
+        _this.headersCreator = headersCreator;
+        _this.withCredentials = withCredentials;
+        return _this;
+    }
+    BasicHttpApi.prototype.get = function (url, params, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.headersCreator()];
+                    case 1:
+                        headers = _a.sent();
+                        return [2, this.provider
+                                .get({
+                                url: "".concat(this.baseUrl).concat(url),
+                                headers: headers,
+                                withCredentials: this.withCredentials,
+                                paramsSerializer: this.paramsSerializer,
+                                params: this.mergeParams('get', url, params),
+                                timeout: timeout,
+                            })
+                                .catch(this.throwWithInterceptor)];
+                }
+            });
+        });
+    };
+    BasicHttpApi.prototype.post = function (url, body, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.headersCreator()];
+                    case 1:
+                        headers = _a.sent();
+                        return [2, this.provider
+                                .post({
+                                url: "".concat(this.baseUrl).concat(this.mergeQueries('post', url, body)),
+                                headers: headers,
+                                withCredentials: this.withCredentials,
+                                paramsSerializer: this.paramsSerializer,
+                                params: body,
+                                timeout: timeout,
+                            })
+                                .catch(this.throwWithInterceptor)];
+                }
+            });
+        });
+    };
+    BasicHttpApi.prototype.put = function (url, body, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.headersCreator()];
+                    case 1:
+                        headers = _a.sent();
+                        return [2, this.provider
+                                .put({
+                                url: "".concat(this.baseUrl).concat(this.mergeQueries('put', url, body)),
+                                headers: headers,
+                                withCredentials: this.withCredentials,
+                                paramsSerializer: this.paramsSerializer,
+                                params: body,
+                                timeout: timeout,
+                            })
+                                .catch(this.throwWithInterceptor)];
+                }
+            });
+        });
+    };
+    BasicHttpApi.prototype.patch = function (url, body, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.headersCreator()];
+                    case 1:
+                        headers = _a.sent();
+                        return [2, this.provider
+                                .patch({
+                                url: "".concat(this.baseUrl).concat(this.mergeQueries('patch', url, body)),
+                                headers: headers,
+                                withCredentials: this.withCredentials,
+                                paramsSerializer: this.paramsSerializer,
+                                params: body,
+                                timeout: timeout,
+                            })
+                                .catch(this.throwWithInterceptor)];
+                }
+            });
+        });
+    };
+    BasicHttpApi.prototype.delete = function (url, body, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.headersCreator()];
+                    case 1:
+                        headers = _a.sent();
+                        return [2, this.provider
+                                .delete({
+                                url: "".concat(this.baseUrl).concat(this.mergeQueries('delete', url, body)),
+                                headers: headers,
+                                withCredentials: this.withCredentials,
+                                paramsSerializer: this.paramsSerializer,
+                                params: body,
+                                timeout: timeout,
+                            })
+                                .catch(this.throwWithInterceptor)];
+                }
+            });
+        });
+    };
+    BasicHttpApi.prototype.getFile = function (url, params, filename) {
+        return this.getBlob(url, params)
+            .then(function (blob) {
+            return new File([blob], filename || getFileName(url));
+        })
+            .catch(this.throwWithInterceptor);
+    };
+    BasicHttpApi.prototype.getBlob = function (url, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.headersCreator()];
+                    case 1:
+                        headers = _a.sent();
+                        return [2, this.provider
+                                .getBlob({
+                                url: "".concat(this.baseUrl).concat(url),
+                                headers: headers,
+                                withCredentials: this.withCredentials,
+                                paramsSerializer: this.paramsSerializer,
+                                params: this.mergeParams('get', url, params),
+                            })
+                                .catch(this.throwWithInterceptor)];
+                }
+            });
+        });
+    };
+    return BasicHttpApi;
+}(BaseInterceptorHttpApi));
+export { BasicHttpApi };

package/esm5/http-api/BasicHttpUploadApi.js

@@ -0,0 +1,60 @@
+import { __awaiter, __extends, __generator } from "tslib";
+import { BaseInterceptorHttpApi } from './BaseInterceptorHttpApi';
+var BasicHttpUploadApi = (function (_super) {
+    __extends(BasicHttpUploadApi, _super);
+    function BasicHttpUploadApi(provider, baseUrl, headersCreator, paramsSerializer, withCredentials) {
+        if (withCredentials === void 0) { withCredentials = true; }
+        var _this = _super.call(this, paramsSerializer) || this;
+        _this.provider = provider;
+        _this.baseUrl = baseUrl;
+        _this.headersCreator = headersCreator;
+        _this.withCredentials = withCredentials;
+        return _this;
+    }
+    BasicHttpUploadApi.prototype.postUpload = function (url, data, progressCallback, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.headersCreator()];
+                    case 1:
+                        headers = _a.sent();
+                        return [2, this.provider
+                                .post({
+                                url: "".concat(this.baseUrl).concat(this.mergeQueries('post', url, data)),
+                                headers: headers,
+                                withCredentials: this.withCredentials,
+                                data: data,
+                                timeout: timeout,
+                                onProgress: progressCallback,
+                            })
+                                .catch(this.throwWithInterceptor)];
+                }
+            });
+        });
+    };
+    BasicHttpUploadApi.prototype.putUpload = function (url, data, progressCallback, timeout) {
+        return __awaiter(this, void 0, void 0, function () {
+            var headers;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4, this.headersCreator()];
+                    case 1:
+                        headers = _a.sent();
+                        return [2, this.provider
+                                .put({
+                                url: "".concat(this.baseUrl).concat(this.mergeQueries('put', url, data)),
+                                headers: headers,
+                                withCredentials: this.withCredentials,
+                                data: data,
+                                timeout: timeout,
+                                onProgress: progressCallback,
+                            })
+                                .catch(this.throwWithInterceptor)];
+                }
+            });
+        });
+    };
+    return BasicHttpUploadApi;
+}(BaseInterceptorHttpApi));
+export { BasicHttpUploadApi };

package/esm5/http-api/ErrorParser.decorator.js

@@ -0,0 +1,83 @@
+import { __spreadArray } from "tslib";
+import { throwHttpRestError } from './network.util';
+function isConstructor(val) {
+    return typeof val === 'function';
+}
+export function ErrorParser(throwableParser) {
+    return function (ClassConstructor) {
+        if (isConstructor(ClassConstructor) === false) {
+            throw new Error('ErrorParser: argument is not function.');
+        }
+        return (function () {
+            function ErrorParserDecoratedUnionHttpNetworkProvider() {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                this.network = new ClassConstructor(args[0], args[1], args[2]);
+            }
+            ErrorParserDecoratedUnionHttpNetworkProvider.prototype.parse = function (error) {
+                var nextError = throwableParser(error);
+                if (nextError) {
+                    throw nextError;
+                }
+                throwHttpRestError(error);
+            };
+            ErrorParserDecoratedUnionHttpNetworkProvider.prototype.get = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return this.network.get
+                    .apply(this.network, __spreadArray([], args, true))
+                    .catch(this.parse);
+            };
+            ErrorParserDecoratedUnionHttpNetworkProvider.prototype.post = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return this.network.post
+                    .apply(this.network, __spreadArray([], args, true))
+                    .catch(this.parse);
+            };
+            ErrorParserDecoratedUnionHttpNetworkProvider.prototype.put = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return this.network.put
+                    .apply(this.network, __spreadArray([], args, true))
+                    .catch(this.parse);
+            };
+            ErrorParserDecoratedUnionHttpNetworkProvider.prototype.patch = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return this.network.patch
+                    .apply(this.network, __spreadArray([], args, true))
+                    .catch(this.parse);
+            };
+            ErrorParserDecoratedUnionHttpNetworkProvider.prototype.delete = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return this.network.delete
+                    .apply(this.network, __spreadArray([], args, true))
+                    .catch(this.parse);
+            };
+            ErrorParserDecoratedUnionHttpNetworkProvider.prototype.getBlob = function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                return this.network.getBlob
+                    .apply(this.network, __spreadArray([], args, true))
+                    .catch(this.parse);
+            };
+            return ErrorParserDecoratedUnionHttpNetworkProvider;
+        }());
+    };
+}

package/esm5/http-api/axios/AxiosHttpNetworkProvider.js

@@ -0,0 +1,57 @@
+import { __assign, __decorate, __rest } from "tslib";
+import axios from 'axios';
+import { ErrorParser } from '../ErrorParser.decorator';
+import { throwableAxiosErrorParser } from './throwableAxiosErrorParser';
+var AxiosHttpNetworkProvider = (function () {
+    function AxiosHttpNetworkProvider() {
+    }
+    AxiosHttpNetworkProvider.prototype.extractData = function (axiosRes) {
+        return axiosRes.data;
+    };
+    AxiosHttpNetworkProvider.prototype.makeAxiosHeaders = function (headers) {
+        return {
+            common: headers,
+        };
+    };
+    AxiosHttpNetworkProvider.prototype.get = function (_a) {
+        var url = _a.url, headers = _a.headers, config = __rest(_a, ["url", "headers"]);
+        return axios
+            .get(url, __assign(__assign({}, config), { headers: this.makeAxiosHeaders(headers) }))
+            .then(this.extractData);
+    };
+    AxiosHttpNetworkProvider.prototype.post = function (_a) {
+        var url = _a.url, headers = _a.headers, data = _a.params, config = __rest(_a, ["url", "headers", "params"]);
+        return axios
+            .post(url, data, __assign(__assign({}, config), { headers: this.makeAxiosHeaders(headers) }))
+            .then(this.extractData);
+    };
+    AxiosHttpNetworkProvider.prototype.put = function (_a) {
+        var url = _a.url, headers = _a.headers, data = _a.params, config = __rest(_a, ["url", "headers", "params"]);
+        return axios
+            .put(url, data, __assign(__assign({}, config), { headers: this.makeAxiosHeaders(headers) }))
+            .then(this.extractData);
+    };
+    AxiosHttpNetworkProvider.prototype.patch = function (_a) {
+        var url = _a.url, headers = _a.headers, data = _a.params, config = __rest(_a, ["url", "headers", "params"]);
+        return axios
+            .patch(url, data, __assign(__assign({}, config), { headers: this.makeAxiosHeaders(headers) }))
+            .then(this.extractData);
+    };
+    AxiosHttpNetworkProvider.prototype.delete = function (_a) {
+        var url = _a.url, headers = _a.headers, data = _a.params, config = __rest(_a, ["url", "headers", "params"]);
+        return axios
+            .delete(url, __assign(__assign({}, config), { data: data, headers: this.makeAxiosHeaders(headers) }))
+            .then(this.extractData);
+    };
+    AxiosHttpNetworkProvider.prototype.getBlob = function (_a) {
+        var url = _a.url, headers = _a.headers, config = __rest(_a, ["url", "headers"]);
+        return axios
+            .get(url, __assign(__assign({}, config), { headers: this.makeAxiosHeaders(headers), responseType: 'blob' }))
+            .then(this.extractData);
+    };
+    AxiosHttpNetworkProvider = __decorate([
+        ErrorParser(throwableAxiosErrorParser)
+    ], AxiosHttpNetworkProvider);
+    return AxiosHttpNetworkProvider;
+}());
+export { AxiosHttpNetworkProvider };

package/esm5/http-api/axios/AxiosHttpUploadProvider.js

@@ -0,0 +1,52 @@
+import { __decorate } from "tslib";
+import axios from 'axios';
+import { ErrorParser } from '../ErrorParser.decorator';
+import { convertToFormData } from '../network.util';
+import { throwableAxiosErrorParser } from './throwableAxiosErrorParser';
+var AxiosHttpUploadProvider = (function () {
+    function AxiosHttpUploadProvider() {
+        this.handleDownloadProgressCurried = function (onProgress) {
+            return function (_a) {
+                var loaded = _a.loaded, total = _a.total;
+                return onProgress({
+                    completed: loaded >= total,
+                    loaded: loaded,
+                    progress: Math.floor((loaded * 1000) / total) / 10,
+                    total: total,
+                });
+            };
+        };
+    }
+    AxiosHttpUploadProvider.prototype.extractData = function (axiosRes) {
+        return axiosRes.data;
+    };
+    AxiosHttpUploadProvider.prototype.makeAxiosHeaders = function (headers) {
+        return {
+            common: headers,
+        };
+    };
+    AxiosHttpUploadProvider.prototype.upload = function (method, _a) {
+        var url = _a.url, data = _a.data, headers = _a.headers, withCredentials = _a.withCredentials, timeout = _a.timeout, onProgress = _a.onProgress;
+        return axios(url, {
+            method: method,
+            data: convertToFormData(data),
+            headers: this.makeAxiosHeaders(headers),
+            withCredentials: withCredentials,
+            timeout: timeout,
+            onDownloadProgress: onProgress
+                ? this.handleDownloadProgressCurried(onProgress)
+                : undefined,
+        }).then(this.extractData);
+    };
+    AxiosHttpUploadProvider.prototype.post = function (config) {
+        return this.upload('POST', config);
+    };
+    AxiosHttpUploadProvider.prototype.put = function (config) {
+        return this.upload('PUT', config);
+    };
+    AxiosHttpUploadProvider = __decorate([
+        ErrorParser(throwableAxiosErrorParser)
+    ], AxiosHttpUploadProvider);
+    return AxiosHttpUploadProvider;
+}());
+export { AxiosHttpUploadProvider };

package/esm5/http-api/axios/axios.util.js

@@ -0,0 +1,7 @@
+export function isAxiosError(error) {
+    return (error &&
+        error.response &&
+        typeof error.response.status === 'number' &&
+        error.config &&
+        typeof error.config.url === 'string');
+}

package/esm5/http-api/axios/index.js

@@ -0,0 +1,2 @@
+export * from './AxiosHttpNetworkProvider';
+export * from './AxiosHttpUploadProvider';

package/esm5/http-api/axios/throwableAxiosErrorParser.js

@@ -0,0 +1,23 @@
+import { HttpRestError } from '../../types';
+import { isAxiosError } from './axios.util';
+export function throwableAxiosErrorParser(error) {
+    var _a, _b;
+    if (isAxiosError(error)) {
+        var errorData = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data;
+        var meta = {
+            url: error.config.url || '',
+            status: ((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) || 0,
+            rawData: errorData,
+        };
+        if (HttpRestError.isErrorLike(errorData)) {
+            throw new HttpRestError(errorData.message, meta);
+        }
+        if (typeof errorData === 'string' && errorData) {
+            if (errorData.substring(0, 200).toLowerCase().includes('<html')) {
+                throw new HttpRestError(HttpRestError.DEFAULT_MESSAGE, meta);
+            }
+            throw new HttpRestError(errorData, meta);
+        }
+        throw new HttpRestError(HttpRestError.DEFAULT_MESSAGE, meta);
+    }
+}

package/esm5/http-api/createHttpApi.factory.js

@@ -0,0 +1,10 @@
+import { qs } from '../util';
+import { AxiosHttpNetworkProvider } from './axios';
+import { BasicHttpApi } from './BasicHttpApi';
+import { defaultHeaderCreator } from './network.util';
+export function createHttpApi(baseUrl, headerCreator, paramsSerializer, withCredentials) {
+    if (headerCreator === void 0) { headerCreator = defaultHeaderCreator; }
+    if (paramsSerializer === void 0) { paramsSerializer = qs.serialize; }
+    if (withCredentials === void 0) { withCredentials = true; }
+    return new BasicHttpApi(new AxiosHttpNetworkProvider(), baseUrl, headerCreator, paramsSerializer, withCredentials);
+}

package/esm5/http-api/createHttpHeaderPipe.js

@@ -0,0 +1,34 @@
+import { __awaiter, __generator } from "tslib";
+import { isServer } from '../util/envCheck';
+function makeHeaders(pipes, token) {
+    if (token === void 0) { token = ''; }
+    var rawMap = pipes.reduce(function (prev, fn) { return fn(prev, token); }, new Map());
+    return Object.fromEntries(rawMap);
+}
+export var createHttpHeaderPipe = function (provider, loginRequiredMessage) {
+    if (loginRequiredMessage === void 0) { loginRequiredMessage = '로그인 상태가 만료 되었습니다.\n다시 로그인 하여 주시기 바랍니다.'; }
+    return function headerPipe() {
+        var pipes = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            pipes[_i] = arguments[_i];
+        }
+        return __awaiter(this, void 0, void 0, function () {
+            var token;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        token = '';
+                        if (!provider) return [3, 2];
+                        return [4, provider.get()];
+                    case 1:
+                        token = _a.sent();
+                        if (!token && !isServer()) {
+                            throw new Error(loginRequiredMessage);
+                        }
+                        _a.label = 2;
+                    case 2: return [2, makeHeaders(pipes, token)];
+                }
+            });
+        });
+    };
+};

package/esm5/http-api/createHttpUploadApi.factory.js

@@ -0,0 +1,10 @@
+import { qs } from '../util';
+import { AxiosHttpUploadProvider } from './axios';
+import { BasicHttpUploadApi } from './BasicHttpUploadApi';
+import { defaultHeaderCreator } from './network.util';
+export function createHttpUploadApi(baseUrl, headerCreator, paramsSerializer, withCredentials) {
+    if (headerCreator === void 0) { headerCreator = defaultHeaderCreator; }
+    if (paramsSerializer === void 0) { paramsSerializer = qs.serialize; }
+    if (withCredentials === void 0) { withCredentials = true; }
+    return new BasicHttpUploadApi(new AxiosHttpUploadProvider(), baseUrl, headerCreator, paramsSerializer, withCredentials);
+}

package/esm5/http-api/httpHeaderOperator.js

@@ -0,0 +1,15 @@
+var pipeHeaderDataCurried = function (key, value) { return function (headerData) {
+    return headerData.set(key, value);
+}; };
+export var httpHeaderOperator = {
+    acceptContentType: pipeHeaderDataCurried('Accept', 'application/json'),
+    contentTypeFormPost: pipeHeaderDataCurried('Content-Type', 'application/x-www-form-urlencoded'),
+    contentTypeFormMultipart: pipeHeaderDataCurried('Content-Type', 'multipart/form-data'),
+    contentTypeJson: pipeHeaderDataCurried('Content-Type', 'application/json; charset=utf-8'),
+    bearerToken: function (headerData, token) {
+        if (token) {
+            headerData.set('Authorization', "Bearer ".concat(token));
+        }
+        return headerData;
+    },
+};

package/esm5/http-api/index.js

@@ -1,3 +1,8 @@
-export * from './httpApi.factory';
-export * from './httpHeader.factory';
+export * from './BasicHttpApi';
+export * from './BasicHttpUploadApi';
+export * from './ErrorParser.decorator';
+export * from './createHttpApi.factory';
+export * from './createHttpHeaderPipe';
+export * from './createHttpUploadApi.factory';
 export * from './network.type';
+export * from './httpHeaderOperator';

package/esm5/http-api/network.util.js

@@ -0,0 +1,72 @@
+import { HttpRestError } from '../types';
+import { isNumber, isObject, isString, isUndefined } from '../util/typeCheck';
+function isOptionalBoolean(value) {
+    if (isUndefined(value)) {
+        return true;
+    }
+    if (value === true || value === false) {
+        return true;
+    }
+    return false;
+}
+function isOptionalNumber(value) {
+    if (isUndefined(value)) {
+        return true;
+    }
+    if (isNumber(value)) {
+        return true;
+    }
+    return false;
+}
+export function isBaseAsyncHttpNetworkConfig(value) {
+    if (!value) {
+        return false;
+    }
+    var target = value;
+    if (!target.url || isString(target.url) === false) {
+        return false;
+    }
+    if (!target.headers || isObject(target.headers) === false) {
+        return false;
+    }
+    if (isOptionalBoolean(target.withCredentials) === false) {
+        return false;
+    }
+    if (isOptionalNumber(target.timeout) === false) {
+        return false;
+    }
+    return true;
+}
+export function throwHttpRestError(error) {
+    if (error &&
+        (HttpRestError.isHttpRestErrorLike(error) ||
+            HttpRestError.isErrorLike(error) ||
+            typeof error === 'string')) {
+        throw HttpRestError.from(error);
+    }
+    throw new HttpRestError(HttpRestError.DEFAULT_MESSAGE, {
+        url: '',
+        status: 0,
+        rawData: error,
+    });
+}
+export function convertToFormData(data) {
+    return Object.entries(data).reduce(function (formData, _a) {
+        var key = _a[0], value = _a[1];
+        if (Array.isArray(value)) {
+            return value.reduce(function (innerFormData, file) {
+                innerFormData.append(key, file, file.name);
+                return innerFormData;
+            }, formData);
+        }
+        if (typeof value === 'string') {
+            formData.set(key, value);
+            return formData;
+        }
+        formData.set(key, value, value.name);
+        return formData;
+    }, new FormData());
+}
+export function defaultHeaderCreator() {
+    return Promise.resolve({});
+}