@module-federation/metro 0.0.0-docs-remove-invalid-lark-link-20251205062649

package/dist/commands/bundle-remote/types.d.ts

@@ -0,0 +1,16 @@
+export type BundleFederatedRemoteArgs = {
+    entryFile: string;
+    platform: string;
+    dev: boolean;
+    minify?: boolean;
+    bundleEncoding?: 'utf8' | 'utf16le' | 'ascii';
+    maxWorkers?: string;
+    sourcemapOutput?: string;
+    sourcemapSourcesRoot?: string;
+    sourcemapUseAbsolutePath?: boolean;
+    assetsDest?: string;
+    assetCatalogDest?: string;
+    resetCache?: boolean;
+    config?: string;
+    output?: string;
+};

package/dist/commands/bundle-remote/types.js

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

package/dist/commands/bundle-remote/types.mjs

@@ -0,0 +1,2 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;

package/dist/commands/index.d.ts

@@ -0,0 +1,48 @@
+import bundleFederatedHost, { bundleFederatedHostOptions } from './bundle-host';
+import bundleFederatedRemote, { bundleFederatedRemoteOptions } from './bundle-remote';
+import loadMetroConfig from './utils/load-metro-config';
+export { bundleFederatedHost, bundleFederatedHostOptions, bundleFederatedRemote, bundleFederatedRemoteOptions, loadMetroConfig, };
+declare const _default: {
+    bundleFederatedHost: typeof bundleFederatedHost;
+    bundleFederatedHostOptions: {
+        name: string;
+        description: string;
+    }[];
+    bundleFederatedRemote: typeof bundleFederatedRemote;
+    bundleFederatedRemoteOptions: ({
+        name: string;
+        description: string;
+        default: string;
+        parse?: undefined;
+    } | {
+        name: string;
+        description: string;
+        parse: (val: string) => boolean;
+        default: boolean;
+    } | {
+        name: string;
+        description: string;
+        parse: (val: string) => boolean;
+        default?: undefined;
+    } | {
+        name: string;
+        description: string;
+        default?: undefined;
+        parse?: undefined;
+    } | {
+        name: string;
+        description: string;
+        default: boolean;
+        parse?: undefined;
+    } | {
+        name: string;
+        description: string;
+        parse: (val: string) => string;
+        default?: undefined;
+    })[];
+    loadMetroConfig: typeof loadMetroConfig;
+};
+export default _default;
+export type { BundleFederatedHostArgs } from './bundle-host/types';
+export type { BundleFederatedRemoteArgs } from './bundle-remote/types';
+export type { Config } from './types';

package/dist/commands/index.js

@@ -0,0 +1,72 @@
+"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__, {
+    bundleFederatedHost: ()=>index_js_default(),
+    bundleFederatedHostOptions: ()=>index_js_namespaceObject.bundleFederatedHostOptions,
+    bundleFederatedRemoteOptions: ()=>external_bundle_remote_index_js_namespaceObject.bundleFederatedRemoteOptions,
+    default: ()=>commands,
+    loadMetroConfig: ()=>load_metro_config_js_default(),
+    bundleFederatedRemote: ()=>external_bundle_remote_index_js_default()
+});
+const index_js_namespaceObject = require("./bundle-host/index.js");
+var index_js_default = /*#__PURE__*/ __webpack_require__.n(index_js_namespaceObject);
+const external_bundle_remote_index_js_namespaceObject = require("./bundle-remote/index.js");
+var external_bundle_remote_index_js_default = /*#__PURE__*/ __webpack_require__.n(external_bundle_remote_index_js_namespaceObject);
+const load_metro_config_js_namespaceObject = require("./utils/load-metro-config.js");
+var load_metro_config_js_default = /*#__PURE__*/ __webpack_require__.n(load_metro_config_js_namespaceObject);
+const commands = {
+    bundleFederatedHost: index_js_default(),
+    bundleFederatedHostOptions: index_js_namespaceObject.bundleFederatedHostOptions,
+    bundleFederatedRemote: external_bundle_remote_index_js_default(),
+    bundleFederatedRemoteOptions: external_bundle_remote_index_js_namespaceObject.bundleFederatedRemoteOptions,
+    loadMetroConfig: load_metro_config_js_default()
+};
+exports.bundleFederatedHost = __webpack_exports__.bundleFederatedHost;
+exports.bundleFederatedHostOptions = __webpack_exports__.bundleFederatedHostOptions;
+exports.bundleFederatedRemote = __webpack_exports__.bundleFederatedRemote;
+exports.bundleFederatedRemoteOptions = __webpack_exports__.bundleFederatedRemoteOptions;
+exports["default"] = __webpack_exports__["default"];
+exports.loadMetroConfig = __webpack_exports__.loadMetroConfig;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "bundleFederatedHost",
+    "bundleFederatedHostOptions",
+    "bundleFederatedRemote",
+    "bundleFederatedRemoteOptions",
+    "default",
+    "loadMetroConfig"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/index.mjs

@@ -0,0 +1,13 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import bundle_host, { bundleFederatedHostOptions } from "./bundle-host/index.mjs";
+import bundle_remote, { bundleFederatedRemoteOptions } from "./bundle-remote/index.mjs";
+import load_metro_config from "./utils/load-metro-config.mjs";
+const commands = {
+    bundleFederatedHost: bundle_host,
+    bundleFederatedHostOptions: bundleFederatedHostOptions,
+    bundleFederatedRemote: bundle_remote,
+    bundleFederatedRemoteOptions: bundleFederatedRemoteOptions,
+    loadMetroConfig: load_metro_config
+};
+export { bundle_host as bundleFederatedHost, bundleFederatedHostOptions, bundle_remote as bundleFederatedRemote, bundleFederatedRemoteOptions, commands as default, load_metro_config as loadMetroConfig };

package/dist/commands/types.d.ts

@@ -0,0 +1,14 @@
+export interface Config {
+    root: string;
+    platforms: Record<string, object>;
+    reactNativePath: string;
+    logger?: Logger;
+}
+export interface Logger {
+    success: (...messages: Array<unknown>) => void;
+    info: (...messages: Array<unknown>) => void;
+    warn: (...messages: Array<unknown>) => void;
+    error: (...messages: Array<unknown>) => void;
+    debug: (...messages: Array<unknown>) => void;
+    log: (...messages: Array<unknown>) => void;
+}

package/dist/commands/types.js

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

package/dist/commands/types.mjs

@@ -0,0 +1,2 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;

package/dist/commands/utils/create-module-path-remapper.d.ts

@@ -0,0 +1,7 @@
+import type { Resolution } from 'metro-resolver';
+export declare function createModulePathRemapper(): {
+    addMapping(originalPath: string, overridePath: string): void;
+    removeMapping(originalPath: string): void;
+    remap(resolved: Resolution): Resolution;
+    reverse(overridePath: string): string;
+};

package/dist/commands/utils/create-module-path-remapper.js

@@ -0,0 +1,64 @@
+"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__, {
+    createModulePathRemapper: ()=>createModulePathRemapper
+});
+function createModulePathRemapper() {
+    const mappings = new Map();
+    const reverseMappings = new Map();
+    return {
+        addMapping (originalPath, overridePath) {
+            mappings.set(originalPath, overridePath);
+            reverseMappings.set(overridePath, originalPath);
+        },
+        removeMapping (originalPath) {
+            const overridePath = mappings.get(originalPath);
+            if (!overridePath) return;
+            mappings.delete(originalPath);
+            reverseMappings.delete(overridePath);
+        },
+        remap (resolved) {
+            if (!('filePath' in resolved)) return resolved;
+            if (!mappings.has(resolved.filePath)) return resolved;
+            const overridePath = mappings.get(resolved.filePath);
+            return {
+                filePath: overridePath,
+                type: resolved.type
+            };
+        },
+        reverse (overridePath) {
+            if (!reverseMappings.has(overridePath)) return overridePath;
+            return reverseMappings.get(overridePath);
+        }
+    };
+}
+exports.createModulePathRemapper = __webpack_exports__.createModulePathRemapper;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createModulePathRemapper"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/utils/create-module-path-remapper.mjs

@@ -0,0 +1,32 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+function createModulePathRemapper() {
+    const mappings = new Map();
+    const reverseMappings = new Map();
+    return {
+        addMapping (originalPath, overridePath) {
+            mappings.set(originalPath, overridePath);
+            reverseMappings.set(overridePath, originalPath);
+        },
+        removeMapping (originalPath) {
+            const overridePath = mappings.get(originalPath);
+            if (!overridePath) return;
+            mappings.delete(originalPath);
+            reverseMappings.delete(overridePath);
+        },
+        remap (resolved) {
+            if (!('filePath' in resolved)) return resolved;
+            if (!mappings.has(resolved.filePath)) return resolved;
+            const overridePath = mappings.get(resolved.filePath);
+            return {
+                filePath: overridePath,
+                type: resolved.type
+            };
+        },
+        reverse (overridePath) {
+            if (!reverseMappings.has(overridePath)) return overridePath;
+            return reverseMappings.get(overridePath);
+        }
+    };
+}
+export { createModulePathRemapper };

package/dist/commands/utils/create-resolver.d.ts

@@ -0,0 +1,20 @@
+import type Server from 'metro/src/Server';
+/**
+ * Creates a resolver utility that mirrors Metro's bundling resolution behavior.
+ * This utility exposes Metro's internal resolver to the command context,
+ * allowing commands to resolve module paths exactly as Metro would during bundling.
+ * The resolver maintains consistency with Metro's resolution strategy,
+ * including platform-specific resolution and dependency graph traversal.
+ */
+/**
+ * Creates a resolver that matches Metro's bundling resolution behavior
+ * @param server - The Metro server instance to use for resolution
+ * @param platform - The target platform for resolution (e.g., 'ios', 'android', null for default)
+ * @returns The resolver object with a resolve method that takes source and target paths
+ */
+export declare function createResolver(server: Server, platform: string | null): Promise<{
+    resolve: ({ from, to }: {
+        from: string;
+        to: string;
+    }) => string;
+}>;

package/dist/commands/utils/create-resolver.js

@@ -0,0 +1,57 @@
+"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__, {
+    createResolver: ()=>createResolver
+});
+async function createResolver(server, platform) {
+    const bundler = server.getBundler().getBundler();
+    const depGraph = await bundler.getDependencyGraph();
+    const resolve = ({ from, to })=>{
+        const config = {
+            name: to,
+            data: {
+                asyncType: null,
+                key: to,
+                locs: []
+            }
+        };
+        const options = {
+            assumeFlatNodeModules: false
+        };
+        const res = depGraph.resolveDependency(from, config, platform, {}, options);
+        return res.filePath;
+    };
+    return {
+        resolve
+    };
+}
+exports.createResolver = __webpack_exports__.createResolver;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "createResolver"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/utils/create-resolver.mjs

@@ -0,0 +1,25 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+async function createResolver(server, platform) {
+    const bundler = server.getBundler().getBundler();
+    const depGraph = await bundler.getDependencyGraph();
+    const resolve = ({ from, to })=>{
+        const config = {
+            name: to,
+            data: {
+                asyncType: null,
+                key: to,
+                locs: []
+            }
+        };
+        const options = {
+            assumeFlatNodeModules: false
+        };
+        const res = depGraph.resolveDependency(from, config, platform, {}, options);
+        return res.filePath;
+    };
+    return {
+        resolve
+    };
+}
+export { createResolver };

package/dist/commands/utils/get-community-plugin.d.ts

@@ -0,0 +1,29 @@
+import type { ConfigT } from 'metro-config';
+import type Server from 'metro/src/Server';
+import type { OutputOptions, RequestOptions } from 'metro/src/shared/types';
+interface Command {
+    name: string;
+    description: string;
+    func: () => Promise<void>;
+    options: {
+        name: string;
+        description: string;
+    }[];
+}
+interface CommunityCliPlugin {
+    bundleCommand: Command;
+    startCommand: Command;
+    unstable_buildBundleWithConfig: (args: unknown, config: ConfigT, bundleImpl: {
+        build: (server: Server, requestOpts: RequestOptions) => Promise<{
+            code: string;
+            map: string;
+        }>;
+        save: (bundle: {
+            code: string;
+            map: string;
+        }, options: OutputOptions, log: (msg: string) => void) => Promise<void>;
+        formatName: 'bundle';
+    }) => Promise<void>;
+}
+export declare function getCommunityCliPlugin(reactNativePath?: string): CommunityCliPlugin;
+export {};

package/dist/commands/utils/get-community-plugin.js

@@ -0,0 +1,50 @@
+"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__, {
+    getCommunityCliPlugin: ()=>getCommunityCliPlugin
+});
+const errors_js_namespaceObject = require("../../utils/errors.js");
+function getCommunityCliPlugin(reactNativePath) {
+    let communityCliPlugin;
+    try {
+        const communityCliPluginPath = require.resolve('@react-native/community-cli-plugin', {
+            paths: [
+                reactNativePath ?? require.resolve('react-native')
+            ]
+        });
+        communityCliPlugin = require(communityCliPluginPath);
+    } catch  {
+        throw new errors_js_namespaceObject.CLIError('Community CLI plugin is not installed.');
+    }
+    return communityCliPlugin;
+}
+exports.getCommunityCliPlugin = __webpack_exports__.getCommunityCliPlugin;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "getCommunityCliPlugin"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/utils/get-community-plugin.mjs

@@ -0,0 +1,18 @@
+import __rslib_shim_module__ from 'module';
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(import.meta.url);
+import { CLIError } from "../../utils/errors.mjs";
+function getCommunityCliPlugin(reactNativePath) {
+    let communityCliPlugin;
+    try {
+        const communityCliPluginPath = require.resolve('@react-native/community-cli-plugin', {
+            paths: [
+                reactNativePath ?? require.resolve('react-native')
+            ]
+        });
+        communityCliPlugin = require(communityCliPluginPath);
+    } catch  {
+        throw new CLIError('Community CLI plugin is not installed.');
+    }
+    return communityCliPlugin;
+}
+export { getCommunityCliPlugin };

package/dist/commands/utils/load-metro-config.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigT, YargArguments } from 'metro-config';
+import type { Config } from '../types';
+export default function loadMetroConfig(cfg: Config, options?: YargArguments): Promise<ConfigT>;

package/dist/commands/utils/load-metro-config.js

@@ -0,0 +1,84 @@
+"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__, {
+    default: ()=>loadMetroConfig
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_metro_config_namespaceObject = require("metro-config");
+const errors_js_namespaceObject = require("../../utils/errors.js");
+function getOverrideConfig(cfg, config) {
+    const nodePath = external_node_path_default();
+    const resolver = {
+        platforms: [
+            ...Object.keys(cfg.platforms),
+            'native'
+        ]
+    };
+    return {
+        resolver,
+        serializer: {
+            getModulesRunBeforeMainModule: (entryFilePath)=>{
+                var _config_serializer_getModulesRunBeforeMainModule, _config_serializer;
+                return [
+                    ...(null == (_config_serializer = config.serializer) ? void 0 : null == (_config_serializer_getModulesRunBeforeMainModule = _config_serializer.getModulesRunBeforeMainModule) ? void 0 : _config_serializer_getModulesRunBeforeMainModule.call(_config_serializer, entryFilePath)) || [],
+                    require.resolve(nodePath.join(cfg.reactNativePath, 'Libraries/Core/InitializeCore'), {
+                        paths: [
+                            cfg.root
+                        ]
+                    })
+                ];
+            }
+        }
+    };
+}
+async function loadMetroConfig(cfg, options = {}) {
+    const cwd = cfg.root;
+    const projectConfig = await (0, external_metro_config_namespaceObject.resolveConfig)(options.config, cwd);
+    if (projectConfig.isEmpty) throw new errors_js_namespaceObject.CLIError(`No Metro config found in ${cwd}`);
+    const config = await (0, external_metro_config_namespaceObject.loadConfig)({
+        cwd,
+        ...options
+    });
+    const overrideConfig = getOverrideConfig(cfg, config);
+    return (0, external_metro_config_namespaceObject.mergeConfig)(config, overrideConfig);
+}
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/commands/utils/load-metro-config.mjs

@@ -0,0 +1,43 @@
+import __rslib_shim_module__ from 'module';
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(import.meta.url);
+import node_path from "node:path";
+import { CLIError } from "../../utils/errors.mjs";
+import { createRequire as __WEBPACK_EXTERNAL_createRequire } from "node:module";
+const external_metro_config_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("metro-config");
+function getOverrideConfig(cfg, config) {
+    const nodePath = node_path;
+    const resolver = {
+        platforms: [
+            ...Object.keys(cfg.platforms),
+            'native'
+        ]
+    };
+    return {
+        resolver,
+        serializer: {
+            getModulesRunBeforeMainModule: (entryFilePath)=>{
+                var _config_serializer_getModulesRunBeforeMainModule, _config_serializer;
+                return [
+                    ...(null == (_config_serializer = config.serializer) ? void 0 : null == (_config_serializer_getModulesRunBeforeMainModule = _config_serializer.getModulesRunBeforeMainModule) ? void 0 : _config_serializer_getModulesRunBeforeMainModule.call(_config_serializer, entryFilePath)) || [],
+                    require.resolve(nodePath.join(cfg.reactNativePath, 'Libraries/Core/InitializeCore'), {
+                        paths: [
+                            cfg.root
+                        ]
+                    })
+                ];
+            }
+        }
+    };
+}
+async function loadMetroConfig(cfg, options = {}) {
+    const cwd = cfg.root;
+    const projectConfig = await (0, external_metro_config_namespaceObject.resolveConfig)(options.config, cwd);
+    if (projectConfig.isEmpty) throw new CLIError(`No Metro config found in ${cwd}`);
+    const config = await (0, external_metro_config_namespaceObject.loadConfig)({
+        cwd,
+        ...options
+    });
+    const overrideConfig = getOverrideConfig(cfg, config);
+    return (0, external_metro_config_namespaceObject.mergeConfig)(config, overrideConfig);
+}
+export { loadMetroConfig as default };

package/dist/commands/utils/save-bundle-and-map.d.ts

@@ -0,0 +1,5 @@
+import type { OutputOptions } from 'metro/src/shared/types';
+export declare function saveBundleAndMap(bundle: {
+    code: string;
+    map: string;
+}, options: OutputOptions, log: (msg: string) => void): Promise<void>;