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

package/dist/cjs/runtime/effect-client/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/runtime/safe-failure.js

@@ -35,6 +35,7 @@ const SAFE_FAILURE_CODES = {
     500: 'INTERNAL_SERVER_ERROR',
     503: 'SERVICE_UNAVAILABLE'
 };
+const INVALID_HTTP_HEADER_VALUE = /[\0-\x08\x0a-\x1f\x7f]/u;
 const readErrorProperty = (error, key)=>{
     if ('object' != typeof error || null === error || !(key in error)) return;
     return error[key];
@@ -47,7 +48,7 @@ const normalizeRetryAfter = (value)=>{
     if ('number' == typeof value && Number.isFinite(value) && value >= 0) return String(Math.ceil(value));
     if ('string' == typeof value) {
         const trimmed = value.trim();
-        return trimmed.length > 0 ? trimmed : void 0;
+        return trimmed.length > 0 && !INVALID_HTTP_HEADER_VALUE.test(trimmed) ? trimmed : void 0;
     }
     if (value instanceof Date) return value.toUTCString();
 };

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

@@ -0,0 +1,152 @@
+"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__, {
+    API_DIR: ()=>API_DIR,
+    CLIENT_DIR: ()=>CLIENT_DIR,
+    EXPORT_PREFIX: ()=>EXPORT_PREFIX,
+    GENERATED_RUNTIME_DIRS: ()=>GENERATED_RUNTIME_DIRS,
+    PLUGIN_DIR: ()=>PLUGIN_DIR,
+    RUNTIME_DIR: ()=>RUNTIME_DIR,
+    TYPE_PREFIX: ()=>TYPE_PREFIX,
+    copyFiles: ()=>copyFiles,
+    createFileDetails: ()=>createFileDetails,
+    posixJoin: ()=>posixJoin,
+    readDirectoryFiles: ()=>readDirectoryFiles,
+    toPosixPath: ()=>toPosixPath,
+    writeTargetFile: ()=>writeTargetFile
+});
+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 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 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;
+}
+async function writeTargetFile(absTargetDir, content) {
+    await utils_namespaceObject.fs.mkdir(external_path_default().dirname(absTargetDir), {
+        recursive: true
+    });
+    await utils_namespaceObject.fs.writeFile(absTargetDir, content);
+}
+async function copyFiles(from, to) {
+    if (await utils_namespaceObject.fs.pathExists(from)) await utils_namespaceObject.fs.copy(toPosixPath(from), toPosixPath(to));
+}
+exports.API_DIR = __webpack_exports__.API_DIR;
+exports.CLIENT_DIR = __webpack_exports__.CLIENT_DIR;
+exports.EXPORT_PREFIX = __webpack_exports__.EXPORT_PREFIX;
+exports.GENERATED_RUNTIME_DIRS = __webpack_exports__.GENERATED_RUNTIME_DIRS;
+exports.PLUGIN_DIR = __webpack_exports__.PLUGIN_DIR;
+exports.RUNTIME_DIR = __webpack_exports__.RUNTIME_DIR;
+exports.TYPE_PREFIX = __webpack_exports__.TYPE_PREFIX;
+exports.copyFiles = __webpack_exports__.copyFiles;
+exports.createFileDetails = __webpack_exports__.createFileDetails;
+exports.posixJoin = __webpack_exports__.posixJoin;
+exports.readDirectoryFiles = __webpack_exports__.readDirectoryFiles;
+exports.toPosixPath = __webpack_exports__.toPosixPath;
+exports.writeTargetFile = __webpack_exports__.writeTargetFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "API_DIR",
+    "CLIENT_DIR",
+    "EXPORT_PREFIX",
+    "GENERATED_RUNTIME_DIRS",
+    "PLUGIN_DIR",
+    "RUNTIME_DIR",
+    "TYPE_PREFIX",
+    "copyFiles",
+    "createFileDetails",
+    "posixJoin",
+    "readDirectoryFiles",
+    "toPosixPath",
+    "writeTargetFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,138 @@
+"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__, {
+    clientGenerator: ()=>clientGenerator,
+    default: ()=>generate
+});
+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 external_files_js_namespaceObject = require("./files.js");
+const external_package_json_js_namespaceObject = require("./package-json.js");
+const external_write_package_js_namespaceObject = require("./write-package.js");
+async function clientGenerator(draftOptions) {
+    const generatedClientDir = external_path_default().resolve(draftOptions.appDir, draftOptions.relativeDistPath, external_files_js_namespaceObject.CLIENT_DIR);
+    await utils_namespaceObject.fs.remove(generatedClientDir);
+    const requestId = (0, external_package_json_js_namespaceObject.getPackageName)(draftOptions.appDir) || process.env.npm_package_name;
+    const lambdaSourceList = draftOptions.existLambda ? await (0, external_files_js_namespaceObject.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 (0, external_files_js_namespaceObject.writeTargetFile)(source.absTargetDir, code.value);
+                await (0, external_files_js_namespaceObject.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 = (0, external_files_js_namespaceObject.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 (0, external_files_js_namespaceObject.writeTargetFile)(effectFileDetails.absTargetDir, effectClientArtifacts.code);
+                    await (0, external_files_js_namespaceObject.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 (0, external_write_package_js_namespaceObject.writeClientModuleBoundary)(draftOptions.appDir, draftOptions.relativeDistPath);
+    await (0, external_write_package_js_namespaceObject.setPackage)(generatedSourceList, draftOptions.appDir, draftOptions.relativeDistPath);
+}
+const generate = clientGenerator;
+exports.clientGenerator = __webpack_exports__.clientGenerator;
+exports["default"] = __webpack_exports__["default"];
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "clientGenerator",
+    "default"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,83 @@
+"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__, {
+    clientGenerator: ()=>external_generate_js_namespaceObject.clientGenerator,
+    copyFiles: ()=>external_files_js_namespaceObject.copyFiles,
+    createFileDetails: ()=>external_files_js_namespaceObject.createFileDetails,
+    default: ()=>external_generate_js_default(),
+    getClientPackageName: ()=>external_package_json_js_namespaceObject.getClientPackageName,
+    getPackageName: ()=>external_package_json_js_namespaceObject.getPackageName,
+    mergePackageJson: ()=>external_package_json_js_namespaceObject.mergePackageJson,
+    readDirectoryFiles: ()=>external_files_js_namespaceObject.readDirectoryFiles,
+    setPackage: ()=>external_write_package_js_namespaceObject.setPackage,
+    writeClientModuleBoundary: ()=>external_write_package_js_namespaceObject.writeClientModuleBoundary,
+    writeTargetFile: ()=>external_files_js_namespaceObject.writeTargetFile
+});
+const external_files_js_namespaceObject = require("./files.js");
+const external_generate_js_namespaceObject = require("./generate.js");
+var external_generate_js_default = /*#__PURE__*/ __webpack_require__.n(external_generate_js_namespaceObject);
+const external_package_json_js_namespaceObject = require("./package-json.js");
+const external_write_package_js_namespaceObject = require("./write-package.js");
+exports.clientGenerator = __webpack_exports__.clientGenerator;
+exports.copyFiles = __webpack_exports__.copyFiles;
+exports.createFileDetails = __webpack_exports__.createFileDetails;
+exports["default"] = __webpack_exports__["default"];
+exports.getClientPackageName = __webpack_exports__.getClientPackageName;
+exports.getPackageName = __webpack_exports__.getPackageName;
+exports.mergePackageJson = __webpack_exports__.mergePackageJson;
+exports.readDirectoryFiles = __webpack_exports__.readDirectoryFiles;
+exports.setPackage = __webpack_exports__.setPackage;
+exports.writeClientModuleBoundary = __webpack_exports__.writeClientModuleBoundary;
+exports.writeTargetFile = __webpack_exports__.writeTargetFile;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "clientGenerator",
+    "copyFiles",
+    "createFileDetails",
+    "default",
+    "getClientPackageName",
+    "getPackageName",
+    "mergePackageJson",
+    "readDirectoryFiles",
+    "setPackage",
+    "writeClientModuleBoundary",
+    "writeTargetFile"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,132 @@
+"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__, {
+    getClientPackageName: ()=>getClientPackageName,
+    getPackageName: ()=>getPackageName,
+    mergePackageJson: ()=>mergePackageJson
+});
+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_files_js_namespaceObject = require("./files.js");
+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 mergePackageJson(packageJson, files, typesVersion, exports1, relativeDistPath) {
+    const distPrefix = (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/`);
+    const generatedPrefixes = external_files_js_namespaceObject.GENERATED_RUNTIME_DIRS.map((dir)=>(0, external_files_js_namespaceObject.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)=>(0, external_files_js_namespaceObject.toPosixPath)(file)))
+    ];
+    const currentFiles = packageJson.files || [];
+    packageJson.files = [
+        ...new Set([
+            ...currentFiles.map((file)=>(0, external_files_js_namespaceObject.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(external_files_js_namespaceObject.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 "${external_files_js_namespaceObject.TYPE_PREFIX}" namespace.`);
+    Object.keys(starTypes).forEach((key)=>{
+        if (generatedTypeKeys.has(key) || key.startsWith(external_files_js_namespaceObject.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(external_files_js_namespaceObject.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 "${external_files_js_namespaceObject.EXPORT_PREFIX}" namespace.`);
+    Object.keys(packageExports).forEach((key)=>{
+        if (generatedExportKeys.has(key) || key.startsWith(external_files_js_namespaceObject.EXPORT_PREFIX)) delete packageExports[key];
+    });
+    Object.assign(packageExports, exports1);
+}
+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`;
+}
+exports.getClientPackageName = __webpack_exports__.getClientPackageName;
+exports.getPackageName = __webpack_exports__.getPackageName;
+exports.mergePackageJson = __webpack_exports__.mergePackageJson;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getClientPackageName",
+    "getPackageName",
+    "mergePackageJson"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,125 @@
+"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__, {
+    setPackage: ()=>setPackage,
+    writeClientModuleBoundary: ()=>writeClientModuleBoundary
+});
+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_files_js_namespaceObject = require("./files.js");
+const external_package_json_js_namespaceObject = require("./package-json.js");
+async function writeClientModuleBoundary(appDirectory, relativeDistPath) {
+    await (0, external_files_js_namespaceObject.writeTargetFile)(external_path_default().resolve(appDirectory, relativeDistPath, external_files_js_namespaceObject.CLIENT_DIR, 'package.json'), `${JSON.stringify({
+        private: true,
+        name: (0, external_package_json_js_namespaceObject.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 = [
+        (0, external_files_js_namespaceObject.posixJoin)(relativeDistPath, external_files_js_namespaceObject.CLIENT_DIR, '**', '*'),
+        (0, external_files_js_namespaceObject.posixJoin)(relativeDistPath, external_files_js_namespaceObject.RUNTIME_DIR, '**', '*'),
+        (0, external_files_js_namespaceObject.posixJoin)(relativeDistPath, external_files_js_namespaceObject.PLUGIN_DIR, '**', '*')
+    ];
+    const typesVersions = {
+        '*': sortedFiles.reduce((acc, file)=>{
+            const typeFilePath = (0, external_files_js_namespaceObject.toPosixPath)(`./${file.targetDir}`).replace(/\.js$/, '.d.ts');
+            return {
+                ...acc,
+                [(0, external_files_js_namespaceObject.toPosixPath)(`${external_files_js_namespaceObject.TYPE_PREFIX}${file.exportKey}`)]: [
+                    typeFilePath
+                ]
+            };
+        }, {
+            [`${external_files_js_namespaceObject.API_DIR}/*`]: [
+                (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.CLIENT_DIR}/*.d.ts`)
+            ],
+            [external_files_js_namespaceObject.RUNTIME_DIR]: [
+                (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.RUNTIME_DIR}/index.d.ts`)
+            ],
+            [external_files_js_namespaceObject.PLUGIN_DIR]: [
+                (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.PLUGIN_DIR}/index.d.ts`)
+            ]
+        })
+    };
+    const exports1 = sortedFiles.reduce((acc, file)=>{
+        const exportKey = `${external_files_js_namespaceObject.EXPORT_PREFIX}${file.exportKey}`;
+        const jsFilePath = (0, external_files_js_namespaceObject.toPosixPath)(`./${file.targetDir}`);
+        return {
+            ...acc,
+            [(0, external_files_js_namespaceObject.toPosixPath)(exportKey)]: {
+                import: jsFilePath,
+                types: (0, external_files_js_namespaceObject.toPosixPath)(jsFilePath.replace(/\.js$/, '.d.ts'))
+            }
+        };
+    }, {
+        [(0, external_files_js_namespaceObject.toPosixPath)(`./${external_files_js_namespaceObject.API_DIR}/*`)]: {
+            import: (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.CLIENT_DIR}/*.js`),
+            types: (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.CLIENT_DIR}/*.d.ts`)
+        },
+        [(0, external_files_js_namespaceObject.toPosixPath)(`./${external_files_js_namespaceObject.PLUGIN_DIR}`)]: {
+            import: (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.PLUGIN_DIR}/index.js`),
+            require: (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.PLUGIN_DIR}/index.js`),
+            types: (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.PLUGIN_DIR}/index.d.ts`)
+        },
+        [(0, external_files_js_namespaceObject.toPosixPath)(`./${external_files_js_namespaceObject.RUNTIME_DIR}`)]: {
+            import: (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.RUNTIME_DIR}/index.js`),
+            require: (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.RUNTIME_DIR}/index.js`),
+            types: (0, external_files_js_namespaceObject.toPosixPath)(`./${relativeDistPath}/${external_files_js_namespaceObject.RUNTIME_DIR}/index.d.ts`)
+        }
+    });
+    (0, external_package_json_js_namespaceObject.mergePackageJson)(packageJson, addFiles, typesVersions, exports1, relativeDistPath);
+    await utils_namespaceObject.fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
+}
+exports.setPackage = __webpack_exports__.setPackage;
+exports.writeClientModuleBoundary = __webpack_exports__.writeClientModuleBoundary;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "setPackage",
+    "writeClientModuleBoundary"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});