@ohos-ports/nx 19.8.4-beta.0

package/src/generators/tree.js

@@ -0,0 +1,309 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FsTree = void 0;
+exports.flushChanges = flushChanges;
+exports.printChanges = printChanges;
+const node_fs_1 = require("node:fs");
+const logger_1 = require("../utils/logger");
+const output_1 = require("../utils/output");
+const path_1 = require("path");
+const chalk = require("chalk");
+class FsTree {
+    constructor(root, isVerbose, logOperationId) {
+        this.root = root;
+        this.isVerbose = isVerbose;
+        this.logOperationId = logOperationId;
+        this.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.
+         */
+        this.locked = false;
+    }
+    read(filePath, encoding) {
+        filePath = this.normalize(filePath);
+        try {
+            let content;
+            if (this.recordedChanges[this.rp(filePath)]) {
+                content = this.recordedChanges[this.rp(filePath)].content;
+            }
+            else {
+                content = this.fsReadFile(filePath);
+            }
+            return encoding ? content.toString(encoding) : content;
+        }
+        catch (e) {
+            if (this.isVerbose) {
+                logger_1.logger.error(e);
+            }
+            return null;
+        }
+    }
+    write(filePath, content, options) {
+        this.assertUnlocked();
+        filePath = this.normalize(filePath);
+        // Remove any recorded changes where a parent directory has been
+        // deleted when writing a new file within the directory.
+        let parent = (0, path_1.dirname)(this.rp(filePath));
+        while (parent !== '.') {
+            if (this.recordedChanges[parent]?.isDeleted) {
+                delete this.recordedChanges[parent];
+            }
+            parent = (0, path_1.dirname)(parent);
+        }
+        if (this.fsExists(this.rp(filePath)) &&
+            Buffer.from(content).equals(this.fsReadFile(filePath))) {
+            // Remove recorded change because the file has been restored to it's original contents
+            delete this.recordedChanges[this.rp(filePath)];
+            return;
+        }
+        try {
+            this.recordedChanges[this.rp(filePath)] = {
+                content: Buffer.from(content),
+                isDeleted: false,
+                options,
+            };
+        }
+        catch (e) {
+            if (this.isVerbose) {
+                logger_1.logger.error(e);
+            }
+        }
+    }
+    overwrite(filePath, content, options) {
+        filePath = this.normalize(filePath);
+        this.write(filePath, content, options);
+    }
+    delete(filePath) {
+        this.assertUnlocked();
+        filePath = this.normalize(filePath);
+        if (this.filesForDir(this.rp(filePath)).length > 0) {
+            this.filesForDir(this.rp(filePath)).forEach((f) => (this.recordedChanges[f] = { content: null, isDeleted: true }));
+        }
+        this.recordedChanges[this.rp(filePath)] = {
+            content: null,
+            isDeleted: true,
+        };
+        // Delete directory when is not root and there are no children
+        if (filePath !== '' &&
+            this.children((0, path_1.dirname)(this.rp(filePath))).length < 1) {
+            this.delete((0, path_1.dirname)(this.rp(filePath)));
+        }
+    }
+    exists(filePath) {
+        filePath = this.normalize(filePath);
+        try {
+            if (this.recordedChanges[this.rp(filePath)]) {
+                return !this.recordedChanges[this.rp(filePath)].isDeleted;
+            }
+            else if (this.filesForDir(this.rp(filePath)).length > 0) {
+                return true;
+            }
+            else {
+                return this.fsExists(filePath);
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    rename(from, to) {
+        this.assertUnlocked();
+        from = this.normalize(from);
+        to = this.normalize(to);
+        if (from === to) {
+            return;
+        }
+        if (this.isFile(from)) {
+            const content = this.read(this.rp(from));
+            this.write(this.rp(to), content);
+            this.delete(this.rp(from));
+        }
+        else {
+            for (const child of this.children(from)) {
+                this.rename((0, path_1.join)(from, child), (0, path_1.join)(to, child));
+            }
+        }
+    }
+    isFile(filePath) {
+        filePath = this.normalize(filePath);
+        try {
+            if (this.recordedChanges[this.rp(filePath)]) {
+                return !this.recordedChanges[this.rp(filePath)].isDeleted;
+            }
+            else {
+                return this.fsIsFile(filePath);
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    children(dirPath) {
+        dirPath = this.normalize(dirPath);
+        let res = this.fsReadDir(dirPath);
+        res = [...res, ...this.directChildrenOfDir(this.rp(dirPath))];
+        res = res.filter((q) => {
+            const r = this.recordedChanges[this.normalize((0, path_1.join)(this.rp(dirPath), q))];
+            return !r?.isDeleted;
+        });
+        // Dedupe
+        return Array.from(new Set(res));
+    }
+    listChanges() {
+        const res = [];
+        Object.keys(this.recordedChanges).forEach((f) => {
+            if (this.recordedChanges[f].isDeleted) {
+                if (this.fsExists(f)) {
+                    res.push({ path: f, type: 'DELETE', content: null });
+                }
+            }
+            else {
+                if (this.fsExists(f)) {
+                    res.push({
+                        path: f,
+                        type: 'UPDATE',
+                        content: this.recordedChanges[f].content,
+                        options: this.recordedChanges[f].options,
+                    });
+                }
+                else {
+                    res.push({
+                        path: f,
+                        type: 'CREATE',
+                        content: this.recordedChanges[f].content,
+                        options: this.recordedChanges[f].options,
+                    });
+                }
+            }
+        });
+        return res;
+    }
+    changePermissions(filePath, mode) {
+        this.assertUnlocked();
+        filePath = this.normalize(filePath);
+        const filePathChangeKey = this.rp(filePath);
+        if (this.recordedChanges[filePathChangeKey]) {
+            if (this.recordedChanges[filePathChangeKey].isDeleted) {
+                throw new Error(`Cannot change permissions of deleted file ${filePath}.`);
+            }
+            this.recordedChanges[filePathChangeKey].options = { mode };
+        }
+        else if (!this.fsExists(filePath)) {
+            throw new Error(`Cannot change permissions of non-existing file ${filePath}.`);
+        }
+        else if (!this.fsIsFile(filePath)) {
+            // To fully support directories we'd need to change how we store
+            // changes to keep a record of directories so we can associate
+            // permissions to them.
+            throw new Error(`Cannot change permissions of non-file ${filePath}.`);
+        }
+        else {
+            this.recordedChanges[filePathChangeKey] = {
+                content: this.fsReadFile(filePath),
+                isDeleted: false,
+                options: { mode },
+            };
+        }
+    }
+    // Marks FsTree as final.
+    lock() {
+        this.locked = true;
+    }
+    assertUnlocked() {
+        if (this.locked) {
+            output_1.output.error({
+                title: `File changes have already been written to disk. Further changes were attempted ${this.logOperationId ? ` while running ${this.logOperationId}.` : '.'}`,
+                bodyLines: [
+                    'The file system can no longer be modified. This commonly happens when a generator attempts to make further changes in its callback, or an asynchronous operation is still running after the generator completes.',
+                ],
+            });
+            throw new Error('Tree changed after commit to disk.');
+        }
+    }
+    normalize(path) {
+        return (0, path_1.relative)(this.root, (0, path_1.join)(this.root, path)).split(path_1.sep).join('/');
+    }
+    fsReadDir(dirPath) {
+        try {
+            return (0, node_fs_1.readdirSync)((0, path_1.join)(this.root, dirPath));
+        }
+        catch {
+            return [];
+        }
+    }
+    fsIsFile(filePath) {
+        const stat = (0, node_fs_1.statSync)((0, path_1.join)(this.root, filePath));
+        return stat.isFile();
+    }
+    fsReadFile(filePath) {
+        return (0, node_fs_1.readFileSync)((0, path_1.join)(this.root, filePath));
+    }
+    fsExists(filePath) {
+        try {
+            const stat = (0, node_fs_1.statSync)((0, path_1.join)(this.root, filePath));
+            return stat.isFile() || stat.isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    filesForDir(path) {
+        return Object.keys(this.recordedChanges).filter((f) => f.startsWith(`${path}/`) && !this.recordedChanges[f].isDeleted);
+    }
+    directChildrenOfDir(path) {
+        const res = {};
+        if (path === '') {
+            return Object.keys(this.recordedChanges).map((file) => file.split('/')[0]);
+        }
+        Object.keys(this.recordedChanges).forEach((f) => {
+            if (f.startsWith(`${path}/`)) {
+                // Remove the current folder's path from the directory
+                const file = f.substring(path.length + 1);
+                // Split the path on segments, and take the first one
+                const basePath = file.split('/')[0];
+                // Mark it as a child of the current directory
+                res[basePath] = true;
+            }
+        });
+        return Object.keys(res);
+    }
+    rp(pp) {
+        return pp.startsWith('/') ? pp.substring(1) : pp;
+    }
+}
+exports.FsTree = FsTree;
+function flushChanges(root, fileChanges) {
+    fileChanges.forEach((f) => {
+        const fpath = (0, path_1.join)(root, f.path);
+        if (f.type === 'CREATE') {
+            (0, node_fs_1.mkdirSync)((0, path_1.dirname)(fpath), { recursive: true });
+            (0, node_fs_1.writeFileSync)(fpath, f.content);
+            if (f.options?.mode)
+                (0, node_fs_1.chmodSync)(fpath, f.options.mode);
+        }
+        else if (f.type === 'UPDATE') {
+            (0, node_fs_1.writeFileSync)(fpath, f.content);
+            if (f.options?.mode)
+                (0, node_fs_1.chmodSync)(fpath, f.options.mode);
+        }
+        else if (f.type === 'DELETE') {
+            (0, node_fs_1.rmSync)(fpath, { recursive: true, force: true });
+        }
+    });
+}
+function printChanges(fileChanges, indent = '') {
+    fileChanges.forEach((f) => {
+        if (f.type === 'CREATE') {
+            console.log(`${indent}${chalk.green('CREATE')} ${f.path}`);
+        }
+        else if (f.type === 'UPDATE') {
+            console.log(`${indent}${chalk.white('UPDATE')} ${f.path}`);
+        }
+        else if (f.type === 'DELETE') {
+            console.log(`${indent}${chalk.yellow('DELETE')} ${f.path}`);
+        }
+    });
+}

package/src/generators/utils/glob.d.ts

@@ -0,0 +1,22 @@
+import { Tree } from '../tree';
+/**
+ * Performs a tree-aware glob search on the files in a workspace. Able to find newly
+ * created files and hides deleted files before the updates are committed to disk.
+ * Paths should be unix-style with forward slashes.
+ *
+ * @param tree The file system tree
+ * @param patterns A list of glob patterns
+ * @returns Normalized paths in the workspace that match the provided glob patterns.
+ * @deprecated Use {@link globAsync} instead.
+ */
+export declare function glob(tree: Tree, patterns: string[]): string[];
+/**
+ * Performs a tree-aware glob search on the files in a workspace. Able to find newly
+ * created files and hides deleted files before the updates are committed to disk.
+ * Paths should be unix-style with forward slashes.
+ *
+ * @param tree The file system tree
+ * @param patterns A list of glob patterns
+ * @returns Normalized paths in the workspace that match the provided glob patterns.
+ */
+export declare function globAsync(tree: Tree, patterns: string[]): Promise<string[]>;

package/src/generators/utils/glob.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.glob = glob;
+exports.globAsync = globAsync;
+const minimatch_1 = require("minimatch");
+const globs_1 = require("../../utils/globs");
+const workspace_context_1 = require("../../utils/workspace-context");
+/**
+ * Performs a tree-aware glob search on the files in a workspace. Able to find newly
+ * created files and hides deleted files before the updates are committed to disk.
+ * Paths should be unix-style with forward slashes.
+ *
+ * @param tree The file system tree
+ * @param patterns A list of glob patterns
+ * @returns Normalized paths in the workspace that match the provided glob patterns.
+ * @deprecated Use {@link globAsync} instead.
+ */
+function glob(tree, patterns) {
+    return combineGlobResultsWithTree(tree, patterns, (0, workspace_context_1.globWithWorkspaceContextSync)(tree.root, patterns));
+}
+/**
+ * Performs a tree-aware glob search on the files in a workspace. Able to find newly
+ * created files and hides deleted files before the updates are committed to disk.
+ * Paths should be unix-style with forward slashes.
+ *
+ * @param tree The file system tree
+ * @param patterns A list of glob patterns
+ * @returns Normalized paths in the workspace that match the provided glob patterns.
+ */
+async function globAsync(tree, patterns) {
+    return combineGlobResultsWithTree(tree, patterns, await (0, workspace_context_1.globWithWorkspaceContext)(tree.root, patterns));
+}
+function combineGlobResultsWithTree(tree, patterns, results) {
+    const matches = new Set(results);
+    const combinedGlob = (0, globs_1.combineGlobPatterns)(patterns);
+    const matcher = minimatch_1.minimatch.makeRe(combinedGlob);
+    if (!matcher) {
+        throw new Error('Invalid glob pattern: ' + combinedGlob);
+    }
+    for (const change of tree.listChanges()) {
+        if (change.type !== 'UPDATE' && matcher.test(change.path)) {
+            if (change.type === 'CREATE') {
+                matches.add(change.path);
+            }
+            else if (change.type === 'DELETE') {
+                matches.delete(change.path);
+            }
+        }
+    }
+    return Array.from(matches);
+}

package/src/generators/utils/json.d.ts

@@ -0,0 +1,28 @@
+import type { Tree } from '../tree';
+import type { JsonParseOptions, JsonSerializeOptions } from '../../utils/json';
+/**
+ * Reads a json file, removes all comments and parses JSON.
+ *
+ * @param tree - file system tree
+ * @param path - file path
+ * @param options - Optional JSON Parse Options
+ */
+export declare function readJson<T extends object = any>(tree: Tree, path: string, options?: JsonParseOptions): T;
+/**
+ * Writes a JSON value to the file system tree
+
+ * @param tree File system tree
+ * @param path Path of JSON file in the Tree
+ * @param value Serializable value to write
+ * @param options Optional JSON Serialize Options
+ */
+export declare function writeJson<T extends object = object>(tree: Tree, path: string, value: T, options?: JsonSerializeOptions): void;
+/**
+ * Updates a JSON value to the file system tree
+ *
+ * @param tree File system tree
+ * @param path Path of JSON file in the Tree
+ * @param updater Function that maps the current value of a JSON document to a new value to be written to the document
+ * @param options Optional JSON Parse and Serialize Options
+ */
+export declare function updateJson<T extends object = any, U extends object = T>(tree: Tree, path: string, updater: (value: T) => U, options?: JsonParseOptions & JsonSerializeOptions): void;

package/src/generators/utils/json.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readJson = readJson;
+exports.writeJson = writeJson;
+exports.updateJson = updateJson;
+const json_1 = require("../../utils/json");
+/**
+ * Reads a json file, removes all comments and parses JSON.
+ *
+ * @param tree - file system tree
+ * @param path - file path
+ * @param options - Optional JSON Parse Options
+ */
+function readJson(tree, path, options) {
+    if (!tree.exists(path)) {
+        throw new Error(`Cannot find ${path}`);
+    }
+    try {
+        return (0, json_1.parseJson)(tree.read(path, 'utf-8'), options);
+    }
+    catch (e) {
+        throw new Error(`Cannot parse ${path}: ${e.message}`);
+    }
+}
+/**
+ * Writes a JSON value to the file system tree
+
+ * @param tree File system tree
+ * @param path Path of JSON file in the Tree
+ * @param value Serializable value to write
+ * @param options Optional JSON Serialize Options
+ */
+function writeJson(tree, path, value, options) {
+    const serialized = (0, json_1.serializeJson)(value, options);
+    tree.write(path, `${serialized}\n`);
+}
+/**
+ * Updates a JSON value to the file system tree
+ *
+ * @param tree File system tree
+ * @param path Path of JSON file in the Tree
+ * @param updater Function that maps the current value of a JSON document to a new value to be written to the document
+ * @param options Optional JSON Parse and Serialize Options
+ */
+function updateJson(tree, path, updater, options) {
+    const updatedValue = updater(readJson(tree, path, options));
+    writeJson(tree, path, updatedValue, options);
+}

package/src/generators/utils/nx-json.d.ts

@@ -0,0 +1,11 @@
+import type { NxJsonConfiguration } from '../../config/nx-json';
+import type { Tree } from '../tree';
+/**
+ * @deprecated You must pass a {@link Tree}
+ */
+export declare function readNxJson(): NxJsonConfiguration | null;
+export declare function readNxJson(tree: Tree): NxJsonConfiguration | null;
+/**
+ * Update nx.json
+ */
+export declare function updateNxJson(tree: Tree, nxJson: NxJsonConfiguration): void;

package/src/generators/utils/nx-json.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readNxJson = readNxJson;
+exports.updateNxJson = updateNxJson;
+const path_1 = require("path");
+const json_1 = require("./json");
+const nx_json_1 = require("../../config/nx-json");
+/**
+ * Reads nx.json
+ */
+function readNxJson(tree) {
+    if (tree) {
+        if (!tree.exists('nx.json')) {
+            return null;
+        }
+        let nxJson = (0, json_1.readJson)(tree, 'nx.json');
+        if (nxJson.extends) {
+            nxJson = { ...readNxJsonExtends(tree, nxJson.extends), ...nxJson };
+        }
+        return nxJson;
+    }
+    else {
+        return (0, nx_json_1.readNxJson)();
+    }
+}
+/**
+ * Update nx.json
+ */
+function updateNxJson(tree, nxJson) {
+    if (tree.exists('nx.json')) {
+        (0, json_1.updateJson)(tree, 'nx.json', (json) => {
+            if (json.extends) {
+                const nxJsonExtends = readNxJsonExtends(tree, json.extends);
+                const changedPropsOfNxJson = {};
+                Object.keys(nxJson).forEach((prop) => {
+                    if (JSON.stringify(nxJson[prop], null, 2) !=
+                        JSON.stringify(nxJsonExtends[prop], null, 2)) {
+                        changedPropsOfNxJson[prop] = nxJson[prop];
+                    }
+                });
+                return changedPropsOfNxJson;
+            }
+            else {
+                return nxJson;
+            }
+        });
+    }
+}
+function readNxJsonExtends(tree, extendsPath) {
+    try {
+        return (0, json_1.readJson)(tree, (0, path_1.relative)(tree.root, require.resolve(extendsPath, {
+            paths: [tree.root],
+        })));
+    }
+    catch (e) {
+        throw new Error(`Unable to resolve nx.json extends. Error: ${e.message}`);
+    }
+}

package/src/generators/utils/project-configuration.d.ts

@@ -0,0 +1,42 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import type { Tree } from '../tree';
+export { readNxJson, updateNxJson } from './nx-json';
+/**
+ * Adds project configuration to the Nx workspace.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @param projectConfiguration - project configuration
+ * @param standalone - whether the project is configured in workspace.json or not
+ */
+export declare function addProjectConfiguration(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration, standalone?: boolean): void;
+/**
+ * Updates the configuration of an existing project.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @param projectConfiguration - project configuration
+ */
+export declare function updateProjectConfiguration(tree: Tree, projectName: string, projectConfiguration: ProjectConfiguration): void;
+/**
+ * Removes the configuration of an existing project.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ */
+export declare function removeProjectConfiguration(tree: Tree, projectName: string): void;
+/**
+ * Reads a project configuration.
+ *
+ * @param tree - the file system tree
+ * @param projectName - unique name. Often directories are part of the name (e.g., mydir-mylib)
+ * @throws If supplied projectName cannot be found
+ */
+export declare function readProjectConfiguration(tree: Tree, projectName: string): ProjectConfiguration;
+/**
+ * Get a map of all projects in a workspace.
+ *
+ * Use {@link readProjectConfiguration} if only one project is needed.
+ */
+export declare function getProjects(tree: Tree): Map<string, ProjectConfiguration>;
+export declare function getRelativeProjectJsonSchemaPath(tree: Tree, project: ProjectConfiguration): string;