@nx/nuxt 17.3.0-beta.3

package/src/plugins/plugin.js

@@ -0,0 +1,140 @@
+"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);
+    return targets;
+}
+function buildTarget(buildTargetName, namedInputs, buildOutputs, projectRoot) {
+    return {
+        command: `nuxi build`,
+        options: { cwd: projectRoot },
+        cache: true,
+        dependsOn: [`^${buildTargetName}`],
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+            {
+                externalDependencies: ['nuxi'],
+            },
+        ],
+        outputs: buildOutputs,
+    };
+}
+function serveTarget(projectRoot) {
+    const targetConfig = {
+        command: `nuxi dev`,
+        options: {
+            cwd: projectRoot,
+        },
+    };
+    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') {
+        // buildDir will most probably be `../dist/my-app/.nuxt`
+        // we want the "general" outputPath to be `../dist/my-app`
+        nuxtBuildDir = nuxtConfig.buildDir.replace((0, path_1.basename)(nuxtConfig.buildDir), '');
+    }
+    const buildOutputPath = normalizeOutputPath(nuxtBuildDir, projectRoot) ??
+        '{workspaceRoot}/dist/{projectRoot}';
+    return {
+        buildOutputs: [buildOutputPath],
+    };
+}
+function normalizeOutputPath(outputPath, projectRoot) {
+    if (!outputPath) {
+        if (projectRoot === '.') {
+            return `{projectRoot}/dist`;
+        }
+        else {
+            return `{workspaceRoot}/dist/{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';
+    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,30 @@
+"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 lint_1 = require("./lint");
+const vue_1 = require("@nx/vue");
+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,
+        });
+        tasks.push(lintTask);
+        (0, devkit_1.updateJson)(host, (0, path_1.joinPathFragments)(options.projectRoot, '.eslintrc.json'), lint_1.extendNuxtEslintJson);
+        (0, vue_1.editEslintConfigFiles)(host, options.projectRoot, options.rootProject);
+        const installTask = (0, devkit_1.addDependenciesToPackageJson)(host, lint_1.extraEslintDependencies.dependencies, {
+            ...lint_1.extraEslintDependencies.devDependencies,
+        });
+        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: [],
+        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/lint.d.ts

@@ -0,0 +1,7 @@
+export declare const extraEslintDependencies: {
+    dependencies: {};
+    devDependencies: {
+        '@nuxt/eslint-config': string;
+    };
+};
+export declare const extendNuxtEslintJson: (json: any) => any;

package/src/utils/lint.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendNuxtEslintJson = exports.extraEslintDependencies = void 0;
+const versions_1 = require("./versions");
+exports.extraEslintDependencies = {
+    dependencies: {},
+    devDependencies: {
+        '@nuxt/eslint-config': versions_1.nuxtEslintConfigVersion,
+    },
+};
+const extendNuxtEslintJson = (json) => {
+    const { extends: pluginExtends, ...config } = json;
+    return {
+        extends: ['@nuxt/eslint-config', ...(pluginExtends || [])],
+        ignorePatterns: ['.nuxt', 'node_modules', '.output'],
+        ...config,
+    };
+};
+exports.extendNuxtEslintJson = extendNuxtEslintJson;

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.8.1";
+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.8.1';
+exports.nuxtDevtoolsVersion = '1.0.0';
+exports.nuxtUiTemplatesVersion = '^1.3.1';
+// linting deps
+exports.nuxtEslintConfigVersion = '0.2.0';