jordy 0.14.7 → 0.14.8

package/{esm5 → esm6}/adaptive-render/AdaptiveRender.js

@@ -1,9 +1,8 @@
 import React from 'react';
 import { useIsMobile, useIsTablet } from './DeviceDetectContext';
-export var AdaptiveRender = function (_a) {
-    var mobile = _a.mobile, notTablet = _a.notTablet, children = _a.children;
-    var isMobile = useIsMobile();
-    var isTablet = useIsTablet();
+export const AdaptiveRender = ({ mobile, notTablet, children, }) => {
+    const isMobile = useIsMobile();
+    const isTablet = useIsTablet();
     if (notTablet && isTablet) {
         return null;
     }

package/{esm5 → esm6}/adaptive-render/DeviceDetectContext.js

@@ -1,4 +1,3 @@
-import { __read } from "tslib";
 import React, { createContext, useContext, useEffect, useMemo, useState, } from 'react';
 import { isMobile as isMobileCheck, isNativeApp as isNativeAppCheck, isServer, isTablet as isTabletCheck, } from '../util/envCheck';
 import { DeviceSizeEnum } from './device.type';
@@ -26,38 +25,37 @@ function getIsTablet() {
         (window.innerWidth >= DeviceSizeEnum.TABLET &&
             window.innerWidth <= DeviceSizeEnum.DESKTOP_SM - 1));
 }
-export var DeviceDetectContext = createContext([
+export const DeviceDetectContext = createContext([
     getIsMobile(),
     getIsTablet(),
     isNativeAppCheck(),
 ]);
-var DeviceDetectContextProvider = DeviceDetectContext.Provider;
-export var DeviceDetectProvider = function (_a) {
-    var children = _a.children;
-    var _b = __read(useState(getIsMobile()), 2), isMobile = _b[0], setIsMobile = _b[1];
-    var _c = __read(useState(getIsTablet()), 2), isTablet = _c[0], setIsTablet = _c[1];
-    var isNative = useMemo(isNativeAppCheck, []);
-    useEffect(function () {
+const { Provider: DeviceDetectContextProvider } = DeviceDetectContext;
+export const DeviceDetectProvider = ({ children, }) => {
+    const [isMobile, setIsMobile] = useState(getIsMobile());
+    const [isTablet, setIsTablet] = useState(getIsTablet());
+    const isNative = useMemo(isNativeAppCheck, []);
+    useEffect(() => {
         if (isServer() || !window || typeof window.matchMedia !== 'function') {
             return undefined;
         }
-        var mqMobile = window.matchMedia("screen and (max-width: ".concat(DeviceSizeEnum.TABLET - 1, "px)"));
-        var mqTablet = window.matchMedia("screen and (min-width: ".concat(DeviceSizeEnum.TABLET, "px) and (max-width: ").concat(DeviceSizeEnum.DESKTOP_SM - 1, "px)"));
-        var handleResizeForMobile = function (e) {
+        const mqMobile = window.matchMedia(`screen and (max-width: ${DeviceSizeEnum.TABLET - 1}px)`);
+        const mqTablet = window.matchMedia(`screen and (min-width: ${DeviceSizeEnum.TABLET}px) and (max-width: ${DeviceSizeEnum.DESKTOP_SM - 1}px)`);
+        const handleResizeForMobile = (e) => {
             setIsMobile(e.matches);
         };
-        var handleResizeForTablet = function (e) {
+        const handleResizeForTablet = (e) => {
             setIsTablet(e.matches);
         };
         mqMobile.addEventListener('change', handleResizeForMobile);
         mqTablet.addEventListener('change', handleResizeForTablet);
-        return function () {
+        return () => {
             mqMobile.removeEventListener('change', handleResizeForMobile);
             mqTablet.removeEventListener('change', handleResizeForTablet);
         };
     }, []);
     return (React.createElement(DeviceDetectContextProvider, { value: [isMobile, isTablet, isNative] }, children));
 };
-export var useIsMobile = function () { return useContext(DeviceDetectContext)[0]; };
-export var useIsTablet = function () { return useContext(DeviceDetectContext)[1]; };
-export var useIsNative = function () { return useContext(DeviceDetectContext)[2]; };
+export const useIsMobile = () => useContext(DeviceDetectContext)[0];
+export const useIsTablet = () => useContext(DeviceDetectContext)[1];
+export const useIsNative = () => useContext(DeviceDetectContext)[2];

package/{esm5 → esm6}/adaptive-render/withAdaptiveRender.js

@@ -1,13 +1,12 @@
-import { __assign } from "tslib";
 import React from 'react';
 import { useIsMobile, useIsTablet, useIsNative } from './DeviceDetectContext';
 export function withAdaptiveRender(settings) {
-    var FnComp = function (props) {
-        var isMobile = useIsMobile();
-        var isTablet = useIsTablet();
-        var isNative = useIsNative();
-        var DesktopComp = settings.desktop, TabletComp = settings.tablet, MobileComp = settings.mobile, NativeAppComp = settings.native;
-        var Comp;
+    const FnComp = (props) => {
+        const isMobile = useIsMobile();
+        const isTablet = useIsTablet();
+        const isNative = useIsNative();
+        const { desktop: DesktopComp, tablet: TabletComp, mobile: MobileComp, native: NativeAppComp, } = settings;
+        let Comp;
         if (isNative && NativeAppComp) {
             Comp = NativeAppComp;
         }
@@ -23,7 +22,7 @@ export function withAdaptiveRender(settings) {
         else {
             return null;
         }
-        return React.createElement(Comp, __assign({}, props));
+        return React.createElement(Comp, Object.assign({}, props));
     };
     return FnComp;
 }

package/esm6/hooks/useDebounce.js

@@ -0,0 +1,24 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useMemo } from 'react';
+export function useDebounce(fn, time = 300, deps = []) {
+    const timerRef = useRef(0);
+    const memoizeFn = useCallback(fn, deps);
+    useEffect(() => () => clearTimeout(timerRef.current), [memoizeFn]);
+    const callback = useMemo(() => {
+        const result = ((args) => {
+            if (timerRef.current) {
+                clearTimeout(timerRef.current);
+            }
+            timerRef.current = setTimeout(() => {
+                memoizeFn(args);
+            }, time);
+        });
+        result.stop = () => {
+            if (timerRef.current) {
+                clearTimeout(timerRef.current);
+            }
+        };
+        return result;
+    }, [memoizeFn]);
+    return callback;
+}

package/{esm5 → esm6}/hooks/useNavigate.js

@@ -1,4 +1,3 @@
-import { __assign, __read, __spreadArray } from "tslib";
 import { useCallback } from 'react';
 import { useNavigate as useRcNavigate, useSearchParams, } from 'react-router-dom';
 import { isNullable, isObject, isUndefined } from '../util';
@@ -12,8 +11,7 @@ function isMergeQueries(option) {
     return isUndefined(option) || (option && option['merge'] === true);
 }
 function refineQueries(queries) {
-    return Object.entries(queries).reduce(function (acc, _a) {
-        var _b = __read(_a, 2), key = _b[0], value = _b[1];
+    return Object.entries(queries).reduce((acc, [key, value]) => {
         if (!isNullable(value) && value !== '') {
             acc[key] = value;
         }
@@ -21,9 +19,9 @@ function refineQueries(queries) {
     }, {});
 }
 export function useNavigate() {
-    var _a = __read(useSearchParams(), 2), currentSearchParams = _a[0], setSearchParams = _a[1];
-    var navigate = useRcNavigate();
-    var navigation = useCallback(function (to, option) {
+    const [currentSearchParams, setSearchParams] = useSearchParams();
+    const navigate = useRcNavigate();
+    const navigation = useCallback((to, option) => {
         if (typeof to === 'number') {
             return navigate(to);
         }
@@ -35,12 +33,11 @@ export function useNavigate() {
         }
         if (instanceOfSearchParams(to)) {
             if (isMergeQueries(option)) {
-                var currentQueries = __spreadArray([], __read(currentSearchParams), false).reduce(function (acc, _a) {
-                    var _b = __read(_a, 2), key = _b[0], value = _b[1];
+                const currentQueries = [...currentSearchParams].reduce((acc, [key, value]) => {
                     acc[key] = value;
                     return acc;
                 }, {});
-                var mergeQueries = __assign(__assign({}, currentQueries), to);
+                const mergeQueries = Object.assign(Object.assign({}, currentQueries), to);
                 return setSearchParams(refineQueries(mergeQueries), option);
             }
             return setSearchParams(refineQueries(to), option);

package/esm6/hooks/useQueryParams.js

@@ -0,0 +1,18 @@
+import { useCallback, useMemo } from 'react';
+import { useLocation, useParams } from 'react-router-dom';
+import { qs } from '../util/queryString';
+const defSelector = (params) => {
+    return params;
+};
+export function useQueryParams(selector = defSelector) {
+    const selConverter = useCallback(selector, []);
+    const location = useLocation();
+    const params = useParams();
+    const searchString = location.search;
+    const result = useMemo(() => {
+        const query = qs.parse(searchString);
+        const innerResult = Object.assign(Object.assign({}, query), params);
+        return selConverter(innerResult);
+    }, [searchString, params, selConverter]);
+    return result;
+}

package/esm6/hooks/useThrottle.js

@@ -0,0 +1,16 @@
+import { useRef, useEffect, useCallback } from 'react';
+export function useThrottle(fn, time = 300, deps = []) {
+    const timerRef = useRef(0);
+    const memoizeFn = useCallback(fn, deps);
+    useEffect(() => () => clearTimeout(timerRef.current), [memoizeFn]);
+    const callback = useCallback((args) => {
+        if (timerRef.current) {
+            return;
+        }
+        timerRef.current = setTimeout(() => {
+            timerRef.current = 0;
+        }, time);
+        memoizeFn(args);
+    }, [memoizeFn]);
+    return callback;
+}

package/esm6/http-api/BaseInterceptorHttpApi.js

@@ -0,0 +1,45 @@
+export class BaseInterceptorHttpApi {
+    constructor(paramsSerializer) {
+        this.paramsSerializer = paramsSerializer;
+        this._interceptor = {};
+        this.mergeParams = (method, url, paramsOriginal) => {
+            if (this._interceptor.params) {
+                const paramsAdditional = this._interceptor.params(method, url, paramsOriginal);
+                if (paramsAdditional) {
+                    if (paramsOriginal) {
+                        return Object.assign(Object.assign({}, paramsOriginal), paramsAdditional);
+                    }
+                    return paramsAdditional;
+                }
+            }
+            return paramsOriginal;
+        };
+        this.mergeQueries = (method, url, paramsOriginal) => {
+            if (this._interceptor.params) {
+                const paramsAdditional = this._interceptor.params(method, url, paramsOriginal);
+                if (!paramsAdditional) {
+                    return url;
+                }
+                return (url +
+                    (url.includes('?') ? '&' : '?') +
+                    this.paramsSerializer(paramsAdditional));
+            }
+            return url;
+        };
+        this.throwWithInterceptor = (err) => {
+            if (this._interceptor.error) {
+                const nextError = this._interceptor.error(err);
+                if (nextError) {
+                    throw nextError;
+                }
+            }
+            throw err;
+        };
+    }
+    get interceptor() {
+        return this._interceptor;
+    }
+    set interceptor(value) {
+        this._interceptor = value;
+    }
+}

package/esm6/http-api/BasicHttpApi.js

@@ -0,0 +1,126 @@
+import { __awaiter } from "tslib";
+import { getFileName } from '../util';
+import { BaseInterceptorHttpApi } from './BaseInterceptorHttpApi';
+export class BasicHttpApi extends BaseInterceptorHttpApi {
+    constructor(provider, baseUrl, headersCreator, paramsSerializer, withCredentials = true) {
+        super(paramsSerializer);
+        this.provider = provider;
+        this.baseUrl = baseUrl;
+        this.headersCreator = headersCreator;
+        this.withCredentials = withCredentials;
+    }
+    get(url, params, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const headers = yield this.headersCreator();
+                return yield this.provider.get({
+                    url: `${this.baseUrl}${url}`,
+                    headers,
+                    withCredentials: this.withCredentials,
+                    paramsSerializer: this.paramsSerializer,
+                    params: this.mergeParams('get', url, params),
+                    timeout,
+                });
+            }
+            catch (error) {
+                this.throwWithInterceptor(error);
+            }
+        });
+    }
+    post(url, body, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const headers = yield this.headersCreator();
+                return yield this.provider.post({
+                    url: `${this.baseUrl}${this.mergeQueries('post', url, body)}`,
+                    headers,
+                    withCredentials: this.withCredentials,
+                    paramsSerializer: this.paramsSerializer,
+                    params: body,
+                    timeout,
+                });
+            }
+            catch (error) {
+                this.throwWithInterceptor(error);
+            }
+        });
+    }
+    put(url, body, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const headers = yield this.headersCreator();
+                return yield this.provider.put({
+                    url: `${this.baseUrl}${this.mergeQueries('put', url, body)}`,
+                    headers,
+                    withCredentials: this.withCredentials,
+                    paramsSerializer: this.paramsSerializer,
+                    params: body,
+                    timeout,
+                });
+            }
+            catch (error) {
+                this.throwWithInterceptor(error);
+            }
+        });
+    }
+    patch(url, body, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const headers = yield this.headersCreator();
+                return yield this.provider.patch({
+                    url: `${this.baseUrl}${this.mergeQueries('patch', url, body)}`,
+                    headers,
+                    withCredentials: this.withCredentials,
+                    paramsSerializer: this.paramsSerializer,
+                    params: body,
+                    timeout,
+                });
+            }
+            catch (error) {
+                this.throwWithInterceptor(error);
+            }
+        });
+    }
+    delete(url, body, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const headers = yield this.headersCreator();
+                return yield this.provider.delete({
+                    url: `${this.baseUrl}${this.mergeQueries('delete', url, body)}`,
+                    headers,
+                    withCredentials: this.withCredentials,
+                    paramsSerializer: this.paramsSerializer,
+                    params: body,
+                    timeout,
+                });
+            }
+            catch (error) {
+                this.throwWithInterceptor(error);
+            }
+        });
+    }
+    getFile(url, params, filename) {
+        return this.getBlob(url, params)
+            .then((blob) => {
+            return new File([blob], filename || getFileName(url));
+        })
+            .catch(this.throwWithInterceptor);
+    }
+    getBlob(url, params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const headers = yield this.headersCreator();
+                return yield this.provider.getBlob({
+                    url: `${this.baseUrl}${url}`,
+                    headers,
+                    withCredentials: this.withCredentials,
+                    paramsSerializer: this.paramsSerializer,
+                    params: this.mergeParams('get', url, params),
+                });
+            }
+            catch (error) {
+                this.throwWithInterceptor(error);
+            }
+        });
+    }
+}

package/esm6/http-api/BasicHttpUploadApi.js

@@ -0,0 +1,47 @@
+import { __awaiter } from "tslib";
+import { BaseInterceptorHttpApi } from './BaseInterceptorHttpApi';
+export class BasicHttpUploadApi extends BaseInterceptorHttpApi {
+    constructor(provider, baseUrl, headersCreator, paramsSerializer, withCredentials = true) {
+        super(paramsSerializer);
+        this.provider = provider;
+        this.baseUrl = baseUrl;
+        this.headersCreator = headersCreator;
+        this.withCredentials = withCredentials;
+    }
+    postUpload(url, data, progressCallback, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const headers = yield this.headersCreator();
+                return yield this.provider.post({
+                    url: `${this.baseUrl}${this.mergeQueries('post', url, data)}`,
+                    headers,
+                    withCredentials: this.withCredentials,
+                    data,
+                    timeout,
+                    onProgress: progressCallback,
+                });
+            }
+            catch (error) {
+                this.throwWithInterceptor(error);
+            }
+        });
+    }
+    putUpload(url, data, progressCallback, timeout) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const headers = yield this.headersCreator();
+                return yield this.provider.put({
+                    url: `${this.baseUrl}${this.mergeQueries('put', url, data)}`,
+                    headers,
+                    withCredentials: this.withCredentials,
+                    data,
+                    timeout,
+                    onProgress: progressCallback,
+                });
+            }
+            catch (error) {
+                this.throwWithInterceptor(error);
+            }
+        });
+    }
+}

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

@@ -0,0 +1,54 @@
+import { __awaiter } 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 class ErrorParserDecoratedUnionHttpNetworkProvider {
+            constructor(...args) {
+                this.parse = (error) => __awaiter(this, void 0, void 0, function* () {
+                    const nextError = throwableParser(error);
+                    if (nextError) {
+                        throw nextError;
+                    }
+                    throwHttpRestError(error);
+                });
+                this.network = new ClassConstructor(args[0], args[1], args[2]);
+            }
+            get(...args) {
+                return this.network.get
+                    .apply(this.network, [...args])
+                    .catch(this.parse);
+            }
+            post(...args) {
+                return this.network.post
+                    .apply(this.network, [...args])
+                    .catch(this.parse);
+            }
+            put(...args) {
+                return this.network.put
+                    .apply(this.network, [...args])
+                    .catch(this.parse);
+            }
+            patch(...args) {
+                return this.network.patch
+                    .apply(this.network, [...args])
+                    .catch(this.parse);
+            }
+            delete(...args) {
+                return this.network.delete
+                    .apply(this.network, [...args])
+                    .catch(this.parse);
+            }
+            getBlob(...args) {
+                return this.network.getBlob
+                    .apply(this.network, [...args])
+                    .catch(this.parse);
+            }
+        };
+    };
+}

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

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

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

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

package/{esm5 → esm6}/http-api/axios/throwableAxiosErrorParser.js

@@ -11,8 +11,8 @@ function tryGetMethod(method) {
 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 = {
+        const errorData = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data;
+        const meta = {
             url: error.config.url || '',
             method: tryGetMethod(error.config.method),
             status: Number(((_b = error.response) === null || _b === void 0 ? void 0 : _b.status) || 0),

package/{esm5 → esm6}/http-api/createHttpApi.factory.js

@@ -2,9 +2,6 @@ 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; }
+export function createHttpApi(baseUrl, headerCreator = defaultHeaderCreator, paramsSerializer = qs.serialize, withCredentials = true) {
     return new BasicHttpApi(new AxiosHttpNetworkProvider(), baseUrl, headerCreator, paramsSerializer, withCredentials);
 }

package/esm6/http-api/createHttpHeaderPipe.js

@@ -0,0 +1,20 @@
+import { __awaiter } from "tslib";
+import { isServer } from '../util/envCheck';
+function makeHeaders(pipes, token = '') {
+    const rawMap = pipes.reduce((prev, fn) => fn(prev, token), new Map());
+    return Object.fromEntries(rawMap);
+}
+export const createHttpHeaderPipe = (provider, loginRequiredMessage = '로그인 상태가 만료 되었습니다.\n다시 로그인 하여 주시기 바랍니다.') => {
+    return function headerPipe(...pipes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let token = '';
+            if (provider) {
+                token = yield provider.get();
+                if (!token && !isServer()) {
+                    throw new Error(loginRequiredMessage);
+                }
+            }
+            return makeHeaders(pipes, token);
+        });
+    };
+};

package/{esm5 → esm6}/http-api/createHttpUploadApi.factory.js

@@ -2,9 +2,6 @@ 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; }
+export function createHttpUploadApi(baseUrl, headerCreator = defaultHeaderCreator, paramsSerializer = qs.serialize, withCredentials = true) {
     return new BasicHttpUploadApi(new AxiosHttpUploadProvider(), baseUrl, headerCreator, paramsSerializer, withCredentials);
 }