@module-federation/modern-js 0.14.2 → 0.15.0

package/dist/esm/cli/configPlugin.spec.js

@@ -0,0 +1,110 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { it, expect, describe } from "vitest";
+import { patchMFConfig } from "./configPlugin";
+import { getIPV4 } from "./utils";
+var mfConfig = {
+  name: "host",
+  filename: "remoteEntry.js",
+  remotes: {
+    remote: "http://localhost:3000/remoteEntry.js"
+  },
+  shared: {
+    react: {
+      singleton: true,
+      eager: true
+    },
+    "react-dom": {
+      singleton: true,
+      eager: true
+    }
+  }
+};
+describe("patchMFConfig", /* @__PURE__ */ _async_to_generator(function() {
+  return _ts_generator(this, function(_state) {
+    it("patchMFConfig: server", /* @__PURE__ */ _async_to_generator(function() {
+      var patchedConfig, ipv4;
+      return _ts_generator(this, function(_state2) {
+        patchedConfig = JSON.parse(JSON.stringify(mfConfig));
+        patchMFConfig(patchedConfig, true);
+        ipv4 = getIPV4();
+        expect(patchedConfig).toStrictEqual({
+          dev: false,
+          dts: false,
+          filename: "remoteEntry.js",
+          library: {
+            name: "host",
+            type: "commonjs-module"
+          },
+          name: "host",
+          remotes: {
+            remote: "http://".concat(ipv4, ":3000/remoteEntry.js")
+          },
+          remoteType: "script",
+          runtimePlugins: [
+            require.resolve("@module-federation/modern-js/shared-strategy"),
+            require.resolve("@module-federation/modern-js/auto-fetch-data"),
+            require.resolve("@module-federation/node/runtimePlugin"),
+            require.resolve("@module-federation/modern-js/inject-node-fetch")
+          ],
+          shared: {
+            react: {
+              eager: true,
+              singleton: true
+            },
+            "react-dom": {
+              eager: true,
+              singleton: true
+            }
+          }
+        });
+        return [
+          2
+        ];
+      });
+    }));
+    it("patchMFConfig: client", /* @__PURE__ */ _async_to_generator(function() {
+      var patchedConfig, ipv4;
+      return _ts_generator(this, function(_state2) {
+        patchedConfig = JSON.parse(JSON.stringify(mfConfig));
+        patchMFConfig(patchedConfig, false);
+        ipv4 = getIPV4();
+        expect(patchedConfig).toStrictEqual({
+          filename: "remoteEntry.js",
+          name: "host",
+          remotes: {
+            remote: "http://".concat(ipv4, ":3000/remoteEntry.js")
+          },
+          remoteType: "script",
+          runtimePlugins: [
+            require.resolve("@module-federation/modern-js/shared-strategy"),
+            require.resolve("@module-federation/modern-js/auto-fetch-data")
+          ],
+          shared: {
+            react: {
+              eager: true,
+              singleton: true
+            },
+            "react-dom": {
+              eager: true,
+              singleton: true
+            }
+          },
+          dts: {
+            consumeTypes: {
+              runtimePkgs: [
+                "@module-federation/modern-js/runtime"
+              ]
+            }
+          }
+        });
+        return [
+          2
+        ];
+      });
+    }));
+    return [
+      2
+    ];
+  });
+}));

package/dist/esm/cli/index.js

@@ -0,0 +1,90 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+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 { isWebTarget } from "./utils";
+var moduleFederationPlugin = function() {
+  var userConfig = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+  var _userConfig_fetchServerQuery;
+  var internalModernPluginOptions = {
+    csrConfig: void 0,
+    ssrConfig: void 0,
+    browserPlugin: void 0,
+    nodePlugin: void 0,
+    distOutputDir: "",
+    originPluginOptions: userConfig,
+    remoteIpStrategy: userConfig === null || userConfig === void 0 ? void 0 : userConfig.remoteIpStrategy,
+    userConfig: userConfig || {},
+    fetchServerQuery: (_userConfig_fetchServerQuery = userConfig.fetchServerQuery) !== null && _userConfig_fetchServerQuery !== void 0 ? _userConfig_fetchServerQuery : void 0
+  };
+  return {
+    name: "@modern-js/plugin-module-federation",
+    setup: function() {
+      var _ref = _async_to_generator(function(api) {
+        var modernjsConfig;
+        return _ts_generator(this, function(_state) {
+          modernjsConfig = api.getConfig();
+          api.modifyBundlerChain(function(chain) {
+            var bundlerType = api.getAppContext().bundlerType === "rspack" ? "rspack" : "webpack";
+            var browserPluginOptions = internalModernPluginOptions.csrConfig;
+            var MFPlugin = bundlerType === "webpack" ? WebpackModuleFederationPlugin : RspackModuleFederationPlugin;
+            if (isWebTarget(chain.get("target"))) {
+              chain.plugin("plugin-module-federation").use(MFPlugin, [
+                browserPluginOptions
+              ]).init(function(Plugin, args) {
+                internalModernPluginOptions.browserPlugin = new Plugin(args[0]);
+                return internalModernPluginOptions.browserPlugin;
+              });
+            }
+            if (bundlerType === "webpack") {
+              var _modernjsConfig_source;
+              var enableAsyncEntry = (_modernjsConfig_source = modernjsConfig.source) === null || _modernjsConfig_source === void 0 ? void 0 : _modernjsConfig_source.enableAsyncEntry;
+              if (!enableAsyncEntry && browserPluginOptions.async !== false) {
+                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) || "");
+                  },
+                  excludeChunk: function(chunk) {
+                    return chunk.name === browserPluginOptions.name;
+                  }
+                };
+                chain.plugin("async-boundary-plugin").use(AsyncBoundaryPlugin, [
+                  asyncBoundaryPluginOptions
+                ]);
+              }
+            }
+          });
+          api._internalServerPlugins(function(param) {
+            var plugins = param.plugins;
+            plugins.push({
+              name: "@module-federation/modern-js/server"
+            });
+            return {
+              plugins
+            };
+          });
+          return [
+            2
+          ];
+        });
+      });
+      return function(api) {
+        return _ref.apply(this, arguments);
+      };
+    }(),
+    usePlugins: [
+      moduleFederationConfigPlugin(internalModernPluginOptions),
+      moduleFederationSSRPlugin(internalModernPluginOptions)
+    ]
+  };
+};
+var cli_default = moduleFederationPlugin;
+import { createModuleFederationConfig } from "@module-federation/enhanced";
+export {
+  createModuleFederationConfig,
+  cli_default as default,
+  moduleFederationPlugin
+};

package/dist/esm/cli/mfRuntimePlugins/auto-fetch-data.js

@@ -0,0 +1,74 @@
+import { getDataFetchInfo, initDataFetchMap, getDataFetchItem, getDataFetchMap, isCSROnly } from "../../utils";
+import logger from "../../logger";
+import { getDataFetchMapKey, isDataLoaderExpose, loadDataFetchModule } from "../../utils/dataFetch";
+import { MF_DATA_FETCH_TYPE, MF_DATA_FETCH_STATUS } from "../../constant";
+import { DATA_FETCH_CLIENT_SUFFIX } from "@module-federation/rsbuild-plugin/constant";
+var autoFetchData = function() {
+  return {
+    name: "auto-fetch-data-plugin",
+    beforeInit: function beforeInit(args) {
+      initDataFetchMap();
+      return args;
+    },
+    afterLoadSnapshot: function afterLoadSnapshot(args) {
+      var id = args.id, moduleInfo = args.moduleInfo, remoteSnapshot = args.remoteSnapshot, host = args.host;
+      if (typeof id === "string" && isDataLoaderExpose(id)) {
+        return args;
+      }
+      if (!remoteSnapshot || !id || !("modules" in remoteSnapshot)) {
+        return args;
+      }
+      var name = moduleInfo.name, alias = moduleInfo.alias;
+      var dataFetchInfo = getDataFetchInfo({
+        name,
+        alias,
+        id,
+        remoteSnapshot
+      });
+      if (!dataFetchInfo) {
+        return args;
+      }
+      var dataFetchId = dataFetchInfo.dataFetchId, dataFetchName = dataFetchInfo.dataFetchName;
+      var dataFetchMapKey = getDataFetchMapKey(dataFetchInfo, {
+        name: host.name,
+        version: host.options.version
+      });
+      logger.debug("======= auto fetch plugin dataFetchMapKey: ", dataFetchMapKey);
+      if (!dataFetchMapKey) {
+        return args;
+      }
+      var dataFetchItem = getDataFetchItem(dataFetchMapKey);
+      if (dataFetchItem) {
+        return args;
+      }
+      var dataFetchMap = getDataFetchMap();
+      var downgradeType = remoteSnapshot.modules.find(function(module) {
+        return module.moduleName === "".concat(dataFetchName).concat(DATA_FETCH_CLIENT_SUFFIX);
+      }) ? MF_DATA_FETCH_TYPE.FETCH_CLIENT : MF_DATA_FETCH_TYPE.FETCH_SERVER;
+      var finalDataFetchId = dataFetchId;
+      if (typeof window !== "undefined") {
+        finalDataFetchId = downgradeType === MF_DATA_FETCH_TYPE.FETCH_CLIENT ? "".concat(dataFetchId).concat(DATA_FETCH_CLIENT_SUFFIX) : dataFetchId;
+      }
+      var getDataFetchGetter = function() {
+        return loadDataFetchModule(host, finalDataFetchId);
+      };
+      var dataFetchFnItem = [
+        getDataFetchGetter,
+        downgradeType
+      ];
+      if (typeof window === "undefined" || isCSROnly()) {
+        dataFetchFnItem.push(getDataFetchGetter());
+      }
+      dataFetchMap[dataFetchMapKey] = [
+        dataFetchFnItem,
+        void 0,
+        MF_DATA_FETCH_STATUS.AWAIT
+      ];
+      return args;
+    }
+  };
+};
+var auto_fetch_data_default = autoFetchData;
+export {
+  auto_fetch_data_default as default
+};

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

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

package/dist/esm/cli/mfRuntimePlugins/resolve-entry-ipv4.js

@@ -0,0 +1,74 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { LOCALHOST } from "../../constant";
+var ipv4 = typeof FEDERATION_IPV4 !== "undefined" ? FEDERATION_IPV4 : "127.0.0.1";
+var remoteIpStrategy = typeof REMOTE_IP_STRATEGY !== "undefined" ? REMOTE_IP_STRATEGY : "inherit";
+function replaceObjectLocalhost(key, obj) {
+  if (remoteIpStrategy !== "ipv4") {
+    return;
+  }
+  if (!(key in obj)) {
+    return;
+  }
+  var remote = obj[key];
+  if (remote && typeof remote === "string" && remote.includes(LOCALHOST)) {
+    obj[key] = replaceLocalhost(remote);
+  }
+}
+function replaceLocalhost(url) {
+  return url.replace(LOCALHOST, ipv4);
+}
+var resolveEntryIpv4Plugin = function() {
+  return {
+    name: "resolve-entry-ipv4",
+    beforeRegisterRemote: function beforeRegisterRemote(args) {
+      var remote = args.remote;
+      replaceObjectLocalhost("entry", remote);
+      return args;
+    },
+    afterResolve: function afterResolve(args) {
+      return _async_to_generator(function() {
+        var remoteInfo;
+        return _ts_generator(this, function(_state) {
+          remoteInfo = args.remoteInfo;
+          replaceObjectLocalhost("entry", remoteInfo);
+          return [
+            2,
+            args
+          ];
+        });
+      })();
+    },
+    beforeLoadRemoteSnapshot: function beforeLoadRemoteSnapshot(args) {
+      var moduleInfo = args.moduleInfo;
+      if ("entry" in moduleInfo) {
+        replaceObjectLocalhost("entry", moduleInfo);
+        return args;
+      }
+      if ("version" in moduleInfo) {
+        replaceObjectLocalhost("version", moduleInfo);
+      }
+      return args;
+    },
+    loadRemoteSnapshot: function loadRemoteSnapshot(args) {
+      var remoteSnapshot = args.remoteSnapshot;
+      if ("publicPath" in remoteSnapshot) {
+        replaceObjectLocalhost("publicPath", remoteSnapshot);
+      }
+      if ("getPublicPath" in remoteSnapshot) {
+        replaceObjectLocalhost("getPublicPath", remoteSnapshot);
+      }
+      if (remoteSnapshot.remotesInfo) {
+        Object.keys(remoteSnapshot.remotesInfo).forEach(function(key) {
+          var remoteInfo = remoteSnapshot.remotesInfo[key];
+          replaceObjectLocalhost("matchedVersion", remoteInfo);
+        });
+      }
+      return args;
+    }
+  };
+};
+var resolve_entry_ipv4_default = resolveEntryIpv4Plugin;
+export {
+  resolve_entry_ipv4_default as default
+};

package/dist/esm/cli/mfRuntimePlugins/shared-strategy.js

@@ -0,0 +1,25 @@
+var sharedStrategy = function() {
+  return {
+    name: "shared-strategy-plugin",
+    beforeInit: function beforeInit(args) {
+      var userOptions = args.userOptions;
+      var shared = userOptions.shared;
+      if (shared) {
+        Object.keys(shared).forEach(function(sharedKey) {
+          var sharedConfigs = shared[sharedKey];
+          var arraySharedConfigs = Array.isArray(sharedConfigs) ? sharedConfigs : [
+            sharedConfigs
+          ];
+          arraySharedConfigs.forEach(function(s) {
+            s.strategy = "loaded-first";
+          });
+        });
+      }
+      return args;
+    }
+  };
+};
+var shared_strategy_default = sharedStrategy;
+export {
+  shared_strategy_default as default
+};

package/dist/esm/cli/server/data-fetch-server-plugin.js

@@ -0,0 +1,237 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import { DATA_FETCH_QUERY, MF_DATA_FETCH_STATUS } from "../../constant";
+import logger from "../../logger";
+import { getDataFetchMap } from "../../utils";
+import { fetchData, initDataFetchMap, loadDataFetchModule } from "../../utils/dataFetch";
+import { SEPARATOR, MANIFEST_EXT } from "@module-federation/sdk";
+function wrapSetTimeout(targetPromise) {
+  var delay = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 2e4, id = arguments.length > 2 ? arguments[2] : void 0;
+  if (targetPromise && typeof targetPromise.then === "function") {
+    return new Promise(function(resolve, reject) {
+      var timeoutId = setTimeout(function() {
+        logger.warn("Data fetch for ID ".concat(id, " timed out after 20 seconds."));
+        reject(new Error("Data fetch for ID ".concat(id, " timed out after 20 seconds")));
+      }, delay);
+      targetPromise.then(function(value) {
+        clearTimeout(timeoutId);
+        resolve(value);
+      }).catch(function(err) {
+        clearTimeout(timeoutId);
+        reject(err);
+      });
+    });
+  }
+}
+function addProtocol(url) {
+  if (url.startsWith("//")) {
+    return "https:" + url;
+  }
+  return url;
+}
+var getDecodeQuery = function(url, name) {
+  var res = url.searchParams.get(name);
+  if (!res) {
+    return null;
+  }
+  return decodeURIComponent(res);
+};
+var middleware = function() {
+  var _ref = _async_to_generator(function(ctx, next) {
+    var _globalThis___FEDERATION__, url, dataFetchId, params, remoteInfo, remoteInfoQuery, _dataFetchMap_dataFetchId, _dataFetchMap_dataFetchId1, dataFetchMap, fetchDataPromise, targetPromise, wrappedPromise, res, hostInstance, remoteEntry, remote, _hostInstance_snapshotHandler_getGlobalRemoteInfo, hostGlobalSnapshot, remoteSnapshot, dataFetchItem, callFetchDataPromise, wrappedPromise1, res1, remoteId, hostInstance1, dataFetchFn, data, e;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          try {
+            url = new URL(ctx.req.url);
+            dataFetchId = getDecodeQuery(url, DATA_FETCH_QUERY);
+            params = JSON.parse(getDecodeQuery(url, "params") || "{}");
+            remoteInfoQuery = getDecodeQuery(url, "remoteInfo");
+            remoteInfo = remoteInfoQuery ? JSON.parse(remoteInfoQuery) : null;
+          } catch (e2) {
+            logger.error("fetch data from server, error: ", e2);
+            return [
+              2,
+              next()
+            ];
+          }
+          if (!dataFetchId) {
+            return [
+              2,
+              next()
+            ];
+          }
+          logger.log("fetch data from server, dataFetchId: ", dataFetchId);
+          logger.debug("fetch data from server, moduleInfo: ", (_globalThis___FEDERATION__ = globalThis.__FEDERATION__) === null || _globalThis___FEDERATION__ === void 0 ? void 0 : _globalThis___FEDERATION__.moduleInfo);
+          _state.label = 1;
+        case 1:
+          _state.trys.push([
+            1,
+            9,
+            ,
+            10
+          ]);
+          dataFetchMap = getDataFetchMap();
+          if (!dataFetchMap) {
+            initDataFetchMap();
+          }
+          fetchDataPromise = (_dataFetchMap_dataFetchId = dataFetchMap[dataFetchId]) === null || _dataFetchMap_dataFetchId === void 0 ? void 0 : _dataFetchMap_dataFetchId[1];
+          logger.debug("fetch data from server, fetchDataPromise: ", fetchDataPromise);
+          if (!(fetchDataPromise && ((_dataFetchMap_dataFetchId1 = dataFetchMap[dataFetchId]) === null || _dataFetchMap_dataFetchId1 === void 0 ? void 0 : _dataFetchMap_dataFetchId1[2]) !== MF_DATA_FETCH_STATUS.ERROR))
+            return [
+              3,
+              4
+            ];
+          targetPromise = fetchDataPromise[0];
+          wrappedPromise = wrapSetTimeout(targetPromise, 2e4, dataFetchId);
+          if (!wrappedPromise)
+            return [
+              3,
+              3
+            ];
+          return [
+            4,
+            wrappedPromise
+          ];
+        case 2:
+          res = _state.sent();
+          logger.log("fetch data from server, fetchDataPromise res: ", res);
+          return [
+            2,
+            ctx.json(res)
+          ];
+        case 3:
+          logger.error("Expected a Promise from fetchDataPromise[0] for dataFetchId ".concat(dataFetchId, ", but received:"), targetPromise, "Will try call new dataFetch again...");
+          _state.label = 4;
+        case 4:
+          if (remoteInfo) {
+            try {
+              hostInstance = globalThis.__FEDERATION__.__INSTANCES__[0];
+              remoteEntry = "".concat(addProtocol(remoteInfo.ssrPublicPath) + remoteInfo.ssrRemoteEntry);
+              if (!hostInstance) {
+                throw new Error("host instance not found!");
+              }
+              remote = hostInstance.options.remotes.find(function(remote2) {
+                return remote2.name === remoteInfo.name;
+              });
+              logger.debug("find remote: ", JSON.stringify(remote));
+              if (!remote) {
+                hostInstance.registerRemotes([
+                  {
+                    name: remoteInfo.name,
+                    entry: remoteEntry,
+                    entryGlobalName: remoteInfo.globalName
+                  }
+                ]);
+              } else if (!("entry" in remote) || !remote.entry.includes(MANIFEST_EXT)) {
+                _hostInstance_snapshotHandler_getGlobalRemoteInfo = hostInstance.snapshotHandler.getGlobalRemoteInfo(remoteInfo), hostGlobalSnapshot = _hostInstance_snapshotHandler_getGlobalRemoteInfo.hostGlobalSnapshot, remoteSnapshot = _hostInstance_snapshotHandler_getGlobalRemoteInfo.remoteSnapshot;
+                logger.debug("find hostGlobalSnapshot: ", JSON.stringify(hostGlobalSnapshot));
+                logger.debug("find remoteSnapshot: ", JSON.stringify(remoteSnapshot));
+                if (!hostGlobalSnapshot || !remoteSnapshot) {
+                  if ("version" in remote) {
+                    delete remote.version;
+                  }
+                  remote.entry = remoteEntry;
+                  remote.entryGlobalName = remoteInfo.globalName;
+                }
+              }
+            } catch (e2) {
+              ctx.status(500);
+              return [
+                2,
+                ctx.text("failed to fetch ".concat(remoteInfo.name, " data, error:\n ").concat(e2))
+              ];
+            }
+          }
+          dataFetchItem = dataFetchMap[dataFetchId];
+          logger.debug("fetch data from server, dataFetchItem: ", dataFetchItem);
+          if (!dataFetchItem)
+            return [
+              3,
+              6
+            ];
+          callFetchDataPromise = fetchData(dataFetchId, _object_spread_props(_object_spread({}, params), {
+            isDowngrade: !remoteInfo
+          }));
+          wrappedPromise1 = wrapSetTimeout(callFetchDataPromise, 2e4, dataFetchId);
+          if (!wrappedPromise1)
+            return [
+              3,
+              6
+            ];
+          return [
+            4,
+            wrappedPromise1
+          ];
+        case 5:
+          res1 = _state.sent();
+          logger.log("fetch data from server, dataFetchItem res: ", res1);
+          return [
+            2,
+            ctx.json(res1)
+          ];
+        case 6:
+          remoteId = dataFetchId.split(SEPARATOR)[0];
+          hostInstance1 = globalThis.__FEDERATION__.__INSTANCES__[0];
+          if (!hostInstance1) {
+            throw new Error("host instance not found!");
+          }
+          return [
+            4,
+            loadDataFetchModule(hostInstance1, remoteId)
+          ];
+        case 7:
+          dataFetchFn = _state.sent();
+          return [
+            4,
+            dataFetchFn(_object_spread_props(_object_spread({}, params), {
+              isDowngrade: !remoteInfo
+            }))
+          ];
+        case 8:
+          data = _state.sent();
+          logger.log("fetch data from server, loadDataFetchModule res: ", data);
+          return [
+            2,
+            ctx.json(data)
+          ];
+        case 9:
+          e = _state.sent();
+          logger.error("server plugin data fetch error: ", e);
+          ctx.status(500);
+          return [
+            2,
+            ctx.text("failed to fetch ".concat(remoteInfo.name, " data, error:\n ").concat(e))
+          ];
+        case 10:
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function middleware2(ctx, next) {
+    return _ref.apply(this, arguments);
+  };
+}();
+var dataFetchServePlugin = function() {
+  return {
+    name: "mf-data-fetch-server-plugin",
+    setup: function(api) {
+      api.onPrepare(function() {
+        var middlewares = api.getServerContext().middlewares;
+        middlewares.push({
+          name: "module-federation-serve-manifest",
+          // @ts-ignore type error
+          handler: middleware
+        });
+      });
+    }
+  };
+};
+var data_fetch_server_plugin_default = dataFetchServePlugin;
+export {
+  data_fetch_server_plugin_default as default
+};