@module-federation/metro 0.0.0-next-20250827124348

package/dist/commands/utils/save-bundle-and-map.js

@@ -0,0 +1,77 @@
+"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, 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 ('undefined' != 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__, {
+    saveBundleAndMap: ()=>saveBundleAndMap
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_util_namespaceObject = require("node:util");
+var external_node_util_default = /*#__PURE__*/ __webpack_require__.n(external_node_util_namespaceObject);
+const relativizeSourceMap_namespaceObject = require("metro/src/lib/relativizeSourceMap");
+var relativizeSourceMap_default = /*#__PURE__*/ __webpack_require__.n(relativizeSourceMap_namespaceObject);
+function relativizeSerializedMap(map, sourceMapSourcesRoot) {
+    const sourceMap = JSON.parse(map);
+    relativizeSourceMap_default()(sourceMap, sourceMapSourcesRoot);
+    return JSON.stringify(sourceMap);
+}
+async function saveBundleAndMap(bundle, options, log) {
+    const { bundleOutput, bundleEncoding: encoding, sourcemapOutput, sourcemapSourcesRoot } = options;
+    const writeFns = [];
+    writeFns.push(async ()=>{
+        log(`Writing bundle output to:\n${external_node_util_default().styleText('dim', bundleOutput)}`);
+        await external_node_fs_namespaceObject.promises.writeFile(bundleOutput, bundle.code, encoding);
+        log('Done writing bundle output');
+    });
+    if (sourcemapOutput) {
+        let { map } = bundle;
+        if (null != sourcemapSourcesRoot) {
+            log('Start relativating source map');
+            map = relativizeSerializedMap(map, sourcemapSourcesRoot);
+            log('Finished relativating');
+        }
+        writeFns.push(async ()=>{
+            log(`Writing sourcemap output to:\n${external_node_util_default().styleText('dim', sourcemapOutput)}`);
+            await external_node_fs_namespaceObject.promises.writeFile(sourcemapOutput, map);
+            log('Done writing sourcemap output');
+        });
+    }
+    await Promise.all(writeFns.map((cb)=>cb()));
+}
+exports.saveBundleAndMap = __webpack_exports__.saveBundleAndMap;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "saveBundleAndMap"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/utils/save-bundle-and-map.mjs

@@ -0,0 +1,57 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { promises } from "node:fs";
+import node_util from "node:util";
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
+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 = (exports, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) Object.defineProperty(exports, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+const relativizeSourceMap_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("metro/src/lib/relativizeSourceMap");
+var relativizeSourceMap_default = /*#__PURE__*/ __webpack_require__.n(relativizeSourceMap_namespaceObject);
+function relativizeSerializedMap(map, sourceMapSourcesRoot) {
+    const sourceMap = JSON.parse(map);
+    relativizeSourceMap_default()(sourceMap, sourceMapSourcesRoot);
+    return JSON.stringify(sourceMap);
+}
+async function saveBundleAndMap(bundle, options, log) {
+    const { bundleOutput, bundleEncoding: encoding, sourcemapOutput, sourcemapSourcesRoot } = options;
+    const writeFns = [];
+    writeFns.push(async ()=>{
+        log(`Writing bundle output to:\n${node_util.styleText('dim', bundleOutput)}`);
+        await promises.writeFile(bundleOutput, bundle.code, encoding);
+        log('Done writing bundle output');
+    });
+    if (sourcemapOutput) {
+        let { map } = bundle;
+        if (null != sourcemapSourcesRoot) {
+            log('Start relativating source map');
+            map = relativizeSerializedMap(map, sourcemapSourcesRoot);
+            log('Finished relativating');
+        }
+        writeFns.push(async ()=>{
+            log(`Writing sourcemap output to:\n${node_util.styleText('dim', sourcemapOutput)}`);
+            await promises.writeFile(sourcemapOutput, map);
+            log('Done writing sourcemap output');
+        });
+    }
+    await Promise.all(writeFns.map((cb)=>cb()));
+}
+export { saveBundleAndMap };

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { withModuleFederation } from './plugin';
+export { updateManifest } from './plugin/manifest';

package/dist/index.js

@@ -0,0 +1,40 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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 ('undefined' != 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__, {
+    withModuleFederation: ()=>index_js_namespaceObject.withModuleFederation,
+    updateManifest: ()=>manifest_js_namespaceObject.updateManifest
+});
+const index_js_namespaceObject = require("./plugin/index.js");
+const manifest_js_namespaceObject = require("./plugin/manifest.js");
+exports.updateManifest = __webpack_exports__.updateManifest;
+exports.withModuleFederation = __webpack_exports__.withModuleFederation;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "updateManifest",
+    "withModuleFederation"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.mjs

@@ -0,0 +1,5 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { withModuleFederation } from "./plugin/index.mjs";
+import { updateManifest } from "./plugin/manifest.mjs";
+export { updateManifest, withModuleFederation };

package/dist/modules/HMRClient.ts

@@ -0,0 +1,31 @@
+import HMRClient from 'react-native/Libraries/Utilities/HMRClient';
+
+let hmrOrigin: string | null = null;
+
+const originalRegisterBundle = HMRClient.registerBundle;
+const originalSetup = HMRClient.setup;
+
+HMRClient.setup = (
+  platform: string,
+  bundleEntry: string,
+  host: string,
+  port: number | string,
+  isEnabled: boolean,
+  scheme = 'http',
+) => {
+  const serverHost = port !== null && port !== '' ? `${host}:${port}` : host;
+  hmrOrigin = `${scheme}://${serverHost}`;
+
+  return originalSetup(platform, bundleEntry, host, port, isEnabled, scheme);
+};
+
+HMRClient.registerBundle = (requestUrl: string) => {
+  // only process registerBundle calls from the same origin
+  if (!requestUrl.includes(hmrOrigin as string)) {
+    return;
+  }
+
+  return originalRegisterBundle(requestUrl);
+};
+
+export default HMRClient;

package/dist/modules/HMRClientShim.ts

@@ -0,0 +1 @@
+export { default } from 'react-native/Libraries/Utilities/HMRClientProdShim';

package/dist/modules/asyncRequire.ts

@@ -0,0 +1,134 @@
+// join two paths
+// e.g. /a/b/ + /c/d -> /a/b/c/d
+function joinComponents(prefix: string, suffix: string) {
+  return prefix.replace(/\/+$/, '') + '/' + suffix.replace(/^\/+/, '');
+}
+
+// get the public path from the url
+// e.g. http://host:8081/a/b.bundle -> http://host:8081/a
+function getPublicPath(url?: string) {
+  return url?.split('/').slice(0, -1).join('/');
+}
+
+function isUrl(url: string) {
+  return url.match(/^https?:\/\//);
+}
+
+// get bundle id from the bundle path
+// e.g. /a/b.bundle?platform=ios -> a/b
+// e.g. http://host:8081/a/b.bundle -> a/b
+function getBundleId(bundlePath: string, publicPath: string) {
+  let path = bundlePath;
+  // remove the public path if it's an url
+  if (isUrl(path)) {
+    path = path.replace(publicPath, '');
+  }
+  // remove the leading slash
+  if (path.startsWith('/')) {
+    path = path.slice(1);
+  }
+  // remove the query params
+  path = path.split('?')[0];
+  // remove the bundle extension
+  return path.replace('.bundle', '');
+}
+
+function isSameOrigin(url: string, originPublicPath?: string) {
+  // if it's not a fully qualified url, we assume it's the same origin
+  if (!isUrl(url)) {
+    return true;
+  }
+  return !!originPublicPath && url.startsWith(originPublicPath);
+}
+
+// prefix the bundle path with the public path
+// e.g. /a/b.bundle -> http://host:8081/a/b.bundle
+function getBundlePath(bundlePath: string, bundleOrigin?: string) {
+  // don't modify the path in development
+  if (process.env.NODE_ENV !== 'production') {
+    return bundlePath;
+  }
+  // don't modify fully qualified urls
+  // e.g. when loading container modules
+  if (isUrl(bundlePath)) {
+    return bundlePath;
+  }
+  // don't modify the path if we don't know the bundle origin
+  // e.g. when loading host split bundles
+  if (!bundleOrigin) {
+    return bundlePath;
+  }
+  return joinComponents(bundleOrigin, bundlePath);
+}
+
+function buildLoadBundleAsyncWrapper() {
+  const registry = require('mf:remote-module-registry');
+
+  const __loadBundleAsync =
+    // @ts-expect-error dynamic key access on global object
+    globalThis[`${__METRO_GLOBAL_PREFIX__ ?? ''}__loadBundleAsync`];
+
+  const loadBundleAsync =
+    __loadBundleAsync as typeof globalThis.__loadBundleAsync;
+
+  return async (originalBundlePath: string) => {
+    const scope = globalThis.__FEDERATION__.__NATIVE__[__METRO_GLOBAL_PREFIX__];
+
+    // entry is always in the root directory of assets associated with remote
+    // based on that, we extract the public path from the origin URL
+    // e.g. http://example.com/a/b/c/mf-manfiest.json -> http://example.com/a/b/c
+    const publicPath = getPublicPath(scope.origin);
+    const bundlePath = getBundlePath(originalBundlePath, publicPath);
+
+    // ../../node_modules/ -> ..%2F..%2Fnode_modules/ so that it's not automatically sanitized
+    const encodedBundlePath = bundlePath.replaceAll('../', '..%2F');
+
+    const result = await loadBundleAsync(encodedBundlePath);
+
+    // when the origin is not the same, it means we are loading a remote container
+    // we can return early since dependencies are processed differently for entry bundles
+    if (!isSameOrigin(bundlePath, publicPath)) {
+      return result;
+    }
+
+    // at this point the code in the bundle has been evaluated
+    // but not yet executed through metroRequire
+    // note: at this point, public path is always defined
+    const bundleId = getBundleId(bundlePath, publicPath!);
+    const shared = scope.deps.shared[bundleId];
+    const remotes = scope.deps.remotes[bundleId];
+
+    const promises = [];
+    if (shared && shared.length > 0) {
+      // load shared used synchronously in the bundle
+      promises.push(...shared.map(registry.loadSharedToRegistry));
+    }
+    if (remotes && remotes.length > 0) {
+      // load remotes used synchronously in the bundle
+      promises.push(...remotes.map(registry.loadRemoteToRegistry));
+    }
+
+    await Promise.all(promises);
+
+    return result;
+  };
+}
+
+// load expo async require if outside expo
+if (!process.env.EXPO_OS) {
+  // @expo/metro-runtime/src/async-require/fetchAsync.native.ts requires
+  // process.env.EXPO_OS to be set but since expo is optional, we set it
+  // to an empty string as a fallback to prevent reference errors
+  process.env.EXPO_OS = '';
+
+  const {
+    buildAsyncRequire,
+  } = require('@expo/metro-runtime/src/async-require/buildAsyncRequire');
+
+  // @ts-expect-error dynamic key access on global object
+  global[`${__METRO_GLOBAL_PREFIX__}__loadBundleAsync`] = buildAsyncRequire();
+}
+
+// @ts-expect-error dynamic key access on global object
+global[`${__METRO_GLOBAL_PREFIX__}__loadBundleAsync`] =
+  buildLoadBundleAsyncWrapper();

package/dist/modules/asyncStartup.tsx

@@ -0,0 +1,38 @@
+import type { Federation } from '@module-federation/runtime';
+import React from 'react';
+
+declare global {
+  var __DEV__: boolean;
+  var __METRO_GLOBAL_PREFIX__: string;
+  var __FUSEBOX_HAS_FULL_CONSOLE_SUPPORT__: boolean;
+  var __loadBundleAsync: (entry: string) => Promise<void>;
+  var __FEDERATION__: Federation;
+}
+
+type LazyComponent = { default: React.ComponentType };
+
+function getFallbackComponent(lazyFallbackFn?: () => LazyComponent) {
+  if (!lazyFallbackFn) return () => null;
+  const fallback = lazyFallbackFn();
+  return fallback.default;
+}
+
+export function withAsyncStartup(
+  lazyAppFn: () => LazyComponent,
+  lazyFallbackFn?: () => LazyComponent,
+): () => () => React.JSX.Element {
+  const AppComponent = React.lazy(async () => {
+    await globalThis.__FEDERATION__.__NATIVE__[__METRO_GLOBAL_PREFIX__].init;
+    return lazyAppFn();
+  });
+
+  const FallbackComponent = getFallbackComponent(lazyFallbackFn);
+
+  return () => () => {
+    return (
+      <React.Suspense fallback={<FallbackComponent />}>
+        <AppComponent />
+      </React.Suspense>
+    );
+  };
+}

package/dist/modules/getDevServer.ts

@@ -0,0 +1,15 @@
+export default function getDevServer() {
+  const scriptUrl =
+    globalThis.__FEDERATION__.__NATIVE__[__METRO_GLOBAL_PREFIX__].origin;
+
+  if (!scriptUrl) {
+    throw new Error(
+      `Cannot determine dev server URL for ${__METRO_GLOBAL_PREFIX__} remote`,
+    );
+  }
+
+  return {
+    url: scriptUrl.match(/^https?:\/\/.*?\//)![0],
+    fullBundleUrl: scriptUrl,
+  };
+}

package/dist/modules/metroCorePlugin.ts

@@ -0,0 +1,83 @@
+import type {
+  Federation,
+  FederationRuntimePlugin,
+} from '@module-federation/runtime';
+
+declare global {
+  var __DEV__: boolean;
+  var __METRO_GLOBAL_PREFIX__: string;
+  var __FUSEBOX_HAS_FULL_CONSOLE_SUPPORT__: boolean;
+  var __loadBundleAsync: (entry: string) => Promise<void>;
+  var __FEDERATION__: Federation;
+}
+
+const getQueryParams = () => {
+  const isFuseboxEnabled = !!globalThis.__FUSEBOX_HAS_FULL_CONSOLE_SUPPORT__;
+  const queryParams: Record<string, string> = {
+    platform: require('react-native').Platform.OS,
+    dev: 'true',
+    lazy: 'true',
+    minify: 'false',
+    runModule: 'true',
+    modulesOnly: 'false',
+  };
+
+  if (isFuseboxEnabled) {
+    queryParams.excludeSource = 'true';
+    queryParams.sourcePaths = 'url-server';
+  }
+
+  return new URLSearchParams(queryParams);
+};
+
+const buildUrlForEntryBundle = (entry: string) => {
+  if (__DEV__) {
+    return `${entry}?${getQueryParams().toString()}`;
+  }
+  return entry;
+};
+
+const MetroCorePlugin: () => FederationRuntimePlugin = () => ({
+  name: 'metro-core-plugin',
+  loadEntry: async ({ remoteInfo }) => {
+    const { entry, entryGlobalName } = remoteInfo;
+
+    const __loadBundleAsync =
+      // @ts-expect-error dynamic key access on global object
+      globalThis[`${__METRO_GLOBAL_PREFIX__ ?? ''}__loadBundleAsync`];
+
+    const loadBundleAsync =
+      __loadBundleAsync as typeof globalThis.__loadBundleAsync;
+
+    if (!loadBundleAsync) {
+      throw new Error('loadBundleAsync is not defined');
+    }
+
+    try {
+      const entryUrl = buildUrlForEntryBundle(entry);
+      await loadBundleAsync(entryUrl);
+
+      if (!globalThis.__FEDERATION__.__NATIVE__[entryGlobalName]) {
+        throw new Error(`Remote entry ${entryGlobalName} failed to register.`);
+      }
+
+      globalThis.__FEDERATION__.__NATIVE__[entryGlobalName].origin = entryUrl;
+
+      return globalThis.__FEDERATION__.__NATIVE__[entryGlobalName].exports;
+    } catch (error) {
+      throw new Error(
+        `Failed to load remote entry: ${entryGlobalName}. Reason: ${error}`,
+      );
+    }
+  },
+  generatePreloadAssets: async () => {
+    // noop for compatibility
+    return Promise.resolve({
+      cssAssets: [],
+      jsAssetsWithoutEntry: [],
+      entryAssets: [],
+    });
+  },
+});
+
+export default MetroCorePlugin;

package/dist/plugin/babel-transformer.d.ts

@@ -0,0 +1,11 @@
+import type { ModuleFederationConfigNormalized } from '../types';
+interface CreateBabelTransformerOptions {
+    blacklistedPaths: string[];
+    federationConfig: ModuleFederationConfigNormalized;
+    originalBabelTransformerPath: string;
+    tmpDirPath: string;
+    enableInitializeCorePatching: boolean;
+    enableRuntimeRequirePatching: boolean;
+}
+export declare function createBabelTransformer({ blacklistedPaths, federationConfig, originalBabelTransformerPath, tmpDirPath, enableInitializeCorePatching, enableRuntimeRequirePatching, }: CreateBabelTransformerOptions): string;
+export {};

package/dist/plugin/babel-transformer.js

@@ -0,0 +1,68 @@
+"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, 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 ('undefined' != 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__, {
+    createBabelTransformer: ()=>createBabelTransformer
+});
+const external_node_fs_namespaceObject = require("node:fs");
+var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+function createBabelTransformer({ blacklistedPaths, federationConfig, originalBabelTransformerPath, tmpDirPath, enableInitializeCorePatching, enableRuntimeRequirePatching }) {
+    const outputPath = external_node_path_default().join(tmpDirPath, 'babel-transformer.js');
+    const templatePath = require.resolve('../babel/transformer.js');
+    const transformerTemplate = external_node_fs_default().readFileSync(templatePath, 'utf-8');
+    const plugins = [
+        [
+            '@module-federation/metro/babel-plugin',
+            {
+                blacklistedPaths,
+                remotes: federationConfig.remotes,
+                shared: federationConfig.shared
+            }
+        ],
+        enableInitializeCorePatching ? '@module-federation/metro/babel-plugin/patch-initialize-core' : void 0,
+        enableRuntimeRequirePatching ? '@module-federation/metro/babel-plugin/patch-require' : void 0
+    ].filter(Boolean);
+    const babelTransformer = transformerTemplate.replaceAll('__BABEL_TRANSFORMER_PATH__', originalBabelTransformerPath).replaceAll('__BABEL_PLUGINS__', JSON.stringify(plugins));
+    external_node_fs_default().writeFileSync(outputPath, babelTransformer, 'utf-8');
+    return outputPath;
+}
+exports.createBabelTransformer = __webpack_exports__.createBabelTransformer;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createBabelTransformer"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/plugin/babel-transformer.mjs

@@ -0,0 +1,25 @@
+import __rslib_shim_module__ from 'module';
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(import.meta.url);
+import node_fs from "node:fs";
+import node_path from "node:path";
+function createBabelTransformer({ blacklistedPaths, federationConfig, originalBabelTransformerPath, tmpDirPath, enableInitializeCorePatching, enableRuntimeRequirePatching }) {
+    const outputPath = node_path.join(tmpDirPath, 'babel-transformer.js');
+    const templatePath = require.resolve('../babel/transformer.js');
+    const transformerTemplate = node_fs.readFileSync(templatePath, 'utf-8');
+    const plugins = [
+        [
+            '@module-federation/metro/babel-plugin',
+            {
+                blacklistedPaths,
+                remotes: federationConfig.remotes,
+                shared: federationConfig.shared
+            }
+        ],
+        enableInitializeCorePatching ? '@module-federation/metro/babel-plugin/patch-initialize-core' : void 0,
+        enableRuntimeRequirePatching ? '@module-federation/metro/babel-plugin/patch-require' : void 0
+    ].filter(Boolean);
+    const babelTransformer = transformerTemplate.replaceAll('__BABEL_TRANSFORMER_PATH__', originalBabelTransformerPath).replaceAll('__BABEL_PLUGINS__', JSON.stringify(plugins));
+    node_fs.writeFileSync(outputPath, babelTransformer, 'utf-8');
+    return outputPath;
+}
+export { createBabelTransformer };

package/dist/plugin/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const INIT_HOST = "mf:init-host";
+export declare const ASYNC_REQUIRE = "mf:async-require";
+export declare const REMOTE_MODULE_REGISTRY = "mf:remote-module-registry";
+export declare const REMOTE_HMR_SETUP = "mf:remote-hmr";
+export declare const DEFAULT_ENTRY_FILENAME = "remoteEntry.bundle";
+export declare const GET_DEV_SERVER_REGEX: RegExp;
+export declare const HMR_CLIENT_REGEX: RegExp;
+export declare const TMP_DIR_NAME = ".mf-metro";
+export declare const MANIFEST_FILENAME = "mf-manifest.json";