@nx/detox 0.0.0-pr-22179-271588f

package/src/generators/application/lib/get-targets.d.ts

@@ -0,0 +1,51 @@
+export declare function reactNativeBuildTarget(platform: 'ios.sim' | 'android.emu'): {
+    options: {
+        detoxConfiguration: string;
+    };
+    configurations: {
+        production: {
+            detoxConfiguration: string;
+        };
+    };
+};
+export declare function expoBuildTarget(platform: 'ios.sim' | 'android.emu'): {
+    options: {
+        detoxConfiguration: string;
+    };
+    configurations: {
+        bare: {
+            detoxConfiguration: string;
+        };
+        production: {
+            detoxConfiguration: string;
+        };
+    };
+};
+export declare function reactNativeTestTarget(platform: 'ios.sim' | 'android.emu', e2eName: string): {
+    options: {
+        detoxConfiguration: string;
+        buildTarget: string;
+    };
+    configurations: {
+        production: {
+            detoxConfiguration: string;
+            buildTarget: string;
+        };
+    };
+};
+export declare function expoTestTarget(platform: 'ios.sim' | 'android.emu', e2eName: string): {
+    options: {
+        detoxConfiguration: string;
+        buildTarget: string;
+    };
+    configurations: {
+        bare: {
+            detoxConfiguration: string;
+            buildTarget: string;
+        };
+        production: {
+            detoxConfiguration: string;
+            buildTarget: string;
+        };
+    };
+};

package/src/generators/application/lib/get-targets.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expoTestTarget = exports.reactNativeTestTarget = exports.expoBuildTarget = exports.reactNativeBuildTarget = void 0;
+function reactNativeBuildTarget(platform) {
+    return {
+        options: {
+            detoxConfiguration: `${platform}.debug`,
+        },
+        configurations: {
+            production: {
+                detoxConfiguration: `${platform}.release`,
+            },
+        },
+    };
+}
+exports.reactNativeBuildTarget = reactNativeBuildTarget;
+function expoBuildTarget(platform) {
+    return {
+        options: {
+            detoxConfiguration: `${platform}.local`,
+        },
+        configurations: {
+            bare: {
+                detoxConfiguration: `${platform}.debug`,
+            },
+            production: {
+                detoxConfiguration: `${platform}.release`,
+            },
+        },
+    };
+}
+exports.expoBuildTarget = expoBuildTarget;
+function reactNativeTestTarget(platform, e2eName) {
+    const buildPlatform = platform === 'ios.sim' ? 'ios' : 'android';
+    return {
+        options: {
+            detoxConfiguration: `${platform}.debug`,
+            buildTarget: `${e2eName}:build-${buildPlatform}`,
+        },
+        configurations: {
+            production: {
+                detoxConfiguration: `${platform}.release`,
+                buildTarget: `${e2eName}:build-${buildPlatform}:production`,
+            },
+        },
+    };
+}
+exports.reactNativeTestTarget = reactNativeTestTarget;
+function expoTestTarget(platform, e2eName) {
+    const buildPlatform = platform === 'ios.sim' ? 'ios' : 'android';
+    return {
+        options: {
+            detoxConfiguration: `${platform}.local`,
+            buildTarget: `${e2eName}:build-${buildPlatform}`,
+        },
+        configurations: {
+            bare: {
+                detoxConfiguration: `${platform}.debug`,
+                buildTarget: `${e2eName}:build-${buildPlatform}:bare`,
+            },
+            production: {
+                detoxConfiguration: `${platform}.release`,
+                buildTarget: `${e2eName}:build-${buildPlatform}:production`,
+            },
+        },
+    };
+}
+exports.expoTestTarget = expoTestTarget;

package/src/generators/application/lib/normalize-options.d.ts

@@ -0,0 +1,11 @@
+import { Tree } from '@nx/devkit';
+import { Schema } from '../schema';
+export interface NormalizedSchema extends Schema {
+    appFileName: string;
+    appClassName: string;
+    appExpoName: string;
+    appRoot: string;
+    e2eProjectName: string;
+    e2eProjectRoot: string;
+}
+export declare function normalizeOptions(host: Tree, options: Schema): Promise<NormalizedSchema>;

package/src/generators/application/lib/normalize-options.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = void 0;
+const devkit_1 = require("@nx/devkit");
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+async function normalizeOptions(host, options) {
+    const { projectName: e2eProjectName, projectRoot: e2eProjectRoot } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+        name: options.e2eName,
+        projectType: 'application',
+        directory: options.e2eDirectory,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        callingGenerator: '@nx/detox:application',
+    });
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPlugin;
+    const { fileName: appFileName, className: appClassName } = (0, devkit_1.names)(options.appName || options.appProject);
+    const { root: appRoot } = (0, devkit_1.readProjectConfiguration)(host, (0, devkit_1.names)(options.appProject).fileName);
+    return {
+        ...options,
+        appFileName,
+        appClassName,
+        appDisplayName: options.appDisplayName || appClassName,
+        appExpoName: options.appDisplayName?.replace(/\s/g, '') || appClassName,
+        appRoot,
+        e2eName: e2eProjectName,
+        e2eProjectName,
+        e2eProjectRoot,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/src/generators/application/schema.json

@@ -0,0 +1,72 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "title": "Create Detox Configuration for the workspace",
+  "description": "Create Detox Configuration for the workspace.",
+  "type": "object",
+  "properties": {
+    "appProject": {
+      "type": "string",
+      "description": "Name of the frontend project to be tested.",
+      "$default": {
+        "$source": "projectName"
+      },
+      "x-prompt": "What is the name of the frontend project to test?"
+    },
+    "e2eName": {
+      "type": "string",
+      "description": "Name of the E2E Project.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the E2E project?",
+      "pattern": "^[a-zA-Z][^:]*$"
+    },
+    "appName": {
+      "type": "string",
+      "description": "Name of the app to be tested if different from appProject"
+    },
+    "appDisplayName": {
+      "type": "string",
+      "description": "Display name of the app to be tested if different from appProject"
+    },
+    "framework": {
+      "type": "string",
+      "description": "App framework to test",
+      "enum": ["react-native", "expo"],
+      "x-prompt": "What app framework should detox test?"
+    },
+    "e2eDirectory": {
+      "type": "string",
+      "description": "A directory where the project is placed relative to apps directory."
+    },
+    "projectNameAndRootFormat": {
+      "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint", "none"],
+      "default": "eslint"
+    },
+    "js": {
+      "description": "Generate JavaScript files rather than TypeScript files.",
+      "type": "boolean",
+      "default": false
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "default": false
+    }
+  },
+  "required": ["e2eName", "appProject", "framework"]
+}

package/src/generators/init/init.d.ts

@@ -0,0 +1,6 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function detoxInitGenerator(host: Tree, schema: Schema): Promise<GeneratorCallback>;
+export declare function detoxInitGeneratorInternal(host: Tree, schema: Schema): Promise<GeneratorCallback>;
+export declare function updateDependencies(host: Tree, schema: Schema): GeneratorCallback;
+export default detoxInitGenerator;

package/src/generators/init/init.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateDependencies = exports.detoxInitGeneratorInternal = exports.detoxInitGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const plugin_1 = require("../../plugins/plugin");
+const versions_1 = require("../../utils/versions");
+function detoxInitGenerator(host, schema) {
+    return detoxInitGeneratorInternal(host, { addPlugin: false, ...schema });
+}
+exports.detoxInitGenerator = detoxInitGenerator;
+async function detoxInitGeneratorInternal(host, schema) {
+    const tasks = [];
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    schema.addPlugin ??= addPluginDefault;
+    if (!schema.skipPackageJson) {
+        tasks.push(moveDependency(host));
+        tasks.push(updateDependencies(host, schema));
+    }
+    if (schema.addPlugin) {
+        addPlugin(host);
+    }
+    if (schema.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(host, plugin_1.createNodes);
+    }
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(host);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.detoxInitGeneratorInternal = detoxInitGeneratorInternal;
+function updateDependencies(host, schema) {
+    return (0, devkit_1.addDependenciesToPackageJson)(host, {}, {
+        '@nx/detox': versions_1.nxVersion,
+        detox: versions_1.detoxVersion,
+    }, undefined, schema.keepExistingVersions);
+}
+exports.updateDependencies = updateDependencies;
+function moveDependency(host) {
+    return (0, devkit_1.removeDependenciesFromPackageJson)(host, ['@nx/detox'], []);
+}
+function addPlugin(host) {
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    nxJson.plugins ??= [];
+    for (const plugin of nxJson.plugins) {
+        if (typeof plugin === 'string'
+            ? plugin === '@nx/detox/plugin'
+            : plugin.plugin === '@nx/detox/plugin') {
+            return;
+        }
+    }
+    nxJson.plugins.push({
+        plugin: '@nx/detox/plugin',
+        options: {
+            buildTargetName: 'build',
+            startTargetName: 'start',
+            testTargetName: 'test',
+        },
+    });
+    (0, devkit_1.updateNxJson)(host, nxJson);
+}
+exports.default = detoxInitGenerator;

package/src/generators/init/schema.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "title": "Add Detox Schematics",
+  "description": "Add Detox Schematics.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/migrations/update-16-0-0/update-detoxrc-json.d.ts

@@ -0,0 +1,10 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Update .detoxrc.json under detox project:
+ * - remove deprecated keys: testRunner
+ * - update keys: runnerConfig
+ * Update jest.config.json under detox project:
+ * - remove key: transform
+ * - add key: rootDir, testMatch, reporter, globalSetup, globalTeardown, verbose
+ */
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0/update-detoxrc-json.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+/**
+ * Update .detoxrc.json under detox project:
+ * - remove deprecated keys: testRunner
+ * - update keys: runnerConfig
+ * Update jest.config.json under detox project:
+ * - remove key: transform
+ * - add key: rootDir, testMatch, reporter, globalSetup, globalTeardown, verbose
+ */
+async function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    projects.forEach((project) => {
+        if (project.targets?.['test-ios']?.executor !== '@nx/detox:test')
+            return;
+        updateDetoxrcJson(tree, project);
+        updateJestConfigJson(tree, project);
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;
+function updateDetoxrcJson(host, project) {
+    const detoxConfigPath = `${project.root}/.detoxrc.json`;
+    if (!host.exists(detoxConfigPath))
+        return;
+    (0, devkit_1.updateJson)(host, detoxConfigPath, (json) => {
+        json.testRunner = {
+            args: {
+                $0: 'jest',
+                config: './jest.config.json',
+            },
+            jest: {
+                setupTimeout: 120000,
+            },
+        };
+        if (json.runnerConfig) {
+            delete json.runnerConfig;
+        }
+        return json;
+    });
+}
+function updateJestConfigJson(host, project) {
+    const jestConfigPath = `${project.root}/jest.config.json`;
+    if (!host.exists(jestConfigPath))
+        return;
+    (0, devkit_1.updateJson)(host, jestConfigPath, (json) => {
+        if (json.transform) {
+            delete json.transform;
+        }
+        if (!json.rootDir) {
+            json.rootDir = '.';
+        }
+        if (!json.testMatch) {
+            json.testMatch = [
+                '<rootDir>/src/**/*.test.ts?(x)',
+                '<rootDir>/src/**/*.spec.ts?(x)',
+            ];
+        }
+        json.reporter = ['detox/runners/jest/reporter'];
+        json.globalSetup = 'detox/runners/jest/globalSetup';
+        json.globalTeardown = 'detox/runners/jest/globalTeardown';
+        json.verbose = true;
+        return json;
+    });
+}

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/detox', '@nx/detox');
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/migrations/update-16-1-4/update-detoxrc-json-expo.d.ts

@@ -0,0 +1,8 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Update .detoxrc.json under detox project for expo:
+ * - fix the eas build command
+ * - fix the local build command
+ * - update project.json targets
+ */
+export default function update(tree: Tree): Promise<void>;

package/src/migrations/update-16-1-4/update-detoxrc-json-expo.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+/**
+ * Update .detoxrc.json under detox project for expo:
+ * - fix the eas build command
+ * - fix the local build command
+ * - update project.json targets
+ */
+async function update(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    projects.forEach((project) => {
+        if (project.targets?.['test-ios']?.executor !== '@nx/detox:test')
+            return;
+        updateDetoxrcJson(tree, project);
+        updateProjectJson(tree, project);
+    });
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = update;
+function updateDetoxrcJson(host, project) {
+    const detoxConfigPath = `${project.root}/.detoxrc.json`;
+    const projectName = project.name?.endsWith('-e2e')
+        ? project.name.substring(0, project.name.indexOf('-e2e'))
+        : project.name;
+    const appRoot = (0, devkit_1.getProjects)(host).get(projectName)?.root;
+    const appName = (0, devkit_1.names)(projectName).className;
+    const offset = (0, devkit_1.offsetFromRoot)(project.root);
+    const exec = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(host.root)).exec;
+    if (!host.exists(detoxConfigPath))
+        return;
+    (0, devkit_1.updateJson)(host, detoxConfigPath, (json) => {
+        if (json.apps?.['ios.eas']) {
+            json.apps['ios.eas'].build = `${exec} nx run ${projectName}:download --platform ios --distribution simulator --output=${offset}${appRoot}/dist/`;
+        }
+        if (json.apps?.['android.eas']) {
+            json.apps['android.eas'].build = `${exec} nx run ${projectName}:download --platform android --distribution simulator --output=${offset}${appRoot}/dist/`;
+            json.apps['android.eas'].type = 'android.apk';
+        }
+        if (json.apps?.['ios.local']) {
+            json.apps['ios.local'].build = `${exec} nx run ${projectName}:build --platform ios --profile preview --wait --local --no-interactive --output=${offset}${appRoot}/dist/${appName}.tar.gz`;
+        }
+        if (json.apps?.['android.local']) {
+            json.apps['android.local'].build = `${exec} nx run ${projectName}:build --platform android --profile preview --wait --local --no-interactive --output=${offset}${appRoot}/dist/${appName}.apk`;
+            json.apps['android.local'].type = 'android.apk';
+        }
+        return json;
+    });
+}
+function updateProjectJson(host, project) {
+    if (project.targets?.['test-ios']?.options?.detoxConfiguration == 'ios.sim.eas') {
+        project.targets['build-ios'].options.detoxConfiguration = 'ios.sim.eas';
+    }
+    if (project.targets?.['test-android']?.options?.detoxConfiguration ==
+        'android.sim.eas') {
+        project.targets['build-android'].options.detoxConfiguration =
+            'android.sim.eas';
+        project.targets['test-android'] = {
+            executor: '@nx/detox:test',
+            options: {
+                detoxConfiguration: 'android.sim.eas',
+                buildTarget: `${project.name}:build-android`,
+            },
+            configurations: {
+                local: {
+                    detoxConfiguration: 'android.emu.local',
+                    buildTarget: `${project.name}:build-android:local`,
+                },
+                bare: {
+                    detoxConfiguration: 'android.emu.debug',
+                    buildTarget: `${project.name}:build-android:bare`,
+                },
+                production: {
+                    detoxConfiguration: 'android.emu.release',
+                    buildTarget: `${project.name}:build-android:production`,
+                },
+            },
+        };
+    }
+    (0, devkit_1.updateProjectConfiguration)(host, project.name, project);
+}

package/src/plugins/plugin.d.ts

@@ -0,0 +1,8 @@
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
+export interface DetoxPluginOptions {
+    buildTargetName?: string;
+    startTargetName?: string;
+    testTargetName?: string;
+}
+export declare const createDependencies: CreateDependencies;
+export declare const createNodes: CreateNodes<DetoxPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,89 @@
+"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, 'detox.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 = [
+    '**/{detox.config,.detoxrc}.{json,js}',
+    (configFilePath, options, context) => {
+        options = normalizeOptions(options);
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        // Do not create a project if project.json isn't there.
+        const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+        if (!siblingFiles.includes('project.json')) {
+            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]
+            : buildDetoxTargets(projectRoot, options, context);
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    targets,
+                },
+            },
+        };
+    },
+];
+function buildDetoxTargets(projectRoot, options, context) {
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {
+        [options.buildTargetName]: {
+            command: `detox build`,
+            options: { cwd: projectRoot },
+            cache: true,
+            inputs: getInputs(namedInputs),
+        },
+        [options.startTargetName]: {
+            command: `detox start`,
+            options: { cwd: projectRoot },
+        },
+        [options.testTargetName]: {
+            command: `detox test`,
+            options: { cwd: projectRoot },
+            cache: true,
+            inputs: getInputs(namedInputs),
+        },
+    };
+    return targets;
+}
+function getInputs(namedInputs) {
+    return [
+        ...('production' in namedInputs
+            ? ['default', '^production']
+            : ['default', '^default']),
+        {
+            externalDependencies: ['detox'],
+        },
+    ];
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.buildTargetName ??= 'build';
+    options.startTargetName ??= 'start';
+    options.testTargetName ??= 'test';
+    return options;
+}

package/src/utils/versions.d.ts

@@ -0,0 +1,4 @@
+export declare const nxVersion: any;
+export declare const detoxVersion = "~20.18.1";
+export declare const testingLibraryJestDom = "~6.4.2";
+export declare const configPluginsDetoxVersion = "~7.0.0";

package/src/utils/versions.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configPluginsDetoxVersion = exports.testingLibraryJestDom = exports.detoxVersion = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+exports.detoxVersion = '~20.18.1';
+exports.testingLibraryJestDom = '~6.4.2';
+exports.configPluginsDetoxVersion = '~7.0.0'; // only required for expo