@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.30 → 3.5.0-ultramodern.32

package/dist/cjs/utils/clientGenerator.js

@@ -1,5 +1,19 @@
 "use strict";
-var __webpack_require__ = {};
+var __webpack_modules__ = {
+    "./client-generator" (module) {
+        module.exports = require("./client-generator/index.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;
@@ -35,311 +49,20 @@ var __webpack_require__ = {};
     };
 })();
 var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    copyFiles: ()=>copyFiles,
-    default: ()=>utils_clientGenerator,
-    readDirectoryFiles: ()=>readDirectoryFiles
-});
-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 external_effectClientGenerator_js_namespaceObject = require("./effectClientGenerator.js");
-const API_DIR = 'api';
-const PLUGIN_DIR = 'plugin';
-const RUNTIME_DIR = 'runtime';
-const CLIENT_DIR = 'client';
-const EXPORT_PREFIX = `./${API_DIR}/`;
-const TYPE_PREFIX = `${API_DIR}/`;
-const GENERATED_RUNTIME_DIRS = [
-    CLIENT_DIR,
-    PLUGIN_DIR,
-    RUNTIME_DIR
-];
-const toPosixPath = (p)=>p.replace(/\\/g, '/');
-const posixJoin = (...args)=>toPosixPath(external_path_default().join(...args));
-function getPackageName(appDirectory) {
-    try {
-        const packageJsonPath = external_path_default().resolve(appDirectory, './package.json');
-        const packageJson = utils_namespaceObject.fs.readJSONSync(packageJsonPath);
-        return packageJson.name;
-    } catch  {
-        return;
-    }
-}
-function createFileDetails(options) {
-    const { appDirectory, baseDirectory, resourcePath, source, relativeDistPath } = options;
-    const relativePath = external_path_default().relative(baseDirectory, resourcePath);
-    const parsedPath = external_path_default().parse(relativePath);
-    const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
-    const absTargetDir = external_path_default().resolve(targetDir);
-    const relativePathFromAppDirectory = external_path_default().relative(appDirectory, external_path_default().dirname(resourcePath));
-    const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${parsedPath.name}.d.ts`);
-    return {
-        resourcePath,
-        source,
-        targetDir,
-        name: parsedPath.name,
-        absTargetDir,
-        relativeTargetDistDir: `./${typesFilePath}`,
-        exportKey: toPosixPath(external_path_default().join(parsedPath.dir, parsedPath.name))
-    };
-}
-async function readDirectoryFiles(appDirectory, directory, relativeDistPath) {
-    const filesList = [];
-    async function readFiles(currentPath) {
-        const entries = await utils_namespaceObject.fs.readdir(currentPath, {
-            withFileTypes: true
-        });
-        for (const entry of entries){
-            if ('_app.ts' === entry.name) continue;
-            const resourcePath = external_path_default().join(currentPath, entry.name);
-            if (entry.isDirectory()) await readFiles(resourcePath);
-            else {
-                const source = await utils_namespaceObject.fs.readFile(resourcePath, 'utf8');
-                filesList.push(createFileDetails({
-                    appDirectory,
-                    baseDirectory: directory,
-                    resourcePath,
-                    source,
-                    relativeDistPath
-                }));
-            }
-        }
-    }
-    await readFiles(directory);
-    return filesList;
-}
-function mergePackageJson(packageJson, files, typesVersion, exports1, relativeDistPath) {
-    const distPrefix = toPosixPath(`./${relativeDistPath}/`);
-    const generatedPrefixes = GENERATED_RUNTIME_DIRS.map((dir)=>toPosixPath(`${distPrefix}${dir}/`));
-    const isManagedExportEntry = (value)=>{
-        if (!value) return false;
-        const values = [
-            value.import,
-            value.require,
-            value.types
-        ].filter(Boolean);
-        return values.every((entry)=>generatedPrefixes.some((prefix)=>entry.startsWith(prefix)));
-    };
-    const isManagedTypeEntry = (value)=>Array.isArray(value) && value.length > 0 && value.every((entry)=>generatedPrefixes.some((prefix)=>entry.startsWith(prefix)));
-    const normalizedFiles = [
-        ...new Set(files.map((file)=>toPosixPath(file)))
-    ];
-    const currentFiles = packageJson.files || [];
-    packageJson.files = [
-        ...new Set([
-            ...currentFiles.map((file)=>toPosixPath(file)),
-            ...normalizedFiles
-        ])
-    ];
-    packageJson.typesVersions ??= {};
-    const typesVersions = packageJson.typesVersions;
-    const starTypes = typesVersions['*'] || {};
-    const generatedTypeEntries = typesVersion['*'] || {};
-    const generatedTypeKeys = new Set(Object.keys(generatedTypeEntries));
-    const typeConflicts = Object.entries(starTypes).filter(([key, value])=>{
-        if (!generatedTypeKeys.has(key) && !key.startsWith(TYPE_PREFIX)) return false;
-        const generatedValue = generatedTypeEntries[key];
-        if (generatedValue) return JSON.stringify(value) !== JSON.stringify(generatedValue) && !isManagedTypeEntry(value);
-        return !isManagedTypeEntry(value);
-    }).map(([key])=>key);
-    if (typeConflicts.length > 0) throw new Error(`[plugin-bff] package.json typesVersions conflict on keys: ${typeConflicts.sort().join(', ')}. Rename these keys or move them outside "${TYPE_PREFIX}" namespace.`);
-    Object.keys(starTypes).forEach((key)=>{
-        if (generatedTypeKeys.has(key) || key.startsWith(TYPE_PREFIX)) delete starTypes[key];
-    });
-    typesVersions['*'] = {
-        ...starTypes,
-        ...generatedTypeEntries
-    };
-    packageJson.exports ??= {};
-    const packageExports = packageJson.exports;
-    const generatedExportKeys = new Set(Object.keys(exports1));
-    const exportConflicts = Object.entries(packageExports).filter(([key, value])=>{
-        if (!generatedExportKeys.has(key) && !key.startsWith(EXPORT_PREFIX)) return false;
-        const generatedValue = exports1[key];
-        if (generatedValue) return JSON.stringify(value) !== JSON.stringify(generatedValue) && !isManagedExportEntry(value);
-        return !isManagedExportEntry(value);
-    }).map(([key])=>key);
-    if (exportConflicts.length > 0) throw new Error(`[plugin-bff] package.json exports conflict on keys: ${exportConflicts.sort().join(', ')}. Rename these exports or move them outside "${EXPORT_PREFIX}" namespace.`);
-    Object.keys(packageExports).forEach((key)=>{
-        if (generatedExportKeys.has(key) || key.startsWith(EXPORT_PREFIX)) delete packageExports[key];
-    });
-    Object.assign(packageExports, exports1);
-}
-async function writeTargetFile(absTargetDir, content) {
-    await utils_namespaceObject.fs.mkdir(external_path_default().dirname(absTargetDir), {
-        recursive: true
-    });
-    await utils_namespaceObject.fs.writeFile(absTargetDir, content);
-}
-function getClientPackageName(appDirectory) {
-    const packageName = getPackageName(appDirectory) || external_path_default().basename(appDirectory);
-    if (packageName.startsWith('@') && packageName.includes('/')) {
-        const [scope, name] = packageName.split('/');
-        return `${scope}/${name}-bff-client`;
-    }
-    return `${packageName}-bff-client`;
-}
-async function writeClientModuleBoundary(appDirectory, relativeDistPath) {
-    await writeTargetFile(external_path_default().resolve(appDirectory, relativeDistPath, CLIENT_DIR, 'package.json'), `${JSON.stringify({
-        private: true,
-        name: getClientPackageName(appDirectory),
-        type: 'module'
-    }, null, 2)}\n`);
-}
-async function setPackage(files, appDirectory, relativeDistPath) {
-    const packagePath = external_path_default().resolve(appDirectory, './package.json');
-    const packageContent = await utils_namespaceObject.fs.readFile(packagePath, 'utf8');
-    const packageJson = JSON.parse(packageContent);
-    const sortedFiles = [
-        ...files
-    ].sort((a, b)=>a.exportKey.localeCompare(b.exportKey));
-    const addFiles = [
-        posixJoin(relativeDistPath, CLIENT_DIR, '**', '*'),
-        posixJoin(relativeDistPath, RUNTIME_DIR, '**', '*'),
-        posixJoin(relativeDistPath, PLUGIN_DIR, '**', '*')
-    ];
-    const typesVersions = {
-        '*': sortedFiles.reduce((acc, file)=>{
-            const typeFilePath = toPosixPath(`./${file.targetDir}`).replace(/\.js$/, '.d.ts');
-            return {
-                ...acc,
-                [toPosixPath(`${TYPE_PREFIX}${file.exportKey}`)]: [
-                    typeFilePath
-                ]
-            };
-        }, {
-            [`${API_DIR}/*`]: [
-                toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.d.ts`)
-            ],
-            [RUNTIME_DIR]: [
-                toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.d.ts`)
-            ],
-            [PLUGIN_DIR]: [
-                toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.d.ts`)
-            ]
-        })
-    };
-    const exports1 = sortedFiles.reduce((acc, file)=>{
-        const exportKey = `${EXPORT_PREFIX}${file.exportKey}`;
-        const jsFilePath = toPosixPath(`./${file.targetDir}`);
-        return {
-            ...acc,
-            [toPosixPath(exportKey)]: {
-                import: jsFilePath,
-                types: toPosixPath(jsFilePath.replace(/\.js$/, '.d.ts'))
-            }
-        };
-    }, {
-        [toPosixPath(`./${API_DIR}/*`)]: {
-            import: toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.js`),
-            types: toPosixPath(`./${relativeDistPath}/${CLIENT_DIR}/*.d.ts`)
-        },
-        [toPosixPath(`./${PLUGIN_DIR}`)]: {
-            import: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.js`),
-            require: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.js`),
-            types: toPosixPath(`./${relativeDistPath}/${PLUGIN_DIR}/index.d.ts`)
-        },
-        [toPosixPath(`./${RUNTIME_DIR}`)]: {
-            import: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.js`),
-            require: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.js`),
-            types: toPosixPath(`./${relativeDistPath}/${RUNTIME_DIR}/index.d.ts`)
-        }
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    var _client_generator__rspack_import_0 = __webpack_require__("./client-generator");
+    var _client_generator__rspack_import_0_default = /*#__PURE__*/ __webpack_require__.n(_client_generator__rspack_import_0);
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _client_generator__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_client_generator__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    __webpack_require__.d(__webpack_exports__, {
+        default: ()=>_client_generator__rspack_import_0_default.a
     });
-    mergePackageJson(packageJson, addFiles, typesVersions, exports1, relativeDistPath);
-    await utils_namespaceObject.fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
-}
-async function copyFiles(from, to) {
-    if (await utils_namespaceObject.fs.pathExists(from)) await utils_namespaceObject.fs.copy(toPosixPath(from), toPosixPath(to));
-}
-async function clientGenerator(draftOptions) {
-    const generatedClientDir = external_path_default().resolve(draftOptions.appDir, draftOptions.relativeDistPath, CLIENT_DIR);
-    await utils_namespaceObject.fs.remove(generatedClientDir);
-    const requestId = getPackageName(draftOptions.appDir) || process.env.npm_package_name;
-    const lambdaSourceList = draftOptions.existLambda ? await readDirectoryFiles(draftOptions.appDir, draftOptions.lambdaDir, draftOptions.relativeDistPath) : [];
-    const generatedSourceList = [
-        ...lambdaSourceList
-    ];
-    const getClitentCode = async (resourcePath, source)=>{
-        const warning = `The file ${resourcePath} is not allowed to be imported in src directory, only API definition files are allowed.`;
-        if (!draftOptions.existLambda) return void utils_namespaceObject.logger.warn(warning);
-        const options = {
-            prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
-            appDir: draftOptions.appDir,
-            apiDir: draftOptions.apiDir,
-            lambdaDir: draftOptions.lambdaDir,
-            port: Number(draftOptions.port),
-            source,
-            resourcePath,
-            target: 'bundle',
-            httpMethodDecider: draftOptions.httpMethodDecider,
-            requestCreator: draftOptions.requestCreator,
-            requestId
-        };
-        const { lambdaDir } = draftOptions;
-        if (!resourcePath.startsWith(lambdaDir)) return void utils_namespaceObject.logger.warn(warning);
-        const result = await (0, bff_core_namespaceObject.generateClient)(options);
-        return result;
-    };
-    try {
-        for (const source of lambdaSourceList){
-            const code = await getClitentCode(source.resourcePath, source.source);
-            if (code?.value) {
-                await writeTargetFile(source.absTargetDir, code.value);
-                await copyFiles(source.relativeTargetDistDir, source.targetDir.replace("js", 'd.ts'));
-            }
-        }
-        if ('effect' === draftOptions.bffRuntimeFramework) {
-            const effectEntryFile = (0, external_effectClientGenerator_js_namespaceObject.resolveEffectEntryFile)({
-                appDir: draftOptions.appDir,
-                apiDir: draftOptions.apiDir,
-                effectEntry: draftOptions.effectEntry
-            });
-            if (effectEntryFile) {
-                const effectSource = await utils_namespaceObject.fs.readFile(effectEntryFile, 'utf8');
-                const effectFileDetails = createFileDetails({
-                    appDirectory: draftOptions.appDir,
-                    baseDirectory: draftOptions.apiDir,
-                    resourcePath: effectEntryFile,
-                    source: effectSource,
-                    relativeDistPath: draftOptions.relativeDistPath
-                });
-                const effectClientArtifacts = await (0, external_effectClientGenerator_js_namespaceObject.generateEffectClient)({
-                    appDir: draftOptions.appDir,
-                    apiDir: draftOptions.apiDir,
-                    resourcePath: effectEntryFile,
-                    prefix: Array.isArray(draftOptions.prefix) ? draftOptions.prefix[0] : draftOptions.prefix,
-                    port: Number(draftOptions.port),
-                    target: 'bundle',
-                    requestCreator: draftOptions.requestCreator,
-                    httpMethodDecider: draftOptions.httpMethodDecider,
-                    dataPlatformBatch: draftOptions.effectDataPlatformBatch
-                });
-                if (effectClientArtifacts) {
-                    const targetTypeFile = effectFileDetails.targetDir.replace(/\.js$/, '.d.ts');
-                    await writeTargetFile(effectFileDetails.absTargetDir, effectClientArtifacts.code);
-                    await writeTargetFile(external_path_default().resolve(targetTypeFile), effectClientArtifacts.declaration);
-                    generatedSourceList.push(effectFileDetails);
-                }
-            }
-        }
-        utils_namespaceObject.logger.info("Client bundle generate succeed");
-    } catch (error) {
-        utils_namespaceObject.logger.error(`Client bundle generate failed: ${error}`);
-    }
-    if (generatedSourceList.length > 0) await writeClientModuleBoundary(draftOptions.appDir, draftOptions.relativeDistPath);
-    await setPackage(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath);
-}
-const utils_clientGenerator = clientGenerator;
-exports.copyFiles = __webpack_exports__.copyFiles;
+})();
 exports["default"] = __webpack_exports__["default"];
-exports.readDirectoryFiles = __webpack_exports__.readDirectoryFiles;
 for(var __rspack_i in __webpack_exports__)if (-1 === [
-    "copyFiles",
-    "default",
-    "readDirectoryFiles"
+    "default"
 ].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true

package/dist/cjs/utils/effect-client-generator/generator.js

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    generateEffectClient: ()=>generateEffectClient,
+    generateEffectClientCode: ()=>generateEffectClientCode
+});
+const utils_namespaceObject = require("@modern-js/utils");
+const endpoint_contracts_js_namespaceObject = require("../../runtime/effect/endpoint-contracts.js");
+const external_rendering_js_namespaceObject = require("./rendering.js");
+const external_runtime_js_namespaceObject = require("./runtime.js");
+async function generateEffectClient(options) {
+    const api = await (0, external_runtime_js_namespaceObject.loadEffectApi)(options.resourcePath);
+    if (!api) {
+        utils_namespaceObject.logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
+        return null;
+    }
+    const httpApiRuntime = await (0, external_runtime_js_namespaceObject.getHttpApiRuntime)();
+    const endpoints = (0, endpoint_contracts_js_namespaceObject.collectEffectEndpoints)(httpApiRuntime.reflect, api, options.prefix);
+    return {
+        code: (0, external_rendering_js_namespaceObject.renderEffectClientCode)(endpoints, options),
+        declaration: (0, external_rendering_js_namespaceObject.renderEffectClientDeclaration)(endpoints),
+        endpoints
+    };
+}
+async function generateEffectClientCode(options) {
+    const artifacts = await generateEffectClient(options);
+    return artifacts ? artifacts.code : null;
+}
+exports.generateEffectClient = __webpack_exports__.generateEffectClient;
+exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateEffectClient",
+    "generateEffectClientCode"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/effect-client-generator/index.js

@@ -0,0 +1,51 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    generateEffectClient: ()=>external_generator_js_namespaceObject.generateEffectClient,
+    generateEffectClientCode: ()=>external_generator_js_namespaceObject.generateEffectClientCode,
+    renderEffectClientDeclaration: ()=>external_rendering_js_namespaceObject.renderEffectClientDeclaration,
+    resolveEffectEntryFile: ()=>external_paths_js_namespaceObject.resolveEffectEntryFile
+});
+const external_generator_js_namespaceObject = require("./generator.js");
+const external_paths_js_namespaceObject = require("./paths.js");
+const external_rendering_js_namespaceObject = require("./rendering.js");
+exports.generateEffectClient = __webpack_exports__.generateEffectClient;
+exports.generateEffectClientCode = __webpack_exports__.generateEffectClientCode;
+exports.renderEffectClientDeclaration = __webpack_exports__.renderEffectClientDeclaration;
+exports.resolveEffectEntryFile = __webpack_exports__.resolveEffectEntryFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "generateEffectClient",
+    "generateEffectClientCode",
+    "renderEffectClientDeclaration",
+    "resolveEffectEntryFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils/effect-client-generator/paths.js

@@ -0,0 +1,73 @@
+"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, getters, values)=>{
+        var define = (defs, kind)=>{
+            for(var key in defs)if (__webpack_require__.o(defs, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+                enumerable: true,
+                [kind]: defs[key]
+            });
+        };
+        define(getters, "get");
+        define(values, "value");
+    };
+})();
+(()=>{
+    __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__, {
+    resolveEffectEntryFile: ()=>resolveEffectEntryFile
+});
+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 JS_OR_TS_EXTS = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.mjs',
+    '.mts',
+    '.cjs',
+    '.cts'
+];
+function resolveEffectEntryFile(options) {
+    const { appDir, apiDir, effectEntry } = options;
+    const resolveEntry = (entryWithoutExt)=>{
+        if (external_path_default().extname(entryWithoutExt)) return utils_namespaceObject.fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
+        return (0, utils_namespaceObject.findExists)(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
+    };
+    if (effectEntry) {
+        const entryWithoutExt = external_path_default().isAbsolute(effectEntry) ? effectEntry : external_path_default().resolve(appDir, effectEntry);
+        return resolveEntry(entryWithoutExt);
+    }
+    return resolveEntry(external_path_default().resolve(apiDir, 'index'));
+}
+exports.resolveEffectEntryFile = __webpack_exports__.resolveEffectEntryFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "resolveEffectEntryFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});