@nx/vite 24.0.0-beta.1 → 24.0.0-beta.3

package/dist/executors.d.ts

@@ -1,6 +1,3 @@
 export { type ViteBuildExecutorOptions } from './src/executors/build/schema';
-export { viteBuildExecutor } from './src/executors/build/build.impl';
 export { type ViteDevServerExecutorOptions } from './src/executors/dev-server/schema';
-export { viteDevServerExecutor } from './src/executors/dev-server/dev-server.impl';
 export { type VitePreviewServerExecutorOptions } from './src/executors/preview-server/schema';
-export { vitePreviewServerExecutor } from './src/executors/preview-server/preview-server.impl';

package/dist/executors.js

@@ -1,9 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.vitePreviewServerExecutor = exports.viteDevServerExecutor = exports.viteBuildExecutor = void 0;
-var build_impl_1 = require("./src/executors/build/build.impl");
-Object.defineProperty(exports, "viteBuildExecutor", { enumerable: true, get: function () { return build_impl_1.viteBuildExecutor; } });
-var dev_server_impl_1 = require("./src/executors/dev-server/dev-server.impl");
-Object.defineProperty(exports, "viteDevServerExecutor", { enumerable: true, get: function () { return dev_server_impl_1.viteDevServerExecutor; } });
-var preview_server_impl_1 = require("./src/executors/preview-server/preview-server.impl");
-Object.defineProperty(exports, "vitePreviewServerExecutor", { enumerable: true, get: function () { return preview_server_impl_1.vitePreviewServerExecutor; } });

package/dist/plugins/nx-copy-assets.plugin.d.ts

@@ -1,9 +1,8 @@
 import type { Plugin } from 'vite';
-import { AssetGlob } from '@nx/js/internal';
+import type { AssetGlob } from '@nx/js/internal';
 /**
- * @deprecated Will be removed in Nx v24. Use Vite's native `publicDir` option
- * for static assets, or the `vite-plugin-static-copy` package for anything
- * that needs glob-based copying. See
- * https://nx.dev/docs/technologies/build-tools/vite/configure-vite for details.
+ * @deprecated Use Vite's `publicDir` option or
+ * `vite-plugin-static-copy`.
+ * This inert stub will be removed in Nx v25.
  */
 export declare function nxCopyAssetsPlugin(_assets: (string | AssetGlob)[]): Plugin;

package/dist/plugins/nx-copy-assets.plugin.js

@@ -1,58 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nxCopyAssetsPlugin = nxCopyAssetsPlugin;
-const node_path_1 = require("node:path");
-const devkit_1 = require("@nx/devkit");
-const internal_1 = require("@nx/js/internal");
 const deprecation_1 = require("../src/utils/deprecation");
+// TODO(v25): remove the inert config-helper stubs in this file.
 /**
- * @deprecated Will be removed in Nx v24. Use Vite's native `publicDir` option
- * for static assets, or the `vite-plugin-static-copy` package for anything
- * that needs glob-based copying. See
- * https://nx.dev/docs/technologies/build-tools/vite/configure-vite for details.
+ * @deprecated Use Vite's `publicDir` option or
+ * `vite-plugin-static-copy`.
+ * This inert stub will be removed in Nx v25.
  */
 function nxCopyAssetsPlugin(_assets) {
     (0, deprecation_1.warnNxCopyAssetsPluginDeprecation)();
-    let config;
-    let handler;
-    let dispose;
-    if (global.NX_GRAPH_CREATION)
-        return;
-    return {
-        name: 'nx-copy-assets-plugin',
-        configResolved(_config) {
-            config = _config;
-        },
-        async buildStart() {
-            const relativeProjectRoot = (0, node_path_1.relative)(devkit_1.workspaceRoot, config.root);
-            const assets = _assets.map((a) => {
-                if (typeof a === 'string') {
-                    return (0, devkit_1.joinPathFragments)(relativeProjectRoot, a);
-                }
-                else {
-                    return {
-                        ...a,
-                        input: (0, devkit_1.joinPathFragments)(relativeProjectRoot, a.input),
-                    };
-                }
-            });
-            handler = new internal_1.CopyAssetsHandler({
-                rootDir: devkit_1.workspaceRoot,
-                projectDir: config.root,
-                outputDir: config.build.outDir.startsWith(config.root)
-                    ? config.build.outDir
-                    : (0, node_path_1.join)(config.root, config.build.outDir),
-                assets,
-            });
-            if (this.meta.watchMode && (0, devkit_1.isDaemonEnabled)()) {
-                dispose = await handler.watchAndProcessOnAssetChange();
-            }
-        },
-        async writeBundle() {
-            await handler.processAllAssetsOnce();
-        },
-        async closeWatcher() {
-            dispose == null ? void 0 : dispose();
-        },
-    };
+    return { name: 'nx-copy-assets-plugin' };
 }

package/dist/plugins/nx-tsconfig-paths.plugin.d.ts

@@ -1,4 +1,4 @@
-import { Plugin } from 'vite';
+import type { Plugin } from 'vite';
 export interface nxViteTsPathsOptions {
     /**
      * Enable debug logging
@@ -36,10 +36,8 @@ export interface nxViteTsPathsOptions {
     testTarget?: string;
 }
 /**
- * @deprecated Will be removed in Nx v24. Replace with `tsconfigPaths()` from
- * the `vite-tsconfig-paths` package. The inferred `@nx/vite/plugin` already
- * ensures projects extend the workspace base tsconfig, so the community
- * plugin handles monorepo path resolution end-to-end. See
- * https://nx.dev/docs/technologies/build-tools/vite/configure-vite for details.
+ * @deprecated Use Vite's `resolve.tsconfigPaths` (Vite 8+) or
+ * `tsconfigPaths()` from `vite-tsconfig-paths`.
+ * This inert stub will be removed in Nx v25.
  */
-export declare function nxViteTsPaths(options?: nxViteTsPathsOptions): Plugin;
+export declare function nxViteTsPaths(_options?: nxViteTsPathsOptions): Plugin;

package/dist/plugins/nx-tsconfig-paths.plugin.js

@@ -1,255 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.nxViteTsPaths = nxViteTsPaths;
-const devkit_1 = require("@nx/devkit");
-const internal_1 = require("@nx/js/internal");
-const js_1 = require("@nx/js");
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const tsconfig_paths_1 = require("tsconfig-paths");
 const deprecation_1 = require("../src/utils/deprecation");
-const nx_tsconfig_paths_load_file_1 = require("../src/utils/nx-tsconfig-paths-load-file");
-const options_utils_1 = require("../src/utils/options-utils");
-const nx_vite_build_coordination_plugin_1 = require("./nx-vite-build-coordination.plugin");
+// TODO(v25): remove the inert config-helper stubs in this file.
 /**
- * @deprecated Will be removed in Nx v24. Replace with `tsconfigPaths()` from
- * the `vite-tsconfig-paths` package. The inferred `@nx/vite/plugin` already
- * ensures projects extend the workspace base tsconfig, so the community
- * plugin handles monorepo path resolution end-to-end. See
- * https://nx.dev/docs/technologies/build-tools/vite/configure-vite for details.
+ * @deprecated Use Vite's `resolve.tsconfigPaths` (Vite 8+) or
+ * `tsconfigPaths()` from `vite-tsconfig-paths`.
+ * This inert stub will be removed in Nx v25.
  */
-function nxViteTsPaths(options = {}) {
+function nxViteTsPaths(_options = {}) {
     (0, deprecation_1.warnNxViteTsPathsDeprecation)();
-    let foundTsConfigPath;
-    let tsConfigPathsLoaded = false;
-    let matchTsPathEsm;
-    let matchTsPathEsmExact;
-    let matchTsPathFallback;
-    let matchTsPathFallbackExact;
-    let tsConfigPathsEsm;
-    let tsConfigPathsFallback;
-    options.extensions ??= [
-        '.ts',
-        '.tsx',
-        '.js',
-        '.jsx',
-        '.json',
-        '.mts',
-        '.mjs',
-        '.cts',
-        '.cjs',
-        '.css',
-        '.scss',
-        '.less',
-    ];
-    options.mainFields ??= [['exports', '.', 'import'], 'module', 'main'];
-    options.buildTarget ??= 'build';
-    options.testTarget ??= 'test';
-    options.buildLibsFromSource ??= true;
-    let projectRoot = '';
-    let projectRootFromWorkspaceRoot;
-    return {
-        name: 'nx-vite-ts-paths',
-        // Ensure the resolveId aspect of the plugin is called before vite's internal resolver
-        // Otherwise, issues can arise with Yarn Workspaces and Pnpm Workspaces
-        enforce: 'pre',
-        async configResolved(config) {
-            projectRoot = config.root;
-            projectRootFromWorkspaceRoot = (0, node_path_1.relative)(devkit_1.workspaceRoot, projectRoot);
-            tsConfigPathsLoaded = false;
-            foundTsConfigPath = getTsConfig(process.env.NX_TSCONFIG_PATH ??
-                (0, node_path_1.join)(devkit_1.workspaceRoot, 'tmp', projectRootFromWorkspaceRoot, process.env.NX_TASK_TARGET_TARGET ?? 'build', 'tsconfig.generated.json'));
-            if (!foundTsConfigPath)
-                return;
-            if (!options.buildLibsFromSource && !global.NX_GRAPH_CREATION) {
-                const projectGraph = await (0, devkit_1.createProjectGraphAsync)({
-                    exitOnError: false,
-                    resetDaemonClient: true,
-                });
-                // When using incremental building and the serve target is called
-                // we need to get the deps for the 'build' target instead.
-                const depsBuildTarget = process.env.NX_TASK_TARGET_TARGET === 'serve' ||
-                    process.env.NX_TASK_TARGET_TARGET === options.testTarget
-                    ? options.buildTarget
-                    : process.env.NX_TASK_TARGET_TARGET;
-                const { dependencies } = (0, internal_1.calculateProjectBuildableDependencies)(undefined, projectGraph, devkit_1.workspaceRoot, process.env.NX_TASK_TARGET_PROJECT, depsBuildTarget, process.env.NX_TASK_TARGET_CONFIGURATION);
-                if (process.env.NX_GENERATED_TSCONFIG_PATH) {
-                    // This is needed for vitest browser mode because it runs two vite dev servers
-                    // so we want to reuse the same tsconfig file for both servers
-                    foundTsConfigPath = process.env.NX_GENERATED_TSCONFIG_PATH;
-                }
-                else {
-                    // This tsconfig is used via the Vite ts paths plugin.
-                    // It can be also used by other user-defined Vite plugins (e.g. for creating type declaration files).
-                    foundTsConfigPath = (0, internal_1.createTmpTsConfig)(foundTsConfigPath, devkit_1.workspaceRoot, (0, node_path_1.relative)(devkit_1.workspaceRoot, projectRoot), dependencies, true);
-                    process.env.NX_GENERATED_TSCONFIG_PATH = foundTsConfigPath;
-                    if (config.command === 'serve') {
-                        const buildableLibraryDependencies = dependencies
-                            .filter((dep) => dep.node.type === 'lib')
-                            .map((dep) => dep.node.name)
-                            .join(',');
-                        const buildCommand = `${(0, devkit_1.getPackageManagerCommand)().exec} nx run-many --target=${depsBuildTarget} --projects=${buildableLibraryDependencies}`;
-                        config.plugins.push((0, nx_vite_build_coordination_plugin_1.nxViteBuildCoordinationPlugin)({ buildCommand }));
-                    }
-                }
-            }
-            // Graph construction resolves every config and never a module, so the
-            // parsing waits for the first `resolveId` there.
-            if (!global.NX_GRAPH_CREATION)
-                loadTsConfigPaths();
-        },
-        resolveId(importPath) {
-            // Let other resolvers handle this path.
-            if (!foundTsConfigPath)
-                return null;
-            // Skip absolute and root-relative paths — these are filesystem paths,
-            // not TypeScript import specifiers. In Vite, `/foo` is a project-root-
-            // relative URL and must be resolved by Vite's built-in resolver, not
-            // by tsconfig path mapping (which would incorrectly use baseUrl).
-            if (importPath.startsWith('/'))
-                return null;
-            if (!tsConfigPathsLoaded)
-                loadTsConfigPaths();
-            let resolvedFile;
-            try {
-                resolvedFile =
-                    matchTsPathEsmExact(importPath) ??
-                        loadFileFromExactAlias(tsConfigPathsEsm, importPath) ??
-                        matchTsPathEsm(importPath);
-            }
-            catch (e) {
-                logIt('Using fallback path matching.');
-                resolvedFile =
-                    matchTsPathFallbackExact?.(importPath) ??
-                        loadFileFromExactAlias(tsConfigPathsFallback, importPath) ??
-                        matchTsPathFallback?.(importPath);
-            }
-            if (!resolvedFile || !(0, node_fs_1.existsSync)(resolvedFile)) {
-                if (tsConfigPathsEsm || tsConfigPathsFallback) {
-                    logIt(`Unable to resolve ${importPath} with tsconfig paths. Using fallback file matching.`);
-                    // The tsconfig the project builds with need not extend the
-                    // root-level one, so the second pass covers aliases only the
-                    // root-level config declares.
-                    resolvedFile =
-                        loadFileFromPathsWithLogging(tsConfigPathsEsm, importPath) ||
-                            loadFileFromPathsWithLogging(tsConfigPathsFallback, importPath);
-                }
-                else {
-                    logIt(`Unable to resolve ${importPath} with tsconfig paths`);
-                }
-            }
-            logIt(`Resolved ${importPath} to ${resolvedFile}`);
-            // Returning null defers to other resolveId functions and eventually the default resolution behavior
-            // https://rollupjs.org/plugin-development/#resolveid
-            return resolvedFile || null;
-        },
-        async writeBundle(options) {
-            if ((0, internal_1.isUsingTsSolutionSetup)())
-                return;
-            const outDir = options.dir || 'dist';
-            const src = (0, node_path_1.resolve)(projectRoot, 'package.json');
-            const dest = (0, node_path_1.join)(outDir, 'package.json');
-            if ((0, node_fs_1.existsSync)(src) && !(0, node_fs_1.existsSync)(dest)) {
-                try {
-                    (0, node_fs_1.copyFileSync)(src, dest);
-                }
-                catch (err) {
-                    console.error('Error copying package.json:', err);
-                }
-            }
-        },
-    };
-    function loadTsConfigPaths() {
-        const parsed = (0, tsconfig_paths_1.loadConfig)(foundTsConfigPath);
-        logIt('first parsed tsconfig: ', parsed);
-        if (parsed.resultType === 'failed') {
-            throw new Error(`Failed loading tsconfig at ${foundTsConfigPath}`);
-        }
-        // `loadConfig` derives `absoluteBaseUrl` from the leaf tsconfig, but
-        // `paths` resolve against the config that declared them.
-        const pathsBaseUrl = (0, js_1.resolvePathsBaseUrl)(foundTsConfigPath);
-        tsConfigPathsEsm = { ...parsed, absoluteBaseUrl: pathsBaseUrl };
-        matchTsPathEsm = (0, tsconfig_paths_1.createMatchPath)(pathsBaseUrl, parsed.paths, options.mainFields);
-        matchTsPathEsmExact = createExactMatchPath(pathsBaseUrl, parsed.paths, options.mainFields);
-        const rootLevelTsConfig = getTsConfig((0, node_path_1.join)(devkit_1.workspaceRoot, 'tsconfig.base.json'));
-        // A workspace may have no root-level tsconfig at all. Passing no path to
-        // `loadConfig` makes it search upwards from the cwd instead, which finds
-        // an unrelated tsconfig whose directory is not this workspace.
-        if (rootLevelTsConfig) {
-            const rootLevelParsed = (0, tsconfig_paths_1.loadConfig)(rootLevelTsConfig);
-            logIt('fallback parsed tsconfig: ', rootLevelParsed);
-            if (rootLevelParsed.resultType === 'success') {
-                const rootLevelPathsBaseUrl = (0, js_1.resolvePathsBaseUrl)(rootLevelTsConfig);
-                tsConfigPathsFallback = {
-                    ...rootLevelParsed,
-                    absoluteBaseUrl: rootLevelPathsBaseUrl,
-                };
-                matchTsPathFallback = (0, tsconfig_paths_1.createMatchPath)(rootLevelPathsBaseUrl, rootLevelParsed.paths, ['main', 'module']);
-                matchTsPathFallbackExact = createExactMatchPath(rootLevelPathsBaseUrl, rootLevelParsed.paths, ['main', 'module']);
-            }
-        }
-        tsConfigPathsLoaded = true;
-    }
-    function getTsConfig(preferredTsConfigPath) {
-        const projectTsConfigPath = (0, options_utils_1.getProjectTsConfigPath)(projectRootFromWorkspaceRoot);
-        return [
-            (0, node_path_1.resolve)(preferredTsConfigPath),
-            projectTsConfigPath
-                ? (0, node_path_1.resolve)((0, node_path_1.join)(devkit_1.workspaceRoot, projectTsConfigPath))
-                : null,
-            (0, node_path_1.resolve)((0, node_path_1.join)(devkit_1.workspaceRoot, 'tsconfig.base.json')),
-            (0, node_path_1.resolve)((0, node_path_1.join)(devkit_1.workspaceRoot, 'tsconfig.json')),
-            (0, node_path_1.resolve)((0, node_path_1.join)(devkit_1.workspaceRoot, 'jsconfig.json')),
-        ]
-            .filter(Boolean)
-            .find((tsPath) => {
-            if ((0, node_fs_1.existsSync)(tsPath)) {
-                logIt('Found tsconfig at', tsPath);
-                return tsPath;
-            }
-        });
-    }
-    function logIt(...msg) {
-        if (process.env.NX_VERBOSE_LOGGING === 'true' && options?.debug !== false) {
-            console.debug('\n[Nx Vite TsPaths]', ...msg);
-        }
-    }
-    /**
-     * Resolves an import that names an alias exactly, through that alias alone.
-     *
-     * The matcher above already covers a mapped path that names a file or a
-     * package entry, so this is what finds an `index` or supplies the extension.
-     * Restricting it to the one alias keeps it from answering with a wildcard,
-     * which is the last resort's job.
-     */
-    function loadFileFromExactAlias(tsconfig, importPath) {
-        // An own-property check, because an import named after an `Object`
-        // prototype member (`constructor`, `toString`) would otherwise read the
-        // inherited value and hand a non-array on to the resolver.
-        if (!tsconfig || !Object.hasOwn(tsconfig.paths, importPath)) {
-            return undefined;
-        }
-        return (0, nx_tsconfig_paths_load_file_1.loadFileFromPaths)({ ...tsconfig, paths: { [importPath]: tsconfig.paths[importPath] } }, importPath, options.extensions);
-    }
-    function loadFileFromPathsWithLogging(tsconfig, importPath) {
-        // The root-level tsconfig is optional: a workspace without one leaves
-        // `tsConfigPathsFallback` unset, and the import has to defer to Vite.
-        if (!tsconfig)
-            return undefined;
-        logIt(`Trying to resolve file from config in ${tsconfig.configFileAbsolutePath}`);
-        return (0, nx_tsconfig_paths_load_file_1.loadFileFromPaths)(tsconfig, importPath, options.extensions);
-    }
-}
-/**
- * Matcher over the non-wildcard aliases alone, to run before the full one.
- *
- * `tsconfig-paths` ranks an alias by the length of the text before its `*`,
- * counting one without a `*` as zero, so an exact alias sorts no higher than
- * any wildcard. TypeScript matches an exact alias first.
- */
-function createExactMatchPath(absoluteBaseUrl, paths, mainFields) {
-    const exactPaths = Object.fromEntries(Object.entries(paths).filter(([alias]) => !alias.includes('*')));
-    // The match-all `*` entry would resolve any import against `baseUrl` before
-    // the wildcard aliases of the full matcher get their turn.
-    return (0, tsconfig_paths_1.createMatchPath)(absoluteBaseUrl, exactPaths, mainFields, false);
+    return { name: 'nx-vite-ts-paths' };
 }

package/dist/src/generators/configuration/configuration.js

@@ -9,16 +9,12 @@ const internal_1 = require("@nx/js/internal");
 const posix_1 = require("node:path/posix");
 const ensure_dependencies_1 = require("../../utils/ensure-dependencies");
 const assert_supported_vite_version_1 = require("../../utils/assert-supported-vite-version");
-const deprecation_1 = require("../../utils/deprecation");
 const generator_utils_1 = require("../../utils/generator-utils");
 const versions_1 = require("../../utils/versions");
 const init_1 = tslib_1.__importDefault(require("../init/init"));
 const convert_non_vite_1 = require("./lib/convert-non-vite");
 function viteConfigurationGenerator(host, schema) {
-    return viteConfigurationGeneratorInternal(host, {
-        addPlugin: false,
-        ...schema,
-    });
+    return viteConfigurationGeneratorInternal(host, schema);
 }
 async function viteConfigurationGeneratorInternal(tree, schema) {
     (0, assert_supported_vite_version_1.assertSupportedViteVersion)(tree);
@@ -30,11 +26,6 @@ async function viteConfigurationGeneratorInternal(tree, schema) {
     // 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';
-    /**
-     * This is for when we are converting an existing project
-     * to use the vite executors.
-     */
-    let projectAlreadyHasViteTargets = {};
     if (!schema.newProject) {
         await (0, convert_non_vite_1.convertNonVite)(tree, schema, projectRoot, projectType, targets);
     }
@@ -51,33 +42,6 @@ async function viteConfigurationGeneratorInternal(tree, schema) {
     });
     tasks.push(initTask);
     tasks.push((0, ensure_dependencies_1.ensureDependencies)(tree, schema));
-    const nxJson = (0, devkit_1.readNxJson)(tree);
-    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
-        nxJson.useInferencePlugins !== false;
-    schema.addPlugin ??= addPluginDefault;
-    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
-        ? p === '@nx/vite/plugin'
-        : p.plugin === '@nx/vite/plugin');
-    if (!hasPlugin) {
-        const willScaffoldExecutorTargets = !projectAlreadyHasViteTargets.build ||
-            (!schema.includeLib &&
-                (!projectAlreadyHasViteTargets.serve ||
-                    !projectAlreadyHasViteTargets.preview));
-        if (willScaffoldExecutorTargets) {
-            (0, deprecation_1.warnViteExecutorGenerating)();
-        }
-        if (!projectAlreadyHasViteTargets.build) {
-            (0, generator_utils_1.addBuildTarget)(tree, schema, 'build');
-        }
-        if (!schema.includeLib) {
-            if (!projectAlreadyHasViteTargets.serve) {
-                (0, generator_utils_1.addServeTarget)(tree, schema, 'serve');
-            }
-            if (!projectAlreadyHasViteTargets.preview) {
-                (0, generator_utils_1.addPreviewTarget)(tree, schema, 'preview');
-            }
-        }
-    }
     if (projectType === 'library') {
         // update tsconfig.lib.json to include vite/client
         (0, devkit_1.updateJson)(tree, (0, devkit_1.joinPathFragments)(projectRoot, 'tsconfig.lib.json'), (json) => {
@@ -113,7 +77,7 @@ async function viteConfigurationGeneratorInternal(tree, schema) {
             }, false, undefined);
         }
         else {
-            (0, generator_utils_1.createOrEditViteConfig)(tree, { ...schema, useEsmExtension: true }, false, projectAlreadyHasViteTargets);
+            (0, generator_utils_1.createOrEditViteConfig)(tree, { ...schema, useEsmExtension: true }, false);
         }
     }
     if (schema.includeVitest) {
@@ -129,7 +93,6 @@ async function viteConfigurationGeneratorInternal(tree, schema) {
             skipViteConfig: true,
             testTarget: 'test',
             skipFormat: true,
-            addPlugin: schema.addPlugin,
             compiler: schema.compiler,
             projectType,
             testEnvironment: schema.testEnvironment,

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

@@ -10,7 +10,6 @@ export interface ViteConfigurationGeneratorSchema {
   testEnvironment?: 'node' | 'jsdom' | 'happy-dom' | 'edge-runtime' | string;
   port?: number;
   // Internal options
-  addPlugin?: boolean;
   projectType?: 'application' | 'library';
   previewPort?: number;
   useViteV7?: boolean;

package/dist/src/generators/convert-to-inferred/lib/build-post-target-transformer.d.ts

@@ -3,4 +3,3 @@ export declare function buildPostTargetTransformer(target: TargetConfiguration,
     projectName: string;
     root: string;
 }, inferredTargetConfiguration: TargetConfiguration): TargetConfiguration<any>;
-export declare function moveBuildLibsFromSourceToViteConfig(tree: Tree, configPath: string): void;

package/dist/src/generators/convert-to-inferred/lib/build-post-target-transformer.js

@@ -1,11 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildPostTargetTransformer = buildPostTargetTransformer;
-exports.moveBuildLibsFromSourceToViteConfig = moveBuildLibsFromSourceToViteConfig;
 const internal_1 = require("@nx/devkit/internal");
 const devkit_1 = require("@nx/devkit");
-const tsquery_1 = require("@phenomnomnominal/tsquery");
-const posix_1 = require("path/posix");
 const utils_1 = require("./utils");
 function buildPostTargetTransformer(target, tree, projectDetails, inferredTargetConfiguration) {
     let viteConfigPath = (0, utils_1.getViteConfigPath)(tree, projectDetails.root);
@@ -16,15 +13,7 @@ function buildPostTargetTransformer(target, tree, projectDetails, inferredTarget
         for (const configurationName in target.configurations) {
             const configuration = target.configurations[configurationName];
             configValues[configurationName] = {};
-            let configurationConfigFile = viteConfigPath;
-            if (configuration.configFile) {
-                if ('buildLibsFromSource' in target.options) {
-                    configuration.buildLibsFromSource =
-                        target.options.buildLibsFromSource;
-                }
-                configurationConfigFile = configuration.configFile;
-            }
-            removePropertiesFromTargetOptions(tree, configuration, configurationConfigFile, projectDetails.root, configValues[configurationName], configuration.configFile && configuration.configFile !== viteConfigPath);
+            removePropertiesFromTargetOptions(configuration, projectDetails.root, configValues[configurationName]);
         }
         for (const configurationName in target.configurations) {
             const configuration = target.configurations[configurationName];
@@ -50,7 +39,7 @@ function buildPostTargetTransformer(target, tree, projectDetails, inferredTarget
         if (target.options.configFile) {
             viteConfigPath = target.options.configFile;
         }
-        removePropertiesFromTargetOptions(tree, target.options, viteConfigPath, projectDetails.root, configValues['default'], true);
+        removePropertiesFromTargetOptions(target.options, projectDetails.root, configValues['default']);
     }
     if (target.outputs) {
         (0, internal_1.processTargetOutputs)(target, [{ newName: 'outDir', oldName: 'outputPath' }], inferredTargetConfiguration, {
@@ -65,7 +54,7 @@ function buildPostTargetTransformer(target, tree, projectDetails, inferredTarget
     (0, utils_1.addConfigValuesToViteConfig)(tree, viteConfigPath, configValues);
     return target;
 }
-function removePropertiesFromTargetOptions(tree, targetOptions, viteConfigPath, projectRoot, configValues, needsAstTransform = false) {
+function removePropertiesFromTargetOptions(targetOptions, projectRoot, configValues) {
     if ('configFile' in targetOptions) {
         targetOptions.config = (0, utils_1.toProjectRelativePath)(targetOptions.configFile, projectRoot);
         delete targetOptions.configFile;
@@ -75,10 +64,6 @@ function removePropertiesFromTargetOptions(tree, targetOptions, viteConfigPath,
         delete targetOptions.outputPath;
     }
     if ('buildLibsFromSource' in targetOptions) {
-        configValues['buildLibsFromSource'] = targetOptions.buildLibsFromSource;
-        if (needsAstTransform) {
-            moveBuildLibsFromSourceToViteConfig(tree, viteConfigPath);
-        }
         delete targetOptions.buildLibsFromSource;
     }
     if ('skipTypeCheck' in targetOptions) {
@@ -94,51 +79,3 @@ function removePropertiesFromTargetOptions(tree, targetOptions, viteConfigPath,
         delete targetOptions.tsConfig;
     }
 }
-function moveBuildLibsFromSourceToViteConfig(tree, configPath) {
-    const PLUGINS_PROPERTY_SELECTOR = 'PropertyAssignment:has(Identifier[name=plugins])';
-    const PLUGINS_NX_VITE_TS_PATHS_SELECTOR = 'PropertyAssignment:has(Identifier[name=plugins]) CallExpression:has(Identifier[name=nxViteTsPaths])';
-    const BUILD_LIBS_FROM_SOURCE_SELECTOR = 'PropertyAssignment:has(Identifier[name=plugins]) CallExpression:has(Identifier[name=nxViteTsPaths]) ObjectLiteralExpression > PropertyAssignment:has(Identifier[name=buildLibsFromSource])';
-    const nxViteTsPathsImport = (0, posix_1.extname)(configPath) === 'js'
-        ? 'const {nxViteTsPaths} = require("@nx/vite/plugins/nx-tsconfig-paths.plugin");'
-        : 'import { nxViteTsPaths } from "@nx/vite/plugins/nx-tsconfig-paths.plugin";';
-    const plugin = `nxViteTsPaths({ buildLibsFromSource: options.buildLibsFromSource }),`;
-    const viteConfigContents = tree.read(configPath, 'utf-8');
-    let newViteConfigContents = viteConfigContents;
-    const sourceFile = (0, tsquery_1.ast)(viteConfigContents);
-    const buildLibsFromSourceNodes = (0, tsquery_1.query)(sourceFile, BUILD_LIBS_FROM_SOURCE_SELECTOR);
-    if (buildLibsFromSourceNodes.length > 0) {
-        return;
-    }
-    const nxViteTsPathsNodes = (0, tsquery_1.query)(sourceFile, PLUGINS_NX_VITE_TS_PATHS_SELECTOR);
-    if (nxViteTsPathsNodes.length === 0) {
-        const pluginsNodes = (0, tsquery_1.query)(sourceFile, PLUGINS_PROPERTY_SELECTOR);
-        if (pluginsNodes.length === 0) {
-            // Add plugin property
-            const configNodes = (0, tsquery_1.query)(sourceFile, 'CallExpression:has(Identifier[name=defineConfig]) > ObjectLiteralExpression');
-            if (configNodes.length === 0) {
-                return;
-            }
-            newViteConfigContents = `${nxViteTsPathsImport}\n${viteConfigContents.slice(0, configNodes[0].getStart() + 1)}plugins: [${plugin}],${viteConfigContents.slice(configNodes[0].getStart() + 1)}`;
-        }
-        else {
-            // Add nxViteTsPaths plugin
-            const pluginsArrayNodes = (0, tsquery_1.query)(pluginsNodes[0], 'ArrayLiteralExpression');
-            if (pluginsArrayNodes.length === 0) {
-                return;
-            }
-            newViteConfigContents = `${nxViteTsPathsImport}\n${viteConfigContents.slice(0, pluginsArrayNodes[0].getStart() + 1)}${plugin}${viteConfigContents.slice(pluginsArrayNodes[0].getStart() + 1)}`;
-        }
-    }
-    else {
-        const pluginOptionsNodes = (0, tsquery_1.query)(nxViteTsPathsNodes[0], 'ObjectLiteralExpression');
-        if (pluginOptionsNodes.length === 0) {
-            // Add the options
-            newViteConfigContents = `${viteConfigContents.slice(0, nxViteTsPathsNodes[0].getStart())}${plugin}${viteConfigContents.slice(nxViteTsPathsNodes[0].getEnd())}`;
-        }
-        else {
-            // update the object
-            newViteConfigContents = `${viteConfigContents.slice(0, pluginOptionsNodes[0].getStart() + 1)}buildLibsFromSource: options.buildLibsFromSource, ${viteConfigContents.slice(pluginOptionsNodes[0].getStart() + 1)}`;
-        }
-    }
-    tree.write(configPath, newViteConfigContents);
-}