@nx/devkit 0.0.0-pr-22179-271588f

package/src/utils/invoke-nx-generator.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertNxGenerator = void 0;
+const path_1 = require("path");
+const nx_1 = require("../../nx");
+let { logger, stripIndent } = (0, nx_1.requireNx)();
+// TODO: Remove this in Nx 19 when Nx 16.7.0 is no longer supported
+stripIndent = stripIndent ?? require('nx/src/utils/logger').stripIndent;
+class RunCallbackTask {
+    constructor(callback) {
+        this.callback = callback;
+    }
+    toConfiguration() {
+        return {
+            name: 'RunCallback',
+            options: {
+                callback: this.callback,
+            },
+        };
+    }
+}
+function createRunCallbackTask() {
+    return {
+        name: 'RunCallback',
+        create: () => {
+            return Promise.resolve(async ({ callback }) => {
+                await callback();
+            });
+        },
+    };
+}
+/**
+ * Convert an Nx Generator into an Angular Devkit Schematic.
+ * @param generator The Nx generator to convert to an Angular Devkit Schematic.
+ */
+function convertNxGenerator(generator, skipWritingConfigInOldFormat = false) {
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+    return (generatorOptions) => invokeNxGenerator(generator, generatorOptions);
+}
+exports.convertNxGenerator = convertNxGenerator;
+/**
+ * Create a Rule to invoke an Nx Generator
+ */
+function invokeNxGenerator(generator, options, skipWritingConfigInOldFormat) {
+    return async (tree, context) => {
+        if (context.engine.workflow) {
+            const engineHost = context.engine.workflow.engineHost;
+            engineHost.registerTaskExecutor(createRunCallbackTask());
+        }
+        const root = context.engine.workflow && context.engine.workflow.engineHost.paths
+            ? context.engine.workflow.engineHost.paths[1]
+            : tree.root.path;
+        const adapterTree = new DevkitTreeFromAngularDevkitTree(tree, root, skipWritingConfigInOldFormat);
+        const result = await generator(adapterTree, options);
+        if (!result) {
+            return adapterTree['tree'];
+        }
+        if (typeof result === 'function') {
+            if (context.engine.workflow) {
+                context.addTask(new RunCallbackTask(result));
+            }
+        }
+    };
+}
+const actionToFileChangeMap = {
+    c: 'CREATE',
+    o: 'UPDATE',
+    d: 'DELETE',
+};
+class DevkitTreeFromAngularDevkitTree {
+    constructor(tree, _root, skipWritingConfigInOldFormat) {
+        this.tree = tree;
+        this._root = _root;
+        this.skipWritingConfigInOldFormat = skipWritingConfigInOldFormat;
+        /**
+         * When using the UnitTestTree from @angular-devkit/schematics/testing, the root is just `/`.
+         * This causes a massive issue if `getProjects()` is used in the underlying generator because it
+         * causes fast-glob to be set to work on the user's entire file system.
+         *
+         * Therefore, in this case, patch the root to match what Nx Devkit does and use /virtual instead.
+         */
+        try {
+            const { UnitTestTree } = require('@angular-devkit/schematics/testing');
+            if (tree instanceof UnitTestTree && _root === '/') {
+                this._root = '/virtual';
+            }
+        }
+        catch { }
+    }
+    get root() {
+        return this._root;
+    }
+    children(dirPath) {
+        const { subdirs, subfiles } = this.tree.getDir(dirPath);
+        return [...subdirs, ...subfiles];
+    }
+    delete(filePath) {
+        this.tree.delete(filePath);
+    }
+    exists(filePath) {
+        if (this.isFile(filePath)) {
+            return this.tree.exists(filePath);
+        }
+        else {
+            return this.children(filePath).length > 0;
+        }
+    }
+    isFile(filePath) {
+        return this.tree.exists(filePath) && !!this.tree.read(filePath);
+    }
+    listChanges() {
+        const fileChanges = [];
+        for (const action of this.tree.actions) {
+            if (action.kind === 'r') {
+                fileChanges.push({
+                    path: this.normalize(action.to),
+                    type: 'CREATE',
+                    content: this.read(action.to),
+                });
+                fileChanges.push({
+                    path: this.normalize(action.path),
+                    type: 'DELETE',
+                    content: null,
+                });
+            }
+            else if (action.kind === 'c' || action.kind === 'o') {
+                fileChanges.push({
+                    path: this.normalize(action.path),
+                    type: actionToFileChangeMap[action.kind],
+                    content: action.content,
+                });
+            }
+            else {
+                fileChanges.push({
+                    path: this.normalize(action.path),
+                    type: 'DELETE',
+                    content: null,
+                });
+            }
+        }
+        return fileChanges;
+    }
+    normalize(path) {
+        return (0, path_1.relative)(this.root, (0, path_1.join)(this.root, path));
+    }
+    read(filePath, encoding) {
+        return encoding
+            ? this.tree.read(filePath).toString(encoding)
+            : this.tree.read(filePath);
+    }
+    rename(from, to) {
+        this.tree.rename(from, to);
+    }
+    write(filePath, content, options) {
+        if (options?.mode) {
+            this.warnUnsupportedFilePermissionsChange(filePath, options.mode);
+        }
+        if (this.tree.exists(filePath)) {
+            this.tree.overwrite(filePath, content);
+        }
+        else {
+            this.tree.create(filePath, content);
+        }
+    }
+    changePermissions(filePath, mode) {
+        this.warnUnsupportedFilePermissionsChange(filePath, mode);
+    }
+    warnUnsupportedFilePermissionsChange(filePath, mode) {
+        logger.warn(stripIndent(`The Angular DevKit tree does not support changing a file permissions.
+                  Ignoring changing ${filePath} permissions to ${mode}.`));
+    }
+}

package/src/utils/log-show-project-command.d.ts

@@ -0,0 +1 @@
+export declare function logShowProjectCommand(projectName: string): void;

package/src/utils/log-show-project-command.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logShowProjectCommand = void 0;
+const nx_1 = require("../../nx");
+function logShowProjectCommand(projectName) {
+    const { output } = (0, nx_1.requireNx)();
+    output.log({
+        title: `👀 View Details of ${projectName}`,
+        bodyLines: [
+            `Run "nx show project ${projectName} --web" to view details about this project.`,
+        ],
+    });
+}
+exports.logShowProjectCommand = logShowProjectCommand;

package/src/utils/move-dir.d.ts

@@ -0,0 +1,5 @@
+import type { Tree } from 'nx/src/generators/tree';
+/**
+ * Analogous to cp -r oldDir newDir
+ */
+export declare function moveFilesToNewDirectory(tree: Tree, oldDir: string, newDir: string): void;

package/src/utils/move-dir.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveFilesToNewDirectory = void 0;
+const path_1 = require("path");
+const visit_not_ignored_files_1 = require("../generators/visit-not-ignored-files");
+const nx_1 = require("../../nx");
+const { normalizePath } = (0, nx_1.requireNx)();
+/**
+ * Analogous to cp -r oldDir newDir
+ */
+function moveFilesToNewDirectory(tree, oldDir, newDir) {
+    oldDir = normalizePath(oldDir);
+    newDir = normalizePath(newDir);
+    (0, visit_not_ignored_files_1.visitNotIgnoredFiles)(tree, oldDir, (file) => {
+        try {
+            tree.rename(file, `${newDir}/${(0, path_1.relative)(oldDir, file)}`);
+        }
+        catch (e) {
+            if (!tree.exists(oldDir)) {
+                console.warn(`Path ${oldDir} does not exist`);
+            }
+            else if (!tree.exists(newDir)) {
+                console.warn(`Path ${newDir} does not exist`);
+            }
+        }
+    });
+}
+exports.moveFilesToNewDirectory = moveFilesToNewDirectory;

package/src/utils/names.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Util function to generate different strings based off the provided name.
+ *
+ * Examples:
+ *
+ * ```typescript
+ * names("my-name") // {name: 'my-name', className: 'MyName', propertyName: 'myName', constantName: 'MY_NAME', fileName: 'my-name'}
+ * names("myName") // {name: 'myName', className: 'MyName', propertyName: 'myName', constantName: 'MY_NAME', fileName: 'my-name'}
+ * ```
+ * @param name
+ */
+export declare function names(name: string): {
+    name: string;
+    className: string;
+    propertyName: string;
+    constantName: string;
+    fileName: string;
+};

package/src/utils/names.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.names = void 0;
+/**
+ * Util function to generate different strings based off the provided name.
+ *
+ * Examples:
+ *
+ * ```typescript
+ * names("my-name") // {name: 'my-name', className: 'MyName', propertyName: 'myName', constantName: 'MY_NAME', fileName: 'my-name'}
+ * names("myName") // {name: 'myName', className: 'MyName', propertyName: 'myName', constantName: 'MY_NAME', fileName: 'my-name'}
+ * ```
+ * @param name
+ */
+function names(name) {
+    return {
+        name,
+        className: toClassName(name),
+        propertyName: toPropertyName(name),
+        constantName: toConstantName(name),
+        fileName: toFileName(name),
+    };
+}
+exports.names = names;
+/**
+ * Hyphenated to UpperCamelCase
+ */
+function toClassName(str) {
+    return toCapitalCase(toPropertyName(str));
+}
+/**
+ * Hyphenated to lowerCamelCase
+ */
+function toPropertyName(s) {
+    return s
+        .replace(/([^a-zA-Z0-9])+(.)?/g, (_, __, chr) => chr ? chr.toUpperCase() : '')
+        .replace(/[^a-zA-Z\d]/g, '')
+        .replace(/^([A-Z])/, (m) => m.toLowerCase());
+}
+/**
+ * Hyphenated to CONSTANT_CASE
+ */
+function toConstantName(s) {
+    const normalizedS = s.toUpperCase() === s ? s.toLowerCase() : s;
+    return toFileName(toPropertyName(normalizedS))
+        .replace(/([^a-zA-Z0-9])/g, '_')
+        .toUpperCase();
+}
+/**
+ * Upper camelCase to lowercase, hyphenated
+ */
+function toFileName(s) {
+    return s
+        .replace(/([a-z\d])([A-Z])/g, '$1_$2')
+        .toLowerCase()
+        .replace(/(?!^[_])[ _]/g, '-');
+}
+/**
+ * Capitalizes the first letter of a string
+ */
+function toCapitalCase(s) {
+    return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/src/utils/offset-from-root.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Calculates an offset from the root of the workspace, which is useful for
+ * constructing relative URLs.
+ *
+ * Examples:
+ *
+ * ```typescript
+ * offsetFromRoot("apps/mydir/myapp/") // returns "../../../"
+ * ```
+ *
+ * @param fullPathToDir - directory path
+ */
+export declare function offsetFromRoot(fullPathToDir: string): string;

package/src/utils/offset-from-root.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.offsetFromRoot = void 0;
+const path_1 = require("path");
+/**
+ * Calculates an offset from the root of the workspace, which is useful for
+ * constructing relative URLs.
+ *
+ * Examples:
+ *
+ * ```typescript
+ * offsetFromRoot("apps/mydir/myapp/") // returns "../../../"
+ * ```
+ *
+ * @param fullPathToDir - directory path
+ */
+function offsetFromRoot(fullPathToDir) {
+    if (fullPathToDir === '.')
+        return './';
+    const parts = (0, path_1.normalize)(fullPathToDir).split(path_1.sep);
+    let offset = '';
+    for (let i = 0; i < parts.length; ++i) {
+        if (parts[i].length > 0) {
+            offset += '../';
+        }
+    }
+    return offset;
+}
+exports.offsetFromRoot = offsetFromRoot;

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

@@ -0,0 +1,78 @@
+import type { Tree } from 'nx/src/generators/tree';
+import type { GeneratorCallback } from 'nx/src/config/misc-interfaces';
+/**
+ * Add Dependencies and Dev Dependencies to package.json
+ *
+ * For example:
+ * ```typescript
+ * addDependenciesToPackageJson(tree, { react: 'latest' }, { jest: 'latest' })
+ * ```
+ * This will **add** `react` and `jest` to the dependencies and devDependencies sections of package.json respectively.
+ *
+ * @param tree Tree representing file system to modify
+ * @param dependencies Dependencies to be added to the dependencies section of package.json
+ * @param devDependencies Dependencies to be added to the devDependencies section of package.json
+ * @param packageJsonPath Path to package.json
+ * @param keepExistingVersions If true, prevents existing dependencies from being bumped to newer versions
+ * @returns Callback to install dependencies only if necessary, no-op otherwise
+ */
+export declare function addDependenciesToPackageJson(tree: Tree, dependencies: Record<string, string>, devDependencies: Record<string, string>, packageJsonPath?: string, keepExistingVersions?: boolean): GeneratorCallback;
+/**
+ * Remove Dependencies and Dev Dependencies from package.json
+ *
+ * For example:
+ * ```typescript
+ * removeDependenciesFromPackageJson(tree, ['react'], ['jest'])
+ * ```
+ * This will **remove** `react` and `jest` from the dependencies and devDependencies sections of package.json respectively.
+ *
+ * @param dependencies Dependencies to be removed from the dependencies section of package.json
+ * @param devDependencies Dependencies to be removed from the devDependencies section of package.json
+ * @returns Callback to uninstall dependencies only if necessary. undefined is returned if changes are not necessary.
+ */
+export declare function removeDependenciesFromPackageJson(tree: Tree, dependencies: string[], devDependencies: string[], packageJsonPath?: string): GeneratorCallback;
+/**
+ * @typedef EnsurePackageOptions
+ * @type {object}
+ * @property {boolean} dev indicate if the package is a dev dependency
+ * @property {throwOnMissing} boolean throws an error when the package is missing
+ */
+/**
+ * @deprecated Use the other function signature without a Tree
+ *
+ * Use a package that has not been installed as a dependency.
+ *
+ * For example:
+ * ```typescript
+ * ensurePackage(tree, '@nx/jest', nxVersion)
+ * ```
+ * This install the @nx/jest@<nxVersion> and return the module
+ * When running with --dryRun, the function will throw when dependencies are missing.
+ * Returns null for ESM dependencies. Import them with a dynamic import instead.
+ *
+ * @param tree the file system tree
+ * @param pkg the package to check (e.g. @nx/jest)
+ * @param requiredVersion the version or semver range to check (e.g. ~1.0.0, >=1.0.0 <2.0.0)
+ * @param {EnsurePackageOptions} options?
+ */
+export declare function ensurePackage(tree: Tree, pkg: string, requiredVersion: string, options?: {
+    dev?: boolean;
+    throwOnMissing?: boolean;
+}): void;
+/**
+ * Ensure that dependencies and devDependencies from package.json are installed at the required versions.
+ * Returns null for ESM dependencies. Import them with a dynamic import instead.
+ *
+ * For example:
+ * ```typescript
+ * ensurePackage('@nx/jest', nxVersion)
+ * ```
+ *
+ * @param pkg the package to install and require
+ * @param version the version to install if the package doesn't exist already
+ */
+export declare function ensurePackage<T extends any = any>(pkg: string, version: string): T;
+/**
+ * @description The version of Nx used by the workspace. Returns null if no version is found.
+ */
+export declare const NX_VERSION: string;