@nx/vitest 0.0.1-alpha.0

package/src/generators/configuration/configuration.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurationGenerator = configurationGenerator;
+exports.configurationGeneratorInternal = configurationGeneratorInternal;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const versions_1 = require("@nx/js/src/utils/versions");
+const path_1 = require("path");
+const ensure_dependencies_1 = require("../../utils/ensure-dependencies");
+const generator_utils_1 = require("../../utils/generator-utils");
+const init_1 = require("../init/init");
+const detect_ui_framework_1 = require("../../utils/detect-ui-framework");
+const version_utils_1 = require("../../utils/version-utils");
+const semver_1 = require("semver");
+/**
+ * @param hasPlugin some frameworks (e.g. Nuxt) provide their own plugin. Their generators handle the plugin detection.
+ */
+function configurationGenerator(tree, schema, hasPlugin = false) {
+    return configurationGeneratorInternal(tree, { addPlugin: false, ...schema }, hasPlugin);
+}
+async function configurationGeneratorInternal(tree, schema, hasPlugin = false) {
+    // Setting default to jsdom since it is the most common use case (React, Web).
+    // The @nx/js:lib generator specifically sets this to node to be more generic.
+    schema.testEnvironment ??= 'jsdom';
+    // Set the viteVersion to the installed version if it already exists in the workspace
+    const installedViteVersion = (0, version_utils_1.getInstalledViteMajorVersion)(tree);
+    schema.viteVersion ??= installedViteVersion;
+    const tasks = [];
+    const { root, projectType: _projectType } = (0, devkit_1.readProjectConfiguration)(tree, schema.project);
+    const projectType = schema.projectType ?? _projectType;
+    const uiFramework = schema.uiFramework ?? (await (0, detect_ui_framework_1.detectUiFramework)(schema.project));
+    const isRootProject = root === '.';
+    tasks.push(await (0, js_1.initGenerator)(tree, { ...schema, skipFormat: true }));
+    const initTask = await (0, init_1.default)(tree, {
+        skipFormat: true,
+        addPlugin: schema.addPlugin,
+        projectRoot: root,
+        viteVersion: schema.viteVersion,
+    });
+    tasks.push(initTask);
+    tasks.push(await (0, ensure_dependencies_1.ensureDependencies)(tree, { ...schema, uiFramework }));
+    (0, generator_utils_1.addOrChangeTestTarget)(tree, schema, hasPlugin);
+    if (!schema.skipViteConfig) {
+        if (uiFramework === 'angular') {
+            const relativeTestSetupPath = (0, devkit_1.joinPathFragments)('src', 'test-setup.ts');
+            const setupFile = (0, devkit_1.joinPathFragments)(root, relativeTestSetupPath);
+            if (!tree.exists(setupFile)) {
+                if (isAngularV20(tree)) {
+                    tree.write(setupFile, `import '@angular/compiler';
+import '@analogjs/vitest-angular/setup-zone';
+
+import {
+  BrowserTestingModule,
+  platformBrowserTesting,
+} from '@angular/platform-browser/testing';
+import { getTestBed } from '@angular/core/testing';
+
+getTestBed().initTestEnvironment(
+  BrowserTestingModule,
+  platformBrowserTesting()
+);
+`);
+                }
+                else {
+                    tree.write(setupFile, `import '@analogjs/vitest-angular/setup-zone';
+
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting,
+} from '@angular/platform-browser-dynamic/testing';
+import { getTestBed } from '@angular/core/testing';
+
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting()
+);
+`);
+                }
+            }
+            (0, generator_utils_1.createOrEditViteConfig)(tree, {
+                project: schema.project,
+                includeLib: false,
+                includeVitest: true,
+                inSourceTests: false,
+                imports: [`import angular from '@analogjs/vite-plugin-angular'`],
+                plugins: ['angular()'],
+                setupFile: relativeTestSetupPath,
+                useEsmExtension: true,
+            }, true);
+        }
+        else if (uiFramework === 'react') {
+            (0, generator_utils_1.createOrEditViteConfig)(tree, {
+                project: schema.project,
+                includeLib: (0, ts_solution_setup_1.getProjectType)(tree, root, projectType) === 'library',
+                includeVitest: true,
+                inSourceTests: schema.inSourceTests,
+                rollupOptionsExternal: [
+                    "'react'",
+                    "'react-dom'",
+                    "'react/jsx-runtime'",
+                ],
+                imports: [
+                    schema.compiler === 'swc'
+                        ? `import react from '@vitejs/plugin-react-swc'`
+                        : `import react from '@vitejs/plugin-react'`,
+                ],
+                plugins: ['react()'],
+                coverageProvider: schema.coverageProvider,
+            }, true);
+        }
+        else {
+            (0, generator_utils_1.createOrEditViteConfig)(tree, {
+                ...schema,
+                includeVitest: true,
+                includeLib: (0, ts_solution_setup_1.getProjectType)(tree, root, projectType) === 'library',
+            }, true);
+        }
+    }
+    const isTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)(tree);
+    createFiles(tree, schema, root, isTsSolutionSetup);
+    updateTsConfig(tree, schema, root, projectType);
+    if (isTsSolutionSetup) {
+        // in the TS solution setup, the test target depends on the build outputs
+        // so we need to setup the task pipeline accordingly
+        const nxJson = (0, devkit_1.readNxJson)(tree);
+        const testTarget = schema.testTarget ?? 'test';
+        nxJson.targetDefaults ??= {};
+        nxJson.targetDefaults[testTarget] ??= {};
+        nxJson.targetDefaults[testTarget].dependsOn ??= [];
+        nxJson.targetDefaults[testTarget].dependsOn = Array.from(new Set([...nxJson.targetDefaults[testTarget].dependsOn, '^build']));
+        (0, devkit_1.updateNxJson)(tree, nxJson);
+    }
+    const devDependencies = await getCoverageProviderDependency(tree, schema.coverageProvider);
+    devDependencies['@types/node'] = versions_1.typesNodeVersion;
+    const installDependenciesTask = (0, devkit_1.addDependenciesToPackageJson)(tree, {}, devDependencies);
+    tasks.push(installDependenciesTask);
+    // Setup workspace config file (https://vitest.dev/guide/workspace.html)
+    if (!isRootProject &&
+        !tree.exists(`vitest.workspace.ts`) &&
+        !tree.exists(`vitest.workspace.js`) &&
+        !tree.exists(`vitest.workspace.json`) &&
+        !tree.exists(`vitest.projects.ts`) &&
+        !tree.exists(`vitest.projects.js`) &&
+        !tree.exists(`vitest.projects.json`)) {
+        tree.write('vitest.workspace.ts', `export default ['**/vite.config.{mjs,js,ts,mts}', '**/vitest.config.{mjs,js,ts,mts}'];`);
+    }
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+function updateTsConfig(tree, options, projectRoot, projectType) {
+    const setupFile = tryFindSetupFile(tree, projectRoot);
+    if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.spec.json'))) {
+        (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.spec.json'), (json) => {
+            if (!json.compilerOptions?.types?.includes('vitest')) {
+                if (json.compilerOptions?.types) {
+                    json.compilerOptions.types.push('vitest');
+                }
+                else {
+                    json.compilerOptions ??= {};
+                    json.compilerOptions.types = ['vitest'];
+                }
+            }
+            if (setupFile) {
+                json.files = [...(json.files ?? []), setupFile];
+            }
+            return json;
+        });
+        (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.json'), (json) => {
+            if (json.references &&
+                !json.references.some((r) => r.path === './tsconfig.spec.json')) {
+                json.references.push({
+                    path: './tsconfig.spec.json',
+                });
+            }
+            return json;
+        });
+    }
+    else {
+        (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.json'), (json) => {
+            if (!json.compilerOptions?.types?.includes('vitest')) {
+                if (json.compilerOptions?.types) {
+                    json.compilerOptions.types.push('vitest');
+                }
+                else {
+                    json.compilerOptions ??= {};
+                    json.compilerOptions.types = ['vitest'];
+                }
+            }
+            return json;
+        });
+    }
+    let runtimeTsconfigPath = (0, devkit_1.joinPathFragments)(projectRoot, (0, ts_solution_setup_1.getProjectType)(tree, projectRoot, projectType) === 'application'
+        ? 'tsconfig.app.json'
+        : 'tsconfig.lib.json');
+    if (options.runtimeTsconfigFileName) {
+        runtimeTsconfigPath = (0, devkit_1.joinPathFragments)(projectRoot, options.runtimeTsconfigFileName);
+        if (!tree.exists(runtimeTsconfigPath)) {
+            throw new Error(`Cannot find the specified runtimeTsConfigFileName ("${options.runtimeTsconfigFileName}") at the project root "${projectRoot}".`);
+        }
+    }
+    if (tree.exists(runtimeTsconfigPath)) {
+        (0, devkit_1.updateJson)(tree, runtimeTsconfigPath, (json) => {
+            if (options.inSourceTests) {
+                (json.compilerOptions.types ??= []).push('vitest/importMeta');
+            }
+            else {
+                const uniqueExclude = new Set([
+                    ...(json.exclude || []),
+                    'vite.config.ts',
+                    'vite.config.mts',
+                    'vitest.config.ts',
+                    'vitest.config.mts',
+                    'src/**/*.test.ts',
+                    'src/**/*.spec.ts',
+                    'src/**/*.test.tsx',
+                    'src/**/*.spec.tsx',
+                    'src/**/*.test.js',
+                    'src/**/*.spec.js',
+                    'src/**/*.test.jsx',
+                    'src/**/*.spec.jsx',
+                ]);
+                json.exclude = [...uniqueExclude];
+            }
+            if (setupFile) {
+                json.exclude = [...(json.exclude ?? []), setupFile];
+            }
+            return json;
+        });
+    }
+    else {
+        devkit_1.logger.warn(`Couldn't find a runtime tsconfig file at ${runtimeTsconfigPath} to exclude the test files from. ` +
+            `If you're using a different filename for your runtime tsconfig, please provide it with the '--runtimeTsconfigFileName' flag.`);
+    }
+}
+function createFiles(tree, options, projectRoot, isTsSolutionSetup) {
+    const rootOffset = (0, devkit_1.offsetFromRoot)(projectRoot);
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files'), projectRoot, {
+        tmpl: '',
+        ...options,
+        projectRoot,
+        extendedConfig: isTsSolutionSetup
+            ? `${rootOffset}tsconfig.base.json`
+            : './tsconfig.json',
+        outDir: isTsSolutionSetup
+            ? `./out-tsc/vitest`
+            : `${rootOffset}dist/out-tsc`,
+    });
+}
+async function getCoverageProviderDependency(tree, coverageProvider) {
+    const { vitestCoverageV8, vitestCoverageIstanbul } = await (0, version_utils_1.getVitestDependenciesVersionsToInstall)(tree);
+    switch (coverageProvider) {
+        case 'v8':
+            return {
+                '@vitest/coverage-v8': vitestCoverageV8,
+            };
+        case 'istanbul':
+            return {
+                '@vitest/coverage-istanbul': vitestCoverageIstanbul,
+            };
+        default:
+            return {
+                '@vitest/coverage-v8': vitestCoverageV8,
+            };
+    }
+}
+function tryFindSetupFile(tree, projectRoot) {
+    const setupFile = (0, devkit_1.joinPathFragments)('src', 'test-setup.ts');
+    if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, setupFile))) {
+        return setupFile;
+    }
+}
+function isAngularV20(tree) {
+    const angularVersion = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, '@angular/core');
+    if (!angularVersion) {
+        // assume the latest version will be installed, which will be 20 or later
+        return true;
+    }
+    const cleanedAngularVersion = (0, semver_1.clean)(angularVersion) ?? (0, semver_1.coerce)(angularVersion).version;
+    return (0, semver_1.major)(cleanedAngularVersion) >= 20;
+}
+exports.default = configurationGenerator;

package/src/generators/configuration/files/tsconfig.spec.json__tmpl__

@@ -0,0 +1,22 @@
+{
+  "extends": "<%= extendedConfig %>",
+  "compilerOptions": {
+    "outDir": "<%= outDir %>",
+    "types": ["vitest/globals", "vitest/importMeta", "vite/client", "node"]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/src/generators/configuration/schema.d.ts

@@ -0,0 +1,16 @@
+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'; // default: babel
+  // internal options
+  projectType?: 'application' | 'library';
+  viteVersion?: 5 | 6 | 7;
+}

package/src/generators/configuration/schema.json

@@ -0,0 +1,65 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "Vitest",
+  "title": "Vitest",
+  "type": "object",
+  "description": "Generate a Vitest setup for a project.",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project to test.",
+      "$default": {
+        "$source": "projectName"
+      }
+    },
+    "uiFramework": {
+      "type": "string",
+      "enum": ["angular", "react", "vue", "none"],
+      "description": "UI framework to use with vitest."
+    },
+    "inSourceTests": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not generate separate spec files and set up in-source testing."
+    },
+    "skipViteConfig": {
+      "type": "boolean",
+      "default": false,
+      "description": "Skip generating a vite config file."
+    },
+    "coverageProvider": {
+      "type": "string",
+      "enum": ["v8", "istanbul", "custom"],
+      "default": "v8",
+      "description": "Coverage provider to use."
+    },
+    "testTarget": {
+      "type": "string",
+      "description": "The test target of the project to be transformed to use the @nx/vitest:test executor.",
+      "hidden": true
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "testEnvironment": {
+      "description": "The vitest environment to use. See https://vitest.dev/config/#environment.",
+      "type": "string",
+      "enum": ["node", "jsdom", "happy-dom", "edge-runtime"]
+    },
+    "runtimeTsconfigFileName": {
+      "type": "string",
+      "description": "The name of the project's tsconfig file that includes the runtime source files. If not provided, it will default to `tsconfig.lib.json` for libraries and `tsconfig.app.json` for applications."
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["babel", "swc"],
+      "default": "babel",
+      "description": "The compiler to use"
+    }
+  },
+  "required": ["project"]
+}

package/src/generators/init/init.d.ts

@@ -0,0 +1,8 @@
+import { type Tree, type GeneratorCallback } from '@nx/devkit';
+import { InitGeneratorSchema } from './schema';
+export declare function updateDependencies(tree: Tree, schema: InitGeneratorSchema): GeneratorCallback;
+export declare function updateNxJsonSettings(tree: Tree): void;
+export declare function initGenerator(tree: Tree, schema: InitGeneratorSchema): Promise<GeneratorCallback>;
+export declare function initGeneratorInternal(tree: Tree, schema: InitGeneratorSchema): Promise<GeneratorCallback>;
+export default initGenerator;
+//# sourceMappingURL=init.d.ts.map

package/src/generators/init/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../../../../../packages/vitest/src/generators/init/init.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,IAAI,EACT,KAAK,iBAAiB,EAOvB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAW/C,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,mBAAmB,qBAmBzE;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,IAAI,QA4B9C;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,mBAAmB,8BAEpE;AAED,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,mBAAmB,8BAmC5B;AAED,eAAe,aAAa,CAAC"}

package/src/generators/init/init.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateDependencies = updateDependencies;
+exports.updateNxJsonSettings = updateNxJsonSettings;
+exports.initGenerator = initGenerator;
+exports.initGeneratorInternal = initGeneratorInternal;
+const devkit_1 = require("@nx/devkit");
+const add_plugin_1 = require("@nx/devkit/src/utils/add-plugin");
+const versions_1 = require("../../utils/versions");
+const plugin_1 = require("../../plugins/plugin");
+const ignore_vitest_temp_files_1 = require("../../utils/ignore-vitest-temp-files");
+function updateDependencies(tree, schema) {
+    const viteVersionToUse = schema.viteVersion
+        ? schema.viteVersion === 5
+            ? versions_1.viteV5Version
+            : schema.viteVersion === 6
+                ? versions_1.viteV6Version
+                : versions_1.viteVersion
+        : versions_1.viteVersion;
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@nx/vitest': versions_1.nxVersion,
+        vitest: versions_1.vitestVersion,
+        vite: viteVersionToUse,
+    }, undefined, schema.keepExistingVersions);
+}
+function updateNxJsonSettings(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const productionFileSet = nxJson.namedInputs?.production;
+    if (productionFileSet) {
+        productionFileSet.push('!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)', '!{projectRoot}/tsconfig.spec.json');
+        nxJson.namedInputs.production = Array.from(new Set(productionFileSet));
+    }
+    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string' ? p === '@nx/vitest' : p.plugin === '@nx/vitest');
+    if (!hasPlugin) {
+        nxJson.targetDefaults ??= {};
+        nxJson.targetDefaults['@nx/vitest:test'] ??= {};
+        nxJson.targetDefaults['@nx/vitest:test'].cache ??= true;
+        nxJson.targetDefaults['@nx/vitest:test'].inputs ??= [
+            'default',
+            productionFileSet ? '^production' : '^default',
+        ];
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+function initGenerator(tree, schema) {
+    return initGeneratorInternal(tree, { addPlugin: false, ...schema });
+}
+async function initGeneratorInternal(tree, schema) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    schema.addPlugin ??= addPluginDefault;
+    if (schema.addPlugin) {
+        await (0, add_plugin_1.addPlugin)(tree, await (0, devkit_1.createProjectGraphAsync)(), '@nx/vitest', plugin_1.createNodesV2, {
+            testTargetName: ['test', 'vitest:test', 'vitest-test'],
+            ciTargetName: ['test-ci', 'vitest:test-ci', 'vitest-test-ci'],
+        }, schema.updatePackageScripts);
+    }
+    updateNxJsonSettings(tree);
+    await (0, ignore_vitest_temp_files_1.ignoreVitestTempFiles)(tree, schema.projectRoot);
+    const tasks = [];
+    if (!schema.skipPackageJson) {
+        tasks.push(updateDependencies(tree, schema));
+    }
+    if (!schema.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.default = initGenerator;

package/src/generators/init/schema.d.ts

@@ -0,0 +1,11 @@
+export interface InitGeneratorSchema {
+  addPlugin?: boolean;
+  rootProject?: boolean;
+  keepExistingVersions?: boolean;
+  projectRoot?: string;
+  updatePackageScripts?: boolean;
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  // Internal only
+  viteVersion?: 5 | 6 | 7;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "Init",
+  "title": "Nx Vitest Init Generator",
+  "type": "object",
+  "description": "Vitest init generator.",
+  "properties": {
+    "addPlugin": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Add plugin to nx.json. Defaults to true for new workspaces."
+    },
+    "rootProject": {
+      "type": "boolean",
+      "x-priority": "internal"
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update package scripts",
+      "default": false
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false
+    },
+    "skipPackageJson": {
+      "description": "Do not add dependencies to `package.json`.",
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/migrations/update-20-3-0/add-vitest-temp-files-to-git-ignore.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+export default function addVitestTempFilesToGitIgnore(tree: Tree): void;
+//# sourceMappingURL=add-vitest-temp-files-to-git-ignore.d.ts.map

package/src/migrations/update-20-3-0/add-vitest-temp-files-to-git-ignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-vitest-temp-files-to-git-ignore.d.ts","sourceRoot":"","sources":["../../../../../../packages/vitest/src/migrations/update-20-3-0/add-vitest-temp-files-to-git-ignore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAGlC,MAAM,CAAC,OAAO,UAAU,6BAA6B,CAAC,IAAI,EAAE,IAAI,QAsB/D"}

package/src/migrations/update-20-3-0/add-vitest-temp-files-to-git-ignore.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = addVitestTempFilesToGitIgnore;
+const ignore_vitest_temp_files_1 = require("../../utils/ignore-vitest-temp-files");
+function addVitestTempFilesToGitIgnore(tree) {
+    // need to check if .gitignore exists before adding to it
+    // then need to check if it contains the following pattern
+    // **/vite.config.{js,ts,mjs,mts,cjs,cts}.timestamp*
+    // if it does, remove just this pattern
+    if (tree.exists('.gitignore')) {
+        const gitIgnoreContents = tree.read('.gitignore', 'utf-8');
+        if (gitIgnoreContents.includes('**/vitest.config.{js,ts,mjs,mts,cjs,cts}.timestamp*')) {
+            tree.write('.gitignore', gitIgnoreContents.replace('**/vitest.config.{js,ts,mjs,mts,cjs,cts}.timestamp*', ''));
+        }
+    }
+    (0, ignore_vitest_temp_files_1.addVitestTempFilesToGitIgnore)(tree);
+}

package/src/plugins/plugin.d.ts

@@ -0,0 +1,19 @@
+import { CreateDependencies, CreateNodesV2 } from '@nx/devkit';
+export interface VitestPluginOptions {
+    testTargetName?: string;
+    /**
+     * Atomizer for vitest
+     */
+    ciTargetName?: string;
+    /**
+     * The name that should be used to group atomized tasks on CI
+     */
+    ciGroupName?: string;
+}
+/**
+ * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
+ */
+export declare const createDependencies: CreateDependencies;
+export declare const createNodes: CreateNodesV2<VitestPluginOptions>;
+export declare const createNodesV2: CreateNodesV2<VitestPluginOptions>;
+//# sourceMappingURL=plugin.d.ts.map

package/src/plugins/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/plugins/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAGlB,aAAa,EAQd,MAAM,YAAY,CAAC;AAapB,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAoBD;;GAEG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBAEhC,CAAC;AAIF,eAAO,MAAM,WAAW,EAAE,aAAa,CAAC,mBAAmB,CA+E1D,CAAC;AAEF,eAAO,MAAM,aAAa,oCAAc,CAAC"}