@granite-js/mpack 0.1.34 → 1.0.1

package/dist/operations/OpenDebuggerKeyboardHandler.js

@@ -0,0 +1,129 @@
+"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 OpenDebuggerKeyboardHandler_exports = {};
+__export(OpenDebuggerKeyboardHandler_exports, {
+  default: () => OpenDebuggerKeyboardHandler
+});
+module.exports = __toCommonJS(OpenDebuggerKeyboardHandler_exports);
+var import_util = require("util");
+class OpenDebuggerKeyboardHandler {
+  #devServerUrl;
+  #reporter;
+  #targetsShownForSelection = null;
+  constructor({ devServerUrl, reporter }) {
+    this.#devServerUrl = devServerUrl;
+    this.#reporter = reporter;
+  }
+  async #tryOpenDebuggerForTarget(target) {
+    this.#targetsShownForSelection = null;
+    this.#clearTerminalMenu();
+    try {
+      const fetchFn = globalThis.fetch;
+      if (fetchFn == null) {
+        throw new Error("Global fetch is not available");
+      }
+      await fetchFn(new URL(`/open-debugger?target=${encodeURIComponent(target.id)}`, this.#devServerUrl).href, {
+        method: "POST"
+      });
+    } catch (error) {
+      this.#log("error", "Failed to open debugger for %s (%s): %s", target.title, target.description, "Network error");
+      if (error instanceof Error && error.cause != null) {
+        this.#log("error", "Cause: %s", error.cause);
+      }
+      this.#clearTerminalMenu();
+    }
+  }
+  async handleOpenDebugger() {
+    this.#setTerminalMenu("Fetching available debugging targets...");
+    this.#targetsShownForSelection = null;
+    try {
+      const fetchFn = globalThis.fetch;
+      if (fetchFn == null) {
+        throw new Error("Global fetch is not available");
+      }
+      const response = await fetchFn(new URL("/json/list", this.#devServerUrl).href, { method: "POST" });
+      if (response.status !== 200) {
+        throw new Error(`Unexpected status code: ${response.status}`);
+      }
+      const targets = await response.json();
+      if (!Array.isArray(targets)) {
+        throw new Error("Expected array.");
+      }
+      if (targets.length === 0) {
+        this.#log("warn", "No connected targets");
+        this.#clearTerminalMenu();
+      } else if (targets.length === 1) {
+        const target = targets[0];
+        if (target) {
+          void this.#tryOpenDebuggerForTarget(target);
+        } else {
+          this.#clearTerminalMenu();
+        }
+      } else {
+        this.#targetsShownForSelection = targets;
+        if (targets.length > 9) {
+          this.#log("warn", "10 or more debug targets available, showing the first 9.");
+        }
+        this.#setTerminalMenu(
+          `Multiple debug targets available, please select:
+  ${targets.slice(0, 9).map(({ title }, index) => `${(0, import_util.styleText)(["white", "inverse"], ` ${index + 1} `)} - "${title}"`).join("\n  ")}`
+        );
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.#log("error", `Failed to fetch debug targets: ${message}`);
+      this.#clearTerminalMenu();
+    }
+  }
+  maybeHandleTargetSelection(keyName) {
+    if (keyName >= "1" && keyName <= "9") {
+      const targetIndex = Number(keyName) - 1;
+      if (this.#targetsShownForSelection != null && targetIndex < this.#targetsShownForSelection.length) {
+        const target = this.#targetsShownForSelection[targetIndex];
+        if (target) {
+          void this.#tryOpenDebuggerForTarget(target);
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  dismiss() {
+    this.#clearTerminalMenu();
+    this.#targetsShownForSelection = null;
+  }
+  #log(level, ...data) {
+    this.#reporter.update({
+      type: "unstable_server_log",
+      level,
+      data
+    });
+  }
+  #setTerminalMenu(message) {
+    this.#reporter.update({
+      type: "unstable_server_menu_updated",
+      message
+    });
+  }
+  #clearTerminalMenu() {
+    this.#reporter.update({
+      type: "unstable_server_menu_cleared"
+    });
+  }
+}

package/dist/operations/attachKeyHandlers.d.ts

@@ -0,0 +1,15 @@
+type MessageSocketEndpoint = {
+    broadcast: (type: string, params?: Record<string, unknown> | null) => void;
+};
+type Reporter = {
+    update: (event: {
+        type: string;
+        [key: string]: unknown;
+    }) => void;
+};
+export default function attachKeyHandlers({ devServerUrl, messageSocket, reporter, }: {
+    devServerUrl: string;
+    messageSocket: MessageSocketEndpoint;
+    reporter: Reporter;
+}): void;
+export {};

package/dist/operations/attachKeyHandlers.js

@@ -0,0 +1,132 @@
+"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 attachKeyHandlers_exports = {};
+__export(attachKeyHandlers_exports, {
+  default: () => attachKeyHandlers
+});
+module.exports = __toCommonJS(attachKeyHandlers_exports);
+var import_readline = __toESM(require("readline"));
+var import_tty = require("tty");
+var import_util = require("util");
+var import_OpenDebuggerKeyboardHandler = __toESM(require("./OpenDebuggerKeyboardHandler"));
+const CTRL_C = "";
+const CTRL_D = "";
+const RELOAD_TIMEOUT = 500;
+const throttle = (callback, timeout) => {
+  let previousCallTimestamp = 0;
+  return () => {
+    const currentCallTimestamp = Date.now();
+    if (currentCallTimestamp - previousCallTimestamp > timeout) {
+      previousCallTimestamp = currentCallTimestamp;
+      callback();
+    }
+  };
+};
+function attachKeyHandlers({
+  devServerUrl,
+  messageSocket,
+  reporter
+}) {
+  if (process.stdin.isTTY !== true) {
+    reporter.update({
+      type: "unstable_server_log",
+      level: "info",
+      data: "Interactive mode is not supported in this environment"
+    });
+    return;
+  }
+  import_readline.default.emitKeypressEvents(process.stdin);
+  setRawMode(true);
+  const reload = throttle(() => {
+    reporter.update({
+      type: "unstable_server_log",
+      level: "info",
+      data: "Reloading connected app(s)..."
+    });
+    messageSocket.broadcast("reload", null);
+  }, RELOAD_TIMEOUT);
+  const openDebuggerKeyboardHandler = new import_OpenDebuggerKeyboardHandler.default({
+    reporter,
+    devServerUrl
+  });
+  process.stdin.on("keypress", (_str, key) => {
+    void _str;
+    const keyName = key?.name;
+    if (keyName && openDebuggerKeyboardHandler.maybeHandleTargetSelection(keyName)) {
+      return;
+    }
+    switch (key?.sequence) {
+      case "r":
+        reload();
+        break;
+      case "d":
+        reporter.update({
+          type: "unstable_server_log",
+          level: "info",
+          data: "Opening Dev Menu..."
+        });
+        messageSocket.broadcast("devMenu", null);
+        break;
+      case "j":
+        void openDebuggerKeyboardHandler.handleOpenDebugger();
+        break;
+      case CTRL_C:
+      case CTRL_D:
+        openDebuggerKeyboardHandler.dismiss();
+        reporter.update({
+          type: "unstable_server_log",
+          level: "info",
+          data: "Stopping server"
+        });
+        setRawMode(false);
+        process.stdin.pause();
+        process.emit("SIGINT");
+        process.exit();
+    }
+  });
+  reporter.update({
+    type: "unstable_server_log",
+    level: "info",
+    data: `Key commands available:
+
+  ${(0, import_util.styleText)(["bold", "inverse"], " r ")} - reload app(s)
+  ${(0, import_util.styleText)(
+      ["bold", "inverse"],
+      " d "
+    )} - open Dev Menu
+  ${(0, import_util.styleText)(["bold", "inverse"], " j ")} - open DevTools
+`
+  });
+}
+function setRawMode(enable) {
+  if (!(process.stdin instanceof import_tty.ReadStream)) {
+    throw new Error("process.stdin must be a readable stream to modify raw mode");
+  }
+  process.stdin.setRawMode(enable);
+}

package/dist/operations/index.d.ts

@@ -1,3 +1,2 @@
 export * as BuildUtils from './build';
 export * from './serve';
-export * from './experimental/serve';

package/dist/operations/index.js

@@ -34,10 +34,8 @@ __export(operations_exports, {
 module.exports = __toCommonJS(operations_exports);
 var BuildUtils = __toESM(require("./build"));
 __reExport(operations_exports, require("./serve"), module.exports);
-__reExport(operations_exports, require("./experimental/serve"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BuildUtils,
-  ...require("./serve"),
-  ...require("./experimental/serve")
+  ...require("./serve")
 });

package/dist/operations/keyReporter.d.ts

@@ -0,0 +1,6 @@
+export declare const keyReporter: {
+    update(event: {
+        type: string;
+        [key: string]: unknown;
+    }): void;
+};

package/dist/operations/keyReporter.js

@@ -0,0 +1,57 @@
+"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 keyReporter_exports = {};
+__export(keyReporter_exports, {
+  keyReporter: () => keyReporter
+});
+module.exports = __toCommonJS(keyReporter_exports);
+const keyReporter = {
+  update(event) {
+    switch (event.type) {
+      case "unstable_server_log": {
+        const level = typeof event.level === "string" ? event.level : "info";
+        const data = event.data;
+        const output = typeof data === "string" ? data : Array.isArray(data) ? data.map(String).join(" ") : String(data);
+        if (level === "error") {
+          console.error(output);
+        } else if (level === "warn") {
+          console.warn(output);
+        } else {
+          console.log(output);
+        }
+        break;
+      }
+      case "unstable_server_menu_updated": {
+        const message = event.message;
+        if (typeof message === "string") {
+          console.log(message);
+        }
+        break;
+      }
+      case "unstable_server_menu_cleared":
+        break;
+      default:
+        break;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  keyReporter
+});

package/dist/operations/serve.d.ts

@@ -3,8 +3,7 @@ interface RunServerConfig {
     config: CompleteGraniteConfig;
     host?: string;
     port?: number;
-    enableEmbeddedReactDevTools?: boolean;
     onServerReady?: () => Promise<void> | void;
 }
-export declare function runServer({ config, host, port, enableEmbeddedReactDevTools, onServerReady, }: RunServerConfig): Promise<void>;
+export declare function runServer({ config, host, port, onServerReady, }: RunServerConfig): Promise<void>;
 export {};

package/dist/operations/serve.js

@@ -32,11 +32,12 @@ __export(serve_exports, {
 });
 module.exports = __toCommonJS(serve_exports);
 var import_plugin_core = require("@granite-js/plugin-core");
+var import_dev_middleware = require("@react-native/dev-middleware");
 var import_cli_server_api = require("@react-native-community/cli-server-api");
 var import_debug = __toESM(require("debug"));
-var import_backend = require("react-native-devtools-standalone/backend");
-var import_createDebuggerMiddleware = require("./createDebuggerMiddleware");
+var import_attachKeyHandlers = __toESM(require("./attachKeyHandlers"));
 var import_constants = require("../constants");
+var import_keyReporter = require("./keyReporter");
 var import_getMetroConfig = require("../metro/getMetroConfig");
 var import_printLogo = require("../utils/printLogo");
 var import_printServerUrl = require("../utils/printServerUrl");
@@ -49,13 +50,32 @@ async function runServer({
   config,
   host = import_constants.DEV_SERVER_DEFAULT_HOST,
   port = import_constants.DEV_SERVER_DEFAULT_PORT,
-  enableEmbeddedReactDevTools = true,
   onServerReady
 }) {
+  const devServerHostname = host === "0.0.0.0" ? "localhost" : host;
+  const devServerUrl = new URL(`http://${devServerHostname}:${port}`).origin;
+  let keyHandlersAttached = false;
   const ref = {};
   const driver = (0, import_plugin_core.createPluginHooksDriver)(config);
   const terminal = new Terminal(process.stdout);
   const terminalReporter = new TerminalReporter(terminal);
+  const resolvedConfig = await (0, import_plugin_core.resolveConfig)(config);
+  const { middlewares = [], inspectorProxy, ...additionalMetroConfig } = resolvedConfig?.metro ?? {};
+  const baseConfig = await (0, import_getMetroConfig.getMetroConfig)({ rootPath: config.cwd }, additionalMetroConfig);
+  const metroConfig = mergeConfig(baseConfig, {
+    server: { port }
+  });
+  metroConfig.server.runInspectorProxy = false;
+  const {
+    middleware,
+    websocketEndpoints: communityWebsocketEndpoints,
+    eventsSocketEndpoint,
+    messageSocketEndpoint
+  } = (0, import_cli_server_api.createDevServerMiddleware)({
+    host,
+    port,
+    watchFolders: metroConfig.watchFolders
+  });
   const reporter = {
     async update(event) {
       debug("Reporter event", event);
@@ -69,9 +89,16 @@ async function runServer({
           (0, import_printLogo.printLogo)();
           break;
         case "initialize_done":
-          enableStdinWatchMode();
           await driver.devServer.post({ host, port });
           (0, import_printServerUrl.printServerUrl)({ host, port });
+          if (!keyHandlersAttached) {
+            keyHandlersAttached = true;
+            (0, import_attachKeyHandlers.default)({
+              devServerUrl,
+              messageSocket: messageSocketEndpoint,
+              reporter: import_keyReporter.keyReporter
+            });
+          }
           await onServerReady?.();
           break;
         default:
@@ -79,24 +106,11 @@ async function runServer({
       }
     }
   };
-  const resolvedConfig = await (0, import_plugin_core.resolveConfig)(config);
-  const { middlewares = [], inspectorProxy, ...additionalMetroConfig } = resolvedConfig?.metro ?? {};
-  const baseConfig = await (0, import_getMetroConfig.getMetroConfig)({ rootPath: config.cwd }, additionalMetroConfig);
-  const metroConfig = mergeConfig(baseConfig, {
-    server: { port },
-    reporter
-  });
-  const { middleware, websocketEndpoints, messageSocketEndpoint, eventsSocketEndpoint } = (0, import_cli_server_api.createDevServerMiddleware)({
-    host,
-    port,
-    watchFolders: metroConfig.watchFolders
-  });
-  const { middleware: debuggerMiddleware, enableStdinWatchMode } = (0, import_createDebuggerMiddleware.createDebuggerMiddleware)({
-    port,
-    broadcastMessage: messageSocketEndpoint.broadcast
+  metroConfig.reporter = reporter;
+  const { middleware: debuggerMiddleware, websocketEndpoints: debuggerWebSocketEndpoints } = (0, import_dev_middleware.createDevMiddleware)({
+    serverBaseUrl: devServerUrl
   });
   middleware.use(debuggerMiddleware);
-  middleware.use(import_cli_server_api.indexPageMiddleware);
   const customEnhanceMiddleware = metroConfig.server.enhanceMiddleware;
   metroConfig.server.enhanceMiddleware = (metroMiddleware, server) => {
     if (customEnhanceMiddleware) {
@@ -107,26 +121,14 @@ async function runServer({
     }
     return middleware.use(metroMiddleware);
   };
-  if (enableEmbeddedReactDevTools) {
-    await (0, import_backend.setupDevToolsProxy)({
-      client: {
-        delegate: {
-          onError: (error) => console.error("React DevTools client error", error)
-        }
-      },
-      devtools: {
-        delegate: {
-          onError: (error) => console.error("React DevTools frontend error", error)
-        }
-      }
-    });
-  }
   ref.reportEvent = eventsSocketEndpoint.reportEvent;
-  ref.enableStdinWatchMode = enableStdinWatchMode;
   await driver.devServer.pre({ host, port });
   const serverInstance = await Metro.runServer(metroConfig, {
     host,
-    websocketEndpoints,
+    websocketEndpoints: {
+      ...communityWebsocketEndpoints,
+      ...debuggerWebSocketEndpoints
+    },
     inspectorProxyDelegate: inspectorProxy?.delegate
   });
   serverInstance.keepAliveTimeout = 3e4;

package/dist/transformer/AsyncTransformPipeline.js

@@ -33,19 +33,36 @@ class AsyncTransformPipeline extends import_TransformPipeline.TransformPipeline
       return this._afterStep ? this._afterStep(code2, args2, context2) : Promise.resolve({ code: code2, done: true });
     };
     let result = await before(code, args, context);
-    for await (const [step, config] of this.steps) {
+    for await (const entry of this.steps) {
       if (result.done) {
         break;
       }
-      if (config?.conditions == null || Array.isArray(config?.conditions) && config.conditions.some((condition) => condition(result.code, args.path))) {
+      if (entry.type === "normal" && entry.step) {
         let trace;
-        if (typeof step.name === "string") {
-          trace = import_performance.Performance.trace(`step-${step.name}`, { detail: { file: args.path } });
+        if (typeof entry.step.name === "string") {
+          trace = import_performance.Performance.trace(`step-${entry.step.name}`, { detail: { file: args.path } });
         }
-        result = await step(result.code, args, context);
+        result = await entry.step(result.code, args, context);
         trace?.stop();
-        if (config?.skipOtherSteps) {
-          break;
+      } else if (entry.type === "conditional" && entry.condition) {
+        const condition = entry.condition;
+        if (condition.if({ path: args.path, code: result.code })) {
+          let trace;
+          if (typeof condition.then.name === "string") {
+            trace = import_performance.Performance.trace(`step-${condition.then.name}`, { detail: { file: args.path } });
+          }
+          result = await condition.then(result.code, args, context);
+          trace?.stop();
+          if (condition.stopAfter) {
+            break;
+          }
+        } else if (condition.else) {
+          let trace;
+          if (typeof condition.else.name === "string") {
+            trace = import_performance.Performance.trace(`step-${condition.else.name}`, { detail: { file: args.path } });
+          }
+          result = await condition.else(result.code, args, context);
+          trace?.stop();
         }
       }
     }

package/dist/transformer/TransformPipeline.d.ts

@@ -13,24 +13,29 @@ interface TransformStep<TransformResult> {
     (code: string, args: TransformStepArgs, context: TransformStepContext): TransformResult;
     name?: string;
 }
-interface TransformStepConfig {
-    /**
-     * step 을 실행하기 위한 조건 (기본값: 항상 실행)
-     */
-    conditions?: Array<(code: string, path: string) => boolean>;
-    /**
-     * 현재 step 이 실행된 경우 done 처리 여부 (기본값: false)
-     */
-    skipOtherSteps?: boolean;
-}
 export type AsyncTransformStep = TransformStep<Promise<TransformStepResult>>;
+export interface ConditionalStep {
+    if: (args: {
+        path: string;
+        code: string;
+    }) => boolean;
+    then: AsyncTransformStep;
+    else?: AsyncTransformStep;
+    stopAfter?: boolean;
+}
+export type StepInput = AsyncTransformStep | ConditionalStep;
+interface StepEntry {
+    type: 'normal' | 'conditional';
+    step?: AsyncTransformStep;
+    condition?: ConditionalStep;
+}
 export declare abstract class TransformPipeline<Step extends TransformStep<unknown>> {
     protected _beforeStep?: Step;
     protected _afterStep?: Step;
-    protected steps: Array<[Step, TransformStepConfig | null]>;
+    protected steps: StepEntry[];
     beforeStep(step: Step): this;
     afterStep(step: Step): this;
-    addStep(step: Step, config?: TransformStepConfig): this;
+    addStep(step: StepInput): this;
     getStepContext(args: TransformStepArgs): Promise<TransformStepContext>;
     abstract transform(code: string, args: TransformStepArgs): ReturnType<Step>;
 }

package/dist/transformer/TransformPipeline.js

@@ -46,8 +46,12 @@ class TransformPipeline {
     this._afterStep = step;
     return this;
   }
-  addStep(step, config) {
-    this.steps.push([step, config ?? null]);
+  addStep(step) {
+    if (typeof step === "function") {
+      this.steps.push({ type: "normal", step });
+    } else {
+      this.steps.push({ type: "conditional", condition: step });
+    }
     return this;
   }
   async getStepContext(args) {

package/dist/utils/getDefaultReactNativePath.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultReactNativePath(rootDir: string): string;

package/dist/utils/getDefaultReactNativePath.js

@@ -0,0 +1,45 @@
+"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 getDefaultReactNativePath_exports = {};
+__export(getDefaultReactNativePath_exports, {
+  getDefaultReactNativePath: () => getDefaultReactNativePath
+});
+module.exports = __toCommonJS(getDefaultReactNativePath_exports);
+var import_path = __toESM(require("path"));
+function getDefaultReactNativePath(rootDir) {
+  return import_path.default.dirname(
+    require.resolve("react-native/package.json", {
+      paths: [rootDir]
+    })
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDefaultReactNativePath
+});

package/dist/utils/getId.js

@@ -37,7 +37,9 @@ function getId(bundleConfig) {
       bundleConfig.buildConfig.esbuild?.loader,
       bundleConfig.buildConfig.esbuild?.resolveExtensions,
       bundleConfig.buildConfig.esbuild?.mainFields,
-      bundleConfig.buildConfig.esbuild?.conditions
+      bundleConfig.buildConfig.esbuild?.conditions,
+      bundleConfig.buildConfig.extra?.skipReactNativePolyfills,
+      bundleConfig.buildConfig.extra?.skipReactNativeInitializeCore
     ])
   );
 }

package/dist/vendors/metro/src/DeltaBundler/Serializers/helpers/getSourceMapInfo.js

@@ -3,7 +3,8 @@ const { getJsOutput } = require("./js");
 function getSourceMapInfo(module2, options) {
   return {
     ...getJsOutput(module2).data,
-    path: module2.path,
+    // MARK: - 0.81
+    path: options.getSourceUrl(module2) ?? module2.path,
     source: options.excludeSource ? "" : getModuleSource(module2)
   };
 }