@module-federation/modern-js 0.0.0-next-20241010084324 → 0.0.0-next-20241011105718

package/dist/esm/cli/dataLoader/plugin.js

@@ -0,0 +1,341 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { fs } from "@modern-js/utils";
+import { transformName2Prefix } from "../../runtime/dataLoader/utils";
+import { DEFAULT_ENTRY, ROUTE_ID } from "../../constant";
+import { META_NAME } from "../../constant";
+import { generateRoutes } from "./ast";
+import { generateRouteFile } from "./generateRouteFile";
+import { patchMFConfig } from "./patchMFConfig";
+import { clearMFCache } from "./clearMFCache";
+import path from "path";
+function _transformRuntimeOptions(buildOptions) {
+  var remotes = buildOptions.remotes || {};
+  var runtimeRemotes = Object.entries(remotes).map(function(remote) {
+    var _remote = _sliced_to_array(remote, 2), alias = _remote[0], nameAndEntry = _remote[1];
+    var _nameAndEntry_split = _sliced_to_array(nameAndEntry.split("@"), 2), name = _nameAndEntry_split[0], entry = _nameAndEntry_split[1];
+    return {
+      name,
+      entry,
+      alias
+    };
+  });
+  return {
+    name: buildOptions.name,
+    remotes: runtimeRemotes
+  };
+}
+var moduleFederationDataLoaderPlugin = function(enable, internalOptions, userConfig) {
+  return {
+    name: "@modern-js/plugin-module-federation-data-loader",
+    pre: [
+      "@modern-js/plugin-module-federation-config"
+    ],
+    post: [
+      "@modern-js/plugin-router",
+      "@modern-js/plugin-module-federation"
+    ],
+    setup: function() {
+      var _ref = _async_to_generator(function(param) {
+        var useAppContext, _userConfig_serverPlugin, serverPlugin, transformRuntimeOptions, appContext, name, _internalOptions_metaName, metaName, internalDirectory, transformRuntimeFn, entries, remotePathMap, ssrByRouteIdsMap, csrConfig, _ref2, scanEntries, scanRemotePathMap, dataLoaderRemotes, serverPluginOptions, hasDataLoaderRemotes;
+        return _ts_generator(this, function(_state) {
+          switch (_state.label) {
+            case 0:
+              useAppContext = param.useAppContext;
+              if (!enable) {
+                return [
+                  2
+                ];
+              }
+              _userConfig_serverPlugin = userConfig.serverPlugin, serverPlugin = _userConfig_serverPlugin === void 0 ? "@module-federation/modern-js/data-loader-server" : _userConfig_serverPlugin, transformRuntimeOptions = userConfig.transformRuntimeOptions;
+              appContext = useAppContext();
+              name = internalOptions.csrConfig.name;
+              _internalOptions_metaName = internalOptions.metaName, metaName = _internalOptions_metaName === void 0 ? META_NAME : _internalOptions_metaName;
+              internalDirectory = appContext.internalDirectory.replace(META_NAME, metaName || META_NAME);
+              transformRuntimeFn = transformRuntimeOptions || _transformRuntimeOptions;
+              entries = /* @__PURE__ */ new Set();
+              remotePathMap = {};
+              ssrByRouteIdsMap = {};
+              csrConfig = internalOptions.csrConfig;
+              if (!(_type_of(csrConfig.remotes) === "object" && Object.keys(csrConfig.remotes).length))
+                return [
+                  3,
+                  2
+                ];
+              return [
+                4,
+                generateRouteFile({
+                  appDirectory: appContext.appDirectory
+                })
+              ];
+            case 1:
+              _ref2 = _state.sent(), scanEntries = _ref2.entries, scanRemotePathMap = _ref2.remotePathMap;
+              scanEntries.forEach(function(e) {
+                return entries.add(e);
+              });
+              remotePathMap = scanRemotePathMap;
+              return [
+                3,
+                3
+              ];
+            case 2:
+              entries.add(DEFAULT_ENTRY);
+              _state.label = 3;
+            case 3:
+              dataLoaderRemotes = _to_consumable_array(new Set(Object.values(remotePathMap).map(function(i) {
+                return i.name;
+              })));
+              serverPluginOptions = {
+                runtimeOptions: transformRuntimeFn(internalOptions.csrConfig),
+                dataLoaderRemotes,
+                ssrByRouteIdsMap
+              };
+              hasDataLoaderRemotes = function() {
+                return Boolean(serverPluginOptions.dataLoaderRemotes.length);
+              };
+              return [
+                2,
+                {
+                  _internalRuntimePlugins: function(param2) {
+                    var entrypoint = param2.entrypoint, plugins = param2.plugins;
+                    if (!hasDataLoaderRemotes()) {
+                      return {
+                        entrypoint,
+                        plugins
+                      };
+                    }
+                    plugins.push({
+                      name: "ssrDataLoader",
+                      path: "@module-federation/modern-js/data-loader",
+                      config: {
+                        metaName,
+                        dataLoaderRemotes
+                      }
+                    });
+                    plugins.push({
+                      name: "ssrDataLoaderInjectAssets",
+                      path: "@module-federation/modern-js/data-loader-inject-assets",
+                      config: {
+                        metaName,
+                        dataLoaderRemotes
+                      }
+                    });
+                    return {
+                      entrypoint,
+                      plugins
+                    };
+                  },
+                  _internalServerPlugins: function _internalServerPlugins(param2) {
+                    var plugins = param2.plugins;
+                    if (!hasDataLoaderRemotes()) {
+                      return {
+                        plugins
+                      };
+                    }
+                    plugins.push({
+                      name: serverPlugin,
+                      options: serverPluginOptions
+                    });
+                    return {
+                      plugins
+                    };
+                  },
+                  modifyFileSystemRoutes: function modifyFileSystemRoutes(options) {
+                    return _async_to_generator(function() {
+                      var routes, entrypoint, entryName, prefix, modifyRouteIds;
+                      return _ts_generator(this, function(_state2) {
+                        switch (_state2.label) {
+                          case 0:
+                            routes = options.routes, entrypoint = options.entrypoint;
+                            entryName = entrypoint.entryName;
+                            prefix = transformName2Prefix(internalOptions.csrConfig.name);
+                            modifyRouteIds = function() {
+                              var _ref3 = _async_to_generator(function(route, pathName) {
+                                var currentPathName, originalId, remoteInfo, _$path, name2, remoteIdPrefix, isLayout, newId, content, _tmp;
+                                return _ts_generator(this, function(_state3) {
+                                  switch (_state3.label) {
+                                    case 0:
+                                      currentPathName = route.path ? path.join(pathName, route.path) : pathName;
+                                      if (!route.id)
+                                        return [
+                                          3,
+                                          6
+                                        ];
+                                      originalId = route.id;
+                                      route.originalId = originalId;
+                                      remoteInfo = remotePathMap[currentPathName];
+                                      if (!remoteInfo)
+                                        return [
+                                          3,
+                                          2
+                                        ];
+                                      _$path = remoteInfo.path, name2 = remoteInfo.name;
+                                      remoteIdPrefix = transformName2Prefix(name2);
+                                      isLayout = Boolean(route.children);
+                                      newId = "".concat(remoteIdPrefix).concat(isLayout ? "layout" : "page");
+                                      ssrByRouteIdsMap[originalId] = newId;
+                                      content = fs.readFileSync(_$path, "utf-8");
+                                      return [
+                                        4,
+                                        fs.writeFile(_$path, content.replace(ROUTE_ID, originalId))
+                                      ];
+                                    case 1:
+                                      _state3.sent();
+                                      route.id = newId;
+                                      return [
+                                        3,
+                                        3
+                                      ];
+                                    case 2:
+                                      route.id = "".concat(prefix).concat(route.id);
+                                      _state3.label = 3;
+                                    case 3:
+                                      _tmp = route.children;
+                                      if (!_tmp)
+                                        return [
+                                          3,
+                                          5
+                                        ];
+                                      return [
+                                        4,
+                                        Promise.all(route.children.map(function() {
+                                          var _ref4 = _async_to_generator(function(r) {
+                                            return _ts_generator(this, function(_state4) {
+                                              switch (_state4.label) {
+                                                case 0:
+                                                  return [
+                                                    4,
+                                                    modifyRouteIds(r, currentPathName)
+                                                  ];
+                                                case 1:
+                                                  return [
+                                                    2,
+                                                    _state4.sent()
+                                                  ];
+                                              }
+                                            });
+                                          });
+                                          return function(r) {
+                                            return _ref4.apply(this, arguments);
+                                          };
+                                        }()))
+                                      ];
+                                    case 4:
+                                      _tmp = _state3.sent();
+                                      _state3.label = 5;
+                                    case 5:
+                                      _tmp;
+                                      _state3.label = 6;
+                                    case 6:
+                                      return [
+                                        2
+                                      ];
+                                  }
+                                });
+                              });
+                              return function modifyRouteIds2(route, pathName) {
+                                return _ref3.apply(this, arguments);
+                              };
+                            }();
+                            return [
+                              4,
+                              Promise.all(routes.map(function() {
+                                var _ref3 = _async_to_generator(function(route) {
+                                  return _ts_generator(this, function(_state3) {
+                                    switch (_state3.label) {
+                                      case 0:
+                                        return [
+                                          4,
+                                          modifyRouteIds(route, entryName)
+                                        ];
+                                      case 1:
+                                        _state3.sent();
+                                        return [
+                                          2
+                                        ];
+                                    }
+                                  });
+                                });
+                                return function(route) {
+                                  return _ref3.apply(this, arguments);
+                                };
+                              }()))
+                            ];
+                          case 1:
+                            _state2.sent();
+                            return [
+                              2,
+                              options
+                            ];
+                        }
+                      });
+                    })();
+                  },
+                  config: /* @__PURE__ */ _async_to_generator(function() {
+                    return _ts_generator(this, function(_state2) {
+                      return [
+                        2,
+                        {
+                          tools: {
+                            // bundlerChain can not keep target order
+                            rspack: function rspack(_config, param2) {
+                              var isServer = param2.isServer;
+                              patchMFConfig({
+                                mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                                metaName,
+                                isServer,
+                                internalDirectory,
+                                entries
+                              });
+                            },
+                            // bundlerChain can not keep target order
+                            webpack: function webpack(_config, param2) {
+                              var isServer = param2.isServer;
+                              patchMFConfig({
+                                mfConfig: isServer ? internalOptions.ssrConfig : internalOptions.csrConfig,
+                                metaName,
+                                isServer,
+                                internalDirectory,
+                                entries
+                              });
+                            }
+                          },
+                          source: {
+                            define: {
+                              MODERN_ROUTER_ID_PREFIX: JSON.stringify(transformName2Prefix(name))
+                            }
+                          }
+                        }
+                      ];
+                    });
+                  }),
+                  afterDev: function afterDev() {
+                    return _async_to_generator(function() {
+                      return _ts_generator(this, function(_state2) {
+                        clearMFCache();
+                        return [
+                          2
+                        ];
+                      });
+                    })();
+                  }
+                }
+              ];
+          }
+        });
+      });
+      return function(_) {
+        return _ref.apply(this, arguments);
+      };
+    }()
+  };
+};
+var plugin_default = moduleFederationDataLoaderPlugin;
+export {
+  plugin_default as default,
+  generateRoutes,
+  moduleFederationDataLoaderPlugin
+};

package/dist/esm/cli/index.js

@@ -1,9 +1,12 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _type_of } from "@swc/helpers/_/_type_of";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import { ModuleFederationPlugin as WebpackModuleFederationPlugin, AsyncBoundaryPlugin } from "@module-federation/enhanced";
 import { ModuleFederationPlugin as RspackModuleFederationPlugin } from "@module-federation/enhanced/rspack";
 import { moduleFederationConfigPlugin } from "./configPlugin";
 import { moduleFederationSSRPlugin } from "./ssrPlugin";
+import { moduleFederationDataLoaderPlugin } from "./dataLoader/plugin";
 var moduleFederationPlugin = function() {
   var userConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
   var internalModernPluginOptions = {
@@ -53,7 +56,7 @@ var moduleFederationPlugin = function() {
                           var enableAsyncEntry = (_modernjsConfig_source = modernjsConfig.source) === null || _modernjsConfig_source === void 0 ? void 0 : _modernjsConfig_source.enableAsyncEntry;
                           if (!enableAsyncEntry && browserPluginOptions.async !== false) {
                             var _config_plugins1;
-                            var asyncBoundaryPluginOptions = typeof browserPluginOptions.async === "object" ? browserPluginOptions.async : {
+                            var asyncBoundaryPluginOptions = _type_of(browserPluginOptions.async) === "object" ? browserPluginOptions.async : {
                               eager: function(module) {
                                 return module && /\.federation/.test((module === null || module === void 0 ? void 0 : module.request) || "");
                               },
@@ -79,7 +82,8 @@ var moduleFederationPlugin = function() {
     }(),
     usePlugins: [
       moduleFederationConfigPlugin(internalModernPluginOptions),
-      moduleFederationSSRPlugin(internalModernPluginOptions)
+      moduleFederationSSRPlugin(internalModernPluginOptions),
+      moduleFederationDataLoaderPlugin(Boolean(userConfig.dataLoader), internalModernPluginOptions, _object_spread({}, typeof userConfig.dataLoader === "boolean" ? {} : userConfig.dataLoader))
     ]
   };
 };

package/dist/esm/cli/mfRuntimePlugins/{inject-node-fetch.js → node-fetch.js}

@@ -1,7 +1,7 @@
 import nodeFetch from "node-fetch";
 var injectNodeFetchPlugin = function() {
   return {
-    name: "inject-node-fetch-plugin",
+    name: "node-fetch-plugin",
     beforeInit: function beforeInit(args) {
       if (!globalThis.fetch) {
         globalThis.fetch = nodeFetch;
@@ -10,7 +10,7 @@ var injectNodeFetchPlugin = function() {
     }
   };
 };
-var inject_node_fetch_default = injectNodeFetchPlugin;
+var node_fetch_default = injectNodeFetchPlugin;
 export {
-  inject_node_fetch_default as default
+  node_fetch_default as default
 };

package/dist/esm/cli/mfRuntimePlugins/node.js

@@ -0,0 +1,13 @@
+import nodeRuntimePlugin from "@module-federation/node/runtimePlugin";
+var isContainer = typeof __filename === "string" ? __filename.includes("remote") ? true : false : false;
+var pluginName = "node-plugin-".concat(isContainer);
+var nodePlugin = function() {
+  return {
+    name: pluginName,
+    beforeInit: nodeRuntimePlugin().beforeInit
+  };
+};
+var node_default = nodePlugin;
+export {
+  node_default as default
+};

package/dist/esm/cli/server/dataLoaderPlugin.js

@@ -0,0 +1,104 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { init } from "@module-federation/enhanced/runtime";
+import { isBrowserEnv } from "@module-federation/sdk";
+import { fetchRemoteFullRoutesMap, getSSRByRouteIds } from "./fetchRemoteFullRoutesMap";
+import { injectRemoteRoutes } from "../../runtime/dataLoader/utils";
+import { MF_ROUTES, DEFAULT_ENTRY, MODERN_JS_ROUTE_SERVER_LOADER } from "../../constant";
+function dataLoaderPlugin_default(param) {
+  var runtimeOptions = param.runtimeOptions, dataLoaderRemotes = param.dataLoaderRemotes, ssrByRouteIdsMap = param.ssrByRouteIdsMap;
+  return {
+    name: "MFDataLoaderServerPlugin",
+    pre: [
+      "@modern-js/plugin-inject-resource"
+    ],
+    setup: function setup(api) {
+      var remotes = runtimeOptions.remotes, name = runtimeOptions.name;
+      var isHandled = false;
+      return {
+        prepare: function prepare() {
+          var middlewares = api.useAppContext().middlewares;
+          middlewares.push({
+            name: "MFPatchRouteMiddleWare",
+            handler: function() {
+              var _ref = _async_to_generator(function(c, next) {
+                var serverManifest, loaderBundles, nestedRoutesJson, _api_useConfigContext_server, instance, remoteFullRoutesMap, originalSSRByRouteIds, remoteSSRByRouteIds, ssrByRouteIds;
+                return _ts_generator(this, function(_state) {
+                  switch (_state.label) {
+                    case 0:
+                      serverManifest = c.get("serverManifest");
+                      loaderBundles = serverManifest.loaderBundles, nestedRoutesJson = serverManifest.nestedRoutesJson;
+                      if (!(isHandled && !globalThis.FORCE_MF_REFRESH))
+                        return [
+                          3,
+                          2
+                        ];
+                      return [
+                        4,
+                        next()
+                      ];
+                    case 1:
+                      _state.sent();
+                      return [
+                        3,
+                        5
+                      ];
+                    case 2:
+                      instance = init({
+                        name,
+                        remotes
+                      });
+                      return [
+                        4,
+                        fetchRemoteFullRoutesMap({
+                          instance,
+                          remotePath: isBrowserEnv() ? "".concat(DEFAULT_ENTRY, "/").concat(MF_ROUTES) : "".concat(DEFAULT_ENTRY, "/").concat(MODERN_JS_ROUTE_SERVER_LOADER),
+                          dataLoaderRemotes
+                        })
+                      ];
+                    case 3:
+                      remoteFullRoutesMap = _state.sent();
+                      originalSSRByRouteIds = (_api_useConfigContext_server = api.useConfigContext().server) === null || _api_useConfigContext_server === void 0 ? void 0 : _api_useConfigContext_server.ssrByRouteIds;
+                      if (originalSSRByRouteIds && dataLoaderRemotes.length) {
+                        remoteSSRByRouteIds = getSSRByRouteIds(dataLoaderRemotes, remoteFullRoutesMap) || [];
+                        ssrByRouteIds = new Set(_to_consumable_array(originalSSRByRouteIds).concat(_to_consumable_array(remoteSSRByRouteIds.map(function(id) {
+                          return ssrByRouteIdsMap[id] || id;
+                        }))));
+                        api.useConfigContext().server.ssrByRouteIds = Array.from(ssrByRouteIds);
+                      }
+                      injectRemoteRoutes(loaderBundles, remoteFullRoutesMap);
+                      injectRemoteRoutes(nestedRoutesJson, remoteFullRoutesMap);
+                      isHandled = true;
+                      globalThis.FORCE_MF_REFRESH = false;
+                      return [
+                        4,
+                        next()
+                      ];
+                    case 4:
+                      _state.sent();
+                      _state.label = 5;
+                    case 5:
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(c, next) {
+                return _ref.apply(this, arguments);
+              };
+            }(),
+            before: [
+              "render"
+            ]
+          });
+        }
+      };
+    }
+  };
+}
+;
+export {
+  dataLoaderPlugin_default as default
+};

package/dist/esm/cli/server/fetchRemoteFullRoutesMap.js

@@ -0,0 +1,93 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import { _ as _to_consumable_array } from "@swc/helpers/_/_to_consumable_array";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+function fetchRemoteFullRoutesMap(options) {
+  return _fetchRemoteFullRoutesMap.apply(this, arguments);
+}
+function _fetchRemoteFullRoutesMap() {
+  _fetchRemoteFullRoutesMap = _async_to_generator(function(options) {
+    var instance, remotePath, dataLoaderRemotes, remotes, remoteRoutesMap;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          instance = options.instance, remotePath = options.remotePath, dataLoaderRemotes = options.dataLoaderRemotes;
+          remotes = instance.options.remotes;
+          remoteRoutesMap = {};
+          if (!remotes.length) {
+            return [
+              2,
+              remoteRoutesMap
+            ];
+          }
+          return [
+            4,
+            Promise.all(remotes.map(function() {
+              var _ref = _async_to_generator(function(remote) {
+                var remoteId, routes;
+                return _ts_generator(this, function(_state2) {
+                  switch (_state2.label) {
+                    case 0:
+                      if (!dataLoaderRemotes.includes(remote.name)) {
+                        return [
+                          2
+                        ];
+                      }
+                      remoteId = "".concat(remote.name, "/").concat(remotePath);
+                      return [
+                        4,
+                        instance.loadRemote(remoteId)
+                      ];
+                    case 1:
+                      routes = _state2.sent().routes;
+                      remoteRoutesMap[remote.name] = {
+                        routes
+                      };
+                      return [
+                        2
+                      ];
+                  }
+                });
+              });
+              return function(remote) {
+                return _ref.apply(this, arguments);
+              };
+            }()))
+          ];
+        case 1:
+          _state.sent();
+          return [
+            2,
+            remoteRoutesMap
+          ];
+      }
+    });
+  });
+  return _fetchRemoteFullRoutesMap.apply(this, arguments);
+}
+function getSSRByRouteIds(dataLoaderRemotes, remoteRoutesMap) {
+  var remoteProviderRouteIds = /* @__PURE__ */ new Set();
+  var collectIds = function(route) {
+    remoteProviderRouteIds.add(route.id);
+    if (route.children) {
+      route.children.forEach(function(r) {
+        collectIds(r);
+      });
+    }
+  };
+  Object.entries(remoteRoutesMap).forEach(function(item) {
+    var _item = _sliced_to_array(item, 2), remoteName = _item[0], routesObj = _item[1];
+    if (!dataLoaderRemotes.includes(remoteName)) {
+      return;
+    }
+    var routes = routesObj.routes;
+    routes.forEach(function(route) {
+      collectIds(route);
+    });
+  });
+  return _to_consumable_array(remoteProviderRouteIds);
+}
+export {
+  fetchRemoteFullRoutesMap,
+  getSSRByRouteIds
+};

package/dist/esm/cli/ssrPlugin.js

@@ -6,7 +6,7 @@ import { ModuleFederationPlugin } from "@module-federation/enhanced/webpack";
 import { ModuleFederationPlugin as RspackModuleFederationPlugin } from "@module-federation/enhanced/rspack";
 import UniverseEntryChunkTrackerPlugin from "@module-federation/node/universe-entry-chunk-tracker-plugin";
 import { updateStatsAndManifest } from "./manifest";
-import { isDev } from "./constant";
+import { isDev, META_NAME } from "../constant";
 function setEnv() {
   process.env["MF_DISABLE_EMIT_STATS"] = "true";
   process.env["MF_SSR_PRJ"] = "true";
@@ -20,10 +20,11 @@ var moduleFederationSSRPlugin = function(userConfig) {
     ],
     setup: function() {
       var _ref = _async_to_generator(function(param) {
-        var useConfigContext, useAppContext, _modernjsConfig_server, modernjsConfig, enableSSR;
+        var useConfigContext, useAppContext, _modernjsConfig_server, modernjsConfig, _userConfig_metaName, metaName, enableSSR;
         return _ts_generator(this, function(_state) {
           useConfigContext = param.useConfigContext, useAppContext = param.useAppContext;
           modernjsConfig = useConfigContext();
+          _userConfig_metaName = userConfig.metaName, metaName = _userConfig_metaName === void 0 ? META_NAME : _userConfig_metaName;
           enableSSR = Boolean(modernjsConfig === null || modernjsConfig === void 0 ? void 0 : (_modernjsConfig_server = modernjsConfig.server) === null || _modernjsConfig_server === void 0 ? void 0 : _modernjsConfig_server.ssr);
           if (!enableSSR) {
             return [
@@ -46,7 +47,9 @@ var moduleFederationSSRPlugin = function(userConfig) {
                 plugins.push({
                   name: "mfSSR",
                   path: "@module-federation/modern-js/ssr-runtime",
-                  config: {}
+                  config: {
+                    metaName
+                  }
                 });
                 return {
                   entrypoint,