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

package/src/migrations/update-18-1-0/add-include-tsconfig.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_utils_1 = require("../../utils/executor-utils");
+const path_1 = require("path");
+async function default_1(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const project of projects.values()) {
+        const nuxtConfigPath = findNuxtConfig(tree, project.root);
+        if (!nuxtConfigPath) {
+            continue;
+        }
+        const nuxtConfig = await getInfoFromNuxtConfig(nuxtConfigPath, project.root);
+        const buildDir = nuxtConfig.buildDir ?? '.nuxt';
+        const tsConfigPath = (0, devkit_1.joinPathFragments)(project.root, 'tsconfig.json');
+        if (tree.exists(tsConfigPath)) {
+            (0, devkit_1.updateJson)(tree, tsConfigPath, (json) => {
+                if (!json.include) {
+                    json.include = [];
+                }
+                if (!json.include.includes(buildDir + '/nuxt.d.ts')) {
+                    json.include.push(buildDir + '/nuxt.d.ts');
+                }
+                return json;
+            });
+        }
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = default_1;
+function findNuxtConfig(tree, projectRoot) {
+    const allowsExt = ['js', 'mjs', 'ts', 'cjs', 'mts', 'cts'];
+    for (const ext of allowsExt) {
+        if (tree.exists((0, devkit_1.joinPathFragments)(projectRoot, `nuxt.config.${ext}`))) {
+            return (0, devkit_1.joinPathFragments)(projectRoot, `nuxt.config.${ext}`);
+        }
+    }
+}
+async function getInfoFromNuxtConfig(configFilePath, projectRoot) {
+    const { loadNuxtConfig } = await (0, executor_utils_1.loadNuxtKitDynamicImport)();
+    const config = await loadNuxtConfig({
+        cwd: (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, projectRoot),
+        configFile: (0, path_1.basename)(configFilePath),
+    });
+    return {
+        buildDir: config?.buildDir,
+    };
+}

package/src/plugins/plugin.d.ts

@@ -0,0 +1,9 @@
+import { CreateDependencies, CreateNodes } from '@nx/devkit';
+export declare const createDependencies: CreateDependencies;
+export interface NuxtPluginOptions {
+    buildTargetName?: string;
+    serveTargetName?: string;
+    serveStaticTargetName?: string;
+    buildStaticTargetName?: string;
+}
+export declare const createNodes: CreateNodes<NuxtPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const fs_1 = require("fs");
+const executor_utils_1 = require("../utils/executor-utils");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const js_1 = require("@nx/js");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'nuxt.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/nuxt.config.{js,ts,mjs,mts,cjs,cts}',
+    async (configFilePath, options, context) => {
+        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_1.readdirSync)((0, path_1.join)(context.workspaceRoot, projectRoot));
+        if (!siblingFiles.includes('package.json') &&
+            !siblingFiles.includes('project.json')) {
+            return {};
+        }
+        options = normalizeOptions(options);
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [
+            (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
+        ]);
+        const targets = targetsCache[hash]
+            ? targetsCache[hash]
+            : await buildNuxtTargets(configFilePath, projectRoot, options, context);
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    root: projectRoot,
+                    targets,
+                },
+            },
+        };
+    },
+];
+async function buildNuxtTargets(configFilePath, projectRoot, options, context) {
+    const nuxtConfig = await getInfoFromNuxtConfig(configFilePath, context, projectRoot);
+    const { buildOutputs } = getOutputs(nuxtConfig, projectRoot);
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {};
+    targets[options.buildTargetName] = buildTarget(options.buildTargetName, namedInputs, buildOutputs, projectRoot);
+    targets[options.serveTargetName] = serveTarget(projectRoot);
+    targets[options.serveStaticTargetName] = serveStaticTarget(options);
+    targets[options.buildStaticTargetName] = buildStaticTarget(options.buildStaticTargetName, namedInputs, buildOutputs, projectRoot);
+    return targets;
+}
+function buildTarget(buildTargetName, namedInputs, buildOutputs, projectRoot) {
+    return {
+        command: `nuxt build`,
+        options: { cwd: projectRoot },
+        cache: true,
+        dependsOn: [`^${buildTargetName}`],
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+            {
+                externalDependencies: ['nuxt'],
+            },
+        ],
+        outputs: buildOutputs,
+    };
+}
+function serveTarget(projectRoot) {
+    const targetConfig = {
+        command: `nuxt dev`,
+        options: {
+            cwd: projectRoot,
+        },
+    };
+    return targetConfig;
+}
+function serveStaticTarget(options) {
+    const targetConfig = {
+        executor: '@nx/web:file-server',
+        options: {
+            buildTarget: `${options.buildStaticTargetName}`,
+            staticFilePath: '{projectRoot}/dist',
+            port: 4200,
+        },
+    };
+    return targetConfig;
+}
+function buildStaticTarget(buildStaticTargetName, namedInputs, buildOutputs, projectRoot) {
+    const targetConfig = {
+        command: `nuxt build --prerender`,
+        options: { cwd: projectRoot },
+        cache: true,
+        dependsOn: [`^${buildStaticTargetName}`],
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+            {
+                externalDependencies: ['nuxt'],
+            },
+        ],
+        outputs: buildOutputs,
+    };
+    return targetConfig;
+}
+async function getInfoFromNuxtConfig(configFilePath, context, projectRoot) {
+    const { loadNuxtConfig } = await (0, executor_utils_1.loadNuxtKitDynamicImport)();
+    const config = await loadNuxtConfig({
+        cwd: (0, devkit_1.joinPathFragments)(context.workspaceRoot, projectRoot),
+        configFile: (0, path_1.basename)(configFilePath),
+    });
+    return {
+        buildDir: config?.buildDir,
+    };
+}
+function getOutputs(nuxtConfig, projectRoot) {
+    let nuxtBuildDir = nuxtConfig?.buildDir;
+    if (nuxtConfig?.buildDir && (0, path_1.basename)(nuxtConfig?.buildDir) === '.nuxt') {
+        // if buildDir exists, it will be `something/something/.nuxt`
+        // we want the "general" outputPath to be `something/something`
+        nuxtBuildDir = nuxtConfig.buildDir.replace((0, path_1.basename)(nuxtConfig.buildDir), '');
+    }
+    const buildOutputPath = normalizeOutputPath(nuxtBuildDir, projectRoot);
+    return {
+        buildOutputs: [buildOutputPath],
+    };
+}
+function normalizeOutputPath(outputPath, projectRoot) {
+    if (!outputPath) {
+        if (projectRoot === '.') {
+            return `{projectRoot}`;
+        }
+        else {
+            return `{workspaceRoot}/{projectRoot}`;
+        }
+    }
+    else {
+        if ((0, path_1.isAbsolute)(outputPath)) {
+            return `{workspaceRoot}/${(0, path_1.relative)(devkit_1.workspaceRoot, outputPath)}`;
+        }
+        else {
+            if (outputPath.startsWith('..')) {
+                return (0, path_1.join)('{workspaceRoot}', (0, path_1.join)(projectRoot, outputPath));
+            }
+            else {
+                return (0, path_1.join)('{projectRoot}', outputPath);
+            }
+        }
+    }
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.buildTargetName ??= 'build';
+    options.serveTargetName ??= 'serve';
+    options.serveStaticTargetName ??= 'serve-static';
+    options.buildStaticTargetName ??= 'build-static';
+    return options;
+}

package/src/utils/add-linting.d.ts

@@ -0,0 +1,10 @@
+import { Tree } from 'nx/src/generators/tree';
+import { Linter } from '@nx/eslint';
+import { GeneratorCallback } from '@nx/devkit';
+export declare function addLinting(host: Tree, options: {
+    linter: Linter;
+    projectName: string;
+    projectRoot: string;
+    unitTestRunner?: 'vitest' | 'none';
+    rootProject?: boolean;
+}): Promise<GeneratorCallback>;

package/src/utils/add-linting.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addLinting = void 0;
+const eslint_1 = require("@nx/eslint");
+const path_1 = require("nx/src/utils/path");
+const devkit_1 = require("@nx/devkit");
+const vue_1 = require("@nx/vue");
+const versions_1 = require("./versions");
+async function addLinting(host, options) {
+    const tasks = [];
+    if (options.linter === 'eslint') {
+        const lintTask = await (0, eslint_1.lintProjectGenerator)(host, {
+            linter: options.linter,
+            project: options.projectName,
+            tsConfigPaths: [(0, path_1.joinPathFragments)(options.projectRoot, 'tsconfig.json')],
+            unitTestRunner: options.unitTestRunner,
+            skipFormat: true,
+            rootProject: options.rootProject,
+            addPlugin: true,
+        });
+        tasks.push(lintTask);
+        (0, vue_1.editEslintConfigFiles)(host, options.projectRoot, options.rootProject);
+        (0, devkit_1.updateJson)(host, (0, path_1.joinPathFragments)(options.projectRoot, '.eslintrc.json'), (json) => {
+            const { extends: pluginExtends, ignorePatterns: pluginIgnorePatters, ...config } = json;
+            return {
+                extends: ['@nuxt/eslint-config', ...(pluginExtends || [])],
+                ignorePatterns: [
+                    ...(pluginIgnorePatters || []),
+                    '.nuxt/**',
+                    '.output/**',
+                    'node_modules',
+                ],
+                ...config,
+            };
+        });
+        const installTask = (0, devkit_1.addDependenciesToPackageJson)(host, {}, {
+            '@nuxt/eslint-config': versions_1.nuxtEslintConfigVersion,
+        });
+        tasks.push(installTask);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.addLinting = addLinting;

package/src/utils/create-ts-config.d.ts

@@ -0,0 +1,6 @@
+import { Tree } from '@nx/devkit';
+export declare function createTsConfig(host: Tree, options: {
+    projectRoot: string;
+    rootProject?: boolean;
+    unitTestRunner?: string;
+}, relativePathToRootTsConfig: string): void;

package/src/utils/create-ts-config.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTsConfig = void 0;
+const devkit_1 = require("@nx/devkit");
+const shared = require("@nx/js/src/utils/typescript/create-ts-config");
+function createTsConfig(host, options, relativePathToRootTsConfig) {
+    createAppTsConfig(host, options);
+    const json = {
+        compilerOptions: {},
+        files: [],
+        include: ['.nuxt/nuxt.d.ts'],
+        references: [
+            {
+                path: './tsconfig.app.json',
+            },
+        ],
+    };
+    if (options.unitTestRunner !== 'none') {
+        json.references.push({
+            path: './tsconfig.spec.json',
+        });
+    }
+    // inline tsconfig.base.json into the project
+    if (options.rootProject) {
+        json.compileOnSave = false;
+        json.compilerOptions = {
+            ...shared.tsConfigBaseOptions,
+            ...json.compilerOptions,
+        };
+        json.exclude = ['node_modules', 'tmp'];
+    }
+    else {
+        json.extends = relativePathToRootTsConfig;
+    }
+    (0, devkit_1.writeJson)(host, `${options.projectRoot}/tsconfig.json`, json);
+}
+exports.createTsConfig = createTsConfig;
+function createAppTsConfig(host, options) {
+    const json = {
+        extends: './tsconfig.json',
+        compilerOptions: {
+            composite: true,
+        },
+        exclude: [],
+    };
+    (0, devkit_1.writeJson)(host, `${options.projectRoot}/tsconfig.app.json`, json);
+}

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

@@ -0,0 +1 @@
+export declare function loadNuxtKitDynamicImport(): Promise<typeof import("@nuxt/kit")>;

package/src/utils/executor-utils.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadNuxtKitDynamicImport = void 0;
+function loadNuxtKitDynamicImport() {
+    return Function('return import("@nuxt/kit")')();
+}
+exports.loadNuxtKitDynamicImport = loadNuxtKitDynamicImport;

package/src/utils/update-gitignore.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function updateGitIgnore(tree: Tree): void;

package/src/utils/update-gitignore.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateGitIgnore = void 0;
+function updateGitIgnore(tree) {
+    const contents = tree.read('.gitignore', 'utf-8') ?? '';
+    const nuxtEntries = [
+        '# Nuxt dev/build outputs',
+        '.output',
+        '.data',
+        '.nuxt',
+        '.nitro',
+        '.cache',
+    ];
+    let newContents = contents;
+    for (const entry of nuxtEntries) {
+        const regex = new RegExp(`^${entry}$`, 'm');
+        if (!regex.test(newContents)) {
+            newContents += `\n${entry}`;
+        }
+    }
+    tree.write('.gitignore', [newContents].join('\n'));
+}
+exports.updateGitIgnore = updateGitIgnore;

package/src/utils/versions.d.ts

@@ -0,0 +1,6 @@
+export declare const nxVersion: any;
+export declare const h3Version = "^1.8.2";
+export declare const nuxtVersion = "^3.10.0";
+export declare const nuxtDevtoolsVersion = "1.0.0";
+export declare const nuxtUiTemplatesVersion = "^1.3.1";
+export declare const nuxtEslintConfigVersion = "0.2.0";

package/src/utils/versions.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nuxtEslintConfigVersion = exports.nuxtUiTemplatesVersion = exports.nuxtDevtoolsVersion = exports.nuxtVersion = exports.h3Version = exports.nxVersion = void 0;
+exports.nxVersion = require('../../package.json').version;
+// nuxt deps
+exports.h3Version = '^1.8.2';
+exports.nuxtVersion = '^3.10.0';
+exports.nuxtDevtoolsVersion = '1.0.0';
+exports.nuxtUiTemplatesVersion = '^1.3.1';
+// linting deps
+exports.nuxtEslintConfigVersion = '0.2.0';