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

package/plugins/jest/svg-mock.js

@@ -0,0 +1,3 @@
+// From https://github.com/kristerkari/react-native-svg-transformer#usage-with-jest
+module.exports = 'SvgMock';
+module.exports.ReactComponent = 'SvgMock';

package/plugins/metro-resolver.d.ts

@@ -0,0 +1 @@
+export declare function getResolveRequest(extensions: string[]): (_context: any, realModuleName: string, platform: string | null) => any;

package/plugins/metro-resolver.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResolveRequest = void 0;
+const metroResolver = require("metro-resolver");
+const tsconfig_paths_1 = require("tsconfig-paths");
+const chalk = require("chalk");
+const enhanced_resolve_1 = require("enhanced-resolve");
+const path_1 = require("path");
+const fs = require("fs");
+const devkit_1 = require("@nx/devkit");
+/*
+ * Use tsconfig to resolve additional workspace libs.
+ *
+ * This resolve function requires projectRoot to be set to
+ * workspace root in order modules and assets to be registered and watched.
+ */
+function getResolveRequest(extensions) {
+    return function (_context, realModuleName, platform) {
+        const debug = process.env.NX_REACT_NATIVE_DEBUG === 'true';
+        if (debug)
+            console.log(chalk.cyan(`[Nx] Resolving: ${realModuleName}`));
+        const { resolveRequest, ...context } = _context;
+        const resolvedPath = resolveRequestFromContext(resolveRequest, _context, realModuleName, platform, debug) ||
+            defaultMetroResolver(context, realModuleName, platform, debug) ||
+            tsconfigPathsResolver(context, extensions, realModuleName, platform, debug) ||
+            pnpmResolver(extensions, context, realModuleName, debug);
+        if (resolvedPath) {
+            return resolvedPath;
+        }
+        if (debug) {
+            console.log(chalk.red(`[Nx] Unable to resolve with any resolver: ${realModuleName}`));
+        }
+        throw new Error(`Cannot resolve ${chalk.bold(realModuleName)}`);
+    };
+}
+exports.getResolveRequest = getResolveRequest;
+function resolveRequestFromContext(resolveRequest, context, realModuleName, platform, debug) {
+    try {
+        return resolveRequest(context, realModuleName, platform);
+    }
+    catch {
+        if (debug)
+            console.log(chalk.cyan(`[Nx] Unable to resolve with default resolveRequest: ${realModuleName}`));
+    }
+}
+/**
+ * This function try to resolve path using metro's default resolver
+ * @returns path if resolved, else undefined
+ */
+function defaultMetroResolver(context, realModuleName, platform, debug) {
+    try {
+        return metroResolver.resolve(context, realModuleName, platform);
+    }
+    catch {
+        if (debug)
+            console.log(chalk.cyan(`[Nx] Unable to resolve with default Metro resolver: ${realModuleName}`));
+    }
+}
+/**
+ * This resolver try to resolve module for pnpm.
+ * @returns path if resolved, else undefined
+ * This pnpm resolver is inspired from https://github.com/vjpr/pnpm-react-native-example/blob/main/packages/pnpm-expo-helper/util/make-resolver.js
+ */
+function pnpmResolver(extensions, context, realModuleName, debug) {
+    try {
+        const pnpmResolve = getPnpmResolver(extensions);
+        const lookupStartPath = (0, path_1.dirname)(context.originModulePath);
+        const filePath = pnpmResolve.resolveSync({}, lookupStartPath, realModuleName);
+        if (filePath) {
+            return { type: 'sourceFile', filePath };
+        }
+    }
+    catch {
+        if (debug)
+            console.log(chalk.cyan(`[Nx] Unable to resolve with default PNPM resolver: ${realModuleName}`));
+    }
+}
+/**
+ * This function try to resolve files that are specified in tsconfig's paths
+ * @returns path if resolved, else undefined
+ */
+function tsconfigPathsResolver(context, extensions, realModuleName, platform, debug) {
+    try {
+        const tsConfigPathMatcher = getMatcher(debug);
+        const match = tsConfigPathMatcher(realModuleName, undefined, undefined, extensions.map((ext) => `.${ext}`));
+        return metroResolver.resolve(context, match, platform);
+    }
+    catch {
+        if (debug) {
+            console.log(chalk.cyan(`[Nx] Failed to resolve ${chalk.bold(realModuleName)}`));
+            console.log(chalk.cyan(`[Nx] The following tsconfig paths was used:\n:${chalk.bold(JSON.stringify(paths, null, 2))}`));
+        }
+    }
+}
+let matcher;
+let absoluteBaseUrl;
+let paths;
+function getMatcher(debug) {
+    if (!matcher) {
+        const result = (0, tsconfig_paths_1.loadConfig)();
+        if (result.resultType === 'success') {
+            absoluteBaseUrl = result.absoluteBaseUrl;
+            paths = result.paths;
+            if (debug) {
+                console.log(chalk.cyan(`[Nx] Located tsconfig at ${chalk.bold(absoluteBaseUrl)}`));
+                console.log(chalk.cyan(`[Nx] Found the following paths:\n:${chalk.bold(JSON.stringify(paths, null, 2))}`));
+            }
+            matcher = (0, tsconfig_paths_1.createMatchPath)(absoluteBaseUrl, paths);
+        }
+        else {
+            console.log(chalk.cyan(`[Nx] Failed to locate tsconfig}`));
+            throw new Error(`Could not load tsconfig for project`);
+        }
+    }
+    return matcher;
+}
+/**
+ * This function returns resolver for pnpm.
+ * It is inspired form https://github.com/vjpr/pnpm-expo-example/blob/main/packages/pnpm-expo-helper/util/make-resolver.js.
+ */
+let resolver;
+function getPnpmResolver(extensions) {
+    if (!resolver) {
+        const fileSystem = new enhanced_resolve_1.CachedInputFileSystem(fs, 4000);
+        resolver = enhanced_resolve_1.ResolverFactory.createResolver({
+            fileSystem,
+            extensions: extensions.map((extension) => '.' + extension),
+            useSyncFileSystemCalls: true,
+            modules: [(0, path_1.join)(devkit_1.workspaceRoot, 'node_modules'), 'node_modules'],
+            conditionNames: ['native', 'browser', 'require', 'default'],
+            mainFields: ['react-native', 'browser', 'main'],
+            aliasFields: ['browser'],
+        });
+    }
+    return resolver;
+}

package/plugins/plugin.d.ts

@@ -0,0 +1,14 @@
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
+export interface ReactNativePluginOptions {
+    startTargetName?: string;
+    podInstallTargetName?: string;
+    runIosTargetName?: string;
+    runAndroidTargetName?: string;
+    buildIosTargetName?: string;
+    buildAndroidTargetName?: string;
+    bundleTargetName?: string;
+    syncDepsTargetName?: string;
+    upgradeTargetname?: string;
+}
+export declare const createDependencies: CreateDependencies;
+export declare const createNodes: CreateNodes<ReactNativePluginOptions>;

package/plugins/plugin.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const js_1 = require("@nx/js");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const fs_1 = require("fs");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'react-native.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/app.{json,config.js}',
+    (configFilePath, options, context) => {
+        options = normalizeOptions(options);
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        // Do not create a project if package.json or project.json or metro.config.js isn't there.
+        const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+        if (!siblingFiles.includes('package.json') ||
+            !siblingFiles.includes('metro.config.js')) {
+            return {};
+        }
+        const appConfig = getAppConfig(configFilePath, context);
+        if (appConfig.expo) {
+            return {};
+        }
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [
+            (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
+        ]);
+        const targets = targetsCache[hash]
+            ? targetsCache[hash]
+            : buildReactNativeTargets(projectRoot, options, context);
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    targets,
+                },
+            },
+        };
+    },
+];
+function buildReactNativeTargets(projectRoot, options, context) {
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {
+        [options.startTargetName]: {
+            command: `react-native start`,
+            options: { cwd: projectRoot },
+        },
+        [options.podInstallTargetName]: {
+            command: `pod install`,
+            options: { cwd: (0, devkit_1.joinPathFragments)(projectRoot, 'ios') },
+            dependsOn: [`${options.syncDepsTargetName}`],
+            cache: true,
+            inputs: getInputs(namedInputs),
+            outputs: [
+                getOutputs(projectRoot, 'ios/Pods'),
+                getOutputs(projectRoot, 'ios/Podfile.lock'),
+            ],
+        },
+        [options.runIosTargetName]: {
+            command: `react-native run-ios`,
+            options: { cwd: projectRoot },
+        },
+        [options.runAndroidTargetName]: {
+            command: `react-native run-android`,
+            options: { cwd: projectRoot },
+        },
+        [options.buildIosTargetName]: {
+            command: `react-native build-ios`,
+            options: { cwd: projectRoot },
+            cache: true,
+            dependsOn: [`^${options.buildIosTargetName}`],
+            inputs: getInputs(namedInputs),
+            outputs: [getOutputs(projectRoot, 'ios/build/Build/Products')],
+        },
+        [options.buildAndroidTargetName]: {
+            command: `react-native build-android`,
+            options: { cwd: projectRoot },
+            cache: true,
+            dependsOn: [`^${options.buildAndroidTargetName}`],
+            inputs: getInputs(namedInputs),
+            outputs: [getOutputs(projectRoot, 'android/app/build/outputs')],
+        },
+        [options.bundleTargetName]: {
+            command: `react-native bundle`,
+            options: { cwd: projectRoot },
+            dependsOn: [`^${options.bundleTargetName}`],
+            inputs: getInputs(namedInputs),
+        },
+        [options.syncDepsTargetName]: {
+            executor: '@nx/react-native:sync-deps',
+        },
+        [options.upgradeTargetname]: {
+            command: `react-native upgrade`,
+            options: { cwd: projectRoot },
+        },
+    };
+    return targets;
+}
+function getAppConfig(configFilePath, context) {
+    const resolvedPath = (0, path_1.join)(context.workspaceRoot, configFilePath);
+    let module = load(resolvedPath);
+    return module.default ?? module;
+}
+function getInputs(namedInputs) {
+    return [
+        ...('production' in namedInputs
+            ? ['default', '^production']
+            : ['default', '^default']),
+        {
+            externalDependencies: ['react-native'],
+        },
+    ];
+}
+function getOutputs(projectRoot, dir) {
+    if (projectRoot === '.') {
+        return `{projectRoot}/${dir}`;
+    }
+    else {
+        return `{workspaceRoot}/${projectRoot}/${dir}`;
+    }
+}
+/**
+ * Load the module after ensuring that the require cache is cleared.
+ */
+function load(path) {
+    // Clear cache if the path is in the cache
+    if (require.cache[path]) {
+        for (const k of Object.keys(require.cache)) {
+            delete require.cache[k];
+        }
+    }
+    // Then require
+    return require(path);
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.startTargetName ??= 'start';
+    options.podInstallTargetName ??= 'pod-install';
+    options.runIosTargetName ??= 'run-ios';
+    options.runAndroidTargetName ??= 'run-android';
+    options.buildIosTargetName ??= 'build-ios';
+    options.buildAndroidTargetName ??= 'build-android';
+    options.bundleTargetName ??= 'bundle';
+    options.syncDepsTargetName ??= 'sync-deps';
+    options.upgradeTargetname ??= 'upgrade';
+    return options;
+}

package/plugins/with-nx-metro.d.ts

@@ -0,0 +1,8 @@
+import type { MetroConfig } from 'metro-config';
+interface WithNxOptions {
+    debug?: boolean;
+    extensions?: string[];
+    watchFolders?: string[];
+}
+export declare function withNxMetro(userConfig: MetroConfig, opts?: WithNxOptions): Promise<import("metro-config").ConfigT>;
+export {};

package/plugins/with-nx-metro.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withNxMetro = void 0;
+const devkit_1 = require("@nx/devkit");
+const metro_config_1 = require("metro-config");
+const fs_extra_1 = require("fs-extra");
+const metro_resolver_1 = require("./metro-resolver");
+async function withNxMetro(userConfig, opts = {}) {
+    const extensions = ['', 'ts', 'tsx', 'js', 'jsx', 'json'];
+    if (opts.debug)
+        process.env.NX_REACT_NATIVE_DEBUG = 'true';
+    if (opts.extensions)
+        extensions.push(...opts.extensions);
+    let watchFolders = (0, fs_extra_1.readdirSync)(devkit_1.workspaceRoot)
+        .filter((fileName) => !['dist', 'e2e'].includes(fileName) && !fileName.startsWith('.'))
+        .map((fileName) => (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, fileName))
+        .filter((filePath) => (0, fs_extra_1.statSync)(filePath).isDirectory());
+    if (opts.watchFolders?.length) {
+        watchFolders = watchFolders.concat(opts.watchFolders);
+    }
+    watchFolders = [...new Set(watchFolders)].filter((folder) => (0, fs_extra_1.existsSync)(folder));
+    const nxConfig = {
+        resolver: {
+            resolveRequest: (0, metro_resolver_1.getResolveRequest)(extensions),
+            nodeModulesPaths: [(0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, 'node_modules')],
+        },
+        watchFolders,
+    };
+    return (0, metro_config_1.mergeConfig)(userConfig, nxConfig);
+}
+exports.withNxMetro = withNxMetro;

package/project.json

@@ -0,0 +1,54 @@
+{
+  "name": "react-native",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/react-native/src",
+  "projectType": "library",
+  "targets": {
+    "lint": {},
+    "test": {},
+    "build-base": {
+      "executor": "@nx/js:tsc",
+      "options": {
+        "assets": [
+          "packages/react-native/*.md",
+          {
+            "input": "packages/react-native",
+            "glob": "**/files/**/.babelrc.template",
+            "output": "/"
+          },
+          {
+            "input": "packages/react-native/src",
+            "glob": "**/*.!(ts)",
+            "output": "/src"
+          },
+          {
+            "input": "packages/react-native",
+            "glob": "**/*.json",
+            "ignore": ["**/tsconfig*.json"],
+            "output": "/"
+          },
+          {
+            "input": "packages/react-native",
+            "glob": "**/*.d.ts",
+            "output": "/"
+          },
+          {
+            "input": "",
+            "glob": "LICENSE",
+            "output": "/"
+          }
+        ]
+      }
+    },
+    "build": {
+      "executor": "nx:run-commands",
+      "outputs": ["{workspaceRoot}/build/packages/react-native"],
+      "options": {
+        "command": "node ./scripts/copy-readme.js react-native"
+      }
+    },
+    "add-extra-dependencies": {
+      "command": "node ./scripts/add-dependency-to-build.js react-native @nrwl/react-native"
+    }
+  }
+}

package/src/executors/build-android/build-android.impl.d.ts

@@ -0,0 +1,6 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ReactNativeBuildAndroidOptions } from './schema';
+export interface ReactNativeBuildOutput {
+    success: boolean;
+}
+export default function buildAndroidExecutor(options: ReactNativeBuildAndroidOptions, context: ExecutorContext): AsyncGenerator<ReactNativeBuildOutput>;

package/src/executors/build-android/build-android.impl.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const chmod_android_gradle_files_1 = require("../../utils/chmod-android-gradle-files");
+const get_cli_options_1 = require("../../utils/get-cli-options");
+async function* buildAndroidExecutor(options, context) {
+    const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
+    (0, chmod_android_gradle_files_1.chmodAndroidGradlewFiles)((0, path_1.join)(context.root, projectRoot, 'android'));
+    await runCliBuild(context.root, projectRoot, options);
+    yield { success: true };
+}
+exports.default = buildAndroidExecutor;
+function runCliBuild(workspaceRoot, projectRoot, options) {
+    return new Promise((res, reject) => {
+        const childProcess = (0, child_process_1.fork)(require.resolve('react-native/cli.js'), ['build-android', ...createBuildAndroidOptions(options)], {
+            stdio: 'inherit',
+            cwd: (0, path_1.resolve)(workspaceRoot, projectRoot),
+            env: { ...process.env, RCT_METRO_PORT: options.port.toString() },
+        });
+        /**
+         * Ensure the child process is killed when the parent exits
+         */
+        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);
+        childProcess.on('error', (err) => {
+            reject(err);
+        });
+        childProcess.on('exit', (code) => {
+            if (code === 0) {
+                res(childProcess);
+            }
+            else {
+                reject(code);
+            }
+        });
+    });
+}
+const startOptions = ['port', 'resetCache'];
+function createBuildAndroidOptions(options) {
+    return (0, get_cli_options_1.getCliOptions)(options, startOptions);
+}

package/src/executors/build-android/build-android.impl.ts

@@ -0,0 +1,69 @@
+import { ExecutorContext } from '@nx/devkit';
+import { join, resolve as pathResolve } from 'path';
+import { ChildProcess, fork } from 'child_process';
+import { ReactNativeBuildAndroidOptions } from './schema';
+import { chmodAndroidGradlewFiles } from '../../utils/chmod-android-gradle-files';
+import { getCliOptions } from '../../utils/get-cli-options';
+
+export interface ReactNativeBuildOutput {
+  success: boolean;
+}
+
+export default async function* buildAndroidExecutor(
+  options: ReactNativeBuildAndroidOptions,
+  context: ExecutorContext
+): AsyncGenerator<ReactNativeBuildOutput> {
+  const projectRoot =
+    context.projectsConfigurations.projects[context.projectName].root;
+  chmodAndroidGradlewFiles(join(context.root, projectRoot, 'android'));
+
+  await runCliBuild(context.root, projectRoot, options);
+  yield { success: true };
+}
+
+function runCliBuild(
+  workspaceRoot: string,
+  projectRoot: string,
+  options: ReactNativeBuildAndroidOptions
+) {
+  return new Promise<ChildProcess>((res, reject) => {
+    const childProcess = fork(
+      require.resolve('react-native/cli.js'),
+      ['build-android', ...createBuildAndroidOptions(options)],
+      {
+        stdio: 'inherit',
+        cwd: pathResolve(workspaceRoot, projectRoot),
+        env: { ...process.env, RCT_METRO_PORT: options.port.toString() },
+      }
+    );
+
+    /**
+     * Ensure the child process is killed when the parent exits
+     */
+    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);
+
+    childProcess.on('error', (err) => {
+      reject(err);
+    });
+    childProcess.on('exit', (code) => {
+      if (code === 0) {
+        res(childProcess);
+      } else {
+        reject(code);
+      }
+    });
+  });
+}
+
+const startOptions = ['port', 'resetCache'];
+
+function createBuildAndroidOptions(options: ReactNativeBuildAndroidOptions) {
+  return getCliOptions<ReactNativeBuildAndroidOptions>(options, startOptions);
+}

package/src/executors/build-android/schema.d.ts

@@ -0,0 +1,14 @@
+// options taken from https://github.com/react-native-community/cli/blob/main/packages/cli-platform-android/src/commands/buildAndroid/index.ts
+// https://github.com/react-native-community/cli/blob/main/packages/cli-platform-android/README.md#build-android
+
+import { ReactNativeStartOptions } from '../start/schema';
+
+export interface ReactNativeBuildAndroidOptions
+  extends ReactNativeStartOptions {
+  // react native options
+  mode: string; // default is debug
+  activeArchOnly: boolean; // default is false
+  tasks?: string | Array<string>;
+  extraParams?: Array<string>;
+  interactive: boolean;
+}

package/src/executors/build-android/schema.json

@@ -0,0 +1,81 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "cli": "nx",
+  "$id": "NxReactNativeBuildAndroid",
+  "$schema": "https://json-schema.org/schema",
+  "title": "Release Build for Android",
+  "description": "Build target options for Android.",
+  "type": "object",
+  "presets": [
+    {
+      "name": "Build Android for current device architecture",
+      "keys": ["activeArchOnly"]
+    },
+    {
+      "name": "Build Android without metro cache",
+      "keys": ["resetCache"]
+    },
+    {
+      "name": "Build Android with specific tasks",
+      "keys": ["tasks"]
+    },
+    {
+      "name": "Build Android with a specific mode",
+      "keys": ["mode"]
+    }
+  ],
+  "properties": {
+    "mode": {
+      "type": "string",
+      "description": "Specify your app's build variant",
+      "default": "debug",
+      "examples": ["debug", "release"],
+      "x-priority": "important"
+    },
+    "port": {
+      "type": "number",
+      "description": "The port where the packager server is listening on.",
+      "default": 8081
+    },
+    "tasks": {
+      "oneOf": [
+        { "type": "array", "items": { "type": "string" } },
+        { "type": "string" }
+      ],
+      "description": "Run custom Gradle tasks. By default it's \"assembleDebug\". Will override passed mode and variant arguments.",
+      "examples": [
+        "assembleDebug",
+        "assembleRelease",
+        "bundleDebug",
+        "bundleRelease",
+        "installDebug",
+        "installRelease"
+      ]
+    },
+    "activeArchOnly": {
+      "type": "boolean",
+      "description": "Build native libraries only for the current device architecture for debug builds.",
+      "default": false
+    },
+    "extraParams": {
+      "oneOf": [
+        { "type": "array", "items": { "type": "string" } },
+        { "type": "string" }
+      ],
+      "description": "Custom params passed to gradle build command",
+      "examples": ["-x lint -x test"]
+    },
+    "interactive": {
+      "type": "boolean",
+      "description": "Explicitly select build type and flavour to use before running a build"
+    },
+    "resetCache": {
+      "type": "boolean",
+      "description": "Resets metro cache.",
+      "default": false
+    }
+  },
+  "required": [],
+  "examplesFile": "../../../docs/build-android-examples.md"
+}

package/src/executors/build-ios/build-ios.impl.d.ts

@@ -0,0 +1,6 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ReactNativeBuildIosOptions } from './schema';
+export interface ReactNativeBuildIosOutput {
+    success: boolean;
+}
+export default function buildIosExecutor(options: ReactNativeBuildIosOptions, context: ExecutorContext): AsyncGenerator<ReactNativeBuildIosOutput>;