@ohos-ports/nx 17.3.2-beta.0

package/src/config/calculate-default-project-name.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findMatchingProjectInCwd = exports.calculateDefaultProjectName = void 0;
+const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
+const path_1 = require("path");
+function calculateDefaultProjectName(cwd, root, { projects }, nxJson) {
+    const relativeCwd = (0, path_1.relative)(root, cwd).replace(/\\/g, '/') ?? null;
+    if (relativeCwd !== null) {
+        const matchingProject = findMatchingProjectInCwd(projects, relativeCwd);
+        // We have found a project
+        if (matchingProject) {
+            // That is not at the root
+            if (projects[matchingProject].root !== '.' &&
+                projects[matchingProject].root !== '') {
+                return matchingProject;
+                // But its at the root, and NX_DEFAULT_PROJECT is set
+            }
+            else if (process.env.NX_DEFAULT_PROJECT) {
+                return process.env.NX_DEFAULT_PROJECT;
+                // Its root, and NX_DEFAULT_PROJECT is not set
+            }
+            else {
+                return matchingProject;
+            }
+        }
+    }
+    // There was no matching project in cwd.
+    return (process.env.NX_DEFAULT_PROJECT ??
+        nxJson.cli?.defaultProjectName ??
+        nxJson?.defaultProject);
+}
+exports.calculateDefaultProjectName = calculateDefaultProjectName;
+function findMatchingProjectInCwd(projects, relativeCwd) {
+    const projectRootMappings = new Map();
+    for (const projectName of Object.keys(projects)) {
+        const { root } = projects[projectName];
+        projectRootMappings.set((0, find_project_for_path_1.normalizeProjectRoot)(root), projectName);
+    }
+    const matchingProject = (0, find_project_for_path_1.findProjectForPath)(relativeCwd, projectRootMappings);
+    return matchingProject;
+}
+exports.findMatchingProjectInCwd = findMatchingProjectInCwd;

package/src/config/configuration.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns information about where apps and libs will be created.
+ */
+export declare function workspaceLayout(): {
+    appsDir: string;
+    libsDir: string;
+};
+export { readNxJson } from './nx-json';

package/src/config/configuration.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNxJson = exports.workspaceLayout = void 0;
+const nx_json_1 = require("./nx-json");
+/**
+ * Returns information about where apps and libs will be created.
+ */
+function workspaceLayout() {
+    const nxJson = (0, nx_json_1.readNxJson)();
+    return {
+        appsDir: nxJson.workspaceLayout?.appsDir ?? 'apps',
+        libsDir: nxJson.workspaceLayout?.libsDir ?? 'libs',
+    };
+}
+exports.workspaceLayout = workspaceLayout;
+var nx_json_2 = require("./nx-json");
+Object.defineProperty(exports, "readNxJson", { enumerable: true, get: function () { return nx_json_2.readNxJson; } });

package/src/config/misc-interfaces.d.ts

@@ -0,0 +1,199 @@
+import { Hash, TaskHasher } from '../hasher/task-hasher';
+import { ProjectGraph } from './project-graph';
+import { Task, TaskGraph } from './task-graph';
+import { TargetConfiguration, ProjectsConfigurations } from './workspace-json-project-json';
+import type { NxJsonConfiguration } from './nx-json';
+import { Schema } from '../utils/params';
+/**
+ * A callback function that is executed after changes are made to the file system
+ */
+export type GeneratorCallback = () => void | Promise<void>;
+/**
+ * A function that schedules updates to the filesystem to be done atomically
+ */
+export type Generator<T = unknown> = (tree: any, schema: T) => void | GeneratorCallback | Promise<void | GeneratorCallback>;
+export interface GeneratorsJsonEntry {
+    hidden?: boolean;
+    schema: string;
+    implementation?: string;
+    factory?: string;
+    description?: string;
+    aliases?: string[];
+    cli?: 'nx';
+    'x-type'?: 'library' | 'application';
+    'x-deprecated'?: string;
+    'x-use-standalone-layout'?: boolean;
+}
+export type OutputCaptureMethod = 'direct-nodejs' | 'pipe';
+export interface ExecutorsJsonEntry {
+    schema: string;
+    implementation: string;
+    batchImplementation?: string;
+    description?: string;
+    hasher?: string;
+}
+export type Dependencies = 'dependencies' | 'devDependencies';
+export interface PackageJsonUpdateForPackage {
+    version: string;
+    ifPackageInstalled?: string;
+    alwaysAddToPackageJson?: boolean | Dependencies;
+    addToPackageJson?: boolean | Dependencies;
+}
+export type PackageJsonUpdates = {
+    [name: string]: {
+        version: string;
+        packages: {
+            [packageName: string]: PackageJsonUpdateForPackage;
+        };
+        'x-prompt'?: string;
+        requires?: Record<string, string>;
+    };
+};
+export interface MigrationsJsonEntry {
+    version: string;
+    description?: string;
+    cli?: string;
+    implementation?: string;
+    factory?: string;
+    requires?: Record<string, string>;
+}
+export interface MigrationsJson {
+    name?: string;
+    version?: string;
+    collection?: string;
+    generators?: {
+        [name: string]: MigrationsJsonEntry;
+    };
+    schematics?: {
+        [name: string]: MigrationsJsonEntry;
+    };
+    packageJsonUpdates?: PackageJsonUpdates;
+}
+export interface GeneratorsJson {
+    extends?: string;
+    schematics?: Record<string, GeneratorsJsonEntry>;
+    generators?: Record<string, GeneratorsJsonEntry>;
+}
+export interface ExecutorsJson {
+    executors?: Record<string, ExecutorsJsonEntry>;
+    builders?: Record<string, ExecutorsJsonEntry>;
+}
+export interface ExecutorConfig {
+    schema: {
+        version?: number;
+        outputCapture?: OutputCaptureMethod;
+    } & Schema;
+    hasherFactory?: () => CustomHasher;
+    implementationFactory: () => Executor;
+    batchImplementationFactory?: () => TaskGraphExecutor;
+}
+/**
+ * Implementation of a target of a project
+ */
+export type Executor<T = any> = (
+/**
+ * Options that users configure or pass via the command line
+ */
+options: T, context: ExecutorContext) => Promise<{
+    success: boolean;
+}> | AsyncIterableIterator<{
+    success: boolean;
+}>;
+export interface HasherContext {
+    hasher: TaskHasher;
+    projectGraph: ProjectGraph;
+    taskGraph: TaskGraph;
+    projectsConfigurations: ProjectsConfigurations;
+    nxJsonConfiguration: NxJsonConfiguration;
+}
+export type CustomHasher = (task: Task, context: HasherContext) => Promise<Hash>;
+export type TaskResult = {
+    success: boolean;
+    terminalOutput: string;
+    startTime?: number;
+    endTime?: number;
+};
+export type BatchExecutorResult = Record<string, TaskResult>;
+export type BatchExecutorTaskResult = {
+    task: string;
+    result: TaskResult;
+};
+/**
+ * Implementation of a target of a project that handles multiple projects to be batched
+ */
+export type TaskGraphExecutor<T = any> = (
+/**
+ * Graph of Tasks to be executed
+ */
+taskGraph: TaskGraph, 
+/**
+ * Map of Task IDs to options for the task
+ */
+options: Record<string, T>, 
+/**
+ * Set of overrides for the overall execution
+ */
+overrides: T, context: ExecutorContext) => Promise<BatchExecutorResult | AsyncIterableIterator<BatchExecutorTaskResult>>;
+/**
+ * Context that is passed into an executor
+ */
+export interface ExecutorContext {
+    /**
+     * The root of the workspace
+     */
+    root: string;
+    /**
+     * The name of the project being executed on
+     */
+    projectName?: string;
+    /**
+     * The name of the target being executed
+     */
+    targetName?: string;
+    /**
+     * The name of the configuration being executed
+     */
+    configurationName?: string;
+    /**
+     * The configuration of the target being executed
+     */
+    target?: TargetConfiguration;
+    /**
+     * Projects config
+     *
+     * @todo(vsavkin): mark this as required for v17
+     */
+    projectsConfigurations?: ProjectsConfigurations;
+    /**
+     * The contents of nx.json.
+     *
+     * @todo(vsavkin): mark this as required for v17
+     */
+    nxJsonConfiguration?: NxJsonConfiguration;
+    /**
+     * The current working directory
+     */
+    cwd: string;
+    /**
+     * Enable verbose logging
+     */
+    isVerbose: boolean;
+    /**
+     * A snapshot of the project graph as
+     * it existed when the Nx command was kicked off
+     *
+     * @todo(vsavkin) mark this required for v17
+     */
+    projectGraph?: ProjectGraph;
+    /**
+     * A snapshot of the task graph as
+     * it existed when the Nx command was kicked off
+     */
+    taskGraph?: TaskGraph;
+    /**
+     * Deprecated. Use projectsConfigurations or nxJsonConfiguration
+     * The full workspace configuration
+     * @todo(vsavkin): remove after v17
+     */
+    workspace?: ProjectsConfigurations & NxJsonConfiguration;
+}

package/src/config/misc-interfaces.js

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

package/src/config/nx-json.d.ts

@@ -0,0 +1,372 @@
+import type { ChangelogRenderOptions } from '../../release/changelog-renderer';
+import { PackageManager } from '../utils/package-manager';
+import { InputDefinition, TargetConfiguration, TargetDependencyConfig } from './workspace-json-project-json';
+export 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;
+}
+export type TargetDefaults = Record<string, Partial<TargetConfiguration>>;
+export type TargetDependencies = Record<string, (TargetDependencyConfig | string)[]>;
+export interface NrwlJsPluginConfig {
+    analyzeSourceFiles?: boolean;
+    analyzePackageJson?: boolean;
+    analyzeLockfile?: boolean;
+}
+interface NxInstallationConfiguration {
+    /**
+     * Version used for Nx
+     */
+    version: string;
+    /**
+     * Record<pluginPackageName, pluginVersion>. e.g.
+     * plugins: { '@nx/angular': '1.0.0' }
+     */
+    plugins?: Record<string, string>;
+}
+/**
+ * **ALPHA**
+ */
+export interface NxReleaseVersionConfiguration {
+    generator?: string;
+    generatorOptions?: Record<string, unknown>;
+    /**
+     * Enabling support for parsing semver bumps via conventional commits and reading the current version from
+     * git tags is so common that we have a first class shorthand for it, which is false by default.
+     *
+     * Setting this to true is the same as adding the following to version.generatorOptions:
+     * - currentVersionResolver: "git-tag"
+     * - specifierSource: "conventional-commits"
+     *
+     * If the user attempts to mix and match these options with the shorthand, we will provide a helpful error.
+     */
+    conventionalCommits?: boolean;
+}
+/**
+ * **ALPHA**
+ */
+export interface NxReleaseChangelogConfiguration {
+    /**
+     * Optionally create a release containing all relevant changes on a supported version control system, it
+     * is false by default.
+     *
+     * NOTE: if createRelease is set on a group of projects, it will cause the default releaseTagPattern of
+     * "{projectName}@{version}" to be used for those projects, even when versioning everything together.
+     */
+    createRelease?: 'github' | false;
+    /**
+     * This can either be set to a string value that will be written to the changelog file(s)
+     * at the workspace root and/or within project directories, or set to `false` to specify
+     * that no changelog entry should be made when there are no code changes.
+     *
+     * NOTE: The string value has a sensible default value and supports interpolation of
+     * {projectName} when generating for project level changelogs.
+     *
+     * E.g. for a project level changelog you could customize the message to something like:
+     * "entryWhenNoChanges": "There were no code changes for {projectName}"
+     */
+    entryWhenNoChanges?: string | false;
+    /**
+     * This is either a workspace path where the changelog markdown file will be created and read from,
+     * or set to false to disable file creation altogether (e.g. if only using Github releases).
+     *
+     * Interpolation of {projectName}, {projectRoot} and {workspaceRoot} is supported.
+     *
+     * The defaults are:
+     * - "{workspaceRoot}/CHANGELOG.md" at the workspace level
+     * - "{projectRoot}/CHANGELOG.md" at the project level
+     */
+    file?: string | false;
+    /**
+     * A path to a valid changelog renderer function used to transform commit messages and other metadata into
+     * the final changelog (usually in markdown format). Its output can be modified using the optional `renderOptions`.
+     *
+     * By default, the renderer is set to "nx/release/changelog-renderer" which nx provides out of the box.
+     */
+    renderer?: string;
+    renderOptions?: ChangelogRenderOptions;
+}
+/**
+ * **ALPHA**
+ */
+export interface NxReleaseGitConfiguration {
+    /**
+     * Whether or not to automatically commit the changes made by current command
+     */
+    commit?: boolean;
+    /**
+     * Custom git commit message to use when committing the changes made by this command {version} will be dynamically interpolated when performing fixed releases, interpolated tags will be appended to the commit body when performing independent releases.
+     */
+    commitMessage?: string;
+    /**
+     * Additional arguments (added after the --message argument, which may or may not be customized with --git-commit-message) to pass to the `git commit` command invoked behind the scenes
+     */
+    commitArgs?: string;
+    /**
+     * Whether or not to stage the changes made by this command. Always treated as true if commit is true.
+     */
+    stageChanges?: boolean;
+    /**
+     * Whether or not to automatically tag the changes made by this command
+     */
+    tag?: boolean;
+    /**
+     * Custom git tag message to use when tagging the changes made by this command. This defaults to be the same value as the tag itself.
+     */
+    tagMessage?: string;
+    /**
+     * Additional arguments to pass to the `git tag` command invoked behind the scenes
+     */
+    tagArgs?: string;
+}
+/**
+ * **ALPHA**
+ */
+interface NxReleaseConfiguration {
+    /**
+     * Shorthand for amending the projects which will be included in the implicit default release group (all projects by default).
+     * @note Only one of `projects` or `groups` can be specified, the cannot be used together.
+     */
+    projects?: string[] | string;
+    /**
+     * @note When no projects or groups are configured at all (the default), all projects in the workspace are treated as
+     * if they were in a release group together with a fixed relationship.
+     */
+    groups?: Record<string, // group name
+    {
+        /**
+         * Whether to version and release projects within the group independently, or together in lock step ("fixed").
+         * If not set on the group, this will be informed by the projectsRelationship config at the top level.
+         */
+        projectsRelationship?: 'fixed' | 'independent';
+        /**
+         * Required list of one or more projects to include in the release group. Any single project can
+         * only be used in a maximum of one release group.
+         */
+        projects: string[] | string;
+        /**
+         * Optionally override version configuration for this group.
+         *
+         * NOTE: git configuration is not supported at the group level, only the root/command level
+         */
+        version?: NxReleaseVersionConfiguration;
+        /**
+         * Project changelogs are disabled by default.
+         *
+         * Here you can optionally override project changelog configuration for this group.
+         * Notes about boolean values:
+         *
+         * - true = enable project level changelogs using default configuration
+         * - false = explicitly disable project level changelogs
+         *
+         * NOTE: git configuration is not supported at the group level, only the root/command level
+         */
+        changelog?: NxReleaseChangelogConfiguration | boolean;
+        /**
+         * Optionally override the git/release tag pattern to use for this group.
+         */
+        releaseTagPattern?: string;
+    }>;
+    /**
+     * Configures the default value for all groups that don't explicitly state their own projectsRelationship.
+     *
+     * By default, this is set to "fixed" which means all projects in the workspace will be versioned and
+     * released together in lock step.
+     */
+    projectsRelationship?: 'fixed' | 'independent';
+    changelog?: {
+        /**
+         * Enable or override configuration for git operations as part of the changelog subcommand
+         */
+        git?: NxReleaseGitConfiguration;
+        /**
+         * Workspace changelog is enabled by default. Notes about boolean values:
+         *
+         * - true = explicitly enable workspace changelog using default configuration
+         * - false = disable workspace changelog
+         */
+        workspaceChangelog?: NxReleaseChangelogConfiguration | boolean;
+        /**
+         * Project changelogs are disabled by default. Notes about boolean values:
+         *
+         * - true = enable project level changelogs using default configuration
+         * - false = explicitly disable project level changelogs
+         */
+        projectChangelogs?: NxReleaseChangelogConfiguration | boolean;
+        /**
+         * Whether or not to automatically look up the first commit for the workspace (or package, if versioning independently)
+         * and use that as the starting point for changelog generation. If this is not enabled, changelog generation will fail
+         * if there is no previous matching git tag to use as a starting point.
+         */
+        automaticFromRef?: boolean;
+    };
+    /**
+     * If no version config is provided, we will assume that @nx/js:release-version
+     * is the desired generator implementation, allowing for terser config for the common case.
+     */
+    version?: NxReleaseVersionConfiguration & {
+        /**
+         * Enable or override configuration for git operations as part of the version subcommand
+         */
+        git?: NxReleaseGitConfiguration;
+    };
+    /**
+     * Optionally override the git/release tag pattern to use. This field is the source of truth
+     * for changelog generation and release tagging, as well as for conventional commits parsing.
+     *
+     * It supports interpolating the version as {version} and (if releasing independently or forcing
+     * project level version control system releases) the project name as {projectName} within the string.
+     *
+     * The default releaseTagPattern for fixed/unified releases is: "v{version}"
+     * The default releaseTagPattern for independent releases at the project level is: "{projectName}@{version}"
+     */
+    releaseTagPattern?: string;
+    /**
+     * Enable and configure automatic git operations as part of the release
+     */
+    git?: NxReleaseGitConfiguration;
+}
+/**
+ * Nx.json configuration
+ *
+ * @note: when adding properties here add them to `allowedWorkspaceExtensions` in adapter/compat.ts
+ */
+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
+     * @deprecated use {@link namedInputs} instead. For more information see https://nx.dev/deprecated/global-implicit-dependencies#global-implicit-dependencies
+     */
+    implicitDependencies?: ImplicitDependencyEntry<T>;
+    /**
+     * Named inputs targets can refer to reduce duplication
+     */
+    namedInputs?: {
+        [inputName: string]: (string | InputDefinition)[];
+    };
+    /**
+     * Dependencies between different target names across all projects
+     */
+    targetDefaults?: TargetDefaults;
+    /**
+     * 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:
+     *
+     * ```
+     * {
+     *   "@nx/react": {
+     *     "library": {
+     *       "style": "scss"
+     *     }
+     *   }
+     * }
+     * ```
+     */
+    generators?: {
+        [collectionName: string]: {
+            [generatorName: string]: any;
+        };
+    };
+    /**
+     * Default generator collection. It is used when no collection is provided.
+     */
+    cli?: {
+        packageManager?: PackageManager;
+        defaultProjectName?: string;
+    };
+    /**
+     * Plugins for extending the project graph
+     */
+    plugins?: PluginConfiguration[];
+    /**
+     * Configuration for Nx Plugins
+     */
+    pluginsConfig?: Record<string, 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;
+    /**
+     * Configures the Nx installation for a repo. Useful for maintaining  a separate
+     * set of dependencies for Nx + Plugins compared to the base package.json, but also
+     * useful for workspaces that don't have a root package.json + node_modules.
+     */
+    installation?: NxInstallationConfiguration;
+    /**
+     * **ALPHA**: Configuration for `nx release` (versioning and publishing of applications and libraries)
+     */
+    release?: NxReleaseConfiguration;
+    /**
+     * If specified Nx will use nx-cloud by default with the given token.
+     * To use a different runner that accepts an access token, define it in {@link tasksRunnerOptions}
+     */
+    nxCloudAccessToken?: string;
+    /**
+     * Specifies the url pointing to an instance of nx cloud. Used for remote
+     * caching and displaying run links.
+     */
+    nxCloudUrl?: string;
+    /**
+     * Specifies the encryption key used to encrypt artifacts data before sending it to nx cloud.
+     */
+    nxCloudEncryptionKey?: string;
+    /**
+     * Specifies how many tasks can be run in parallel.
+     */
+    parallel?: number;
+    /**
+     * Changes the directory used by Nx to store its cache.
+     */
+    cacheDirectory?: string;
+    /**
+     * Set this to false to disable the daemon.
+     */
+    useDaemonProcess?: boolean;
+}
+export type PluginConfiguration = string | {
+    plugin: string;
+    options?: unknown;
+};
+export declare function readNxJson(root?: string): NxJsonConfiguration;
+export declare function hasNxJson(root: string): boolean;
+export {};

package/src/config/nx-json.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasNxJson = exports.readNxJson = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const fileutils_1 = require("../utils/fileutils");
+const workspace_root_1 = require("../utils/workspace-root");
+function readNxJson(root = workspace_root_1.workspaceRoot) {
+    const nxJson = (0, path_1.join)(root, 'nx.json');
+    if ((0, fs_1.existsSync)(nxJson)) {
+        const nxJsonConfiguration = (0, fileutils_1.readJsonFile)(nxJson);
+        if (nxJsonConfiguration.extends) {
+            const extendedNxJsonPath = require.resolve(nxJsonConfiguration.extends, {
+                paths: [(0, path_1.dirname)(nxJson)],
+            });
+            const baseNxJson = (0, fileutils_1.readJsonFile)(extendedNxJsonPath);
+            return {
+                ...baseNxJson,
+                ...nxJsonConfiguration,
+            };
+        }
+        else {
+            return nxJsonConfiguration;
+        }
+    }
+    else {
+        try {
+            return (0, fileutils_1.readJsonFile)((0, path_1.join)(__dirname, '..', '..', 'presets', 'core.json'));
+        }
+        catch (e) {
+            return {};
+        }
+    }
+}
+exports.readNxJson = readNxJson;
+function hasNxJson(root) {
+    const nxJson = (0, path_1.join)(root, 'nx.json');
+    return (0, fs_1.existsSync)(nxJson);
+}
+exports.hasNxJson = hasNxJson;