@nx/vite 21.3.7 → 21.4.0-beta.1

package/src/plugins/plugin.js

@@ -1,55 +1,45 @@
 "use strict";
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    createDependencies: function() {
-        return createDependencies;
-    },
-    createNodes: function() {
-        return createNodes;
-    },
-    createNodesV2: function() {
-        return createNodesV2;
-    }
-});
-const _extends = require("@swc/helpers/_/_extends");
-const _devkit = require("@nx/devkit");
-const _path = require("path");
-const _getnamedinputs = require("@nx/devkit/src/utils/get-named-inputs");
-const _fs = require("fs");
-const _calculatehashforcreatenodes = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
-const _cachedirectory = require("nx/src/utils/cache-directory");
-const _js = require("@nx/js");
-const _executorutils = require("../utils/executor-utils");
-const _filehasher = require("nx/src/hasher/file-hasher");
-const _tssolutionsetup = require("@nx/js/src/utils/typescript/ts-solution-setup");
-const _util = require("@nx/js/src/plugins/typescript/util");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createNodesV2 = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const fs_1 = require("fs");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const js_1 = require("@nx/js");
+const executor_utils_1 = require("../utils/executor-utils");
+const file_hasher_1 = require("nx/src/hasher/file-hasher");
 const picomatch = require("picomatch");
-const pmc = (0, _devkit.getPackageManagerCommand)();
+const ts_solution_setup_1 = require("@nx/js/src/utils/typescript/ts-solution-setup");
+const util_1 = require("@nx/js/src/plugins/typescript/util");
+const pmc = (0, devkit_1.getPackageManagerCommand)();
 function readTargetsCache(cachePath) {
-    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, _fs.existsSync)(cachePath) ? (0, _devkit.readJsonFile)(cachePath) : {};
+    return process.env.NX_CACHE_PROJECT_GRAPH !== 'false' && (0, fs_1.existsSync)(cachePath)
+        ? (0, devkit_1.readJsonFile)(cachePath)
+        : {};
 }
 function writeTargetsToCache(cachePath, results) {
-    (0, _devkit.writeJsonFile)(cachePath, results);
+    (0, devkit_1.writeJsonFile)(cachePath, results);
 }
-const createDependencies = ()=>{
+/**
+ * @deprecated The 'createDependencies' function is now a no-op. This functionality is included in 'createNodesV2'.
+ */
+const createDependencies = () => {
     return [];
 };
+exports.createDependencies = createDependencies;
 const viteVitestConfigGlob = '**/{vite,vitest}.config.{js,ts,mjs,mts,cjs,cts}';
-const createNodesV2 = [
+exports.createNodesV2 = [
     viteVitestConfigGlob,
-    async (configFilePaths, options, context)=>{
-        const optionsHash = (0, _filehasher.hashObject)(options);
+    async (configFilePaths, options, context) => {
+        const optionsHash = (0, file_hasher_1.hashObject)(options);
         const normalizedOptions = normalizeOptions(options);
-        const cachePath = (0, _path.join)(_cachedirectory.workspaceDataDirectory, `vite-${optionsHash}.hash`);
+        const cachePath = (0, path_1.join)(cache_directory_1.workspaceDataDirectory, `vite-${optionsHash}.hash`);
         const targetsCache = readTargetsCache(cachePath);
-        const isUsingTsSolutionSetup = (0, _tssolutionsetup.isUsingTsSolutionSetup)();
-        const { roots: projectRoots, configFiles: validConfigFiles } = configFilePaths.reduce((acc, configFile)=>{
-            const potentialRoot = (0, _path.dirname)(configFile);
+        const isUsingTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
+        const { roots: projectRoots, configFiles: validConfigFiles } = configFilePaths.reduce((acc, configFile) => {
+            const potentialRoot = (0, path_1.dirname)(configFile);
             if (checkIfConfigFileShouldBeProject(potentialRoot, context)) {
                 acc.roots.push(potentialRoot);
                 acc.configFiles.push(configFile);
@@ -57,37 +47,33 @@ const createNodesV2 = [
             return acc;
         }, {
             roots: [],
-            configFiles: []
+            configFiles: [],
         });
-        const lockfile = (0, _js.getLockFileName)((0, _devkit.detectPackageManager)(context.workspaceRoot));
-        const hashes = await (0, _calculatehashforcreatenodes.calculateHashesForCreateNodes)(projectRoots, _extends._({}, normalizedOptions, {
-            isUsingTsSolutionSetup
-        }), context, projectRoots.map((r)=>[
-                lockfile
-            ]));
+        const lockfile = (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot));
+        const hashes = await (0, calculate_hash_for_create_nodes_1.calculateHashesForCreateNodes)(projectRoots, { ...normalizedOptions, isUsingTsSolutionSetup }, context, projectRoots.map((r) => [lockfile]));
         try {
-            return await (0, _devkit.createNodesFromFiles)(async (configFile, _, context, idx)=>{
-                var _targetsCache, _hash;
-                const projectRoot = (0, _path.dirname)(configFile);
+            return await (0, devkit_1.createNodesFromFiles)(async (configFile, _, context, idx) => {
+                const projectRoot = (0, path_1.dirname)(configFile);
                 // Do not create a project if package.json and project.json isn't there.
-                const siblingFiles = (0, _fs.readdirSync)((0, _path.join)(context.workspaceRoot, projectRoot));
-                var _siblingFiles_filter;
-                const tsConfigFiles = (_siblingFiles_filter = siblingFiles.filter((p)=>picomatch('tsconfig*{.json,.*.json}')(p))) != null ? _siblingFiles_filter : [];
-                const hasReactRouterConfig = siblingFiles.some((configFile)=>{
+                const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+                const tsConfigFiles = siblingFiles.filter((p) => picomatch('tsconfig*{.json,.*.json}')(p)) ?? [];
+                const hasReactRouterConfig = siblingFiles.some((configFile) => {
                     const parts = configFile.split('.');
-                    return parts[0] === 'react-router' && parts[1] === 'config' && parts.length > 2;
+                    return (parts[0] === 'react-router' &&
+                        parts[1] === 'config' &&
+                        parts.length > 2);
                 });
                 // results from vitest.config.js will be different from results of vite.config.js
                 // but the hash will be the same because it is based on the files under the project root.
                 // Adding the config file path to the hash ensures that the final hash value is different
                 // for different config files.
                 const hash = hashes[idx] + configFile;
-                var _1;
-                const { projectType, metadata, targets } = (_1 = (_targetsCache = targetsCache)[_hash = hash]) != null ? _1 : _targetsCache[_hash] = await buildViteTargets(configFile, projectRoot, normalizedOptions, tsConfigFiles, hasReactRouterConfig, isUsingTsSolutionSetup, context);
+                const { projectType, metadata, targets } = (targetsCache[hash] ??=
+                    await buildViteTargets(configFile, projectRoot, normalizedOptions, tsConfigFiles, hasReactRouterConfig, isUsingTsSolutionSetup, context));
                 const project = {
                     root: projectRoot,
                     targets,
-                    metadata
+                    metadata,
                 };
                 // If project is buildable, then the project type.
                 // If it is not buildable, then leave it to other plugins/project.json to set the project type.
@@ -96,38 +82,40 @@ const createNodesV2 = [
                 }
                 return {
                     projects: {
-                        [projectRoot]: project
-                    }
+                        [projectRoot]: project,
+                    },
                 };
             }, validConfigFiles, options, context);
-        } finally{
+        }
+        finally {
             writeTargetsToCache(cachePath, targetsCache);
         }
-    }
+    },
 ];
-const createNodes = [
+exports.createNodes = [
     viteVitestConfigGlob,
-    async (configFilePath, options, context)=>{
-        _devkit.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
-        const projectRoot = (0, _path.dirname)(configFilePath);
+    async (configFilePath, options, context) => {
+        devkit_1.logger.warn('`createNodes` is deprecated. Update your plugin to utilize createNodesV2 instead. In Nx 20, this will change to the createNodesV2 API.');
+        const projectRoot = (0, path_1.dirname)(configFilePath);
         // Do not create a project if package.json and project.json isn't there.
-        const siblingFiles = (0, _fs.readdirSync)((0, _path.join)(context.workspaceRoot, projectRoot));
-        if (!siblingFiles.includes('package.json') && !siblingFiles.includes('project.json')) {
+        const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+        if (!siblingFiles.includes('package.json') &&
+            !siblingFiles.includes('project.json')) {
             return {};
         }
-        var _siblingFiles_filter;
-        const tsConfigFiles = (_siblingFiles_filter = siblingFiles.filter((p)=>picomatch('tsconfig*{.json,.*.json}')(p))) != null ? _siblingFiles_filter : [];
-        const hasReactRouterConfig = siblingFiles.some((configFile)=>{
+        const tsConfigFiles = siblingFiles.filter((p) => picomatch('tsconfig*{.json,.*.json}')(p)) ??
+            [];
+        const hasReactRouterConfig = siblingFiles.some((configFile) => {
             const parts = configFile.split('.');
-            return parts[0] === 'react-router' && parts[1] === 'config' && parts.length > 2;
+            return (parts[0] === 'react-router' && parts[1] === 'config' && parts.length > 2);
         });
         const normalizedOptions = normalizeOptions(options);
-        const isUsingTsSolutionSetup = (0, _tssolutionsetup.isUsingTsSolutionSetup)();
+        const isUsingTsSolutionSetup = (0, ts_solution_setup_1.isUsingTsSolutionSetup)();
         const { projectType, metadata, targets } = await buildViteTargets(configFilePath, projectRoot, normalizedOptions, tsConfigFiles, hasReactRouterConfig, isUsingTsSolutionSetup, context);
         const project = {
             root: projectRoot,
             targets,
-            metadata
+            metadata,
         };
         // If project is buildable, then the project type.
         // If it is not buildable, then leave it to other plugins/project.json to set the project type.
@@ -136,29 +124,29 @@ const createNodes = [
         }
         return {
             projects: {
-                [projectRoot]: project
-            }
+                [projectRoot]: project,
+            },
         };
-    }
+    },
 ];
 async function buildViteTargets(configFilePath, projectRoot, options, tsConfigFiles, hasReactRouterConfig, isUsingTsSolutionSetup, context) {
-    var _viteBuildConfig_build;
-    const absoluteConfigFilePath = (0, _devkit.joinPathFragments)(context.workspaceRoot, configFilePath);
+    const absoluteConfigFilePath = (0, devkit_1.joinPathFragments)(context.workspaceRoot, configFilePath);
     // Workaround for the `build$3 is not a function` error that we sometimes see in agents.
     // This should be removed later once we address the issue properly
     try {
-        const importEsbuild = ()=>new Function('return import("esbuild")')();
+        const importEsbuild = () => new Function('return import("esbuild")')();
         await importEsbuild();
-    } catch (e) {
-    // do nothing
     }
-    const { resolveConfig } = await (0, _executorutils.loadViteDynamicImport)();
+    catch {
+        // do nothing
+    }
+    const { resolveConfig } = await (0, executor_utils_1.loadViteDynamicImport)();
     const viteBuildConfig = await resolveConfig({
         configFile: absoluteConfigFilePath,
-        mode: 'development'
+        mode: 'development',
     }, 'build');
     const { buildOutputs, testOutputs, hasTest, isBuildable, hasServeConfig } = getOutputs(viteBuildConfig, projectRoot, context.workspaceRoot);
-    const namedInputs = (0, _getnamedinputs.getNamedInputs)(projectRoot, context);
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
     const targets = {};
     // if file is vitest.config or vite.config has definition for test, create target for test
     if (configFilePath.includes('vitest.config') || hasTest) {
@@ -166,148 +154,112 @@ async function buildViteTargets(configFilePath, projectRoot, options, tsConfigFi
     }
     if (hasReactRouterConfig) {
         // If we have a react-router config, we can skip the rest of the targets
-        return {
-            targets,
-            metadata: {},
-            projectType: 'application'
-        };
+        return { targets, metadata: {}, projectType: 'application' };
     }
     // If file is not vitest.config and buildable, create targets for build, serve, preview and serve-static
-    const hasRemixPlugin = viteBuildConfig.plugins && viteBuildConfig.plugins.some((p)=>p.name === 'remix');
-    if (!configFilePath.includes('vitest.config') && !hasRemixPlugin && isBuildable) {
-        var _viteBuildConfig_build1;
+    const hasRemixPlugin = viteBuildConfig.plugins &&
+        viteBuildConfig.plugins.some((p) => p.name === 'remix');
+    if (!configFilePath.includes('vitest.config') &&
+        !hasRemixPlugin &&
+        isBuildable) {
         targets[options.buildTargetName] = await buildTarget(options.buildTargetName, namedInputs, buildOutputs, projectRoot, isUsingTsSolutionSetup);
         // If running in library mode, then there is nothing to serve.
-        if (!((_viteBuildConfig_build1 = viteBuildConfig.build) == null ? void 0 : _viteBuildConfig_build1.lib) || hasServeConfig) {
+        if (!viteBuildConfig.build?.lib || hasServeConfig) {
             const devTarget = serveTarget(projectRoot, isUsingTsSolutionSetup);
-            targets[options.serveTargetName] = _extends._({}, devTarget, {
-                metadata: _extends._({}, devTarget.metadata, {
-                    deprecated: 'Use devTargetName instead. This option will be removed in Nx 22.'
-                })
-            });
+            targets[options.serveTargetName] = {
+                ...devTarget,
+                metadata: {
+                    ...devTarget.metadata,
+                    deprecated: 'Use devTargetName instead. This option will be removed in Nx 22.',
+                },
+            };
             targets[options.devTargetName] = devTarget;
             targets[options.previewTargetName] = previewTarget(projectRoot, options.buildTargetName);
             targets[options.serveStaticTargetName] = serveStaticTarget(options, isUsingTsSolutionSetup);
         }
     }
     if (tsConfigFiles.length) {
-        var _viteBuildConfig_plugins;
-        var _find;
-        const tsConfigToUse = (_find = [
-            'tsconfig.app.json',
-            'tsconfig.lib.json',
-            'tsconfig.json'
-        ].find((t)=>tsConfigFiles.includes(t))) != null ? _find : tsConfigFiles[0];
+        const tsConfigToUse = ['tsconfig.app.json', 'tsconfig.lib.json', 'tsconfig.json'].find((t) => tsConfigFiles.includes(t)) ?? tsConfigFiles[0];
         // Check if the project uses Vue plugin
-        const hasVuePlugin = (_viteBuildConfig_plugins = viteBuildConfig.plugins) == null ? void 0 : _viteBuildConfig_plugins.some((p)=>p.name === 'vite:vue');
+        const hasVuePlugin = viteBuildConfig.plugins?.some((p) => p.name === 'vite:vue');
         const typeCheckCommand = hasVuePlugin ? 'vue-tsc' : 'tsc';
         targets[options.typecheckTargetName] = {
             cache: true,
             inputs: [
-                ...'production' in namedInputs ? [
-                    'production',
-                    '^production'
-                ] : [
-                    'default',
-                    '^default'
-                ],
+                ...('production' in namedInputs
+                    ? ['production', '^production']
+                    : ['default', '^default']),
                 {
-                    externalDependencies: hasVuePlugin ? [
-                        'vue-tsc',
-                        'typescript'
-                    ] : [
-                        'typescript'
-                    ]
-                }
+                    externalDependencies: hasVuePlugin
+                        ? ['vue-tsc', 'typescript']
+                        : ['typescript'],
+                },
             ],
-            command: isUsingTsSolutionSetup ? `${typeCheckCommand} --build --emitDeclarationOnly` : `${typeCheckCommand} --noEmit -p ${tsConfigToUse}`,
-            options: {
-                cwd: (0, _devkit.joinPathFragments)(projectRoot)
-            },
+            command: isUsingTsSolutionSetup
+                ? `${typeCheckCommand} --build --emitDeclarationOnly`
+                : `${typeCheckCommand} --noEmit -p ${tsConfigToUse}`,
+            options: { cwd: (0, devkit_1.joinPathFragments)(projectRoot) },
             metadata: {
                 description: `Runs type-checking for the project.`,
-                technologies: hasVuePlugin ? [
-                    'typescript',
-                    'vue'
-                ] : [
-                    'typescript'
-                ],
+                technologies: hasVuePlugin ? ['typescript', 'vue'] : ['typescript'],
                 help: {
-                    command: isUsingTsSolutionSetup ? `${pmc.exec} ${typeCheckCommand} --build --help` : `${pmc.exec} ${typeCheckCommand} -p ${tsConfigToUse} --help`,
-                    example: isUsingTsSolutionSetup ? {
-                        args: [
-                            '--force'
-                        ]
-                    } : {
-                        options: {
-                            noEmit: true
-                        }
-                    }
-                }
-            }
+                    command: isUsingTsSolutionSetup
+                        ? `${pmc.exec} ${typeCheckCommand} --build --help`
+                        : `${pmc.exec} ${typeCheckCommand} -p ${tsConfigToUse} --help`,
+                    example: isUsingTsSolutionSetup
+                        ? { args: ['--force'] }
+                        : { options: { noEmit: true } },
+                },
+            },
         };
         if (isUsingTsSolutionSetup) {
             targets[options.typecheckTargetName].dependsOn = [
-                `^${options.typecheckTargetName}`
+                `^${options.typecheckTargetName}`,
             ];
             targets[options.typecheckTargetName].syncGenerators = [
-                '@nx/js:typescript-sync'
+                '@nx/js:typescript-sync',
             ];
         }
     }
-    (0, _util.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
+    (0, util_1.addBuildAndWatchDepsTargets)(context.workspaceRoot, projectRoot, targets, options, pmc);
     const metadata = {};
     return {
         targets,
         metadata,
-        projectType: ((_viteBuildConfig_build = viteBuildConfig.build) == null ? void 0 : _viteBuildConfig_build.lib) ? 'library' : 'application'
+        projectType: viteBuildConfig.build?.lib ? 'library' : 'application',
     };
 }
 async function buildTarget(buildTargetName, namedInputs, outputs, projectRoot, isUsingTsSolutionSetup) {
     const buildTarget = {
         command: `vite build`,
-        options: {
-            cwd: (0, _devkit.joinPathFragments)(projectRoot)
-        },
+        options: { cwd: (0, devkit_1.joinPathFragments)(projectRoot) },
         cache: true,
-        dependsOn: [
-            `^${buildTargetName}`
-        ],
+        dependsOn: [`^${buildTargetName}`],
         inputs: [
-            ...'production' in namedInputs ? [
-                'production',
-                '^production'
-            ] : [
-                'default',
-                '^default'
-            ],
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
             {
-                externalDependencies: [
-                    'vite'
-                ]
-            }
+                externalDependencies: ['vite'],
+            },
         ],
         outputs,
         metadata: {
-            technologies: [
-                'vite'
-            ],
+            technologies: ['vite'],
             description: `Run Vite build`,
             help: {
                 command: `${pmc.exec} vite build --help`,
                 example: {
                     options: {
                         sourcemap: true,
-                        manifest: 'manifest.json'
-                    }
-                }
-            }
-        }
+                        manifest: 'manifest.json',
+                    },
+                },
+            },
+        },
     };
     if (isUsingTsSolutionSetup) {
-        buildTarget.syncGenerators = [
-            '@nx/js:typescript-sync'
-        ];
+        buildTarget.syncGenerators = ['@nx/js:typescript-sync'];
     }
     return buildTarget;
 }
@@ -316,27 +268,23 @@ function serveTarget(projectRoot, isUsingTsSolutionSetup) {
         continuous: true,
         command: `vite`,
         options: {
-            cwd: (0, _devkit.joinPathFragments)(projectRoot)
+            cwd: (0, devkit_1.joinPathFragments)(projectRoot),
         },
         metadata: {
-            technologies: [
-                'vite'
-            ],
+            technologies: ['vite'],
             description: `Starts Vite dev server`,
             help: {
                 command: `${pmc.exec} vite --help`,
                 example: {
                     options: {
-                        port: 3000
-                    }
-                }
-            }
-        }
+                        port: 3000,
+                    },
+                },
+            },
+        },
     };
     if (isUsingTsSolutionSetup) {
-        targetConfig.syncGenerators = [
-            '@nx/js:typescript-sync'
-        ];
+        targetConfig.syncGenerators = ['@nx/js:typescript-sync'];
     }
     return targetConfig;
 }
@@ -344,69 +292,53 @@ function previewTarget(projectRoot, buildTargetName) {
     const targetConfig = {
         continuous: true,
         command: `vite preview`,
-        dependsOn: [
-            buildTargetName
-        ],
+        dependsOn: [buildTargetName],
         options: {
-            cwd: (0, _devkit.joinPathFragments)(projectRoot)
+            cwd: (0, devkit_1.joinPathFragments)(projectRoot),
         },
         metadata: {
-            technologies: [
-                'vite'
-            ],
+            technologies: ['vite'],
             description: `Locally preview Vite production build`,
             help: {
                 command: `${pmc.exec} vite preview --help`,
                 example: {
                     options: {
-                        port: 3000
-                    }
-                }
-            }
-        }
+                        port: 3000,
+                    },
+                },
+            },
+        },
     };
     return targetConfig;
 }
 async function testTarget(namedInputs, outputs, projectRoot) {
     return {
         command: `vitest`,
-        options: {
-            cwd: (0, _devkit.joinPathFragments)(projectRoot)
-        },
+        options: { cwd: (0, devkit_1.joinPathFragments)(projectRoot) },
         cache: true,
         inputs: [
-            ...'production' in namedInputs ? [
-                'default',
-                '^production'
-            ] : [
-                'default',
-                '^default'
-            ],
+            ...('production' in namedInputs
+                ? ['default', '^production']
+                : ['default', '^default']),
             {
-                externalDependencies: [
-                    'vitest'
-                ]
+                externalDependencies: ['vitest'],
             },
-            {
-                env: 'CI'
-            }
+            { env: 'CI' },
         ],
         outputs,
         metadata: {
-            technologies: [
-                'vite'
-            ],
+            technologies: ['vite'],
             description: `Run Vite tests`,
             help: {
                 command: `${pmc.exec} vitest --help`,
                 example: {
                     options: {
                         bail: 1,
-                        coverage: true
-                    }
-                }
-            }
-        }
+                        coverage: true,
+                    },
+                },
+            },
+        },
     };
 }
 function serveStaticTarget(options, isUsingTsSolutionSetup) {
@@ -415,80 +347,70 @@ function serveStaticTarget(options, isUsingTsSolutionSetup) {
         executor: '@nx/web:file-server',
         options: {
             buildTarget: `${options.buildTargetName}`,
-            spa: true
-        }
+            spa: true,
+        },
     };
     if (isUsingTsSolutionSetup) {
-        targetConfig.syncGenerators = [
-            '@nx/js:typescript-sync'
-        ];
+        targetConfig.syncGenerators = ['@nx/js:typescript-sync'];
     }
     return targetConfig;
 }
 function getOutputs(viteBuildConfig, projectRoot, workspaceRoot) {
-    var _build_rollupOptions, _test_coverage;
     const { build, test, server } = viteBuildConfig;
-    const buildOutputPath = normalizeOutputPath(build == null ? void 0 : build.outDir, projectRoot, workspaceRoot, 'dist');
-    const isBuildable = (build == null ? void 0 : build.lib) || (build == null ? void 0 : (_build_rollupOptions = build.rollupOptions) == null ? void 0 : _build_rollupOptions.input) || (0, _fs.existsSync)((0, _path.join)(workspaceRoot, projectRoot, 'index.html'));
+    const buildOutputPath = normalizeOutputPath(build?.outDir, projectRoot, workspaceRoot, 'dist');
+    const isBuildable = build?.lib ||
+        build?.rollupOptions?.input ||
+        (0, fs_1.existsSync)((0, path_1.join)(workspaceRoot, projectRoot, 'index.html'));
     const hasServeConfig = Boolean(server);
-    const reportsDirectoryPath = normalizeOutputPath(test == null ? void 0 : (_test_coverage = test.coverage) == null ? void 0 : _test_coverage.reportsDirectory, projectRoot, workspaceRoot, 'coverage');
+    const reportsDirectoryPath = normalizeOutputPath(test?.coverage?.reportsDirectory, projectRoot, workspaceRoot, 'coverage');
     return {
-        buildOutputs: [
-            buildOutputPath
-        ],
-        testOutputs: [
-            reportsDirectoryPath
-        ],
+        buildOutputs: [buildOutputPath],
+        testOutputs: [reportsDirectoryPath],
         hasTest: !!test,
         isBuildable,
-        hasServeConfig
+        hasServeConfig,
     };
 }
 function normalizeOutputPath(outputPath, projectRoot, workspaceRoot, path) {
     if (!outputPath) {
         if (projectRoot === '.') {
             return `{projectRoot}/${path}`;
-        } else {
+        }
+        else {
             return `{workspaceRoot}/${path}/{projectRoot}`;
         }
-    } else {
-        if ((0, _path.isAbsolute)(outputPath)) {
-            return `{workspaceRoot}/${(0, _path.relative)(workspaceRoot, outputPath)}`;
-        } else {
+    }
+    else {
+        if ((0, path_1.isAbsolute)(outputPath)) {
+            return `{workspaceRoot}/${(0, path_1.relative)(workspaceRoot, outputPath)}`;
+        }
+        else {
             if (outputPath.startsWith('..')) {
-                return (0, _path.join)('{workspaceRoot}', (0, _path.join)(projectRoot, outputPath));
-            } else {
-                return (0, _path.join)('{projectRoot}', outputPath);
+                return (0, path_1.join)('{workspaceRoot}', (0, path_1.join)(projectRoot, outputPath));
+            }
+            else {
+                return (0, path_1.join)('{projectRoot}', outputPath);
             }
         }
     }
 }
 function normalizeOptions(options) {
-    var _options, _options1, _options2, _options3, _options4, _options5, _options6;
-    options != null ? options : options = {};
-    var _buildTargetName;
-    (_buildTargetName = (_options = options).buildTargetName) != null ? _buildTargetName : _options.buildTargetName = 'build';
-    var _serveTargetName;
-    (_serveTargetName = (_options1 = options).serveTargetName) != null ? _serveTargetName : _options1.serveTargetName = 'serve';
-    var _devTargetName;
-    (_devTargetName = (_options2 = options).devTargetName) != null ? _devTargetName : _options2.devTargetName = 'dev';
-    var _previewTargetName;
-    (_previewTargetName = (_options3 = options).previewTargetName) != null ? _previewTargetName : _options3.previewTargetName = 'preview';
-    var _testTargetName;
-    (_testTargetName = (_options4 = options).testTargetName) != null ? _testTargetName : _options4.testTargetName = 'test';
-    var _serveStaticTargetName;
-    (_serveStaticTargetName = (_options5 = options).serveStaticTargetName) != null ? _serveStaticTargetName : _options5.serveStaticTargetName = 'serve-static';
-    var _typecheckTargetName;
-    (_typecheckTargetName = (_options6 = options).typecheckTargetName) != null ? _typecheckTargetName : _options6.typecheckTargetName = 'typecheck';
+    options ??= {};
+    options.buildTargetName ??= 'build';
+    options.serveTargetName ??= 'serve';
+    options.devTargetName ??= 'dev';
+    options.previewTargetName ??= 'preview';
+    options.testTargetName ??= 'test';
+    options.serveStaticTargetName ??= 'serve-static';
+    options.typecheckTargetName ??= 'typecheck';
     return options;
 }
 function checkIfConfigFileShouldBeProject(projectRoot, context) {
     // Do not create a project if package.json and project.json isn't there.
-    const siblingFiles = (0, _fs.readdirSync)((0, _path.join)(context.workspaceRoot, projectRoot));
-    if (!siblingFiles.includes('package.json') && !siblingFiles.includes('project.json')) {
+    const siblingFiles = (0, fs_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+    if (!siblingFiles.includes('package.json') &&
+        !siblingFiles.includes('project.json')) {
         return false;
     }
     return true;
 }
-
-//# sourceMappingURL=plugin.js.map