@module-federation/metro 0.0.0-next-20250827124348

package/dist/commands/bundle-host/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-host/types.mjs

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

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

@@ -0,0 +1,12 @@
+import type { ModuleFederationConfigNormalized } from '../../types';
+import type { Config } from '../types';
+import type { BundleFederatedRemoteArgs } from './types';
+declare global {
+    var __METRO_FEDERATION_CONFIG: ModuleFederationConfigNormalized;
+    var __METRO_FEDERATION_ORIGINAL_ENTRY_PATH: string | undefined;
+    var __METRO_FEDERATION_REMOTE_ENTRY_PATH: string | undefined;
+    var __METRO_FEDERATION_MANIFEST_PATH: string | undefined;
+}
+declare function bundleFederatedRemote(_argv: Array<string>, cfg: Config, args: BundleFederatedRemoteArgs): Promise<void>;
+export default bundleFederatedRemote;
+export { default as bundleFederatedRemoteOptions } from './options';

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

@@ -0,0 +1,226 @@
+"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__, {
+    bundleFederatedRemoteOptions: ()=>external_options_js_default(),
+    default: ()=>bundle_remote
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const external_node_url_namespaceObject = require("node:url");
+const external_node_util_namespaceObject = require("node:util");
+var external_node_util_default = /*#__PURE__*/ __webpack_require__.n(external_node_util_namespaceObject);
+const external_metro_namespaceObject = require("metro");
+const Server_namespaceObject = require("metro/src/Server");
+var Server_default = /*#__PURE__*/ __webpack_require__.n(Server_namespaceObject);
+const errors_js_namespaceObject = require("../../utils/errors.js");
+const create_module_path_remapper_js_namespaceObject = require("../utils/create-module-path-remapper.js");
+const create_resolver_js_namespaceObject = require("../utils/create-resolver.js");
+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 save_bundle_and_map_js_namespaceObject = require("../utils/save-bundle-and-map.js");
+const external_options_js_namespaceObject = require("./options.js");
+var external_options_js_default = /*#__PURE__*/ __webpack_require__.n(external_options_js_namespaceObject);
+const DEFAULT_OUTPUT = 'dist';
+async function buildBundle(server, requestOpts) {
+    const bundle = await server.build({
+        ...Server_default().DEFAULT_BUNDLE_OPTIONS,
+        ...requestOpts
+    });
+    return bundle;
+}
+function getRequestOpts(args, opts) {
+    return {
+        dev: args.dev,
+        minify: void 0 !== args.minify ? args.minify : !args.dev,
+        platform: args.platform,
+        entryFile: opts.entryFile,
+        sourceUrl: opts.sourceUrl,
+        sourceMapUrl: opts.sourceMapUrl,
+        lazy: opts.isContainerModule,
+        runModule: opts.isContainerModule,
+        modulesOnly: !opts.isContainerModule
+    };
+}
+function getSaveBundleOpts(args, opts) {
+    return {
+        indexedRamBundle: false,
+        bundleEncoding: args.bundleEncoding,
+        dev: args.dev,
+        platform: args.platform,
+        sourcemapSourcesRoot: args.sourcemapSourcesRoot,
+        sourcemapUseAbsolutePath: args.sourcemapUseAbsolutePath,
+        bundleOutput: opts.bundleOutput,
+        sourcemapOutput: opts.sourcemapOutput
+    };
+}
+async function bundleFederatedRemote(_argv, cfg, args) {
+    const rawConfig = await load_metro_config_js_default()(cfg, {
+        maxWorkers: args.maxWorkers,
+        resetCache: args.resetCache,
+        config: args.config
+    });
+    const logger = cfg.logger ?? console;
+    const federationConfig = global.__METRO_FEDERATION_CONFIG;
+    if (!federationConfig) {
+        logger.error(`${external_node_util_default().styleText('red', 'error')} Module Federation configuration is missing.`);
+        logger.info("Import the plugin 'withModuleFederation' from '@module-federation/metro' package and wrap your final Metro config with it.");
+        throw new errors_js_namespaceObject.CLIError('Bundling failed');
+    }
+    const containerEntryFilepath = global.__METRO_FEDERATION_REMOTE_ENTRY_PATH;
+    if (!containerEntryFilepath) {
+        logger.error(`${external_node_util_default().styleText('red', 'error')} Cannot determine the container entry file path.`);
+        logger.info("To bundle a container, you need to expose at least one module in your Module Federation configuration.");
+        throw new errors_js_namespaceObject.CLIError('Bundling failed');
+    }
+    const manifestFilepath = global.__METRO_FEDERATION_MANIFEST_PATH;
+    if (!manifestFilepath) {
+        logger.error(`${external_node_util_default().styleText('red', 'error')} Cannot determine the manifest file path.`);
+        throw new errors_js_namespaceObject.CLIError('Bundling failed');
+    }
+    if (-1 === rawConfig.resolver.platforms.indexOf(args.platform)) {
+        logger.error(`${external_node_util_default().styleText('red', 'error')}: Invalid platform ${args.platform ? `"${external_node_util_default().styleText('bold', args.platform)}" ` : ''}selected.`);
+        logger.info(`Available platforms are: ${rawConfig.resolver.platforms.map((x)=>`"${external_node_util_default().styleText('bold', x)}"`).join(', ')}. If you are trying to bundle for an out-of-tree platform, it may not be installed.`);
+        throw new errors_js_namespaceObject.CLIError('Bundling failed');
+    }
+    process.env.NODE_ENV = args.dev ? 'development' : 'production';
+    const modulePathRemapper = (0, create_module_path_remapper_js_namespaceObject.createModulePathRemapper)();
+    const config = (0, external_metro_namespaceObject.mergeConfig)(rawConfig, {
+        resolver: {
+            resolveRequest: (context, moduleName, platform)=>{
+                const originalResolveRequest = rawConfig.resolver.resolveRequest;
+                const res = originalResolveRequest(context, moduleName, platform);
+                return modulePathRemapper.remap(res);
+            }
+        },
+        serializer: {
+            createModuleIdFactory: ()=>{
+                const factory = rawConfig.serializer.createModuleIdFactory();
+                return (path)=>factory(modulePathRemapper.reverse(path));
+            }
+        }
+    });
+    const server = new (Server_default())(config);
+    config.server.enhanceMiddleware(server.processRequest, server);
+    const resolver = await (0, create_resolver_js_namespaceObject.createResolver)(server, args.platform);
+    const outputDir = args.output ? external_node_path_default().resolve(external_node_path_default().join(args.output, args.platform)) : external_node_path_default().resolve(config.projectRoot, external_node_path_default().join(DEFAULT_OUTPUT, args.platform));
+    const containerModule = {
+        [federationConfig.filename]: {
+            moduleInputFilepath: containerEntryFilepath,
+            moduleOutputDir: outputDir,
+            isContainerModule: true
+        }
+    };
+    resolver.resolve({
+        from: config.projectRoot,
+        to: `./${external_node_path_default().relative(config.projectRoot, containerEntryFilepath)}`
+    });
+    const exposedModules = Object.entries(federationConfig.exposes).map(([moduleName, moduleFilepath])=>[
+            moduleName.slice(2),
+            moduleFilepath
+        ]).reduce((acc, [moduleName, moduleInputFilepath])=>{
+        acc[moduleName] = {
+            moduleInputFilepath: external_node_path_default().resolve(config.projectRoot, moduleInputFilepath),
+            moduleOutputDir: external_node_path_default().resolve(outputDir, 'exposed'),
+            isContainerModule: false
+        };
+        return acc;
+    }, {});
+    const sharedModules = Object.entries(federationConfig.shared).filter(([, sharedConfig])=>!sharedConfig.eager && false !== sharedConfig.import).reduce((acc, [moduleName])=>{
+        const inputFilepath = resolver.resolve({
+            from: containerEntryFilepath,
+            to: moduleName
+        });
+        acc[moduleName] = {
+            moduleInputFilepath: inputFilepath,
+            moduleOutputDir: external_node_path_default().resolve(outputDir, 'shared'),
+            isContainerModule: false
+        };
+        return acc;
+    }, {});
+    const requests = Object.entries({
+        ...containerModule,
+        ...exposedModules,
+        ...sharedModules
+    }).map(([moduleName, { moduleInputFilepath, moduleOutputDir, isContainerModule = false }])=>{
+        const moduleBundleName = isContainerModule ? moduleName : `${moduleName}.bundle`;
+        const moduleBundleFilepath = external_node_path_default().resolve(moduleOutputDir, moduleBundleName);
+        const moduleBundleUrl = (0, external_node_url_namespaceObject.pathToFileURL)('/' + external_node_path_default().relative(outputDir, moduleBundleFilepath)).href;
+        const moduleSourceMapName = `${moduleBundleName}.map`;
+        const moduleSourceMapFilepath = external_node_path_default().resolve(moduleOutputDir, moduleSourceMapName);
+        const moduleSourceMapUrl = external_node_path_default().relative(outputDir, moduleSourceMapFilepath);
+        if (!isContainerModule) modulePathRemapper.addMapping(moduleInputFilepath, external_node_path_default().relative(outputDir, moduleBundleFilepath));
+        return {
+            targetDir: external_node_path_default().dirname(moduleBundleFilepath),
+            requestOpts: getRequestOpts(args, {
+                isContainerModule,
+                entryFile: moduleInputFilepath,
+                sourceUrl: moduleBundleUrl,
+                sourceMapUrl: moduleSourceMapUrl
+            }),
+            saveBundleOpts: getSaveBundleOpts(args, {
+                bundleOutput: moduleBundleFilepath,
+                sourcemapOutput: moduleSourceMapFilepath
+            })
+        };
+    });
+    try {
+        logger.info(`${external_node_util_default().styleText('blue', 'Processing remote container and exposed modules')}`);
+        for (const { requestOpts, saveBundleOpts, targetDir } of requests){
+            await external_node_fs_namespaceObject.promises.mkdir(targetDir, {
+                recursive: true,
+                mode: 493
+            });
+            const bundle = await buildBundle(server, requestOpts);
+            await (0, save_bundle_and_map_js_namespaceObject.saveBundleAndMap)(bundle, saveBundleOpts, logger.info);
+        }
+        logger.info(`${external_node_util_default().styleText('blue', 'Processing manifest')}`);
+        const manifestOutputFilepath = external_node_path_default().resolve(outputDir, 'mf-manifest.json');
+        await external_node_fs_namespaceObject.promises.copyFile(manifestFilepath, manifestOutputFilepath);
+        logger.info(`Done writing MF Manifest to:\n${external_node_util_default().styleText('dim', manifestOutputFilepath)}`);
+    } finally{
+        await server.end();
+    }
+}
+const bundle_remote = bundleFederatedRemote;
+exports.bundleFederatedRemoteOptions = __webpack_exports__.bundleFederatedRemoteOptions;
+exports["default"] = __webpack_exports__["default"];
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "bundleFederatedRemoteOptions",
+    "default"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,200 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import { promises } from "node:fs";
+import node_path from "node:path";
+import { pathToFileURL } from "node:url";
+import node_util from "node:util";
+import { CLIError } from "../../utils/errors.mjs";
+import { createModulePathRemapper } from "../utils/create-module-path-remapper.mjs";
+import { createResolver } from "../utils/create-resolver.mjs";
+import load_metro_config from "../utils/load-metro-config.mjs";
+import { saveBundleAndMap } from "../utils/save-bundle-and-map.mjs";
+import options from "./options.mjs";
+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 external_metro_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("metro");
+const Server_namespaceObject = __WEBPACK_EXTERNAL_createRequire(import.meta.url)("metro/src/Server");
+var Server_default = /*#__PURE__*/ __webpack_require__.n(Server_namespaceObject);
+const DEFAULT_OUTPUT = 'dist';
+async function buildBundle(server, requestOpts) {
+    const bundle = await server.build({
+        ...Server_default().DEFAULT_BUNDLE_OPTIONS,
+        ...requestOpts
+    });
+    return bundle;
+}
+function getRequestOpts(args, opts) {
+    return {
+        dev: args.dev,
+        minify: void 0 !== args.minify ? args.minify : !args.dev,
+        platform: args.platform,
+        entryFile: opts.entryFile,
+        sourceUrl: opts.sourceUrl,
+        sourceMapUrl: opts.sourceMapUrl,
+        lazy: opts.isContainerModule,
+        runModule: opts.isContainerModule,
+        modulesOnly: !opts.isContainerModule
+    };
+}
+function getSaveBundleOpts(args, opts) {
+    return {
+        indexedRamBundle: false,
+        bundleEncoding: args.bundleEncoding,
+        dev: args.dev,
+        platform: args.platform,
+        sourcemapSourcesRoot: args.sourcemapSourcesRoot,
+        sourcemapUseAbsolutePath: args.sourcemapUseAbsolutePath,
+        bundleOutput: opts.bundleOutput,
+        sourcemapOutput: opts.sourcemapOutput
+    };
+}
+async function bundleFederatedRemote(_argv, cfg, args) {
+    const rawConfig = await load_metro_config(cfg, {
+        maxWorkers: args.maxWorkers,
+        resetCache: args.resetCache,
+        config: args.config
+    });
+    const logger = cfg.logger ?? console;
+    const federationConfig = global.__METRO_FEDERATION_CONFIG;
+    if (!federationConfig) {
+        logger.error(`${node_util.styleText('red', 'error')} Module Federation configuration is missing.`);
+        logger.info("Import the plugin 'withModuleFederation' from '@module-federation/metro' package and wrap your final Metro config with it.");
+        throw new CLIError('Bundling failed');
+    }
+    const containerEntryFilepath = global.__METRO_FEDERATION_REMOTE_ENTRY_PATH;
+    if (!containerEntryFilepath) {
+        logger.error(`${node_util.styleText('red', 'error')} Cannot determine the container entry file path.`);
+        logger.info("To bundle a container, you need to expose at least one module in your Module Federation configuration.");
+        throw new CLIError('Bundling failed');
+    }
+    const manifestFilepath = global.__METRO_FEDERATION_MANIFEST_PATH;
+    if (!manifestFilepath) {
+        logger.error(`${node_util.styleText('red', 'error')} Cannot determine the manifest file path.`);
+        throw new CLIError('Bundling failed');
+    }
+    if (-1 === rawConfig.resolver.platforms.indexOf(args.platform)) {
+        logger.error(`${node_util.styleText('red', 'error')}: Invalid platform ${args.platform ? `"${node_util.styleText('bold', args.platform)}" ` : ''}selected.`);
+        logger.info(`Available platforms are: ${rawConfig.resolver.platforms.map((x)=>`"${node_util.styleText('bold', x)}"`).join(', ')}. If you are trying to bundle for an out-of-tree platform, it may not be installed.`);
+        throw new CLIError('Bundling failed');
+    }
+    process.env.NODE_ENV = args.dev ? 'development' : 'production';
+    const modulePathRemapper = createModulePathRemapper();
+    const config = (0, external_metro_namespaceObject.mergeConfig)(rawConfig, {
+        resolver: {
+            resolveRequest: (context, moduleName, platform)=>{
+                const originalResolveRequest = rawConfig.resolver.resolveRequest;
+                const res = originalResolveRequest(context, moduleName, platform);
+                return modulePathRemapper.remap(res);
+            }
+        },
+        serializer: {
+            createModuleIdFactory: ()=>{
+                const factory = rawConfig.serializer.createModuleIdFactory();
+                return (path)=>factory(modulePathRemapper.reverse(path));
+            }
+        }
+    });
+    const server = new (Server_default())(config);
+    config.server.enhanceMiddleware(server.processRequest, server);
+    const resolver = await createResolver(server, args.platform);
+    const outputDir = args.output ? node_path.resolve(node_path.join(args.output, args.platform)) : node_path.resolve(config.projectRoot, node_path.join(DEFAULT_OUTPUT, args.platform));
+    const containerModule = {
+        [federationConfig.filename]: {
+            moduleInputFilepath: containerEntryFilepath,
+            moduleOutputDir: outputDir,
+            isContainerModule: true
+        }
+    };
+    resolver.resolve({
+        from: config.projectRoot,
+        to: `./${node_path.relative(config.projectRoot, containerEntryFilepath)}`
+    });
+    const exposedModules = Object.entries(federationConfig.exposes).map(([moduleName, moduleFilepath])=>[
+            moduleName.slice(2),
+            moduleFilepath
+        ]).reduce((acc, [moduleName, moduleInputFilepath])=>{
+        acc[moduleName] = {
+            moduleInputFilepath: node_path.resolve(config.projectRoot, moduleInputFilepath),
+            moduleOutputDir: node_path.resolve(outputDir, 'exposed'),
+            isContainerModule: false
+        };
+        return acc;
+    }, {});
+    const sharedModules = Object.entries(federationConfig.shared).filter(([, sharedConfig])=>!sharedConfig.eager && false !== sharedConfig.import).reduce((acc, [moduleName])=>{
+        const inputFilepath = resolver.resolve({
+            from: containerEntryFilepath,
+            to: moduleName
+        });
+        acc[moduleName] = {
+            moduleInputFilepath: inputFilepath,
+            moduleOutputDir: node_path.resolve(outputDir, 'shared'),
+            isContainerModule: false
+        };
+        return acc;
+    }, {});
+    const requests = Object.entries({
+        ...containerModule,
+        ...exposedModules,
+        ...sharedModules
+    }).map(([moduleName, { moduleInputFilepath, moduleOutputDir, isContainerModule = false }])=>{
+        const moduleBundleName = isContainerModule ? moduleName : `${moduleName}.bundle`;
+        const moduleBundleFilepath = node_path.resolve(moduleOutputDir, moduleBundleName);
+        const moduleBundleUrl = pathToFileURL('/' + node_path.relative(outputDir, moduleBundleFilepath)).href;
+        const moduleSourceMapName = `${moduleBundleName}.map`;
+        const moduleSourceMapFilepath = node_path.resolve(moduleOutputDir, moduleSourceMapName);
+        const moduleSourceMapUrl = node_path.relative(outputDir, moduleSourceMapFilepath);
+        if (!isContainerModule) modulePathRemapper.addMapping(moduleInputFilepath, node_path.relative(outputDir, moduleBundleFilepath));
+        return {
+            targetDir: node_path.dirname(moduleBundleFilepath),
+            requestOpts: getRequestOpts(args, {
+                isContainerModule,
+                entryFile: moduleInputFilepath,
+                sourceUrl: moduleBundleUrl,
+                sourceMapUrl: moduleSourceMapUrl
+            }),
+            saveBundleOpts: getSaveBundleOpts(args, {
+                bundleOutput: moduleBundleFilepath,
+                sourcemapOutput: moduleSourceMapFilepath
+            })
+        };
+    });
+    try {
+        logger.info(`${node_util.styleText('blue', 'Processing remote container and exposed modules')}`);
+        for (const { requestOpts, saveBundleOpts, targetDir } of requests){
+            await promises.mkdir(targetDir, {
+                recursive: true,
+                mode: 493
+            });
+            const bundle = await buildBundle(server, requestOpts);
+            await saveBundleAndMap(bundle, saveBundleOpts, logger.info);
+        }
+        logger.info(`${node_util.styleText('blue', 'Processing manifest')}`);
+        const manifestOutputFilepath = node_path.resolve(outputDir, 'mf-manifest.json');
+        await promises.copyFile(manifestFilepath, manifestOutputFilepath);
+        logger.info(`Done writing MF Manifest to:\n${node_util.styleText('dim', manifestOutputFilepath)}`);
+    } finally{
+        await server.end();
+    }
+}
+const bundle_remote = bundleFederatedRemote;
+export { options as bundleFederatedRemoteOptions, bundle_remote as default };

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

@@ -0,0 +1,32 @@
+declare const options: ({
+    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;
+})[];
+export default options;

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

@@ -0,0 +1,109 @@
+"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: ()=>options
+});
+const external_node_path_namespaceObject = require("node:path");
+var external_node_path_default = /*#__PURE__*/ __webpack_require__.n(external_node_path_namespaceObject);
+const options_options = [
+    {
+        name: '--platform <string>',
+        description: 'Either "ios" or "android"',
+        default: 'ios'
+    },
+    {
+        name: '--dev [boolean]',
+        description: 'If false, warnings are disabled and the bundle is minified',
+        parse: (val)=>'false' !== val,
+        default: true
+    },
+    {
+        name: '--minify [boolean]',
+        description: "Allows overriding whether bundle is minified. This defaults to false if dev is true, and true if dev is false. Disabling minification can be useful for speeding up production builds for testing purposes.",
+        parse: (val)=>'false' !== val
+    },
+    {
+        name: '--bundle-encoding <string>',
+        description: 'Encoding the bundle should be written in (https://nodejs.org/api/buffer.html#buffer_buffer).',
+        default: 'utf8'
+    },
+    {
+        name: '--max-workers <number>',
+        description: "Specifies the maximum number of workers the worker-pool will spawn for transforming files. This defaults to the number of the cores available on your machine."
+    },
+    {
+        name: '--sourcemap-output <string>',
+        description: 'File name where to store the sourcemap file for resulting bundle, ex. /tmp/groups.map'
+    },
+    {
+        name: '--sourcemap-sources-root <string>',
+        description: "Path to make sourcemap's sources entries relative to, ex. /root/dir"
+    },
+    {
+        name: '--sourcemap-use-absolute-path',
+        description: 'Report SourceMapURL using its full path',
+        default: false
+    },
+    {
+        name: '--assets-dest <string>',
+        description: 'Directory name where to store assets referenced in the bundle'
+    },
+    {
+        name: '--asset-catalog-dest [string]',
+        description: 'Path where to create an iOS Asset Catalog for images'
+    },
+    {
+        name: '--reset-cache',
+        description: 'Removes cached files',
+        default: false
+    },
+    {
+        name: '--config <string>',
+        description: 'Path to the CLI configuration file',
+        parse: (val)=>external_node_path_default().resolve(val)
+    },
+    {
+        name: '--output <string>',
+        description: 'Output directory for the bundle'
+    }
+];
+const options = options_options;
+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/bundle-remote/options.mjs

@@ -0,0 +1,67 @@
+import 'module';
+/*#__PURE__*/ import.meta.url;
+import node_path from "node:path";
+const options_options = [
+    {
+        name: '--platform <string>',
+        description: 'Either "ios" or "android"',
+        default: 'ios'
+    },
+    {
+        name: '--dev [boolean]',
+        description: 'If false, warnings are disabled and the bundle is minified',
+        parse: (val)=>'false' !== val,
+        default: true
+    },
+    {
+        name: '--minify [boolean]',
+        description: "Allows overriding whether bundle is minified. This defaults to false if dev is true, and true if dev is false. Disabling minification can be useful for speeding up production builds for testing purposes.",
+        parse: (val)=>'false' !== val
+    },
+    {
+        name: '--bundle-encoding <string>',
+        description: 'Encoding the bundle should be written in (https://nodejs.org/api/buffer.html#buffer_buffer).',
+        default: 'utf8'
+    },
+    {
+        name: '--max-workers <number>',
+        description: "Specifies the maximum number of workers the worker-pool will spawn for transforming files. This defaults to the number of the cores available on your machine."
+    },
+    {
+        name: '--sourcemap-output <string>',
+        description: 'File name where to store the sourcemap file for resulting bundle, ex. /tmp/groups.map'
+    },
+    {
+        name: '--sourcemap-sources-root <string>',
+        description: "Path to make sourcemap's sources entries relative to, ex. /root/dir"
+    },
+    {
+        name: '--sourcemap-use-absolute-path',
+        description: 'Report SourceMapURL using its full path',
+        default: false
+    },
+    {
+        name: '--assets-dest <string>',
+        description: 'Directory name where to store assets referenced in the bundle'
+    },
+    {
+        name: '--asset-catalog-dest [string]',
+        description: 'Path where to create an iOS Asset Catalog for images'
+    },
+    {
+        name: '--reset-cache',
+        description: 'Removes cached files',
+        default: false
+    },
+    {
+        name: '--config <string>',
+        description: 'Path to the CLI configuration file',
+        parse: (val)=>node_path.resolve(val)
+    },
+    {
+        name: '--output <string>',
+        description: 'Output directory for the bundle'
+    }
+];
+const options = options_options;
+export { options as default };