@nx/vitest 0.0.1-alpha.0

package/src/plugins/plugin.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodesV2 = exports.createNodes = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const js_1 = require("@nx/js");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const plugins_1 = require("nx/src/utils/plugins");
+const executor_utils_1 = require("../utils/executor-utils");
+const pmc = (0, devkit_1.getPackageManagerCommand)();
+function readTargetsCache(cachePath) {
+    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, node_fs_1.existsSync)(cachePath)
+        ? (0, devkit_1.readJsonFile)(cachePath)
+        : {};
+}
+function writeTargetsToCache(cachePath, results) {
+    (0, devkit_1.writeJsonFile)(cachePath, results);
+}
+/**
+ * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
+ */
+const createDependencies = () => {
+    return [];
+};
+exports.createDependencies = createDependencies;
+const vitestConfigGlob = '**/{vite,vitest}.config.{js,ts,mjs,mts,cjs,cts}';
+exports.createNodes = [
+    vitestConfigGlob,
+    async (configFilePaths, options, context) => {
+        const optionsHash = (0, file_hasher_1.hashObject)(options);
+        const normalizedOptions = normalizeOptions(options);
+        const cachePath = (0, node_path_1.join)(cache_directory_1.workspaceDataDirectory, `vitest-${optionsHash}.hash`);
+        const targetsCache = readTargetsCache(cachePath);
+        const { roots: projectRoots, configFiles: validConfigFiles } = configFilePaths.reduce((acc, configFile) => {
+            const potentialRoot = (0, node_path_1.dirname)(configFile);
+            if (checkIfConfigFileShouldBeProject(potentialRoot, context)) {
+                acc.roots.push(potentialRoot);
+                acc.configFiles.push(configFile);
+            }
+            return acc;
+        }, {
+            roots: [],
+            configFiles: [],
+        });
+        const lockfile = (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, normalizedOptions, context, projectRoots.map((r) => [lockfile]));
+        try {
+            return await (0, devkit_1.createNodesFromFiles)(async (configFile, _, context, idx) => {
+                const projectRoot = (0, node_path_1.dirname)(configFile);
+                // results from vitest.config.js will be different from results of vite.config.js
+                // but the hash will be the same because it is based on the files under the project root.
+                // Adding the config file path to the hash ensures that the final hash value is different
+                // for different config files.
+                const hash = hashes[idx] + configFile;
+                const { projectType, metadata, targets } = (targetsCache[hash] ??=
+                    await buildVitestTargets(configFile, projectRoot, normalizedOptions, context));
+                const project = {
+                    root: projectRoot,
+                    targets,
+                    metadata,
+                    projectType,
+                };
+                return {
+                    projects: {
+                        [projectRoot]: project,
+                    },
+                };
+            }, validConfigFiles, options, context);
+        }
+        finally {
+            writeTargetsToCache(cachePath, targetsCache);
+        }
+    },
+];
+exports.createNodesV2 = exports.createNodes;
+async function buildVitestTargets(configFilePath, projectRoot, options, context) {
+    const absoluteConfigFilePath = (0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath);
+    // Workaround for the `build$3 is not a function` error that we sometimes see in agents.
+    // This should be removed later once we address the issue properly
+    try {
+        const importEsbuild = () => new Function('return import("esbuild")')();
+        await importEsbuild();
+    }
+    catch {
+        // do nothing
+    }
+    // Workaround for race condition with ESM-only Vite plugins (e.g. @vitejs/plugin-vue@6+)
+    // If vite.config.ts is compiled as CJS, then when both require('@vitejs/plugin-vue') and import('@vitejs/plugin-vue')
+    // are pending in the same process, Node will throw an error:
+    // Error [ERR_INTERNAL_ASSERTION]: Cannot require() ES Module @vitejs/plugin-vue/dist/index.js because it is not yet fully loaded.
+    // This may be caused by a race condition if the module is simultaneously dynamically import()-ed via Promise.all().
+    try {
+        const importVuePlugin = () => new Function('return import("@vitejs/plugin-vue")')();
+        await importVuePlugin();
+    }
+    catch {
+        // Plugin not installed or not needed, ignore
+    }
+    const { resolveConfig } = await (0, executor_utils_1.loadViteDynamicImport)();
+    const viteBuildConfig = await resolveConfig({
+        configFile: absoluteConfigFilePath,
+        mode: 'development',
+    }, 'build');
+    let metadata = {};
+    const { testOutputs, hasTest } = getOutputs(viteBuildConfig, projectRoot, context.workspaceRoot);
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {};
+    // if file is vitest.config or vite.config has definition for test, create targets for test and/or atomized tests
+    if (configFilePath.includes('vitest.config') || hasTest) {
+        targets[options.testTargetName] = await testTarget(namedInputs, testOutputs, projectRoot);
+        if (options.ciTargetName) {
+            const groupName = options.ciGroupName ?? (0, plugins_1.deriveGroupNameFromTarget)(options.ciTargetName);
+            const targetGroup = [];
+            const dependsOn = [];
+            metadata = {
+                targetGroups: {
+                    [groupName]: targetGroup,
+                },
+            };
+            const projectRootRelativeTestPaths = await getTestPathsRelativeToProjectRoot(projectRoot, context.workspaceRoot);
+            for (const relativePath of projectRootRelativeTestPaths) {
+                if (relativePath.includes('../')) {
+                    throw new Error('@nx/vitest attempted to run tests outside of the project root. This is not supported and should not happen. Please open an issue at https://github.com/nrwl/nx/issues/new/choose with the following information:\n\n' +
+                        `\n\n${JSON.stringify({
+                            projectRoot,
+                            relativePath,
+                            projectRootRelativeTestPaths,
+                            context,
+                        }, null, 2)}`);
+                }
+                const targetName = `${options.ciTargetName}--${relativePath}`;
+                dependsOn.push(targetName);
+                targets[targetName] = {
+                    // It does not make sense to run atomized tests in watch mode as they are intended to be run in CI
+                    command: `vitest run ${relativePath}`,
+                    cache: targets[options.testTargetName].cache,
+                    inputs: targets[options.testTargetName].inputs,
+                    outputs: targets[options.testTargetName].outputs,
+                    options: {
+                        cwd: projectRoot,
+                        env: targets[options.testTargetName].options.env,
+                    },
+                    metadata: {
+                        technologies: ['vitest'],
+                        description: `Run Vitest Tests in ${relativePath}`,
+                        help: {
+                            command: `${pmc.exec} vitest --help`,
+                            example: {
+                                options: {
+                                    coverage: true,
+                                },
+                            },
+                        },
+                    },
+                };
+                targetGroup.push(targetName);
+            }
+            if (targetGroup.length > 0) {
+                targets[options.ciTargetName] = {
+                    executor: 'nx:noop',
+                    cache: true,
+                    inputs: targets[options.testTargetName].inputs,
+                    outputs: targets[options.testTargetName].outputs,
+                    dependsOn,
+                    metadata: {
+                        technologies: ['vitest'],
+                        description: 'Run Vitest Tests in CI',
+                        nonAtomizedTarget: options.testTargetName,
+                        help: {
+                            command: `${pmc.exec} vitest --help`,
+                            example: {
+                                options: {
+                                    coverage: true,
+                                },
+                            },
+                        },
+                    },
+                };
+                targetGroup.unshift(options.ciTargetName);
+            }
+        }
+    }
+    return { targets, metadata, projectType: 'library' };
+}
+async function testTarget(namedInputs, outputs, projectRoot) {
+    return {
+        command: `vitest`,
+        options: { cwd: (0, devkit_1.joinPathFragments)(projectRoot) },
+        cache: true,
+        inputs: [
+            ...('production' in namedInputs
+                ? ['default', '^production']
+                : ['default', '^default']),
+            {
+                externalDependencies: ['vitest'],
+            },
+            { env: 'CI' },
+        ],
+        outputs,
+        metadata: {
+            technologies: ['vitest'],
+            description: `Run Vitest tests`,
+            help: {
+                command: `${pmc.exec} vitest --help`,
+                example: {
+                    options: {
+                        bail: 1,
+                        coverage: true,
+                    },
+                },
+            },
+        },
+    };
+}
+function getOutputs(viteBuildConfig, projectRoot, workspaceRoot) {
+    const { test } = viteBuildConfig;
+    const reportsDirectoryPath = normalizeOutputPath(test?.coverage?.reportsDirectory, projectRoot, workspaceRoot, 'coverage');
+    return {
+        testOutputs: [reportsDirectoryPath],
+        hasTest: !!test,
+    };
+}
+function normalizeOutputPath(outputPath, projectRoot, workspaceRoot, path) {
+    if (!outputPath) {
+        if (projectRoot === '.') {
+            return `{projectRoot}/${path}`;
+        }
+        else {
+            return `{workspaceRoot}/${path}/{projectRoot}`;
+        }
+    }
+    else {
+        if ((0, node_path_1.isAbsolute)(outputPath)) {
+            return `{workspaceRoot}/${(0, node_path_1.relative)(workspaceRoot, outputPath)}`;
+        }
+        else {
+            if (outputPath.startsWith('..')) {
+                return (0, node_path_1.join)('{workspaceRoot}', (0, node_path_1.join)(projectRoot, outputPath));
+            }
+            else {
+                return (0, node_path_1.join)('{projectRoot}', outputPath);
+            }
+        }
+    }
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.testTargetName ??= 'test';
+    return options;
+}
+function checkIfConfigFileShouldBeProject(projectRoot, context) {
+    // Do not create a project if package.json and project.json isn't there.
+    const siblingFiles = (0, node_fs_1.readdirSync)((0, node_path_1.join)(context.workspaceRoot, projectRoot));
+    if (!siblingFiles.includes('package.json') &&
+        !siblingFiles.includes('project.json')) {
+        return false;
+    }
+    return true;
+}
+async function getTestPathsRelativeToProjectRoot(projectRoot, workspaceRoot) {
+    const fullProjectRoot = (0, node_path_1.join)(workspaceRoot, projectRoot);
+    const { createVitest } = await Promise.resolve().then(() => require('vitest/node'));
+    const vitest = await createVitest('test', {
+        root: fullProjectRoot,
+        dir: fullProjectRoot,
+        filesOnly: true,
+        watch: false,
+    });
+    const relevantTestSpecifications = await vitest.getRelevantTestSpecifications();
+    return relevantTestSpecifications
+        .filter((ts) => fullProjectRoot === '.' ? true : ts.moduleId.startsWith(fullProjectRoot))
+        .map((ts) => (0, node_path_1.relative)(projectRoot, ts.moduleId));
+}

package/src/utils/detect-ui-framework.d.ts

@@ -0,0 +1,2 @@
+export declare function detectUiFramework(project: string): Promise<'angular' | 'react' | 'none'>;
+//# sourceMappingURL=detect-ui-framework.d.ts.map

package/src/utils/detect-ui-framework.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect-ui-framework.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/utils/detect-ui-framework.ts"],"names":[],"mappings":"AAMA,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,GAAG,OAAO,GAAG,MAAM,CAAC,CAuBvC"}

package/src/utils/detect-ui-framework.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectUiFramework = detectUiFramework;
+const devkit_1 = require("@nx/devkit");
+const ANGULAR_NPM_SCOPE = 'angular';
+const ANGULAR_DEPS = ['@nx/angular'];
+const REACT_DEPS = ['react', '@nx/react'];
+async function detectUiFramework(project) {
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    for (const dep of graph.dependencies[project] ?? []) {
+        if (dep.source !== project || !dep.target.startsWith('npm:')) {
+            continue;
+        }
+        const npmDependency = dep.target.replace('npm:', '');
+        if (dep.target.startsWith(`npm:@${ANGULAR_NPM_SCOPE}/`) ||
+            ANGULAR_DEPS.includes(npmDependency)) {
+            return 'angular';
+        }
+        if (REACT_DEPS.includes(npmDependency)) {
+            return 'react';
+        }
+    }
+    return 'none';
+}

package/src/utils/ensure-dependencies.d.ts

@@ -0,0 +1,9 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+export type EnsureDependenciesOptions = {
+    uiFramework: 'angular' | 'react' | 'vue' | 'none';
+    compiler?: 'babel' | 'swc';
+    includeLib?: boolean;
+    testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string;
+};
+export declare function ensureDependencies(tree: Tree, schema: EnsureDependenciesOptions): Promise<GeneratorCallback>;
+//# sourceMappingURL=ensure-dependencies.d.ts.map

package/src/utils/ensure-dependencies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-dependencies.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/utils/ensure-dependencies.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,iBAAiB,EACtB,KAAK,IAAI,EACV,MAAM,YAAY,CAAC;AAapB,MAAM,MAAM,yBAAyB,GAAG;IACtC,WAAW,EAAE,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IAClD,QAAQ,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IAC3B,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,WAAW,GAAG,cAAc,GAAG,MAAM,CAAC;CAC5E,CAAC;AAEF,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,iBAAiB,CAAC,CA6C5B"}

package/src/utils/ensure-dependencies.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDependencies = ensureDependencies;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("./versions");
+const version_utils_1 = require("./version-utils");
+async function ensureDependencies(tree, schema) {
+    const useVitestUi = schema.uiFramework === 'angular' ||
+        schema.uiFramework === 'react' ||
+        schema.uiFramework === 'vue';
+    const devDependencies = {};
+    if (schema.testEnvironment === 'jsdom') {
+        devDependencies['jsdom'] = versions_1.jsdomVersion;
+    }
+    else if (schema.testEnvironment === 'happy-dom') {
+        devDependencies['happy-dom'] = versions_1.happyDomVersion;
+    }
+    else if (schema.testEnvironment === 'edge-runtime') {
+        devDependencies['@edge-runtime/vm'] = versions_1.edgeRuntimeVmVersion;
+    }
+    else if (schema.testEnvironment !== 'node' && schema.testEnvironment) {
+        devkit_1.logger.info(`A custom environment was provided: ${schema.testEnvironment}. You need to install it manually.`);
+    }
+    if (schema.uiFramework === 'angular') {
+        devDependencies['@analogjs/vitest-angular'] = versions_1.analogVitestAngular;
+        devDependencies['@analogjs/vite-plugin-angular'] = versions_1.analogVitestAngular;
+    }
+    if (schema.uiFramework === 'react') {
+        if (schema.compiler === 'swc') {
+            devDependencies['@vitejs/plugin-react-swc'] = versions_1.vitePluginReactSwcVersion;
+        }
+        else {
+            devDependencies['@vitejs/plugin-react'] = versions_1.vitePluginReactVersion;
+        }
+    }
+    if (schema.includeLib) {
+        devDependencies['vite-plugin-dts'] = versions_1.vitePluginDtsVersion;
+        if ((0, devkit_1.detectPackageManager)() !== 'pnpm') {
+            devDependencies['ajv'] = versions_1.ajvVersion;
+        }
+    }
+    if (useVitestUi) {
+        const { vitestUi } = await (0, version_utils_1.getVitestDependenciesVersionsToInstall)(tree);
+        devDependencies['@vitest/ui'] = vitestUi;
+    }
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies);
+}

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

@@ -0,0 +1,3 @@
+export declare function loadViteDynamicImport(): Promise<typeof import("vite")>;
+export declare function loadVitestDynamicImport(): Promise<typeof import("vitest/node")>;
+//# sourceMappingURL=executor-utils.d.ts.map

package/src/utils/executor-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"executor-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/utils/executor-utils.ts"],"names":[],"mappings":"AAAA,wBAAgB,qBAAqB,IACW,OAAO,CAAC,cAAc,MAAM,CAAC,CAAC,CAC7E;AAED,wBAAgB,uBAAuB,IACgB,OAAO,CAC1D,cAAc,aAAa,CAAC,CAC7B,CACF"}

package/src/utils/executor-utils.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadViteDynamicImport = loadViteDynamicImport;
+exports.loadVitestDynamicImport = loadVitestDynamicImport;
+function loadViteDynamicImport() {
+    return Function('return import("vite")')();
+}
+function loadVitestDynamicImport() {
+    return Function('return import("vitest/node")')();
+}

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

@@ -0,0 +1,35 @@
+import { Tree } from '@nx/devkit';
+export type Target = 'build' | 'serve' | 'test' | 'preview';
+export type TargetFlags = Partial<Record<Target, boolean>>;
+export interface VitestGeneratorSchema {
+    project: string;
+    uiFramework?: 'angular' | 'react' | 'vue' | 'none';
+    coverageProvider: 'v8' | 'istanbul' | 'custom';
+    inSourceTests?: boolean;
+    skipViteConfig?: boolean;
+    testTarget?: string;
+    skipFormat?: boolean;
+    testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string;
+    addPlugin?: boolean;
+    runtimeTsconfigFileName?: string;
+    compiler?: 'babel' | 'swc';
+    projectType?: 'application' | 'library';
+}
+export declare function addOrChangeTestTarget(tree: Tree, options: VitestGeneratorSchema, hasPlugin: boolean): void;
+export interface ViteConfigFileOptions {
+    project: string;
+    includeLib?: boolean;
+    includeVitest?: boolean;
+    inSourceTests?: boolean;
+    testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string;
+    rollupOptionsExternal?: string[];
+    imports?: string[];
+    plugins?: string[];
+    coverageProvider?: 'v8' | 'istanbul' | 'custom';
+    setupFile?: string;
+    useEsmExtension?: boolean;
+    port?: number;
+    previewPort?: number;
+}
+export declare function createOrEditViteConfig(tree: Tree, options: ViteConfigFileOptions, onlyVitest: boolean, projectAlreadyHasViteTargets?: TargetFlags, vitestFileName?: boolean): void;
+//# sourceMappingURL=generator-utils.d.ts.map

package/src/utils/generator-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/utils/generator-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,IAAI,EAGL,MAAM,YAAY,CAAC;AAMpB,MAAM,MAAM,MAAM,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;AAC5D,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAE3D,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,SAAS,GAAG,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IACnD,gBAAgB,EAAE,IAAI,GAAG,UAAU,GAAG,QAAQ,CAAC;IAC/C,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,WAAW,GAAG,cAAc,GAAG,MAAM,CAAC;IAC3E,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,uBAAuB,CAAC,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,EAAE,OAAO,GAAG,KAAK,CAAC;IAC3B,WAAW,CAAC,EAAE,aAAa,GAAG,SAAS,CAAC;CACzC;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,qBAAqB,EAC9B,SAAS,EAAE,OAAO,QAuCnB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,WAAW,GAAG,cAAc,GAAG,MAAM,CAAC;IAC3E,qBAAqB,CAAC,EAAE,MAAM,EAAE,CAAC;IACjC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gBAAgB,CAAC,EAAE,IAAI,GAAG,UAAU,GAAG,QAAQ,CAAC;IAChD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,qBAAqB,EAC9B,UAAU,EAAE,OAAO,EACnB,4BAA4B,CAAC,EAAE,WAAW,EAC1C,cAAc,CAAC,EAAE,OAAO,QA6LzB"}

package/src/utils/generator-utils.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOrChangeTestTarget = addOrChangeTestTarget;
+exports.createOrEditViteConfig = createOrEditViteConfig;
+const devkit_1 = require("@nx/devkit");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const vite_config_edit_utils_1 = require("./vite-config-edit-utils");
+const versions_1 = require("./versions");
+function addOrChangeTestTarget(tree, options, hasPlugin) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/vitest'
+        : p.plugin === '@nx/vitest' || hasPlugin);
+    if (hasPlugin) {
+        return;
+    }
+    const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const target = options.testTarget ?? 'test';
+    const reportsDirectory = (0, devkit_1.joinPathFragments)((0, devkit_1.offsetFromRoot)(project.root), 'coverage', project.root === '.' ? options.project : project.root);
+    const testOptions = {
+        reportsDirectory,
+    };
+    project.targets ??= {};
+    if (project.targets[target]) {
+        throw new Error(`Target "${target}" already exists in the project.`);
+    }
+    else {
+        project.targets[target] = {
+            executor: '@nx/vitest:test',
+            outputs: ['{options.reportsDirectory}'],
+            options: testOptions,
+        };
+    }
+    (0, devkit_1.updateProjectConfiguration)(tree, options.project, project);
+}
+function createOrEditViteConfig(tree, options, onlyVitest, projectAlreadyHasViteTargets, vitestFileName) {
+    const { root: projectRoot } = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    const extension = options.useEsmExtension ? 'mts' : 'ts';
+    const viteConfigPath = vitestFileName
+        ? `${projectRoot}/vitest.config.${extension}`
+        : `${projectRoot}/vite.config.${extension}`;
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
+    const buildOutDir = isTsSolutionSetup
+        ? './dist'
+        : projectRoot === '.'
+            ? `./dist/${options.project}`
+            : `${(0, devkit_1.offsetFromRoot)(projectRoot)}dist/${projectRoot}`;
+    const buildOption = onlyVitest
+        ? ''
+        : options.includeLib
+            ? `  // Configuration for building your library.
+  // See: https://vite.dev/guide/build.html#library-mode
+  build: {
+    outDir: '${buildOutDir}',
+    emptyOutDir: true,
+    reportCompressedSize: true,
+    commonjsOptions: {
+      transformMixedEsModules: true,
+    },
+    lib: {
+      // Could also be a dictionary or array of multiple entry points.
+      entry: 'src/index.ts',
+      name: '${options.project}',
+      fileName: 'index',
+      // Change this to the formats you want to support.
+      // Don't forget to update your package.json as well.
+      formats: ['es' as const]
+    },
+    rollupOptions: {
+      // External packages that should not be bundled into your library.
+      external: [${options.rollupOptionsExternal ?? ''}]
+    },
+  },`
+            : `  build: {
+    outDir: '${buildOutDir}',
+    emptyOutDir: true,
+    reportCompressedSize: true,
+    commonjsOptions: {
+      transformMixedEsModules: true,
+    },
+  },`;
+    const imports = options.imports ? [...options.imports] : [];
+    const plugins = options.plugins ? [...options.plugins] : [];
+    if (!onlyVitest && options.includeLib && !isTsSolutionSetup) {
+        imports.push(`import dts from 'vite-plugin-dts'`, `import * as path from 'path'`);
+    }
+    if (!isTsSolutionSetup) {
+        imports.push(`import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin'`, `import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin'`);
+        plugins.push(`nxViteTsPaths()`, `nxCopyAssetsPlugin(['*.md'])`);
+        (0, devkit_1.addDependenciesToPackageJson)(tree, {}, { '@nx/vite': versions_1.nxVersion });
+    }
+    if (!onlyVitest && options.includeLib) {
+        plugins.push(`dts({ entryRoot: 'src', tsconfigPath: path.join(__dirname, 'tsconfig.lib.json')${!isTsSolutionSetup ? ', pathsToAliases: false' : ''} })`);
+    }
+    const reportsDirectory = isTsSolutionSetup
+        ? './test-output/vitest/coverage'
+        : projectRoot === '.'
+            ? `./coverage/${options.project}`
+            : `${(0, devkit_1.offsetFromRoot)(projectRoot)}coverage/${projectRoot}`;
+    const testOption = options.includeVitest
+        ? `  test: {
+    name: '${options.project}',
+    watch: false,
+    globals: true,
+    environment: '${options.testEnvironment ?? 'jsdom'}',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+${options.setupFile ? `    setupFiles: ['${options.setupFile}'],\n` : ''}\
+${options.inSourceTests
+            ? `    includeSource: ['src/**/*.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],\n`
+            : ''}\
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '${reportsDirectory}',
+      provider: ${options.coverageProvider
+            ? `'${options.coverageProvider}' as const`
+            : `'v8' as const`},
+    }
+  },`
+        : '';
+    const defineOption = options.inSourceTests
+        ? `  define: {
+    'import.meta.vitest': undefined
+  },`
+        : '';
+    const devServerOption = onlyVitest
+        ? ''
+        : options.includeLib
+            ? ''
+            : `  server:{
+    port: ${options.port ?? 4200},
+    host: 'localhost',
+  },`;
+    const previewServerOption = onlyVitest
+        ? ''
+        : options.includeLib
+            ? ''
+            : `  preview:{
+    port: ${options.previewPort ?? 4300},
+    host: 'localhost',
+  },`;
+    const workerOption = isTsSolutionSetup
+        ? `  // Uncomment this if you are using workers.
+  // worker: {
+  //  plugins: [],
+  // },`
+        : `  // Uncomment this if you are using workers.
+  // worker: {
+  //  plugins: [ nxViteTsPaths() ],
+  // },`;
+    const cacheDir = `cacheDir: '${normalizedJoinPaths((0, devkit_1.offsetFromRoot)(projectRoot), 'node_modules', '.vite', projectRoot === '.' ? options.project : projectRoot)}',`;
+    if (tree.exists(viteConfigPath)) {
+        handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, (0, devkit_1.offsetFromRoot)(projectRoot), projectAlreadyHasViteTargets);
+        return;
+    }
+    const viteConfigContent = `/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+${imports.join(';\n')}${imports.length ? ';' : ''}
+
+export default defineConfig(() => ({
+  root: __dirname,
+  ${printOptions(cacheDir, devServerOption, previewServerOption, `  plugins: [${plugins.join(', ')}],`, workerOption, buildOption, defineOption, testOption)}
+}));
+`.replace(/\s+(?=(\n|$))/gm, '\n');
+    tree.write(viteConfigPath, viteConfigContent);
+}
+function printOptions(...options) {
+    return options.filter(Boolean).join('\n');
+}
+function handleViteConfigFileExists(tree, viteConfigPath, options, buildOption, buildOutDir, imports, plugins, testOption, reportsDirectory, cacheDir, projectRoot, offsetFromRoot, projectAlreadyHasViteTargets) {
+    if (projectAlreadyHasViteTargets?.build &&
+        projectAlreadyHasViteTargets?.test) {
+        return;
+    }
+    if (process.env.NX_VERBOSE_LOGGING === 'true') {
+        devkit_1.logger.info(`vite.config.ts already exists for project ${options.project}.`);
+    }
+    const buildOptionObject = options.includeLib
+        ? {
+            lib: {
+                entry: 'src/index.ts',
+                name: options.project,
+                fileName: 'index',
+                formats: ['es'],
+            },
+            rollupOptions: {
+                external: options.rollupOptionsExternal ?? [],
+            },
+            outDir: buildOutDir,
+            reportCompressedSize: true,
+            commonjsOptions: {
+                transformMixedEsModules: true,
+            },
+        }
+        : {
+            outDir: buildOutDir,
+            reportCompressedSize: true,
+            commonjsOptions: {
+                transformMixedEsModules: true,
+            },
+        };
+    const testOptionObject = {
+        globals: true,
+        environment: options.testEnvironment ?? 'jsdom',
+        include: ['src/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+        reporters: ['default'],
+        coverage: {
+            reportsDirectory: reportsDirectory,
+            provider: `'${options.coverageProvider ?? 'v8'}'`,
+        },
+    };
+    const changed = (0, vite_config_edit_utils_1.ensureViteConfigIsCorrect)(tree, viteConfigPath, buildOption, buildOptionObject, imports, plugins, testOption, testOptionObject, cacheDir, projectAlreadyHasViteTargets ?? {});
+    if (!changed) {
+        devkit_1.logger.warn(`Make sure the following setting exists in your Vite configuration file (${viteConfigPath}):
+
+        ${buildOption}
+
+        `);
+    }
+}
+function normalizedJoinPaths(...paths) {
+    const path = (0, devkit_1.joinPathFragments)(...paths);
+    return path.startsWith('.') ? path : `./${path}`;
+}

package/src/utils/ignore-vitest-temp-files.d.ts

@@ -0,0 +1,5 @@
+import { type Tree } from '@nx/devkit';
+export declare function ignoreVitestTempFiles(tree: Tree, projectRoot?: string | undefined): Promise<void>;
+export declare function addVitestTempFilesToGitIgnore(tree: Tree): void;
+export declare function isEslintInstalled(tree: Tree): boolean;
+//# sourceMappingURL=ignore-vitest-temp-files.d.ts.map

package/src/utils/ignore-vitest-temp-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ignore-vitest-temp-files.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/utils/ignore-vitest-temp-files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyC,KAAK,IAAI,EAAE,MAAM,YAAY,CAAC;AAG9E,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,IAAI,EACV,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,GAC/B,OAAO,CAAC,IAAI,CAAC,CAGf;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,CAU9D;AAiCD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAYrD"}