@ohos-ports/nx 17.3.2-beta.0

package/src/adapter/rxjs-for-await.d.ts

@@ -0,0 +1,109 @@
+import { Observable } from 'rxjs';
+export declare class Deferred<T> {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    promise: Promise<T>;
+}
+/**
+ * Will subscribe to the `source` observable provided,
+ *
+ * Allowing a `for await..of` loop to iterate over every
+ * value that the source emits.
+ *
+ * **WARNING**: If the async loop is slower than the observable
+ * producing values, the values will build up in a buffer
+ * and you could experience an out of memory error.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of eachValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function eachValueFrom<T>(source: Observable<T>): AsyncIterableIterator<T>;
+/**
+ * Will subscribe to the `source` observable provided
+ * and build the emitted values up in a buffer. Allowing
+ * `for await..of` loops to iterate and get the buffer
+ * on each loop.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const buffer of bufferedValuesFrom(source$)) {
+ *     for (const value of buffer) {
+ *       console.log(value);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function bufferedValuesFrom<T>(source: Observable<T>): AsyncGenerator<any, void, unknown>;
+/**
+ * Will subscribe to the provided `source` observable,
+ * allowing `for await..of` loops to iterate and get the
+ * most recent value that was emitted. Will not iterate out
+ * the same emission twice.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of latestValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function latestValueFrom<T>(source: Observable<T>): AsyncGenerator<any, void, unknown>;
+/**
+ * Subscribes to the provided `source` observable and allows
+ * `for await..of` loops to iterate over it, such that
+ * all values are dropped until the iteration occurs, then
+ * the very next value that arrives is provided to the
+ * `for await` loop.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of nextValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function nextValueFrom<T>(source: Observable<T>): AsyncGenerator<T, void, void>;

package/src/adapter/rxjs-for-await.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextValueFrom = exports.latestValueFrom = exports.bufferedValuesFrom = exports.eachValueFrom = exports.Deferred = void 0;
+class Deferred {
+    constructor() {
+        this.resolve = null;
+        this.reject = null;
+        this.promise = new Promise((a, b) => {
+            this.resolve = a;
+            this.reject = b;
+        });
+    }
+}
+exports.Deferred = Deferred;
+const RESOLVED = Promise.resolve();
+/**
+ * Will subscribe to the `source` observable provided,
+ *
+ * Allowing a `for await..of` loop to iterate over every
+ * value that the source emits.
+ *
+ * **WARNING**: If the async loop is slower than the observable
+ * producing values, the values will build up in a buffer
+ * and you could experience an out of memory error.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of eachValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* eachValueFrom(source) {
+    const deferreds = [];
+    const values = [];
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            if (deferreds.length > 0) {
+                deferreds.shift().resolve({ value, done: false });
+            }
+            else {
+                values.push(value);
+            }
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            while (deferreds.length > 0) {
+                deferreds.shift().reject(err);
+            }
+        },
+        complete: () => {
+            completed = true;
+            while (deferreds.length > 0) {
+                deferreds.shift().resolve({ value: undefined, done: true });
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (values.length > 0) {
+                yield values.shift();
+            }
+            else if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                const d = new Deferred();
+                deferreds.push(d);
+                const result = await d.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+exports.eachValueFrom = eachValueFrom;
+/**
+ * Will subscribe to the `source` observable provided
+ * and build the emitted values up in a buffer. Allowing
+ * `for await..of` loops to iterate and get the buffer
+ * on each loop.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const buffer of bufferedValuesFrom(source$)) {
+ *     for (const value of buffer) {
+ *       console.log(value);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* bufferedValuesFrom(source) {
+    let deferred = null;
+    const buffer = [];
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            if (deferred) {
+                deferred.resolve(RESOLVED.then(() => {
+                    const bufferCopy = buffer.slice();
+                    buffer.length = 0;
+                    return { value: bufferCopy, done: false };
+                }));
+                deferred = null;
+            }
+            buffer.push(value);
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            if (deferred) {
+                deferred.reject(err);
+                deferred = null;
+            }
+        },
+        complete: () => {
+            completed = true;
+            if (deferred) {
+                deferred.resolve({ value: undefined, done: true });
+                deferred = null;
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (buffer.length > 0) {
+                const bufferCopy = buffer.slice();
+                buffer.length = 0;
+                yield bufferCopy;
+            }
+            else if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                deferred = new Deferred();
+                const result = await deferred.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+exports.bufferedValuesFrom = bufferedValuesFrom;
+/**
+ * Will subscribe to the provided `source` observable,
+ * allowing `for await..of` loops to iterate and get the
+ * most recent value that was emitted. Will not iterate out
+ * the same emission twice.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of latestValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* latestValueFrom(source) {
+    let deferred = undefined;
+    let latestValue;
+    let hasLatestValue = false;
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            hasLatestValue = true;
+            latestValue = value;
+            if (deferred) {
+                deferred.resolve(RESOLVED.then(() => {
+                    hasLatestValue = false;
+                    return { value: latestValue, done: false };
+                }));
+            }
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            if (deferred) {
+                deferred.reject(err);
+            }
+        },
+        complete: () => {
+            completed = true;
+            if (deferred) {
+                hasLatestValue = false;
+                deferred.resolve({ value: undefined, done: true });
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (hasLatestValue) {
+                await RESOLVED;
+                const value = latestValue;
+                hasLatestValue = false;
+                yield value;
+            }
+            else if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                deferred = new Deferred();
+                const result = await deferred.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+exports.latestValueFrom = latestValueFrom;
+/**
+ * Subscribes to the provided `source` observable and allows
+ * `for await..of` loops to iterate over it, such that
+ * all values are dropped until the iteration occurs, then
+ * the very next value that arrives is provided to the
+ * `for await` loop.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of nextValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* nextValueFrom(source) {
+    let deferred = undefined;
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            if (deferred) {
+                deferred.resolve({ value, done: false });
+            }
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            if (deferred) {
+                deferred.reject(err);
+            }
+        },
+        complete: () => {
+            completed = true;
+            if (deferred) {
+                deferred.resolve({ value: undefined, done: true });
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                deferred = new Deferred();
+                const result = await deferred.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+exports.nextValueFrom = nextValueFrom;

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

@@ -0,0 +1,2 @@
+import type { AddOptions } from './command-object';
+export declare function addHandler(options: AddOptions): Promise<void>;

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

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const ora = require("ora");
+const angular_json_1 = require("../../adapter/angular-json");
+const nx_json_1 = require("../../config/nx-json");
+const child_process_2 = require("../../utils/child-process");
+const fileutils_1 = require("../../utils/fileutils");
+const logger_1 = require("../../utils/logger");
+const output_1 = require("../../utils/output");
+const package_manager_1 = require("../../utils/package-manager");
+const params_1 = require("../../utils/params");
+const plugins_1 = require("../../utils/plugins");
+const versions_1 = require("../../utils/versions");
+const workspace_root_1 = require("../../utils/workspace-root");
+function addHandler(options) {
+    if (options.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
+    return (0, params_1.handleErrors)(isVerbose, async () => {
+        output_1.output.addNewline();
+        const [pkgName, version] = parsePackageSpecifier(options.packageSpecifier);
+        await installPackage(pkgName, version);
+        await initializePlugin(pkgName, options);
+        output_1.output.success({
+            title: `Package ${pkgName} added successfully.`,
+        });
+    });
+}
+exports.addHandler = addHandler;
+async function installPackage(pkgName, version) {
+    const spinner = ora(`Installing ${pkgName}@${version}...`);
+    spinner.start();
+    if ((0, fs_1.existsSync)('package.json')) {
+        const pmc = (0, package_manager_1.getPackageManagerCommand)();
+        await new Promise((resolve) => (0, child_process_1.exec)(`${pmc.addDev} ${pkgName}@${version}`, (error, stdout) => {
+            if (error) {
+                spinner.fail();
+                output_1.output.addNewline();
+                logger_1.logger.error(stdout);
+                output_1.output.error({
+                    title: `Failed to install ${pkgName}. Please check the error above for more details.`,
+                });
+                process.exit(1);
+            }
+            return resolve();
+        }));
+    }
+    else {
+        const nxJson = (0, nx_json_1.readNxJson)();
+        nxJson.installation.plugins ??= {};
+        nxJson.installation.plugins[pkgName] = version;
+        (0, fileutils_1.writeJsonFile)('nx.json', nxJson);
+        try {
+            await (0, child_process_2.runNxAsync)('');
+        }
+        catch (e) {
+            // revert adding the plugin to nx.json
+            nxJson.installation.plugins[pkgName] = undefined;
+            (0, fileutils_1.writeJsonFile)('nx.json', nxJson);
+            spinner.fail();
+            output_1.output.addNewline();
+            logger_1.logger.error(e.message);
+            output_1.output.error({
+                title: `Failed to install ${pkgName}. Please check the error above for more details.`,
+            });
+            process.exit(1);
+        }
+    }
+    spinner.succeed();
+}
+async function initializePlugin(pkgName, options) {
+    const capabilities = await (0, plugins_1.getPluginCapabilities)(workspace_root_1.workspaceRoot, pkgName, {});
+    const generators = capabilities?.generators;
+    if (!generators) {
+        output_1.output.log({
+            title: `No generators found in ${pkgName}. Skipping initialization.`,
+        });
+        return;
+    }
+    const initGenerator = findInitGenerator(generators);
+    if (!initGenerator) {
+        output_1.output.log({
+            title: `No "init" generator found in ${pkgName}. Skipping initialization.`,
+        });
+        return;
+    }
+    const spinner = ora(`Initializing ${pkgName}...`);
+    spinner.start();
+    try {
+        let updatePackageScripts;
+        if (options.updatePackageScripts !== undefined) {
+            updatePackageScripts = options.updatePackageScripts;
+        }
+        else {
+            updatePackageScripts =
+                process.env.NX_PCV3 === 'true' && coreNxPlugins.includes(pkgName);
+        }
+        await (0, child_process_2.runNxAsync)(`g ${pkgName}:${initGenerator} --keepExistingVersions${updatePackageScripts ? ' --updatePackageScripts' : ''}`);
+    }
+    catch (e) {
+        spinner.fail();
+        output_1.output.addNewline();
+        logger_1.logger.error(e.message);
+        output_1.output.error({
+            title: `Failed to initialize ${pkgName}. Please check the error above for more details.`,
+        });
+        process.exit(1);
+    }
+    spinner.succeed();
+}
+function findInitGenerator(generators) {
+    if (generators['init']) {
+        return 'init';
+    }
+    const angularPluginInstalled = (0, angular_json_1.isAngularPluginInstalled)();
+    if (angularPluginInstalled && generators['ng-add']) {
+        return 'ng-add';
+    }
+    return Object.keys(generators).find((name) => generators[name].aliases?.includes('init') ||
+        (angularPluginInstalled && generators[name].aliases?.includes('ng-add')));
+}
+function parsePackageSpecifier(packageSpecifier) {
+    const i = packageSpecifier.lastIndexOf('@');
+    if (i <= 0) {
+        if (coreNxPlugins.includes(packageSpecifier)) {
+            return [packageSpecifier, versions_1.nxVersion];
+        }
+        return [packageSpecifier, 'latest'];
+    }
+    const pkgName = packageSpecifier.substring(0, i);
+    const version = packageSpecifier.substring(i + 1);
+    return [pkgName, version];
+}
+const coreNxPlugins = [
+    '@nx/angular',
+    '@nx/cypress',
+    '@nx/detox',
+    '@nx/devkit',
+    '@nx/esbuild',
+    '@nx/eslint',
+    '@nx/eslint-plugin',
+    '@nx/expo',
+    '@nx/express',
+    '@nx/jest',
+    '@nx/nest',
+    '@nx/next',
+    '@nx/node',
+    '@nx/nuxt',
+    '@nx/playwright',
+    '@nx/plugin',
+    '@nx/react',
+    '@nx/react-native',
+    '@nx/remix',
+    '@nx/rollup',
+    '@nx/storybook',
+    '@nx/vite',
+    '@nx/vue',
+    '@nx/web',
+    '@nx/webpack',
+    '@nx/workspace',
+];

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

@@ -0,0 +1,7 @@
+import { CommandModule } from 'yargs';
+export interface AddOptions {
+    packageSpecifier: string;
+    updatePackageScripts?: boolean;
+    verbose?: boolean;
+}
+export declare const yargsAddCommand: CommandModule<Record<string, unknown>, AddOptions>;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsAddCommand = void 0;
+exports.yargsAddCommand = {
+    command: 'add <packageSpecifier>',
+    describe: 'Install a plugin and initialize it.',
+    builder: (yargs) => yargs
+        .positional('packageSpecifier', {
+        type: 'string',
+        description: 'The package name and optional version (e.g. `@nx/react` or `@nx/react@latest`) to install and initialize. If the version is not specified it will install the same version as the `nx` package for Nx core plugins or the latest version for other packages',
+    })
+        .option('updatePackageScripts', {
+        type: 'boolean',
+        description: 'Update `package.json` scripts with inferred targets. Defaults to `true` when `NX_PCV3=true` and the package is a core Nx plugin',
+    })
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Prints additional information about the commands (e.g., stack traces)',
+    })
+        .example('$0 add @nx/react', 'Install the latest version of the `@nx/react` package and run its `@nx/react:init` generator')
+        .example('$0 add non-core-nx-plugin', 'Install the latest version of the `non-core-nx-plugin` package and run its `non-core-nx-plugin:init` generator if available')
+        .example('$0 add @nx/react@17.0.0', 'Install version `17.0.0` of the `@nx/react` package and run its `@nx/react:init` generator'),
+    handler: (args) => Promise.resolve().then(() => require('./add')).then((m) => m.addHandler(args)),
+};

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

@@ -0,0 +1,7 @@
+import type { NxArgs } from '../../utils/command-line-utils';
+import { ProjectGraph, ProjectGraphProjectNode } from '../../config/project-graph';
+import { TargetDependencyConfig } from '../../config/workspace-json-project-json';
+export declare function affected(command: 'graph' | 'print-affected' | 'affected', args: {
+    [k: string]: any;
+}, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>): Promise<void>;
+export declare function getAffectedGraphNodes(nxArgs: NxArgs, projectGraph: ProjectGraph): Promise<ProjectGraphProjectNode[]>;