nx 13.8.8 → 13.9.0-beta.2

package/src/shared/nx.d.ts

@@ -0,0 +1,110 @@
+import { PackageManager } from './package-manager';
+import { TargetDependencyConfig } from './workspace';
+export declare type ImplicitDependencyEntry<T = '*' | string[]> = {
+    [key: string]: T | ImplicitJsonSubsetDependency<T>;
+};
+export interface ImplicitJsonSubsetDependency<T = '*' | string[]> {
+    [key: string]: T | ImplicitJsonSubsetDependency<T>;
+}
+export interface NxAffectedConfig {
+    /**
+     * Default based branch used by affected commands.
+     */
+    defaultBase?: string;
+}
+/**
+ * Nx.json configuration
+ */
+export interface NxJsonConfiguration<T = '*' | string[]> {
+    /**
+     * Optional (additional) Nx.json configuration file which becomes a base for this one
+     */
+    extends?: string;
+    /**
+     * Map of files to projects that implicitly depend on them
+     */
+    implicitDependencies?: ImplicitDependencyEntry<T>;
+    /**
+     * Dependencies between different target names across all projects
+     */
+    targetDependencies?: Record<string, TargetDependencyConfig[]>;
+    /**
+     * NPM Scope that the workspace uses
+     */
+    npmScope: string;
+    /**
+     * Default options for `nx affected`
+     */
+    affected?: NxAffectedConfig;
+    /**
+     * Where new apps + libs should be placed
+     */
+    workspaceLayout?: {
+        libsDir: string;
+        appsDir: string;
+    };
+    /**
+     * Available Task Runners
+     */
+    tasksRunnerOptions?: {
+        [tasksRunnerName: string]: {
+            /**
+             * Path to resolve the runner
+             */
+            runner: string;
+            /**
+             * Default options for the runner
+             */
+            options?: any;
+        };
+    };
+    /**
+     * List of default values used by generators.
+     *
+     * These defaults are global. They are used when no other defaults are configured.
+     *
+     * Example:
+     *
+     * ```
+     * {
+     *   "@nrwl/react": {
+     *     "library": {
+     *       "style": "scss"
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    generators?: {
+        [collectionName: string]: {
+            [generatorName: string]: any;
+        };
+    };
+    /**
+     * Default generator collection. It is used when no collection is provided.
+     */
+    cli?: {
+        packageManager?: PackageManager;
+        defaultCollection?: string;
+    };
+    /**
+     * Plugins for extending the project graph
+     */
+    plugins?: string[];
+    /**
+     * Configuration for Nx Plugins
+     */
+    pluginsConfig?: Record<string, unknown>;
+    /**
+     * Default project. When project isn't provided, the default project
+     * will be used. Convenient for small workspaces with one main application.
+     */
+    defaultProject?: string;
+}
+/**
+ * @deprecated(v14): nx.json no longer contains projects
+ */
+export interface NxJsonProjectConfiguration {
+    implicitDependencies?: string[];
+    tags?: string[];
+}

package/src/shared/nx.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=nx.js.map

package/src/shared/nx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nx.js","sourceRoot":"","sources":["../../../../../packages/nx/src/shared/nx.ts"],"names":[],"mappings":""}

package/src/shared/package-json.d.ts

@@ -0,0 +1,28 @@
+import { TargetConfiguration } from './workspace';
+export declare type PackageJsonTargetConfiguration = Omit<TargetConfiguration, 'executor'>;
+export interface NxProjectPackageJsonConfiguration {
+    targets?: Record<string, PackageJsonTargetConfiguration>;
+}
+export interface PackageJson {
+    name: string;
+    scripts?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    nx?: NxProjectPackageJsonConfiguration;
+    generators?: string;
+    schematics?: string;
+    builders?: string;
+    executors?: string;
+    'nx-migrations'?: string;
+}
+export declare function buildTargetFromScript(script: string, nx: NxProjectPackageJsonConfiguration): {
+    executor: string;
+    options: any;
+    outputs?: string[];
+    dependsOn?: import("./workspace").TargetDependencyConfig[];
+    configurations?: {
+        [config: string]: any;
+    };
+    defaultConfiguration?: string;
+};

package/src/shared/package-json.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTargetFromScript = void 0;
+function buildTargetFromScript(script, nx) {
+    var _a;
+    const nxTargetConfiguration = ((_a = nx === null || nx === void 0 ? void 0 : nx.targets) === null || _a === void 0 ? void 0 : _a[script]) || {};
+    return Object.assign(Object.assign({}, nxTargetConfiguration), { executor: '@nrwl/workspace:run-script', options: Object.assign(Object.assign({}, (nxTargetConfiguration.options || {})), { script }) });
+}
+exports.buildTargetFromScript = buildTargetFromScript;
+//# sourceMappingURL=package-json.js.map

package/src/shared/package-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-json.js","sourceRoot":"","sources":["../../../../../packages/nx/src/shared/package-json.ts"],"names":[],"mappings":";;;AA8BA,SAAgB,qBAAqB,CACnC,MAAc,EACd,EAAqC;;IAErC,MAAM,qBAAqB,GAAG,CAAA,MAAA,EAAE,aAAF,EAAE,uBAAF,EAAE,CAAE,OAAO,0CAAG,MAAM,CAAC,KAAI,EAAE,CAAC;IAE1D,uCACK,qBAAqB,KACxB,QAAQ,EAAE,4BAA4B,EACtC,OAAO,kCACF,CAAC,qBAAqB,CAAC,OAAO,IAAI,EAAE,CAAC,KACxC,MAAM,OAER;AACJ,CAAC;AAdD,sDAcC"}

package/src/shared/package-manager.d.ts

@@ -0,0 +1,32 @@
+export declare type PackageManager = 'yarn' | 'pnpm' | 'npm';
+export interface PackageManagerCommands {
+    install: string;
+    add: string;
+    addDev: string;
+    rm: string;
+    exec: string;
+    list: string;
+    run: (script: string, args: string) => string;
+}
+/**
+ * Detects which package manager is used in the workspace based on the lock file.
+ */
+export declare function detectPackageManager(dir?: string): PackageManager;
+/**
+ * Returns commands for the package manager used in the workspace.
+ * By default, the package manager is derived based on the lock file,
+ * but it can also be passed in explicitly.
+ *
+ * Example:
+ *
+ * ```javascript
+ * execSync(`${getPackageManagerCommand().addDev} my-dev-package`);
+ * ```
+ */
+export declare function getPackageManagerCommand(packageManager?: PackageManager): PackageManagerCommands;
+/**
+ * Returns the version of the package manager used in the workspace.
+ * By default, the package manager is derived based on the lock file,
+ * but it can also be passed in explicitly.
+ */
+export declare function getPackageManagerVersion(packageManager?: PackageManager): string;

package/src/shared/package-manager.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageManagerVersion = exports.getPackageManagerCommand = exports.detectPackageManager = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Detects which package manager is used in the workspace based on the lock file.
+ */
+function detectPackageManager(dir = '') {
+    return (0, fs_1.existsSync)((0, path_1.join)(dir, 'yarn.lock'))
+        ? 'yarn'
+        : (0, fs_1.existsSync)((0, path_1.join)(dir, 'pnpm-lock.yaml'))
+            ? 'pnpm'
+            : 'npm';
+}
+exports.detectPackageManager = detectPackageManager;
+/**
+ * Returns commands for the package manager used in the workspace.
+ * By default, the package manager is derived based on the lock file,
+ * but it can also be passed in explicitly.
+ *
+ * Example:
+ *
+ * ```javascript
+ * execSync(`${getPackageManagerCommand().addDev} my-dev-package`);
+ * ```
+ */
+function getPackageManagerCommand(packageManager = detectPackageManager()) {
+    const commands = {
+        yarn: () => ({
+            install: 'yarn',
+            add: 'yarn add -W',
+            addDev: 'yarn add -D -W',
+            rm: 'yarn remove',
+            exec: 'yarn',
+            run: (script, args) => `yarn ${script} ${args}`,
+            list: 'yarn list',
+        }),
+        pnpm: () => {
+            const [major, minor] = getPackageManagerVersion('pnpm').split('.');
+            let useExec = false;
+            if (+major >= 6 && +minor >= 13) {
+                useExec = true;
+            }
+            return {
+                install: 'pnpm install --no-frozen-lockfile',
+                add: 'pnpm add',
+                addDev: 'pnpm add -D',
+                rm: 'pnpm rm',
+                exec: useExec ? 'pnpm exec' : 'pnpx',
+                run: (script, args) => `pnpm run ${script} -- ${args}`,
+                list: 'pnpm ls --depth 100',
+            };
+        },
+        npm: () => {
+            var _a;
+            var _b;
+            (_a = (_b = process.env).npm_config_legacy_peer_deps) !== null && _a !== void 0 ? _a : (_b.npm_config_legacy_peer_deps = 'true');
+            return {
+                install: 'npm install',
+                add: 'npm install',
+                addDev: 'npm install -D',
+                rm: 'npm rm',
+                exec: 'npx',
+                run: (script, args) => `npm run ${script} -- ${args}`,
+                list: 'npm ls',
+            };
+        },
+    };
+    return commands[packageManager]();
+}
+exports.getPackageManagerCommand = getPackageManagerCommand;
+/**
+ * Returns the version of the package manager used in the workspace.
+ * By default, the package manager is derived based on the lock file,
+ * but it can also be passed in explicitly.
+ */
+function getPackageManagerVersion(packageManager = detectPackageManager()) {
+    return (0, child_process_1.execSync)(`${packageManager} --version`).toString('utf-8').trim();
+}
+exports.getPackageManagerVersion = getPackageManagerVersion;
+//# sourceMappingURL=package-manager.js.map

package/src/shared/package-manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"package-manager.js","sourceRoot":"","sources":["../../../../../packages/nx/src/shared/package-manager.ts"],"names":[],"mappings":";;;AAAA,iDAAyC;AACzC,2BAAgC;AAChC,+BAA4B;AAc5B;;GAEG;AACH,SAAgB,oBAAoB,CAAC,MAAc,EAAE;IACnD,OAAO,IAAA,eAAU,EAAC,IAAA,WAAI,EAAC,GAAG,EAAE,WAAW,CAAC,CAAC;QACvC,CAAC,CAAC,MAAM;QACR,CAAC,CAAC,IAAA,eAAU,EAAC,IAAA,WAAI,EAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;YACzC,CAAC,CAAC,MAAM;YACR,CAAC,CAAC,KAAK,CAAC;AACZ,CAAC;AAND,oDAMC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,wBAAwB,CACtC,iBAAiC,oBAAoB,EAAE;IAEvD,MAAM,QAAQ,GAA6D;QACzE,IAAI,EAAE,GAAG,EAAE,CAAC,CAAC;YACX,OAAO,EAAE,MAAM;YACf,GAAG,EAAE,aAAa;YAClB,MAAM,EAAE,gBAAgB;YACxB,EAAE,EAAE,aAAa;YACjB,IAAI,EAAE,MAAM;YACZ,GAAG,EAAE,CAAC,MAAc,EAAE,IAAY,EAAE,EAAE,CAAC,QAAQ,MAAM,IAAI,IAAI,EAAE;YAC/D,IAAI,EAAE,WAAW;SAClB,CAAC;QACF,IAAI,EAAE,GAAG,EAAE;YACT,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,GAAG,wBAAwB,CAAC,MAAM,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;YACnE,IAAI,OAAO,GAAG,KAAK,CAAC;YACpB,IAAI,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,KAAK,IAAI,EAAE,EAAE;gBAC/B,OAAO,GAAG,IAAI,CAAC;aAChB;YACD,OAAO;gBACL,OAAO,EAAE,mCAAmC;gBAC5C,GAAG,EAAE,UAAU;gBACf,MAAM,EAAE,aAAa;gBACrB,EAAE,EAAE,SAAS;gBACb,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,MAAM;gBACpC,GAAG,EAAE,CAAC,MAAc,EAAE,IAAY,EAAE,EAAE,CAAC,YAAY,MAAM,OAAO,IAAI,EAAE;gBACtE,IAAI,EAAE,qBAAqB;aAC5B,CAAC;QACJ,CAAC;QACD,GAAG,EAAE,GAAG,EAAE;;;YACR,YAAA,OAAO,CAAC,GAAG,EAAC,2BAA2B,uCAA3B,2BAA2B,GAAK,MAAM,EAAC;YAEnD,OAAO;gBACL,OAAO,EAAE,aAAa;gBACtB,GAAG,EAAE,aAAa;gBAClB,MAAM,EAAE,gBAAgB;gBACxB,EAAE,EAAE,QAAQ;gBACZ,IAAI,EAAE,KAAK;gBACX,GAAG,EAAE,CAAC,MAAc,EAAE,IAAY,EAAE,EAAE,CAAC,WAAW,MAAM,OAAO,IAAI,EAAE;gBACrE,IAAI,EAAE,QAAQ;aACf,CAAC;QACJ,CAAC;KACF,CAAC;IAEF,OAAO,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;AACpC,CAAC;AA7CD,4DA6CC;AAED;;;;GAIG;AACH,SAAgB,wBAAwB,CACtC,iBAAiC,oBAAoB,EAAE;IAEvD,OAAO,IAAA,wBAAQ,EAAC,GAAG,cAAc,YAAY,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,CAAC;AAC1E,CAAC;AAJD,4DAIC"}

package/src/shared/params.d.ts

@@ -0,0 +1,113 @@
+import type { Arguments } from 'yargs-parser';
+import { TargetConfiguration, WorkspaceJsonConfiguration } from './workspace';
+import { NxJsonConfiguration } from './nx';
+declare type PropertyDescription = {
+    type?: string | string[];
+    required?: string[];
+    enum?: string[];
+    properties?: any;
+    oneOf?: PropertyDescription[];
+    anyOf?: PropertyDescription[];
+    allOf?: PropertyDescription[];
+    items?: any;
+    alias?: string;
+    aliases?: string[];
+    description?: string;
+    format?: string;
+    visible?: boolean;
+    default?: string | number | boolean | string[] | {
+        [key: string]: string | number | boolean | string[];
+    };
+    $ref?: string;
+    $default?: {
+        $source: 'argv';
+        index: number;
+    } | {
+        $source: 'projectName';
+    };
+    additionalProperties?: boolean;
+    'x-prompt'?: string | {
+        message: string;
+        type: string;
+        items: any[];
+        multiselect?: boolean;
+    };
+    'x-deprecated'?: boolean | string;
+    multipleOf?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+};
+declare type Properties = {
+    [p: string]: PropertyDescription;
+};
+export declare type Schema = {
+    properties: Properties;
+    required?: string[];
+    description?: string;
+    definitions?: Properties;
+    additionalProperties?: boolean;
+};
+export declare type Unmatched = {
+    name: string;
+    possible: string[];
+};
+export declare type Options = {
+    '--'?: Unmatched[];
+    [k: string]: string | number | boolean | string[] | Unmatched[];
+};
+export declare function handleErrors(isVerbose: boolean, fn: Function): Promise<any>;
+export declare function convertToCamelCase(parsed: Arguments): Options;
+/**
+ * Coerces (and replaces) options identified as 'boolean' or 'number' in the Schema
+ *
+ * @param opts The options to check
+ * @param schema The schema definition with types to check against
+ *
+ */
+export declare function coerceTypesInOptions(opts: Options, schema: Schema): Options;
+/**
+ * Converts any options passed in with short aliases to their full names if found
+ * Unmatched options are added to opts['--']
+ *
+ * @param opts The options passed in by the user
+ * @param schema The schema definition to check against
+ */
+export declare function convertAliases(opts: Options, schema: Schema, excludeUnmatched: boolean): Options;
+export declare class SchemaError {
+    readonly message: string;
+    constructor(message: string);
+}
+export declare function validateOptsAgainstSchema(opts: {
+    [k: string]: any;
+}, schema: Schema): void;
+export declare function validateObject(opts: {
+    [k: string]: any;
+}, properties: Properties, required: string[], additionalProperties: boolean | undefined, definitions: Properties): void;
+export declare function setDefaults(opts: {
+    [k: string]: any;
+}, schema: Schema): {
+    [k: string]: any;
+};
+export declare function applyVerbosity(options: Record<string, unknown>, schema: Schema, isVerbose: boolean): void;
+export declare function combineOptionsForExecutor(commandLineOpts: Options, config: string, target: TargetConfiguration, schema: Schema, defaultProjectName: string | null, relativeCwd: string | null, isVerbose?: boolean): any;
+export declare function combineOptionsForGenerator(commandLineOpts: Options, collectionName: string, generatorName: string, wc: (WorkspaceJsonConfiguration & NxJsonConfiguration) | null, schema: Schema, isInteractive: boolean, defaultProjectName: string | null, relativeCwd: string | null, isVerbose?: boolean): Promise<Options>;
+export declare function warnDeprecations(opts: {
+    [k: string]: any;
+}, schema: Schema): void;
+export declare function convertSmartDefaultsIntoNamedParams(opts: {
+    [k: string]: any;
+}, schema: Schema, argv: string[], defaultProjectName: string | null, relativeCwd: string | null): void;
+/**
+ * Tries to find what the user meant by unmatched commands
+ *
+ * @param opts The options passed in by the user
+ * @param schema The schema definition to check against
+ *
+ */
+export declare function lookupUnmatched(opts: Options, schema: Schema): Options;
+export {};