@bleedingdev/modern-js-plugin-bff 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/cli.js

@@ -0,0 +1 @@
+module.exports = require('./dist/cjs/cli');

package/dist/cjs/cli.js

@@ -0,0 +1,294 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    bffPlugin: ()=>bffPlugin,
+    default: ()=>cli
+});
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+const server_utils_namespaceObject = require("@modern-js/server-utils");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const clientGenerator_js_namespaceObject = require("./utils/clientGenerator.js");
+var clientGenerator_js_default = /*#__PURE__*/ __webpack_require__.n(clientGenerator_js_namespaceObject);
+const pluginGenerator_js_namespaceObject = require("./utils/pluginGenerator.js");
+var pluginGenerator_js_default = /*#__PURE__*/ __webpack_require__.n(pluginGenerator_js_namespaceObject);
+const runtimeGenerator_js_namespaceObject = require("./utils/runtimeGenerator.js");
+var runtimeGenerator_js_default = /*#__PURE__*/ __webpack_require__.n(runtimeGenerator_js_namespaceObject);
+const RUNTIME_CREATE_REQUEST = '@modern-js/plugin-bff/client';
+const WATCHABLE_EXTENSIONS = [
+    '.ts',
+    '.tsx',
+    '.js',
+    '.jsx',
+    '.mts',
+    '.cts',
+    '.mjs',
+    '.cjs',
+    '.json'
+];
+const isWatchableBffFile = (filename)=>WATCHABLE_EXTENSIONS.some((ext)=>filename.endsWith(ext));
+const normalizePrefixList = (prefix)=>{
+    if (Array.isArray(prefix)) return prefix.filter(Boolean);
+    return [
+        prefix || utils_namespaceObject.DEFAULT_API_PREFIX
+    ];
+};
+const getPrimaryPrefix = (prefix)=>normalizePrefixList(prefix)[0] || utils_namespaceObject.DEFAULT_API_PREFIX;
+const bffPlugin = ()=>({
+        name: '@modern-js/plugin-bff',
+        setup: (api)=>{
+            {
+                const appContext = api.getAppContext();
+                const userRuntimeFramework = api.getConfig()?.bff?.runtimeFramework;
+                api.updateAppContext({
+                    ...appContext,
+                    bffRuntimeFramework: 'hono' === userRuntimeFramework ? 'hono' : 'effect'
+                });
+            }
+            const compileApi = async ()=>{
+                const { appDirectory, distDirectory, apiDirectory, sharedDirectory, moduleType } = api.getAppContext();
+                const modernConfig = api.getNormalizedConfig();
+                const distDir = external_path_default().resolve(distDirectory);
+                const apiDir = apiDirectory || external_path_default().resolve(appDirectory, utils_namespaceObject.API_DIR);
+                const sharedDir = sharedDirectory || external_path_default().resolve(appDirectory, utils_namespaceObject.SHARED_DIR);
+                const tsconfigPath = (0, utils_namespaceObject.resolveServerTsconfig)(appDirectory, modernConfig?.server?.tsconfigPath);
+                const sourceDirs = [];
+                if (await utils_namespaceObject.fs.pathExists(apiDir)) sourceDirs.push(apiDir);
+                if (await utils_namespaceObject.fs.pathExists(sharedDir)) sourceDirs.push(sharedDir);
+                const { alias } = modernConfig.source;
+                const { alias: resolveAlias } = modernConfig.resolve;
+                if (sourceDirs.length > 0) {
+                    const combinedAlias = [].concat(alias ?? []).concat(resolveAlias ?? []);
+                    await (0, server_utils_namespaceObject.compile)(appDirectory, {
+                        alias: combinedAlias
+                    }, {
+                        sourceDirs,
+                        distDir,
+                        tsconfigPath,
+                        moduleType,
+                        throwErrorInsteadOfExit: true
+                    });
+                }
+            };
+            const generator = async ()=>{
+                const { appDirectory, apiDirectory, lambdaDirectory, port, bffRuntimeFramework } = api.getAppContext();
+                const modernConfig = api.getNormalizedConfig();
+                const relativeDistPath = modernConfig?.output?.distPath?.root || 'dist';
+                const { bff } = modernConfig || {};
+                const prefix = getPrimaryPrefix(bff?.prefix);
+                const httpMethodDecider = bff?.httpMethodDecider;
+                const apiRouter = new bff_core_namespaceObject.ApiRouter({
+                    apiDir: apiDirectory,
+                    appDir: appDirectory,
+                    lambdaDir: lambdaDirectory,
+                    prefix,
+                    httpMethodDecider,
+                    isBuild: true
+                });
+                const lambdaDir = apiRouter.getLambdaDir();
+                const existLambda = apiRouter.isExistLambda();
+                const runtime = bff?.runtimeCreateRequest || RUNTIME_CREATE_REQUEST;
+                const relativeApiPath = external_path_default().relative(appDirectory, apiDirectory);
+                const relativeLambdaPath = external_path_default().relative(appDirectory, lambdaDir);
+                await pluginGenerator_js_default()({
+                    prefix,
+                    appDirectory,
+                    relativeDistPath,
+                    relativeApiPath,
+                    relativeLambdaPath,
+                    runtimeFramework: 'hono' === bffRuntimeFramework ? 'hono' : 'effect'
+                });
+                await clientGenerator_js_default()({
+                    prefix,
+                    appDir: appDirectory,
+                    apiDir: apiDirectory,
+                    lambdaDir,
+                    existLambda,
+                    port,
+                    requestCreator: bff?.requestCreator,
+                    httpMethodDecider,
+                    relativeDistPath,
+                    relativeApiPath,
+                    bffRuntimeFramework,
+                    effectEntry: bff?.effect?.entry,
+                    effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
+                });
+                await runtimeGenerator_js_default()({
+                    runtime,
+                    appDirectory,
+                    relativeDistPath
+                });
+            };
+            const handleCrossProjectInvocation = async (isBuild = false)=>{
+                const { bff } = api.getNormalizedConfig();
+                if (bff?.crossProject) {
+                    if (!isBuild) await compileApi();
+                    await generator();
+                }
+            };
+            const isHono = ()=>{
+                const { bffRuntimeFramework } = api.getAppContext();
+                return 'hono' === bffRuntimeFramework;
+            };
+            const createCompressConfig = (devServer, prefix)=>{
+                if (!devServer || 'object' != typeof devServer || Array.isArray(devServer)) return;
+                const { compress } = devServer;
+                if (void 0 === compress || true === compress) {
+                    const prefixes = normalizePrefixList(prefix);
+                    return {
+                        filter: (req)=>!prefixes.some((item)=>req.url?.includes(item))
+                    };
+                }
+                if (false === compress) return false;
+                return compress;
+            };
+            api.config(async ()=>{
+                const devServer = api.getConfig()?.tools?.devServer;
+                const prefix = api.getConfig()?.bff?.prefix || utils_namespaceObject.DEFAULT_API_PREFIX;
+                const compress = createCompressConfig(devServer, prefix);
+                return {
+                    tools: {
+                        devServer: {
+                            compress
+                        },
+                        bundlerChain: (chain, { CHAIN_ID, isServer })=>{
+                            const { port, appDirectory, apiDirectory, lambdaDirectory, bffRuntimeFramework } = api.getAppContext();
+                            const modernConfig = api.getNormalizedConfig();
+                            const { bff } = modernConfig || {};
+                            const prefix = getPrimaryPrefix(bff?.prefix);
+                            const httpMethodDecider = bff?.httpMethodDecider;
+                            const apiRouter = new bff_core_namespaceObject.ApiRouter({
+                                apiDir: apiDirectory,
+                                appDir: appDirectory,
+                                lambdaDir: lambdaDirectory,
+                                prefix,
+                                httpMethodDecider,
+                                isBuild: true
+                            });
+                            const lambdaDir = apiRouter.getLambdaDir();
+                            const existLambda = apiRouter.isExistLambda();
+                            const apiRegexp = new RegExp((0, utils_namespaceObject.normalizeOutputPath)(`${apiDirectory}${external_path_default().sep}.*(.[tj]s)$`));
+                            const name = isServer ? 'server' : 'client';
+                            const sourceExt = 'js';
+                            const loaderPath = external_path_default().join(__dirname, `loader.${sourceExt}`);
+                            chain.module.rule(CHAIN_ID.RULE.JS).exclude.add(apiRegexp);
+                            chain.module.rule('js-bff-api').test(apiRegexp).use('custom-loader').loader(loaderPath.replace(/\\/g, '/')).options({
+                                prefix,
+                                appDir: appDirectory,
+                                apiDir: apiDirectory,
+                                lambdaDir,
+                                existLambda,
+                                port,
+                                target: name,
+                                requestCreator: bff?.requestCreator,
+                                httpMethodDecider,
+                                bffRuntimeFramework,
+                                effectEntry: bff?.effect?.entry,
+                                effectDataPlatformBatch: bff?.effect?.dataPlatform?.batch
+                            });
+                        }
+                    }
+                };
+            });
+            api.modifyServerRoutes(({ routes })=>{
+                const modernConfig = api.getNormalizedConfig();
+                const { bff } = modernConfig || {};
+                const prefix = bff?.prefix || '/api';
+                const prefixList = [];
+                if (Array.isArray(prefix)) prefixList.push(...prefix);
+                else prefixList.push(prefix);
+                const apiServerRoutes = prefixList.map((pre)=>({
+                        urlPath: pre,
+                        isApi: true,
+                        entryPath: '',
+                        isSPA: false,
+                        isSSR: false
+                    }));
+                if (!isHono() && bff?.enableHandleWeb) return {
+                    routes: routes.map((route)=>({
+                            ...route,
+                            isApi: true
+                        })).concat(apiServerRoutes)
+                };
+                return {
+                    routes: routes.concat(apiServerRoutes)
+                };
+            });
+            api._internalServerPlugins(({ plugins })=>{
+                plugins.push({
+                    name: '@modern-js/plugin-bff/server-plugin'
+                });
+                return {
+                    plugins
+                };
+            });
+            api.onBeforeDev(async ()=>{
+                await handleCrossProjectInvocation();
+            });
+            api.onAfterBuild(async ()=>{
+                await compileApi();
+                await handleCrossProjectInvocation(true);
+            });
+            api.addWatchFiles(async ()=>{
+                const appContext = api.getAppContext();
+                const config = api.getNormalizedConfig();
+                if (config?.bff?.crossProject) return [
+                    appContext.apiDirectory,
+                    appContext.sharedDirectory
+                ].filter(Boolean);
+                return [];
+            });
+            api.onFileChanged(async (e)=>{
+                const { filename, eventType, isPrivate } = e;
+                const { appDirectory, apiDirectory, sharedDirectory } = api.getAppContext();
+                const relativeApiPath = external_path_default().relative(appDirectory, apiDirectory);
+                const relativeSharedPath = sharedDirectory ? external_path_default().relative(appDirectory, sharedDirectory) : '';
+                const isApiFile = filename.startsWith(`${relativeApiPath}/`);
+                const isSharedFile = relativeSharedPath ? filename.startsWith(`${relativeSharedPath}/`) : false;
+                if (!isPrivate && ('add' === eventType || 'change' === eventType || 'unlink' === eventType) && (isApiFile || isSharedFile) && isWatchableBffFile(filename)) await handleCrossProjectInvocation();
+            });
+        }
+    });
+const cli = bffPlugin;
+exports.bffPlugin = __webpack_exports__.bffPlugin;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "bffPlugin",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/constants.js

@@ -0,0 +1,48 @@
+"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__, {
+    API_APP_NAME: ()=>API_APP_NAME,
+    BUILD_FILES: ()=>BUILD_FILES
+});
+const API_APP_NAME = '_app';
+const BUILD_FILES = [
+    '**/*.[tj]sx?',
+    '!**/*.test.jsx?',
+    '!**/*.test.tsx?',
+    '!**/*.spec.jsx?',
+    '!**/*.spec.tsx?',
+    '!__tests__/*.tsx?',
+    '!__tests__/*.jsx?'
+];
+exports.API_APP_NAME = __webpack_exports__.API_APP_NAME;
+exports.BUILD_FILES = __webpack_exports__.BUILD_FILES;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "API_APP_NAME",
+    "BUILD_FILES"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __webpack_modules__ = {
+    "./constants" (module) {
+        module.exports = require("./constants.js");
+    }
+};
+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__);
+    var _constants__rspack_import_0 = __webpack_require__("./constants");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _constants__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_constants__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/loader.js

@@ -0,0 +1,106 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__, {
+    default: ()=>src_loader
+});
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+const utils_namespaceObject = require("@modern-js/utils");
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const effectClientGenerator_js_namespaceObject = require("./utils/effectClientGenerator.js");
+async function loader(source) {
+    this.cacheable();
+    const { resourcePath } = this;
+    delete require.cache[resourcePath];
+    const callback = this.async();
+    const draftOptions = this.getOptions();
+    const effectEntryFile = (0, effectClientGenerator_js_namespaceObject.resolveEffectEntryFile)({
+        appDir: draftOptions.appDir,
+        apiDir: draftOptions.apiDir,
+        effectEntry: draftOptions.effectEntry
+    });
+    if ('effect' === draftOptions.bffRuntimeFramework && effectEntryFile && external_path_default().resolve(effectEntryFile) === external_path_default().resolve(resourcePath)) {
+        const code = await (0, effectClientGenerator_js_namespaceObject.generateEffectClientCode)({
+            appDir: draftOptions.appDir,
+            apiDir: draftOptions.apiDir,
+            resourcePath,
+            prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+            port: Number(draftOptions.port),
+            target: draftOptions.target,
+            requestCreator: draftOptions.requestCreator,
+            httpMethodDecider: draftOptions.httpMethodDecider,
+            dataPlatformBatch: draftOptions.effectDataPlatformBatch
+        });
+        if (code) return void callback(void 0, code);
+        callback(void 0, `throw new Error('Failed to generate Effect client for ${resourcePath}')`);
+        return;
+    }
+    const warning = `The file ${resourcePath} is not allowed to be imported in src directory, only API definition files are allowed.`;
+    if (!draftOptions.existLambda) {
+        utils_namespaceObject.logger.warn(warning);
+        callback(null, `throw new Error('${warning}')`);
+        return;
+    }
+    const options = {
+        prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
+        appDir: draftOptions.appDir,
+        apiDir: draftOptions.apiDir,
+        lambdaDir: draftOptions.lambdaDir,
+        target: draftOptions.target,
+        port: Number(draftOptions.port),
+        source,
+        resourcePath,
+        httpMethodDecider: draftOptions.httpMethodDecider
+    };
+    const { lambdaDir } = draftOptions;
+    if (!resourcePath.startsWith(lambdaDir)) {
+        utils_namespaceObject.logger.warn(warning);
+        callback(null, `throw new Error('${warning}')`);
+        return;
+    }
+    if (draftOptions.fetcher) options.fetcher = draftOptions.fetcher;
+    if (draftOptions.requestCreator) options.requestCreator = draftOptions.requestCreator;
+    options.requireResolve = require.resolve;
+    const result = await (0, bff_core_namespaceObject.generateClient)(options);
+    callback(void 0, result.isOk ? result.value : `throw new Error('${result.value}')`);
+}
+const src_loader = loader;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/create-request/index.js

@@ -0,0 +1,48 @@
+"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__, {
+    configure: ()=>create_request_namespaceObject.configure,
+    createRequest: ()=>create_request_namespaceObject.createRequest,
+    createRequestContextHeaders: ()=>create_request_namespaceObject.createRequestContextHeaders,
+    createRequestContextSnapshot: ()=>create_request_namespaceObject.createRequestContextSnapshot,
+    createUploader: ()=>create_request_namespaceObject.createUploader
+});
+const create_request_namespaceObject = require("@modern-js/create-request");
+exports.configure = __webpack_exports__.configure;
+exports.createRequest = __webpack_exports__.createRequest;
+exports.createRequestContextHeaders = __webpack_exports__.createRequestContextHeaders;
+exports.createRequestContextSnapshot = __webpack_exports__.createRequestContextSnapshot;
+exports.createUploader = __webpack_exports__.createUploader;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "configure",
+    "createRequest",
+    "createRequestContextHeaders",
+    "createRequestContextSnapshot",
+    "createUploader"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});