@bleedingdev/modern-js-plugin-bff 3.5.0-ultramodern.3 → 3.5.0-ultramodern.31

package/dist/esm-node/utils/client-generator/package-json.mjs

@@ -0,0 +1,79 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path from "path";
+import { EXPORT_PREFIX, GENERATED_RUNTIME_DIRS, TYPE_PREFIX, toPosixPath } from "./files.mjs";
+function getPackageName(appDirectory) {
+    try {
+        const packageJsonPath = path.resolve(appDirectory, './package.json');
+        const packageJson = fs.readJSONSync(packageJsonPath);
+        return packageJson.name;
+    } catch  {
+        return;
+    }
+}
+function mergePackageJson(packageJson, files, typesVersion, exports, 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(exports));
+    const exportConflicts = Object.entries(packageExports).filter(([key, value])=>{
+        if (!generatedExportKeys.has(key) && !key.startsWith(EXPORT_PREFIX)) return false;
+        const generatedValue = exports[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, exports);
+}
+function getClientPackageName(appDirectory) {
+    const packageName = getPackageName(appDirectory) || path.basename(appDirectory);
+    if (packageName.startsWith('@') && packageName.includes('/')) {
+        const [scope, name] = packageName.split('/');
+        return `${scope}/${name}-bff-client`;
+    }
+    return `${packageName}-bff-client`;
+}
+export { getClientPackageName, getPackageName, mergePackageJson };

package/dist/esm-node/utils/client-generator/write-package.mjs

@@ -0,0 +1,75 @@
+import "node:module";
+import { fs } from "@modern-js/utils";
+import path from "path";
+import { API_DIR, CLIENT_DIR, EXPORT_PREFIX, PLUGIN_DIR, RUNTIME_DIR, TYPE_PREFIX, posixJoin, toPosixPath, writeTargetFile } from "./files.mjs";
+import { getClientPackageName, mergePackageJson } from "./package-json.mjs";
+async function writeClientModuleBoundary(appDirectory, relativeDistPath) {
+    await writeTargetFile(path.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 = path.resolve(appDirectory, './package.json');
+    const packageContent = await 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 exports = 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`)
+        }
+    });
+    mergePackageJson(packageJson, addFiles, typesVersions, exports, relativeDistPath);
+    await fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
+}
+export { setPackage, writeClientModuleBoundary };

package/dist/esm-node/utils/clientGenerator.mjs

@@ -1,294 +1,3 @@
 import "node:module";
-import { generateClient } from "@modern-js/bff-core";
-import { fs, logger } from "@modern-js/utils";
-import path from "path";
-import { generateEffectClient, resolveEffectEntryFile } from "./effectClientGenerator.mjs";
-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(path.join(...args));
-function getPackageName(appDirectory) {
-    try {
-        const packageJsonPath = path.resolve(appDirectory, './package.json');
-        const packageJson = fs.readJSONSync(packageJsonPath);
-        return packageJson.name;
-    } catch  {
-        return;
-    }
-}
-function createFileDetails(options) {
-    const { appDirectory, baseDirectory, resourcePath, source, relativeDistPath } = options;
-    const relativePath = path.relative(baseDirectory, resourcePath);
-    const parsedPath = path.parse(relativePath);
-    const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
-    const absTargetDir = path.resolve(targetDir);
-    const relativePathFromAppDirectory = path.relative(appDirectory, path.dirname(resourcePath));
-    const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${parsedPath.name}.d.ts`);
-    return {
-        resourcePath,
-        source,
-        targetDir,
-        name: parsedPath.name,
-        absTargetDir,
-        relativeTargetDistDir: `./${typesFilePath}`,
-        exportKey: toPosixPath(path.join(parsedPath.dir, parsedPath.name))
-    };
-}
-async function readDirectoryFiles(appDirectory, directory, relativeDistPath) {
-    const filesList = [];
-    async function readFiles(currentPath) {
-        const entries = await fs.readdir(currentPath, {
-            withFileTypes: true
-        });
-        for (const entry of entries){
-            if ('_app.ts' === entry.name) continue;
-            const resourcePath = path.join(currentPath, entry.name);
-            if (entry.isDirectory()) await readFiles(resourcePath);
-            else {
-                const source = await fs.readFile(resourcePath, 'utf8');
-                filesList.push(createFileDetails({
-                    appDirectory,
-                    baseDirectory: directory,
-                    resourcePath,
-                    source,
-                    relativeDistPath
-                }));
-            }
-        }
-    }
-    await readFiles(directory);
-    return filesList;
-}
-function mergePackageJson(packageJson, files, typesVersion, exports, 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(exports));
-    const exportConflicts = Object.entries(packageExports).filter(([key, value])=>{
-        if (!generatedExportKeys.has(key) && !key.startsWith(EXPORT_PREFIX)) return false;
-        const generatedValue = exports[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, exports);
-}
-async function writeTargetFile(absTargetDir, content) {
-    await fs.mkdir(path.dirname(absTargetDir), {
-        recursive: true
-    });
-    await fs.writeFile(absTargetDir, content);
-}
-function getClientPackageName(appDirectory) {
-    const packageName = getPackageName(appDirectory) || path.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(path.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 = path.resolve(appDirectory, './package.json');
-    const packageContent = await 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 exports = 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`)
-        }
-    });
-    mergePackageJson(packageJson, addFiles, typesVersions, exports, relativeDistPath);
-    await fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
-}
-async function copyFiles(from, to) {
-    if (await fs.pathExists(from)) await fs.copy(toPosixPath(from), toPosixPath(to));
-}
-async function clientGenerator(draftOptions) {
-    const generatedClientDir = path.resolve(draftOptions.appDir, draftOptions.relativeDistPath, CLIENT_DIR);
-    await 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 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 logger.warn(warning);
-        const result = await 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 = resolveEffectEntryFile({
-                appDir: draftOptions.appDir,
-                apiDir: draftOptions.apiDir,
-                effectEntry: draftOptions.effectEntry
-            });
-            if (effectEntryFile) {
-                const effectSource = await fs.readFile(effectEntryFile, 'utf8');
-                const effectFileDetails = createFileDetails({
-                    appDirectory: draftOptions.appDir,
-                    baseDirectory: draftOptions.apiDir,
-                    resourcePath: effectEntryFile,
-                    source: effectSource,
-                    relativeDistPath: draftOptions.relativeDistPath
-                });
-                const effectClientArtifacts = await 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(path.resolve(targetTypeFile), effectClientArtifacts.declaration);
-                    generatedSourceList.push(effectFileDetails);
-                }
-            }
-        }
-        logger.info("Client bundle generate succeed");
-    } catch (error) {
-        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;
-export default utils_clientGenerator;
-export { copyFiles, readDirectoryFiles };
+export * from "./client-generator/index.mjs";
+export { default } from "./client-generator/index.mjs";

package/dist/esm-node/utils/effect-client-generator/generator.mjs

@@ -0,0 +1,24 @@
+import "node:module";
+import { logger } from "@modern-js/utils";
+import { collectEffectEndpoints } from "../../runtime/effect/endpoint-contracts.mjs";
+import { renderEffectClientCode, renderEffectClientDeclaration } from "./rendering.mjs";
+import { getHttpApiRuntime, loadEffectApi } from "./runtime.mjs";
+async function generateEffectClient(options) {
+    const api = await loadEffectApi(options.resourcePath);
+    if (!api) {
+        logger.warn(`[BFF][Effect] Failed to generate client for ${options.resourcePath}: unable to resolve exported HttpApi.`);
+        return null;
+    }
+    const httpApiRuntime = await getHttpApiRuntime();
+    const endpoints = collectEffectEndpoints(httpApiRuntime.reflect, api, options.prefix);
+    return {
+        code: renderEffectClientCode(endpoints, options),
+        declaration: renderEffectClientDeclaration(endpoints),
+        endpoints
+    };
+}
+async function generateEffectClientCode(options) {
+    const artifacts = await generateEffectClient(options);
+    return artifacts ? artifacts.code : null;
+}
+export { generateEffectClient, generateEffectClientCode };

package/dist/esm-node/utils/effect-client-generator/index.mjs

@@ -0,0 +1,4 @@
+import "node:module";
+export { generateEffectClient, generateEffectClientCode } from "./generator.mjs";
+export { resolveEffectEntryFile } from "./paths.mjs";
+export { renderEffectClientDeclaration } from "./rendering.mjs";

package/dist/esm-node/utils/effect-client-generator/paths.mjs

@@ -0,0 +1,26 @@
+import "node:module";
+import { findExists, fs } from "@modern-js/utils";
+import path from "path";
+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 (path.extname(entryWithoutExt)) return fs.existsSync(entryWithoutExt) ? entryWithoutExt : void 0;
+        return findExists(JS_OR_TS_EXTS.map((ext)=>`${entryWithoutExt}${ext}`));
+    };
+    if (effectEntry) {
+        const entryWithoutExt = path.isAbsolute(effectEntry) ? effectEntry : path.resolve(appDir, effectEntry);
+        return resolveEntry(entryWithoutExt);
+    }
+    return resolveEntry(path.resolve(apiDir, 'index'));
+}
+export { resolveEffectEntryFile };