nx 20.8.4 → 22.7.7

package/dist/src/adapter/compat.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allowedWorkspaceExtensions = exports.allowedProjectExtensions = void 0;
+const project_graph_1 = require("../project-graph/project-graph");
+const configuration_1 = require("../config/configuration");
+const angular_json_1 = require("./angular-json");
+const Module = require('module');
+const originalRequire = Module.prototype.require;
+let patched = false;
+// If we pass props on a project that angular doesn't know about,
+// it throws a warning that users see. We want to pass them still,
+// so older plugins writtin in Ng Devkit can update these.
+//
+// There are some props in here (root) that angular already knows about,
+// but it doesn't hurt to have them in here as well to help static analysis.
+exports.allowedProjectExtensions = [
+    'tags',
+    'implicitDependencies',
+    'configFilePath',
+    '$schema',
+    'generators',
+    'namedInputs',
+    'name',
+    'files',
+    'root',
+    'sourceRoot',
+    'projectType',
+    'release',
+    'includedScripts',
+    'metadata',
+    'owners',
+    'nxCloudImplicitDependencies',
+];
+// If we pass props on the workspace that angular doesn't know about,
+// it throws a warning that users see. We want to pass them still,
+// so older plugins writtin in Ng Devkit can update these.
+//
+// There are some props in here (root) that angular already knows about,
+// but it doesn't hurt to have them in here as well to help static analysis.
+exports.allowedWorkspaceExtensions = [
+    '$schema',
+    'implicitDependencies',
+    'affected',
+    'defaultBase',
+    'tasksRunnerOptions',
+    'workspaceLayout',
+    'plugins',
+    'targetDefaults',
+    'files',
+    'generators',
+    'namedInputs',
+    'extends',
+    'cli',
+    'pluginsConfig',
+    'defaultProject',
+    'installation',
+    'release',
+    'nxCloudAccessToken',
+    'nxCloudId',
+    'nxCloudUrl',
+    'nxCloudEncryptionKey',
+    'parallel',
+    'cacheDirectory',
+    'useDaemonProcess',
+    'useInferencePlugins',
+    'neverConnectToCloud',
+    'analytics',
+    'sync',
+    'useLegacyCache',
+    'maxCacheSize',
+    'tui',
+    'owners',
+];
+if (!patched) {
+    Module.prototype.require = function () {
+        const result = originalRequire.apply(this, arguments);
+        if (arguments[0].startsWith('@angular-devkit/core')) {
+            const ngCoreWorkspace = originalRequire.apply(this, [
+                `@angular-devkit/core/src/workspace/core`,
+            ]);
+            mockReadWorkspace(ngCoreWorkspace);
+            const readJsonUtils = originalRequire.apply(this, [
+                `@angular-devkit/core/src/workspace/json/reader`,
+            ]);
+            mockReadJsonWorkspace(readJsonUtils);
+        }
+        return result;
+    };
+    try {
+        require('@angular-devkit/build-angular/src/utils/version').Version.assertCompatibleAngularVersion =
+            () => { };
+    }
+    catch (e) { }
+    try {
+        require('@angular-devkit/build-angular/src/utils/version').assertCompatibleAngularVersion =
+            () => { };
+    }
+    catch (e) { }
+    try {
+        require('@angular/build/private').assertCompatibleAngularVersion = () => { };
+    }
+    catch (e) { }
+    patched = true;
+}
+function mockReadWorkspace(ngCoreWorkspace) {
+    mockMember(ngCoreWorkspace, 'readWorkspace', (originalReadWorkspace) => (path, ...rest) => {
+        path = 'angular.json';
+        return originalReadWorkspace.apply(this, [path, ...rest]);
+    });
+}
+/**
+ * Patch readJsonWorkspace to handle workspaces without a central workspace file.
+ * NOTE: We hide warnings that would be logged during this process.
+ */
+function mockReadJsonWorkspace(readJsonUtils) {
+    mockMember(readJsonUtils, 'readJsonWorkspace', (originalReadJsonWorkspace) => async (path, host, options) => {
+        const modifiedOptions = {
+            ...options,
+            allowedProjectExtensions: exports.allowedProjectExtensions,
+            allowedWorkspaceExtensions: exports.allowedWorkspaceExtensions,
+        };
+        try {
+            // Attempt angular CLI default behaviour
+            return await originalReadJsonWorkspace(path, host, modifiedOptions);
+        }
+        catch {
+            // This failed. Its most likely due to a lack of a workspace definition file,
+            // or other things that are different between NgCLI and Nx config files.
+            const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+            const nxJson = (0, configuration_1.readNxJson)();
+            // Construct old workspace.json format from project graph
+            const w = {
+                ...nxJson,
+                ...(0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph),
+            };
+            // Read our v1 workspace schema
+            const workspaceConfiguration = (0, angular_json_1.toOldFormat)(w);
+            // readJsonWorkspace actually has AST parsing + more, so we
+            // still need to call it rather than just return our file
+            return originalReadJsonWorkspace.apply(this, [
+                'angular.json', // path name, doesn't matter
+                {
+                    // second arg is a host, only method used is readFile
+                    readFile: () => JSON.stringify(workspaceConfiguration),
+                },
+                modifiedOptions,
+            ]);
+        }
+    });
+}
+function mockMember(obj, method, factory) {
+    obj[method] = factory(obj[method]);
+}

package/dist/src/adapter/ngcli-adapter.d.ts

@@ -0,0 +1,104 @@
+import { logging, Path, PathFragment, virtualFs } from '@angular-devkit/core';
+import { FileBuffer } from '@angular-devkit/core/src/virtual-fs/host/interface';
+import { Observable } from 'rxjs';
+import type { GenerateOptions } from '../command-line/generate/generate';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { Tree } from '../generators/tree';
+import type { ProjectGraph } from '../config/project-graph';
+import { ExecutorContext, GeneratorCallback } from '../config/misc-interfaces';
+export declare function createBuilderContext(builderInfo: {
+    builderName: string;
+    description: string;
+    optionSchema: any;
+}, context: ExecutorContext): Promise<import("@angular-devkit/architect").BuilderContext>;
+export declare function scheduleTarget(root: string, opts: {
+    project: string;
+    target: string;
+    configuration: string;
+    runOptions: any;
+    projects: Record<string, ProjectConfiguration>;
+}, verbose: boolean, projectGraph: ProjectGraph): Promise<Observable<import('@angular-devkit/architect').BuilderOutput>>;
+type AngularProjectConfiguration = ProjectConfiguration & {
+    prefix?: string;
+};
+export declare class NxScopedHost extends virtualFs.ScopedHost<any> {
+    private root;
+    protected _projectGraph?: ProjectGraph;
+    constructor(root: string, _projectGraph?: ProjectGraph);
+    read(path: Path): Observable<FileBuffer>;
+    protected readMergedWorkspaceConfiguration(): Observable<any>;
+    write(path: Path, content: FileBuffer): Observable<void>;
+    isFile(path: Path): Observable<boolean>;
+    exists(path: Path): Observable<boolean>;
+    mergeProjectConfiguration(existing: AngularProjectConfiguration, updated: AngularProjectConfiguration, projectName: string): AngularProjectConfiguration;
+    readExistingAngularJson(): Observable<any>;
+    protected readJson<T = any>(path: string): Observable<T>;
+}
+/**
+ * Host used by Angular CLI builders. It reads the project configurations from
+ * the project graph to access the expanded targets.
+ */
+export declare class NxScopedHostForBuilders extends NxScopedHost {
+    constructor(root: string, projectGraph: ProjectGraph);
+    protected readMergedWorkspaceConfiguration(): Observable<any>;
+}
+export declare function arrayBufferToString(buffer: any): string;
+/**
+ * Host used by Angular CLI schematics. It reads the project configurations from
+ * the project configuration files.
+ */
+export declare class NxScopeHostUsedForWrappedSchematics extends NxScopedHost {
+    private readonly host;
+    constructor(root: string, host: Tree, projectGraph: ProjectGraph);
+    read(path: Path): Observable<FileBuffer>;
+    exists(path: Path): Observable<boolean>;
+    isDirectory(path: Path): Observable<boolean>;
+    isFile(path: Path): Observable<boolean>;
+    list(path: Path): Observable<PathFragment[]>;
+}
+export declare function generate(root: string, opts: GenerateOptions, projects: Record<string, ProjectConfiguration>, verbose: boolean, projectGraph: ProjectGraph): Promise<number>;
+export declare function runMigration(root: string, packageName: string, migrationName: string, projects: Record<string, ProjectConfiguration>, isVerbose: boolean, projectGraph: ProjectGraph): Promise<{
+    loggingQueue: string[];
+    madeChanges: boolean;
+}>;
+/**
+ * If you have an Nx Devkit generator invoking the wrapped Angular Devkit schematic,
+ * and you don't want the Angular Devkit schematic to run, you can mock it up using this function.
+ *
+ * Unfortunately, there are some edge cases in the Nx-Angular devkit integration that
+ * can be seen in the unit tests context. This function is useful for handling that as well.
+ *
+ * In this case, you can mock it up.
+ *
+ * Example:
+ *
+ * ```typescript
+ *   mockSchematicsForTesting({
+ *     'mycollection:myschematic': (tree, params) => {
+ *        tree.write("README.md");
+ *     }
+ *   });
+ *
+ * ```
+ */
+export declare function mockSchematicsForTesting(schematics: {
+    [name: string]: (host: Tree, generatorOptions: {
+        [k: string]: any;
+    }) => Promise<void>;
+}): void;
+export declare function wrapAngularDevkitSchematic(collectionName: string, generatorName: string): (host: Tree, generatorOptions: {
+    [k: string]: any;
+}) => Promise<GeneratorCallback>;
+export declare const getLogger: (isVerbose?: boolean) => logging.Logger;
+/**
+ * Restores Nx tokens in options when possible by comparing new and previous
+ * options.
+ * The function preserves tokens in the following cases:
+ * 1. When the resolved previous value matches the new value exactly
+ * 2. When the previous value used {workspaceRoot}
+ * 3. When the previous value used {projectRoot} and the new value starts with
+ *    the project root path
+ * Those are the only safe cases, for all other cases, the new value is used as-is.
+ */
+export declare function restoreNxTokensInOptions<T extends Object | Array<unknown>>(newOptions: T, previousOptions: T, project: ProjectConfiguration): T;
+export {};