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

package/dist/cjs/node.js

@@ -0,0 +1,531 @@
+"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");
+    },
+    "@modern-js/runtime-utils/node" (module) {
+        module.exports = require("@modern-js/runtime-utils/node");
+    },
+    "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 _modern_js_runtime_utils_node__rspack_import_0 = __webpack_require__("@modern-js/runtime-utils/node");
+    var path_to_regexp__rspack_import_1 = __webpack_require__("path-to-regexp");
+    var qs__rspack_import_2 = __webpack_require__("qs");
+    var _handleRes__rspack_import_3 = __webpack_require__("./handleRes");
+    var _transport__rspack_import_4 = __webpack_require__("./transport");
+    var _types__rspack_import_5 = __webpack_require__("./types");
+    var _utiles__rspack_import_6 = __webpack_require__("./utiles");
+    var _requestContext__rspack_import_7 = __webpack_require__("./requestContext");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _requestContext__rspack_import_7)if ([
+        "IdentityBindingViolationError",
+        "configure",
+        "OperationContractViolationError",
+        "default",
+        "ProducerClientNotInitializedError",
+        "ProducerDomainNotConfiguredError",
+        "createUploader",
+        "CrossOriginEnvelopePolicyError",
+        "createRequest"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_requestContext__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_5)if ([
+        "IdentityBindingViolationError",
+        "configure",
+        "OperationContractViolationError",
+        "default",
+        "ProducerClientNotInitializedError",
+        "ProducerDomainNotConfiguredError",
+        "createUploader",
+        "CrossOriginEnvelopePolicyError",
+        "createRequest"
+    ].indexOf(__rspack_import_key) < 0) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_5[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    const realRequest = new Map();
+    const realAllowedHeaders = new Map();
+    const realResolveHeaders = 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_5.BFF_OPERATION_CONTEXT_DETAIL_HEADER;
+    const TRACEPARENT_REGEX = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/i;
+    const isStrictDefaultRequestIdEnabled = ()=>'true' === process.env.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 resolveSourceOrigin = (headers)=>{
+        const origin = toOrigin(firstHeaderValue(headers.origin));
+        if (origin) return origin;
+        const referer = toOrigin(firstHeaderValue(headers.referer));
+        if (referer) return referer;
+        const host = firstHeaderValue(headers.host);
+        if (!host) return;
+        const proto = firstHeaderValue(headers['x-forwarded-proto']) || 'http';
+        return `${proto}://${host}`;
+    };
+    const extractPathParamNames = (path)=>Array.from(path.matchAll(/:([A-Za-z0-9_]+)/g)).map(([, key])=>key);
+    const originFetch = (...params)=>{
+        const [, init] = params;
+        if (init?.method?.toLowerCase() === 'get') init.body = void 0;
+        return fetch(...params).then(_handleRes__rspack_import_3.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: 'server',
+                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, resolveHeaders, 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 ('function' == typeof resolveHeaders) realResolveHeaders.set(requestId, resolveHeaders);
+        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: 'server',
+                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, requestId = 'default', operationContext } = normalizeRequestOptions(...args);
+        const getFinalPath = (0, path_to_regexp__rspack_import_1.compile)(path, {
+            encode: encodeURIComponent
+        });
+        const keyNames = extractPathParamNames(path);
+        const sender = (...args)=>{
+            const fetcher = getConfiguredRequest(requestId, fetch1);
+            let webRequestHeaders = {};
+            try {
+                webRequestHeaders = _modern_js_runtime_utils_node__rspack_import_0.storage.useContext().headers || {};
+            } catch (error) {
+                webRequestHeaders = {};
+            }
+            let body;
+            let headers;
+            let url;
+            if ('inputParams' === httpMethodDecider) {
+                const configDomain = domainMap.get(requestId);
+                if ('default' !== requestId && isEmptyDomain(configDomain)) throw new ProducerDomainNotConfiguredError(requestId);
+                url = `${configDomain || `http://127.0.0.1:${port}`}${path}`;
+                body = 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 plainPath = getFinalPath(payload.params);
+                const finalPath = payload.query ? `${plainPath}?${(0, qs__rspack_import_2.stringify)(payload.query)}` : plainPath;
+                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_5.BFF_DEFAULT_PROTECTED_IDENTITY_HEADERS).map((header)=>header.toLowerCase());
+                const targetAllowedHeaders = realAllowedHeaders.get(requestId) || [];
+                const forwardedHeaders = {};
+                for (const key of targetAllowedHeaders)if (void 0 !== webRequestHeaders[key]) forwardedHeaders[key] = webRequestHeaders[key];
+                if (identityBindingEnabled) {
+                    const derivedIdentityHeaders = {};
+                    for (const header of protectedIdentityHeaders){
+                        const incomingHeaderValue = readHeader(webRequestHeaders, header);
+                        if (void 0 !== incomingHeaderValue) writeHeader(derivedIdentityHeaders, header, incomingHeaderValue);
+                    }
+                    const customDerivedHeaders = identityBinding?.deriveHeaders?.({
+                        requestId,
+                        target: 'server',
+                        incomingHeaders: {
+                            ...webRequestHeaders
+                        },
+                        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: 'server',
+                            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(forwardedHeaders, header, derivedIdentityHeaders[header]);
+                    });
+                }
+                const resolveHeaders = realResolveHeaders.get(requestId);
+                if (resolveHeaders) {
+                    const resolvedHeaders = resolveHeaders({
+                        requestId,
+                        allowedHeaders: targetAllowedHeaders,
+                        incomingHeaders: {
+                            ...forwardedHeaders
+                        }
+                    });
+                    if (resolvedHeaders && 'object' == typeof resolvedHeaders) {
+                        for (const key of targetAllowedHeaders)if (void 0 !== resolvedHeaders[key]) forwardedHeaders[key] = resolvedHeaders[key];
+                    }
+                }
+                headers = {
+                    ...headers,
+                    ...forwardedHeaders
+                };
+                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 ? (0, qs__rspack_import_2.stringify)(payload.formUrlencoded) : payload.formUrlencoded;
+                }
+                const configDomain = domainMap.get(requestId);
+                if ('default' !== requestId && isEmptyDomain(configDomain)) throw new ProducerDomainNotConfiguredError(requestId);
+                url = `${configDomain || `http://127.0.0.1:${port}`}${finalPath}`;
+            }
+            if (void 0 === readHeader(headers, TRACEPARENT_HEADER)) {
+                const incomingTraceparent = firstHeaderValue(readHeader(webRequestHeaders, TRACEPARENT_HEADER));
+                if ('string' == typeof incomingTraceparent) writeHeader(headers, TRACEPARENT_HEADER, incomingTraceparent);
+            }
+            if (void 0 === readHeader(headers, TRACEPARENT_HEADER) && operationContext?.traceparent) writeHeader(headers, TRACEPARENT_HEADER, operationContext.traceparent);
+            const shouldRequireEnvelope = realRequireEnvelope.get(requestId) ?? isSecuredRequestId(requestId);
+            if (shouldRequireEnvelope) {
+                const sourceOrigin = resolveSourceOrigin(webRequestHeaders);
+                const targetOrigin = toOrigin(url);
+                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: 'server'
+                    }) : true === policy;
+                    if (!isAllowed) throw new CrossOriginEnvelopePolicyError(requestId, sourceOrigin, targetOrigin);
+                }
+                headers[_types__rspack_import_5.BFF_ENVELOPE_HEADER] = JSON.stringify({
+                    requestId,
+                    target: 'server',
+                    timestamp: Date.now(),
+                    sourceOrigin,
+                    targetOrigin,
+                    ...traceContext ? {
+                        traceId: traceContext.traceId,
+                        spanId: traceContext.spanId
+                    } : {}
+                });
+            }
+            if (isSecuredRequestId(requestId)) {
+                const contextPayload = buildOperationContext({
+                    requestId,
+                    method,
+                    path,
+                    operationContext,
+                    traceparent: readHeader(headers, TRACEPARENT_HEADER)
+                });
+                validateOperationContract(requestId, contextPayload);
+                if (void 0 === readHeader(headers, _types__rspack_import_5.BFF_OPERATION_CONTEXT_HEADER)) writeHeader(headers, _types__rspack_import_5.BFF_OPERATION_CONTEXT_HEADER, contextPayload.operationId);
+                writeHeader(headers, OPERATION_CONTEXT_DETAIL_HEADER, JSON.stringify(contextPayload));
+            }
+            if ('get' === method.toLowerCase()) body = void 0;
+            headers.accept = "application/json,*/*;q=0.8";
+            return (0, _transport__rspack_import_4.executeWithResilience)({
+                requestId,
+                target: 'server',
+                method,
+                url,
+                init: {
+                    method,
+                    body,
+                    headers
+                },
+                fetcher,
+                transport: realTransportResilience.get(requestId)
+            });
+        };
+        return sender;
+    };
+    const createUploader = ({ path, requestId = 'default' })=>{
+        const sender = (...args)=>{
+            const fetcher = getConfiguredRequest(requestId, originFetch);
+            const { body, headers } = (0, _utiles__rspack_import_6.getUploadPayload)(args);
+            const configDomain = domainMap.get(requestId);
+            const finalURL = `${configDomain || ''}${path}`;
+            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/qs.js

@@ -0,0 +1,39 @@
+"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__, {
+    parse: ()=>external_qs_namespaceObject.parse,
+    stringify: ()=>external_qs_namespaceObject.stringify
+});
+const external_qs_namespaceObject = require("qs");
+exports.parse = __webpack_exports__.parse;
+exports.stringify = __webpack_exports__.stringify;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "parse",
+    "stringify"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/requestContext.js

@@ -0,0 +1,94 @@
+"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__, {
+    BFF_LOCALE_HEADER: ()=>BFF_LOCALE_HEADER,
+    BFF_TRACEPARENT_HEADER: ()=>BFF_TRACEPARENT_HEADER,
+    createRequestContextHeaders: ()=>createRequestContextHeaders,
+    createRequestContextSnapshot: ()=>createRequestContextSnapshot
+});
+const BFF_LOCALE_HEADER = 'accept-language';
+const BFF_TRACEPARENT_HEADER = 'traceparent';
+const TRACEPARENT_REGEX = /^00-([0-9a-f]{32})-([0-9a-f]{16})-[0-9a-f]{2}$/i;
+const readHeader = (headers, header)=>{
+    if (!headers) return;
+    const normalized = header.toLowerCase();
+    const key = Object.keys(headers).find((current)=>current.toLowerCase() === normalized);
+    if (!key) return;
+    const value = headers[key];
+    return Array.isArray(value) ? value[0] : value;
+};
+const readString = (value)=>'string' == typeof value && value.length > 0 ? value : void 0;
+function parseTraceparent(traceparent) {
+    if (!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()
+    };
+}
+function createRequestContextSnapshot(input = {}) {
+    const locale = readString(input.locale) || readString(readHeader(input.headers, BFF_LOCALE_HEADER));
+    const traceparent = readString(input.traceparent) || readString(input.operationContext?.traceparent) || readString(readHeader(input.headers, BFF_TRACEPARENT_HEADER));
+    const parsedTraceparent = input.operationContext?.traceId && input.operationContext?.spanId ? {
+        traceId: input.operationContext.traceId,
+        spanId: input.operationContext.spanId
+    } : parseTraceparent(traceparent);
+    const headers = {};
+    if (locale) headers[BFF_LOCALE_HEADER] = locale;
+    if (traceparent) headers[BFF_TRACEPARENT_HEADER] = traceparent;
+    return {
+        headers,
+        ...locale ? {
+            locale
+        } : {},
+        ...traceparent ? {
+            traceparent
+        } : {},
+        ...parsedTraceparent ? {
+            traceId: parsedTraceparent.traceId,
+            spanId: parsedTraceparent.spanId
+        } : {}
+    };
+}
+function createRequestContextHeaders(input = {}) {
+    return createRequestContextSnapshot(input).headers;
+}
+exports.BFF_LOCALE_HEADER = __webpack_exports__.BFF_LOCALE_HEADER;
+exports.BFF_TRACEPARENT_HEADER = __webpack_exports__.BFF_TRACEPARENT_HEADER;
+exports.createRequestContextHeaders = __webpack_exports__.createRequestContextHeaders;
+exports.createRequestContextSnapshot = __webpack_exports__.createRequestContextSnapshot;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "BFF_LOCALE_HEADER",
+    "BFF_TRACEPARENT_HEADER",
+    "createRequestContextHeaders",
+    "createRequestContextSnapshot"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});