@ohos-ports/nx 19.8.4-beta.0

package/src/command-line/init/init-v2.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.installPlugins = installPlugins;
+exports.initHandler = initHandler;
+exports.detectPlugins = detectPlugins;
+const fs_1 = require("fs");
+const semver_1 = require("semver");
+const output_1 = require("../../utils/output");
+const package_manager_1 = require("../../utils/package-manager");
+const add_nx_scripts_1 = require("./implementation/dot-nx/add-nx-scripts");
+const child_process_1 = require("../../utils/child-process");
+const fileutils_1 = require("../../utils/fileutils");
+const versions_1 = require("../../utils/versions");
+const utils_1 = require("./implementation/utils");
+const enquirer_1 = require("enquirer");
+const child_process_2 = require("child_process");
+const angular_1 = require("./implementation/angular");
+const workspace_context_1 = require("../../utils/workspace-context");
+const connect_to_nx_cloud_1 = require("../connect/connect-to-nx-cloud");
+const add_nx_to_npm_repo_1 = require("./implementation/add-nx-to-npm-repo");
+const add_nx_to_monorepo_1 = require("./implementation/add-nx-to-monorepo");
+const nx_json_1 = require("../../config/nx-json");
+const get_package_name_from_import_path_1 = require("../../utils/get-package-name-from-import-path");
+function installPlugins(repoRoot, plugins, pmc, updatePackageScripts) {
+    if (plugins.length === 0) {
+        return;
+    }
+    (0, utils_1.addDepsToPackageJson)(repoRoot, plugins);
+    (0, utils_1.runInstall)(repoRoot, pmc);
+    output_1.output.log({ title: '🔨 Configuring plugins' });
+    for (const plugin of plugins) {
+        (0, child_process_2.execSync)(`${pmc.exec} nx g ${plugin}:init --keepExistingVersions ${updatePackageScripts ? '--updatePackageScripts' : ''}`, {
+            stdio: [0, 1, 2],
+            cwd: repoRoot,
+            windowsHide: true,
+        });
+    }
+}
+async function initHandler(options) {
+    process.env.NX_RUNNING_NX_INIT = 'true';
+    const version = process.env.NX_VERSION ?? ((0, semver_1.prerelease)(versions_1.nxVersion) ? 'next' : 'latest');
+    if (process.env.NX_VERSION) {
+        output_1.output.log({ title: `Using version ${process.env.NX_VERSION}` });
+    }
+    if (!(0, fs_1.existsSync)('package.json') || options.useDotNxInstallation) {
+        if (process.platform !== 'win32') {
+            console.log('Setting Nx up installation in `.nx`. You can run Nx commands like: `./nx --help`');
+        }
+        else {
+            console.log('Setting Nx up installation in `.nx`. You can run Nx commands like: `./nx.bat --help`');
+        }
+        (0, add_nx_scripts_1.generateDotNxSetup)(version);
+        const nxJson = (0, nx_json_1.readNxJson)(process.cwd());
+        const { plugins } = await detectPlugins(nxJson, options.interactive);
+        plugins.forEach((plugin) => {
+            (0, child_process_1.runNxSync)(`add ${plugin}`, {
+                stdio: 'inherit',
+            });
+        });
+        // invokes the wrapper, thus invoking the initial installation process
+        (0, child_process_1.runNxSync)('--version', { stdio: 'ignore' });
+        return;
+    }
+    // TODO(jack): Remove this Angular logic once `@nx/angular` is compatible with inferred targets.
+    if ((0, fs_1.existsSync)('angular.json')) {
+        await (0, angular_1.addNxToAngularCliRepo)({
+            ...options,
+            integrated: !!options.integrated,
+        });
+        (0, utils_1.printFinalMessage)({
+            learnMoreLink: 'https://nx.dev/recipes/angular/migration/angular',
+        });
+        return;
+    }
+    const packageJson = (0, fileutils_1.readJsonFile)('package.json');
+    if ((0, utils_1.isMonorepo)(packageJson)) {
+        await (0, add_nx_to_monorepo_1.addNxToMonorepo)({
+            interactive: options.interactive,
+            nxCloud: false,
+        });
+    }
+    else {
+        await (0, add_nx_to_npm_repo_1.addNxToNpmRepo)({
+            interactive: options.interactive,
+            nxCloud: false,
+        });
+    }
+    const learnMoreLink = (0, utils_1.isMonorepo)(packageJson)
+        ? 'https://nx.dev/getting-started/tutorials/npm-workspaces-tutorial'
+        : 'https://nx.dev/recipes/adopting-nx/adding-to-existing-project';
+    const useNxCloud = options.nxCloud ??
+        (options.interactive ? await (0, connect_to_nx_cloud_1.connectExistingRepoToNxCloudPrompt)() : false);
+    const repoRoot = process.cwd();
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    (0, utils_1.createNxJsonFile)(repoRoot, [], [], {});
+    (0, utils_1.updateGitIgnore)(repoRoot);
+    const nxJson = (0, nx_json_1.readNxJson)(repoRoot);
+    output_1.output.log({ title: '🧐 Checking dependencies' });
+    const { plugins, updatePackageScripts } = await detectPlugins(nxJson, options.interactive);
+    output_1.output.log({ title: '📦 Installing Nx' });
+    installPlugins(repoRoot, plugins, pmc, updatePackageScripts);
+    if (useNxCloud) {
+        output_1.output.log({ title: '🛠️ Setting up Nx Cloud' });
+        await (0, utils_1.initCloud)('nx-init');
+    }
+    (0, utils_1.printFinalMessage)({
+        learnMoreLink,
+    });
+}
+const npmPackageToPluginMap = {
+    // Generic JS tools
+    eslint: '@nx/eslint',
+    storybook: '@nx/storybook',
+    // Bundlers
+    vite: '@nx/vite',
+    vitest: '@nx/vite',
+    webpack: '@nx/webpack',
+    rollup: '@nx/rollup',
+    // Testing tools
+    jest: '@nx/jest',
+    cypress: '@nx/cypress',
+    '@playwright/test': '@nx/playwright',
+    // Frameworks
+    detox: '@nx/detox',
+    expo: '@nx/expo',
+    next: '@nx/next',
+    nuxt: '@nx/nuxt',
+    'react-native': '@nx/react-native',
+    '@remix-run/dev': '@nx/remix',
+};
+async function detectPlugins(nxJson, interactive, includeAngularCli) {
+    let files = ['package.json'].concat((0, workspace_context_1.globWithWorkspaceContextSync)(process.cwd(), ['**/*/package.json']));
+    const currentPlugins = new Set((nxJson.plugins ?? []).map((p) => {
+        const plugin = typeof p === 'string' ? p : p.plugin;
+        return (0, get_package_name_from_import_path_1.getPackageNameFromImportPath)(plugin);
+    }));
+    const detectedPlugins = new Set();
+    for (const file of files) {
+        if (!(0, fs_1.existsSync)(file))
+            continue;
+        let packageJson;
+        try {
+            packageJson = (0, fileutils_1.readJsonFile)(file);
+        }
+        catch {
+            // Could have malformed JSON for unit tests, etc.
+            continue;
+        }
+        const deps = {
+            ...packageJson.dependencies,
+            ...packageJson.devDependencies,
+        };
+        const _npmPackageToPluginMap = {
+            ...npmPackageToPluginMap,
+        };
+        if (includeAngularCli) {
+            _npmPackageToPluginMap['@angular/cli'] = '@nx/angular';
+        }
+        for (const [dep, plugin] of Object.entries(_npmPackageToPluginMap)) {
+            if (deps[dep]) {
+                detectedPlugins.add(plugin);
+            }
+        }
+    }
+    let gradlewFiles = ['gradlew', 'gradlew.bat'].concat((0, workspace_context_1.globWithWorkspaceContextSync)(process.cwd(), [
+        '**/gradlew',
+        '**/gradlew.bat',
+    ]));
+    if (gradlewFiles.some((f) => (0, fs_1.existsSync)(f))) {
+        detectedPlugins.add('@nx/gradle');
+    }
+    // Remove existing plugins
+    for (const plugin of detectedPlugins) {
+        if (currentPlugins.has(plugin)) {
+            detectedPlugins.delete(plugin);
+        }
+    }
+    const plugins = Array.from(detectedPlugins);
+    if (plugins.length === 0) {
+        return {
+            plugins: [],
+            updatePackageScripts: false,
+        };
+    }
+    if (!interactive) {
+        output_1.output.log({
+            title: `Recommended Plugins:`,
+            bodyLines: [
+                `Adding these Nx plugins to integrate with the tools used in your workspace:`,
+                ...plugins.map((p) => `- ${p}`),
+            ],
+        });
+        return {
+            plugins,
+            updatePackageScripts: true,
+        };
+    }
+    output_1.output.log({
+        title: `Recommended Plugins:`,
+        bodyLines: [
+            `Add these Nx plugins to integrate with the tools used in your workspace.`,
+        ],
+    });
+    const pluginsToInstall = await (0, enquirer_1.prompt)([
+        {
+            name: 'plugins',
+            type: 'multiselect',
+            message: `Which plugins would you like to add? Press <Space> to select and <Enter> to submit.`,
+            choices: plugins.map((p) => ({ name: p, value: p })),
+            /**
+             * limit is missing from the interface but it limits the amount of options shown
+             */
+            limit: process.stdout.rows - 4, // 4 leaves room for the header above, the prompt and some whitespace
+        },
+    ]).then((r) => r.plugins);
+    if (pluginsToInstall?.length === 0)
+        return {
+            plugins: [],
+            updatePackageScripts: false,
+        };
+    const updatePackageScripts = (0, fs_1.existsSync)('package.json') &&
+        (await (0, enquirer_1.prompt)([
+            {
+                name: 'updatePackageScripts',
+                type: 'autocomplete',
+                message: `Do you want to start using Nx in your package.json scripts?`,
+                choices: [
+                    {
+                        name: 'Yes',
+                    },
+                    {
+                        name: 'No',
+                    },
+                ],
+                initial: 0,
+            },
+        ]).then((r) => r.updatePackageScripts === 'Yes'));
+    return { plugins: pluginsToInstall, updatePackageScripts };
+}

package/src/command-line/list/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsListCommand: CommandModule;

package/src/command-line/list/command-object.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsListCommand = void 0;
+exports.yargsListCommand = {
+    command: 'list [plugin]',
+    describe: 'Lists installed plugins, capabilities of installed plugins and other available plugins.',
+    builder: (yargs) => yargs.positional('plugin', {
+        type: 'string',
+        description: 'The name of an installed plugin to query.',
+    }),
+    handler: async (args) => {
+        await (await Promise.resolve().then(() => require('./list'))).listHandler(args);
+        process.exit(0);
+    },
+};

package/src/command-line/list/list.d.ts

@@ -0,0 +1,13 @@
+export interface ListArgs {
+    /** The name of an installed plugin to query  */
+    plugin?: string | undefined;
+}
+/**
+ * List available plugins or capabilities within a specific plugin
+ *
+ * @remarks
+ *
+ * Must be run within an Nx workspace
+ *
+ */
+export declare function listHandler(args: ListArgs): Promise<void>;

package/src/command-line/list/list.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listHandler = listHandler;
+const nx_json_1 = require("../../config/nx-json");
+const project_graph_1 = require("../../project-graph/project-graph");
+const output_1 = require("../../utils/output");
+const plugins_1 = require("../../utils/plugins");
+const workspace_root_1 = require("../../utils/workspace-root");
+const output_2 = require("../../utils/plugins/output");
+/**
+ * List available plugins or capabilities within a specific plugin
+ *
+ * @remarks
+ *
+ * Must be run within an Nx workspace
+ *
+ */
+async function listHandler(args) {
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+    const projects = (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph);
+    if (args.plugin) {
+        await (0, plugins_1.listPluginCapabilities)(args.plugin, projects.projects);
+    }
+    else {
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const localPlugins = await (0, plugins_1.getLocalWorkspacePlugins)(projects, nxJson);
+        const installedPlugins = await (0, plugins_1.getInstalledPluginsAndCapabilities)(workspace_root_1.workspaceRoot, projects.projects);
+        if (localPlugins.size) {
+            (0, plugins_1.listPlugins)(localPlugins, 'Local workspace plugins:');
+        }
+        (0, plugins_1.listPlugins)(installedPlugins, 'Installed plugins:');
+        (0, plugins_1.listAlsoAvailableCorePlugins)(installedPlugins);
+        (0, output_2.listPowerpackPlugins)();
+        output_1.output.note({
+            title: 'Community Plugins',
+            bodyLines: [
+                'Looking for a technology / framework not listed above?',
+                'There are many excellent plugins maintained by the Nx community.',
+                'Search for the one you need here: https://nx.dev/plugin-registry.',
+            ],
+        });
+        output_1.output.note({ title: `Use "nx list [plugin]" to find out more` });
+    }
+}

package/src/command-line/login/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsLoginCommand: CommandModule;

package/src/command-line/login/command-object.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsLoginCommand = void 0;
+const shared_options_1 = require("../../command-line/yargs-utils/shared-options");
+exports.yargsLoginCommand = {
+    command: 'login [nxCloudUrl]',
+    describe: 'Login to Nx Cloud. This command is an alias for [`nx-cloud login`](/ci/reference/nx-cloud-cli#npx-nxcloud-login).',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs.positional('nxCloudUrl', {
+        describe: 'The Nx Cloud URL of the instance you are trying to connect to. If no positional argument is provided, this command will connect to https://cloud.nx.app.',
+        type: 'string',
+        required: false,
+    })),
+    handler: async (args) => {
+        process.exit(await (await Promise.resolve().then(() => require('./login'))).loginHandler(args));
+    },
+};

package/src/command-line/login/login.d.ts

@@ -0,0 +1,5 @@
+export interface LoginArgs {
+    nxCloudUrl?: string;
+    verbose?: boolean;
+}
+export declare function loginHandler(args: LoginArgs): Promise<number>;

package/src/command-line/login/login.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginHandler = loginHandler;
+const update_manager_1 = require("../../nx-cloud/update-manager");
+const get_cloud_options_1 = require("../../nx-cloud/utilities/get-cloud-options");
+const handle_errors_1 = require("../../utils/handle-errors");
+function loginHandler(args) {
+    if (args.nxCloudUrl) {
+        process.env.NX_CLOUD_API = args.nxCloudUrl;
+    }
+    return (0, handle_errors_1.handleErrors)(args.verbose, async () => {
+        const nxCloudClient = (await (0, update_manager_1.verifyOrUpdateNxCloudClient)((0, get_cloud_options_1.getCloudOptions)()))
+            .nxCloudClient;
+        await nxCloudClient.commands.login();
+    });
+}

package/src/command-line/logout/command-object.d.ts

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsLogoutCommand: CommandModule;

package/src/command-line/logout/command-object.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsLogoutCommand = void 0;
+const shared_options_1 = require("../../command-line/yargs-utils/shared-options");
+exports.yargsLogoutCommand = {
+    command: 'logout',
+    describe: 'Logout from Nx Cloud. This command is an alias for [`nx-cloud logout`](/ci/reference/nx-cloud-cli#npx-nxcloud-logout).',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs),
+    handler: async (args) => {
+        process.exit(await (await Promise.resolve().then(() => require('./logout'))).logoutHandler(args));
+    },
+};

package/src/command-line/logout/logout.d.ts

@@ -0,0 +1,4 @@
+export interface LogoutArgs {
+    verbose?: boolean;
+}
+export declare function logoutHandler(args: LogoutArgs): Promise<number>;

package/src/command-line/logout/logout.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logoutHandler = logoutHandler;
+const update_manager_1 = require("../../nx-cloud/update-manager");
+const get_cloud_options_1 = require("../../nx-cloud/utilities/get-cloud-options");
+const handle_errors_1 = require("../../utils/handle-errors");
+function logoutHandler(args) {
+    return (0, handle_errors_1.handleErrors)(args.verbose, async () => {
+        const nxCloudClient = (await (0, update_manager_1.verifyOrUpdateNxCloudClient)((0, get_cloud_options_1.getCloudOptions)()))
+            .nxCloudClient;
+        await nxCloudClient.commands.logout();
+    });
+}

package/src/command-line/migrate/command-object.d.ts

@@ -0,0 +1,3 @@
+import { CommandModule } from 'yargs';
+export declare const yargsMigrateCommand: CommandModule;
+export declare const yargsInternalMigrateCommand: CommandModule;

package/src/command-line/migrate/command-object.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsInternalMigrateCommand = exports.yargsMigrateCommand = void 0;
+const path = require("path");
+const child_process_1 = require("../../utils/child-process");
+const documentation_1 = require("../yargs-utils/documentation");
+const child_process_2 = require("child_process");
+const package_manager_1 = require("../../utils/package-manager");
+const fileutils_1 = require("../../utils/fileutils");
+const workspace_root_1 = require("../../utils/workspace-root");
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsMigrateCommand = {
+    command: 'migrate [packageAndVersion]',
+    describe: `Creates a migrations file or runs migrations from the migrations file.
+  - Migrate packages and create migrations.json (e.g., nx migrate @nx/workspace@latest)
+  - Run migrations (e.g., nx migrate --run-migrations=migrations.json). Use flag --if-exists to run migrations only if the migrations file exists.`,
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)(withMigrationOptions(yargs), 'migrate'),
+    handler: () => {
+        runMigration();
+        process.exit(0);
+    },
+};
+exports.yargsInternalMigrateCommand = {
+    command: '_migrate [packageAndVersion]',
+    describe: false,
+    builder: (yargs) => withMigrationOptions(yargs),
+    handler: async (args) => process.exit(await (await Promise.resolve().then(() => require('./migrate'))).migrate(process.cwd(), args, process.argv.slice(3))),
+};
+function withMigrationOptions(yargs) {
+    const defaultCommitPrefix = 'chore: [nx migration] ';
+    return (0, shared_options_1.withVerbose)(yargs)
+        .positional('packageAndVersion', {
+        describe: `The target package and version (e.g, @nx/workspace@16.0.0).`,
+        type: 'string',
+    })
+        .option('runMigrations', {
+        describe: `Execute migrations from a file (when the file isn't provided, execute migrations from migrations.json).`,
+        type: 'string',
+    })
+        .option('ifExists', {
+        describe: `Run migrations only if the migrations file exists, if not continues successfully.`,
+        type: 'boolean',
+        default: false,
+    })
+        .option('from', {
+        describe: 'Use the provided versions for packages instead of the ones installed in node_modules (e.g., --from="@nx/react@16.0.0,@nx/js@16.0.0").',
+        type: 'string',
+    })
+        .option('to', {
+        describe: 'Use the provided versions for packages instead of the ones calculated by the migrator (e.g., --to="@nx/react@16.0.0,@nx/js@16.0.0").',
+        type: 'string',
+    })
+        .option('createCommits', {
+        describe: 'Automatically create a git commit after each migration runs.',
+        type: 'boolean',
+        alias: ['C'],
+        default: false,
+    })
+        .option('commitPrefix', {
+        describe: 'Commit prefix to apply to the commit for each migration, when --create-commits is enabled.',
+        type: 'string',
+        default: defaultCommitPrefix,
+    })
+        .option('interactive', {
+        describe: 'Enable prompts to confirm whether to collect optional package updates and migrations.',
+        type: 'boolean',
+        default: false,
+    })
+        .option('excludeAppliedMigrations', {
+        describe: 'Exclude migrations that should have been applied on previous updates. To be used with --from.',
+        type: 'boolean',
+        default: false,
+    })
+        .check(({ createCommits, commitPrefix, from, excludeAppliedMigrations }) => {
+        if (!createCommits && commitPrefix !== defaultCommitPrefix) {
+            throw new Error('Error: Providing a custom commit prefix requires --create-commits to be enabled');
+        }
+        if (excludeAppliedMigrations && !from) {
+            throw new Error('Error: Excluding migrations that should have been previously applied requires --from to be set');
+        }
+        return true;
+    });
+}
+function runMigration() {
+    const runLocalMigrate = () => {
+        (0, child_process_1.runNxSync)(`_migrate ${process.argv.slice(3).join(' ')}`, {
+            stdio: ['inherit', 'inherit', 'inherit'],
+        });
+    };
+    if (process.env.NX_MIGRATE_USE_LOCAL === undefined) {
+        const p = nxCliPath();
+        if (p === null) {
+            runLocalMigrate();
+        }
+        else {
+            // ensure local registry from process is not interfering with the install
+            // when we start the process from temp folder the local registry would override the custom registry
+            if (process.env.npm_config_registry &&
+                process.env.npm_config_registry.match(/^https:\/\/registry\.(npmjs\.org|yarnpkg\.com)/)) {
+                delete process.env.npm_config_registry;
+            }
+            (0, child_process_2.execSync)(`${p} _migrate ${process.argv.slice(3).join(' ')}`, {
+                stdio: ['inherit', 'inherit', 'inherit'],
+                windowsHide: true,
+            });
+        }
+    }
+    else {
+        runLocalMigrate();
+    }
+}
+function nxCliPath() {
+    const version = process.env.NX_MIGRATE_CLI_VERSION || 'latest';
+    try {
+        const packageManager = (0, package_manager_1.detectPackageManager)();
+        const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+        const { dirSync } = require('tmp');
+        const tmpDir = dirSync().name;
+        (0, fileutils_1.writeJsonFile)(path.join(tmpDir, 'package.json'), {
+            dependencies: {
+                nx: version,
+            },
+            license: 'MIT',
+        });
+        (0, package_manager_1.copyPackageManagerConfigurationFiles)(workspace_root_1.workspaceRoot, tmpDir);
+        if (pmc.preInstall) {
+            // ensure package.json and repo in tmp folder is set to a proper package manager state
+            (0, child_process_2.execSync)(pmc.preInstall, {
+                cwd: tmpDir,
+                stdio: ['ignore', 'ignore', 'ignore'],
+                windowsHide: true,
+            });
+            // if it's berry ensure we set the node_linker to node-modules
+            if (packageManager === 'yarn' && pmc.ciInstall.includes('immutable')) {
+                (0, child_process_2.execSync)('yarn config set nodeLinker node-modules', {
+                    cwd: tmpDir,
+                    stdio: ['ignore', 'ignore', 'ignore'],
+                    windowsHide: true,
+                });
+            }
+        }
+        (0, child_process_2.execSync)(pmc.install, {
+            cwd: tmpDir,
+            stdio: ['ignore', 'ignore', 'ignore'],
+            windowsHide: true,
+        });
+        // Set NODE_PATH so that these modules can be used for module resolution
+        addToNodePath(path.join(tmpDir, 'node_modules'));
+        addToNodePath(path.join(workspace_root_1.workspaceRoot, 'node_modules'));
+        return path.join(tmpDir, `node_modules`, '.bin', 'nx');
+    }
+    catch (e) {
+        console.error(`Failed to install the ${version} version of the migration script. Using the current version.`);
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.error(e);
+        }
+        return null;
+    }
+}
+function addToNodePath(dir) {
+    // NODE_PATH is a delimited list of paths.
+    // The delimiter is different for windows.
+    const delimiter = require('os').platform() === 'win32' ? ';' : ':';
+    const paths = process.env.NODE_PATH
+        ? process.env.NODE_PATH.split(delimiter)
+        : [];
+    // Add the tmp path
+    paths.push(dir);
+    // Update the env variable.
+    process.env.NODE_PATH = paths.join(delimiter);
+}