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

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

@@ -0,0 +1,95 @@
+/**
+ * Converts a camelized string into all lower case separated by underscores.
+ *
+ ```javascript
+ decamelize('innerHTML');         // 'inner_html'
+ decamelize('action_name');       // 'action_name'
+ decamelize('css-class-name');    // 'css-class-name'
+ decamelize('my favorite items'); // 'my favorite items'
+ ```
+
+ @method decamelize
+ @param {String} str The string to decamelize.
+ @return {String} the decamelized string.
+ */
+export declare function decamelize(str: string): string;
+/**
+ Replaces underscores, spaces, periods, or camelCase with dashes.
+
+ ```javascript
+ dasherize('innerHTML');         // 'inner-html'
+ dasherize('action_name');       // 'action-name'
+ dasherize('css-class-name');    // 'css-class-name'
+ dasherize('my favorite items'); // 'my-favorite-items'
+ dasherize('nrwl.io');           // 'nrwl-io'
+ ```
+
+ @method dasherize
+ @param {String} str The string to dasherize.
+ @return {String} the dasherized string.
+ */
+export declare function dasherize(str?: string): string;
+/**
+ Returns the lowerCamelCase form of a string.
+
+ ```javascript
+ camelize('innerHTML');          // 'innerHTML'
+ camelize('action_name');        // 'actionName'
+ camelize('css-class-name');     // 'cssClassName'
+ camelize('my favorite items');  // 'myFavoriteItems'
+ camelize('My Favorite Items');  // 'myFavoriteItems'
+ ```
+
+ @method camelize
+ @param {String} str The string to camelize.
+ @return {String} the camelized string.
+ */
+export declare function camelize(str: string): string;
+/**
+ Returns the UpperCamelCase form of a string.
+
+ ```javascript
+ 'innerHTML'.classify();          // 'InnerHTML'
+ 'action_name'.classify();        // 'ActionName'
+ 'css-class-name'.classify();     // 'CssClassName'
+ 'my favorite items'.classify();  // 'MyFavoriteItems'
+ ```
+
+ @method classify
+ @param {String} str the string to classify
+ @return {String} the classified string
+ */
+export declare function classify(str: string): string;
+/**
+ More general than decamelize. Returns the lower\_case\_and\_underscored
+ form of a string.
+
+ ```javascript
+ 'innerHTML'.underscore();          // 'inner_html'
+ 'action_name'.underscore();        // 'action_name'
+ 'css-class-name'.underscore();     // 'css_class_name'
+ 'my favorite items'.underscore();  // 'my_favorite_items'
+ ```
+
+ @method underscore
+ @param {String} str The string to underscore.
+ @return {String} the underscored string.
+ */
+export declare function underscore(str: string): string;
+/**
+ Returns the Capitalized form of a string
+
+ ```javascript
+ 'innerHTML'.capitalize()         // 'InnerHTML'
+ 'action_name'.capitalize()       // 'Action_name'
+ 'css-class-name'.capitalize()    // 'Css-class-name'
+ 'my favorite items'.capitalize() // 'My favorite items'
+ ```
+
+ @method capitalize
+ @param {String} str The string to capitalize.
+ @return {String} The capitalized string.
+ */
+export declare function capitalize(str: string): string;
+export declare function group(name: string, group: string | undefined): string;
+export declare function featurePath(group: boolean | undefined, flat: boolean | undefined, path: string, name: string): string;

package/src/utils/string-utils.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.featurePath = exports.group = exports.capitalize = exports.underscore = exports.classify = exports.camelize = exports.dasherize = exports.decamelize = void 0;
+/**
+ * @license
+ * Copyright Google Inc. All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+const STRING_DASHERIZE_REGEXP = /[ _.]/g;
+const STRING_DECAMELIZE_REGEXP = /([a-z\d])([A-Z])/g;
+const STRING_CAMELIZE_REGEXP = /(-|_|\.|\s)+(.)?/g;
+const STRING_UNDERSCORE_REGEXP_1 = /([a-z\d])([A-Z]+)/g;
+const STRING_UNDERSCORE_REGEXP_2 = /-|\s+/g;
+/**
+ * Converts a camelized string into all lower case separated by underscores.
+ *
+ ```javascript
+ decamelize('innerHTML');         // 'inner_html'
+ decamelize('action_name');       // 'action_name'
+ decamelize('css-class-name');    // 'css-class-name'
+ decamelize('my favorite items'); // 'my favorite items'
+ ```
+
+ @method decamelize
+ @param {String} str The string to decamelize.
+ @return {String} the decamelized string.
+ */
+function decamelize(str) {
+    return str.replace(STRING_DECAMELIZE_REGEXP, '$1_$2').toLowerCase();
+}
+exports.decamelize = decamelize;
+/**
+ Replaces underscores, spaces, periods, or camelCase with dashes.
+
+ ```javascript
+ dasherize('innerHTML');         // 'inner-html'
+ dasherize('action_name');       // 'action-name'
+ dasherize('css-class-name');    // 'css-class-name'
+ dasherize('my favorite items'); // 'my-favorite-items'
+ dasherize('nrwl.io');           // 'nrwl-io'
+ ```
+
+ @method dasherize
+ @param {String} str The string to dasherize.
+ @return {String} the dasherized string.
+ */
+function dasherize(str) {
+    return decamelize(str || '').replace(STRING_DASHERIZE_REGEXP, '-');
+}
+exports.dasherize = dasherize;
+/**
+ Returns the lowerCamelCase form of a string.
+
+ ```javascript
+ camelize('innerHTML');          // 'innerHTML'
+ camelize('action_name');        // 'actionName'
+ camelize('css-class-name');     // 'cssClassName'
+ camelize('my favorite items');  // 'myFavoriteItems'
+ camelize('My Favorite Items');  // 'myFavoriteItems'
+ ```
+
+ @method camelize
+ @param {String} str The string to camelize.
+ @return {String} the camelized string.
+ */
+function camelize(str) {
+    return str
+        .replace(STRING_CAMELIZE_REGEXP, (_match, _separator, chr) => {
+        return chr ? chr.toUpperCase() : '';
+    })
+        .replace(/^([A-Z])/, (match) => match.toLowerCase());
+}
+exports.camelize = camelize;
+/**
+ Returns the UpperCamelCase form of a string.
+
+ ```javascript
+ 'innerHTML'.classify();          // 'InnerHTML'
+ 'action_name'.classify();        // 'ActionName'
+ 'css-class-name'.classify();     // 'CssClassName'
+ 'my favorite items'.classify();  // 'MyFavoriteItems'
+ ```
+
+ @method classify
+ @param {String} str the string to classify
+ @return {String} the classified string
+ */
+function classify(str) {
+    return str
+        .split('.')
+        .map((part) => capitalize(camelize(part)))
+        .join('.');
+}
+exports.classify = classify;
+/**
+ More general than decamelize. Returns the lower\_case\_and\_underscored
+ form of a string.
+
+ ```javascript
+ 'innerHTML'.underscore();          // 'inner_html'
+ 'action_name'.underscore();        // 'action_name'
+ 'css-class-name'.underscore();     // 'css_class_name'
+ 'my favorite items'.underscore();  // 'my_favorite_items'
+ ```
+
+ @method underscore
+ @param {String} str The string to underscore.
+ @return {String} the underscored string.
+ */
+function underscore(str) {
+    return str
+        .replace(STRING_UNDERSCORE_REGEXP_1, '$1_$2')
+        .replace(STRING_UNDERSCORE_REGEXP_2, '_')
+        .toLowerCase();
+}
+exports.underscore = underscore;
+/**
+ Returns the Capitalized form of a string
+
+ ```javascript
+ 'innerHTML'.capitalize()         // 'InnerHTML'
+ 'action_name'.capitalize()       // 'Action_name'
+ 'css-class-name'.capitalize()    // 'Css-class-name'
+ 'my favorite items'.capitalize() // 'My favorite items'
+ ```
+
+ @method capitalize
+ @param {String} str The string to capitalize.
+ @return {String} The capitalized string.
+ */
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+exports.capitalize = capitalize;
+function group(name, group) {
+    return group ? `${group}/${name}` : name;
+}
+exports.group = group;
+function featurePath(group, flat, path, name) {
+    if (group && !flat) {
+        return `../../${path}/${name}/`;
+    }
+    return group ? `../${path}/` : './';
+}
+exports.featurePath = featurePath;

package/src/utils/update-package-scripts.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from 'nx/src/generators/tree';
+import type { CreateNodes } from 'nx/src/utils/nx-plugin';
+export declare function updatePackageScripts(tree: Tree, createNodesTuple: CreateNodes): Promise<void>;

package/src/utils/update-package-scripts.js

@@ -0,0 +1,175 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePackageScripts = void 0;
+const path_1 = require("path");
+const yargs = require("yargs-parser");
+const nx_1 = require("../../nx");
+const { glob, readJson, readNxJson, workspaceRoot, writeJson } = (0, nx_1.requireNx)();
+async function updatePackageScripts(tree, createNodesTuple) {
+    const nxJson = readNxJson(tree);
+    const [pattern, createNodes] = createNodesTuple;
+    const files = glob(tree, [pattern]);
+    for (const file of files) {
+        const projectRoot = getProjectRootFromConfigFile(file);
+        await processProject(tree, projectRoot, file, createNodes, nxJson);
+    }
+}
+exports.updatePackageScripts = updatePackageScripts;
+async function processProject(tree, projectRoot, projectConfigurationFile, createNodesFunction, nxJsonConfiguration) {
+    const packageJsonPath = `${projectRoot}/package.json`;
+    if (!tree.exists(packageJsonPath)) {
+        return;
+    }
+    const packageJson = readJson(tree, packageJsonPath);
+    if (!packageJson.scripts || !Object.keys(packageJson.scripts).length) {
+        return;
+    }
+    const result = await createNodesFunction(projectConfigurationFile, {}, { nxJsonConfiguration, workspaceRoot });
+    const targetCommands = getInferredTargetCommands(result);
+    if (!targetCommands.length) {
+        return;
+    }
+    const replacedTargets = new Set();
+    for (const targetCommand of targetCommands) {
+        const { command, target, configuration } = targetCommand;
+        const targetCommandRegex = new RegExp(`(?<=^|&)((?: )*(?:[^&\\r\\n\\s]+ )*)(${command})((?: [^&\\r\\n\\s]+)*(?: )*)(?=$|&)`, 'g');
+        for (const scriptName of Object.keys(packageJson.scripts)) {
+            const script = packageJson.scripts[scriptName];
+            // quick check for exact match within the script
+            if (targetCommandRegex.test(script)) {
+                packageJson.scripts[scriptName] = script.replace(targetCommandRegex, configuration
+                    ? `$1nx ${target} --configuration=${configuration}$3`
+                    : `$1nx ${target}$3`);
+                replacedTargets.add(target);
+            }
+            else {
+                /**
+                 * Parse script and command to handle the following:
+                 * - if command doesn't match script                  => don't replace
+                 * - if command has more args                         => don't replace
+                 * - if command has same args, regardless of order    => replace removing args
+                 * - if command has less args or with different value => replace leaving args
+                 */
+                const parsedCommand = yargs(command, {
+                    configuration: { 'strip-dashed': true },
+                });
+                // this assumes there are no positional args in the command, everything is a command or subcommand
+                const commandCommand = parsedCommand._.join(' ');
+                const commandRegex = new RegExp(`(?<=^|&)((?: )*(?:[^&\\r\\n\\s]+ )*)(${commandCommand})((?: [^&\\r\\n\\s]+)*( )*)(?=$|&)`, 'g');
+                const matches = script.match(commandRegex);
+                if (!matches) {
+                    // the command doesn't match the script, don't replace
+                    continue;
+                }
+                for (const match of matches) {
+                    // parse the matched command within the script
+                    const parsedScript = yargs(match, {
+                        configuration: { 'strip-dashed': true },
+                    });
+                    let hasArgsWithDifferentValues = false;
+                    let scriptHasExtraArgs = false;
+                    let commandHasExtraArgs = false;
+                    for (const [key, value] of Object.entries(parsedCommand)) {
+                        if (key === '_') {
+                            continue;
+                        }
+                        if (parsedScript[key] === undefined) {
+                            commandHasExtraArgs = true;
+                            break;
+                        }
+                        if (parsedScript[key] !== value) {
+                            hasArgsWithDifferentValues = true;
+                        }
+                    }
+                    if (commandHasExtraArgs) {
+                        // the command has extra args, don't replace
+                        continue;
+                    }
+                    for (const key of Object.keys(parsedScript)) {
+                        if (key === '_') {
+                            continue;
+                        }
+                        if (!parsedCommand[key]) {
+                            scriptHasExtraArgs = true;
+                            break;
+                        }
+                    }
+                    if (!hasArgsWithDifferentValues && !scriptHasExtraArgs) {
+                        // they are the same, replace with the command removing the args
+                        packageJson.scripts[scriptName] = packageJson.scripts[scriptName].replace(match, match.replace(commandRegex, configuration
+                            ? `$1nx ${target} --configuration=${configuration}$4`
+                            : `$1nx ${target}$4`));
+                        replacedTargets.add(target);
+                    }
+                    else {
+                        // there are different args or the script has extra args, replace with the command leaving the args
+                        packageJson.scripts[scriptName] = packageJson.scripts[scriptName].replace(match, match.replace(commandRegex, configuration
+                            ? `$1nx ${target} --configuration=${configuration}$3`
+                            : `$1nx ${target}$3`));
+                        replacedTargets.add(target);
+                    }
+                }
+            }
+        }
+    }
+    packageJson.nx ??= {};
+    if (process.env.NX_RUNNING_NX_INIT === 'true') {
+        // running `nx init` so we want to exclude everything by default
+        packageJson.nx.includedScripts = [];
+    }
+    else {
+        /**
+         * Running `nx add`. In this case we want to:
+         * - if `includedScripts` is already set: exclude scripts that match inferred targets that were used to replace a script
+         * - if `includedScripts` is not set: set `includedScripts` with all scripts except the ones that match an inferred target that was used to replace a script
+         */
+        packageJson.nx.includedScripts ??= Object.keys(packageJson.scripts);
+        packageJson.nx.includedScripts = packageJson.nx.includedScripts.filter((s) => !replacedTargets.has(s));
+    }
+    writeJson(tree, packageJsonPath, packageJson);
+}
+function getInferredTargetCommands(result) {
+    const targetCommands = [];
+    for (const project of Object.values(result.projects ?? {})) {
+        for (const [targetName, target] of Object.entries(project.targets ?? {})) {
+            if (target.command) {
+                targetCommands.push({ command: target.command, target: targetName });
+            }
+            else if (target.executor === 'nx:run-commands' &&
+                target.options?.command) {
+                targetCommands.push({
+                    command: target.options.command,
+                    target: targetName,
+                });
+            }
+            if (!target.configurations) {
+                continue;
+            }
+            for (const [configurationName, configuration] of Object.entries(target.configurations)) {
+                if (configuration.command) {
+                    targetCommands.push({
+                        command: configuration.command,
+                        target: targetName,
+                        configuration: configurationName,
+                    });
+                }
+                else if (target.executor === 'nx:run-commands' &&
+                    configuration.options?.command) {
+                    targetCommands.push({
+                        command: configuration.options.command,
+                        target: targetName,
+                        configuration: configurationName,
+                    });
+                }
+            }
+        }
+    }
+    return targetCommands;
+}
+function getProjectRootFromConfigFile(file) {
+    let projectRoot = (0, path_1.dirname)(file);
+    if ((0, path_1.basename)(projectRoot) === '.storybook') {
+        projectRoot = (0, path_1.dirname)(projectRoot);
+    }
+    return projectRoot;
+}

package/src/utils/versions.d.ts

@@ -0,0 +1 @@
+export declare const typescriptVersion = "~5.3.2";

package/src/utils/versions.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.typescriptVersion = void 0;
+exports.typescriptVersion = '~5.3.2';

package/testing.d.ts

@@ -0,0 +1 @@
+export * from 'nx/src/devkit-testing-exports';

package/testing.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// eslint-disable-next-line @typescript-eslint/no-restricted-imports
+tslib_1.__exportStar(require("nx/src/devkit-testing-exports"), exports);