@granite-js/mpack 0.0.0-dev-20250725013859

package/dist/metro/types.d.ts

@@ -0,0 +1,92 @@
+import { ReportableEvent } from "../vendors/metro/src/lib/ReportableEvent";
+type Untyped = any;
+interface PackageJson {
+    readonly name?: string;
+    readonly main?: string;
+    readonly exports?: string | Untyped;
+}
+interface PackageInfo {
+    readonly packageJson: PackageJson;
+    readonly rootPath: string;
+}
+type ResolveAsset = (dirPath: string, assetName: string, extension: string) => string[] | undefined;
+interface ResolutionContext {
+    readonly assetExts: string[];
+    readonly allowHaste: boolean;
+    readonly customResolverOptions: Untyped;
+    readonly disableHierarchicalLookup: boolean;
+    readonly doesFileExist: Untyped;
+    readonly extraNodeModules?: {
+        [key: string]: string;
+    };
+    readonly getPackage: (packageJsonPath: string) => PackageJson | null;
+    readonly getPackageForModule: (modulePath: string) => PackageInfo | null;
+    readonly dependency?: any;
+    readonly mainFields: string[];
+    readonly originModulePath: string;
+    readonly nodeModulesPaths: string[];
+    readonly preferNativePlatform: boolean;
+    readonly resolveAsset: ResolveAsset;
+    readonly redirectModulePath: (modulePath: string) => string | false;
+    readonly resolveHasteModule: (name: string) => string | undefined;
+    readonly resolveHastePackage: (name: string) => string | undefined;
+    readonly resolveRequest?: CustomResolver;
+    readonly sourceExts: string[];
+    readonly unstable_conditionsByPlatform: {
+        [platform: string]: string[];
+    };
+    unstable_conditionNames: string[];
+    unstable_enablePackageExports: boolean;
+    unstable_getRealPath?: any;
+    unstable_logWarning: (message: string) => void;
+}
+export interface CustomResolutionContext extends ResolutionContext {
+    readonly resolveRequest: CustomResolver;
+}
+type CustomResolver = (context: CustomResolutionContext, moduleName: string, platform: string | null) => any;
+interface ResolverConfig {
+    assetExts: string[];
+    assetResolutions: string[];
+    blacklistRE?: RegExp | RegExp[];
+    blockList: RegExp | RegExp[];
+    dependencyExtractor?: string;
+    disableHierarchicalLookup: boolean;
+    extraNodeModules: {
+        [name: string]: string;
+    };
+    emptyModulePath: string;
+    enableGlobalPackages: boolean;
+    hasteImplModulePath?: string;
+    nodeModulesPaths: string[];
+    platforms: string[];
+    resolveRequest?: CustomResolver;
+    resolverMainFields: string[];
+    sourceExts: string[];
+    unstable_enableSymlinks: boolean;
+    unstable_conditionNames: string[];
+    unstable_conditionsByPlatform: Readonly<{
+        [platform: string]: string[];
+    }>;
+    unstable_enablePackageExports: boolean;
+    useWatchman: boolean;
+    requireCycleIgnorePatterns: ReadonlyArray<RegExp>;
+}
+/**
+ * 패키지에서 타입 정의 파일이 export 되어있지 않아 별도로 타입을 정의합니다.
+ */
+export interface MetroConfig {
+    readonly watchFolders?: string[];
+    readonly cacheStores?: any;
+    readonly resolver?: Partial<ResolverConfig>;
+    readonly server?: any;
+    readonly serializer?: object & {
+        getPolyfills?: () => string[];
+    };
+    readonly symbolicator?: any;
+    readonly transformer?: any;
+    readonly watcher?: any;
+    readonly reporter?: {
+        update: (event: ReportableEvent) => void;
+    };
+}
+export {};

package/dist/metro/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/operations/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const DEBUGGER_FRONTEND_PATH = "debugger-frontend";
+export declare const DEBUGGER_TEMP_DIR = "granite-debugger";
+export declare const REACT_NATIVE_INSPECTOR_PAGE = "rn_inspector.html";

package/dist/operations/constants.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  DEBUGGER_FRONTEND_PATH: () => DEBUGGER_FRONTEND_PATH,
+  DEBUGGER_TEMP_DIR: () => DEBUGGER_TEMP_DIR,
+  REACT_NATIVE_INSPECTOR_PAGE: () => REACT_NATIVE_INSPECTOR_PAGE
+});
+module.exports = __toCommonJS(constants_exports);
+const DEBUGGER_FRONTEND_PATH = "debugger-frontend";
+const DEBUGGER_TEMP_DIR = "granite-debugger";
+const REACT_NATIVE_INSPECTOR_PAGE = "rn_inspector.html";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEBUGGER_FRONTEND_PATH,
+  DEBUGGER_TEMP_DIR,
+  REACT_NATIVE_INSPECTOR_PAGE
+});

package/dist/operations/createDebuggerMiddleware.d.ts

@@ -0,0 +1,11 @@
+import connect from 'connect';
+interface DebuggerMiddlewareConfig {
+    host?: string;
+    port: number;
+    broadcastMessage: (method: string, params?: Record<string, unknown>) => void;
+}
+export declare function createDebuggerMiddleware({ host, port, broadcastMessage }: DebuggerMiddlewareConfig): {
+    middleware: connect.Server;
+    enableStdinWatchMode: () => void;
+};
+export {};

package/dist/operations/createDebuggerMiddleware.js

@@ -0,0 +1,128 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var createDebuggerMiddleware_exports = {};
+__export(createDebuggerMiddleware_exports, {
+  createDebuggerMiddleware: () => createDebuggerMiddleware
+});
+module.exports = __toCommonJS(createDebuggerMiddleware_exports);
+var import_path = __toESM(require("path"));
+var import_readline = __toESM(require("readline"));
+var import_devtools_frontend = __toESM(require("@granite-js/devtools-frontend"));
+var import_prompts = require("@inquirer/prompts");
+var import_chalk = __toESM(require("chalk"));
+var import_connect = __toESM(require("connect"));
+var import_debug = __toESM(require("debug"));
+var import_serve_static = __toESM(require("serve-static"));
+var import_constants = require("./constants");
+var import_openDebugger = require("./openDebugger");
+var import_vendors = require("../vendors");
+const debug = (0, import_debug.default)("cli:start");
+const { InspectorProxy } = (0, import_vendors.getModule)("metro-inspector-proxy");
+const chromeInstanceMap = /* @__PURE__ */ new Map();
+function createDebuggerMiddleware({ host, port, broadcastMessage }) {
+  const middleware = (0, import_connect.default)().use(`/${import_constants.DEBUGGER_FRONTEND_PATH}`, (0, import_serve_static.default)(import_path.default.resolve(import_devtools_frontend.default)));
+  function enableStdinWatchMode() {
+    if (!process.stdout.isTTY || process.stdin.setRawMode == null) {
+      console.warn("Watch mode is not supported in this environment");
+      return;
+    }
+    import_readline.default.emitKeypressEvents(process.stdin);
+    process.stdin.setRawMode(true);
+    console.log(`To reload the app press ${import_chalk.default.blue('"r"')}`);
+    console.log(`To open developer menu press ${import_chalk.default.blue('"d"')}`);
+    console.log(`To open debugger press ${import_chalk.default.blue('"j"')}`);
+    console.log("");
+    process.stdin.on("keypress", (_key, data) => {
+      if (data.ctrl === true) {
+        switch (data.name) {
+          case "c":
+            process.exit(0);
+          // eslint-disable-next-line no-fallthrough
+          case "z":
+            process.emit("SIGTSTP", "SIGTSTP");
+            break;
+        }
+        return;
+      }
+      switch (data.name) {
+        case "r":
+          console.info("Reloading app...");
+          broadcastMessage("reload");
+          break;
+        case "d":
+          console.info("Opening developer menu...");
+          broadcastMessage("devMenu");
+          break;
+        case "j":
+          openReactNativeDebugger(host, port);
+          break;
+      }
+    });
+  }
+  return { middleware, enableStdinWatchMode };
+}
+async function openReactNativeDebugger(host = "localhost", port) {
+  const connectedDevices = Array.from(InspectorProxy.devices.entries());
+  let targetDevice;
+  for (const [id, device] of connectedDevices) {
+    debug(`[${id}] ${device.getName()}`);
+  }
+  if (connectedDevices.length === 0) {
+    console.log("No compatible apps connected");
+    return;
+  } else if (connectedDevices.length === 1) {
+    const [id, device] = connectedDevices[0];
+    const name = device.getName();
+    targetDevice = { id, name };
+  } else {
+    const deviceInfo = await (0, import_prompts.select)({
+      message: "Select a device to connect",
+      choices: connectedDevices.map(([id, device]) => ({
+        value: { id, name: device.getName() },
+        name: device.getName()
+      }))
+    });
+    process.stdin.resume();
+    targetDevice = deviceInfo;
+  }
+  console.log(`Opening debugger for '${targetDevice.name}'...`);
+  chromeInstanceMap.get(targetDevice.id)?.kill();
+  (0, import_openDebugger.openDebugger)(host, port, targetDevice.id.toString()).then((chrome) => {
+    chromeInstanceMap.set(targetDevice.id, chrome);
+  }).catch((error) => {
+    if (error.message.includes("ECONNREFUSED")) {
+      return;
+    }
+    console.error(error);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createDebuggerMiddleware
+});

package/dist/operations/experimental/StartMenuHandler.d.ts

@@ -0,0 +1,13 @@
+interface Menu {
+    key: string;
+    description: string;
+    action: () => void;
+}
+export declare class StartMenuHandler {
+    private menus;
+    constructor(menus: Menu[]);
+    attach(): this;
+    close(): void;
+    private keyPressHandler;
+}
+export {};

package/dist/operations/experimental/StartMenuHandler.js

@@ -0,0 +1,86 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var StartMenuHandler_exports = {};
+__export(StartMenuHandler_exports, {
+  StartMenuHandler: () => StartMenuHandler
+});
+module.exports = __toCommonJS(StartMenuHandler_exports);
+var import_readline = __toESM(require("readline"));
+var import_chalk = __toESM(require("chalk"));
+class StartMenuHandler {
+  constructor(menus) {
+    this.menus = menus;
+  }
+  attach() {
+    const isSupportInteractiveMode = process.stdout.isTTY && typeof process.stdin.setRawMode === "function";
+    if (isSupportInteractiveMode) {
+      import_readline.default.emitKeypressEvents(process.stdin);
+      process.stdin.setRawMode(true);
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("keypress", this.keyPressHandler.bind(this));
+      process.stdout.write("\n");
+      this.menus.forEach(({ key, description }) => {
+        console.log(`${import_chalk.default.bold(key)} - ${description}`);
+      });
+      process.stdout.write("\n");
+    }
+    return this;
+  }
+  close() {
+    process.stdin.off("keypress", this.keyPressHandler);
+  }
+  keyPressHandler(_data, { ctrl, name }) {
+    if (name === void 0) {
+      console.log("\uD55C/\uC601\uD0A4\uB97C \uD655\uC778\uD574\uC8FC\uC138\uC694");
+      return;
+    }
+    if (ctrl) {
+      switch (name) {
+        // Ctrl + C: SIGINT
+        case "c":
+          process.exit(0);
+          return;
+        // Ctrl + Z: SIGTSTP
+        case "z":
+          process.emit("SIGTSTP", "SIGTSTP");
+          return;
+      }
+      return;
+    }
+    this.menus.forEach(({ key, action }) => {
+      if (key === name) {
+        action();
+      }
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StartMenuHandler
+});

package/dist/operations/experimental/runServer.d.ts

@@ -0,0 +1,13 @@
+import type { DevServerOptions } from '../../server/types';
+import type { Middleware } from '../../types';
+interface RunServerArgs {
+    host?: string;
+    port?: number;
+    buildConfig: DevServerOptions['buildConfig'];
+    middlewares?: Middleware[];
+    onServerReady?: () => Promise<void> | void;
+}
+export declare function EXPERIMENTAL__runServer({ host, port, buildConfig, middlewares, onServerReady, }: RunServerArgs): Promise<{
+    cleanup: () => Promise<void>;
+}>;
+export {};

package/dist/operations/experimental/runServer.js

@@ -0,0 +1,130 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var runServer_exports = {};
+__export(runServer_exports, {
+  EXPERIMENTAL__runServer: () => EXPERIMENTAL__runServer
+});
+module.exports = __toCommonJS(runServer_exports);
+var import_prompts = require("@inquirer/prompts");
+var import_debug = __toESM(require("debug"));
+var import_StartMenuHandler = require("./StartMenuHandler");
+var import_constants = require("../../constants");
+var import_DevServer = require("../../server/DevServer");
+var import_printLogo = require("../../utils/printLogo");
+var import_openDebugger = require("../openDebugger");
+const debug = (0, import_debug.default)("cli:start");
+const chromeInstanceMap = /* @__PURE__ */ new Map();
+async function EXPERIMENTAL__runServer({
+  host,
+  port = import_constants.DEV_SERVER_DEFAULT_PORT,
+  buildConfig,
+  middlewares,
+  onServerReady
+}) {
+  const rootDir = process.cwd();
+  const server = new import_DevServer.DevServer({
+    buildConfig,
+    host,
+    port,
+    middlewares,
+    rootDir
+  });
+  (0, import_printLogo.printLogo)();
+  await server.initialize();
+  await server.listen();
+  await onServerReady?.();
+  const menuHandler = new import_StartMenuHandler.StartMenuHandler([
+    {
+      key: "r",
+      description: "Refresh",
+      action: () => {
+        console.log("Refreshing...");
+        server.broadcastCommand("reload");
+      }
+    },
+    {
+      key: "d",
+      description: "Open Developer Menu",
+      action: () => {
+        console.log("Opening developer menu...");
+        server.broadcastCommand("devMenu");
+      }
+    },
+    {
+      key: "j",
+      description: "Open Debugger",
+      action: async () => {
+        const devices = server.getInspectorProxy()?.getDevices();
+        const connectedDevices = Array.from(devices?.entries() ?? []);
+        let targetDevice;
+        for (const [id, device] of connectedDevices) {
+          debug(`[${id}] ${device.getName()}`);
+        }
+        if (connectedDevices.length === 0) {
+          console.log("No compatible apps connected");
+          return;
+        } else if (connectedDevices.length === 1) {
+          const [id, device] = connectedDevices[0];
+          const name = device.getName();
+          targetDevice = { id, name };
+        } else {
+          const deviceInfo = await (0, import_prompts.select)({
+            message: "Select a device to connect",
+            choices: connectedDevices.map(([id, device]) => ({
+              value: { id, name: device.getName() },
+              name: device.getName()
+            }))
+          });
+          process.stdin.resume();
+          targetDevice = deviceInfo;
+        }
+        console.log(`Opening debugger for '${targetDevice.name}'...`);
+        chromeInstanceMap.get(targetDevice.id)?.kill();
+        (0, import_openDebugger.openDebugger)(server.host, server.port, targetDevice.id).then((chrome) => {
+          chromeInstanceMap.set(targetDevice.id, chrome);
+        }).catch((error) => {
+          if (error.message.includes("ECONNREFUSED")) {
+            return;
+          }
+          console.error(error);
+        });
+      }
+    }
+  ]).attach();
+  return {
+    cleanup: async () => {
+      await server.close();
+      menuHandler.close();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EXPERIMENTAL__runServer
+});

package/dist/operations/index.d.ts

@@ -0,0 +1,3 @@
+export * from './runBundle';
+export * from './runServer';
+export * from './experimental/runServer';

package/dist/operations/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var operations_exports = {};
+module.exports = __toCommonJS(operations_exports);
+__reExport(operations_exports, require("./runBundle"), module.exports);
+__reExport(operations_exports, require("./runServer"), module.exports);
+__reExport(operations_exports, require("./experimental/runServer"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./runBundle"),
+  ...require("./runServer"),
+  ...require("./experimental/runServer")
+});

package/dist/operations/openDebugger.d.ts

@@ -0,0 +1 @@
+export declare function openDebugger(host: string | undefined, port: number, deviceId: string): Promise<import("chrome-launcher").LaunchedChrome>;

package/dist/operations/openDebugger.js

@@ -0,0 +1,73 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var openDebugger_exports = {};
+__export(openDebugger_exports, {
+  openDebugger: () => openDebugger
+});
+module.exports = __toCommonJS(openDebugger_exports);
+var fs = __toESM(require("fs/promises"));
+var os = __toESM(require("os"));
+var path = __toESM(require("path"));
+var import_chrome_launcher = require("chrome-launcher");
+var import_constants = require("./constants");
+async function openDebugger(host = "localhost", port, deviceId) {
+  const appUrl = getDevToolsFrontendUrl(host, port, deviceId);
+  const tempDir = await createTemporaryDirectory();
+  const chromePath = (0, import_chrome_launcher.getChromePath)();
+  if (!chromePath) {
+    throw new Error("unable to get Chrome browser path");
+  }
+  return (0, import_chrome_launcher.launch)({
+    chromePath,
+    chromeFlags: [
+      `--app=${appUrl}`,
+      `--user-data-dir=${tempDir}`,
+      "--no-first-run",
+      "--no-default-browser-check",
+      "--window-size=1200,800"
+    ]
+  });
+}
+function getDevToolsFrontendUrl(host, port, deviceId) {
+  const wsUrl = `${host}:${port}/inspector/debug?device=${deviceId}&page=-1`;
+  const url = new URL(`http://${host}:${port}/${import_constants.DEBUGGER_FRONTEND_PATH}/${import_constants.REACT_NATIVE_INSPECTOR_PAGE}`);
+  url.searchParams.set("ws", wsUrl);
+  url.searchParams.set("unstable_enableNetworkPanel", "true");
+  url.searchParams.set("sources.hide_add_folder", "true");
+  return url.toString();
+}
+async function createTemporaryDirectory() {
+  const tempDir = path.join(os.tmpdir(), import_constants.DEBUGGER_TEMP_DIR);
+  await fs.mkdir(tempDir, { recursive: true });
+  return tempDir;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  openDebugger
+});

package/dist/operations/runBundle.d.ts

@@ -0,0 +1,6 @@
+import { BundlerConfig, PluginFactory } from '../types';
+interface RunBundleOptions extends BundlerConfig {
+    plugins?: PluginFactory[];
+}
+export declare function runBundle({ plugins, ...bundlerConfig }: RunBundleOptions): Promise<import("..").BuildResult>;
+export {};