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

package/src/generators/ci-workflow/files/bitbucket-pipelines/bitbucket-pipelines.yml__tmpl__

@@ -0,0 +1,41 @@
+image: node:20
+
+clone:
+  depth: full
+
+pipelines:
+  pull-requests:
+    '**':
+      - step:
+          name: 'Build and test affected apps on Pull Requests'
+          script:
+            - export NX_BRANCH=$BITBUCKET_PR_ID
+
+            # Connect your workspace on <%= nxCloudHost %> and uncomment this to enable task distribution.
+            # The "--stop-agents-after" is optional, but allows idle agents to shut down once the "<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>" targets have been requested
+            # - <%= packageManagerPrefix %> nx-cloud start-ci-run --distribute-on="5 linux-medium-js" --stop-agents-after="<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>"
+
+            <% if(packageManager == 'pnpm'){ %>
+            - npm install --prefix=$HOME/.local -g pnpm@8
+            <% } %>
+            - <%= packageManagerInstall %>
+
+            - <%= packageManagerPrefix %> nx-cloud record -- nx format:check
+            - <%= packageManagerPrefix %> nx affected -t lint test build<% if(hasE2E){ %> e2e-ci<% } %> --base=origin/<%= mainBranch %>
+
+  branches:
+    main:
+      - step:
+          name: 'Build and test affected apps on "<%= mainBranch %>" branch changes'
+          script:
+            # Connect your workspace on <%= nxCloudHost %> and uncomment this to enable task distribution.
+            # The "--stop-agents-after" is optional, but allows idle agents to shut down once the "<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>" targets have been requested
+            # - <%= packageManagerPrefix %> nx-cloud start-ci-run --distribute-on="5 linux-medium-js" --stop-agents-after="<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>"
+
+            <% if(packageManager == 'pnpm'){ %>
+            - npm install --prefix=$HOME/.local -g pnpm@8
+            <% } %>
+            - <%= packageManagerInstall %>
+
+            - <%= packageManagerPrefix %> nx-cloud record -- nx format:check
+            - <%= packageManagerPrefix %> nx affected -t lint test build<% if(hasE2E){ %> e2e-ci<% } %> --base=HEAD~1

package/src/generators/ci-workflow/files/circleci/.circleci/config.yml__tmpl__

@@ -0,0 +1,33 @@
+version: 2.1
+
+orbs:
+  nx: nrwl/nx@1.6.2
+
+jobs:
+  main:
+    docker:
+      - image: cimg/node:lts-browsers
+    steps:
+      - checkout
+
+      # Connect your workspace on <%= nxCloudHost %> and uncomment this to enable task distribution.
+      # The "--stop-agents-after" is optional, but allows idle agents to shut down once the "<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>" targets have been requested
+      # - run: <%= packageManagerPrefix %> nx-cloud start-ci-run --distribute-on="5 linux-medium-js" --stop-agents-after="<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>"
+
+      <% if(packageManager == 'pnpm'){ %>
+      - run:
+          name: Install PNPM
+          command: npm install --prefix=$HOME/.local -g pnpm@8
+      <% } %>- run: <%= packageManagerInstall %>
+      - nx/set-shas:
+          main-branch-name: '<%= mainBranch %>'
+
+      - run: <%= packageManagerPrefix %> nx-cloud record -- nx format:check --base=$NX_BASE --head=$NX_HEAD
+      - run: <%= packageManagerPrefix %> nx affected --base=$NX_BASE --head=$NX_HEAD -t lint test build<% if(hasE2E){ %> e2e-ci<% } %>
+
+workflows:
+  version: 2
+
+  <%= workflowFileName %>:
+    jobs:
+      - main

package/src/generators/ci-workflow/files/github/.github/workflows/__workflowFileName__.yml__tmpl__

@@ -0,0 +1,38 @@
+name: <%= workflowName %>
+
+on:
+  push:
+    branches:
+      - <%= mainBranch %>
+  pull_request:
+
+permissions:
+  actions: read
+  contents: read
+
+jobs:
+  main:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      # Connect your workspace on <%= nxCloudHost %> and uncomment this to enable task distribution.
+      # The "--stop-agents-after" is optional, but allows idle agents to shut down once the "<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>" targets have been requested
+      # - run: <%= packageManagerPrefix %> nx-cloud start-ci-run --distribute-on="5 linux-medium-js" --stop-agents-after="<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>"
+
+      <% if(packageManager == 'pnpm'){ %>
+      - uses: pnpm/action-setup@v2
+        with:
+          version: 8
+      <% } %># Cache node_modules
+      - uses: actions/setup-node@v3
+        with:
+          node-version: 20
+          cache: '<%= packageManager %>'
+      - run: <%= packageManagerInstall %>
+      - uses: nrwl/nx-set-shas@v4
+
+      - run: <%= packageManagerPrefix %> nx-cloud record -- nx format:check
+      - run: <%= packageManagerPrefix %> nx affected -t lint test build<% if(hasE2E){ %> e2e-ci<% } %>

package/src/generators/ci-workflow/files/gitlab/.gitlab-ci.yml__tmpl__

@@ -0,0 +1,24 @@
+image: node:20
+variables:
+  CI: 'true'
+
+# Main job
+<%= workflowName %>:
+  interruptible: true
+  only:
+    - main
+    - merge_requests
+  script:
+    # Connect your workspace on <%= nxCloudHost %> and uncomment this to enable task distribution.
+    # The "--stop-agents-after" is optional, but allows idle agents to shut down once the "<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>" targets have been requested
+    # - <%= packageManagerPrefix %> nx-cloud start-ci-run --distribute-on="5 linux-medium-js" --stop-agents-after="<% if(hasE2E){ %>e2e-ci<% } else { %>build<% } %>"
+
+    <% if(packageManager == 'pnpm'){ %>
+    - npm install --prefix=$HOME/.local -g pnpm@8
+    <% } %>
+    - <%= packageManagerInstall %>
+    - NX_HEAD=$CI_COMMIT_SHA
+    - NX_BASE=${CI_MERGE_REQUEST_DIFF_BASE_SHA:-$CI_COMMIT_BEFORE_SHA}
+
+    - <%= packageManagerPrefix %> nx-cloud record -- nx format:check --base=$NX_BASE --head=$NX_HEAD
+    - <%= packageManagerPrefix %> nx affected --base=$NX_BASE --head=$NX_HEAD -t lint test build<% if(hasE2E){ %> e2e-ci<% } %>

package/src/generators/ci-workflow/schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxWorkspaceCIWorkflow",
+  "title": "Generate a CI workflow.",
+  "description": "Generate a CI workflow.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "ci": {
+      "type": "string",
+      "description": "CI provider.",
+      "enum": ["github", "circleci", "azure", "bitbucket-pipelines", "gitlab"],
+      "x-prompt": {
+        "message": "What is your target CI provider?",
+        "type": "list",
+        "items": [
+          { "value": "github", "label": "GitHub Actions" },
+          { "value": "circleci", "label": "Circle CI" },
+          { "value": "azure", "label": "Azure DevOps" },
+          { "value": "bitbucket-pipelines", "label": "BitBucket Pipelines" },
+          { "value": "gitlab", "label": "Gitlab" }
+        ]
+      }
+    },
+    "name": {
+      "type": "string",
+      "description": "Workflow name.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "default": "CI",
+      "x-prompt": "How should we name your workflow?",
+      "pattern": "^[a-zA-Z].*$"
+    }
+  },
+  "required": ["ci", "name"]
+}

package/src/generators/convert-to-monorepo/convert-to-monorepo.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export declare function monorepoGenerator(tree: Tree, options: {}): Promise<void>;
+export default monorepoGenerator;

package/src/generators/convert-to-monorepo/convert-to-monorepo.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.monorepoGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const move_1 = require("../move/move");
+async function monorepoGenerator(tree, options) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+    let rootProject;
+    const projectsToMove = [];
+    // Need to determine libs vs packages directory base on the type of root project.
+    for (const [, project] of projects) {
+        if (project.root === '.') {
+            rootProject = project;
+        }
+        else {
+            projectsToMove.push(project);
+        }
+    }
+    projectsToMove.unshift(rootProject); // move the root project 1st
+    // Currently, Nx only handles apps+libs or packages. You cannot mix and match them.
+    // If the standalone project is an app (React, Angular, etc), then use apps+libs.
+    // Otherwise, for TS standalone (lib), use packages.
+    const isRootProjectApp = rootProject.projectType === 'application';
+    const appsDir = isRootProjectApp ? 'apps' : 'packages';
+    const libsDir = isRootProjectApp ? 'libs' : 'packages';
+    for (const project of projectsToMove) {
+        await (0, move_1.moveGenerator)(tree, {
+            projectName: project.name,
+            newProjectName: project.name,
+            destination: project.projectType === 'application'
+                ? (0, devkit_1.joinPathFragments)(appsDir, project.root === '.' ? project.name : project.root)
+                : (0, devkit_1.joinPathFragments)(libsDir, project.root === '.' ? project.name : project.root),
+            updateImportPath: project.projectType === 'library',
+            projectNameAndRootFormat: 'as-provided',
+        });
+    }
+}
+exports.monorepoGenerator = monorepoGenerator;
+exports.default = monorepoGenerator;

package/src/generators/convert-to-monorepo/schema.json

@@ -0,0 +1,16 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxWorkspaceConvertToMonorepo",
+  "cli": "nx",
+  "title": "Nx Convert to Monorepo",
+  "description": "Convert an Nx project to a monorepo.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/workspace:monorepo",
+      "description": "Convert an Nx standalone project to a monorepo."
+    }
+  ],
+  "properties": {},
+  "required": []
+}

package/src/generators/convert-to-nx-project/convert-to-nx-project.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function validateSchema(schema: Schema, configName: string): Promise<void>;
+export declare function convertToNxProjectGenerator(host: Tree, schema: Schema): Promise<void>;
+export default convertToNxProjectGenerator;

package/src/generators/convert-to-nx-project/convert-to-nx-project.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToNxProjectGenerator = exports.validateSchema = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const angular_json_1 = require("nx/src/adapter/angular-json");
+const output_1 = require("../../utils/output");
+async function validateSchema(schema, configName) {
+    if (schema.project && schema.all) {
+        throw new Error('--project and --all are mutually exclusive');
+    }
+    if (schema.project && schema.reformat) {
+        throw new Error('--project and --reformat are mutually exclusive');
+    }
+    if (schema.all && schema.reformat) {
+        throw new Error('--all and --reformat are mutually exclusive');
+    }
+    if ((configName === 'workspace.json' && schema.project) ||
+        (configName === 'workspace.json' && schema.reformat)) {
+        throw new Error('workspace.json is no longer supported. Please pass --all to convert all projects and remove workspace.json.');
+    }
+    if (!schema.project && !schema.all && !schema.reformat) {
+        schema.all = true;
+    }
+}
+exports.validateSchema = validateSchema;
+async function convertToNxProjectGenerator(host, schema) {
+    const configName = host.exists('angular.json')
+        ? 'angular.json'
+        : 'workspace.json';
+    if (!host.exists(configName))
+        return;
+    await validateSchema(schema, configName);
+    const projects = (0, angular_json_1.toNewFormat)((0, devkit_1.readJson)(host, configName)).projects;
+    const leftOverProjects = {};
+    for (const projectName of Object.keys(projects)) {
+        const config = projects[projectName];
+        if ((!schema.project || schema.project === projectName) &&
+            !schema.reformat) {
+            if (typeof config === 'string') {
+                // configuration is in project.json
+                const projectConfig = (0, devkit_1.readJson)(host, (0, path_1.join)(config, 'project.json'));
+                if (projectConfig.name !== projectName) {
+                    projectConfig.name = projectName;
+                    projectConfig.root = config;
+                    (0, devkit_1.updateProjectConfiguration)(host, projectName, projectConfig);
+                }
+            }
+            else {
+                // configuration is an object in workspace.json
+                const path = (0, path_1.join)(config.root, 'project.json');
+                if (!host.exists(path)) {
+                    projects[projectName].name = projectName;
+                    (0, devkit_1.addProjectConfiguration)(host, path, projects[projectName]);
+                }
+            }
+        }
+        else {
+            leftOverProjects[projectName] = config;
+        }
+    }
+    if (Object.keys(leftOverProjects).length > 0) {
+        (0, devkit_1.writeJson)(host, 'angular.json', (0, angular_json_1.toOldFormat)({ version: 1, projects: leftOverProjects }));
+    }
+    else {
+        host.delete(configName);
+    }
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(host);
+    }
+    output_1.output.note({
+        title: 'Use "nx show projects" to read the list of projects.',
+        bodyLines: [
+            `If you read the list of projects from ${configName}, use "nx show projects" instead.`,
+        ],
+    });
+}
+exports.convertToNxProjectGenerator = convertToNxProjectGenerator;
+exports.default = convertToNxProjectGenerator;

package/src/generators/convert-to-nx-project/schema.d.ts

@@ -0,0 +1,7 @@
+export interface Schema {
+  project?: string;
+  all?: boolean;
+
+  reformat?: boolean;
+  skipFormat?: boolean;
+}

package/src/generators/convert-to-nx-project/schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "SchematicsConvertToNxProject",
+  "title": "@nx/workspace:fix-configuration",
+  "description": "Migrates v1 config to v2 standalone configuration.",
+  "type": "object",
+  "cli": "nx",
+  "examples": [
+    {
+      "command": "nx g @nx/workspace:convert-to-nx-project --project my-feature-lib",
+      "description": "Convert the `my-feature-lib` project to use `project.json` file instead of `workspace.json`"
+    },
+    {
+      "command": "nx g @nx/workspace:convert-to-nx-project --all",
+      "description": "Convert all projects in `workspace.json` to separate `project.json` files"
+    }
+  ],
+  "properties": {
+    "project": {
+      "description": "Convert a single project",
+      "type": "string"
+    },
+    "all": {
+      "description": "Convert all projects",
+      "type": "boolean"
+    },
+    "reformat": {
+      "description": "Just reformats the configuration",
+      "type": "boolean"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    }
+  }
+}

package/src/generators/move/lib/check-destination.d.ts

@@ -0,0 +1,11 @@
+import type { Tree } from '@nx/devkit';
+import type { NormalizedSchema } from '../schema';
+/**
+ * Checks whether the destination folder is valid
+ *
+ * - must not be outside the workspace
+ * - must be a new folder
+ *
+ * @param schema The options provided to the schematic
+ */
+export declare function checkDestination(tree: Tree, schema: NormalizedSchema, providedDestination: string): void;

package/src/generators/move/lib/check-destination.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDestination = void 0;
+/**
+ * Checks whether the destination folder is valid
+ *
+ * - must not be outside the workspace
+ * - must be a new folder
+ *
+ * @param schema The options provided to the schematic
+ */
+function checkDestination(tree, schema, providedDestination) {
+    const INVALID_DESTINATION = `Invalid destination: [${providedDestination}]`;
+    if (providedDestination.includes('..')) {
+        throw new Error(`${INVALID_DESTINATION} - Please specify explicit path.`);
+    }
+    if (tree.children(schema.relativeToRootDestination).length > 0) {
+        throw new Error(`${INVALID_DESTINATION} - Path is not empty.`);
+    }
+}
+exports.checkDestination = checkDestination;

package/src/generators/move/lib/create-project-configuration-in-new-destination.d.ts

@@ -0,0 +1,3 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+export declare function createProjectConfigurationInNewDestination(tree: Tree, schema: NormalizedSchema, projectConfig: ProjectConfiguration): void;

package/src/generators/move/lib/create-project-configuration-in-new-destination.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProjectConfigurationInNewDestination = void 0;
+const devkit_1 = require("@nx/devkit");
+function createProjectConfigurationInNewDestination(tree, schema, projectConfig) {
+    projectConfig.name = schema.newProjectName;
+    const isRootProject = projectConfig.root === '.';
+    // Subtle bug if project name === path, where the updated name was being overridden.
+    const { name, ...rest } = projectConfig;
+    // replace old root path with new one
+    let newProjectString = JSON.stringify(rest);
+    if (isRootProject) {
+        // Don't replace . with new root since it'll match all characters.
+        // Only look for "./" and replace with new root.
+        newProjectString = newProjectString.replace(/\.\//g, schema.relativeToRootDestination + '/');
+        newProjectString = newProjectString.replace(/"((tsconfig|jest|webpack|vite)\..*?\.(ts|js|json))"/g, `"${schema.relativeToRootDestination}/$1"`);
+        newProjectString = newProjectString.replace(/"(\.\/)?src\/(.*?)"/g, `"${schema.relativeToRootDestination}/src/$2"`);
+    }
+    else {
+        // There's another issue if project name === path, where the target
+        // string (my-app:build:production) was being replaced
+        // and resulting in my-destination/my-new-name:build:production
+        // Change anything but target strings (my-app:build:production).
+        // Target string are going to be updated in the updateBuildTargets function
+        newProjectString = newProjectString.replace(new RegExp(projectConfig.root + '(?!:)', 'g'), schema.relativeToRootDestination);
+    }
+    const newProject = {
+        name,
+        ...JSON.parse(newProjectString),
+    };
+    newProject.root = schema.relativeToRootDestination;
+    // Correct "e2e" target and config since part of the rename will be wrong unless we make the project name "e2e" more unique.
+    // e.g. my-app-e2e is safer to search and replace than "e2e".
+    if (projectConfig.name === 'e2e') {
+        for (const [targetName, targetConfig] of Object.entries(newProject.targets)) {
+            const wrongName = schema.relativeToRootDestination;
+            if (targetName !== wrongName)
+                continue;
+            if (targetConfig.options?.testingType === wrongName) {
+                targetConfig.options.testingType = 'e2e';
+            }
+            newProject.targets['e2e'] = targetConfig;
+            delete newProject.targets[targetName];
+        }
+    }
+    // Original sourceRoot is typically 'src' or 'app', but it could be any folder.
+    // Make sure it is updated to be under the new destination.
+    if (isRootProject && projectConfig.sourceRoot) {
+        newProject.sourceRoot = (0, devkit_1.joinPathFragments)(schema.relativeToRootDestination, projectConfig.sourceRoot);
+    }
+    // Create a new project with the root replaced
+    (0, devkit_1.addProjectConfiguration)(tree, schema.newProjectName, newProject);
+}
+exports.createProjectConfigurationInNewDestination = createProjectConfigurationInNewDestination;

package/src/generators/move/lib/extract-base-configs.d.ts

@@ -0,0 +1,4 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+export declare function maybeExtractTsConfigBase(tree: Tree): void;
+export declare function maybeExtractJestConfigBase(tree: Tree): Promise<void>;
+export declare function maybeMigrateEslintConfigIfRootProject(tree: Tree, rootProject: ProjectConfiguration): void;

package/src/generators/move/lib/extract-base-configs.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maybeMigrateEslintConfigIfRootProject = exports.maybeExtractJestConfigBase = exports.maybeExtractTsConfigBase = void 0;
+const devkit_1 = require("@nx/devkit");
+function maybeExtractTsConfigBase(tree) {
+    let extractTsConfigBase;
+    try {
+        extractTsConfigBase = require('@nx/' + 'js').extractTsConfigBase;
+    }
+    catch {
+        // Not installed, skip
+        return;
+    }
+    extractTsConfigBase(tree);
+}
+exports.maybeExtractTsConfigBase = maybeExtractTsConfigBase;
+async function maybeExtractJestConfigBase(tree) {
+    let jestInitGenerator;
+    try {
+        jestInitGenerator = require('@nx/' + 'jest').jestInitGenerator;
+    }
+    catch {
+        // Not installed, skip
+        return;
+    }
+    await jestInitGenerator(tree, {});
+}
+exports.maybeExtractJestConfigBase = maybeExtractJestConfigBase;
+function maybeMigrateEslintConfigIfRootProject(tree, rootProject) {
+    let migrateConfigToMonorepoStyle;
+    try {
+        migrateConfigToMonorepoStyle = require('@nx/' +
+            'eslint/src/generators/init/init-migration').migrateConfigToMonorepoStyle;
+    }
+    catch {
+        // eslint not installed
+    }
+    migrateConfigToMonorepoStyle?.(Array.from((0, devkit_1.getProjects)(tree).values()), tree, tree.exists((0, devkit_1.joinPathFragments)(rootProject.root, 'jest.config.ts')) ||
+        tree.exists((0, devkit_1.joinPathFragments)(rootProject.root, 'jest.config.js'))
+        ? 'jest'
+        : 'none');
+}
+exports.maybeMigrateEslintConfigIfRootProject = maybeMigrateEslintConfigIfRootProject;

package/src/generators/move/lib/move-project-files.d.ts

@@ -0,0 +1,8 @@
+import { ProjectConfiguration, Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+/**
+ * Moves a project to the given destination path
+ *
+ * @param schema The options provided to the schematic
+ */
+export declare function moveProjectFiles(tree: Tree, schema: NormalizedSchema, project: ProjectConfiguration): void;

package/src/generators/move/lib/move-project-files.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moveProjectFiles = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+/**
+ * Moves a project to the given destination path
+ *
+ * @param schema The options provided to the schematic
+ */
+function moveProjectFiles(tree, schema, project) {
+    // We don't want to move configuration files and other folders that we don't know about.
+    // Moving the wrong files is worse than not moving them, because there might be
+    // a lot of work to undo it.
+    const knownRootProjectFiles = [
+        // Config files
+        'project.json',
+        'tsconfig.json',
+        'tsconfig.app.json',
+        'tsconfig.lib.json',
+        'tsconfig.spec.json',
+        '.babelrc',
+        '.eslintrc.json',
+        'eslint.config.js',
+        /^jest\.config\.((app|lib)\.)?[jt]s$/,
+        'vite.config.ts',
+        /^webpack.*\.js$/,
+        'index.html', // Vite
+    ];
+    const knownRootProjectFolders = [
+        'src', // Most apps/libs
+        'app', // Remix, Next.js
+        'pages', // Next.js
+        'public', // Vite, Remix, Next.js
+    ];
+    const isKnownRootProjectFile = (file) => {
+        const baseDir = (0, path_1.dirname)(file).split(path_1.sep)[0];
+        if (baseDir === '.') {
+            // Not nested, check file matches
+            return knownRootProjectFiles.some((stringOrRegex) => typeof stringOrRegex === 'string'
+                ? file === stringOrRegex
+                : stringOrRegex.test(file));
+        }
+        else {
+            // Nested, check base dir matches
+            return knownRootProjectFolders.includes(baseDir);
+        }
+    };
+    (0, devkit_1.visitNotIgnoredFiles)(tree, project.root, (file) => {
+        if (project.root === '.' && !isKnownRootProjectFile(file))
+            return;
+        // This is a rename but Angular Devkit isn't capable of writing to a file after it's renamed so this is a workaround
+        const relativeFromOriginalSource = (0, path_1.relative)(project.root, file);
+        const newFilePath = (0, path_1.join)(schema.relativeToRootDestination, relativeFromOriginalSource);
+        const content = tree.read(file);
+        tree.write(newFilePath, content);
+        tree.delete(file);
+    });
+}
+exports.moveProjectFiles = moveProjectFiles;

package/src/generators/move/lib/normalize-schema.d.ts

@@ -0,0 +1,3 @@
+import { type ProjectConfiguration, type Tree } from '@nx/devkit';
+import type { NormalizedSchema, Schema } from '../schema';
+export declare function normalizeSchema(tree: Tree, schema: Schema, projectConfiguration: ProjectConfiguration): Promise<NormalizedSchema>;