@ohos-ports/nx 17.3.2-beta.0

package/src/adapter/compat.js

@@ -0,0 +1,136 @@
+"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");
+/* eslint-disable */
+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',
+];
+// 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 = [
+    'implicitDependencies',
+    'affected',
+    'tasksRunnerOptions',
+    'workspaceLayout',
+    'plugins',
+    'targetDefaults',
+    'files',
+    'generators',
+    'namedInputs',
+    'extends',
+    'cli',
+    'pluginsConfig',
+    'defaultProject',
+    'installation',
+    'release',
+    'nxCloudAccessToken',
+    'nxCloudUrl',
+    'nxCloudEncryptionKey',
+    'parallel',
+    'cacheDirectory',
+    'useDaemonProcess',
+];
+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) { }
+    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/src/adapter/decorate-cli.d.ts

@@ -0,0 +1 @@
+export declare function decorateCli(): void;

package/src/adapter/decorate-cli.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decorateCli = void 0;
+const fs_1 = require("fs");
+const output_1 = require("../utils/output");
+function decorateCli() {
+    output_1.output.warn({
+        title: `Decoration of the Angular CLI is deprecated and will be removed in a future version`,
+        bodyLines: [
+            `Please replace usage of "ng <command>" in any scripts, particularly for CI, with "nx <command>"`,
+        ],
+    });
+    const path = 'node_modules/@angular/cli/lib/cli/index.js';
+    const angularCLIInit = (0, fs_1.readFileSync)(path, 'utf-8');
+    const start = angularCLIInit.indexOf(`(options) {`) + 11;
+    const newContent = `${angularCLIInit.slice(0, start)}
+  if (!process.env['NX_CLI_SET']) {
+    require('nx/bin/nx');
+    return new Promise(function(res, rej) {});
+  }
+  ${angularCLIInit.substring(start)}
+`;
+    (0, fs_1.writeFileSync)(path, newContent);
+}
+exports.decorateCli = decorateCli;

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

@@ -0,0 +1,90 @@
+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 { ExecutorContext } 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): Promise<Observable<import('@angular-devkit/architect').BuilderOutput>>;
+type AngularProjectConfiguration = ProjectConfiguration & {
+    prefix?: string;
+};
+export declare class NxScopedHost extends virtualFs.ScopedHost<any> {
+    private root;
+    constructor(root: string);
+    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 {
+    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);
+    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): Promise<number>;
+export declare function runMigration(root: string, packageName: string, migrationName: string, projects: Record<string, ProjectConfiguration>, isVerbose: boolean): 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<any>;
+export declare const getLogger: (isVerbose?: boolean) => logging.Logger;
+export {};