@nx/react-native 0.0.0-pr-22179-271588f

package/src/executors/start/start.impl.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCliStart = void 0;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const is_packager_running_1 = require("./lib/is-packager-running");
+async function* startExecutor(options, context) {
+    const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
+    await runCliStart(context.root, projectRoot, options);
+    yield {
+        port: options.port,
+        success: true,
+    };
+}
+exports.default = startExecutor;
+/*
+ * Starts the JS bundler and checks for "running" status before notifying
+ * that packager has started.
+ */
+async function runCliStart(workspaceRoot, projectRoot, options) {
+    const result = await (0, is_packager_running_1.isPackagerRunning)(options.port);
+    if (result === 'running') {
+        devkit_1.logger.info(`JS server already running on port ${options.port}.`);
+    }
+    else if (result === 'unrecognized') {
+        devkit_1.logger.warn('JS server not recognized.');
+    }
+    else {
+        // result === 'not_running'
+        devkit_1.logger.info('Starting JS server...');
+        try {
+            return await startAsync(workspaceRoot, projectRoot, options);
+        }
+        catch (error) {
+            devkit_1.logger.error(`Failed to start the packager server. Error details: ${error.message ?? error}`);
+            throw error;
+        }
+    }
+}
+exports.runCliStart = runCliStart;
+function startAsync(workspaceRoot, projectRoot, options) {
+    return new Promise((resolve, reject) => {
+        const childProcess = (0, child_process_1.fork)(require.resolve('react-native/cli.js'), ['start', ...createStartOptions(options)], {
+            cwd: (0, path_1.resolve)(workspaceRoot, projectRoot),
+            env: process.env,
+            stdio: 'inherit',
+        });
+        childProcess.on('error', (err) => {
+            reject(err);
+        });
+        childProcess.on('exit', (code) => {
+            if (code === 0) {
+                resolve(childProcess);
+            }
+            else {
+                reject(code);
+            }
+        });
+        const processExitListener = (signal) => () => {
+            childProcess.kill(signal);
+            process.exit();
+        };
+        process.once('exit', (signal) => childProcess.kill(signal));
+        process.once('SIGTERM', processExitListener);
+        process.once('SIGINT', processExitListener);
+        process.once('SIGQUIT', processExitListener);
+    });
+}
+function createStartOptions(options) {
+    return Object.keys(options).reduce((acc, k) => {
+        if (k === 'resetCache') {
+            if (options[k] === true) {
+                acc.push(`--reset-cache`);
+            }
+        }
+        else if (k === 'interactive') {
+            if (options[k] === false) {
+                acc.push(`--no-interactive`);
+            }
+        }
+        else {
+            acc.push(`--${k}`, options[k]);
+        }
+        return acc;
+    }, []);
+}

package/src/executors/start/start.impl.ts

@@ -0,0 +1,111 @@
+import { ExecutorContext, logger } from '@nx/devkit';
+import { ChildProcess, fork } from 'child_process';
+import { resolve as pathResolve } from 'path';
+import { isPackagerRunning } from './lib/is-packager-running';
+import { ReactNativeStartOptions } from './schema';
+
+export interface ReactNativeStartOutput {
+  port?: number;
+  success: boolean;
+}
+
+export default async function* startExecutor(
+  options: ReactNativeStartOptions,
+  context: ExecutorContext
+): AsyncGenerator<ReactNativeStartOutput> {
+  const projectRoot =
+    context.projectsConfigurations.projects[context.projectName].root;
+
+  await runCliStart(context.root, projectRoot, options);
+
+  yield {
+    port: options.port,
+    success: true,
+  };
+}
+
+/*
+ * Starts the JS bundler and checks for "running" status before notifying
+ * that packager has started.
+ */
+export async function runCliStart(
+  workspaceRoot: string,
+  projectRoot: string,
+  options: ReactNativeStartOptions
+): Promise<ChildProcess> {
+  const result = await isPackagerRunning(options.port);
+  if (result === 'running') {
+    logger.info(`JS server already running on port ${options.port}.`);
+  } else if (result === 'unrecognized') {
+    logger.warn('JS server not recognized.');
+  } else {
+    // result === 'not_running'
+    logger.info('Starting JS server...');
+
+    try {
+      return await startAsync(workspaceRoot, projectRoot, options);
+    } catch (error) {
+      logger.error(
+        `Failed to start the packager server. Error details: ${
+          error.message ?? error
+        }`
+      );
+      throw error;
+    }
+  }
+}
+
+function startAsync(
+  workspaceRoot: string,
+  projectRoot: string,
+  options: ReactNativeStartOptions
+): Promise<ChildProcess> {
+  return new Promise<ChildProcess>((resolve, reject) => {
+    const childProcess = fork(
+      require.resolve('react-native/cli.js'),
+      ['start', ...createStartOptions(options)],
+      {
+        cwd: pathResolve(workspaceRoot, projectRoot),
+        env: process.env,
+        stdio: 'inherit',
+      }
+    );
+
+    childProcess.on('error', (err) => {
+      reject(err);
+    });
+    childProcess.on('exit', (code) => {
+      if (code === 0) {
+        resolve(childProcess);
+      } else {
+        reject(code);
+      }
+    });
+
+    const processExitListener = (signal?: number | NodeJS.Signals) => () => {
+      childProcess.kill(signal);
+      process.exit();
+    };
+    process.once('exit', (signal) => childProcess.kill(signal));
+    process.once('SIGTERM', processExitListener);
+    process.once('SIGINT', processExitListener);
+    process.once('SIGQUIT', processExitListener);
+  });
+}
+
+function createStartOptions(options) {
+  return Object.keys(options).reduce((acc, k) => {
+    if (k === 'resetCache') {
+      if (options[k] === true) {
+        acc.push(`--reset-cache`);
+      }
+    } else if (k === 'interactive') {
+      if (options[k] === false) {
+        acc.push(`--no-interactive`);
+      }
+    } else {
+      acc.push(`--${k}`, options[k]);
+    }
+    return acc;
+  }, []);
+}

package/src/executors/storybook/schema.d.ts

@@ -0,0 +1,5 @@
+export interface ReactNativeStorybookOptions {
+  searchDir: string[];
+  outputFile: string;
+  pattern: string;
+}

package/src/executors/storybook/schema.json

@@ -0,0 +1,29 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "React Native Storybook Load Stories",
+  "cli": "nx",
+  "description": "Load stories for react native.",
+  "type": "object",
+  "properties": {
+    "searchDir": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "default": [],
+      "description": "The directory or directories, relative to the project root, to search for files in."
+    },
+    "outputFile": {
+      "type": "string",
+      "description": "The output file that will be written. It is relative to the project directory.",
+      "default": "./.storybook/story-loader.ts"
+    },
+    "pattern": {
+      "type": "string",
+      "description": "The pattern of files to look at. It can be a specific file, or any valid glob. Note: if using the CLI, globs with `**/*...` must be escaped with quotes",
+      "default": "**/*.stories.@(js|jsx|ts|tsx|md)"
+    }
+  },
+  "required": ["searchDir", "outputFile", "pattern"]
+}

package/src/executors/storybook/storybook.impl.d.ts

@@ -0,0 +1,10 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ReactNativeStorybookOptions } from './schema';
+/**
+ * TODO (@xiongemi): remove this function in v19.
+ * @deprecated Going to use the default react storybook target. Use @nx/react:storybook executor instead.
+ */
+export default function reactNativeStorybookExecutor(options: ReactNativeStorybookOptions, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+}>;
+export declare function runCliStorybook(workspaceRoot: string, options: ReactNativeStorybookOptions): void;

package/src/executors/storybook/storybook.impl.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCliStorybook = void 0;
+const path_1 = require("path");
+const devkit_1 = require("@nx/devkit");
+const fileutils_1 = require("@nx/workspace/src/utilities/fileutils");
+const chalk = require("chalk");
+const glob_1 = require("glob");
+const sync_deps_impl_1 = require("../sync-deps/sync-deps.impl");
+const fs_extra_1 = require("fs-extra");
+/**
+ * TODO (@xiongemi): remove this function in v19.
+ * @deprecated Going to use the default react storybook target. Use @nx/react:storybook executor instead.
+ */
+async function* reactNativeStorybookExecutor(options, context) {
+    const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
+    devkit_1.logger.info(`${chalk.bold.cyan('info')} To see your Storybook stories on the device, you should start your mobile app for the <platform> of your choice (typically ios or android).`);
+    // add storybook addons to app's package.json
+    const packageJsonPath = (0, path_1.join)(context.root, projectRoot, 'package.json');
+    const workspacePackageJsonPath = (0, path_1.join)(context.root, 'package.json');
+    const workspacePackageJson = (0, devkit_1.readJsonFile)(workspacePackageJsonPath);
+    const projectPackageJson = (0, devkit_1.readJsonFile)(packageJsonPath);
+    if ((0, fileutils_1.fileExists)(packageJsonPath))
+        (0, sync_deps_impl_1.displayNewlyAddedDepsMessage)(context.projectName, await (0, sync_deps_impl_1.syncDeps)(context.projectName, projectPackageJson, packageJsonPath, workspacePackageJson, context.projectGraph, [
+            `@storybook/react-native`,
+            '@storybook/addon-ondevice-actions',
+            '@storybook/addon-ondevice-backgrounds',
+            '@storybook/addon-ondevice-controls',
+            '@storybook/addon-ondevice-notes',
+            '@react-native-async-storage/async-storage',
+            'react-native-safe-area-context',
+        ]));
+    runCliStorybook(context.root, options);
+    yield { success: true };
+}
+exports.default = reactNativeStorybookExecutor;
+function runCliStorybook(workspaceRoot, options) {
+    const storiesFiles = options.searchDir.flatMap((dir) => (0, glob_1.sync)((0, path_1.join)(dir, options.pattern)));
+    if (storiesFiles.length === 0) {
+        devkit_1.logger.warn(`${chalk.bold.yellow('warn')} No stories found.`);
+    }
+    const newContents = `// Auto-generated file created by nx
+// DO NOT EDIT.
+export function loadStories() {
+  return [
+    ${storiesFiles.map((story) => `require('${story}')`).join(',\n')}
+  ];
+}`;
+    (0, fs_extra_1.writeFileSync)((0, path_1.join)(workspaceRoot, options.outputFile), newContents);
+}
+exports.runCliStorybook = runCliStorybook;

package/src/executors/storybook/storybook.impl.ts

@@ -0,0 +1,85 @@
+import { join } from 'path';
+import { ExecutorContext, logger, readJsonFile } from '@nx/devkit';
+import { fileExists } from '@nx/workspace/src/utilities/fileutils';
+import * as chalk from 'chalk';
+import { sync as globSync } from 'glob';
+
+import { ReactNativeStorybookOptions } from './schema';
+import {
+  displayNewlyAddedDepsMessage,
+  syncDeps,
+} from '../sync-deps/sync-deps.impl';
+import { writeFileSync } from 'fs-extra';
+import { PackageJson } from 'nx/src/utils/package-json';
+
+/**
+ * TODO (@xiongemi): remove this function in v19.
+ * @deprecated Going to use the default react storybook target. Use @nx/react:storybook executor instead.
+ */
+export default async function* reactNativeStorybookExecutor(
+  options: ReactNativeStorybookOptions,
+  context: ExecutorContext
+): AsyncGenerator<{ success: boolean }> {
+  const projectRoot =
+    context.projectsConfigurations.projects[context.projectName].root;
+  logger.info(
+    `${chalk.bold.cyan(
+      'info'
+    )} To see your Storybook stories on the device, you should start your mobile app for the <platform> of your choice (typically ios or android).`
+  );
+
+  // add storybook addons to app's package.json
+  const packageJsonPath = join(context.root, projectRoot, 'package.json');
+  const workspacePackageJsonPath = join(context.root, 'package.json');
+
+  const workspacePackageJson = readJsonFile<PackageJson>(
+    workspacePackageJsonPath
+  );
+  const projectPackageJson = readJsonFile<PackageJson>(packageJsonPath);
+
+  if (fileExists(packageJsonPath))
+    displayNewlyAddedDepsMessage(
+      context.projectName,
+      await syncDeps(
+        context.projectName,
+        projectPackageJson,
+        packageJsonPath,
+        workspacePackageJson,
+        context.projectGraph,
+        [
+          `@storybook/react-native`,
+          '@storybook/addon-ondevice-actions',
+          '@storybook/addon-ondevice-backgrounds',
+          '@storybook/addon-ondevice-controls',
+          '@storybook/addon-ondevice-notes',
+          '@react-native-async-storage/async-storage',
+          'react-native-safe-area-context',
+        ]
+      )
+    );
+
+  runCliStorybook(context.root, options);
+  yield { success: true };
+}
+
+export function runCliStorybook(
+  workspaceRoot: string,
+  options: ReactNativeStorybookOptions
+) {
+  const storiesFiles: string[] = options.searchDir.flatMap((dir) =>
+    globSync(join(dir, options.pattern))
+  );
+  if (storiesFiles.length === 0) {
+    logger.warn(`${chalk.bold.yellow('warn')} No stories found.`);
+  }
+
+  const newContents = `// Auto-generated file created by nx
+// DO NOT EDIT.
+export function loadStories() {
+  return [
+    ${storiesFiles.map((story) => `require('${story}')`).join(',\n')}
+  ];
+}`;
+
+  writeFileSync(join(workspaceRoot, options.outputFile), newContents);
+}

package/src/executors/sync-deps/schema.d.ts

@@ -0,0 +1,5 @@
+export interface ReactNativeSyncDepsOptions {
+  include: string[] | string; // default is an empty array []
+  exclude: string[] | string; // default is an empty array []
+  all: boolean; // default is false
+}

package/src/executors/sync-deps/schema.json

@@ -0,0 +1,33 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "cli": "nx",
+  "$id": "NxReactNativeSyncDeps",
+  "$schema": "https://json-schema.org/schema",
+  "title": "Sync Deps for React Native",
+  "description": "Updates `package.json` with project dependencies.",
+  "type": "object",
+  "properties": {
+    "include": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "default": [],
+      "description": "An array of additional npm packages to include."
+    },
+    "exclude": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "default": [],
+      "description": "An array of npm packages to exclude."
+    },
+    "all": {
+      "type": "boolean",
+      "description": "Copy all dependencies and devDependencies from the workspace root package.json.",
+      "default": false
+    }
+  }
+}

package/src/executors/sync-deps/sync-deps.impl.d.ts

@@ -0,0 +1,9 @@
+import { ExecutorContext, ProjectGraph } from '@nx/devkit';
+import { ReactNativeSyncDepsOptions } from './schema';
+import { PackageJson } from 'nx/src/utils/package-json';
+export interface ReactNativeSyncDepsOutput {
+    success: boolean;
+}
+export default function syncDepsExecutor(options: ReactNativeSyncDepsOptions, context: ExecutorContext): AsyncGenerator<ReactNativeSyncDepsOutput>;
+export declare function syncDeps(projectName: string, projectPackageJson: PackageJson, projectPackageJsonPath: string, workspacePackageJson: PackageJson, projectGraph?: ProjectGraph, include?: string[], exclude?: string[], all?: boolean): Promise<string[]>;
+export declare function displayNewlyAddedDepsMessage(projectName: string, deps: string[]): void;

package/src/executors/sync-deps/sync-deps.impl.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayNewlyAddedDepsMessage = exports.syncDeps = void 0;
+const path_1 = require("path");
+const chalk = require("chalk");
+const devkit_1 = require("@nx/devkit");
+const find_all_npm_dependencies_1 = require("../../utils/find-all-npm-dependencies");
+async function* syncDepsExecutor(options, context) {
+    const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
+    const workspacePackageJsonPath = (0, path_1.join)(context.root, 'package.json');
+    const projectPackageJsonPath = (0, path_1.join)(context.root, projectRoot, 'package.json');
+    const workspacePackageJson = (0, devkit_1.readJsonFile)(workspacePackageJsonPath);
+    const projectPackageJson = (0, devkit_1.readJsonFile)(projectPackageJsonPath);
+    displayNewlyAddedDepsMessage(context.projectName, await syncDeps(context.projectName, projectPackageJson, projectPackageJsonPath, workspacePackageJson, context.projectGraph, typeof options.include === 'string'
+        ? options.include.split(',')
+        : options.include, typeof options.exclude === 'string'
+        ? options.exclude.split(',')
+        : options.exclude, options.all));
+    yield { success: true };
+}
+exports.default = syncDepsExecutor;
+async function syncDeps(projectName, projectPackageJson, projectPackageJsonPath, workspacePackageJson, projectGraph = (0, devkit_1.readCachedProjectGraph)(), include = [], exclude = [], all = false) {
+    let npmDeps = all
+        ? Object.keys(workspacePackageJson.dependencies || {})
+        : (0, find_all_npm_dependencies_1.findAllNpmDependencies)(projectGraph, projectName);
+    let npmDevdeps = all
+        ? Object.keys(workspacePackageJson.devDependencies || {})
+        : [];
+    const newDeps = [];
+    let updated = false;
+    if (!projectPackageJson.dependencies) {
+        projectPackageJson.dependencies = {};
+        updated = true;
+    }
+    if (include && include.length) {
+        npmDeps.push(...include);
+    }
+    if (exclude && exclude.length) {
+        npmDeps = npmDeps.filter((dep) => !exclude.includes(dep));
+    }
+    if (!projectPackageJson.devDependencies) {
+        projectPackageJson.devDependencies = {};
+    }
+    if (!projectPackageJson.dependencies) {
+        projectPackageJson.dependencies = {};
+    }
+    npmDeps.forEach((dep) => {
+        if (!projectPackageJson.dependencies[dep] &&
+            !projectPackageJson.devDependencies[dep]) {
+            projectPackageJson.dependencies[dep] = '*';
+            newDeps.push(dep);
+            updated = true;
+        }
+    });
+    npmDevdeps.forEach((dep) => {
+        if (!projectPackageJson.dependencies[dep] &&
+            !projectPackageJson.devDependencies[dep]) {
+            projectPackageJson.devDependencies[dep] = '*';
+            newDeps.push(dep);
+            updated = true;
+        }
+    });
+    if (updated) {
+        (0, devkit_1.writeJsonFile)(projectPackageJsonPath, projectPackageJson);
+    }
+    return newDeps;
+}
+exports.syncDeps = syncDeps;
+function displayNewlyAddedDepsMessage(projectName, deps) {
+    if (deps.length > 0) {
+        devkit_1.logger.info(`${chalk.bold.cyan('info')} Added entries to 'package.json' for '${projectName}' (for autolink):
+  ${deps.map((d) => chalk.bold.cyan(`"${d}": "*"`)).join('\n  ')}`);
+    }
+    else {
+        devkit_1.logger.info(`${chalk.bold.cyan('info')} Dependencies for '${projectName}' are up to date! No changes made.`);
+    }
+}
+exports.displayNewlyAddedDepsMessage = displayNewlyAddedDepsMessage;

package/src/executors/sync-deps/sync-deps.impl.ts

@@ -0,0 +1,140 @@
+import { join } from 'path';
+import * as chalk from 'chalk';
+import {
+  ExecutorContext,
+  ProjectGraph,
+  logger,
+  readCachedProjectGraph,
+  readJsonFile,
+  writeJsonFile,
+} from '@nx/devkit';
+
+import { ReactNativeSyncDepsOptions } from './schema';
+import { findAllNpmDependencies } from '../../utils/find-all-npm-dependencies';
+import { PackageJson } from 'nx/src/utils/package-json';
+
+export interface ReactNativeSyncDepsOutput {
+  success: boolean;
+}
+
+export default async function* syncDepsExecutor(
+  options: ReactNativeSyncDepsOptions,
+  context: ExecutorContext
+): AsyncGenerator<ReactNativeSyncDepsOutput> {
+  const projectRoot =
+    context.projectsConfigurations.projects[context.projectName].root;
+
+  const workspacePackageJsonPath = join(context.root, 'package.json');
+  const projectPackageJsonPath = join(
+    context.root,
+    projectRoot,
+    'package.json'
+  );
+
+  const workspacePackageJson = readJsonFile(workspacePackageJsonPath);
+  const projectPackageJson = readJsonFile(projectPackageJsonPath);
+  displayNewlyAddedDepsMessage(
+    context.projectName,
+    await syncDeps(
+      context.projectName,
+      projectPackageJson,
+      projectPackageJsonPath,
+      workspacePackageJson,
+      context.projectGraph,
+      typeof options.include === 'string'
+        ? options.include.split(',')
+        : options.include,
+      typeof options.exclude === 'string'
+        ? options.exclude.split(',')
+        : options.exclude,
+      options.all
+    )
+  );
+
+  yield { success: true };
+}
+
+export async function syncDeps(
+  projectName: string,
+  projectPackageJson: PackageJson,
+  projectPackageJsonPath: string,
+  workspacePackageJson: PackageJson,
+  projectGraph: ProjectGraph = readCachedProjectGraph(),
+  include: string[] = [],
+  exclude: string[] = [],
+  all: boolean = false
+): Promise<string[]> {
+  let npmDeps = all
+    ? Object.keys(workspacePackageJson.dependencies || {})
+    : findAllNpmDependencies(projectGraph, projectName);
+  let npmDevdeps = all
+    ? Object.keys(workspacePackageJson.devDependencies || {})
+    : [];
+
+  const newDeps = [];
+  let updated = false;
+
+  if (!projectPackageJson.dependencies) {
+    projectPackageJson.dependencies = {};
+    updated = true;
+  }
+
+  if (include && include.length) {
+    npmDeps.push(...include);
+  }
+  if (exclude && exclude.length) {
+    npmDeps = npmDeps.filter((dep) => !exclude.includes(dep));
+  }
+
+  if (!projectPackageJson.devDependencies) {
+    projectPackageJson.devDependencies = {};
+  }
+  if (!projectPackageJson.dependencies) {
+    projectPackageJson.dependencies = {};
+  }
+
+  npmDeps.forEach((dep) => {
+    if (
+      !projectPackageJson.dependencies[dep] &&
+      !projectPackageJson.devDependencies[dep]
+    ) {
+      projectPackageJson.dependencies[dep] = '*';
+      newDeps.push(dep);
+      updated = true;
+    }
+  });
+  npmDevdeps.forEach((dep) => {
+    if (
+      !projectPackageJson.dependencies[dep] &&
+      !projectPackageJson.devDependencies[dep]
+    ) {
+      projectPackageJson.devDependencies[dep] = '*';
+      newDeps.push(dep);
+      updated = true;
+    }
+  });
+
+  if (updated) {
+    writeJsonFile(projectPackageJsonPath, projectPackageJson);
+  }
+
+  return newDeps;
+}
+
+export function displayNewlyAddedDepsMessage(
+  projectName: string,
+  deps: string[]
+) {
+  if (deps.length > 0) {
+    logger.info(`${chalk.bold.cyan(
+      'info'
+    )} Added entries to 'package.json' for '${projectName}' (for autolink):
+  ${deps.map((d) => chalk.bold.cyan(`"${d}": "*"`)).join('\n  ')}`);
+  } else {
+    logger.info(
+      `${chalk.bold.cyan(
+        'info'
+      )} Dependencies for '${projectName}' are up to date! No changes made.`
+    );
+  }
+}

package/src/executors/upgrade/schema.d.ts

@@ -0,0 +1 @@
+export interface UpgradeExecutorSchema {}

package/src/executors/upgrade/schema.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "version": 2,
+  "cli": "nx",
+  "$id": "NxReactNativeUpgrade",
+  "title": "React Native Upgrade Executor",
+  "description": "Upgrade React Native code for project.",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

package/src/executors/upgrade/upgrade.impl.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { ExecutorContext } from '@nx/devkit';
+import { ChildProcess } from 'child_process';
+import { UpgradeExecutorSchema } from './schema';
+export interface ReactNativeUpgradeOutput {
+    success: boolean;
+}
+/**
+ * This executor is equivalent to `npx react-native upgrade`.
+ * https://github.com/react-native-community/cli/blob/main/packages/cli/src/commands/upgrade/upgrade.ts
+ */
+export default function upgradeExecutor(options: UpgradeExecutorSchema, context: ExecutorContext): AsyncGenerator<ReactNativeUpgradeOutput>;
+export declare function runCliUpgrade(workspaceRoot: string, projectRoot: string): Promise<ChildProcess>;