@depup/nx 22.5.4-depup.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 pc = require("picocolors");
+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}${pc.green('CREATE')} ${f.path}`);
+        }
+        else if (f.type === 'UPDATE') {
+            console.log(`${indent}${pc.white('UPDATE')} ${f.path}`);
+        }
+        else if (f.type === 'DELETE') {
+            console.log(`${indent}${pc.yellow('DELETE')} ${f.path}`);
+        }
+    });
+}

package/src/generators/utils/generate-files.d.ts

@@ -0,0 +1,45 @@
+import { Tree } from '../tree';
+/**
+ * Specify what should be done when a file is generated but already exists on the system
+ */
+export declare enum OverwriteStrategy {
+    Overwrite = "overwrite",
+    KeepExisting = "keepExisting",
+    ThrowIfExisting = "throwIfExisting"
+}
+/**
+ * Options for the generateFiles function
+ */
+export interface GenerateFilesOptions {
+    /**
+     * Specify what should be done when a file is generated but already exists on the system
+     */
+    overwriteStrategy?: OverwriteStrategy;
+}
+/**
+ * Generates a folder of files based on provided templates.
+ *
+ * While doing so it performs two substitutions:
+ * - Substitutes segments of file names surrounded by __
+ * - Uses ejs to substitute values in templates
+ *
+ * Examples:
+ * ```typescript
+ * generateFiles(tree, path.join(__dirname , 'files'), './tools/scripts', {tmpl: '', name: 'myscript'})
+ * ```
+ * This command will take all the files from the `files` directory next to the place where the command is invoked from.
+ * It will replace all `__tmpl__` with '' and all `__name__` with 'myscript' in the file names, and will replace all
+ * `<%= name %>` with `myscript` in the files themselves.
+ * `tmpl: ''` is a common pattern. With it you can name files like this: `index.ts__tmpl__`, so your editor
+ * doesn't get confused about incorrect TypeScript files.
+ *
+ * @param tree - the file system tree
+ * @param srcFolder - the source folder of files (absolute path)
+ * @param target - the target folder (relative to the tree root)
+ * @param substitutions - an object of key-value pairs
+ * @param options - See {@link GenerateFilesOptions}
+ */
+export declare function generateFiles(tree: Tree, srcFolder: string, target: string, substitutions: {
+    [k: string]: any;
+}, options?: GenerateFilesOptions): void;
+//# sourceMappingURL=generate-files.d.ts.map

package/src/generators/utils/generate-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-files.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/utils/generate-files.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAG/B;;GAEG;AACH,oBAAY,iBAAiB;IAC3B,SAAS,cAAc;IACvB,YAAY,iBAAiB;IAC7B,eAAe,oBAAoB;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,IAAI,EACV,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,aAAa,EAAE;IAAE,CAAC,CAAC,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE,EACnC,OAAO,GAAE,oBAER,GACA,IAAI,CAmDN"}

package/src/generators/utils/generate-files.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OverwriteStrategy = void 0;
+exports.generateFiles = generateFiles;
+const fs_1 = require("fs");
+const path = require("path");
+const binary_extensions_1 = require("../../utils/binary-extensions");
+const logger_1 = require("../../utils/logger");
+/**
+ * Specify what should be done when a file is generated but already exists on the system
+ */
+var OverwriteStrategy;
+(function (OverwriteStrategy) {
+    OverwriteStrategy["Overwrite"] = "overwrite";
+    OverwriteStrategy["KeepExisting"] = "keepExisting";
+    OverwriteStrategy["ThrowIfExisting"] = "throwIfExisting";
+})(OverwriteStrategy || (exports.OverwriteStrategy = OverwriteStrategy = {}));
+/**
+ * Generates a folder of files based on provided templates.
+ *
+ * While doing so it performs two substitutions:
+ * - Substitutes segments of file names surrounded by __
+ * - Uses ejs to substitute values in templates
+ *
+ * Examples:
+ * ```typescript
+ * generateFiles(tree, path.join(__dirname , 'files'), './tools/scripts', {tmpl: '', name: 'myscript'})
+ * ```
+ * This command will take all the files from the `files` directory next to the place where the command is invoked from.
+ * It will replace all `__tmpl__` with '' and all `__name__` with 'myscript' in the file names, and will replace all
+ * `<%= name %>` with `myscript` in the files themselves.
+ * `tmpl: ''` is a common pattern. With it you can name files like this: `index.ts__tmpl__`, so your editor
+ * doesn't get confused about incorrect TypeScript files.
+ *
+ * @param tree - the file system tree
+ * @param srcFolder - the source folder of files (absolute path)
+ * @param target - the target folder (relative to the tree root)
+ * @param substitutions - an object of key-value pairs
+ * @param options - See {@link GenerateFilesOptions}
+ */
+function generateFiles(tree, srcFolder, target, substitutions, options = {
+    overwriteStrategy: OverwriteStrategy.Overwrite,
+}) {
+    options ??= {};
+    options.overwriteStrategy ??= OverwriteStrategy.Overwrite;
+    const ejs = require('ejs');
+    const files = allFilesInDir(srcFolder);
+    if (files.length === 0) {
+        throw new Error(`generateFiles: No files found in "${srcFolder}". Are you sure you specified the correct path?`);
+    }
+    else {
+        files.forEach((filePath) => {
+            let newContent;
+            const computedPath = computePath(srcFolder, target, filePath, substitutions);
+            if (tree.exists(computedPath)) {
+                if (options.overwriteStrategy === OverwriteStrategy.KeepExisting) {
+                    return;
+                }
+                else if (options.overwriteStrategy === OverwriteStrategy.ThrowIfExisting) {
+                    throw new Error(`Generated file already exists, not allowed by overwrite strategy in generator (${computedPath})`);
+                }
+                // else: file should be overwritten, so just fall through to file generation
+            }
+            if ((0, binary_extensions_1.isBinaryPath)(filePath)) {
+                newContent = (0, fs_1.readFileSync)(filePath);
+            }
+            else {
+                const template = (0, fs_1.readFileSync)(filePath, 'utf-8');
+                try {
+                    newContent = ejs.render(template, substitutions, {
+                        filename: filePath,
+                    });
+                }
+                catch (e) {
+                    logger_1.logger.error(`Error in ${filePath.replace(`${tree.root}/`, '')}:`);
+                    throw e;
+                }
+            }
+            tree.write(computedPath, newContent);
+        });
+    }
+}
+function computePath(srcFolder, target, filePath, substitutions) {
+    const relativeFromSrcFolder = path.relative(srcFolder, filePath);
+    let computedPath = path.join(target, relativeFromSrcFolder);
+    if (computedPath.endsWith('.template')) {
+        computedPath = computedPath.substring(0, computedPath.length - 9);
+    }
+    Object.entries(substitutions).forEach(([propertyName, value]) => {
+        computedPath = computedPath.split(`__${propertyName}__`).join(value);
+    });
+    return computedPath;
+}
+function allFilesInDir(parent) {
+    let res = [];
+    try {
+        (0, fs_1.readdirSync)(parent).forEach((c) => {
+            const child = path.join(parent, c);
+            try {
+                const s = (0, fs_1.statSync)(child);
+                if (!s.isDirectory()) {
+                    res.push(child);
+                }
+                else if (s.isDirectory()) {
+                    res = [...res, ...allFilesInDir(child)];
+                }
+            }
+            catch { }
+        });
+    }
+    catch { }
+    return res;
+}

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

@@ -0,0 +1,23 @@
+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[]>;
+//# sourceMappingURL=glob.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glob.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/utils/glob.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAO/B;;;;;;;;;GASG;AACH,wBAAgB,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAM7D;AAED;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAC7B,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,MAAM,EAAE,GACjB,OAAO,CAAC,MAAM,EAAE,CAAC,CAMnB"}

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,29 @@
+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;
+//# sourceMappingURL=json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/utils/json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAEpC,OAAO,KAAK,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAE/E;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,EAC7C,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,gBAAgB,GACzB,CAAC,CASH;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EACjD,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,CAAC,EACR,OAAO,CAAC,EAAE,oBAAoB,GAC7B,IAAI,CAGN;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,MAAM,GAAG,GAAG,EAAE,CAAC,SAAS,MAAM,GAAG,CAAC,EACrE,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,CAAC,EACxB,OAAO,CAAC,EAAE,gBAAgB,GAAG,oBAAoB,GAChD,IAAI,CAGN"}

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';
+/**
+ * Reads nx.json
+ */
+export declare function readNxJson(tree: Tree): NxJsonConfiguration | null;
+/**
+ * Update nx.json
+ */
+export declare function updateNxJson(tree: Tree, nxJson: NxJsonConfiguration): void;
+//# sourceMappingURL=nx-json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nx-json.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/generators/utils/nx-json.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,SAAS,CAAC;AAIpC;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,GAAG,mBAAmB,GAAG,IAAI,CASjE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAoB1E"}