@bleedingdev/modern-js-create-request 3.2.0-ultramodern.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,26 @@
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+
+<h1 align="center">Modern.js</h1>
+
+<p align="center">
+  A Progressive React Framework for modern web development.
+</p>
+
+## Getting Started
+
+Please follow [Quick Start](https://modernjs.dev/en/guides/get-started/quick-start) to get started with Modern.js.
+
+## Documentation
+
+- [English Documentation](https://modernjs.dev/en/)
+- [中文文档](https://modernjs.dev)
+
+## Contributing
+
+Please read the [Contributing Guide](https://github.com/web-infra-dev/modern.js/blob/main/CONTRIBUTING.md).
+
+## License
+
+Modern.js is [MIT licensed](https://github.com/web-infra-dev/modern.js/blob/main/LICENSE).

package/dist/cjs/browser.js

@@ -0,0 +1,489 @@
+"use strict";
+var __webpack_modules__ = {
+    "./handleRes" (module) {
+        module.exports = require("./handleRes.js");
+    },
+    "./requestContext" (module) {
+        module.exports = require("./requestContext.js");
+    },
+    "./transport" (module) {
+        module.exports = require("./transport.js");
+    },
+    "./types" (module) {
+        module.exports = require("./types.js");
+    },
+    "./utiles" (module) {
+        module.exports = require("./utiles.js");
+    },
+    "path-to-regexp" (module) {
+        module.exports = require("path-to-regexp");
+    },
+    qs (module) {
+        module.exports = require("qs");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        CrossOriginEnvelopePolicyError: ()=>CrossOriginEnvelopePolicyError,
+        IdentityBindingViolationError: ()=>IdentityBindingViolationError,
+        OperationContractViolationError: ()=>OperationContractViolationError,
+        ProducerClientNotInitializedError: ()=>ProducerClientNotInitializedError,
+        ProducerDomainNotConfiguredError: ()=>ProducerDomainNotConfiguredError,
+        configure: ()=>configure,
+        createRequest: ()=>createRequest,
+        createUploader: ()=>createUploader
+    });
+    var path_to_regexp__rspack_import_0 = __webpack_require__("path-to-regexp");
+    var qs__rspack_import_1 = __webpack_require__("qs");
+    var _handleRes__rspack_import_2 = __webpack_require__("./handleRes");
+    var _transport__rspack_import_3 = __webpack_require__("./transport");
+    var _types__rspack_import_4 = __webpack_require__("./types");
+    var _utiles__rspack_import_5 = __webpack_require__("./utiles");
+    var _requestContext__rspack_import_6 = __webpack_require__("./requestContext");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _requestContext__rspack_import_6)if ([
+        "IdentityBindingViolationError",
+        "configure",
+        "OperationContractViolationError",
+        "default",
+        "ProducerClientNotInitializedError",
+        "ProducerDomainNotConfiguredError",
+        "createUploader",
+        "CrossOriginEnvelopePolicyError",
+        "createRequest"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_requestContext__rspack_import_6[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_4)if ([
+        "IdentityBindingViolationError",
+        "configure",
+        "OperationContractViolationError",
+        "default",
+        "ProducerClientNotInitializedError",
+        "ProducerDomainNotConfiguredError",
+        "createUploader",
+        "CrossOriginEnvelopePolicyError",
+        "createRequest"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    const realRequest = new Map();
+    const realAllowedHeaders = new Map();
+    const realRequireEnvelope = new Map();
+    const realAllowCrossOriginEnvelope = new Map();
+    const realTransportResilience = new Map();
+    const realIdentityBinding = new Map();
+    const realOperationContract = new Map();
+    const domainMap = new Map();
+    const isEmptyDomain = (domain)=>'string' != typeof domain || '' === domain.trim();
+    const TRACEPARENT_HEADER = 'traceparent';
+    const OPERATION_CONTEXT_DETAIL_HEADER = _types__rspack_import_4.BFF_OPERATION_CONTEXT_DETAIL_HEADER;
+    const TRACEPARENT_REGEX = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/i;
+    const readProcessEnv = (key)=>{
+        if ("u" < typeof process || void 0 === process.env || 'string' != typeof process.env[key]) return;
+        return process.env[key];
+    };
+    const isStrictDefaultRequestIdEnabled = ()=>'true' === readProcessEnv('MODERN_BFF_STRICT_DEFAULT_REQUEST_ID');
+    const isSecuredRequestId = (requestId)=>'default' !== requestId || isStrictDefaultRequestIdEnabled();
+    const firstHeaderValue = (value)=>Array.isArray(value) ? value[0] : value;
+    const findHeaderKey = (headers, header)=>{
+        const normalized = header.toLowerCase();
+        return Object.keys(headers).find((key)=>key.toLowerCase() === normalized);
+    };
+    const readHeader = (headers, header)=>{
+        const key = findHeaderKey(headers, header);
+        return 'string' == typeof key ? headers[key] : void 0;
+    };
+    const writeHeader = (headers, header, value)=>{
+        if (void 0 === value) return;
+        const key = findHeaderKey(headers, header);
+        if ('string' == typeof key && key !== header) delete headers[key];
+        headers[header] = value;
+    };
+    const deleteHeader = (headers, header)=>{
+        const key = findHeaderKey(headers, header);
+        if ('string' == typeof key) delete headers[key];
+    };
+    const toOrigin = (value)=>{
+        if (!value) return;
+        try {
+            return new URL(value).origin;
+        } catch (error) {
+            return;
+        }
+    };
+    const parseTraceparent = (value)=>{
+        const traceparent = firstHeaderValue(value);
+        if ('string' != typeof traceparent) return;
+        const match = traceparent.trim().match(TRACEPARENT_REGEX);
+        if (!match) return;
+        const [, traceId, spanId] = match;
+        if (!traceId || !spanId) return;
+        return {
+            traceId: traceId.toLowerCase(),
+            spanId: spanId.toLowerCase()
+        };
+    };
+    const extractPathParamNames = (path)=>Array.from(path.matchAll(/:([A-Za-z0-9_]+)/g)).flatMap(([, key])=>key ? [
+                key
+            ] : []);
+    const originFetch = (...params)=>{
+        const [url, init] = params;
+        if (init?.method?.toLowerCase() === 'get') init.body = void 0;
+        return fetch(url, init).then(_handleRes__rspack_import_2.handleRes);
+    };
+    const buildOperationContext = ({ requestId, method, path, operationContext, traceparent })=>{
+        const routePath = operationContext?.routePath || path;
+        const operationMethod = (operationContext?.method || method || 'GET').toUpperCase();
+        const rawOperationId = operationContext?.operationId || `${operationMethod}:${routePath}`;
+        const operationId = rawOperationId.startsWith(`${requestId}:`) ? rawOperationId : `${requestId}:${rawOperationId}`;
+        const traceparentValue = operationContext?.traceparent || ('string' == typeof firstHeaderValue(traceparent) ? String(firstHeaderValue(traceparent)) : void 0);
+        const parsedTraceContext = operationContext?.traceId && operationContext?.spanId ? {
+            traceId: operationContext.traceId,
+            spanId: operationContext.spanId
+        } : parseTraceparent(traceparentValue);
+        return {
+            requestId,
+            operationId,
+            routePath,
+            method: operationMethod,
+            ...operationContext?.schemaHash ? {
+                schemaHash: operationContext.schemaHash
+            } : {},
+            ...'number' == typeof operationContext?.operationVersion ? {
+                operationVersion: operationContext.operationVersion
+            } : {},
+            ...traceparentValue ? {
+                traceparent: traceparentValue
+            } : {},
+            ...parsedTraceContext ? {
+                traceId: parsedTraceContext.traceId,
+                spanId: parsedTraceContext.spanId
+            } : {}
+        };
+    };
+    class ProducerClientNotInitializedError extends Error {
+        constructor(requestId){
+            super(`Producer client "${requestId}" is not initialized. Call initProducerClient() (or configure()) before using generated APIs for this requestId.`), this.code = 'BFF_PRODUCER_CLIENT_NOT_INITIALIZED';
+            this.name = 'ProducerClientNotInitializedError';
+        }
+    }
+    class ProducerDomainNotConfiguredError extends Error {
+        constructor(requestId){
+            super(`Producer client "${requestId}" must provide setDomain() during configure().`), this.code = 'BFF_PRODUCER_DOMAIN_NOT_CONFIGURED';
+            this.name = 'ProducerDomainNotConfiguredError';
+        }
+    }
+    class CrossOriginEnvelopePolicyError extends Error {
+        constructor(requestId, sourceOrigin, targetOrigin){
+            super(`Cross-origin envelope is not allowed for producer "${requestId}" (${sourceOrigin || 'unknown-origin'} -> ${targetOrigin || 'unknown-origin'}). Configure allowCrossOriginEnvelope to explicitly allow this flow.`), this.code = 'BFF_CROSS_ORIGIN_ENVELOPE_NOT_ALLOWED';
+            this.name = 'CrossOriginEnvelopePolicyError';
+        }
+    }
+    class IdentityBindingViolationError extends Error {
+        constructor(violation){
+            super(`Identity header "${violation.header}" for producer "${violation.requestId}" was rejected by server-derived identity binding.`), this.code = 'BFF_IDENTITY_BINDING_VIOLATION';
+            this.name = 'IdentityBindingViolationError';
+            this.violation = violation;
+        }
+    }
+    class OperationContractViolationError extends Error {
+        constructor(violation){
+            super(`Operation contract violation "${violation.reason}" for producer "${violation.requestId}" operation "${violation.operationId}".`), this.code = 'BFF_OPERATION_CONTRACT_VIOLATION';
+            this.name = 'OperationContractViolationError';
+            this.violation = violation;
+        }
+    }
+    const validateOperationContract = (requestId, contextPayload)=>{
+        const operationContract = realOperationContract.get(requestId);
+        const operationContractEnabled = operationContract?.enabled ?? isSecuredRequestId(requestId);
+        if (!operationContractEnabled) return;
+        const strict = operationContract?.strict ?? true;
+        const requireSchemaHash = operationContract?.requireSchemaHash ?? true;
+        const requireOperationVersion = operationContract?.requireOperationVersion ?? true;
+        const maybeReportViolation = (reason)=>{
+            const violation = {
+                requestId,
+                target: 'browser',
+                operationId: contextPayload.operationId,
+                routePath: contextPayload.routePath,
+                method: contextPayload.method,
+                schemaHash: 'string' == typeof contextPayload.schemaHash ? contextPayload.schemaHash : void 0,
+                operationVersion: 'number' == typeof contextPayload.operationVersion ? contextPayload.operationVersion : void 0,
+                reason
+            };
+            operationContract?.onViolation?.(violation);
+            if (strict) throw new OperationContractViolationError(violation);
+        };
+        if (requireSchemaHash && 'string' != typeof contextPayload.schemaHash) maybeReportViolation('missing_schema_hash');
+        if (requireOperationVersion && 'number' != typeof contextPayload.operationVersion) maybeReportViolation('missing_operation_version');
+    };
+    const getConfiguredRequest = (requestId, fallback)=>{
+        const configuredRequest = realRequest.get(requestId);
+        if (configuredRequest) return configuredRequest;
+        if ('default' !== requestId) throw new ProducerClientNotInitializedError(requestId);
+        return fallback;
+    };
+    const configure = (options)=>{
+        const { request, interceptor, allowedHeaders, transport, requireEnvelope, allowCrossOriginEnvelope, identityBinding, operationContract, setDomain, requestId = 'default' } = options;
+        const hasExistingDomain = domainMap.has(requestId);
+        if ('default' !== requestId && !setDomain && !hasExistingDomain) throw new ProducerDomainNotConfiguredError(requestId);
+        let configuredRequest = request || originFetch;
+        if (interceptor && !request) configuredRequest = interceptor(fetch);
+        if (Array.isArray(allowedHeaders)) realAllowedHeaders.set(requestId, allowedHeaders);
+        if (transport && 'object' == typeof transport) realTransportResilience.set(requestId, transport);
+        if (identityBinding && 'object' == typeof identityBinding) realIdentityBinding.set(requestId, identityBinding);
+        if (operationContract && 'object' == typeof operationContract) realOperationContract.set(requestId, operationContract);
+        if ('boolean' == typeof requireEnvelope) realRequireEnvelope.set(requestId, requireEnvelope);
+        if ('boolean' == typeof allowCrossOriginEnvelope || 'function' == typeof allowCrossOriginEnvelope) realAllowCrossOriginEnvelope.set(requestId, allowCrossOriginEnvelope);
+        if (setDomain) {
+            const resolvedDomain = setDomain({
+                target: 'browser',
+                requestId
+            });
+            if ('default' !== requestId && isEmptyDomain(resolvedDomain)) throw new ProducerDomainNotConfiguredError(requestId);
+            if ('string' == typeof resolvedDomain) domainMap.set(requestId, resolvedDomain);
+        }
+        realRequest.set(requestId, configuredRequest);
+    };
+    const normalizeRequestOptions = (...args)=>{
+        if ('object' == typeof args[0] && null !== args[0]) return args[0];
+        const [path, method, port, httpMethodDecider, fetch1, requestId, operationContext] = args;
+        return {
+            path,
+            method,
+            port,
+            httpMethodDecider,
+            fetch: fetch1,
+            requestId,
+            operationContext
+        };
+    };
+    const createRequest = (...args)=>{
+        const { path, method, port, httpMethodDecider = 'functionName', fetch: fetch1 = originFetch, domain, requestId = 'default', operationContext } = normalizeRequestOptions(...args);
+        const getFinalPath = (0, path_to_regexp__rspack_import_0.compile)(path, {
+            encode: encodeURIComponent
+        });
+        const keyNames = extractPathParamNames(path);
+        const sender = async (...args)=>{
+            const fetcher = getConfiguredRequest(requestId, fetch1);
+            let body;
+            let finalURL;
+            let headers;
+            if ('inputParams' === httpMethodDecider) {
+                finalURL = path;
+                body = JSON.stringify({
+                    args
+                });
+                headers = {
+                    'Content-Type': 'application/json'
+                };
+            } else {
+                const payload = 'object' == typeof args[args.length - 1] ? args[args.length - 1] : {};
+                payload.params = payload.params || {};
+                const requestParams = args[0];
+                if ('object' == typeof requestParams && requestParams.params) {
+                    const { params } = requestParams;
+                    keyNames.forEach((keyName)=>{
+                        payload.params[keyName] = params[keyName];
+                    });
+                } else keyNames.forEach((keyName, index)=>{
+                    payload.params[keyName] = args[index];
+                });
+                const finalPath = getFinalPath(payload.params);
+                finalURL = payload.query ? `${finalPath}?${(0, qs__rspack_import_1.stringify)(payload.query)}` : finalPath;
+                headers = payload.headers ? {
+                    ...payload.headers
+                } : {};
+                const identityBinding = realIdentityBinding.get(requestId);
+                const identityBindingEnabled = identityBinding?.enabled ?? isSecuredRequestId(requestId);
+                const identityBindingStrict = identityBinding?.strict ?? isSecuredRequestId(requestId);
+                const protectedIdentityHeaders = (identityBinding?.protectedHeaders || _types__rspack_import_4.BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS).map((header)=>header.toLowerCase());
+                if (identityBindingEnabled) {
+                    const derivedIdentityHeaders = {};
+                    const customDerivedHeaders = identityBinding?.deriveHeaders?.({
+                        requestId,
+                        target: 'browser',
+                        incomingHeaders: {},
+                        protectedHeaders: [
+                            ...protectedIdentityHeaders
+                        ]
+                    });
+                    if (customDerivedHeaders && 'object' == typeof customDerivedHeaders) for (const header of protectedIdentityHeaders){
+                        const customValue = readHeader(customDerivedHeaders, header);
+                        if (void 0 !== customValue) writeHeader(derivedIdentityHeaders, header, customValue);
+                    }
+                    for (const header of protectedIdentityHeaders){
+                        const attemptedValue = readHeader(headers, header);
+                        if (void 0 === attemptedValue) continue;
+                        const violation = {
+                            requestId,
+                            target: 'browser',
+                            header,
+                            attemptedValue,
+                            derivedValue: readHeader(derivedIdentityHeaders, header),
+                            reason: identityBindingStrict ? 'client_override_rejected' : 'client_override_blocked'
+                        };
+                        identityBinding?.onViolation?.(violation);
+                        if (identityBindingStrict) throw new IdentityBindingViolationError(violation);
+                        deleteHeader(headers, header);
+                    }
+                    Object.keys(derivedIdentityHeaders).forEach((header)=>{
+                        writeHeader(headers, header, derivedIdentityHeaders[header]);
+                    });
+                }
+                body = payload.data && 'object' == typeof payload.data ? JSON.stringify(payload.data) : payload.body;
+                if (payload.data) {
+                    headers['Content-Type'] = 'application/json';
+                    body = 'object' == typeof payload.data ? JSON.stringify(payload.data) : payload.body;
+                } else if (payload.body) {
+                    headers['Content-Type'] = 'text/plain';
+                    body = payload.body;
+                } else if (payload.formData) body = payload.formData;
+                else if (payload.formUrlencoded) {
+                    headers['Content-Type'] = 'application/x-www-form-urlencoded';
+                    body = 'object' != typeof payload.formUrlencoded || payload.formUrlencoded instanceof URLSearchParams ? payload.formUrlencoded : (0, qs__rspack_import_1.stringify)(payload.formUrlencoded);
+                }
+            }
+            headers.accept = "application/json,*/*;q=0.8";
+            const configDomain = domainMap.get(requestId);
+            if ('default' !== requestId && isEmptyDomain(configDomain)) throw new ProducerDomainNotConfiguredError(requestId);
+            finalURL = `${configDomain || ''}${finalURL}`;
+            const shouldRequireEnvelope = realRequireEnvelope.get(requestId) ?? isSecuredRequestId(requestId);
+            if (shouldRequireEnvelope) {
+                const sourceOrigin = "u" > typeof window ? window.location.origin : void 0;
+                const targetOrigin = toOrigin(finalURL);
+                const traceContext = parseTraceparent(readHeader(headers, TRACEPARENT_HEADER));
+                const isCrossOrigin = Boolean(sourceOrigin) && Boolean(targetOrigin) && sourceOrigin !== targetOrigin;
+                if (isCrossOrigin) {
+                    const policy = realAllowCrossOriginEnvelope.get(requestId);
+                    const isAllowed = 'function' == typeof policy ? policy({
+                        requestId,
+                        sourceOrigin,
+                        targetOrigin,
+                        target: 'browser'
+                    }) : true === policy;
+                    if (!isAllowed) throw new CrossOriginEnvelopePolicyError(requestId, sourceOrigin, targetOrigin);
+                }
+                headers[_types__rspack_import_4.BFF_ENVELOPE_HEADER] = JSON.stringify({
+                    requestId,
+                    target: 'browser',
+                    timestamp: Date.now(),
+                    sourceOrigin,
+                    targetOrigin,
+                    ...traceContext ? {
+                        traceId: traceContext.traceId,
+                        spanId: traceContext.spanId
+                    } : {}
+                });
+            }
+            if (isSecuredRequestId(requestId)) {
+                if (void 0 === readHeader(headers, TRACEPARENT_HEADER) && operationContext?.traceparent) writeHeader(headers, TRACEPARENT_HEADER, operationContext.traceparent);
+                const contextPayload = buildOperationContext({
+                    requestId,
+                    method,
+                    path,
+                    operationContext,
+                    traceparent: readHeader(headers, TRACEPARENT_HEADER)
+                });
+                validateOperationContract(requestId, contextPayload);
+                if (void 0 === readHeader(headers, _types__rspack_import_4.BFF_OPERATION_CONTEXT_HEADER)) writeHeader(headers, _types__rspack_import_4.BFF_OPERATION_CONTEXT_HEADER, contextPayload.operationId);
+                writeHeader(headers, OPERATION_CONTEXT_DETAIL_HEADER, JSON.stringify(contextPayload));
+            }
+            return (0, _transport__rspack_import_3.executeWithResilience)({
+                requestId,
+                target: 'browser',
+                method,
+                url: finalURL,
+                init: {
+                    method,
+                    body,
+                    headers
+                },
+                fetcher,
+                transport: realTransportResilience.get(requestId)
+            });
+        };
+        return sender;
+    };
+    const createUploader = ({ path, domain, requestId = 'default' })=>{
+        const getFinalPath = (0, path_to_regexp__rspack_import_0.compile)(path, {
+            encode: encodeURIComponent
+        });
+        const sender = (...args)=>{
+            const fetcher = getConfiguredRequest(requestId, originFetch);
+            const { body, headers, params } = (0, _utiles__rspack_import_5.getUploadPayload)(args);
+            const finalPath = getFinalPath(params);
+            const configDomain = domainMap.get(requestId);
+            const finalURL = `${configDomain || domain || ''}${finalPath}`;
+            return fetcher(finalURL, {
+                method: 'POST',
+                body,
+                headers
+            });
+        };
+        return sender;
+    };
+})();
+exports.CrossOriginEnvelopePolicyError = __webpack_exports__.CrossOriginEnvelopePolicyError;
+exports.IdentityBindingViolationError = __webpack_exports__.IdentityBindingViolationError;
+exports.OperationContractViolationError = __webpack_exports__.OperationContractViolationError;
+exports.ProducerClientNotInitializedError = __webpack_exports__.ProducerClientNotInitializedError;
+exports.ProducerDomainNotConfiguredError = __webpack_exports__.ProducerDomainNotConfiguredError;
+exports.configure = __webpack_exports__.configure;
+exports.createRequest = __webpack_exports__.createRequest;
+exports.createUploader = __webpack_exports__.createUploader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CrossOriginEnvelopePolicyError",
+    "IdentityBindingViolationError",
+    "OperationContractViolationError",
+    "ProducerClientNotInitializedError",
+    "ProducerDomainNotConfiguredError",
+    "configure",
+    "createRequest",
+    "createUploader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/handleRes.js

@@ -0,0 +1,49 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    handleRes: ()=>handleRes
+});
+const handleRes = async (res)=>{
+    const contentType = res.headers.get('content-type');
+    if (!res.ok) {
+        const data = await res.json();
+        res.data = data;
+        throw res;
+    }
+    if (contentType?.includes('application/json') || contentType?.includes('text/json')) return res.json();
+    if (contentType?.includes('text/html') || contentType?.includes('text/plain')) return res.text();
+    if ((contentType?.includes('application/x-www-form-urlencoded') || contentType?.includes('multipart/form-data')) && res instanceof Response) return res.formData();
+    if (contentType?.includes('application/octet-stream')) return res.arrayBuffer();
+    if (contentType?.includes('image/png')) return res;
+    return res.text();
+};
+exports.handleRes = __webpack_exports__.handleRes;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "handleRes"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});