@nx/vite 21.3.7 → 21.4.0-beta.1

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

@@ -1,30 +1,28 @@
 "use strict";
-Object.defineProperty(exports, "ensureViteConfigIsCorrect", {
-    enumerable: true,
-    get: function() {
-        return ensureViteConfigIsCorrect;
-    }
-});
-const _devkit = require("@nx/devkit");
-const _js = require("@nx/js");
+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 == null ? void 0 : projectAlreadyHasViteTargets.test) && (testConfigString == null ? void 0 : testConfigString.length)) {
+    if (!projectAlreadyHasViteTargets?.test && testConfigString?.length) {
         updatedContent = handleBuildOrTestNode(fileContent, testConfigString, testConfigObject, 'test');
     }
-    if (!(projectAlreadyHasViteTargets == null ? void 0 : projectAlreadyHasViteTargets.build) && (buildConfigString == null ? void 0 : buildConfigString.length)) {
-        updatedContent = handleBuildOrTestNode(updatedContent != null ? updatedContent : fileContent, buildConfigString, buildConfigObject, 'build');
+    if (!projectAlreadyHasViteTargets?.build && buildConfigString?.length) {
+        updatedContent = handleBuildOrTestNode(updatedContent ?? fileContent, buildConfigString, buildConfigObject, 'build');
     }
-    var _handlePluginNode;
-    updatedContent = (_handlePluginNode = handlePluginNode(updatedContent != null ? updatedContent : fileContent, imports, plugins)) != null ? _handlePluginNode : updatedContent;
-    if (cacheDir == null ? void 0 : cacheDir.length) {
-        updatedContent = handleCacheDirNode(updatedContent != null ? updatedContent : fileContent, cacheDir);
+    updatedContent =
+        handlePluginNode(updatedContent ?? fileContent, imports, plugins) ??
+            updatedContent;
+    if (cacheDir?.length) {
+        updatedContent = handleCacheDirNode(updatedContent ?? fileContent, cacheDir);
     }
     if (updatedContent) {
         tree.write(path, updatedContent);
         return true;
-    } else {
+    }
+    else {
         return false;
     }
 }
@@ -32,124 +30,140 @@ function handleBuildOrTestNode(updatedFileContent, configContentString, configCo
     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)=>{
+        return tsquery.replace(updatedFileContent, `PropertyAssignment:has(Identifier[name="${name}"])`, (node) => {
             const existingProperties = tsquery.query(node.initializer, 'PropertyAssignment');
             let updatedPropsString = '';
-            for (const prop of existingProperties){
+            for (const prop of existingProperties) {
                 const propName = prop.name.getText();
-                if (!configContentObject[propName] && propName !== 'dir' && propName !== 'reportsDirectory' && propName !== 'provider') {
+                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)){
+            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)){
+                    for (const [pName, pValue] of Object.entries(propValue)) {
                         if (pName === 'provider') {
                             propString += `    '${pName}': ${pValue} as const,\n`;
-                        } else {
+                        }
+                        else {
                             propString += `    '${pName}': '${pValue}',\n`;
                         }
                     }
                     propString += `}`;
                     updatedPropsString += `${propString}\n`;
-                } else if (propName === 'lib') {
+                }
+                else if (propName === 'lib') {
                     let propString = `    '${propName}': {\n`;
-                    for (const [pName, pValue] of Object.entries(propValue)){
+                    for (const [pName, pValue] of Object.entries(propValue)) {
                         if (pName === 'formats') {
-                            propString += `      '${pName}': [${pValue.map((format)=>`'${format}' as const`).join(', ')}],\n`;
-                        } else {
+                            propString += `      '${pName}': [${pValue
+                                .map((format) => `'${format}' as const`)
+                                .join(', ')}],\n`;
+                        }
+                        else {
                             propString += `      '${pName}': ${JSON.stringify(pValue)},\n`;
                         }
                     }
                     propString += `    },`;
                     updatedPropsString += `${propString}\n`;
-                } else {
+                }
+                else {
                     updatedPropsString += `    '${propName}': ${JSON.stringify(propValue)},\n`;
                 }
             }
             return `${name}: {
 ${updatedPropsString}  }`;
         });
-    } else {
+    }
+    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 {
+                }
+                else {
                     // no test config in conditional config
                     return updatedFileContent;
                 }
-            } else {
+            }
+            else {
                 const propertyAssignments = tsquery.query(foundDefineConfig[0], 'PropertyAssignment');
                 if (propertyAssignments.length) {
-                    return (0, _devkit.applyChangesToString)(updatedFileContent, [
+                    return (0, devkit_1.applyChangesToString)(updatedFileContent, [
                         {
-                            type: _devkit.ChangeType.Insert,
+                            type: devkit_1.ChangeType.Insert,
                             index: propertyAssignments[0].getStart(),
-                            text: configContentString
-                        }
+                            text: configContentString,
+                        },
                     ]);
-                } else {
-                    return (0, _devkit.applyChangesToString)(updatedFileContent, [
+                }
+                else {
+                    return (0, devkit_1.applyChangesToString)(updatedFileContent, [
                         {
-                            type: _devkit.ChangeType.Insert,
+                            type: devkit_1.ChangeType.Insert,
                             index: foundDefineConfig[0].getStart() + 14,
-                            text: configContentString
-                        }
+                            text: configContentString,
+                        },
                     ]);
                 }
             }
-        } else {
+        }
+        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 == null ? void 0 : defaultExport[0], 'ObjectLiteralExpression');
-                const startOfObject = found == null ? void 0 : found[0].getStart();
-                return (0, _devkit.applyChangesToString)(updatedFileContent, [
+                const found = tsquery.query(defaultExport?.[0], 'ObjectLiteralExpression');
+                const startOfObject = found?.[0].getStart();
+                return (0, devkit_1.applyChangesToString)(updatedFileContent, [
                     {
-                        type: _devkit.ChangeType.Insert,
+                        type: devkit_1.ChangeType.Insert,
                         index: startOfObject + 1,
-                        text: configContentString
-                    }
+                        text: configContentString,
+                    },
                 ]);
-            } catch (e) {
+            }
+            catch {
                 return updatedFileContent;
             }
         }
     }
 }
 function transformCurrentBuildObject(index, returnStatements, appFileContent, buildConfigObject) {
-    var _tsquery_query;
-    if (!(returnStatements == null ? void 0 : returnStatements[index])) {
+    if (!returnStatements?.[index]) {
         return undefined;
     }
     const { tsquery } = require('@phenomnomnominal/tsquery');
-    const currentBuildObject = (_tsquery_query = tsquery.query(returnStatements[index], 'ObjectLiteralExpression')) == null ? void 0 : _tsquery_query[0].getText();
+    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)=>{
+    const newReturnObject = tsquery.replace(returnStatements[index].getText(), 'ObjectLiteralExpression', (_node) => {
         return `{
         ...${currentBuildObject},
         ...${JSON.stringify(buildConfigObject)}
       }`;
     });
-    const newContents = (0, _devkit.applyChangesToString)(appFileContent, [
+    const newContents = (0, devkit_1.applyChangesToString)(appFileContent, [
         {
-            type: _devkit.ChangeType.Delete,
+            type: devkit_1.ChangeType.Delete,
             start: currentBuildObjectStart,
-            length: currentBuildObjectEnd - currentBuildObjectStart
+            length: currentBuildObjectEnd - currentBuildObjectStart,
         },
         {
-            type: _devkit.ChangeType.Insert,
+            type: devkit_1.ChangeType.Insert,
             index: currentBuildObjectStart,
-            text: newReturnObject
-        }
+            text: newReturnObject,
+        },
     ]);
     return newContents;
 }
@@ -157,40 +171,40 @@ function transformConditionalConfig(conditionalConfig, appFileContent, buildConf
     const { tsquery } = require('@phenomnomnominal/tsquery');
     const { SyntaxKind } = require('typescript');
     const functionBlock = tsquery.query(conditionalConfig[0], 'Block');
-    const ifStatement = tsquery.query(functionBlock == null ? void 0 : functionBlock[0], 'IfStatement');
-    const binaryExpressions = tsquery.query(ifStatement == null ? void 0 : ifStatement[0], 'BinaryExpression');
-    const buildExists = binaryExpressions == null ? void 0 : binaryExpressions.find((binaryExpression)=>binaryExpression.getText() === `command === 'build'`);
-    const buildExistsExpressionIndex = binaryExpressions == null ? void 0 : binaryExpressions.findIndex((binaryExpression)=>binaryExpression.getText() === `command === 'build'`);
-    const serveExists = binaryExpressions == null ? void 0 : binaryExpressions.find((binaryExpression)=>binaryExpression.getText() === `command === 'serve'`);
-    const elseKeywordExists = (0, _js.findNodes)(ifStatement == null ? void 0 : ifStatement[0], SyntaxKind.ElseKeyword);
+    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) {
-            var _transformCurrentBuildObject;
             // build options live inside the else block
-            return (_transformCurrentBuildObject = transformCurrentBuildObject((returnStatements == null ? void 0 : returnStatements.length) - 1, returnStatements, appFileContent, buildConfigObject)) != null ? _transformCurrentBuildObject : appFileContent;
-        } else {
+            return (transformCurrentBuildObject(returnStatements?.length - 1, returnStatements, appFileContent, buildConfigObject) ?? appFileContent);
+        }
+        else {
             // no build options exist yet
-            const functionBlockStart = functionBlock == null ? void 0 : functionBlock[0].getStart();
-            const newContents = (0, _devkit.applyChangesToString)(appFileContent, [
+            const functionBlockStart = functionBlock?.[0].getStart();
+            const newContents = (0, devkit_1.applyChangesToString)(appFileContent, [
                 {
-                    type: _devkit.ChangeType.Insert,
+                    type: devkit_1.ChangeType.Insert,
                     index: functionBlockStart + 1,
                     text: `
             if (command === 'build') {
               return ${JSON.stringify(buildConfigObject)}
             }
-            `
-                }
+            `,
+                },
             ]);
             return newContents;
         }
-    } else {
-        var _transformCurrentBuildObject1;
+    }
+    else {
         // build already exists
         // it will be the return statement which lives
         // at the buildExistsExpressionIndex
-        return (_transformCurrentBuildObject1 = transformCurrentBuildObject(buildExistsExpressionIndex, returnStatements, appFileContent, buildConfigObject)) != null ? _transformCurrentBuildObject1 : appFileContent;
+        return (transformCurrentBuildObject(buildExistsExpressionIndex, returnStatements, appFileContent, buildConfigObject) ?? appFileContent);
     }
 }
 function handlePluginNode(appFileContent, imports, plugins) {
@@ -199,23 +213,23 @@ function handlePluginNode(appFileContent, imports, plugins) {
     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)=>{
+        appFileContent = tsquery.replace(file.getText(), 'PropertyAssignment:has(Identifier[name="plugins"])', (node) => {
             const found = tsquery.query(node, 'ArrayLiteralExpression');
             let updatedPluginsString = '';
-            var _found__elements;
-            const existingPluginNodes = (_found__elements = found == null ? void 0 : found[0].elements) != null ? _found__elements : [];
-            for (const plugin of existingPluginNodes){
+            const existingPluginNodes = found?.[0].elements ?? [];
+            for (const plugin of existingPluginNodes) {
                 updatedPluginsString += `${plugin.getText()}, `;
             }
-            for (const plugin of plugins){
-                if (!(existingPluginNodes == null ? void 0 : existingPluginNodes.some((node)=>node.getText().includes(plugin)))) {
+            for (const plugin of plugins) {
+                if (!existingPluginNodes?.some((node) => node.getText().includes(plugin))) {
                     updatedPluginsString += `${plugin}, `;
                 }
             }
             return `plugins: [${updatedPluginsString}]`;
         });
         writeFile = true;
-    } else {
+    }
+    else {
         // Plugins node does not exist yet
         // So make one from scratch
         const foundDefineConfig = tsquery.query(file, 'CallExpression:has(Identifier[name="defineConfig"])');
@@ -225,44 +239,48 @@ function handlePluginNode(appFileContent, imports, plugins) {
                 // We are NOT transforming the conditional config
                 // with plugins
                 writeFile = false;
-            } else {
+            }
+            else {
                 const propertyAssignments = tsquery.query(foundDefineConfig[0], 'PropertyAssignment');
                 if (propertyAssignments.length) {
-                    appFileContent = (0, _devkit.applyChangesToString)(appFileContent, [
+                    appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
                         {
-                            type: _devkit.ChangeType.Insert,
+                            type: devkit_1.ChangeType.Insert,
                             index: propertyAssignments[0].getStart(),
-                            text: `plugins: [${plugins.join(', ')}],`
-                        }
+                            text: `plugins: [${plugins.join(', ')}],`,
+                        },
                     ]);
                     writeFile = true;
-                } else {
-                    appFileContent = (0, _devkit.applyChangesToString)(appFileContent, [
+                }
+                else {
+                    appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
                         {
-                            type: _devkit.ChangeType.Insert,
+                            type: devkit_1.ChangeType.Insert,
                             index: foundDefineConfig[0].getStart() + 14,
-                            text: `plugins: [${plugins.join(', ')}],`
-                        }
+                            text: `plugins: [${plugins.join(', ')}],`,
+                        },
                     ]);
                     writeFile = true;
                 }
             }
-        } else {
+        }
+        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 == null ? void 0 : tsquery.query(defaultExport == null ? void 0 : defaultExport[0], 'ObjectLiteralExpression');
-                const startOfObject = found == null ? void 0 : found[0].getStart();
-                appFileContent = (0, _devkit.applyChangesToString)(appFileContent, [
+                const found = tsquery?.query(defaultExport?.[0], 'ObjectLiteralExpression');
+                const startOfObject = found?.[0].getStart();
+                appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
                     {
-                        type: _devkit.ChangeType.Insert,
+                        type: devkit_1.ChangeType.Insert,
                         index: startOfObject + 1,
-                        text: `plugins: [${plugins.join(', ')}],`
-                    }
+                        text: `plugins: [${plugins.join(', ')}],`,
+                    },
                 ]);
                 writeFile = true;
-            } catch (e) {
+            }
+            catch {
                 writeFile = false;
             }
         }
@@ -276,64 +294,66 @@ 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 == null ? void 0 : importNodes.map((node)=>{
+    const importsArrayExisting = importNodes?.map((node) => {
         return node.getText().slice(0, -1);
     });
-    return imports.filter((importString)=>{
-        return !(importsArrayExisting == null ? void 0 : importsArrayExisting.includes(importString));
+    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 == null ? void 0 : cacheDirNode.length) || (cacheDirNode == null ? void 0 : cacheDirNode.length) === 0) {
+    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 {
+                // We are NOT transforming the conditional config
+                // with cacheDir
+            }
+            else {
                 const propertyAssignments = tsquery.query(foundDefineConfig[0], 'PropertyAssignment');
                 if (propertyAssignments.length) {
-                    appFileContent = (0, _devkit.applyChangesToString)(appFileContent, [
+                    appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
                         {
-                            type: _devkit.ChangeType.Insert,
+                            type: devkit_1.ChangeType.Insert,
                             index: propertyAssignments[0].getStart(),
-                            text: cacheDir
-                        }
+                            text: cacheDir,
+                        },
                     ]);
-                } else {
-                    appFileContent = (0, _devkit.applyChangesToString)(appFileContent, [
+                }
+                else {
+                    appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
                         {
-                            type: _devkit.ChangeType.Insert,
+                            type: devkit_1.ChangeType.Insert,
                             index: foundDefineConfig[0].getStart() + 14,
-                            text: cacheDir
-                        }
+                            text: cacheDir,
+                        },
                     ]);
                 }
             }
-        } else {
+        }
+        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 == null ? void 0 : tsquery.query(defaultExport == null ? void 0 : defaultExport[0], 'ObjectLiteralExpression');
-                const startOfObject = found == null ? void 0 : found[0].getStart();
-                appFileContent = (0, _devkit.applyChangesToString)(appFileContent, [
+                const found = tsquery?.query(defaultExport?.[0], 'ObjectLiteralExpression');
+                const startOfObject = found?.[0].getStart();
+                appFileContent = (0, devkit_1.applyChangesToString)(appFileContent, [
                     {
-                        type: _devkit.ChangeType.Insert,
+                        type: devkit_1.ChangeType.Insert,
                         index: startOfObject + 1,
-                        text: cacheDir
-                    }
+                        text: cacheDir,
+                    },
                 ]);
-            } catch (e) {}
+            }
+            catch { }
         }
     }
     return appFileContent;
 }
-
-//# sourceMappingURL=vite-config-edit-utils.js.map

package/executors.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../packages/vite/executors.ts"],"sourcesContent":["export { type ViteBuildExecutorOptions } from './src/executors/build/schema';\nexport { viteBuildExecutor } from './src/executors/build/build.impl';\nexport { type ViteDevServerExecutorOptions } from './src/executors/dev-server/schema';\nexport { viteDevServerExecutor } from './src/executors/dev-server/dev-server.impl';\nexport { type VitePreviewServerExecutorOptions } from './src/executors/preview-server/schema';\nexport { vitePreviewServerExecutor } from './src/executors/preview-server/preview-server.impl';\nexport { type VitestExecutorOptions } from './src/executors/test/schema';\nexport { vitestExecutor } from './src/executors/test/vitest.impl';\n"],"names":["viteBuildExecutor","viteDevServerExecutor","vitePreviewServerExecutor","vitestExecutor"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IACSA,iBAAiB;eAAjBA,4BAAiB;;IAEjBC,qBAAqB;eAArBA,oCAAqB;;IAErBC,yBAAyB;eAAzBA,4CAAyB;;IAEzBC,cAAc;eAAdA,0BAAc;;;2BANW;+BAEI;mCAEI;4BAEX"}

package/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../packages/vite/index.ts"],"sourcesContent":["export * from './src/utils/versions';\nexport * from './src/utils/generator-utils';\nexport * from './src/utils/e2e-web-server-info-utils';\nexport { type ViteConfigurationGeneratorSchema } from './src/generators/configuration/schema';\nexport { viteConfigurationGenerator } from './src/generators/configuration/configuration';\nexport { type VitestGeneratorSchema } from './src/generators/vitest/schema';\nexport { vitestGenerator } from './src/generators/vitest/vitest-generator';\nexport { type InitGeneratorSchema } from './src/generators/init/schema';\nexport { initGenerator } from './src/generators/init/init';\n"],"names":["initGenerator","viteConfigurationGenerator","vitestGenerator"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IAQSA,aAAa;eAAbA,mBAAa;;IAJbC,0BAA0B;eAA1BA,yCAA0B;;IAE1BC,eAAe;eAAfA,gCAAe;;;;uBANV;uBACA;uBACA;+BAE6B;iCAEX;sBAEF"}

package/plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../packages/vite/plugin.ts"],"sourcesContent":["export {\n  createNodes,\n  createNodesV2,\n  VitePluginOptions,\n  createDependencies,\n} from './src/plugins/plugin';\n"],"names":["VitePluginOptions","createDependencies","createNodes","createNodesV2"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;IAGEA,iBAAiB;eAAjBA,yBAAiB;;IACjBC,kBAAkB;eAAlBA,0BAAkB;;IAHlBC,WAAW;eAAXA,mBAAW;;IACXC,aAAa;eAAbA,qBAAa;;;wBAGR"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../packages/vite/plugins/nx-copy-assets.plugin.ts"],"sourcesContent":["import { join, relative } from 'node:path';\nimport type { Plugin, ResolvedConfig } from 'vite';\nimport { isDaemonEnabled, joinPathFragments, workspaceRoot } from '@nx/devkit';\nimport { AssetGlob } from '@nx/js/src/utils/assets/assets';\nimport { CopyAssetsHandler } from '@nx/js/src/utils/assets/copy-assets-handler';\n\nexport function nxCopyAssetsPlugin(_assets: (string | AssetGlob)[]): Plugin {\n  let config: ResolvedConfig;\n  let handler: CopyAssetsHandler;\n  let dispose: () => void;\n\n  if (global.NX_GRAPH_CREATION) return;\n\n  return {\n    name: 'nx-copy-assets-plugin',\n    configResolved(_config) {\n      config = _config;\n    },\n    async buildStart() {\n      const relativeProjectRoot = relative(workspaceRoot, config.root);\n      const assets = _assets.map((a) => {\n        if (typeof a === 'string') {\n          return joinPathFragments(relativeProjectRoot, a);\n        } else {\n          return {\n            ...a,\n            input: joinPathFragments(relativeProjectRoot, a.input),\n          };\n        }\n      });\n      handler = new CopyAssetsHandler({\n        rootDir: workspaceRoot,\n        projectDir: config.root,\n        outputDir: config.build.outDir.startsWith(config.root)\n          ? config.build.outDir\n          : join(config.root, config.build.outDir),\n        assets,\n      });\n      if (this.meta.watchMode && isDaemonEnabled()) {\n        dispose = await handler.watchAndProcessOnAssetChange();\n      }\n    },\n    async writeBundle() {\n      await handler.processAllAssetsOnce();\n    },\n    async closeWatcher() {\n      dispose == null ? void 0 : dispose();\n    },\n  };\n}\n"],"names":["nxCopyAssetsPlugin","_assets","config","handler","dispose","global","NX_GRAPH_CREATION","name","configResolved","_config","buildStart","relativeProjectRoot","relative","workspaceRoot","root","assets","map","a","joinPathFragments","input","CopyAssetsHandler","rootDir","projectDir","outputDir","build","outDir","startsWith","join","meta","watchMode","isDaemonEnabled","watchAndProcessOnAssetChange","writeBundle","processAllAssetsOnce","closeWatcher"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAMgBA;;;eAAAA;;;;0BANe;wBAEmC;mCAEhC;AAE3B,SAASA,mBAAmBC,OAA+B;IAChE,IAAIC;IACJ,IAAIC;IACJ,IAAIC;IAEJ,IAAIC,OAAOC,iBAAiB,EAAE;IAE9B,OAAO;QACLC,MAAM;QACNC,gBAAeC,OAAO;YACpBP,SAASO;QACX;QACA,MAAMC;YACJ,MAAMC,sBAAsBC,IAAAA,kBAAQ,EAACC,qBAAa,EAAEX,OAAOY,IAAI;YAC/D,MAAMC,SAASd,QAAQe,GAAG,CAAC,CAACC;gBAC1B,IAAI,OAAOA,MAAM,UAAU;oBACzB,OAAOC,IAAAA,yBAAiB,EAACP,qBAAqBM;gBAChD,OAAO;oBACL,OAAO,eACFA;wBACHE,OAAOD,IAAAA,yBAAiB,EAACP,qBAAqBM,EAAEE,KAAK;;gBAEzD;YACF;YACAhB,UAAU,IAAIiB,oCAAiB,CAAC;gBAC9BC,SAASR,qBAAa;gBACtBS,YAAYpB,OAAOY,IAAI;gBACvBS,WAAWrB,OAAOsB,KAAK,CAACC,MAAM,CAACC,UAAU,CAACxB,OAAOY,IAAI,IACjDZ,OAAOsB,KAAK,CAACC,MAAM,GACnBE,IAAAA,cAAI,EAACzB,OAAOY,IAAI,EAAEZ,OAAOsB,KAAK,CAACC,MAAM;gBACzCV;YACF;YACA,IAAI,IAAI,CAACa,IAAI,CAACC,SAAS,IAAIC,IAAAA,uBAAe,KAAI;gBAC5C1B,UAAU,MAAMD,QAAQ4B,4BAA4B;YACtD;QACF;QACA,MAAMC;YACJ,MAAM7B,QAAQ8B,oBAAoB;QACpC;QACA,MAAMC;YACJ9B,WAAW,OAAO,KAAK,IAAIA;QAC7B;IACF;AACF"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../packages/vite/plugins/nx-tsconfig-paths.plugin.ts"],"sourcesContent":["import {\n  createProjectGraphAsync,\n  joinPathFragments,\n  stripIndents,\n  workspaceRoot,\n} from '@nx/devkit';\nimport { copyFileSync, existsSync } from 'node:fs';\nimport { join, relative, resolve } from 'node:path';\nimport {\n  loadConfig,\n  createMatchPath,\n  MatchPath,\n  ConfigLoaderSuccessResult,\n} from 'tsconfig-paths';\nimport {\n  calculateProjectBuildableDependencies,\n  createTmpTsConfig,\n} from '@nx/js/src/utils/buildable-libs-utils';\nimport { Plugin } from 'vite';\nimport { nxViteBuildCoordinationPlugin } from './nx-vite-build-coordination.plugin';\nimport { findFile } from '../src/utils/nx-tsconfig-paths-find-file';\nimport { isUsingTsSolutionSetup } from '@nx/js/src/utils/typescript/ts-solution-setup';\nimport { getProjectTsConfigPath } from '../src/utils/options-utils';\n\nexport interface nxViteTsPathsOptions {\n  /**\n   * Enable debug logging\n   * If set to false, it will always ignore the debug logging even when `--verbose` or `NX_VERBOSE_LOGGING` is set to true.\n   * @default undefined\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   * Inform Nx whether to use the raw source or to use the built output for buildable dependencies.\n   * Set to `false` to use incremental builds.\n   * @default true\n   */\n  buildLibsFromSource?: boolean;\n}\n\nexport function nxViteTsPaths(options: nxViteTsPathsOptions = {}) {\n  let foundTsConfigPath: string;\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    '.mts',\n    '.mjs',\n    '.cts',\n    '.cjs',\n    '.css',\n    '.scss',\n    '.less',\n  ];\n  options.mainFields ??= [['exports', '.', 'import'], 'module', 'main'];\n  options.buildLibsFromSource ??= true;\n  let projectRoot = '';\n\n  return {\n    name: 'nx-vite-ts-paths',\n    // Ensure the resolveId aspect of the plugin is called before vite's internal resolver\n    // Otherwise, issues can arise with Yarn Workspaces and Pnpm Workspaces\n    enforce: 'pre',\n    async configResolved(config: any) {\n      projectRoot = config.root;\n      const projectRootFromWorkspaceRoot = relative(workspaceRoot, projectRoot);\n      foundTsConfigPath = getTsConfig(\n        process.env.NX_TSCONFIG_PATH ??\n          join(\n            workspaceRoot,\n            'tmp',\n            projectRootFromWorkspaceRoot,\n            process.env.NX_TASK_TARGET_TARGET ?? 'build',\n            'tsconfig.generated.json'\n          )\n      );\n\n      if (!foundTsConfigPath) return;\n\n      if (\n        !options.buildLibsFromSource &&\n        !global.NX_GRAPH_CREATION &&\n        config.mode !== 'test'\n      ) {\n        const projectGraph = await createProjectGraphAsync({\n          exitOnError: false,\n          resetDaemonClient: true,\n        });\n        // When using incremental building and the serve target is called\n        // we need to get the deps for the 'build' target instead.\n        const depsBuildTarget =\n          process.env.NX_TASK_TARGET_TARGET === 'serve'\n            ? 'build'\n            : process.env.NX_TASK_TARGET_TARGET;\n        const { dependencies } = calculateProjectBuildableDependencies(\n          undefined,\n          projectGraph,\n          workspaceRoot,\n          process.env.NX_TASK_TARGET_PROJECT,\n          depsBuildTarget,\n          process.env.NX_TASK_TARGET_CONFIGURATION\n        );\n        // This tsconfig is used via the Vite ts paths plugin.\n        // It can be also used by other user-defined Vite plugins (e.g. for creating type declaration files).\n        foundTsConfigPath = createTmpTsConfig(\n          foundTsConfigPath,\n          workspaceRoot,\n          relative(workspaceRoot, projectRoot),\n          dependencies,\n          true\n        );\n\n        if (config.command === 'serve') {\n          const buildableLibraryDependencies = dependencies\n            .filter((dep) => dep.node.type === 'lib')\n            .map((dep) => dep.node.name)\n            .join(',');\n          const buildCommand = `npx nx run-many --target=${depsBuildTarget} --projects=${buildableLibraryDependencies}`;\n          config.plugins.push(nxViteBuildCoordinationPlugin({ buildCommand }));\n        }\n      }\n\n      const parsed = loadConfig(foundTsConfigPath);\n\n      logIt('first parsed tsconfig: ', parsed);\n      if (parsed.resultType === 'failed') {\n        throw new Error(`Failed loading tsconfig 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 other resolvers handle this path.\n      if (!foundTsConfigPath) return null;\n\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 || !existsSync(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    async writeBundle(options) {\n      if (isUsingTsSolutionSetup()) return;\n      const outDir = options.dir || 'dist';\n      const src = resolve(projectRoot, 'package.json');\n      if (existsSync(src)) {\n        const dest = join(outDir, 'package.json');\n\n        try {\n          copyFileSync(src, dest);\n        } catch (err) {\n          console.error('Error copying package.json:', err);\n        }\n      }\n    },\n  } as Plugin;\n\n  function getTsConfig(preferredTsConfigPath: string): string {\n    const projectTsConfigPath = getProjectTsConfigPath(projectRoot);\n    return [\n      resolve(preferredTsConfigPath),\n      projectTsConfigPath ? resolve(projectTsConfigPath) : null,\n      resolve(join(workspaceRoot, 'tsconfig.base.json')),\n      resolve(join(workspaceRoot, 'tsconfig.json')),\n      resolve(join(workspaceRoot, 'jsconfig.json')),\n    ]\n      .filter(Boolean)\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 !== false) {\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 (\n        importPath === normalizedImport ||\n        importPath.startsWith(normalizedImport + '/')\n      ) {\n        const joinedPath = joinPathFragments(\n          tsconfig.absoluteBaseUrl,\n          paths[0].replace(/\\/\\*$/, '')\n        );\n\n        resolvedFile = findFile(\n          importPath.replace(normalizedImport, joinedPath),\n          options.extensions\n        );\n\n        if (\n          resolvedFile === undefined &&\n          options.extensions.some((ext) => importPath.endsWith(ext))\n        ) {\n          const foundExtension = options.extensions.find((ext) =>\n            importPath.endsWith(ext)\n          );\n          const pathWithoutExtension = importPath\n            .replace(normalizedImport, joinedPath)\n            .slice(0, -foundExtension.length);\n          resolvedFile = findFile(pathWithoutExtension, options.extensions);\n        }\n      }\n    }\n\n    return resolvedFile;\n  }\n}\n"],"names":["nxViteTsPaths","options","foundTsConfigPath","matchTsPathEsm","matchTsPathFallback","tsConfigPathsEsm","tsConfigPathsFallback","extensions","mainFields","buildLibsFromSource","projectRoot","name","enforce","configResolved","config","root","projectRootFromWorkspaceRoot","relative","workspaceRoot","process","getTsConfig","env","NX_TSCONFIG_PATH","join","NX_TASK_TARGET_TARGET","global","NX_GRAPH_CREATION","mode","projectGraph","createProjectGraphAsync","exitOnError","resetDaemonClient","depsBuildTarget","dependencies","calculateProjectBuildableDependencies","undefined","NX_TASK_TARGET_PROJECT","NX_TASK_TARGET_CONFIGURATION","createTmpTsConfig","command","buildableLibraryDependencies","filter","dep","node","type","map","buildCommand","plugins","push","nxViteBuildCoordinationPlugin","parsed","loadConfig","logIt","resultType","Error","createMatchPath","absoluteBaseUrl","paths","rootLevelTsConfig","rootLevelParsed","resolveId","importPath","resolvedFile","e","existsSync","loadFileFromPaths","writeBundle","isUsingTsSolutionSetup","outDir","dir","src","resolve","dest","copyFileSync","err","console","error","preferredTsConfigPath","projectTsConfigPath","getProjectTsConfigPath","Boolean","find","tsPath","msg","NX_VERBOSE_LOGGING","debug","tsconfig","configFileAbsolutePath","alias","normalizedImport","replace","startsWith","joinedPath","joinPathFragments","findFile","some","ext","endsWith","foundExtension","pathWithoutExtension","slice","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/plugins/nx-vite-build-coordination.plugin.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../packages/vite/plugins/nx-vite-build-coordination.plugin.ts"],"sourcesContent":["import { type Plugin } from 'vite';\nimport { BatchFunctionRunner } from 'nx/src/command-line/watch/watch';\nimport { exec, type ChildProcess } from 'child_process';\nimport {\n  daemonClient,\n  type UnregisterCallback,\n} from 'nx/src/daemon/client/client';\nimport { output } from 'nx/src/utils/output';\n\nexport interface NxViteBuildCoordinationPluginOptions {\n  buildCommand: string;\n}\nexport function nxViteBuildCoordinationPlugin(\n  options: NxViteBuildCoordinationPluginOptions\n): Plugin {\n  let activeBuildProcess: ChildProcess | undefined;\n  let unregisterFileWatcher: UnregisterCallback | undefined;\n\n  async function buildChangedProjects() {\n    await new Promise<void>((res) => {\n      activeBuildProcess = exec(options.buildCommand, {\n        windowsHide: false,\n      });\n      activeBuildProcess.stdout.pipe(process.stdout);\n      activeBuildProcess.stderr.pipe(process.stderr);\n      activeBuildProcess.on('exit', () => {\n        res();\n      });\n      activeBuildProcess.on('error', () => {\n        res();\n      });\n    });\n    activeBuildProcess = undefined;\n  }\n\n  function createFileWatcher() {\n    const runner = new BatchFunctionRunner(() => buildChangedProjects());\n    return daemonClient.registerFileWatcher(\n      { watchProjects: 'all' },\n      (err, { changedProjects, changedFiles }) => {\n        if (err === 'closed') {\n          output.error({\n            title: 'Watch connection closed',\n            bodyLines: [\n              'The daemon had closed the connection to this watch process.',\n              'Please restart your watch command.',\n            ],\n          });\n          process.exit(1);\n        }\n\n        if (activeBuildProcess) {\n          activeBuildProcess.kill(2);\n          activeBuildProcess = undefined;\n        }\n\n        runner.enqueue(changedProjects, changedFiles);\n      }\n    );\n  }\n\n  let firstBuildStart = true;\n\n  return {\n    name: 'nx-vite-build-coordination-plugin',\n    async buildStart() {\n      if (firstBuildStart) {\n        firstBuildStart = false;\n        await buildChangedProjects();\n        if (daemonClient.enabled()) {\n          unregisterFileWatcher = await createFileWatcher();\n          process.on('exit', () => unregisterFileWatcher());\n          process.on('SIGINT', () => process.exit());\n        } else {\n          output.warn({\n            title:\n              'Nx Daemon is not enabled. Projects will not be rebuilt when files change.',\n          });\n        }\n      }\n    },\n  };\n}\n"],"names":["nxViteBuildCoordinationPlugin","options","activeBuildProcess","unregisterFileWatcher","buildChangedProjects","Promise","res","exec","buildCommand","windowsHide","stdout","pipe","process","stderr","on","undefined","createFileWatcher","runner","BatchFunctionRunner","daemonClient","registerFileWatcher","watchProjects","err","changedProjects","changedFiles","output","error","title","bodyLines","exit","kill","enqueue","firstBuildStart","name","buildStart","enabled","warn"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";+BAYgBA;;;eAAAA;;;uBAXoB;+BACI;wBAIjC;wBACgB;AAKhB,SAASA,8BACdC,OAA6C;IAE7C,IAAIC;IACJ,IAAIC;IAEJ,eAAeC;QACb,MAAM,IAAIC,QAAc,CAACC;YACvBJ,qBAAqBK,IAAAA,mBAAI,EAACN,QAAQO,YAAY,EAAE;gBAC9CC,aAAa;YACf;YACAP,mBAAmBQ,MAAM,CAACC,IAAI,CAACC,QAAQF,MAAM;YAC7CR,mBAAmBW,MAAM,CAACF,IAAI,CAACC,QAAQC,MAAM;YAC7CX,mBAAmBY,EAAE,CAAC,QAAQ;gBAC5BR;YACF;YACAJ,mBAAmBY,EAAE,CAAC,SAAS;gBAC7BR;YACF;QACF;QACAJ,qBAAqBa;IACvB;IAEA,SAASC;QACP,MAAMC,SAAS,IAAIC,0BAAmB,CAAC,IAAMd;QAC7C,OAAOe,oBAAY,CAACC,mBAAmB,CACrC;YAAEC,eAAe;QAAM,GACvB,CAACC,KAAK,EAAEC,eAAe,EAAEC,YAAY,EAAE;YACrC,IAAIF,QAAQ,UAAU;gBACpBG,cAAM,CAACC,KAAK,CAAC;oBACXC,OAAO;oBACPC,WAAW;wBACT;wBACA;qBACD;gBACH;gBACAhB,QAAQiB,IAAI,CAAC;YACf;YAEA,IAAI3B,oBAAoB;gBACtBA,mBAAmB4B,IAAI,CAAC;gBACxB5B,qBAAqBa;YACvB;YAEAE,OAAOc,OAAO,CAACR,iBAAiBC;QAClC;IAEJ;IAEA,IAAIQ,kBAAkB;IAEtB,OAAO;QACLC,MAAM;QACN,MAAMC;YACJ,IAAIF,iBAAiB;gBACnBA,kBAAkB;gBAClB,MAAM5B;gBACN,IAAIe,oBAAY,CAACgB,OAAO,IAAI;oBAC1BhC,wBAAwB,MAAMa;oBAC9BJ,QAAQE,EAAE,CAAC,QAAQ,IAAMX;oBACzBS,QAAQE,EAAE,CAAC,UAAU,IAAMF,QAAQiB,IAAI;gBACzC,OAAO;oBACLJ,cAAM,CAACW,IAAI,CAAC;wBACVT,OACE;oBACJ;gBACF;YACF;QACF;IACF;AACF"}

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

@@ -1 +0,0 @@
-{"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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","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.js.map

@@ -1 +0,0 @@
-{"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 {\n  combineAsyncIterables,\n  createAsyncIterable,\n} from '@nx/devkit/src/utils/async-iterable';\nimport {\n  createBuildableTsConfig,\n  loadViteDynamicImport,\n  validateTypes,\n} from '../../utils/executor-utils';\nimport { type Plugin } from 'vite';\nimport { isUsingTsSolutionSetup } from '@nx/js/src/utils/typescript/ts-solution-setup';\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, resolveConfig, createBuilder } =\n    await loadViteDynamicImport();\n  const projectRoot =\n    context.projectsConfigurations.projects[context.projectName].root;\n  const tsConfigForBuild = createBuildableTsConfig(\n    projectRoot,\n    options,\n    context\n  );\n\n  const viteConfigPath = normalizeViteConfigFilePath(\n    context.root,\n    projectRoot,\n    options.configFile\n  );\n  const root =\n    projectRoot === '.' || projectRoot === ''\n      ? process.cwd()\n      : relative(context.cwd, joinPathFragments(context.root, projectRoot));\n\n  const { buildOptions, otherOptions } = await getBuildExtraArgs(options);\n  const defaultMode = otherOptions?.mode ?? 'production';\n\n  const resolved = await resolveConfig(\n    {\n      configFile: viteConfigPath,\n      mode: defaultMode,\n    },\n    'build',\n    defaultMode,\n    process.env.NODE_ENV ?? defaultMode\n  );\n\n  const outDir =\n    joinPathFragments(offsetFromRoot(projectRoot), options.outputPath) ??\n    resolved?.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.root ?? root,\n      configFile: viteConfigPath,\n    },\n    {\n      build: {\n        outDir,\n        ...buildOptions,\n      },\n      ...otherOptions,\n    }\n  );\n  // New TS Solution already has a typecheck target\n  if (!options.skipTypeCheck && !isUsingTsSolutionSetup()) {\n    await validateTypes({\n      workspaceRoot: context.root,\n      tsconfig: tsConfigForBuild,\n      isVueProject: Boolean(\n        resolved.plugins?.find(\n          (plugin: Plugin) =>\n            typeof plugin === 'object' && plugin?.name === 'vite:vue'\n        )\n      ),\n    });\n  }\n\n  const builder =\n    createBuilder !== undefined && options.useEnvironmentsApi\n      ? await createBuilder(buildConfig)\n      : // This is needed to ensure support for Vite 5\n        {\n          build: (inlineConfig) => build(inlineConfig),\n          environments: { build: buildConfig },\n        };\n\n  let iterables: AsyncIterable<{ success: boolean; outfile?: string }>[] = [];\n  for (const env of Object.values(builder.environments)) {\n    // This is needed to overwrite the resolve build config with executor options in Vite 6\n    if (env.config?.build) {\n      env.config.build = {\n        ...env.config.build,\n        ...buildConfig.build,\n      };\n    }\n    const watcherOrOutput = await builder.build(env as any);\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 absoluteOutDir = resolve(resolve(context.root, projectRoot), outDir);\n    const outDirRelativeToWorkspaceRoot = relative(\n      context.root,\n      absoluteOutDir\n    );\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/nx-api/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          skipOverrides: options.skipOverrides,\n          skipPackageManager: options.skipPackageManager,\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      if (packageManager === 'bun') {\n        logger.warn(\n          'Bun lockfile generation is not supported. The generated package.json will not include a lockfile. Run \"bun install\" in the output directory after deployment if needed.'\n        );\n      } else {\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    }\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    const iterable = createAsyncIterable<{\n      success: boolean;\n      outfile?: string;\n    }>(({ next, done }) => {\n      if ('on' in watcherOrOutput) {\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      } else {\n        const output =\n          watcherOrOutput?.['output'] || watcherOrOutput?.[0]?.output;\n        const fileName = output?.[0]?.fileName || 'main.cjs';\n        const outfile = resolve(outDirRelativeToWorkspaceRoot, fileName);\n        next({ success: true, outfile });\n        done();\n      }\n    });\n    iterables.push(iterable);\n  }\n  return yield* combineAsyncIterables(iterables.shift(), ...(iterables ?? []));\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":["getBuildExtraArgs","viteBuildExecutor","options","context","resolved","process","env","VITE_CJS_IGNORE_WARNING","mergeConfig","build","resolveConfig","createBuilder","loadViteDynamicImport","projectRoot","projectsConfigurations","projects","projectName","root","tsConfigForBuild","createBuildableTsConfig","viteConfigPath","normalizeViteConfigFilePath","configFile","cwd","relative","joinPathFragments","buildOptions","otherOptions","defaultMode","mode","NODE_ENV","outDir","offsetFromRoot","outputPath","buildConfig","skipTypeCheck","isUsingTsSolutionSetup","validateTypes","workspaceRoot","tsconfig","isVueProject","Boolean","plugins","find","plugin","name","builder","undefined","useEnvironmentsApi","inlineConfig","environments","iterables","Object","values","config","watcherOrOutput","libraryPackageJson","resolve","rootPackageJson","absoluteOutDir","outDirRelativeToWorkspaceRoot","distPackageJson","generatePackageJson","builtPackageJson","projectGraph","nodes","type","logger","warn","stripIndents","createPackageJson","target","targetName","isProduction","includeDevDependenciesInPackageJson","skipOverrides","skipPackageManager","writeJsonFile","packageManager","detectPackageManager","lockFile","createLockFile","writeFileSync","getLockFileName","encoding","existsSync","copyAssets","assets","input","output","glob","iterable","createAsyncIterable","next","done","success","on","event","code","result","close","fileName","outfile","push","combineAsyncIterables","shift","schema","extraArgs","key","keys","properties","buildSchemaKeys","includes","watch"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -1 +0,0 @@
-{"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"],"rangeMappings":";;;;;;;;;","mappings":";+BAGA;;;eAAA;;;wBAHkC;2BACJ;MAE9B,WAAeA,IAAAA,yBAAiB,EAACC,kBAAiB"}

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

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