@modern-js/plugin-bff 2.69.5 → 3.0.0-alpha.0

package/dist/cjs/utils/clientGenerator.js

@@ -1,227 +1,225 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var clientGenerator_exports = {};
-__export(clientGenerator_exports, {
-  copyFiles: () => copyFiles,
-  default: () => clientGenerator_default,
-  readDirectoryFiles: () => readDirectoryFiles
+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__, {
+    readDirectoryFiles: ()=>readDirectoryFiles,
+    copyFiles: ()=>copyFiles,
+    default: ()=>utils_clientGenerator
 });
-module.exports = __toCommonJS(clientGenerator_exports);
-var import_path = __toESM(require("path"));
-var import_bff_core = require("@modern-js/bff-core");
-var import_utils = require("@modern-js/utils");
-const API_DIR = "api";
-const PLUGIN_DIR = "plugin";
-const RUNTIME_DIR = "runtime";
-const CLIENT_DIR = "client";
+const external_path_namespaceObject = require("path");
+var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+const bff_core_namespaceObject = require("@modern-js/bff-core");
+const utils_namespaceObject = require("@modern-js/utils");
+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 toPosixPath = (p) => p.replace(/\\/g, "/");
-const posixJoin = (...args) => toPosixPath(import_path.default.join(...args));
+const toPosixPath = (p)=>p.replace(/\\/g, '/');
+const posixJoin = (...args)=>toPosixPath(external_path_default().join(...args));
 async function readDirectoryFiles(appDirectory, directory, relativeDistPath) {
-  const filesList = [];
-  async function readFiles(currentPath) {
-    const entries = await import_utils.fs.readdir(currentPath, {
-      withFileTypes: true
-    });
-    for (const entry of entries) {
-      if (entry.name === "_app.ts")
-        continue;
-      const resourcePath = import_path.default.join(currentPath, entry.name);
-      if (entry.isDirectory()) {
-        await readFiles(resourcePath);
-      } else {
-        const source = await import_utils.fs.readFile(resourcePath, "utf8");
-        const relativePath = import_path.default.relative(directory, resourcePath);
-        const parsedPath = import_path.default.parse(relativePath);
-        const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
-        const name = parsedPath.name;
-        const absTargetDir = import_path.default.resolve(targetDir);
-        const relativePathFromAppDirectory = import_path.default.relative(appDirectory, currentPath);
-        const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${name}.d.ts`);
-        const relativeTargetDistDir = `./${typesFilePath}`;
-        const exportKey = toPosixPath(import_path.default.join(parsedPath.dir, name));
-        filesList.push({
-          resourcePath,
-          source,
-          targetDir,
-          name,
-          absTargetDir,
-          relativeTargetDistDir,
-          exportKey
+    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');
+                const relativePath = external_path_default().relative(directory, resourcePath);
+                const parsedPath = external_path_default().parse(relativePath);
+                const targetDir = posixJoin(`./${relativeDistPath}/${CLIENT_DIR}`, parsedPath.dir, `${parsedPath.name}.js`);
+                const name = parsedPath.name;
+                const absTargetDir = external_path_default().resolve(targetDir);
+                const relativePathFromAppDirectory = external_path_default().relative(appDirectory, currentPath);
+                const typesFilePath = posixJoin(`./${relativeDistPath}`, relativePathFromAppDirectory, `${name}.d.ts`);
+                const relativeTargetDistDir = `./${typesFilePath}`;
+                const exportKey = toPosixPath(external_path_default().join(parsedPath.dir, name));
+                filesList.push({
+                    resourcePath,
+                    source,
+                    targetDir,
+                    name,
+                    absTargetDir,
+                    relativeTargetDistDir,
+                    exportKey
+                });
+            }
+        }
     }
-  }
-  await readFiles(directory);
-  return filesList;
+    await readFiles(directory);
+    return filesList;
 }
-function mergePackageJson(packageJson, files, typesVersion, exports) {
-  var _packageJson, _packageJson1;
-  packageJson.files = [
-    .../* @__PURE__ */ new Set([
-      ...packageJson.files || [],
-      ...files
-    ])
-  ];
-  var _typesVersions;
-  (_typesVersions = (_packageJson = packageJson).typesVersions) !== null && _typesVersions !== void 0 ? _typesVersions : _packageJson.typesVersions = {};
-  const starTypes = packageJson.typesVersions["*"] || {};
-  Object.keys(starTypes).forEach((k) => k.startsWith(TYPE_PREFIX) && delete starTypes[k]);
-  packageJson.typesVersions["*"] = {
-    ...starTypes,
-    ...typesVersion["*"] || {}
-  };
-  var _exports;
-  (_exports = (_packageJson1 = packageJson).exports) !== null && _exports !== void 0 ? _exports : _packageJson1.exports = {};
-  Object.keys(packageJson.exports).forEach((k) => k.startsWith(EXPORT_PREFIX) && delete packageJson.exports[k]);
-  Object.assign(packageJson.exports, exports);
+function mergePackageJson(packageJson, files, typesVersion, exports1) {
+    packageJson.files = [
+        ...new Set([
+            ...packageJson.files || [],
+            ...files
+        ])
+    ];
+    packageJson.typesVersions ??= {};
+    const starTypes = packageJson.typesVersions['*'] || {};
+    Object.keys(starTypes).forEach((k)=>k.startsWith(TYPE_PREFIX) && delete starTypes[k]);
+    packageJson.typesVersions['*'] = {
+        ...starTypes,
+        ...typesVersion['*'] || {}
+    };
+    packageJson.exports ??= {};
+    Object.keys(packageJson.exports).forEach((k)=>k.startsWith(EXPORT_PREFIX) && delete packageJson.exports[k]);
+    Object.assign(packageJson.exports, exports1);
 }
 async function writeTargetFile(absTargetDir, content) {
-  await import_utils.fs.mkdir(import_path.default.dirname(absTargetDir), {
-    recursive: true
-  });
-  await import_utils.fs.writeFile(absTargetDir, content);
+    await utils_namespaceObject.fs.mkdir(external_path_default().dirname(absTargetDir), {
+        recursive: true
+    });
+    await utils_namespaceObject.fs.writeFile(absTargetDir, content);
 }
 async function setPackage(files, appDirectory, relativeDistPath) {
-  try {
-    const packagePath = import_path.default.resolve(appDirectory, "./package.json");
-    const packageContent = await import_utils.fs.readFile(packagePath, "utf8");
-    const packageJson = JSON.parse(packageContent);
-    const addFiles = [
-      posixJoin(relativeDistPath, CLIENT_DIR, "**", "*"),
-      posixJoin(relativeDistPath, RUNTIME_DIR, "**", "*"),
-      posixJoin(relativeDistPath, PLUGIN_DIR, "**", "*")
-    ];
-    const typesVersions = {
-      "*": files.reduce((acc, file) => {
-        const typeFilePath = toPosixPath(`./${file.targetDir}`).replace("js", "d.ts");
-        return {
-          ...acc,
-          [toPosixPath(`${TYPE_PREFIX}${file.exportKey}`)]: [
-            typeFilePath
-          ]
+    try {
+        const packagePath = external_path_default().resolve(appDirectory, './package.json');
+        const packageContent = await utils_namespaceObject.fs.readFile(packagePath, 'utf8');
+        const packageJson = JSON.parse(packageContent);
+        const addFiles = [
+            posixJoin(relativeDistPath, CLIENT_DIR, '**', '*'),
+            posixJoin(relativeDistPath, RUNTIME_DIR, '**', '*'),
+            posixJoin(relativeDistPath, PLUGIN_DIR, '**', '*')
+        ];
+        const typesVersions = {
+            '*': files.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`)
+                ]
+            })
         };
-      }, {
-        [`${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 = files.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);
-    await import_utils.fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
-  } catch (error) {
-    import_utils.logger.error(`package.json update failed: ${error}`);
-  }
+        const exports1 = files.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, exports1);
+        await utils_namespaceObject.fs.promises.writeFile(packagePath, JSON.stringify(packageJson, null, 2));
+    } catch (error) {
+        utils_namespaceObject.logger.error(`package.json update failed: ${error}`);
+    }
 }
 async function copyFiles(from, to) {
-  if (await import_utils.fs.pathExists(from)) {
-    await import_utils.fs.copy(toPosixPath(from), toPosixPath(to));
-  }
+    if (await utils_namespaceObject.fs.pathExists(from)) await utils_namespaceObject.fs.copy(toPosixPath(from), toPosixPath(to));
 }
 async function clientGenerator(draftOptions) {
-  const sourceList = await readDirectoryFiles(draftOptions.appDir, draftOptions.lambdaDir, draftOptions.relativeDistPath);
-  const getClitentCode = async (resourcePath, source) => {
-    const warning = `The file ${resourcePath} is not allowd to be imported in src directory, only API definition files are allowed.`;
-    if (!draftOptions.existLambda) {
-      import_utils.logger.warn(warning);
-      return;
-    }
-    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
+    const sourceList = await readDirectoryFiles(draftOptions.appDir, draftOptions.lambdaDir, draftOptions.relativeDistPath);
+    const getClitentCode = async (resourcePath, source)=>{
+        const warning = `The file ${resourcePath} is not allowd 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
+        };
+        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;
     };
-    const { lambdaDir } = draftOptions;
-    if (!resourcePath.startsWith(lambdaDir)) {
-      import_utils.logger.warn(warning);
-      return;
-    }
-    const result = await (0, import_bff_core.generateClient)(options);
-    return result;
-  };
-  try {
-    for (const source of sourceList) {
-      const code = await getClitentCode(source.resourcePath, source.source);
-      if (code === null || code === void 0 ? void 0 : code.value) {
-        await writeTargetFile(source.absTargetDir, code.value);
-        await copyFiles(source.relativeTargetDistDir, source.targetDir.replace(`js`, "d.ts"));
-      }
+    try {
+        for (const source of sourceList){
+            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'));
+            }
+        }
+        utils_namespaceObject.logger.info("Client bundle generate succeed");
+    } catch (error) {
+        utils_namespaceObject.logger.error(`Client bundle generate failed: ${error}`);
     }
-    import_utils.logger.info(`Client bundle generate succeed`);
-  } catch (error) {
-    import_utils.logger.error(`Client bundle generate failed: ${error}`);
-  }
-  setPackage(sourceList, draftOptions.appDir, draftOptions.relativeDistPath);
+    setPackage(sourceList, draftOptions.appDir, draftOptions.relativeDistPath);
 }
-var clientGenerator_default = clientGenerator;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  copyFiles,
-  readDirectoryFiles
+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"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
 });