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

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "nxViteTsPaths", {
+    enumerable: true,
+    get: function() {
+        return nxViteTsPaths;
+    }
+});
+const _devkit = require("@nx/devkit");
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _tsconfigpaths = require("tsconfig-paths");
+function nxViteTsPaths(options = {}) {
+    var _options, _options1;
+    let matchTsPathEsm;
+    let matchTsPathFallback;
+    let tsConfigPathsEsm;
+    let tsConfigPathsFallback;
+    var _extensions;
+    (_extensions = (_options = options).extensions) != null ? _extensions : _options.extensions = [
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx',
+        '.json',
+        '.mjs',
+        '.cjs'
+    ];
+    var _mainFields;
+    (_mainFields = (_options1 = options).mainFields) != null ? _mainFields : _options1.mainFields = [
+        [
+            'exports',
+            '.',
+            'import'
+        ],
+        'module',
+        'main'
+    ];
+    return {
+        name: 'nx-vite-ts-paths',
+        configResolved (config) {
+            const projectRoot = config.root;
+            const projectRootFromWorkspaceRoot = (0, _nodepath.relative)(_devkit.workspaceRoot, projectRoot);
+            const foundTsConfigPath = getTsConfig((0, _nodepath.join)(_devkit.workspaceRoot, 'tmp', projectRootFromWorkspaceRoot, 'tsconfig.generated.json'));
+            if (!foundTsConfigPath) {
+                throw new Error((0, _devkit.stripIndents)`Unable to find a tsconfig in the workspace! 
+There should at least be a tsconfig.base.json or tsconfig.json in the root of the workspace ${_devkit.workspaceRoot}`);
+            }
+            const parsed = (0, _tsconfigpaths.loadConfig)(foundTsConfigPath);
+            logIt('first parsed tsconfig: ', parsed);
+            if (parsed.resultType === 'failed') {
+                throw new Error(`Failed loading tsonfig at ${foundTsConfigPath}`);
+            }
+            tsConfigPathsEsm = parsed;
+            matchTsPathEsm = (0, _tsconfigpaths.createMatchPath)(parsed.absoluteBaseUrl, parsed.paths, options.mainFields);
+            const rootLevelTsConfig = getTsConfig((0, _nodepath.join)(_devkit.workspaceRoot, 'tsconfig.base.json'));
+            const rootLevelParsed = (0, _tsconfigpaths.loadConfig)(rootLevelTsConfig);
+            logIt('fallback parsed tsconfig: ', rootLevelParsed);
+            if (rootLevelParsed.resultType === 'success') {
+                tsConfigPathsFallback = rootLevelParsed;
+                matchTsPathFallback = (0, _tsconfigpaths.createMatchPath)(rootLevelParsed.absoluteBaseUrl, rootLevelParsed.paths, [
+                    'main',
+                    'module'
+                ]);
+            }
+        },
+        resolveId (importPath) {
+            let resolvedFile;
+            try {
+                resolvedFile = matchTsPathEsm(importPath);
+            } catch (e) {
+                logIt('Using fallback path matching.');
+                resolvedFile = matchTsPathFallback == null ? void 0 : matchTsPathFallback(importPath);
+            }
+            if (!resolvedFile) {
+                if (tsConfigPathsEsm || tsConfigPathsFallback) {
+                    logIt(`Unable to resolve ${importPath} with tsconfig paths. Using fallback file matching.`);
+                    resolvedFile = loadFileFromPaths(tsConfigPathsEsm, importPath) || loadFileFromPaths(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;
+        }
+    };
+    function getTsConfig(preferredTsConfigPath) {
+        return [
+            (0, _nodepath.resolve)(preferredTsConfigPath),
+            (0, _nodepath.resolve)((0, _nodepath.join)(_devkit.workspaceRoot, 'tsconfig.base.json')),
+            (0, _nodepath.resolve)((0, _nodepath.join)(_devkit.workspaceRoot, 'tsconfig.json'))
+        ].find((tsPath)=>{
+            if ((0, _nodefs.existsSync)(tsPath)) {
+                logIt('Found tsconfig at', tsPath);
+                return tsPath;
+            }
+        });
+    }
+    function logIt(...msg) {
+        if (process.env.NX_VERBOSE_LOGGING === 'true' || (options == null ? void 0 : options.debug)) {
+            console.debug('\n[Nx Vite TsPaths]', ...msg);
+        }
+    }
+    function loadFileFromPaths(tsconfig, importPath) {
+        logIt(`Trying to resolve file from config in ${tsconfig.configFileAbsolutePath}`);
+        let resolvedFile;
+        for(const alias in tsconfig.paths){
+            const paths = tsconfig.paths[alias];
+            const normalizedImport = alias.replace(/\/\*$/, '');
+            if (importPath.startsWith(normalizedImport)) {
+                const joinedPath = (0, _devkit.joinPathFragments)(tsconfig.absoluteBaseUrl, paths[0].replace(/\/\*$/, ''));
+                resolvedFile = findFile(importPath.replace(normalizedImport, joinedPath));
+            }
+        }
+        return resolvedFile;
+    }
+    function findFile(path) {
+        for (const ext of options.extensions){
+            const resolvedPath = (0, _nodepath.resolve)(path + ext);
+            if ((0, _nodefs.existsSync)(resolvedPath)) {
+                return resolvedPath;
+            }
+            const resolvedIndexPath = (0, _nodepath.resolve)(path, `index${ext}`);
+            if ((0, _nodefs.existsSync)(resolvedIndexPath)) {
+                return resolvedIndexPath;
+            }
+        }
+    }
+}
+
+//# sourceMappingURL=nx-tsconfig-paths.plugin.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/vite/plugins/nx-tsconfig-paths.plugin.ts"],"sourcesContent":["import { joinPathFragments, stripIndents, workspaceRoot } from '@nx/devkit';\nimport { existsSync } from 'node:fs';\nimport { relative, join, resolve } from 'node:path';\nimport {\n  loadConfig,\n  createMatchPath,\n  MatchPath,\n  ConfigLoaderSuccessResult,\n} from 'tsconfig-paths';\n\nexport interface nxViteTsPathsOptions {\n  /**\n   * Enable debug logging\n   * @default false\n   **/\n  debug?: boolean;\n  /**\n   * export fields in package.json to use for resolving\n   * @default [['exports', '.', 'import'], 'module', 'main']\n   *\n   * fallback resolution will use ['main', 'module']\n   **/\n  mainFields?: (string | string[])[];\n  /**\n   * extensions to check when resolving files when package.json resolution fails\n   * @default ['.ts', '.tsx', '.js', '.jsx', '.json', '.mjs', '.cjs']\n   **/\n  extensions?: string[];\n}\n\nexport function nxViteTsPaths(options: nxViteTsPathsOptions = {}) {\n  let matchTsPathEsm: MatchPath;\n  let matchTsPathFallback: MatchPath | undefined;\n  let tsConfigPathsEsm: ConfigLoaderSuccessResult;\n  let tsConfigPathsFallback: ConfigLoaderSuccessResult;\n\n  options.extensions ??= [\n    '.ts',\n    '.tsx',\n    '.js',\n    '.jsx',\n    '.json',\n    '.mjs',\n    '.cjs',\n  ];\n  options.mainFields ??= [['exports', '.', 'import'], 'module', 'main'];\n\n  return {\n    name: 'nx-vite-ts-paths',\n    configResolved(config: any) {\n      const projectRoot = config.root;\n      const projectRootFromWorkspaceRoot = relative(workspaceRoot, projectRoot);\n\n      const foundTsConfigPath = getTsConfig(\n        join(\n          workspaceRoot,\n          'tmp',\n          projectRootFromWorkspaceRoot,\n          'tsconfig.generated.json'\n        )\n      );\n      if (!foundTsConfigPath) {\n        throw new Error(stripIndents`Unable to find a tsconfig in the workspace! \nThere should at least be a tsconfig.base.json or tsconfig.json in the root of the workspace ${workspaceRoot}`);\n      }\n      const parsed = loadConfig(foundTsConfigPath);\n\n      logIt('first parsed tsconfig: ', parsed);\n      if (parsed.resultType === 'failed') {\n        throw new Error(`Failed loading tsonfig at ${foundTsConfigPath}`);\n      }\n      tsConfigPathsEsm = parsed;\n\n      matchTsPathEsm = createMatchPath(\n        parsed.absoluteBaseUrl,\n        parsed.paths,\n        options.mainFields\n      );\n\n      const rootLevelTsConfig = getTsConfig(\n        join(workspaceRoot, 'tsconfig.base.json')\n      );\n      const rootLevelParsed = loadConfig(rootLevelTsConfig);\n      logIt('fallback parsed tsconfig: ', rootLevelParsed);\n      if (rootLevelParsed.resultType === 'success') {\n        tsConfigPathsFallback = rootLevelParsed;\n        matchTsPathFallback = createMatchPath(\n          rootLevelParsed.absoluteBaseUrl,\n          rootLevelParsed.paths,\n          ['main', 'module']\n        );\n      }\n    },\n    resolveId(importPath: string) {\n      let resolvedFile: string;\n      try {\n        resolvedFile = matchTsPathEsm(importPath);\n      } catch (e) {\n        logIt('Using fallback path matching.');\n        resolvedFile = matchTsPathFallback?.(importPath);\n      }\n\n      if (!resolvedFile) {\n        if (tsConfigPathsEsm || tsConfigPathsFallback) {\n          logIt(\n            `Unable to resolve ${importPath} with tsconfig paths. Using fallback file matching.`\n          );\n          resolvedFile =\n            loadFileFromPaths(tsConfigPathsEsm, importPath) ||\n            loadFileFromPaths(tsConfigPathsFallback, importPath);\n        } else {\n          logIt(`Unable to resolve ${importPath} with tsconfig paths`);\n        }\n      }\n\n      logIt(`Resolved ${importPath} to ${resolvedFile}`);\n      // Returning null defers to other resolveId functions and eventually the default resolution behavior\n      // https://rollupjs.org/plugin-development/#resolveid\n      return resolvedFile || null;\n    },\n  };\n\n  function getTsConfig(preferredTsConfigPath: string): string {\n    return [\n      resolve(preferredTsConfigPath),\n      resolve(join(workspaceRoot, 'tsconfig.base.json')),\n      resolve(join(workspaceRoot, 'tsconfig.json')),\n    ].find((tsPath) => {\n      if (existsSync(tsPath)) {\n        logIt('Found tsconfig at', tsPath);\n        return tsPath;\n      }\n    });\n  }\n\n  function logIt(...msg: any[]) {\n    if (process.env.NX_VERBOSE_LOGGING === 'true' || options?.debug) {\n      console.debug('\\n[Nx Vite TsPaths]', ...msg);\n    }\n  }\n\n  function loadFileFromPaths(\n    tsconfig: ConfigLoaderSuccessResult,\n    importPath: string\n  ) {\n    logIt(\n      `Trying to resolve file from config in ${tsconfig.configFileAbsolutePath}`\n    );\n    let resolvedFile: string;\n    for (const alias in tsconfig.paths) {\n      const paths = tsconfig.paths[alias];\n\n      const normalizedImport = alias.replace(/\\/\\*$/, '');\n\n      if (importPath.startsWith(normalizedImport)) {\n        const joinedPath = joinPathFragments(\n          tsconfig.absoluteBaseUrl,\n          paths[0].replace(/\\/\\*$/, '')\n        );\n\n        resolvedFile = findFile(\n          importPath.replace(normalizedImport, joinedPath)\n        );\n      }\n    }\n\n    return resolvedFile;\n  }\n\n  function findFile(path: string): string {\n    for (const ext of options.extensions) {\n      const resolvedPath = resolve(path + ext);\n      if (existsSync(resolvedPath)) {\n        return resolvedPath;\n      }\n\n      const resolvedIndexPath = resolve(path, `index${ext}`);\n      if (existsSync(resolvedIndexPath)) {\n        return resolvedIndexPath;\n      }\n    }\n  }\n}\n"],"names":["nxViteTsPaths","options","matchTsPathEsm","matchTsPathFallback","tsConfigPathsEsm","tsConfigPathsFallback","extensions","mainFields","name","configResolved","config","projectRoot","root","projectRootFromWorkspaceRoot","relative","workspaceRoot","foundTsConfigPath","getTsConfig","join","Error","stripIndents","parsed","loadConfig","logIt","resultType","createMatchPath","absoluteBaseUrl","paths","rootLevelTsConfig","rootLevelParsed","resolveId","importPath","resolvedFile","e","loadFileFromPaths","preferredTsConfigPath","resolve","find","tsPath","existsSync","msg","process","env","NX_VERBOSE_LOGGING","debug","console","tsconfig","configFileAbsolutePath","alias","normalizedImport","replace","startsWith","joinedPath","joinPathFragments","findFile","path","ext","resolvedPath","resolvedIndexPath"],"mappings":"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"}

package/plugins/rollup-replace-files.plugin.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @function replaceFiles
+ * @param {FileReplacement[]} replacements
+ * @return {({name: "rollup-plugin-replace-files", enforce: "pre" | "post" | undefined, Promise<resolveId>})}
+ */
+export declare function replaceFiles(replacements: FileReplacement[]): {
+    name: string;
+    enforce: 'pre' | 'post' | undefined;
+    resolveId(source: any, importer: any, options: any): Promise<{
+        id: string;
+    }>;
+};
+export interface FileReplacement {
+    replace: string;
+    with: string;
+}

package/plugins/rollup-replace-files.plugin.js

@@ -0,0 +1,51 @@
+// source: https://github.com/Myrmod/vitejs-theming/blob/master/build-plugins/rollup/replace-files.js
+/**
+ * @function replaceFiles
+ * @param {FileReplacement[]} replacements
+ * @return {({name: "rollup-plugin-replace-files", enforce: "pre" | "post" | undefined, Promise<resolveId>})}
+ */ "use strict";
+Object.defineProperty(exports, "replaceFiles", {
+    enumerable: true,
+    get: function() {
+        return replaceFiles;
+    }
+});
+const _extends = require("@swc/helpers/_/_extends");
+function replaceFiles(replacements) {
+    if (!(replacements == null ? void 0 : replacements.length)) {
+        return null;
+    }
+    return {
+        name: 'rollup-plugin-replace-files',
+        enforce: 'pre',
+        async resolveId (source, importer, options) {
+            const resolved = await this.resolve(source, importer, _extends._({}, options, {
+                skipSelf: true
+            }));
+            /**
+       * The reason we're using endsWith here is because the resolved id
+       * will be the absolute path to the file. We want to check if the
+       * file ends with the file we're trying to replace, which will be essentially
+       * the path from the root of our workspace.
+       */ const foundReplace = replacements.find((replacement)=>{
+                var _resolved_id;
+                return resolved == null ? void 0 : (_resolved_id = resolved.id) == null ? void 0 : _resolved_id.endsWith(replacement.replace);
+            });
+            if (foundReplace) {
+                console.info(`replace "${foundReplace.replace}" with "${foundReplace.with}"`);
+                try {
+                    // return new file content
+                    return {
+                        id: foundReplace.with
+                    };
+                } catch (err) {
+                    console.error(err);
+                    return null;
+                }
+            }
+            return null;
+        }
+    };
+}
+
+//# sourceMappingURL=rollup-replace-files.plugin.js.map

package/plugins/rollup-replace-files.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../packages/vite/plugins/rollup-replace-files.plugin.ts"],"sourcesContent":["// source: https://github.com/Myrmod/vitejs-theming/blob/master/build-plugins/rollup/replace-files.js\n\n/**\n * @function replaceFiles\n * @param {FileReplacement[]} replacements\n * @return {({name: \"rollup-plugin-replace-files\", enforce: \"pre\" | \"post\" | undefined, Promise<resolveId>})}\n */\nexport function replaceFiles(replacements: FileReplacement[]): {\n  name: string;\n  enforce: 'pre' | 'post' | undefined;\n  resolveId(\n    source: any,\n    importer: any,\n    options: any\n  ): Promise<{\n    id: string;\n  }>;\n} {\n  if (!replacements?.length) {\n    return null;\n  }\n  return {\n    name: 'rollup-plugin-replace-files',\n    enforce: 'pre',\n    async resolveId(source, importer, options) {\n      const resolved = await this.resolve(source, importer, {\n        ...options,\n        skipSelf: true,\n      });\n      /**\n       * The reason we're using endsWith here is because the resolved id\n       * will be the absolute path to the file. We want to check if the\n       * file ends with the file we're trying to replace, which will be essentially\n       * the path from the root of our workspace.\n       */\n\n      const foundReplace = replacements.find((replacement) =>\n        resolved?.id?.endsWith(replacement.replace)\n      );\n      if (foundReplace) {\n        console.info(\n          `replace \"${foundReplace.replace}\" with \"${foundReplace.with}\"`\n        );\n        try {\n          // return new file content\n          return {\n            id: foundReplace.with,\n          };\n        } catch (err) {\n          console.error(err);\n          return null;\n        }\n      }\n      return null;\n    },\n  };\n}\n\nexport interface FileReplacement {\n  replace: string;\n  with: string;\n}\n"],"names":["replaceFiles","replacements","length","name","enforce","resolveId","source","importer","options","resolved","resolve","skipSelf","foundReplace","find","replacement","id","endsWith","replace","console","info","with","err","error"],"mappings":"AAAA,qGAAqG;AAErG;;;;CAIC;+BACeA;;;eAAAA;;;;AAAT,SAASA,aAAaC,YAA+B;IAW1D,IAAI,EAACA,gCAAAA,aAAcC,MAAM,GAAE;QACzB,OAAO;IACT;IACA,OAAO;QACLC,MAAM;QACNC,SAAS;QACT,MAAMC,WAAUC,MAAM,EAAEC,QAAQ,EAAEC,OAAO;YACvC,MAAMC,WAAW,MAAM,IAAI,CAACC,OAAO,CAACJ,QAAQC,UAAU,eACjDC;gBACHG,UAAU;;YAEZ;;;;;OAKC,GAED,MAAMC,eAAeX,aAAaY,IAAI,CAAC,CAACC;oBACtCL;uBAAAA,6BAAAA,eAAAA,SAAUM,EAAE,qBAAZN,aAAcO,QAAQ,CAACF,YAAYG,OAAO;;YAE5C,IAAIL,cAAc;gBAChBM,QAAQC,IAAI,CACV,CAAC,SAAS,EAAEP,aAAaK,OAAO,CAAC,QAAQ,EAAEL,aAAaQ,IAAI,CAAC,CAAC,CAAC;gBAEjE,IAAI;oBACF,0BAA0B;oBAC1B,OAAO;wBACLL,IAAIH,aAAaQ,IAAI;oBACvB;gBACF,EAAE,OAAOC,KAAK;oBACZH,QAAQI,KAAK,CAACD;oBACd,OAAO;gBACT;YACF;YACA,OAAO;QACT;IACF;AACF"}

package/src/executors/build/build.impl.d.ts

@@ -0,0 +1,13 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ViteBuildExecutorOptions } from './schema';
+export declare function viteBuildExecutor(options: Record<string, any> & ViteBuildExecutorOptions, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+} | {
+    success: boolean;
+    outfile: string;
+}, void, undefined>;
+export declare function getBuildExtraArgs(options: ViteBuildExecutorOptions): Promise<{
+    buildOptions: Record<string, unknown>;
+    otherOptions: Record<string, any>;
+}>;
+export default viteBuildExecutor;

package/src/executors/build/build.impl.js

@@ -0,0 +1,187 @@
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    viteBuildExecutor: function() {
+        return viteBuildExecutor;
+    },
+    getBuildExtraArgs: function() {
+        return getBuildExtraArgs;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _extends = require("@swc/helpers/_/_extends");
+const _devkit = require("@nx/devkit");
+const _optionsutils = require("../../utils/options-utils");
+const _js = require("@nx/js");
+const _fs = require("fs");
+const _path = require("path");
+const _asynciterable = require("@nx/devkit/src/utils/async-iterable");
+const _executorutils = require("../../utils/executor-utils");
+async function* viteBuildExecutor(options, context) {
+    var _resolved_config_build, _resolved_config;
+    process.env.VITE_CJS_IGNORE_WARNING = 'true';
+    // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.
+    const { mergeConfig, build, loadConfigFromFile } = await (0, _executorutils.loadViteDynamicImport)();
+    const projectRoot = context.projectsConfigurations.projects[context.projectName].root;
+    (0, _executorutils.createBuildableTsConfig)(projectRoot, options, context);
+    const viteConfigPath = (0, _optionsutils.normalizeViteConfigFilePath)(context.root, projectRoot, options.configFile);
+    const root = projectRoot === '.' ? process.cwd() : (0, _path.relative)(context.cwd, (0, _devkit.joinPathFragments)(context.root, projectRoot));
+    const { buildOptions, otherOptions } = await getBuildExtraArgs(options);
+    var _otherOptions_mode;
+    const resolved = await loadConfigFromFile({
+        mode: (_otherOptions_mode = otherOptions == null ? void 0 : otherOptions.mode) != null ? _otherOptions_mode : 'production',
+        command: 'build'
+    }, viteConfigPath);
+    var _joinPathFragments;
+    const outDir = (_joinPathFragments = (0, _devkit.joinPathFragments)((0, _devkit.offsetFromRoot)(projectRoot), options.outputPath)) != null ? _joinPathFragments : resolved == null ? void 0 : (_resolved_config = resolved.config) == null ? void 0 : (_resolved_config_build = _resolved_config.build) == null ? void 0 : _resolved_config_build.outDir;
+    var _resolved_config_root;
+    const buildConfig = mergeConfig({
+        // This should not be needed as it's going to be set in vite.config.ts
+        // but leaving it here in case someone did not migrate correctly
+        root: (_resolved_config_root = resolved.config.root) != null ? _resolved_config_root : root,
+        configFile: viteConfigPath
+    }, _extends._({
+        build: _extends._({
+            outDir
+        }, buildOptions)
+    }, otherOptions));
+    if (!options.skipTypeCheck) {
+        var _options_tsConfig;
+        await (0, _executorutils.validateTypes)({
+            workspaceRoot: context.root,
+            projectRoot: projectRoot,
+            tsconfig: (_options_tsConfig = options.tsConfig) != null ? _options_tsConfig : (0, _optionsutils.getProjectTsConfigPath)(projectRoot)
+        });
+    }
+    const watcherOrOutput = await build(buildConfig);
+    const libraryPackageJson = (0, _path.resolve)(projectRoot, 'package.json');
+    const rootPackageJson = (0, _path.resolve)(context.root, 'package.json');
+    // Here, we want the outdir relative to the workspace root.
+    // So, we calculate the relative path from the workspace root to the outdir.
+    const outDirRelativeToWorkspaceRoot = outDir.replaceAll('../', '');
+    const distPackageJson = (0, _path.resolve)(outDirRelativeToWorkspaceRoot, 'package.json');
+    // Generate a package.json if option has been set.
+    if (options.generatePackageJson) {
+        if (context.projectGraph.nodes[context.projectName].type !== 'app') {
+            _devkit.logger.warn((0, _devkit.stripIndents)`The project ${context.projectName} is using the 'generatePackageJson' option which is deprecated for library projects. It should only be used for applications.
+        For libraries, configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/packages/eslint-plugin/documents/dependency-checks).`);
+        }
+        const builtPackageJson = (0, _js.createPackageJson)(context.projectName, context.projectGraph, {
+            target: context.targetName,
+            root: context.root,
+            isProduction: !options.includeDevDependenciesInPackageJson
+        });
+        builtPackageJson.type = 'module';
+        (0, _devkit.writeJsonFile)(`${outDirRelativeToWorkspaceRoot}/package.json`, builtPackageJson);
+        const packageManager = (0, _devkit.detectPackageManager)(context.root);
+        const lockFile = (0, _js.createLockFile)(builtPackageJson, context.projectGraph, packageManager);
+        (0, _fs.writeFileSync)(`${outDirRelativeToWorkspaceRoot}/${(0, _js.getLockFileName)(packageManager)}`, lockFile, {
+            encoding: 'utf-8'
+        });
+    } else if (options.generatePackageJson !== false && !(0, _fs.existsSync)(distPackageJson) && (0, _fs.existsSync)(libraryPackageJson) && rootPackageJson !== libraryPackageJson) {
+        await (0, _js.copyAssets)({
+            outputPath: outDirRelativeToWorkspaceRoot,
+            assets: [
+                {
+                    input: projectRoot,
+                    output: '.',
+                    glob: 'package.json'
+                }
+            ]
+        }, context);
+    }
+    if ('on' in watcherOrOutput) {
+        const iterable = (0, _asynciterable.createAsyncIterable)(({ next })=>{
+            let success = true;
+            watcherOrOutput.on('event', (event)=>{
+                if (event.code === 'START') {
+                    success = true;
+                } else if (event.code === 'ERROR') {
+                    success = false;
+                } else if (event.code === 'END') {
+                    next({
+                        success
+                    });
+                }
+                // result must be closed when present.
+                // see https://rollupjs.org/guide/en/#rollupwatch
+                if ('result' in event && event.result) {
+                    event.result.close();
+                }
+            });
+        });
+        yield* iterable;
+    } else {
+        var _watcherOrOutput_, _output_;
+        const output = (watcherOrOutput == null ? void 0 : watcherOrOutput['output']) || (watcherOrOutput == null ? void 0 : (_watcherOrOutput_ = watcherOrOutput[0]) == null ? void 0 : _watcherOrOutput_.output);
+        const fileName = (output == null ? void 0 : (_output_ = output[0]) == null ? void 0 : _output_.fileName) || 'main.cjs';
+        const outfile = (0, _path.resolve)(outDirRelativeToWorkspaceRoot, fileName);
+        yield {
+            success: true,
+            outfile
+        };
+    }
+}
+async function getBuildExtraArgs(options) {
+    // support passing extra args to vite cli
+    const schema = await Promise.resolve().then(()=>require("./schema.json"));
+    const extraArgs = {};
+    for (const key of Object.keys(options)){
+        if (!schema.properties[key]) {
+            extraArgs[key] = options[key];
+        }
+    }
+    const buildOptions = {};
+    const buildSchemaKeys = [
+        'target',
+        'polyfillModulePreload',
+        'modulePreload',
+        'outDir',
+        'assetsDir',
+        'assetsInlineLimit',
+        'cssCodeSplit',
+        'cssTarget',
+        'cssMinify',
+        'sourcemap',
+        'minify',
+        'terserOptions',
+        'rollupOptions',
+        'commonjsOptions',
+        'dynamicImportVarsOptions',
+        'write',
+        'emptyOutDir',
+        'copyPublicDir',
+        'manifest',
+        'lib',
+        'ssr',
+        'ssrManifest',
+        'ssrEmitAssets',
+        'reportCompressedSize',
+        'chunkSizeWarningLimit',
+        'watch'
+    ];
+    const otherOptions = {};
+    for (const key of Object.keys(extraArgs)){
+        if (buildSchemaKeys.includes(key)) {
+            buildOptions[key] = extraArgs[key];
+        } else {
+            otherOptions[key] = extraArgs[key];
+        }
+    }
+    var _options_watch;
+    buildOptions['watch'] = (_options_watch = options.watch) != null ? _options_watch : undefined;
+    return {
+        buildOptions,
+        otherOptions
+    };
+}
+const _default = viteBuildExecutor;
+
+//# sourceMappingURL=build.impl.js.map

package/src/executors/build/build.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/vite/src/executors/build/build.impl.ts"],"sourcesContent":["import {\n  detectPackageManager,\n  ExecutorContext,\n  joinPathFragments,\n  logger,\n  offsetFromRoot,\n  stripIndents,\n  writeJsonFile,\n} from '@nx/devkit';\nimport {\n  getProjectTsConfigPath,\n  normalizeViteConfigFilePath,\n} from '../../utils/options-utils';\nimport { ViteBuildExecutorOptions } from './schema';\nimport {\n  copyAssets,\n  createLockFile,\n  createPackageJson,\n  getLockFileName,\n} from '@nx/js';\nimport { existsSync, writeFileSync } from 'fs';\nimport { relative, resolve } from 'path';\nimport { createAsyncIterable } from '@nx/devkit/src/utils/async-iterable';\nimport {\n  createBuildableTsConfig,\n  loadViteDynamicImport,\n  validateTypes,\n} from '../../utils/executor-utils';\n\nexport async function* viteBuildExecutor(\n  options: Record<string, any> & ViteBuildExecutorOptions,\n  context: ExecutorContext\n) {\n  process.env.VITE_CJS_IGNORE_WARNING = 'true';\n  // Allows ESM to be required in CJS modules. Vite will be published as ESM in the future.\n  const { mergeConfig, build, loadConfigFromFile } =\n    await loadViteDynamicImport();\n  const projectRoot =\n    context.projectsConfigurations.projects[context.projectName].root;\n  createBuildableTsConfig(projectRoot, options, context);\n\n  const viteConfigPath = normalizeViteConfigFilePath(\n    context.root,\n    projectRoot,\n    options.configFile\n  );\n  const root =\n    projectRoot === '.'\n      ? process.cwd()\n      : relative(context.cwd, joinPathFragments(context.root, projectRoot));\n\n  const { buildOptions, otherOptions } = await getBuildExtraArgs(options);\n\n  const resolved = await loadConfigFromFile(\n    {\n      mode: otherOptions?.mode ?? 'production',\n      command: 'build',\n    },\n    viteConfigPath\n  );\n\n  const outDir =\n    joinPathFragments(offsetFromRoot(projectRoot), options.outputPath) ??\n    resolved?.config?.build?.outDir;\n\n  const buildConfig = mergeConfig(\n    {\n      // This should not be needed as it's going to be set in vite.config.ts\n      // but leaving it here in case someone did not migrate correctly\n      root: resolved.config.root ?? root,\n      configFile: viteConfigPath,\n    },\n    {\n      build: {\n        outDir,\n        ...buildOptions,\n      },\n      ...otherOptions,\n    }\n  );\n\n  if (!options.skipTypeCheck) {\n    await validateTypes({\n      workspaceRoot: context.root,\n      projectRoot: projectRoot,\n      tsconfig: options.tsConfig ?? getProjectTsConfigPath(projectRoot),\n    });\n  }\n\n  const watcherOrOutput = await build(buildConfig);\n\n  const libraryPackageJson = resolve(projectRoot, 'package.json');\n  const rootPackageJson = resolve(context.root, 'package.json');\n\n  // Here, we want the outdir relative to the workspace root.\n  // So, we calculate the relative path from the workspace root to the outdir.\n  const outDirRelativeToWorkspaceRoot = outDir.replaceAll('../', '');\n  const distPackageJson = resolve(\n    outDirRelativeToWorkspaceRoot,\n    'package.json'\n  );\n\n  // Generate a package.json if option has been set.\n  if (options.generatePackageJson) {\n    if (context.projectGraph.nodes[context.projectName].type !== 'app') {\n      logger.warn(\n        stripIndents`The project ${context.projectName} is using the 'generatePackageJson' option which is deprecated for library projects. It should only be used for applications.\n        For libraries, configure the project to use the '@nx/dependency-checks' ESLint rule instead (https://nx.dev/packages/eslint-plugin/documents/dependency-checks).`\n      );\n    }\n\n    const builtPackageJson = createPackageJson(\n      context.projectName,\n      context.projectGraph,\n      {\n        target: context.targetName,\n        root: context.root,\n        isProduction: !options.includeDevDependenciesInPackageJson, // By default we remove devDependencies since this is a production build.\n      }\n    );\n\n    builtPackageJson.type = 'module';\n\n    writeJsonFile(\n      `${outDirRelativeToWorkspaceRoot}/package.json`,\n      builtPackageJson\n    );\n    const packageManager = detectPackageManager(context.root);\n\n    const lockFile = createLockFile(\n      builtPackageJson,\n      context.projectGraph,\n      packageManager\n    );\n    writeFileSync(\n      `${outDirRelativeToWorkspaceRoot}/${getLockFileName(packageManager)}`,\n      lockFile,\n      {\n        encoding: 'utf-8',\n      }\n    );\n  }\n  // For buildable libs, copy package.json if it exists.\n  else if (\n    options.generatePackageJson !== false &&\n    !existsSync(distPackageJson) &&\n    existsSync(libraryPackageJson) &&\n    rootPackageJson !== libraryPackageJson\n  ) {\n    await copyAssets(\n      {\n        outputPath: outDirRelativeToWorkspaceRoot,\n        assets: [\n          {\n            input: projectRoot,\n            output: '.',\n            glob: 'package.json',\n          },\n        ],\n      },\n      context\n    );\n  }\n\n  if ('on' in watcherOrOutput) {\n    const iterable = createAsyncIterable<{ success: boolean }>(({ next }) => {\n      let success = true;\n      watcherOrOutput.on('event', (event) => {\n        if (event.code === 'START') {\n          success = true;\n        } else if (event.code === 'ERROR') {\n          success = false;\n        } else if (event.code === 'END') {\n          next({ success });\n        }\n        // result must be closed when present.\n        // see https://rollupjs.org/guide/en/#rollupwatch\n        if ('result' in event && event.result) {\n          event.result.close();\n        }\n      });\n    });\n    yield* iterable;\n  } else {\n    const output = watcherOrOutput?.['output'] || watcherOrOutput?.[0]?.output;\n    const fileName = output?.[0]?.fileName || 'main.cjs';\n    const outfile = resolve(outDirRelativeToWorkspaceRoot, fileName);\n    yield { success: true, outfile };\n  }\n}\n\nexport async function getBuildExtraArgs(\n  options: ViteBuildExecutorOptions\n): Promise<{\n  // vite BuildOptions\n  buildOptions: Record<string, unknown>;\n  otherOptions: Record<string, any>;\n}> {\n  // support passing extra args to vite cli\n  const schema = await import('./schema.json');\n  const extraArgs = {};\n  for (const key of Object.keys(options)) {\n    if (!schema.properties[key]) {\n      extraArgs[key] = options[key];\n    }\n  }\n\n  const buildOptions = {};\n  const buildSchemaKeys = [\n    'target',\n    'polyfillModulePreload',\n    'modulePreload',\n    'outDir',\n    'assetsDir',\n    'assetsInlineLimit',\n    'cssCodeSplit',\n    'cssTarget',\n    'cssMinify',\n    'sourcemap',\n    'minify',\n    'terserOptions',\n    'rollupOptions',\n    'commonjsOptions',\n    'dynamicImportVarsOptions',\n    'write',\n    'emptyOutDir',\n    'copyPublicDir',\n    'manifest',\n    'lib',\n    'ssr',\n    'ssrManifest',\n    'ssrEmitAssets',\n    'reportCompressedSize',\n    'chunkSizeWarningLimit',\n    'watch',\n  ];\n  const otherOptions = {};\n  for (const key of Object.keys(extraArgs)) {\n    if (buildSchemaKeys.includes(key)) {\n      buildOptions[key] = extraArgs[key];\n    } else {\n      otherOptions[key] = extraArgs[key];\n    }\n  }\n\n  buildOptions['watch'] = options.watch ?? undefined;\n\n  return {\n    buildOptions,\n    otherOptions,\n  };\n}\n\nexport default viteBuildExecutor;\n"],"names":["viteBuildExecutor","getBuildExtraArgs","options","context","resolved","process","env","VITE_CJS_IGNORE_WARNING","mergeConfig","build","loadConfigFromFile","loadViteDynamicImport","projectRoot","projectsConfigurations","projects","projectName","root","createBuildableTsConfig","viteConfigPath","normalizeViteConfigFilePath","configFile","cwd","relative","joinPathFragments","buildOptions","otherOptions","mode","command","outDir","offsetFromRoot","outputPath","config","buildConfig","skipTypeCheck","validateTypes","workspaceRoot","tsconfig","tsConfig","getProjectTsConfigPath","watcherOrOutput","libraryPackageJson","resolve","rootPackageJson","outDirRelativeToWorkspaceRoot","replaceAll","distPackageJson","generatePackageJson","projectGraph","nodes","type","logger","warn","stripIndents","builtPackageJson","createPackageJson","target","targetName","isProduction","includeDevDependenciesInPackageJson","writeJsonFile","packageManager","detectPackageManager","lockFile","createLockFile","writeFileSync","getLockFileName","encoding","existsSync","copyAssets","assets","input","output","glob","iterable","createAsyncIterable","next","success","on","event","code","result","close","fileName","outfile","schema","extraArgs","key","Object","keys","properties","buildSchemaKeys","includes","watch","undefined"],"mappings":"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"}

package/src/executors/build/compat.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/src/executors/build/compat.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _devkit = require("@nx/devkit");
+const _buildimpl = require("./build.impl");
+const _default = (0, _devkit.convertNxExecutor)(_buildimpl.default);
+
+//# sourceMappingURL=compat.js.map

package/src/executors/build/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/vite/src/executors/build/compat.ts"],"sourcesContent":["import { convertNxExecutor } from '@nx/devkit';\nimport viteBuildExecutor from './build.impl';\n\nexport default convertNxExecutor(viteBuildExecutor);\n"],"names":["convertNxExecutor","viteBuildExecutor"],"mappings":";+BAGA;;;eAAA;;;wBAHkC;2BACJ;MAE9B,WAAeA,IAAAA,yBAAiB,EAACC,kBAAiB"}

package/src/executors/build/schema.d.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=schema.d.js.map

package/src/executors/build/schema.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/vite/src/executors/build/schema.d.ts"],"names":[],"mappings":""}

package/src/executors/build/schema.d.ts

@@ -0,0 +1,10 @@
+export interface ViteBuildExecutorOptions {
+  outputPath?: string;
+  buildLibsFromSource?: boolean;
+  skipTypeCheck?: boolean;
+  configFile?: string;
+  watch?: boolean;
+  generatePackageJson?: boolean;
+  includeDevDependenciesInPackageJson?: boolean;
+  tsConfig?: string;
+}

package/src/executors/build/schema.json

@@ -0,0 +1,67 @@
+{
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "Vite Prod Builder",
+  "cli": "nx",
+  "description": "Builds a Vite.js application for production.",
+  "type": "object",
+  "presets": [
+    {
+      "name": "Default minimum setup",
+      "keys": []
+    }
+  ],
+  "properties": {
+    "outputPath": {
+      "type": "string",
+      "description": "The output path of the generated files.",
+      "x-completion-type": "directory",
+      "x-priority": "important"
+    },
+    "buildLibsFromSource": {
+      "type": "boolean",
+      "description": "Read buildable libraries from source instead of building them separately.",
+      "default": true
+    },
+    "skipTypeCheck": {
+      "type": "boolean",
+      "description": "Skip type-checking via TypeScript. Skipping type-checking speeds up the build but type errors are not caught.",
+      "default": false
+    },
+    "tsConfig": {
+      "type": "string",
+      "description": "The path to custom tsconfig file for type-checking when skipTypeCheck is false. Required when tsconfig file is not at the projectRoot level.",
+      "x-completion-type": "file",
+      "x-completion-glob": "tsconfig.*.json"
+    },
+    "configFile": {
+      "type": "string",
+      "description": "The name of the Vite.js configuration file.",
+      "x-completion-type": "file",
+      "x-completion-glob": "vite.config.@(js|ts)"
+    },
+    "watch": {
+      "description": "Enable re-building when files change.",
+      "oneOf": [
+        {
+          "type": "boolean"
+        },
+        {
+          "type": "object"
+        }
+      ],
+      "default": false
+    },
+    "generatePackageJson": {
+      "description": "Generate a package.json for the build output.",
+      "type": "boolean"
+    },
+    "includeDevDependenciesInPackageJson": {
+      "description": "Include devDependencies in the generated package.json.",
+      "type": "boolean"
+    }
+  },
+  "definitions": {},
+  "required": [],
+  "examplesFile": "../../../docs/build-examples.md"
+}

package/src/executors/dev-server/compat.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/src/executors/dev-server/compat.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return _default;
+    }
+});
+const _devkit = require("@nx/devkit");
+const _devserverimpl = require("./dev-server.impl");
+const _default = (0, _devkit.convertNxExecutor)(_devserverimpl.default);
+
+//# sourceMappingURL=compat.js.map

package/src/executors/dev-server/compat.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/vite/src/executors/dev-server/compat.ts"],"sourcesContent":["import { convertNxExecutor } from '@nx/devkit';\nimport viteDevServerExecutor from './dev-server.impl';\n\nexport default convertNxExecutor(viteDevServerExecutor);\n"],"names":["convertNxExecutor","viteDevServerExecutor"],"mappings":";+BAGA;;;eAAA;;;wBAHkC;+BACA;MAElC,WAAeA,IAAAA,yBAAiB,EAACC,sBAAqB"}

package/src/executors/dev-server/dev-server.impl.d.ts

@@ -0,0 +1,7 @@
+import { ExecutorContext } from '@nx/devkit';
+import { ViteDevServerExecutorOptions } from './schema';
+export declare function viteDevServerExecutor(options: ViteDevServerExecutorOptions, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    baseUrl: string;
+}>;
+export default viteDevServerExecutor;