@react-native/community-cli-plugin 0.73.0-nightly-20230922-52104c6ee

package/dist/commands/start/runServer.js

@@ -0,0 +1,173 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = void 0;
+var _chalk = _interopRequireDefault(require("chalk"));
+var _metro = _interopRequireDefault(require("metro"));
+var _metroCore = require("metro-core");
+var _path = _interopRequireDefault(require("path"));
+var _devMiddleware = require("@react-native/dev-middleware");
+var _cliServerApi = require("@react-native-community/cli-server-api");
+var _cliTools = require("@react-native-community/cli-tools");
+var _isDevServerRunning = _interopRequireDefault(
+  require("../../utils/isDevServerRunning")
+);
+var _loadMetroConfig = _interopRequireDefault(
+  require("../../utils/loadMetroConfig")
+);
+var _attachKeyHandlers = _interopRequireDefault(require("./attachKeyHandlers"));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ * @oncall react_native
+ */
+
+async function runServer(_argv, ctx, args) {
+  const metroConfig = await (0, _loadMetroConfig.default)(ctx, {
+    config: args.config,
+    maxWorkers: args.maxWorkers,
+    port: args.port ?? 8081,
+    resetCache: args.resetCache,
+    watchFolders: args.watchFolders,
+    projectRoot: args.projectRoot,
+    sourceExts: args.sourceExts,
+  });
+  const host = args.host?.length ? args.host : "localhost";
+  const {
+    projectRoot,
+    server: { port },
+    watchFolders,
+  } = metroConfig;
+  const scheme = args.https === true ? "https" : "http";
+  const devServerUrl = `${scheme}://${host}:${port}`;
+  _cliTools.logger.info(`Welcome to React Native v${ctx.reactNativeVersion}`);
+  const serverStatus = await (0, _isDevServerRunning.default)(
+    scheme,
+    host,
+    port,
+    projectRoot
+  );
+  if (serverStatus === "matched_server_running") {
+    _cliTools.logger.info(
+      `A dev server is already running for this project on port ${port}. Exiting.`
+    );
+    return;
+  } else if (serverStatus === "port_taken") {
+    _cliTools.logger.error(
+      `Another process is running on port ${port}. Please terminate this ` +
+        'process and try again, or use another port with "--port".'
+    );
+    return;
+  }
+  _cliTools.logger.info(
+    `Starting dev server on port ${_chalk.default.bold(String(port))}...`
+  );
+  if (args.assetPlugins) {
+    // $FlowIgnore[cannot-write] Assigning to readonly property
+    metroConfig.transformer.assetPlugins = args.assetPlugins.map((plugin) =>
+      require.resolve(plugin)
+    );
+  }
+  const {
+    middleware: communityMiddleware,
+    websocketEndpoints: communityWebsocketEndpoints,
+    messageSocketEndpoint,
+    eventsSocketEndpoint,
+  } = (0, _cliServerApi.createDevServerMiddleware)({
+    host,
+    port,
+    watchFolders,
+  });
+  const { middleware, websocketEndpoints } = (0,
+  _devMiddleware.createDevMiddleware)({
+    projectRoot,
+    serverBaseUrl: devServerUrl,
+    logger: _cliTools.logger,
+    unstable_experiments: {
+      // NOTE: Only affects the /open-debugger endpoint
+      enableCustomDebuggerFrontend: true,
+    },
+  });
+  let reportEvent;
+  const terminal = new _metroCore.Terminal(process.stdout);
+  const ReporterImpl = getReporterImpl(args.customLogReporterPath);
+  const terminalReporter = new ReporterImpl(terminal);
+  // $FlowIgnore[cannot-write] Assigning to readonly property
+  metroConfig.reporter = {
+    update(event) {
+      terminalReporter.update(event);
+      if (reportEvent) {
+        reportEvent(event);
+      }
+      if (args.interactive && event.type === "initialize_done") {
+        _cliTools.logger.info("Dev server ready");
+        (0, _attachKeyHandlers.default)({
+          cliConfig: ctx,
+          devServerUrl,
+          serverInstance,
+          messageSocket: messageSocketEndpoint,
+        });
+      }
+    },
+  };
+  const serverInstance = await _metro.default.runServer(metroConfig, {
+    host: args.host,
+    secure: args.https,
+    secureCert: args.cert,
+    secureKey: args.key,
+    unstable_extraMiddleware: [
+      communityMiddleware,
+      _cliServerApi.indexPageMiddleware,
+      middleware,
+    ],
+    websocketEndpoints: {
+      ...communityWebsocketEndpoints,
+      ...websocketEndpoints,
+    },
+  });
+  reportEvent = eventsSocketEndpoint.reportEvent;
+
+  // In Node 8, the default keep-alive for an HTTP connection is 5 seconds. In
+  // early versions of Node 8, this was implemented in a buggy way which caused
+  // some HTTP responses (like those containing large JS bundles) to be
+  // terminated early.
+  //
+  // As a workaround, arbitrarily increase the keep-alive from 5 to 30 seconds,
+  // which should be enough to send even the largest of JS bundles.
+  //
+  // For more info: https://github.com/nodejs/node/issues/13391
+  //
+  serverInstance.keepAliveTimeout = 30000;
+  await _cliTools.version.logIfUpdateAvailable(ctx.root);
+}
+function getReporterImpl(customLogReporterPath) {
+  if (customLogReporterPath == null) {
+    return require("metro/src/lib/TerminalReporter");
+  }
+  try {
+    // First we let require resolve it, so we can require packages in node_modules
+    // as expected. eg: require('my-package/reporter');
+    // $FlowIgnore[unsupported-syntax]
+    return require(customLogReporterPath);
+  } catch (e) {
+    if (e.code !== "MODULE_NOT_FOUND") {
+      throw e;
+    }
+    // If that doesn't work, then we next try relative to the cwd, eg:
+    // require('./reporter');
+    // $FlowIgnore[unsupported-syntax]
+    return require(_path.default.resolve(customLogReporterPath));
+  }
+}
+var _default = runServer;
+exports.default = _default;

package/dist/commands/start/runServer.js.flow

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import type { Config } from "@react-native-community/cli-types";
+export type StartCommandArgs = {
+  assetPlugins?: string[],
+  cert?: string,
+  customLogReporterPath?: string,
+  host?: string,
+  https?: boolean,
+  maxWorkers?: number,
+  key?: string,
+  platforms?: string[],
+  port?: number,
+  resetCache?: boolean,
+  sourceExts?: string[],
+  transformer?: string,
+  watchFolders?: string[],
+  config?: string,
+  projectRoot?: string,
+  interactive: boolean,
+};
+
+declare function runServer(
+  _argv: Array<string>,
+  ctx: Config,
+  args: StartCommandArgs
+): void;
+
+declare export default runServer;

package/dist/index.flow.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+Object.defineProperty(exports, "bundleCommand", {
+  enumerable: true,
+  get: function () {
+    return _bundle.default;
+  },
+});
+Object.defineProperty(exports, "ramBundleCommand", {
+  enumerable: true,
+  get: function () {
+    return _ramBundle.default;
+  },
+});
+Object.defineProperty(exports, "startCommand", {
+  enumerable: true,
+  get: function () {
+    return _start.default;
+  },
+});
+Object.defineProperty(exports, "unstable_buildBundleWithConfig", {
+  enumerable: true,
+  get: function () {
+    return _buildBundle.unstable_buildBundleWithConfig;
+  },
+});
+var _bundle = _interopRequireDefault(require("./commands/bundle"));
+var _ramBundle = _interopRequireDefault(require("./commands/ram-bundle"));
+var _start = _interopRequireDefault(require("./commands/start"));
+var _buildBundle = require("./commands/bundle/buildBundle");
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}

package/dist/index.flow.js.flow

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+export { default as bundleCommand } from "./commands/bundle";
+export { default as ramBundleCommand } from "./commands/ram-bundle";
+export { default as startCommand } from "./commands/start";
+
+export { unstable_buildBundleWithConfig } from "./commands/bundle/buildBundle";

package/dist/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+module.exports = require("./index.flow");

package/dist/index.js.flow

@@ -0,0 +1,12 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ * @oncall react_native
+ */
+
+declare module.exports: $FlowFixMe;

package/dist/utils/KeyPressHandler.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.KeyPressHandler = void 0;
+var _cliTools = require("@react-native-community/cli-tools");
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ * @oncall react_native
+ */
+
+const CTRL_C = "\u0003";
+
+/** An abstract key stroke interceptor. */
+class KeyPressHandler {
+  _isInterceptingKeyStrokes = false;
+  _isHandlingKeyPress = false;
+  constructor(onPress) {
+    this._onPress = onPress;
+  }
+
+  /** Start observing interaction pause listeners. */
+  createInteractionListener() {
+    // Support observing prompts.
+    let wasIntercepting = false;
+    const listener = ({ pause }) => {
+      if (pause) {
+        // Track if we were already intercepting key strokes before pausing, so we can
+        // resume after pausing.
+        wasIntercepting = this._isInterceptingKeyStrokes;
+        this.stopInterceptingKeyStrokes();
+      } else if (wasIntercepting) {
+        // Only start if we were previously intercepting.
+        this.startInterceptingKeyStrokes();
+      }
+    };
+    return listener;
+  }
+  _handleKeypress = async (key) => {
+    // Prevent sending another event until the previous event has finished.
+    if (this._isHandlingKeyPress && key !== CTRL_C) {
+      return;
+    }
+    this._isHandlingKeyPress = true;
+    try {
+      _cliTools.logger.debug(`Key pressed: ${key}`);
+      await this._onPress(key);
+    } catch (error) {
+      return new _cliTools.CLIError(
+        "There was an error with the key press handler."
+      );
+    } finally {
+      this._isHandlingKeyPress = false;
+    }
+  };
+
+  /** Start intercepting all key strokes and passing them to the input `onPress` method. */
+  startInterceptingKeyStrokes() {
+    if (this._isInterceptingKeyStrokes) {
+      return;
+    }
+    this._isInterceptingKeyStrokes = true;
+    const { stdin } = process;
+    // $FlowFixMe[prop-missing]
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    stdin.on("data", this._handleKeypress);
+  }
+
+  /** Stop intercepting all key strokes. */
+  stopInterceptingKeyStrokes() {
+    if (!this._isInterceptingKeyStrokes) {
+      return;
+    }
+    this._isInterceptingKeyStrokes = false;
+    const { stdin } = process;
+    stdin.removeListener("data", this._handleKeypress);
+    // $FlowFixMe[prop-missing]
+    stdin.setRawMode(false);
+    stdin.resume();
+  }
+}
+exports.KeyPressHandler = KeyPressHandler;

package/dist/utils/KeyPressHandler.js.flow

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+/** An abstract key stroke interceptor. */
+declare export class KeyPressHandler {
+  _isInterceptingKeyStrokes: $FlowFixMe;
+  _isHandlingKeyPress: $FlowFixMe;
+  _onPress: (key: string) => Promise<void>;
+  constructor(onPress: (key: string) => Promise<void>): void;
+  createInteractionListener(): ({ pause: boolean, ... }) => void;
+  _handleKeypress: $FlowFixMe;
+  startInterceptingKeyStrokes(): void;
+  stopInterceptingKeyStrokes(): void;
+}

package/dist/utils/isDevServerRunning.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = isDevServerRunning;
+var _net = _interopRequireDefault(require("net"));
+var _nodeFetch = _interopRequireDefault(require("node-fetch"));
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ * @oncall react_native
+ */
+
+/**
+ * Determine whether we can run the dev server.
+ *
+ * Return values:
+ * - `not_running`: The port is unoccupied.
+ * - `matched_server_running`: The port is occupied by another instance of this
+ *   dev server (matching the passed `projectRoot`).
+ * - `port_taken`: The port is occupied by another process.
+ * - `unknown`: An error was encountered; attempt server creation anyway.
+ */
+async function isDevServerRunning(scheme, host, port, projectRoot) {
+  try {
+    if (!(await isPortOccupied(host, port))) {
+      return "not_running";
+    }
+    const statusResponse = await (0, _nodeFetch.default)(
+      `${scheme}://${host}:${port}/status`
+    );
+    const body = await statusResponse.text();
+    return body === "packager-status:running" &&
+      statusResponse.headers.get("X-React-Native-Project-Root") === projectRoot
+      ? "matched_server_running"
+      : "port_taken";
+  } catch (e) {
+    return "unknown";
+  }
+}
+async function isPortOccupied(host, port) {
+  let result = false;
+  const server = _net.default.createServer();
+  return new Promise((resolve, reject) => {
+    server.once("error", (e) => {
+      server.close();
+      if (e.code === "EADDRINUSE") {
+        result = true;
+      } else {
+        reject(e);
+      }
+    });
+    server.once("listening", () => {
+      result = false;
+      server.close();
+    });
+    server.once("close", () => {
+      resolve(result);
+    });
+    server.listen({
+      host,
+      port,
+    });
+  });
+}

package/dist/utils/isDevServerRunning.js.flow

@@ -0,0 +1,27 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+/**
+ * Determine whether we can run the dev server.
+ *
+ * Return values:
+ * - `not_running`: The port is unoccupied.
+ * - `matched_server_running`: The port is occupied by another instance of this
+ *   dev server (matching the passed `projectRoot`).
+ * - `port_taken`: The port is occupied by another process.
+ * - `unknown`: An error was encountered; attempt server creation anyway.
+ */
+declare export default function isDevServerRunning(
+  scheme: string,
+  host: string,
+  port: number,
+  projectRoot: string
+): Promise<"not_running" | "matched_server_running" | "port_taken" | "unknown">;

package/dist/utils/loadMetroConfig.js

@@ -0,0 +1,107 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.default = loadMetroConfig;
+var _path = _interopRequireDefault(require("path"));
+var _metroConfig = require("metro-config");
+var _cliTools = require("@react-native-community/cli-tools");
+var _metroPlatformResolver = require("./metroPlatformResolver");
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : { default: obj };
+}
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ * @oncall react_native
+ */
+
+/**
+ * Get the config options to override based on RN CLI inputs.
+ */
+function getOverrideConfig(ctx) {
+  const outOfTreePlatforms = Object.keys(ctx.platforms).filter(
+    (platform) => ctx.platforms[platform].npmPackageName
+  );
+  const resolver = {
+    platforms: [...Object.keys(ctx.platforms), "native"],
+  };
+  if (outOfTreePlatforms.length) {
+    resolver.resolveRequest = (0,
+    _metroPlatformResolver.reactNativePlatformResolver)(
+      outOfTreePlatforms.reduce((result, platform) => {
+        result[platform] = ctx.platforms[platform].npmPackageName;
+        return result;
+      }, {})
+    );
+  }
+  return {
+    resolver,
+    serializer: {
+      // We can include multiple copies of InitializeCore here because metro will
+      // only add ones that are already part of the bundle
+      getModulesRunBeforeMainModule: () => [
+        require.resolve(
+          _path.default.join(
+            ctx.reactNativePath,
+            "Libraries/Core/InitializeCore"
+          ),
+          {
+            paths: [ctx.root],
+          }
+        ),
+        ...outOfTreePlatforms.map((platform) =>
+          require.resolve(
+            `${ctx.platforms[platform].npmPackageName}/Libraries/Core/InitializeCore`
+          )
+        ),
+      ],
+    },
+  };
+}
+
+/**
+ * Load Metro config.
+ *
+ * Allows the CLI to override select values in `metro.config.js` based on
+ * dynamic user options in `ctx`.
+ */
+async function loadMetroConfig(ctx, options = {}) {
+  const overrideConfig = getOverrideConfig(ctx);
+  const cwd = ctx.root;
+  const projectConfig = await (0, _metroConfig.resolveConfig)(
+    options.config,
+    cwd
+  );
+  if (projectConfig.isEmpty) {
+    throw new _cliTools.CLIError(`No Metro config found in ${cwd}`);
+  }
+  _cliTools.logger.debug(`Reading Metro config from ${projectConfig.filepath}`);
+  if (!global.__REACT_NATIVE_METRO_CONFIG_LOADED) {
+    for (const line of `
+=================================================================================================
+From React Native 0.73, your project's Metro config should extend '@react-native/metro-config'
+or it will fail to build. Please copy the template at:
+https://github.com/facebook/react-native/blob/main/packages/react-native/template/metro.config.js
+This warning will be removed in future (https://github.com/facebook/metro/issues/1018).
+=================================================================================================
+    `
+      .trim()
+      .split("\n")) {
+      _cliTools.logger.warn(line);
+    }
+  }
+  return (0, _metroConfig.mergeConfig)(
+    await (0, _metroConfig.loadConfig)({
+      cwd,
+      ...options,
+    }),
+    overrideConfig
+  );
+}

package/dist/utils/loadMetroConfig.js.flow

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import type { Config } from "@react-native-community/cli-types";
+import type { ConfigT, YargArguments } from "metro-config";
+
+export type { Config };
+
+export type ConfigLoadingContext = $ReadOnly<{
+  root: Config["root"],
+  reactNativePath: Config["reactNativePath"],
+  platforms: Config["platforms"],
+  ...
+}>;
+
+/**
+ * Load Metro config.
+ *
+ * Allows the CLI to override select values in `metro.config.js` based on
+ * dynamic user options in `ctx`.
+ */
+declare export default function loadMetroConfig(
+  ctx: ConfigLoadingContext,
+  options: YargArguments
+): Promise<ConfigT>;

package/dist/utils/metroPlatformResolver.js

@@ -0,0 +1,46 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true,
+});
+exports.reactNativePlatformResolver = reactNativePlatformResolver;
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ * @format
+ * @oncall react_native
+ */
+
+/**
+ * This is an implementation of a metro resolveRequest option which will remap react-native imports
+ * to different npm packages based on the platform requested.  This allows a single metro instance/config
+ * to produce bundles for multiple out of tree platforms at a time.
+ *
+ * @param platformImplementations
+ * A map of platform to npm package that implements that platform
+ *
+ * Ex:
+ * {
+ *    windows: 'react-native-windows'
+ *    macos: 'react-native-macos'
+ * }
+ */
+function reactNativePlatformResolver(platformImplementations) {
+  return (context, moduleName, platform) => {
+    let modifiedModuleName = moduleName;
+    if (platform != null && platformImplementations[platform]) {
+      if (moduleName === "react-native") {
+        modifiedModuleName = platformImplementations[platform];
+      } else if (moduleName.startsWith("react-native/")) {
+        modifiedModuleName = `${
+          platformImplementations[platform]
+        }/${modifiedModuleName.slice("react-native/".length)}`;
+      }
+    }
+    return context.resolveRequest(context, modifiedModuleName, platform);
+  };
+}