nx 23.2.0-beta.0 → 23.2.0-beta.10

package/dist/src/utils/package-manager.d.ts

@@ -118,12 +118,33 @@ export declare function resolvePackageVersionUsingRegistry(packageName: string,
  * package.json.
  */
 export declare function resolvePackageVersionUsingInstallation(packageName: string, version: string): Promise<string>;
-export declare function packageRegistryView(pkg: string, version: string, args: string, options?: {
+/**
+ * The registry the fetch for `pkg` went to, with its userinfo masked because a
+ * registry URL can carry a bare token. The lookup is spawned the way
+ * `packageRegistryView` spawns the fetch this describes (same manager, same
+ * environment), so a registry the package manager keeps outside the .npmrc
+ * chain and a scope resolved for itself both land on the value that fetch used.
+ * Null where the manager yields no usable registry URL; throws where it cannot be run.
+ */
+export declare function getWorkspaceRegistryUrlForDisplay(pkg: string): string | null;
+export declare function packageRegistryView(pkg: string, version: string, args: string[], options?: {
     forceNpm?: boolean;
 }): Promise<string>;
-export declare function packageRegistryPack(cwd: string, pkg: string, version: string): Promise<{
+/**
+ * Only `npm pack` supports downloading a tarball of a specified remote
+ * package. `yarn` packs the active workspace, `pnpm pack` only packs
+ * the local project, and `bun` doesn't support pack.
+ *
+ * @param packDestination Directory passed to npm's `--pack-destination`, where
+ * the `.tgz` is written.
+ * @see https://github.com/nrwl/nx/pull/9667#discussion_r842553994
+ */
+export declare function packageRegistryPack(packDestination: string, pkg: string, version: string, options?: {
+    bypassMinReleaseAge?: boolean;
+}): Promise<{
     tarballPath: string;
 }>;
+export declare function clearPackageManagerVersionCache(): void;
 /**
  * Gets the workspaces defined in the package manager configuration.
  * @returns workspaces defined in the package manager configuration, empty array if none are defined

package/dist/src/utils/package-manager.js

@@ -13,8 +13,10 @@ exports.copyPackageManagerConfigurationFiles = copyPackageManagerConfigurationFi
 exports.createTempNpmDirectory = createTempNpmDirectory;
 exports.resolvePackageVersionUsingRegistry = resolvePackageVersionUsingRegistry;
 exports.resolvePackageVersionUsingInstallation = resolvePackageVersionUsingInstallation;
+exports.getWorkspaceRegistryUrlForDisplay = getWorkspaceRegistryUrlForDisplay;
 exports.packageRegistryView = packageRegistryView;
 exports.packageRegistryPack = packageRegistryPack;
+exports.clearPackageManagerVersionCache = clearPackageManagerVersionCache;
 exports.getPackageWorkspaces = getPackageWorkspaces;
 exports.addPackagePathToWorkspaces = addPackagePathToWorkspaces;
 const child_process_1 = require("child_process");
@@ -30,9 +32,36 @@ const file_utils_1 = require("../project-graph/file-utils");
 const catalog_1 = require("./catalog");
 const fileutils_1 = require("./fileutils");
 const installation_directory_1 = require("./installation-directory");
+const logger_1 = require("./logger");
 const package_json_1 = require("./package-json");
+const shell_quoting_1 = require("./shell-quoting");
 const workspace_root_1 = require("./workspace-root");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
+/**
+ * Shell-less spawn for the registry-bridged fetches: `exec` goes through
+ * /bin/sh, which is dash on Debian-family systems, and dash drops environment
+ * names that are not valid shell identifiers, i.e. every `//...:_authToken`
+ * credential and `@scope:registry` entry the overlay carries. Windows stays on
+ * `exec`, with every argument quoted, because Node refuses to execFile the
+ * package manager's `.cmd` shim without a shell.
+ *
+ * That quoting is the whole defence on Windows, so it goes through
+ * quoteShellArg, which throws on the one argument it cannot make safe.
+ */
+function execPackageManagerAsync(pm, args, options) {
+    if (process.platform === 'win32') {
+        return execAsync([pm, ...args].map(shell_quoting_1.quoteShellArg).join(' '), options);
+    }
+    return execFileAsync(pm, args, options);
+}
+/** Same split, and the same quoting, for a blocking caller. */
+function execPackageManagerSync(pm, args, options) {
+    if (process.platform === 'win32') {
+        return (0, child_process_1.execSync)([pm, ...args].map(shell_quoting_1.quoteShellArg).join(' '), options);
+    }
+    return (0, child_process_1.execFileSync)(pm, args, options);
+}
 /**
  * Detects which package manager is used in the workspace based on the lock file.
  */
@@ -165,8 +194,12 @@ function getPackageManagerCommand(packageManager = detectPackageManager(), root
                 install: 'pnpm install --no-frozen-lockfile', // explicitly disable in case of CI
                 ciInstall: 'pnpm install --frozen-lockfile',
                 updateLockFile: 'pnpm install --lockfile-only',
-                add: isPnpmWorkspace ? 'pnpm add -w' : 'pnpm add',
-                addDev: isPnpmWorkspace ? 'pnpm add -Dw' : 'pnpm add -D',
+                add: isPnpmWorkspace
+                    ? 'pnpm add -w --config.frozen-lockfile=false'
+                    : 'pnpm add --config.frozen-lockfile=false',
+                addDev: isPnpmWorkspace
+                    ? 'pnpm add -Dw --config.frozen-lockfile=false'
+                    : 'pnpm add -D --config.frozen-lockfile=false',
                 rm: 'pnpm rm',
                 exec: modernPnpm ? 'pnpm exec' : 'pnpx',
                 dlx: modernPnpm ? 'pnpm dlx' : 'pnpx',
@@ -235,7 +268,10 @@ function getPackageManagerVersion(packageManager = detectPackageManager(), cwd =
     }
     if (!version) {
         try {
-            version = (0, child_process_1.execSync)(`${packageManager} --version`, {
+            const versionArgs = packageManager === 'pnpm'
+                ? '--ignore-workspace --version'
+                : '--version';
+            version = (0, child_process_1.execSync)(`${packageManager} ${versionArgs}`, {
                 cwd,
                 encoding: 'utf-8',
                 windowsHide: true,
@@ -345,6 +381,20 @@ function modifyPnpmWorkspaceYamlToFitNewDirectory(contents) {
     doc.set('packages', ['.']);
     // Relative patch paths don't resolve in the temp dir.
     doc.delete('patchedDependencies');
+    // link:/file: overrides (e.g. written by `pnpm link`) point at paths that
+    // don't exist in the temp dir, and an override would hijack an exact-version
+    // add (`pnpm add pkg@x.y.z` would install the linked dir instead).
+    const overrides = doc.toJS()?.overrides;
+    if (overrides && typeof overrides === 'object') {
+        for (const [name, spec] of Object.entries(overrides)) {
+            if (typeof spec === 'string' && /^(link|file):/.test(spec)) {
+                doc.deleteIn(['overrides', name]);
+            }
+        }
+        if (Object.keys(doc.toJS()?.overrides ?? {}).length === 0) {
+            doc.delete('overrides');
+        }
+    }
     return doc.toString();
 }
 function copyPackageManagerConfigurationFiles(root, destination) {
@@ -390,6 +440,27 @@ function copyPackageManagerConfigurationFiles(root, destination) {
         }
     }
 }
+/**
+ * A non-JS workspace has no root package.json and keeps its package manager
+ * files under the Nx installation directory instead.
+ */
+function getPackageManagerConfigRoot() {
+    if ((0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'))) {
+        return workspace_root_1.workspaceRoot;
+    }
+    const installationPath = (0, installation_directory_1.getNxInstallationPath)(workspace_root_1.workspaceRoot);
+    // The installation directory can be missing or not a directory, and spawning
+    // with such a cwd fails outright (ENOENT/ENOTDIR).
+    try {
+        return (0, fs_1.statSync)(installationPath).isDirectory()
+            ? installationPath
+            : workspace_root_1.workspaceRoot;
+    }
+    catch (e) {
+        logger_1.logger.verbose(`Failed to stat the Nx installation directory at "${installationPath}".`, e);
+        return workspace_root_1.workspaceRoot;
+    }
+}
 /**
  * Creates a temporary directory where you can run package manager commands safely.
  *
@@ -406,8 +477,7 @@ function createTempNpmDirectory(skipCopy = false) {
     // A package.json is needed for pnpm pack and for .npmrc to resolve
     (0, fileutils_1.writeJsonFile)(`${dir}/package.json`, {});
     if (!skipCopy) {
-        const isNonJs = !(0, fs_1.existsSync)((0, path_1.join)(workspace_root_1.workspaceRoot, 'package.json'));
-        copyPackageManagerConfigurationFiles(isNonJs ? (0, installation_directory_1.getNxInstallationPath)(workspace_root_1.workspaceRoot) : workspace_root_1.workspaceRoot, dir);
+        copyPackageManagerConfigurationFiles(getPackageManagerConfigRoot(), dir);
     }
     const cleanup = async () => {
         try {
@@ -426,7 +496,9 @@ function createTempNpmDirectory(skipCopy = false) {
 async function resolvePackageVersionUsingRegistry(packageName, version) {
     try {
         const resolvedVersion = (0, catalog_1.resolveCatalogReferenceIfNeeded)(packageName, version);
-        const result = await packageRegistryView(packageName, resolvedVersion, 'version');
+        const result = await packageRegistryView(packageName, resolvedVersion, [
+            'version',
+        ]);
         if (!result) {
             throw new Error(`Unable to resolve version ${packageName}@${resolvedVersion}.`);
         }
@@ -448,9 +520,29 @@ async function resolvePackageVersionUsingRegistry(packageName, version) {
             .replace(/'/g, '');
         return finalResolvedVersion;
     }
-    catch {
-        throw new Error(`Unable to resolve version ${packageName}@${version}.`);
+    catch (e) {
+        // npm masks a URL credential only in the password position, so a bare token
+        // in the registry URL survives into the error kept as the cause.
+        throw new Error(`Unable to resolve version ${packageName}@${version}.`, {
+            cause: redactErrorCause(e),
+        });
+    }
+}
+// Masks the userinfo in a URL: `user`, `user:pass`, or a bare token.
+function redactUrlCredentials(text) {
+    return text.replace(/([a-z][a-z0-9+.-]*:\/\/)[^/@\s]+@/gi, '$1***@');
+}
+function redactErrorCause(error) {
+    if (error && typeof error === 'object') {
+        const e = error;
+        // An exec error carries the command and both output streams as fields.
+        for (const field of ['message', 'stack', 'stderr', 'stdout', 'cmd']) {
+            if (typeof e[field] === 'string') {
+                e[field] = redactUrlCredentials(e[field]);
+            }
+        }
     }
+    return error;
 }
 /**
  * Return the resolved version for a given package and version tag using by
@@ -480,12 +572,86 @@ async function resolvePackageVersionUsingInstallation(packageName, version) {
         await cleanup();
     }
 }
-async function packageRegistryView(pkg, version, args, 
-// `forceNpm` runs the view through npm even in a pnpm workspace: npm projects
-// a field across every matched version, whereas `pnpm view <pkg>@<range>`
-// collapses to the single highest match (breaks per-version field queries).
-options) {
-    let pm = detectPackageManager();
+/**
+ * What every registry-bound npm spawn resolves the same way: where npm runs,
+ * and an environment reproducing the workspace package manager's own registry,
+ * auth and TLS resolution for `pkg`. `buildEnv` adds the caller's own entries.
+ */
+function createRegistrySpawnContext(pkg) {
+    // Deferred so the registry resolvers load only for the commands that spawn
+    // npm, not with every package-manager.ts import.
+    const { getNpmSpawnRegistryEnv, getPackageScope, ignoresNpmConfigEnv, mergeNpmConfigEnv, } = require('./registry-config');
+    const workspacePm = detectPackageManager();
+    const configRoot = getPackageManagerConfigRoot();
+    const workspacePmVersion = getPackageManagerVersionSafe(workspacePm, configRoot);
+    return {
+        workspacePm,
+        workspacePmVersion,
+        configRoot,
+        scope: getPackageScope(pkg),
+        buildEnv: (extra) => mergeNpmConfigEnv(process.env, {
+            ...getNpmSpawnRegistryEnv(pkg, configRoot, workspacePm, workspacePmVersion),
+            ...extra,
+        }, ignoresNpmConfigEnv(workspacePm, workspacePmVersion)),
+    };
+}
+/**
+ * The registry the fetch for `pkg` went to, with its userinfo masked because a
+ * registry URL can carry a bare token. The lookup is spawned the way
+ * `packageRegistryView` spawns the fetch this describes (same manager, same
+ * environment), so a registry the package manager keeps outside the .npmrc
+ * chain and a scope resolved for itself both land on the value that fetch used.
+ * Null where the manager yields no usable registry URL; throws where it cannot be run.
+ */
+function getWorkspaceRegistryUrlForDisplay(pkg) {
+    const { workspacePm, workspacePmVersion, configRoot, scope, buildEnv } = createRegistrySpawnContext(pkg);
+    const { pm, env, usesNativePnpm } = resolveRegistrySpawnTarget(workspacePm, workspacePmVersion, buildEnv);
+    // Ask for the package scope first. Native pnpm can keep the workspace
+    // `registries.default` separate from the flat `registry`, so it is queried
+    // in between.
+    const keys = scope ? [`${scope}:registry`] : [];
+    if (usesNativePnpm) {
+        keys.push('registries.default');
+    }
+    keys.push('registry');
+    for (const key of keys) {
+        const value = execPackageManagerSync(pm, ['config', 'get', key], {
+            cwd: configRoot,
+            timeout: 5000,
+            windowsHide: true,
+            encoding: 'utf-8',
+            // The downgraded pin warns on stderr, which is noise on a path that only
+            // decorates an error message.
+            stdio: ['ignore', 'pipe', 'ignore'],
+            env,
+        }).trim();
+        if (!value || value === 'undefined' || value === 'null') {
+            continue;
+        }
+        // A present but unusable answer (a `registries:` map with a non-string
+        // default serializes as JSON; a non-HTTP(S) scheme) also aborted the fetch
+        // this describes, so a key below it was never contacted either.
+        if (!URL.canParse(value)) {
+            return null;
+        }
+        const protocol = new URL(value).protocol;
+        if (protocol !== 'http:' && protocol !== 'https:') {
+            return null;
+        }
+        return redactUrlCredentials(value);
+    }
+    return null;
+}
+/**
+ * Which manager answers a registry read for this workspace, and the environment
+ * it reads under. pnpm 11 reimplemented `view` natively, resolving registry and
+ * credentials (tokenHelper included) itself, so it runs on the untouched
+ * environment; pnpm 10 passed `view` through to the npm CLI, which needs the
+ * overlay. Shared so a lookup describing a fetch cannot resolve against a
+ * different environment than the fetch used.
+ */
+function resolveRegistrySpawnTarget(workspacePm, workspacePmVersion, buildEnv, options) {
+    let pm = workspacePm;
     if (options?.forceNpm || pm === 'yarn' || pm === 'bun') {
         /**
          * yarn has `yarn info` but it behaves differently than (p)npm,
@@ -499,40 +665,98 @@ options) {
          */
         pm = 'npm';
     }
+    if (pm === 'pnpm' && ((0, semver_1.parse)(workspacePmVersion)?.major ?? 0) >= 11) {
+        return { pm, env: process.env, usesNativePnpm: true };
+    }
+    // npm_config_force downgrades npm's `devEngines.packageManager` enforcement,
+    // which otherwise aborts even a read-only lookup when the pin sets
+    // `onFail: error`. Only set for npm so a pnpm spawn is untouched.
+    return {
+        pm,
+        env: buildEnv(pm === 'npm' ? { npm_config_force: 'true' } : {}),
+        usesNativePnpm: false,
+    };
+}
+async function packageRegistryView(pkg, version, args, 
+// `forceNpm` runs the view through npm even in a pnpm workspace: npm projects
+// a field across every matched version, whereas `pnpm view <pkg>@<range>`
+// collapses to the single highest match (breaks per-version field queries).
+options) {
+    const { workspacePm, workspacePmVersion, configRoot, buildEnv } = createRegistrySpawnContext(pkg);
+    const { pm, env } = resolveRegistrySpawnTarget(workspacePm, workspacePmVersion, buildEnv, options);
     // An empty version means we want the full packument; omit the trailing `@`.
-    // Quote the spec so range operators (e.g. `>=0.0.0`) are not parsed as shell
-    // redirections.
     const spec = version ? `${pkg}@${version}` : pkg;
-    // npm enforces `devEngines.packageManager` on every command, even a read-only
-    // `view`; in a yarn/bun workspace we run npm, so a non-npm pin with
-    // `onFail: error` aborts the lookup. force downgrades that to a warning.
-    // Scoped to npm so a `pnpm view` spawn is left untouched.
-    const { stdout } = await execAsync(`${pm} view "${spec}" ${args}`, {
-        windowsHide: true,
-        ...(pm === 'npm'
-            ? { env: { ...process.env, npm_config_force: 'true' } }
-            : {}),
-    });
-    return stdout.toString().trim();
+    try {
+        const { stdout } = await execPackageManagerAsync(pm, ['view', spec, ...args], {
+            windowsHide: true,
+            cwd: configRoot,
+            env,
+        });
+        return stdout.toString().trim();
+    }
+    catch (e) {
+        throw redactErrorCause(e);
+    }
 }
-async function packageRegistryPack(cwd, pkg, version) {
-    /**
-     * Only `npm pack` supports downloading a tarball of a specified remote
-     * package. `yarn` packs the active workspace, `pnpm pack` only packs
-     * the local project, and `bun` doesn't support pack.
-     *
-     * @see https://github.com/nrwl/nx/pull/9667#discussion_r842553994
-     */
+/**
+ * Only `npm pack` supports downloading a tarball of a specified remote
+ * package. `yarn` packs the active workspace, `pnpm pack` only packs
+ * the local project, and `bun` doesn't support pack.
+ *
+ * @param packDestination Directory passed to npm's `--pack-destination`, where
+ * the `.tgz` is written.
+ * @see https://github.com/nrwl/nx/pull/9667#discussion_r842553994
+ */
+async function packageRegistryPack(packDestination, pkg, version, options) {
     const pm = 'npm';
-    const { stdout } = await execAsync(`${pm} pack ${pkg}@${version}`, {
-        cwd,
-        windowsHide: true,
-        // npm enforces `devEngines.packageManager` even on `pack`; force keeps the
-        // download working in workspaces that pin a non-npm manager (onFail: error).
-        env: { ...process.env, npm_config_force: 'true' },
-    });
-    const tarballPath = stdout.trim();
-    return { tarballPath };
+    const { configRoot, buildEnv } = createRegistrySpawnContext(pkg);
+    // Run from the config root, not the temp dir, so npm reads the workspace
+    // .npmrc natively; --pack-destination still writes the tarball to the temp
+    // dir. npm prints the tarball basename to stdout.
+    try {
+        const { stdout } = await execPackageManagerAsync(pm, ['pack', `${pkg}@${version}`, '--pack-destination', packDestination], {
+            cwd: configRoot,
+            windowsHide: true,
+            env: buildEnv({
+                // downgrade npm's devEngines.packageManager enforcement (onFail:
+                // error) to a warning so pack still runs in a non-npm workspace
+                npm_config_force: 'true',
+                ...(options?.bypassMinReleaseAge
+                    ? { npm_config_min_release_age: '0' }
+                    : {}),
+            }),
+        });
+        const tarballPath = stdout.trim();
+        return { tarballPath };
+    }
+    catch (e) {
+        throw redactErrorCause(e);
+    }
+}
+// The version probe shells out when the packageManager field is absent, and
+// packageRegistryView/packageRegistryPack run in tight resolution loops.
+const packageManagerVersionCache = new Map();
+/**
+ * A null version is tolerated per package manager: pnpm and yarn skip bridging,
+ * bun assumes a current version.
+ */
+function getPackageManagerVersionSafe(packageManager, root) {
+    const key = `${packageManager}:${root}`;
+    if (!packageManagerVersionCache.has(key)) {
+        let version = null;
+        try {
+            version = getPackageManagerVersion(packageManager, root);
+        }
+        catch (e) {
+            logger_1.logger.verbose(`Failed to determine the ${packageManager} version in "${root}".`, e);
+        }
+        packageManagerVersionCache.set(key, version);
+    }
+    return packageManagerVersionCache.get(key);
+}
+// Test-only: production never re-resolves a version mid-run.
+function clearPackageManagerVersionCache() {
+    packageManagerVersionCache.clear();
 }
 /**
  * Gets the workspaces defined in the package manager configuration.

package/dist/src/utils/params.d.ts

@@ -125,16 +125,22 @@ export declare function warnDeprecations(opts: {
 export declare function convertSmartDefaultsIntoNamedParams(opts: {
     [k: string]: any;
 }, schema: Schema, defaultProjectName: string | null, relativeCwd: string | null): void;
-type Prompt = ConstructorParameters<typeof import('enquirer').Prompt>[0] & {
+type Prompt = {
     name: string;
     type: 'input' | 'autocomplete' | 'multiselect' | 'confirm' | 'numeral';
     message: string;
     initial?: any;
+    /**
+     * Retained because {@link getPromptsForSchema} is exported and asserted on;
+     * the prompt itself scrolls rather than truncating.
+     */
     limit?: number;
     choices?: (string | {
         name: string;
         message: string;
     })[];
+    /** Returns `true` when valid, otherwise the message to show. */
+    validate?: (value: any) => boolean | string;
 };
 export declare function getPromptsForSchema(opts: Options, schema: Schema, projectsConfigurations: ProjectsConfigurations): Prompt[];
 export {};

package/dist/src/utils/params.js

@@ -14,7 +14,7 @@ exports.warnDeprecations = warnDeprecations;
 exports.convertSmartDefaultsIntoNamedParams = convertSmartDefaultsIntoNamedParams;
 exports.getPromptsForSchema = getPromptsForSchema;
 const logger_1 = require("./logger");
-const handle_import_1 = require("./handle-import");
+const prompt_helpers_1 = require("./prompt-helpers");
 function camelCase(input) {
     if (input.indexOf('-') > 1) {
         return input
@@ -658,13 +658,71 @@ function getPromptsForSchema(opts, schema, projectsConfigurations) {
     return prompts;
 }
 async function promptForValues(opts, schema, projectsConfigurations) {
-    return await (await (0, handle_import_1.handleImport)('enquirer'))
-        .prompt(getPromptsForSchema(opts, schema, projectsConfigurations))
-        .then((values) => ({ ...opts, ...values }))
-        .catch((e) => {
+    try {
+        const values = {};
+        // Asked one at a time; a schema prompt has no cross-question state, so the
+        // order is just the schema's own.
+        for (const question of getPromptsForSchema(opts, schema, projectsConfigurations)) {
+            values[question.name] = await askSchemaQuestion(question);
+        }
+        return { ...opts, ...values };
+    }
+    catch (e) {
         console.error(e);
         process.exit(1);
-    });
+    }
+}
+async function askSchemaQuestion(question) {
+    const validate = question.validate
+        ? (value) => {
+            const result = question.validate(value);
+            return result === true
+                ? undefined
+                : typeof result === 'string'
+                    ? result
+                    : 'Invalid value';
+        }
+        : undefined;
+    const choices = (question.choices ?? []).map((c) => typeof c === 'string' ? { value: c } : { value: c.name, label: c.message });
+    switch (question.type) {
+        case 'confirm':
+            return (0, prompt_helpers_1.confirmationPrompt)({
+                message: question.message,
+                initial: question.initial !== false,
+            });
+        case 'multiselect':
+            return (0, prompt_helpers_1.multiselectPrompt)({
+                message: question.message,
+                choices,
+                initialValues: Array.isArray(question.initial)
+                    ? question.initial
+                    : undefined,
+            });
+        case 'autocomplete':
+            return (0, prompt_helpers_1.selectPrompt)({
+                message: question.message,
+                choices,
+                initial: question.initial,
+            });
+        case 'numeral': {
+            // No numeric prompt; the answer is parsed back so the schema still
+            // receives a number.
+            const answer = await (0, prompt_helpers_1.textPrompt)({
+                message: question.message,
+                initialValue: question.initial === undefined ? undefined : String(question.initial),
+                validate: (value) => value !== '' && !Number.isNaN(Number(value))
+                    ? validate?.(Number(value))
+                    : 'Please enter a number',
+            });
+            return Number(answer);
+        }
+        default:
+            return (0, prompt_helpers_1.textPrompt)({
+                message: question.message,
+                initialValue: typeof question.initial === 'string' ? question.initial : undefined,
+                validate,
+            });
+    }
 }
 function findSchemaForProperty(propName, schema) {
     if (propName in schema.properties) {

package/dist/src/utils/plugins/core-plugins.js

@@ -42,6 +42,10 @@ exports.CORE_PLUGINS = [
         name: '@nx/eslint',
         capabilities: 'executors,generators',
     },
+    {
+        name: '@nx/oxlint',
+        capabilities: 'generators',
+    },
     {
         name: '@nx/nest',
         capabilities: 'generators',

package/dist/src/utils/prompt-helpers.d.ts

@@ -0,0 +1,53 @@
+export interface Choice<T extends string> {
+    value: T;
+    label?: string;
+    hint?: string;
+}
+/** A bare string is a choice whose label is its value. */
+export type ChoiceOrValue<T extends string> = T | Choice<T>;
+/**
+ * Ctrl+C yields a sentinel rather than throwing. `onCancel` decides what that
+ * means for the caller - either a fallback answer or an abort. The default
+ * aborts with the POSIX interrupt status.
+ */
+export type OnCancel<T> = () => T;
+export declare function selectPrompt<T extends string>(options: {
+    message: string;
+    choices: readonly ChoiceOrValue<T>[];
+    initial?: T;
+    /** Answer without prompting; defaults to the first choice. */
+    skip?: boolean;
+    skippedValue?: T;
+    onCancel?: OnCancel<T>;
+}): Promise<T>;
+export declare function confirmationPrompt(options: {
+    message: string;
+    initial?: boolean;
+    skip?: boolean;
+    skippedValue?: boolean;
+    onCancel?: OnCancel<boolean>;
+}): Promise<boolean>;
+export declare function textPrompt(options: {
+    message: string;
+    initialValue?: string;
+    placeholder?: string;
+    /**
+     * Runs synchronously; clack does not await validators.
+     *
+     * Always receives a string. clack validates on Enter *before* it coerces an
+     * empty submit to `''`, so it would otherwise hand `undefined` to a prompt
+     * declaring no `initialValue`; the wrapper below normalizes that, matching
+     * what enquirer passed.
+     */
+    validate?: (value: string) => string | undefined;
+    skip?: boolean;
+    skippedValue?: string;
+    onCancel?: OnCancel<string>;
+}): Promise<string>;
+export declare function multiselectPrompt<T extends string>(options: {
+    message: string;
+    choices: readonly ChoiceOrValue<T>[];
+    required?: boolean;
+    initialValues?: readonly T[];
+    onCancel?: OnCancel<T[]>;
+}): Promise<T[]>;