@ohos-ports/nx 19.8.4-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.Deferred = void 0;
+exports.eachValueFrom = eachValueFrom;
+exports.bufferedValuesFrom = bufferedValuesFrom;
+exports.latestValueFrom = latestValueFrom;
+exports.nextValueFrom = nextValueFrom;
+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();
+    }
+}
+/**
+ * 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();
+    }
+}
+/**
+ * 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();
+    }
+}
+/**
+ * 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();
+    }
+}

package/src/command-line/activate-powerpack/activate-powerpack.d.ts

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

package/src/command-line/activate-powerpack/activate-powerpack.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleActivatePowerpack = handleActivatePowerpack;
+const workspace_root_1 = require("../../utils/workspace-root");
+const enquirer_1 = require("enquirer");
+const child_process_1 = require("child_process");
+const package_manager_1 = require("../../utils/package-manager");
+async function handleActivatePowerpack(options) {
+    const license = options.license ??
+        (await (0, enquirer_1.prompt)({
+            type: 'input',
+            name: 'license',
+            message: 'Enter your License Key',
+        }));
+    const { activatePowerpack } = await requirePowerpack();
+    activatePowerpack(workspace_root_1.workspaceRoot, license);
+}
+async function requirePowerpack() {
+    // @ts-ignore
+    return Promise.resolve().then(() => require('@nx/powerpack-license')).catch(async (e) => {
+        if ('code' in e && e.code === 'MODULE_NOT_FOUND') {
+            try {
+                (0, child_process_1.execSync)(`${(0, package_manager_1.getPackageManagerCommand)().addDev} @nx/powerpack-license@latest`, {
+                    windowsHide: true,
+                });
+                // @ts-ignore
+                return await Promise.resolve().then(() => require('@nx/powerpack-license'));
+            }
+            catch (e) {
+                throw new Error('Failed to install @nx/powerpack-license. Please install @nx/powerpack-license and try again.');
+            }
+        }
+    });
+}

package/src/command-line/activate-powerpack/command-object.d.ts

@@ -0,0 +1,6 @@
+import { CommandModule } from 'yargs';
+export interface ActivatePowerpackOptions {
+    license: string;
+    verbose: boolean;
+}
+export declare const yargsActivatePowerpackCommand: CommandModule<{}, ActivatePowerpackOptions>;

package/src/command-line/activate-powerpack/command-object.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsActivatePowerpackCommand = void 0;
+const shared_options_1 = require("../yargs-utils/shared-options");
+const handle_errors_1 = require("../../utils/handle-errors");
+exports.yargsActivatePowerpackCommand = {
+    command: 'activate-powerpack <license>',
+    describe: false,
+    // describe: 'Activate a Nx Powerpack license.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs)
+        .parserConfiguration({
+        'strip-dashed': true,
+        'unknown-options-as-args': true,
+    })
+        .positional('license', {
+        type: 'string',
+        description: 'This is a License Key for Nx Powerpack.',
+    })
+        .example('$0 activate-powerpack <license key>', 'Activate a Nx Powerpack license'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose, async () => {
+            return (await Promise.resolve().then(() => require('./activate-powerpack'))).handleActivatePowerpack(args);
+        });
+        process.exit(exitCode);
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { AddOptions } from './command-object';
+export declare function addHandler(options: AddOptions): Promise<number>;
+export declare const coreNxPluginVersions: Map<string, string>;

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

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coreNxPluginVersions = void 0;
+exports.addHandler = addHandler;
+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 handle_errors_1 = require("../../utils/handle-errors");
+const plugins_1 = require("../../utils/plugins");
+const versions_1 = require("../../utils/versions");
+const workspace_root_1 = require("../../utils/workspace-root");
+const add_nx_scripts_1 = require("../init/implementation/dot-nx/add-nx-scripts");
+function addHandler(options) {
+    return (0, handle_errors_1.handleErrors)(options.verbose, async () => {
+        output_1.output.addNewline();
+        const [pkgName, version] = parsePackageSpecifier(options.packageSpecifier);
+        const nxJson = (0, nx_json_1.readNxJson)();
+        await installPackage(pkgName, version, nxJson);
+        await initializePlugin(pkgName, options, nxJson);
+        output_1.output.success({
+            title: `Package ${pkgName} added successfully.`,
+        });
+    });
+}
+async function installPackage(pkgName, version, nxJson) {
+    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}`, {
+            windowsHide: true,
+        }, (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 {
+        nxJson.installation.plugins ??= {};
+        nxJson.installation.plugins[pkgName] = (0, add_nx_scripts_1.normalizeVersionForNxJson)(pkgName, version);
+        (0, fileutils_1.writeJsonFile)('nx.json', nxJson);
+        try {
+            await (0, child_process_2.runNxAsync)('--help', { silent: true });
+        }
+        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, nxJson) {
+    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 {
+        const args = [];
+        if (exports.coreNxPluginVersions.has(pkgName)) {
+            args.push(`--keepExistingVersions`);
+            if (options.updatePackageScripts ||
+                (options.updatePackageScripts === undefined &&
+                    nxJson.useInferencePlugins !== false &&
+                    process.env.NX_ADD_PLUGINS !== 'false')) {
+                args.push(`--updatePackageScripts`);
+            }
+        }
+        if (options.__overrides_unparsed__.length) {
+            args.push(...options.__overrides_unparsed__);
+        }
+        (0, child_process_2.runNxSync)(`g ${pkgName}:${initGenerator} ${args.join(' ')}`, {
+            stdio: [0, 1, 2],
+        });
+    }
+    catch (e) {
+        spinner.fail();
+        output_1.output.addNewline();
+        logger_1.logger.error(e);
+        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 (exports.coreNxPluginVersions.has(packageSpecifier)) {
+            return [packageSpecifier, exports.coreNxPluginVersions.get(packageSpecifier)];
+        }
+        return [packageSpecifier, 'latest'];
+    }
+    const pkgName = packageSpecifier.substring(0, i);
+    const version = packageSpecifier.substring(i + 1);
+    return [pkgName, version];
+}
+exports.coreNxPluginVersions = require('../../../package.json')['nx-migrations'].packageGroup.reduce((map, entry) => {
+    const packageName = typeof entry === 'string' ? entry : entry.package;
+    const version = typeof entry === 'string' ? versions_1.nxVersion : entry.version;
+    return map.set(packageName, version);
+}, 
+// Package Name -> Desired Version
+new Map());