@ohos-ports/nx 19.8.4-beta.0

package/src/executors/run-script/run-script.impl.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const path = require("path");
+const package_manager_1 = require("../../utils/package-manager");
+const child_process_1 = require("child_process");
+const pseudo_terminal_1 = require("../../tasks-runner/pseudo-terminal");
+async function default_1(options, context) {
+    const pm = (0, package_manager_1.getPackageManagerCommand)();
+    try {
+        let command = pm.run(options.script, options.__unparsed__.join(' '));
+        let cwd = path.join(context.root, context.projectsConfigurations.projects[context.projectName].root);
+        let env = process.env;
+        // when running nx through npx with node_modules installed with npm, the path gets modified to include the full workspace path with the node_modules folder
+        // This causes issues when running in a pty process, so we filter out the node_modules paths from the PATH
+        // Since the command here will be run with the package manager script command, the path will be modified again within the PTY process itself.
+        let filteredPath = env.PATH?.split(path.delimiter)
+            .filter((p) => !p.startsWith(path.join(context.root, 'node_modules')))
+            .join(path.delimiter) ?? '';
+        env.PATH = filteredPath;
+        if (pseudo_terminal_1.PseudoTerminal.isSupported()) {
+            await ptyProcess(command, cwd, env);
+        }
+        else {
+            nodeProcess(command, cwd, env);
+        }
+        return { success: true };
+    }
+    catch (e) {
+        return { success: false };
+    }
+}
+function nodeProcess(command, cwd, env) {
+    (0, child_process_1.execSync)(command, {
+        stdio: ['inherit', 'inherit', 'inherit'],
+        cwd,
+        env,
+        windowsHide: true,
+    });
+}
+async function ptyProcess(command, cwd, env) {
+    const terminal = (0, pseudo_terminal_1.getPseudoTerminal)();
+    return new Promise((res, rej) => {
+        const cp = terminal.runCommand(command, { cwd, jsEnv: env });
+        cp.onExit((code) => {
+            if (code === 0) {
+                res();
+            }
+            else if (code >= 128) {
+                process.exit(code);
+            }
+            else {
+                rej();
+            }
+        });
+    });
+}

package/src/executors/run-script/schema.json

@@ -0,0 +1,28 @@
+{
+  "version": 2,
+  "title": "Run Script",
+  "description": "Run any NPM script of a project in the project's root directory.",
+  "type": "object",
+  "cli": "nx",
+  "outputCapture": "pipe",
+  "properties": {
+    "script": {
+      "type": "string",
+      "description": "An npm script name in the `package.json` file of the project (e.g., `build`)."
+    },
+    "__unparsed__": {
+      "hidden": true,
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "$default": {
+        "$source": "unparsed"
+      },
+      "x-priority": "internal"
+    }
+  },
+  "additionalProperties": true,
+  "required": ["script"],
+  "examplesFile": "../../../docs/run-script-examples.md"
+}

package/src/executors/utils/convert-nx-executor.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This is a copy of the @nx/devkit utility but this should not be used outside of the nx package
+ */
+import { Executor } from '../../config/misc-interfaces';
+/**
+ * Convert an Nx Executor into an Angular Devkit Builder
+ *
+ * Use this to expose a compatible Angular Builder
+ */
+export declare function convertNxExecutor(executor: Executor): any;

package/src/executors/utils/convert-nx-executor.js

@@ -0,0 +1,85 @@
+"use strict";
+/**
+ * This is a copy of the @nx/devkit utility but this should not be used outside of the nx package
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertNxExecutor = convertNxExecutor;
+const nx_json_1 = require("../../config/nx-json");
+const retrieve_workspace_files_1 = require("../../project-graph/utils/retrieve-workspace-files");
+const project_configuration_utils_1 = require("../../project-graph/utils/project-configuration-utils");
+const internal_api_1 = require("../../project-graph/plugins/internal-api");
+/**
+ * Convert an Nx Executor into an Angular Devkit Builder
+ *
+ * Use this to expose a compatible Angular Builder
+ */
+function convertNxExecutor(executor) {
+    const builderFunction = (options, builderContext) => {
+        const promise = async () => {
+            const nxJsonConfiguration = (0, nx_json_1.readNxJson)(builderContext.workspaceRoot);
+            const [plugins, cleanup] = await (0, internal_api_1.loadNxPlugins)(nxJsonConfiguration.plugins, builderContext.workspaceRoot);
+            const projectsConfigurations = {
+                version: 2,
+                projects: (0, project_configuration_utils_1.readProjectConfigurationsFromRootMap)((await (0, retrieve_workspace_files_1.retrieveProjectConfigurations)(plugins, builderContext.workspaceRoot, nxJsonConfiguration)).projects),
+            };
+            cleanup();
+            const context = {
+                root: builderContext.workspaceRoot,
+                projectName: builderContext.target.project,
+                targetName: builderContext.target.target,
+                target: builderContext.target.target,
+                configurationName: builderContext.target.configuration,
+                workspace: { ...nxJsonConfiguration, ...projectsConfigurations },
+                projectsConfigurations,
+                nxJsonConfiguration,
+                cwd: process.cwd(),
+                projectGraph: null,
+                taskGraph: null,
+                isVerbose: false,
+            };
+            return executor(options, context);
+        };
+        return toObservable(promise());
+    };
+    return require('@angular-devkit/architect').createBuilder(builderFunction);
+}
+function toObservable(promiseOrAsyncIterator) {
+    return new (require('rxjs').Observable)((subscriber) => {
+        promiseOrAsyncIterator
+            .then((value) => {
+            if (!value.next) {
+                subscriber.next(value);
+                subscriber.complete();
+            }
+            else {
+                let asyncIterator = value;
+                function recurse(iterator) {
+                    iterator
+                        .next()
+                        .then((result) => {
+                        if (!result.done) {
+                            subscriber.next(result.value);
+                            recurse(iterator);
+                        }
+                        else {
+                            if (result.value) {
+                                subscriber.next(result.value);
+                            }
+                            subscriber.complete();
+                        }
+                    })
+                        .catch((e) => {
+                        subscriber.error(e);
+                    });
+                }
+                recurse(asyncIterator);
+                return () => {
+                    asyncIterator.return();
+                };
+            }
+        })
+            .catch((err) => {
+            subscriber.error(err);
+        });
+    });
+}

package/src/generators/internal-utils/format-changed-files-with-prettier-if-available.d.ts

@@ -0,0 +1,14 @@
+import type { Tree } from '../tree';
+/**
+ * Formats all the created or updated files using Prettier
+ * @param tree - the file system tree
+ */
+export declare function formatChangedFilesWithPrettierIfAvailable(tree: Tree, options?: {
+    silent?: boolean;
+}): Promise<void>;
+export declare function formatFilesWithPrettierIfAvailable(files: {
+    path: string;
+    content: string | Buffer;
+}[], root: string, options?: {
+    silent?: boolean;
+}): Promise<Map<string, string>>;

package/src/generators/internal-utils/format-changed-files-with-prettier-if-available.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatChangedFilesWithPrettierIfAvailable = formatChangedFilesWithPrettierIfAvailable;
+exports.formatFilesWithPrettierIfAvailable = formatFilesWithPrettierIfAvailable;
+const path = require("path");
+/**
+ * Formats all the created or updated files using Prettier
+ * @param tree - the file system tree
+ */
+async function formatChangedFilesWithPrettierIfAvailable(tree, options) {
+    const files = new Set(tree.listChanges().filter((file) => file.type !== 'DELETE'));
+    const results = await formatFilesWithPrettierIfAvailable(Array.from(files), tree.root, options);
+    for (const [path, content] of results) {
+        tree.write(path, content);
+    }
+}
+async function formatFilesWithPrettierIfAvailable(files, root, options) {
+    const results = new Map();
+    let prettier;
+    try {
+        prettier = await Promise.resolve().then(() => require('prettier'));
+    }
+    catch { }
+    if (!prettier) {
+        return results;
+    }
+    await Promise.all(Array.from(files).map(async (file) => {
+        try {
+            const systemPath = path.join(root, file.path);
+            let options = {
+                filepath: systemPath,
+            };
+            const resolvedOptions = await prettier.resolveConfig(systemPath, {
+                editorconfig: true,
+            });
+            if (!resolvedOptions) {
+                return;
+            }
+            options = {
+                ...options,
+                ...resolvedOptions,
+            };
+            const support = await prettier.getFileInfo(systemPath, options);
+            if (support.ignored || !support.inferredParser) {
+                return;
+            }
+            results.set(file.path, 
+            // In prettier v3 the format result is a promise
+            await prettier.format(file.content.toString('utf-8'), options));
+        }
+        catch (e) {
+            if (!options?.silent) {
+                console.warn(`Could not format ${file.path}. Error: "${e.message}"`);
+            }
+        }
+    }));
+    return results;
+}

package/src/generators/testing-utils/create-tree-with-empty-workspace.d.ts

@@ -0,0 +1,11 @@
+import type { Tree } from '../tree';
+/**
+ * Creates a host for testing.
+ */
+export declare function createTreeWithEmptyWorkspace(opts?: {
+    layout?: "apps-libs";
+}): Tree;
+/**
+ * @deprecated use createTreeWithEmptyWorkspace instead
+ */
+export declare function createTreeWithEmptyV1Workspace(): Tree;

package/src/generators/testing-utils/create-tree-with-empty-workspace.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTreeWithEmptyWorkspace = createTreeWithEmptyWorkspace;
+exports.createTreeWithEmptyV1Workspace = createTreeWithEmptyV1Workspace;
+const tree_1 = require("../tree");
+const workspace_root_1 = require("../../utils/workspace-root");
+/**
+ * Creates a host for testing.
+ */
+function createTreeWithEmptyWorkspace(opts = {}) {
+    const tree = new tree_1.FsTree('/virtual', false);
+    // Our unit tests are all written as though they are at the root of a workspace
+    // However, when they are run in a subdirectory of the workspaceRoot,
+    // the relative path between workspaceRoot and the directory the tests are run
+    // is prepended to the paths created in the virtual tree.
+    // Setting this envVar to workspaceRoot prevents this behaviour
+    process.env.INIT_CWD = workspace_root_1.workspaceRoot;
+    return addCommonFiles(tree, opts.layout === 'apps-libs');
+}
+/**
+ * @deprecated use createTreeWithEmptyWorkspace instead
+ */
+function createTreeWithEmptyV1Workspace() {
+    throw new Error('Use createTreeWithEmptyWorkspace instead of createTreeWithEmptyV1Workspace');
+}
+function addCommonFiles(tree, addAppsAndLibsFolders) {
+    tree.write('./.prettierrc', JSON.stringify({ singleQuote: true }));
+    tree.write('/package.json', JSON.stringify({
+        name: '@proj/source',
+        dependencies: {},
+        devDependencies: {},
+    }));
+    tree.write('/nx.json', JSON.stringify({
+        affected: {
+            defaultBase: 'main',
+        },
+        targetDefaults: {
+            build: {
+                cache: true,
+            },
+            lint: {
+                cache: true,
+            },
+        },
+    }));
+    tree.write('/tsconfig.base.json', JSON.stringify({ compilerOptions: { paths: {} } }));
+    if (addAppsAndLibsFolders) {
+        tree.write('/apps/.gitignore', '');
+        tree.write('/libs/.gitignore', '');
+    }
+    return tree;
+}

package/src/generators/testing-utils/create-tree.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from '../tree';
+/**
+ * Creates a host for testing.
+ */
+export declare function createTree(): Tree;

package/src/generators/testing-utils/create-tree.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTree = createTree;
+const tree_1 = require("../tree");
+/**
+ * Creates a host for testing.
+ */
+function createTree() {
+    return new tree_1.FsTree('/virtual', false);
+}

package/src/generators/tree.d.ts

@@ -0,0 +1,125 @@
+import type { Mode } from 'node:fs';
+/**
+ * Options to set when writing a file in the Virtual file system tree.
+ */
+export interface TreeWriteOptions {
+    /**
+     * Permission to be granted on the file, given as a string (e.g `755`) or octal integer (e.g `0o755`).
+     * The logical OR operator can be used to separate multiple permissions.
+     * See https://nodejs.org/api/fs.html#fs_file_modes
+     */
+    mode?: Mode;
+}
+/**
+ * Virtual file system tree.
+ */
+export interface Tree {
+    /**
+     * Root of the workspace. All paths are relative to this.
+     */
+    root: string;
+    /**
+     * Read the contents of a file.
+     * @param filePath A path to a file.
+     */
+    read(filePath: string): Buffer | null;
+    /**
+     * Read the contents of a file as string.
+     * @param filePath A path to a file.
+     * @param encoding the encoding for the result
+     */
+    read(filePath: string, encoding: BufferEncoding): string | null;
+    /**
+     * Update the contents of a file or create a new file.
+     */
+    write(filePath: string, content: Buffer | string, options?: TreeWriteOptions): void;
+    /**
+     * Check if a file exists.
+     */
+    exists(filePath: string): boolean;
+    /**
+     * Delete the file.
+     */
+    delete(filePath: string): void;
+    /**
+     * Rename the file or the folder.
+     */
+    rename(from: string, to: string): void;
+    /**
+     * Check if this is a file or not.
+     */
+    isFile(filePath: string): boolean;
+    /**
+     * Returns the list of children of a folder.
+     */
+    children(dirPath: string): string[];
+    /**
+     * Returns the list of currently recorded changes.
+     */
+    listChanges(): FileChange[];
+    /**
+     * Changes permissions of a file.
+     * @param filePath A path to a file.
+     * @param mode The permission to be granted on the file, given as a string (e.g `755`) or octal integer (e.g `0o755`).
+     * See https://nodejs.org/api/fs.html#fs_file_modes.
+     */
+    changePermissions(filePath: string, mode: Mode): void;
+}
+/**
+ * Description of a file change in the Nx virtual file system/
+ */
+export interface FileChange {
+    /**
+     * Path relative to the workspace root
+     */
+    path: string;
+    /**
+     * Type of change: 'CREATE' | 'DELETE' | 'UPDATE'
+     */
+    type: 'CREATE' | 'DELETE' | 'UPDATE';
+    /**
+     * The content of the file or null in case of delete.
+     */
+    content: Buffer | null;
+    /**
+     * Options to set on the file being created or updated.
+     */
+    options?: TreeWriteOptions;
+}
+export declare class FsTree implements Tree {
+    readonly root: string;
+    private readonly isVerbose;
+    private readonly logOperationId?;
+    private recordedChanges;
+    /**
+     * Signifies if operations on the tree instance
+     * are allowed. Set to false after changes are written
+     * to disk, to prevent someone trying to use the tree to update
+     * files when the tree is no longer effective.
+     */
+    private locked;
+    constructor(root: string, isVerbose: boolean, logOperationId?: string);
+    read(filePath: string): Buffer | null;
+    read(filePath: string, encoding: BufferEncoding): string | null;
+    write(filePath: string, content: Buffer | string, options?: TreeWriteOptions): void;
+    overwrite(filePath: string, content: Buffer | string, options?: TreeWriteOptions): void;
+    delete(filePath: string): void;
+    exists(filePath: string): boolean;
+    rename(from: string, to: string): void;
+    isFile(filePath: string): boolean;
+    children(dirPath: string): string[];
+    listChanges(): FileChange[];
+    changePermissions(filePath: string, mode: Mode): void;
+    lock(): void;
+    private assertUnlocked;
+    private normalize;
+    private fsReadDir;
+    private fsIsFile;
+    private fsReadFile;
+    private fsExists;
+    private filesForDir;
+    private directChildrenOfDir;
+    private rp;
+}
+export declare function flushChanges(root: string, fileChanges: FileChange[]): void;
+export declare function printChanges(fileChanges: FileChange[], indent?: string): void;