@ohos-ports/nx 17.3.2-beta.0

package/src/utils/path.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCwd = exports.joinPathFragments = exports.normalizePath = void 0;
+const path = require("path");
+const workspace_root_1 = require("./workspace-root");
+function removeWindowsDriveLetter(osSpecificPath) {
+    return osSpecificPath.replace(/^[A-Z]:/, '');
+}
+/**
+ * Coverts an os specific path to a unix style path. Use this when writing paths to config files.
+ * This should not be used to read files on disk because of the removal of Windows drive letters.
+ */
+function normalizePath(osSpecificPath) {
+    return removeWindowsDriveLetter(osSpecificPath).split('\\').join('/');
+}
+exports.normalizePath = normalizePath;
+/**
+ * Normalized path fragments and joins them. Use this when writing paths to config files.
+ * This should not be used to read files on disk because of the removal of Windows drive letters.
+ */
+function joinPathFragments(...fragments) {
+    return normalizePath(path.join(...fragments));
+}
+exports.joinPathFragments = joinPathFragments;
+/**
+ * When running a script with the package manager (e.g. `npm run`), the package manager will
+ * traverse the directory tree upwards until it finds a `package.json` and will set `process.cwd()`
+ * to the folder where it found it. The actual working directory is stored in the INIT_CWD
+ * environment variable (see here: https://docs.npmjs.com/cli/v9/commands/npm-run-script#description).
+ *
+ * @returns The path to the current working directory.
+ */
+function getCwd() {
+    return process.env.INIT_CWD?.startsWith(workspace_root_1.workspaceRoot)
+        ? process.env.INIT_CWD
+        : process.cwd();
+}
+exports.getCwd = getCwd;

package/src/utils/perf-logging.d.ts

@@ -0,0 +1 @@
+export {};

package/src/utils/perf-logging.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const perf_hooks_1 = require("perf_hooks");
+if (process.env.NX_PERF_LOGGING === 'true') {
+    const obs = new perf_hooks_1.PerformanceObserver((list) => {
+        for (const entry of list.getEntries()) {
+            console.log(`Time for '${entry.name}'`, entry.duration);
+        }
+    });
+    obs.observe({ entryTypes: ['measure'] });
+}

package/src/utils/plugins/community-plugins.d.ts

@@ -0,0 +1,2 @@
+import type { CommunityPlugin } from './models';
+export declare function fetchCommunityPlugins(): Promise<CommunityPlugin[]>;

package/src/utils/plugins/community-plugins.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchCommunityPlugins = void 0;
+const https_1 = require("https");
+const COMMUNITY_PLUGINS_JSON_URL = 'https://raw.githubusercontent.com/nrwl/nx/master/community/approved-plugins.json';
+async function fetchCommunityPlugins() {
+    return new Promise((resolve, reject) => {
+        const req = (0, https_1.get)(COMMUNITY_PLUGINS_JSON_URL, (res) => {
+            if (res.statusCode < 200 || res.statusCode >= 300) {
+                reject(new Error(`Request failed with status code ${res.statusCode}`));
+            }
+            const data = [];
+            res.on('data', (chunk) => {
+                data.push(chunk);
+            });
+            res.on('end', () => {
+                try {
+                    resolve(JSON.parse(Buffer.concat(data).toString('utf-8')));
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.end();
+    });
+}
+exports.fetchCommunityPlugins = fetchCommunityPlugins;

package/src/utils/plugins/core-plugins.d.ts

@@ -0,0 +1,3 @@
+import type { CorePlugin, PluginCapabilities } from './models';
+export declare function fetchCorePlugins(): CorePlugin[];
+export declare function listCorePlugins(installedPlugins: Map<string, PluginCapabilities>, corePlugins: CorePlugin[]): void;

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listCorePlugins = exports.fetchCorePlugins = void 0;
+const chalk = require("chalk");
+const output_1 = require("../output");
+function fetchCorePlugins() {
+    return [
+        {
+            name: '@nx/angular',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/cypress',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/detox',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/esbuild',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/expo',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/express',
+            capabilities: 'generators',
+        },
+        {
+            name: '@nx/jest',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/js',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/eslint',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/nest',
+            capabilities: 'generators',
+        },
+        {
+            name: '@nx/next',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/node',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: 'nx',
+            capabilities: 'executors',
+        },
+        {
+            name: '@nx/plugin',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/react',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/react-native',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/remix',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/rollup',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/storybook',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/vite',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/web',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/webpack',
+            capabilities: 'executors,generators',
+        },
+        {
+            name: '@nx/workspace',
+            capabilities: 'executors,generators',
+        },
+    ];
+}
+exports.fetchCorePlugins = fetchCorePlugins;
+function listCorePlugins(installedPlugins, corePlugins) {
+    const alsoAvailable = corePlugins.filter((p) => !installedPlugins.has(p.name));
+    if (alsoAvailable.length) {
+        output_1.output.log({
+            title: `Also available:`,
+            bodyLines: alsoAvailable.map((p) => {
+                return `${chalk.bold(p.name)} (${p.capabilities})`;
+            }),
+        });
+    }
+}
+exports.listCorePlugins = listCorePlugins;

package/src/utils/plugins/index.d.ts

@@ -0,0 +1,4 @@
+export { fetchCommunityPlugins } from './community-plugins';
+export { fetchCorePlugins, listCorePlugins } from './core-plugins';
+export { getInstalledPluginsAndCapabilities, listInstalledPlugins, } from './installed-plugins';
+export { getPluginCapabilities, listPluginCapabilities, } from './plugin-capabilities';

package/src/utils/plugins/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPluginCapabilities = exports.getPluginCapabilities = exports.listInstalledPlugins = exports.getInstalledPluginsAndCapabilities = exports.listCorePlugins = exports.fetchCorePlugins = exports.fetchCommunityPlugins = void 0;
+var community_plugins_1 = require("./community-plugins");
+Object.defineProperty(exports, "fetchCommunityPlugins", { enumerable: true, get: function () { return community_plugins_1.fetchCommunityPlugins; } });
+var core_plugins_1 = require("./core-plugins");
+Object.defineProperty(exports, "fetchCorePlugins", { enumerable: true, get: function () { return core_plugins_1.fetchCorePlugins; } });
+Object.defineProperty(exports, "listCorePlugins", { enumerable: true, get: function () { return core_plugins_1.listCorePlugins; } });
+var installed_plugins_1 = require("./installed-plugins");
+Object.defineProperty(exports, "getInstalledPluginsAndCapabilities", { enumerable: true, get: function () { return installed_plugins_1.getInstalledPluginsAndCapabilities; } });
+Object.defineProperty(exports, "listInstalledPlugins", { enumerable: true, get: function () { return installed_plugins_1.listInstalledPlugins; } });
+var plugin_capabilities_1 = require("./plugin-capabilities");
+Object.defineProperty(exports, "getPluginCapabilities", { enumerable: true, get: function () { return plugin_capabilities_1.getPluginCapabilities; } });
+Object.defineProperty(exports, "listPluginCapabilities", { enumerable: true, get: function () { return plugin_capabilities_1.listPluginCapabilities; } });

package/src/utils/plugins/installed-plugins.d.ts

@@ -0,0 +1,6 @@
+import type { PluginCapabilities } from './models';
+import { PackageJson } from '../package-json';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export declare function findInstalledPlugins(): PackageJson[];
+export declare function getInstalledPluginsAndCapabilities(workspaceRoot: string, projects: Record<string, ProjectConfiguration>): Promise<Map<string, PluginCapabilities>>;
+export declare function listInstalledPlugins(installedPlugins: Map<string, PluginCapabilities>): void;

package/src/utils/plugins/installed-plugins.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listInstalledPlugins = exports.getInstalledPluginsAndCapabilities = exports.findInstalledPlugins = void 0;
+const chalk = require("chalk");
+const output_1 = require("../output");
+const plugin_capabilities_1 = require("./plugin-capabilities");
+const shared_1 = require("./shared");
+const fileutils_1 = require("../fileutils");
+const package_json_1 = require("../package-json");
+const workspace_root_1 = require("../workspace-root");
+const path_1 = require("path");
+const nx_json_1 = require("../../config/nx-json");
+const installation_directory_1 = require("../installation-directory");
+function findInstalledPlugins() {
+    const packageJsonDeps = getDependenciesFromPackageJson();
+    const nxJsonDeps = getDependenciesFromNxJson();
+    const deps = packageJsonDeps.concat(nxJsonDeps);
+    const result = [];
+    for (const dep of deps) {
+        const pluginPackageJson = getNxPluginPackageJsonOrNull(dep);
+        if (pluginPackageJson) {
+            result.push(pluginPackageJson);
+        }
+    }
+    return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+exports.findInstalledPlugins = findInstalledPlugins;
+function getNxPluginPackageJsonOrNull(pkg) {
+    try {
+        const { packageJson } = (0, package_json_1.readModulePackageJson)(pkg, (0, installation_directory_1.getNxRequirePaths)());
+        return packageJson &&
+            [
+                'ng-update',
+                'nx-migrations',
+                'schematics',
+                'generators',
+                'builders',
+                'executors',
+            ].some((field) => field in packageJson)
+            ? packageJson
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function getDependenciesFromPackageJson(packageJsonPath = 'package.json') {
+    try {
+        const { dependencies, devDependencies } = (0, fileutils_1.readJsonFile)((0, path_1.join)(workspace_root_1.workspaceRoot, packageJsonPath));
+        return Object.keys({ ...dependencies, ...devDependencies });
+    }
+    catch { }
+    return [];
+}
+function getDependenciesFromNxJson() {
+    const { installation } = (0, nx_json_1.readNxJson)();
+    if (!installation) {
+        return [];
+    }
+    return ['nx', ...Object.keys(installation.plugins || {})];
+}
+async function getInstalledPluginsAndCapabilities(workspaceRoot, projects) {
+    const plugins = findInstalledPlugins().map((p) => p.name);
+    const result = new Map();
+    for (const plugin of Array.from(plugins).sort()) {
+        try {
+            const capabilities = await (0, plugin_capabilities_1.getPluginCapabilities)(workspaceRoot, plugin, projects);
+            if (capabilities &&
+                (capabilities.executors ||
+                    capabilities.generators ||
+                    capabilities.projectGraphExtension ||
+                    capabilities.projectInference)) {
+                result.set(plugin, capabilities);
+            }
+        }
+        catch { }
+    }
+    return result;
+}
+exports.getInstalledPluginsAndCapabilities = getInstalledPluginsAndCapabilities;
+function listInstalledPlugins(installedPlugins) {
+    const bodyLines = [];
+    for (const [, p] of installedPlugins) {
+        const capabilities = [];
+        if ((0, shared_1.hasElements)(p.executors)) {
+            capabilities.push('executors');
+        }
+        if ((0, shared_1.hasElements)(p.generators)) {
+            capabilities.push('generators');
+        }
+        if (p.projectGraphExtension) {
+            capabilities.push('graph-extensions');
+        }
+        if (p.projectInference) {
+            capabilities.push('project-inference');
+        }
+        bodyLines.push(`${chalk.bold(p.name)} (${capabilities.join()})`);
+    }
+    output_1.output.log({
+        title: `Installed plugins:`,
+        bodyLines: bodyLines,
+    });
+}
+exports.listInstalledPlugins = listInstalledPlugins;

package/src/utils/plugins/local-plugins.d.ts

@@ -0,0 +1,5 @@
+import type { PluginCapabilities } from './models';
+import { ProjectsConfigurations } from '../../config/workspace-json-project-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
+export declare function getLocalWorkspacePlugins(projectsConfiguration: ProjectsConfigurations, nxJson: NxJsonConfiguration): Promise<Map<string, PluginCapabilities>>;
+export declare function listLocalWorkspacePlugins(installedPlugins: Map<string, PluginCapabilities>): void;

package/src/utils/plugins/local-plugins.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listLocalWorkspacePlugins = exports.getLocalWorkspacePlugins = void 0;
+const chalk = require("chalk");
+const output_1 = require("../output");
+const shared_1 = require("./shared");
+const fileutils_1 = require("../fileutils");
+const path_1 = require("path");
+const workspace_root_1 = require("../workspace-root");
+const fs_1 = require("fs");
+const plugin_capabilities_1 = require("./plugin-capabilities");
+async function getLocalWorkspacePlugins(projectsConfiguration, nxJson) {
+    const plugins = new Map();
+    for (const project of Object.values(projectsConfiguration.projects)) {
+        const packageJsonPath = (0, path_1.join)(workspace_root_1.workspaceRoot, project.root, 'package.json');
+        if ((0, fs_1.existsSync)(packageJsonPath)) {
+            const packageJson = (0, fileutils_1.readJsonFile)(packageJsonPath);
+            const includeRuntimeCapabilities = nxJson?.plugins?.some((p) => (typeof p === 'string' ? p : p.plugin).startsWith(packageJson.name));
+            const capabilities = await (0, plugin_capabilities_1.getPluginCapabilities)(workspace_root_1.workspaceRoot, packageJson.name, projectsConfiguration.projects, includeRuntimeCapabilities);
+            if (capabilities &&
+                (Object.keys(capabilities.executors ?? {}).length ||
+                    Object.keys(capabilities.generators ?? {}).length ||
+                    capabilities.projectGraphExtension ||
+                    capabilities.projectInference)) {
+                plugins.set(packageJson.name, {
+                    ...capabilities,
+                    name: packageJson.name,
+                });
+            }
+        }
+    }
+    return plugins;
+}
+exports.getLocalWorkspacePlugins = getLocalWorkspacePlugins;
+function listLocalWorkspacePlugins(installedPlugins) {
+    const bodyLines = [];
+    for (const [, p] of installedPlugins) {
+        const capabilities = [];
+        if ((0, shared_1.hasElements)(p.executors)) {
+            capabilities.push('executors');
+        }
+        if ((0, shared_1.hasElements)(p.generators)) {
+            capabilities.push('generators');
+        }
+        if (p.projectGraphExtension) {
+            capabilities.push('graph-extension');
+        }
+        if (p.projectInference) {
+            capabilities.push('project-inference');
+        }
+        bodyLines.push(`${chalk.bold(p.name)} (${capabilities.join()})`);
+    }
+    output_1.output.log({
+        title: `Local workspace plugins:`,
+        bodyLines: bodyLines,
+    });
+}
+exports.listLocalWorkspacePlugins = listLocalWorkspacePlugins;

package/src/utils/plugins/models.d.ts

@@ -0,0 +1,22 @@
+import { ExecutorsJsonEntry, GeneratorsJsonEntry } from '../../config/misc-interfaces';
+export interface PluginCapabilities {
+    name: string;
+    executors?: {
+        [name: string]: ExecutorsJsonEntry;
+    };
+    generators?: {
+        [name: string]: GeneratorsJsonEntry;
+    };
+    projectInference?: boolean;
+    projectGraphExtension?: boolean;
+}
+export interface CorePlugin {
+    name: string;
+    capabilities: 'executors' | 'generators' | 'executors,generators';
+    link?: string;
+}
+export interface CommunityPlugin {
+    name: string;
+    url: string;
+    description: string;
+}

package/src/utils/plugins/models.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/utils/plugins/plugin-capabilities.d.ts

@@ -0,0 +1,4 @@
+import type { PluginCapabilities } from './models';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export declare function getPluginCapabilities(workspaceRoot: string, pluginName: string, projects: Record<string, ProjectConfiguration>, includeRuntimeCapabilities?: boolean): Promise<PluginCapabilities | null>;
+export declare function listPluginCapabilities(pluginName: string, projects: Record<string, ProjectConfiguration>): Promise<void>;

package/src/utils/plugins/plugin-capabilities.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPluginCapabilities = exports.getPluginCapabilities = void 0;
+const workspace_root_1 = require("../workspace-root");
+const chalk = require("chalk");
+const path_1 = require("path");
+const output_1 = require("../output");
+const shared_1 = require("./shared");
+const fileutils_1 = require("../fileutils");
+const package_manager_1 = require("../package-manager");
+const nx_plugin_1 = require("../nx-plugin");
+const installation_directory_1 = require("../installation-directory");
+function tryGetCollection(packageJsonPath, collectionFile, propName) {
+    if (!collectionFile) {
+        return null;
+    }
+    try {
+        const collectionFilePath = (0, path_1.join)((0, path_1.dirname)(packageJsonPath), collectionFile);
+        return (0, fileutils_1.readJsonFile)(collectionFilePath)[propName];
+    }
+    catch {
+        return null;
+    }
+}
+async function getPluginCapabilities(workspaceRoot, pluginName, projects, includeRuntimeCapabilities = false) {
+    try {
+        const { json: packageJson, path: packageJsonPath } = await (0, nx_plugin_1.readPluginPackageJson)(pluginName, projects, (0, installation_directory_1.getNxRequirePaths)(workspaceRoot));
+        const pluginModule = includeRuntimeCapabilities
+            ? await tryGetModule(packageJson, workspaceRoot, projects)
+            : {};
+        return {
+            name: pluginName,
+            generators: {
+                ...tryGetCollection(packageJsonPath, packageJson.schematics, 'schematics'),
+                ...tryGetCollection(packageJsonPath, packageJson.generators, 'schematics'),
+                ...tryGetCollection(packageJsonPath, packageJson.schematics, 'generators'),
+                ...tryGetCollection(packageJsonPath, packageJson.generators, 'generators'),
+            },
+            executors: {
+                ...tryGetCollection(packageJsonPath, packageJson.builders, 'builders'),
+                ...tryGetCollection(packageJsonPath, packageJson.executors, 'builders'),
+                ...tryGetCollection(packageJsonPath, packageJson.builders, 'executors'),
+                ...tryGetCollection(packageJsonPath, packageJson.executors, 'executors'),
+            },
+            projectGraphExtension: pluginModule &&
+                ('processProjectGraph' in pluginModule ||
+                    'createNodes' in pluginModule ||
+                    'createDependencies' in pluginModule),
+            projectInference: pluginModule &&
+                ('projectFilePatterns' in pluginModule ||
+                    'createNodes' in pluginModule),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+exports.getPluginCapabilities = getPluginCapabilities;
+async function tryGetModule(packageJson, workspaceRoot, projects) {
+    try {
+        return (packageJson.generators ??
+            packageJson.executors ??
+            packageJson['nx-migrations'] ??
+            packageJson['schematics'] ??
+            packageJson['builders'])
+            ? (await (0, nx_plugin_1.loadNxPluginAsync)(packageJson.name, (0, installation_directory_1.getNxRequirePaths)(workspaceRoot), projects, workspaceRoot)).plugin
+            : {
+                name: packageJson.name,
+            };
+    }
+    catch {
+        return null;
+    }
+}
+async function listPluginCapabilities(pluginName, projects) {
+    const plugin = await getPluginCapabilities(workspace_root_1.workspaceRoot, pluginName, projects);
+    if (!plugin) {
+        const pmc = (0, package_manager_1.getPackageManagerCommand)();
+        output_1.output.note({
+            title: `${pluginName} is not currently installed`,
+            bodyLines: [
+                `Use "${pmc.addDev} ${pluginName}" to install the plugin.`,
+                `After that, use "${pmc.exec} nx g ${pluginName}:init" to add the required peer deps and initialize the plugin.`,
+            ],
+        });
+        return;
+    }
+    const hasBuilders = (0, shared_1.hasElements)(plugin.executors);
+    const hasGenerators = (0, shared_1.hasElements)(plugin.generators);
+    const hasProjectGraphExtension = !!plugin.projectGraphExtension;
+    const hasProjectInference = !!plugin.projectInference;
+    if (!hasBuilders &&
+        !hasGenerators &&
+        !hasProjectGraphExtension &&
+        !hasProjectInference) {
+        output_1.output.warn({ title: `No capabilities found in ${pluginName}` });
+        return;
+    }
+    const bodyLines = [];
+    if (hasGenerators) {
+        bodyLines.push(chalk.bold(chalk.green('GENERATORS')));
+        bodyLines.push('');
+        bodyLines.push(...Object.keys(plugin.generators).map((name) => `${chalk.bold(name)} : ${plugin.generators[name].description}`));
+        if (hasBuilders) {
+            bodyLines.push('');
+        }
+    }
+    if (hasBuilders) {
+        bodyLines.push(chalk.bold(chalk.green('EXECUTORS/BUILDERS')));
+        bodyLines.push('');
+        bodyLines.push(...Object.keys(plugin.executors).map((name) => `${chalk.bold(name)} : ${plugin.executors[name].description}`));
+    }
+    if (hasProjectGraphExtension) {
+        bodyLines.push(`✔️  Project Graph Extension`);
+    }
+    if (hasProjectInference) {
+        bodyLines.push(`✔️  Project Inference`);
+    }
+    output_1.output.log({
+        title: `Capabilities in ${plugin.name}:`,
+        bodyLines,
+    });
+}
+exports.listPluginCapabilities = listPluginCapabilities;

package/src/utils/plugins/shared.d.ts

@@ -0,0 +1 @@
+export declare function hasElements(obj: any): boolean;

package/src/utils/plugins/shared.js

@@ -0,0 +1,8 @@
+"use strict";
+// Lifted in part from https://github.com/nrwl/angular-console
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasElements = void 0;
+function hasElements(obj) {
+    return obj && Object.values(obj).length > 0;
+}
+exports.hasElements = hasElements;

package/src/utils/print-help.d.ts

@@ -0,0 +1,11 @@
+import { Schema } from './params';
+export declare function printHelp(header: string, schema: Schema, meta: {
+    mode: 'generate';
+    plugin: string;
+    entity: string;
+    aliases: string[];
+} | {
+    mode: 'run';
+    plugin: string;
+    entity: string;
+}): void;