@nx/vitest 0.0.1-alpha.0

package/src/utils/ignore-vitest-temp-files.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoreVitestTempFiles = ignoreVitestTempFiles;
+exports.addVitestTempFilesToGitIgnore = addVitestTempFilesToGitIgnore;
+exports.isEslintInstalled = isEslintInstalled;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("./versions");
+async function ignoreVitestTempFiles(tree, projectRoot) {
+    addVitestTempFilesToGitIgnore(tree);
+    await ignoreVitestTempFilesInEslintConfig(tree, projectRoot);
+}
+function addVitestTempFilesToGitIgnore(tree) {
+    let gitIgnoreContents = tree.exists('.gitignore')
+        ? tree.read('.gitignore', 'utf-8')
+        : '';
+    if (!/^vitest\.config\.\*\.timestamp\*$/m.test(gitIgnoreContents)) {
+        gitIgnoreContents = (0, devkit_1.stripIndents) `${gitIgnoreContents}
+      vitest.config.*.timestamp*`;
+    }
+    tree.write('.gitignore', gitIgnoreContents);
+}
+async function ignoreVitestTempFilesInEslintConfig(tree, projectRoot) {
+    if (!isEslintInstalled(tree)) {
+        return;
+    }
+    (0, devkit_1.ensurePackage)('@nx/eslint', versions_1.nxVersion);
+    const { addIgnoresToLintConfig, isEslintConfigSupported } = await Promise.resolve().then(() => require('@nx/eslint/src/generators/utils/eslint-file'));
+    if (!isEslintConfigSupported(tree)) {
+        return;
+    }
+    const { useFlatConfig } = await Promise.resolve().then(() => require('@nx/eslint/src/utils/flat-config'));
+    const isUsingFlatConfig = useFlatConfig(tree);
+    if (!projectRoot && !isUsingFlatConfig) {
+        // root eslintrc files ignore all files and the root eslintrc files add
+        // back all the project files, so we only add the ignores to the project
+        // eslintrc files
+        return;
+    }
+    // for flat config, we update the root config file
+    const directory = isUsingFlatConfig ? '' : projectRoot ?? '';
+    addIgnoresToLintConfig(tree, directory, ['**/vitest.config.*.timestamp*']);
+}
+function isEslintInstalled(tree) {
+    try {
+        require('eslint');
+        return true;
+    }
+    catch { }
+    // it might not be installed yet, but it might be in the tree pending install
+    const { devDependencies, dependencies } = tree.exists('package.json')
+        ? (0, devkit_1.readJson)(tree, 'package.json')
+        : {};
+    return !!devDependencies?.['eslint'] || !!dependencies?.['eslint'];
+}

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

@@ -0,0 +1,8 @@
+import { ExecutorContext } from '@nx/devkit';
+/**
+ * Returns the path to the vite config file or undefined when not found.
+ */
+export declare function normalizeViteConfigFilePath(contextRoot: string, projectRoot: string, configFile?: string): string | undefined;
+export declare function getProjectTsConfigPath(projectRoot: string): string | undefined;
+export declare function getNxTargetOptions(target: string, context: ExecutorContext): any;
+//# sourceMappingURL=options-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"options-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/utils/options-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAKhB,MAAM,YAAY,CAAC;AAGpB;;GAEG;AACH,wBAAgB,2BAA2B,CACzC,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAgCpB;AAED,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAYpB;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,OAG1E"}

package/src/utils/options-utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeViteConfigFilePath = normalizeViteConfigFilePath;
+exports.getProjectTsConfigPath = getProjectTsConfigPath;
+exports.getNxTargetOptions = getNxTargetOptions;
+const devkit_1 = require("@nx/devkit");
+const fs_1 = require("fs");
+/**
+ * Returns the path to the vite config file or undefined when not found.
+ */
+function normalizeViteConfigFilePath(contextRoot, projectRoot, configFile) {
+    if (configFile) {
+        const normalized = (0, devkit_1.joinPathFragments)(contextRoot, configFile);
+        if (!(0, fs_1.existsSync)(normalized)) {
+            throw new Error(`Could not find vite config at provided path "${normalized}".`);
+        }
+        return normalized;
+    }
+    const allowsExt = ['js', 'mjs', 'ts', 'cjs', 'mts', 'cts'];
+    for (const ext of allowsExt) {
+        if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vite.config.${ext}`))) {
+            return (0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vite.config.${ext}`);
+        }
+        else if ((0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vitest.config.${ext}`))) {
+            return (0, devkit_1.joinPathFragments)(contextRoot, projectRoot, `vitest.config.${ext}`);
+        }
+    }
+}
+function getProjectTsConfigPath(projectRoot) {
+    return (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot, 'tsconfig.app.json'))
+        ? (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.app.json')
+        : (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot, 'tsconfig.lib.json'))
+            ? (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.lib.json')
+            : (0, fs_1.existsSync)((0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot, 'tsconfig.json'))
+                ? (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.json')
+                : undefined;
+}
+function getNxTargetOptions(target, context) {
+    const targetObj = (0, devkit_1.parseTargetString)(target, context);
+    return (0, devkit_1.readTargetOptions)(targetObj, context);
+}

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

@@ -0,0 +1,16 @@
+import type { Tree } from 'nx/src/generators/tree';
+type VitestDependenciesVersions = {
+    vitest: string;
+    vitestUi: string;
+    vitestCoverageV8: string;
+    vitestCoverageIstanbul: string;
+};
+export declare function getVitestDependenciesVersionsToInstall(tree: Tree): Promise<VitestDependenciesVersions>;
+export declare function isVitestV1(tree: Tree): Promise<boolean>;
+export declare function isVitestV2(tree: Tree): Promise<boolean>;
+export declare function getInstalledVitestVersion(tree: Tree): string;
+export declare function getInstalledViteVersion(tree: Tree): string;
+export declare function getInstalledViteMajorVersion(tree: Tree): 5 | 6 | 7 | undefined;
+export declare function getInstalledVitestVersionFromGraph(): Promise<string>;
+export {};
+//# sourceMappingURL=version-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"version-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/utils/version-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAcnD,KAAK,0BAA0B,GAAG;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;CAChC,CAAC;AAEF,wBAAsB,sCAAsC,CAC1D,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,0BAA0B,CAAC,CAwBrC;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,IAAI,oBAM1C;AAED,wBAAsB,UAAU,CAAC,IAAI,EAAE,IAAI,oBAM1C;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAiB5D;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,CAe1D;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,IAAI,GACT,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,SAAS,CAWvB;AAED,wBAAsB,kCAAkC,oBASvD"}

package/src/utils/version-utils.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getVitestDependenciesVersionsToInstall = getVitestDependenciesVersionsToInstall;
+exports.isVitestV1 = isVitestV1;
+exports.isVitestV2 = isVitestV2;
+exports.getInstalledVitestVersion = getInstalledVitestVersion;
+exports.getInstalledViteVersion = getInstalledViteVersion;
+exports.getInstalledViteMajorVersion = getInstalledViteMajorVersion;
+exports.getInstalledVitestVersionFromGraph = getInstalledVitestVersionFromGraph;
+const devkit_1 = require("@nx/devkit");
+const semver_1 = require("semver");
+const versions_1 = require("./versions");
+async function getVitestDependenciesVersionsToInstall(tree) {
+    if (await isVitestV1(tree)) {
+        return {
+            vitest: versions_1.vitestV1Version,
+            vitestUi: versions_1.vitestV1Version,
+            vitestCoverageV8: versions_1.vitestV1CoverageV8Version,
+            vitestCoverageIstanbul: versions_1.vitestV1CoverageIstanbulVersion,
+        };
+    }
+    else if (await isVitestV2(tree)) {
+        return {
+            vitest: versions_1.vitestV2Version,
+            vitestUi: versions_1.vitestV2Version,
+            vitestCoverageV8: versions_1.vitestV2CoverageV8Version,
+            vitestCoverageIstanbul: versions_1.vitestV2CoverageIstanbulVersion,
+        };
+    }
+    else {
+        // Default to latest (v3)
+        return {
+            vitest: versions_1.vitestVersion,
+            vitestUi: versions_1.vitestVersion,
+            vitestCoverageV8: versions_1.vitestCoverageV8Version,
+            vitestCoverageIstanbul: versions_1.vitestCoverageIstanbulVersion,
+        };
+    }
+}
+async function isVitestV1(tree) {
+    let installedVitestVersion = await getInstalledVitestVersionFromGraph();
+    if (!installedVitestVersion) {
+        installedVitestVersion = getInstalledVitestVersion(tree);
+    }
+    return (0, semver_1.major)(installedVitestVersion) === 1;
+}
+async function isVitestV2(tree) {
+    let installedVitestVersion = await getInstalledVitestVersionFromGraph();
+    if (!installedVitestVersion) {
+        installedVitestVersion = getInstalledVitestVersion(tree);
+    }
+    return (0, semver_1.major)(installedVitestVersion) === 2;
+}
+function getInstalledVitestVersion(tree) {
+    const installedVitestVersion = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, 'vitest');
+    if (!installedVitestVersion ||
+        installedVitestVersion === 'latest' ||
+        installedVitestVersion === 'beta') {
+        return (0, semver_1.clean)(versions_1.vitestVersion) ?? (0, semver_1.coerce)(versions_1.vitestVersion).version;
+    }
+    return ((0, semver_1.clean)(installedVitestVersion) ?? (0, semver_1.coerce)(installedVitestVersion).version);
+}
+function getInstalledViteVersion(tree) {
+    const installedViteVersion = (0, devkit_1.getDependencyVersionFromPackageJson)(tree, 'vite');
+    if (!installedViteVersion ||
+        installedViteVersion === 'latest' ||
+        installedViteVersion === 'beta') {
+        return (0, semver_1.clean)(versions_1.vitestVersion) ?? (0, semver_1.coerce)(versions_1.vitestVersion).version;
+    }
+    return (0, semver_1.clean)(installedViteVersion) ?? (0, semver_1.coerce)(installedViteVersion).version;
+}
+function getInstalledViteMajorVersion(tree) {
+    const installedViteVersion = getInstalledViteVersion(tree);
+    if (!installedViteVersion) {
+        return;
+    }
+    const installedMajor = (0, semver_1.major)(installedViteVersion);
+    if (installedMajor < 5 || installedMajor > 7) {
+        return undefined;
+    }
+    return installedMajor;
+}
+async function getInstalledVitestVersionFromGraph() {
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    const vitestDep = graph.externalNodes?.['npm:vitest'];
+    if (!vitestDep) {
+        return undefined;
+    }
+    return ((0, semver_1.clean)(vitestDep.data.version) ?? (0, semver_1.coerce)(vitestDep.data.version).version);
+}

package/src/utils/versions.d.ts

@@ -0,0 +1,23 @@
+export declare const nxVersion: any;
+export declare const viteVersion = "^7.0.0";
+export declare const viteV6Version = "^6.0.0";
+export declare const viteV5Version = "^5.0.0";
+export declare const vitestVersion = "^3.0.0";
+export declare const vitestV2Version = "^2.1.8";
+export declare const vitestV1Version = "^1.3.1";
+export declare const vitePluginReactVersion = "^4.2.0";
+export declare const vitePluginReactSwcVersion = "^3.5.0";
+export declare const jsdomVersion = "~22.1.0";
+export declare const vitePluginDtsVersion = "~4.5.0";
+export declare const ajvVersion = "^8.0.0";
+export declare const happyDomVersion = "~9.20.3";
+export declare const edgeRuntimeVmVersion = "~3.0.2";
+export declare const jitiVersion = "2.4.2";
+export declare const analogVitestAngular = "~1.19.1";
+export declare const vitestCoverageV8Version = "^3.0.5";
+export declare const vitestV2CoverageV8Version = "^2.1.8";
+export declare const vitestV1CoverageV8Version = "^1.0.4";
+export declare const vitestCoverageIstanbulVersion = "^3.0.5";
+export declare const vitestV2CoverageIstanbulVersion = "^2.1.8";
+export declare const vitestV1CoverageIstanbulVersion = "^1.0.4";
+//# sourceMappingURL=versions.d.ts.map

package/src/utils/versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"versions.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/utils/versions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,SAAS,KAAwC,CAAC;AAE/D,eAAO,MAAM,WAAW,WAAW,CAAC;AACpC,eAAO,MAAM,aAAa,WAAW,CAAC;AACtC,eAAO,MAAM,aAAa,WAAW,CAAC;AACtC,eAAO,MAAM,aAAa,WAAW,CAAC;AACtC,eAAO,MAAM,eAAe,WAAW,CAAC;AACxC,eAAO,MAAM,eAAe,WAAW,CAAC;AACxC,eAAO,MAAM,sBAAsB,WAAW,CAAC;AAC/C,eAAO,MAAM,yBAAyB,WAAW,CAAC;AAClD,eAAO,MAAM,YAAY,YAAY,CAAC;AACtC,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAC7C,eAAO,MAAM,UAAU,WAAW,CAAC;AACnC,eAAO,MAAM,eAAe,YAAY,CAAC;AACzC,eAAO,MAAM,oBAAoB,WAAW,CAAC;AAC7C,eAAO,MAAM,WAAW,UAAU,CAAC;AAEnC,eAAO,MAAM,mBAAmB,YAAY,CAAC;AAG7C,eAAO,MAAM,uBAAuB,WAAW,CAAC;AAChD,eAAO,MAAM,yBAAyB,WAAW,CAAC;AAClD,eAAO,MAAM,yBAAyB,WAAW,CAAC;AAClD,eAAO,MAAM,6BAA6B,WAAW,CAAC;AACtD,eAAO,MAAM,+BAA+B,WAAW,CAAC;AACxD,eAAO,MAAM,+BAA+B,WAAW,CAAC"}

package/src/utils/versions.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vitestV1CoverageIstanbulVersion = exports.vitestV2CoverageIstanbulVersion = exports.vitestCoverageIstanbulVersion = exports.vitestV1CoverageV8Version = exports.vitestV2CoverageV8Version = exports.vitestCoverageV8Version = exports.analogVitestAngular = exports.jitiVersion = exports.edgeRuntimeVmVersion = exports.happyDomVersion = exports.ajvVersion = exports.vitePluginDtsVersion = exports.jsdomVersion = exports.vitePluginReactSwcVersion = exports.vitePluginReactVersion = exports.vitestV1Version = exports.vitestV2Version = exports.vitestVersion = exports.viteV5Version = exports.viteV6Version = exports.viteVersion = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+exports.viteVersion = '^7.0.0';
+exports.viteV6Version = '^6.0.0';
+exports.viteV5Version = '^5.0.0';
+exports.vitestVersion = '^3.0.0';
+exports.vitestV2Version = '^2.1.8';
+exports.vitestV1Version = '^1.3.1';
+exports.vitePluginReactVersion = '^4.2.0';
+exports.vitePluginReactSwcVersion = '^3.5.0';
+exports.jsdomVersion = '~22.1.0';
+exports.vitePluginDtsVersion = '~4.5.0';
+exports.ajvVersion = '^8.0.0';
+exports.happyDomVersion = '~9.20.3';
+exports.edgeRuntimeVmVersion = '~3.0.2';
+exports.jitiVersion = '2.4.2';
+exports.analogVitestAngular = '~1.19.1';
+// Coverage providers
+exports.vitestCoverageV8Version = '^3.0.5';
+exports.vitestV2CoverageV8Version = '^2.1.8';
+exports.vitestV1CoverageV8Version = '^1.0.4';
+exports.vitestCoverageIstanbulVersion = '^3.0.5';
+exports.vitestV2CoverageIstanbulVersion = '^2.1.8';
+exports.vitestV1CoverageIstanbulVersion = '^1.0.4';

package/src/utils/vite-config-edit-utils.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import { TargetFlags } from './generator-utils';
+export declare function ensureViteConfigIsCorrect(tree: Tree, path: string, buildConfigString: string, buildConfigObject: {}, imports: string[], plugins: string[], testConfigString: string, testConfigObject: {}, cacheDir: string, projectAlreadyHasViteTargets?: TargetFlags): boolean;
+//# sourceMappingURL=vite-config-edit-utils.d.ts.map

package/src/utils/vite-config-edit-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite-config-edit-utils.d.ts","sourceRoot":"","sources":["../../../../../packages/vitest/src/utils/vite-config-edit-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoC,IAAI,EAAE,MAAM,YAAY,CAAC;AAEpE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAQhD,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,IAAI,EACV,IAAI,EAAE,MAAM,EACZ,iBAAiB,EAAE,MAAM,EACzB,iBAAiB,EAAE,EAAE,EACrB,OAAO,EAAE,MAAM,EAAE,EACjB,OAAO,EAAE,MAAM,EAAE,EACjB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,EAAE,EACpB,QAAQ,EAAE,MAAM,EAChB,4BAA4B,CAAC,EAAE,WAAW,GACzC,OAAO,CAwCT"}

package/src/utils/vite-config-edit-utils.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureViteConfigIsCorrect = ensureViteConfigIsCorrect;
+const devkit_1 = require("@nx/devkit");
+const js_1 = require("@nx/js");
+function ensureViteConfigIsCorrect(tree, path, buildConfigString, buildConfigObject, imports, plugins, testConfigString, testConfigObject, cacheDir, projectAlreadyHasViteTargets) {
+    const fileContent = tree.read(path, 'utf-8');
+    let updatedContent = undefined;
+    if (!projectAlreadyHasViteTargets?.test && testConfigString?.length) {
+        updatedContent = handleBuildOrTestNode(fileContent, testConfigString, testConfigObject, 'test');
+    }
+    if (!projectAlreadyHasViteTargets?.build && buildConfigString?.length) {
+        updatedContent = handleBuildOrTestNode(updatedContent ?? fileContent, buildConfigString, buildConfigObject, 'build');
+    }
+    updatedContent =
+        handlePluginNode(updatedContent ?? fileContent, imports, plugins) ??
+            updatedContent;
+    if (cacheDir?.length) {
+        updatedContent = handleCacheDirNode(updatedContent ?? fileContent, cacheDir);
+    }
+    if (updatedContent) {
+        tree.write(path, updatedContent);
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+function handleBuildOrTestNode(updatedFileContent, configContentString, configContentObject, name) {
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const buildOrTestNode = tsquery.query(updatedFileContent, `PropertyAssignment:has(Identifier[name="${name}"])`);
+    if (buildOrTestNode.length) {
+        return tsquery.replace(updatedFileContent, `PropertyAssignment:has(Identifier[name="${name}"])`, (node) => {
+            const existingProperties = tsquery.query(node.initializer, 'PropertyAssignment');
+            let updatedPropsString = '';
+            for (const prop of existingProperties) {
+                const propName = prop.name.getText();
+                if (!configContentObject[propName] &&
+                    propName !== 'dir' &&
+                    propName !== 'reportsDirectory' &&
+                    propName !== 'provider') {
+                    // NOTE: Watch for formatting.
+                    updatedPropsString += `    '${propName}': ${prop.initializer.getText()},\n`;
+                }
+            }
+            for (const [propName, propValue] of Object.entries(configContentObject)) {
+                // NOTE: Watch for formatting.
+                if (propName === 'coverage') {
+                    let propString = `    '${propName}': {\n`;
+                    for (const [pName, pValue] of Object.entries(propValue)) {
+                        if (pName === 'provider') {
+                            propString += `    '${pName}': ${pValue} as const,\n`;
+                        }
+                        else {
+                            propString += `    '${pName}': '${pValue}',\n`;
+                        }
+                    }
+                    propString += `}`;
+                    updatedPropsString += `${propString}\n`;
+                }
+                else if (propName === 'lib') {
+                    let propString = `    '${propName}': {\n`;
+                    for (const [pName, pValue] of Object.entries(propValue)) {
+                        if (pName === 'formats') {
+                            propString += `      '${pName}': [${pValue
+                                .map((format) => `'${format}' as const`)
+                                .join(', ')}],\n`;
+                        }
+                        else {
+                            propString += `      '${pName}': ${JSON.stringify(pValue)},\n`;
+                        }
+                    }
+                    propString += `    },`;
+                    updatedPropsString += `${propString}\n`;
+                }
+                else {
+                    updatedPropsString += `    '${propName}': ${JSON.stringify(propValue)},\n`;
+                }
+            }
+            return `${name}: {
+${updatedPropsString}  }`;
+        });
+    }
+    else {
+        const foundDefineConfig = tsquery.query(updatedFileContent, 'CallExpression:has(Identifier[name="defineConfig"])');
+        if (foundDefineConfig.length) {
+            const conditionalConfig = tsquery.query(foundDefineConfig[0], 'ArrowFunction');
+            if (conditionalConfig.length) {
+                if (name === 'build') {
+                    return transformConditionalConfig(conditionalConfig, updatedFileContent, configContentString);
+                }
+                else {
+                    // no test config in conditional config
+                    return updatedFileContent;
+                }
+            }
+            else {
+                const propertyAssignments = tsquery.query(foundDefineConfig[0], 'PropertyAssignment');
+                if (propertyAssignments.length) {
+                    return (0, devkit_1.applyChangesToString)(updatedFileContent, [
+                        {
+                            type: devkit_1.ChangeType.Insert,
+                            index: propertyAssignments[0].getStart(),
+                            text: configContentString,
+                        },
+                    ]);
+                }
+                else {
+                    return (0, devkit_1.applyChangesToString)(updatedFileContent, [
+                        {
+                            type: devkit_1.ChangeType.Insert,
+                            index: foundDefineConfig[0].getStart() + 14,
+                            text: configContentString,
+                        },
+                    ]);
+                }
+            }
+        }
+        else {
+            // build config does not exist and defineConfig is not used
+            // could also potentially be invalid syntax, so try-catch
+            try {
+                const defaultExport = tsquery.query(updatedFileContent, 'ExportAssignment');
+                const found = tsquery.query(defaultExport?.[0], 'ObjectLiteralExpression');
+                const startOfObject = found?.[0].getStart();
+                return (0, devkit_1.applyChangesToString)(updatedFileContent, [
+                    {
+                        type: devkit_1.ChangeType.Insert,
+                        index: startOfObject + 1,
+                        text: configContentString,
+                    },
+                ]);
+            }
+            catch {
+                return updatedFileContent;
+            }
+        }
+    }
+}
+function transformCurrentBuildObject(index, returnStatements, appFileContent, buildConfigObject) {
+    if (!returnStatements?.[index]) {
+        return undefined;
+    }
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const currentBuildObject = tsquery
+        .query(returnStatements[index], 'ObjectLiteralExpression')?.[0]
+        .getText();
+    const currentBuildObjectStart = returnStatements[index].getStart();
+    const currentBuildObjectEnd = returnStatements[index].getEnd();
+    const newReturnObject = tsquery.replace(returnStatements[index].getText(), 'ObjectLiteralExpression', (_node) => {
+        return `{
+        ...${currentBuildObject},
+        ...${JSON.stringify(buildConfigObject)}
+      }`;
+    });
+    const newContents = (0, devkit_1.applyChangesToString)(appFileContent, [
+        {
+            type: devkit_1.ChangeType.Delete,
+            start: currentBuildObjectStart,
+            length: currentBuildObjectEnd - currentBuildObjectStart,
+        },
+        {
+            type: devkit_1.ChangeType.Insert,
+            index: currentBuildObjectStart,
+            text: newReturnObject,
+        },
+    ]);
+    return newContents;
+}
+function transformConditionalConfig(conditionalConfig, appFileContent, buildConfigObject) {
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const { SyntaxKind } = require('typescript');
+    const functionBlock = tsquery.query(conditionalConfig[0], 'Block');
+    const ifStatement = tsquery.query(functionBlock?.[0], 'IfStatement');
+    const binaryExpressions = tsquery.query(ifStatement?.[0], 'BinaryExpression');
+    const buildExists = binaryExpressions?.find((binaryExpression) => binaryExpression.getText() === `command === 'build'`);
+    const buildExistsExpressionIndex = binaryExpressions?.findIndex((binaryExpression) => binaryExpression.getText() === `command === 'build'`);
+    const serveExists = binaryExpressions?.find((binaryExpression) => binaryExpression.getText() === `command === 'serve'`);
+    const elseKeywordExists = (0, js_1.findNodes)(ifStatement?.[0], SyntaxKind.ElseKeyword);
+    const returnStatements = tsquery.query(ifStatement[0], 'ReturnStatement');
+    if (!buildExists) {
+        if (serveExists && elseKeywordExists) {
+            // build options live inside the else block
+            return (transformCurrentBuildObject(returnStatements?.length - 1, returnStatements, appFileContent, buildConfigObject) ?? appFileContent);
+        }
+        else {
+            // no build options exist yet
+            const functionBlockStart = functionBlock?.[0].getStart();
+            const newContents = (0, devkit_1.applyChangesToString)(appFileContent, [
+                {
+                    type: devkit_1.ChangeType.Insert,
+                    index: functionBlockStart + 1,
+                    text: `
+            if (command === 'build') {
+              return ${JSON.stringify(buildConfigObject)}
+            }
+            `,
+                },
+            ]);
+            return newContents;
+        }
+    }
+    else {
+        // build already exists
+        // it will be the return statement which lives
+        // at the buildExistsExpressionIndex
+        return (transformCurrentBuildObject(buildExistsExpressionIndex, returnStatements, appFileContent, buildConfigObject) ?? appFileContent);
+    }
+}
+function handlePluginNode(appFileContent, imports, plugins) {
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const file = tsquery.ast(appFileContent);
+    const pluginsNode = tsquery.query(file, 'PropertyAssignment:has(Identifier[name="plugins"])');
+    let writeFile = false;
+    if (pluginsNode.length) {
+        appFileContent = tsquery.replace(file.getText(), 'PropertyAssignment:has(Identifier[name="plugins"])', (node) => {
+            const found = tsquery.query(node, 'ArrayLiteralExpression');
+            let updatedPluginsString = '';
+            const existingPluginNodes = found?.[0].elements ?? [];
+            for (const plugin of existingPluginNodes) {
+                updatedPluginsString += `${plugin.getText()}, `;
+            }
+            for (const plugin of plugins) {
+                if (!existingPluginNodes?.some((node) => node.getText().includes(plugin))) {
+                    updatedPluginsString += `${plugin}, `;
+                }
+            }
+            return `plugins: [${updatedPluginsString}]`;
+        });
+        writeFile = true;
+    }
+    else {
+        // Plugins node does not exist yet
+        // So make one from scratch
+        const foundDefineConfig = tsquery.query(file, 'CallExpression:has(Identifier[name="defineConfig"])');
+        if (foundDefineConfig.length) {
+            const conditionalConfig = tsquery.query(foundDefineConfig[0], 'ArrowFunction');
+            if (conditionalConfig.length) {
+                // We are NOT transforming the conditional config
+                // with plugins
+                writeFile = false;
+            }
+            else {
+                const propertyAssignments = tsquery.query(foundDefineConfig[0], 'PropertyAssignment');
+                if (propertyAssignments.length) {
+                    appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
+                        {
+                            type: devkit_1.ChangeType.Insert,
+                            index: propertyAssignments[0].getStart(),
+                            text: `plugins: [${plugins.join(', ')}],`,
+                        },
+                    ]);
+                    writeFile = true;
+                }
+                else {
+                    appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
+                        {
+                            type: devkit_1.ChangeType.Insert,
+                            index: foundDefineConfig[0].getStart() + 14,
+                            text: `plugins: [${plugins.join(', ')}],`,
+                        },
+                    ]);
+                    writeFile = true;
+                }
+            }
+        }
+        else {
+            // Plugins option does not exist and defineConfig is not used
+            // could also potentially be invalid syntax, so try-catch
+            try {
+                const defaultExport = tsquery.query(file, 'ExportAssignment');
+                const found = tsquery?.query(defaultExport?.[0], 'ObjectLiteralExpression');
+                const startOfObject = found?.[0].getStart();
+                appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
+                    {
+                        type: devkit_1.ChangeType.Insert,
+                        index: startOfObject + 1,
+                        text: `plugins: [${plugins.join(', ')}],`,
+                    },
+                ]);
+                writeFile = true;
+            }
+            catch {
+                writeFile = false;
+            }
+        }
+    }
+    if (writeFile) {
+        const filteredImports = filterImport(appFileContent, imports);
+        return filteredImports.join(';\n') + '\n' + appFileContent;
+    }
+}
+function filterImport(appFileContent, imports) {
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const file = tsquery.ast(appFileContent);
+    const importNodes = tsquery.query(file, ':matches(ImportDeclaration, VariableStatement)');
+    const importsArrayExisting = importNodes?.map((node) => {
+        return node.getText().slice(0, -1);
+    });
+    return imports.filter((importString) => {
+        return !importsArrayExisting?.includes(importString);
+    });
+}
+function handleCacheDirNode(appFileContent, cacheDir) {
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const file = tsquery.ast(appFileContent);
+    const cacheDirNode = tsquery.query(file, 'PropertyAssignment:has(Identifier[name="cacheDir"])');
+    if (!cacheDirNode?.length || cacheDirNode?.length === 0) {
+        // cacheDir node does not exist yet
+        // So make one from scratch
+        const foundDefineConfig = tsquery.query(file, 'CallExpression:has(Identifier[name="defineConfig"])');
+        if (foundDefineConfig.length) {
+            const conditionalConfig = tsquery.query(foundDefineConfig[0], 'ArrowFunction');
+            if (conditionalConfig.length) {
+                // We are NOT transforming the conditional config
+                // with cacheDir
+            }
+            else {
+                const propertyAssignments = tsquery.query(foundDefineConfig[0], 'PropertyAssignment');
+                if (propertyAssignments.length) {
+                    appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
+                        {
+                            type: devkit_1.ChangeType.Insert,
+                            index: propertyAssignments[0].getStart(),
+                            text: cacheDir,
+                        },
+                    ]);
+                }
+                else {
+                    appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
+                        {
+                            type: devkit_1.ChangeType.Insert,
+                            index: foundDefineConfig[0].getStart() + 14,
+                            text: cacheDir,
+                        },
+                    ]);
+                }
+            }
+        }
+        else {
+            // cacheDir option does not exist and defineConfig is not used
+            // could also potentially be invalid syntax, so try-catch
+            try {
+                const defaultExport = tsquery.query(file, 'ExportAssignment');
+                const found = tsquery?.query(defaultExport?.[0], 'ObjectLiteralExpression');
+                const startOfObject = found?.[0].getStart();
+                appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
+                    {
+                        type: devkit_1.ChangeType.Insert,
+                        index: startOfObject + 1,
+                        text: cacheDir,
+                    },
+                ]);
+            }
+            catch { }
+        }
+    }
+    return appFileContent;
+}