@nx/nuxt 17.0.4

package/src/generators/application/files/src/pages/about.vue__tmpl__

@@ -0,0 +1,16 @@
+<template>
+    <div class="about">
+        <h1>This is an about page.</h1>
+    </div>
+</template>
+  
+<style>
+@media (min-width: 768px) {
+    .about {
+        max-width: 768px;
+        margin-left: auto;
+        margin-right: auto;
+        padding: 0 1rem;
+    }
+}
+</style>

package/src/generators/application/files/src/pages/index.vue__tmpl__

@@ -0,0 +1,6 @@
+<template>
+  <NxWelcome title="<%= title %>" />
+</template>
+
+
+

package/src/generators/application/files/src/server/api/greet.ts__tmpl__

@@ -0,0 +1,10 @@
+import { defineEventHandler, getQuery } from 'h3';
+
+export default defineEventHandler((event) => {
+  const q = getQuery(event);
+  const name = q.name || 'World';
+
+  return {
+    message: `Hello ${name}`,
+  };
+});

package/src/generators/application/files/src/server/tsconfig.json__tmpl__

@@ -0,0 +1,3 @@
+{
+  "extends": "../.nuxt/tsconfig.server.json"
+}

package/src/generators/application/lib/add-e2e.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+export declare function addE2e(host: Tree, options: NormalizedSchema): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/application/lib/add-e2e.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addE2e = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../utils/versions");
+async function addE2e(host, options) {
+    if (options.e2eTestRunner === 'cypress') {
+        const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
+        (0, devkit_1.addProjectConfiguration)(host, options.e2eProjectName, {
+            projectType: 'application',
+            root: options.e2eProjectRoot,
+            sourceRoot: (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'src'),
+            targets: {},
+            tags: [],
+            implicitDependencies: [options.projectName],
+        });
+        return await configurationGenerator(host, {
+            ...options,
+            project: options.e2eProjectName,
+            directory: 'src',
+            bundler: 'vite',
+            skipFormat: true,
+            devServerTarget: `${options.projectName}:${options.e2eWebServerTarget}`,
+            webServerCommands: {
+                default: `${(0, devkit_1.getPackageManagerCommand)().exec} nx ${options.e2eWebServerTarget} ${options.projectName}`,
+            },
+            ciWebServerCommand: `nx run ${options.projectName}:serve-static`,
+            baseUrl: options.e2eWebServerAddress,
+            jsx: true,
+            addPlugin: true,
+        });
+    }
+    else if (options.e2eTestRunner === 'playwright') {
+        const { configurationGenerator } = (0, devkit_1.ensurePackage)('@nx/playwright', versions_1.nxVersion);
+        (0, devkit_1.addProjectConfiguration)(host, options.e2eProjectName, {
+            root: options.e2eProjectRoot,
+            sourceRoot: (0, devkit_1.joinPathFragments)(options.e2eProjectRoot, 'src'),
+            targets: {},
+            implicitDependencies: [options.projectName],
+        });
+        return configurationGenerator(host, {
+            project: options.e2eProjectName,
+            skipFormat: true,
+            skipPackageJson: options.skipPackageJson,
+            directory: 'src',
+            js: false,
+            linter: options.linter,
+            setParserOptionsProject: options.setParserOptionsProject,
+            webServerAddress: options.e2eWebServerAddress,
+            webServerCommand: `${(0, devkit_1.getPackageManagerCommand)().exec} nx ${options.e2eWebServerTarget} ${options.projectName}`,
+            addPlugin: true,
+        });
+    }
+    return () => { };
+}
+exports.addE2e = addE2e;

package/src/generators/application/lib/add-vitest.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { NormalizedSchema } from '../schema';
+export declare function addVitest(tree: Tree, options: NormalizedSchema): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/application/lib/add-vitest.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addVitest = void 0;
+const devkit_1 = require("@nx/devkit");
+const utils_1 = require("../../init/lib/utils");
+const versions_1 = require("../../../utils/versions");
+async function addVitest(tree, options) {
+    (0, utils_1.addVitestTargetDefaults)(tree);
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/nuxt/plugin'
+        : p.plugin === '@nx/nuxt/plugin');
+    const { createOrEditViteConfig, vitestGenerator } = (0, devkit_1.ensurePackage)('@nx/vite', versions_1.nxVersion);
+    const vitestTask = await vitestGenerator(tree, {
+        project: options.name,
+        uiFramework: 'none',
+        coverageProvider: 'v8',
+        skipFormat: true,
+        testEnvironment: 'jsdom',
+        skipViteConfig: true,
+        addPlugin: true,
+    }, hasPlugin);
+    createOrEditViteConfig(tree, {
+        project: options.name,
+        includeLib: false,
+        includeVitest: true,
+        testEnvironment: 'jsdom',
+        imports: [`import vue from '@vitejs/plugin-vue'`],
+        plugins: ['vue()'],
+    }, true, undefined, true);
+    (0, devkit_1.updateJson)(tree, `${options.appProjectRoot}/tsconfig.spec.json`, (json) => {
+        json.compilerOptions ??= {};
+        json.compilerOptions.composite = true;
+        return json;
+    });
+    return vitestTask;
+}
+exports.addVitest = addVitest;

package/src/generators/application/lib/ensure-dependencies.d.ts

@@ -0,0 +1,3 @@
+import { type Tree } from '@nx/devkit';
+import type { NormalizedSchema } from '../schema';
+export declare function ensureDependencies(host: Tree, options: NormalizedSchema): import("@nx/devkit").GeneratorCallback;

package/src/generators/application/lib/ensure-dependencies.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const vue_1 = require("@nx/vue");
+const versions_1 = require("../../../utils/versions");
+function ensureDependencies(host, options) {
+    const devDependencies = {
+        '@nx/vite': versions_1.nxVersion, // needed for the nxViteTsPaths plugin and @nx/vite/plugin
+        '@nuxt/devtools': versions_1.nuxtDevtoolsVersion,
+        '@nuxt/kit': versions_1.nuxtVersion,
+        '@nuxt/ui-templates': versions_1.nuxtUiTemplatesVersion,
+        nuxt: versions_1.nuxtVersion,
+        h3: versions_1.h3Version,
+        vue: vue_1.vueVersion,
+        'vue-router': vue_1.vueRouterVersion,
+        'vue-tsc': vue_1.vueTscVersion,
+    };
+    if (options.style === 'scss') {
+        devDependencies['sass'] = vue_1.sassVersion;
+    }
+    else if (options.style === 'less') {
+        devDependencies['less'] = vue_1.lessVersion;
+    }
+    return (0, devkit_1.addDependenciesToPackageJson)(host, {}, devDependencies);
+}
+exports.ensureDependencies = ensureDependencies;

package/src/generators/application/lib/normalize-options.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import { NormalizedSchema, Schema } from '../schema';
+export declare function normalizeDirectory(options: Schema): string;
+export declare function normalizeOptions(host: Tree, options: Schema, callingGenerator?: string): Promise<NormalizedSchema>;

package/src/generators/application/lib/normalize-options.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = exports.normalizeDirectory = void 0;
+const devkit_1 = require("@nx/devkit");
+const project_name_and_root_utils_1 = require("@nx/devkit/src/generators/project-name-and-root-utils");
+function normalizeDirectory(options) {
+    options.directory = options.directory?.replace(/\\{1,2}/g, '/');
+    const { projectDirectory } = (0, devkit_1.extractLayoutDirectory)(options.directory);
+    return projectDirectory
+        ? `${(0, devkit_1.names)(projectDirectory).fileName}/${(0, devkit_1.names)(options.name).fileName}`
+        : (0, devkit_1.names)(options.name).fileName;
+}
+exports.normalizeDirectory = normalizeDirectory;
+async function normalizeOptions(host, options, callingGenerator = '@nx/nuxt:application') {
+    const { projectName: appProjectName, projectRoot: appProjectRoot, projectNameAndRootFormat, } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+        name: options.name,
+        projectType: 'application',
+        directory: options.directory,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        rootProject: options.rootProject,
+        callingGenerator,
+    });
+    options.rootProject = appProjectRoot === '.';
+    options.projectNameAndRootFormat = projectNameAndRootFormat;
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    let e2eWebServerTarget = 'serve';
+    if (nxJson.plugins) {
+        for (const plugin of nxJson.plugins) {
+            if (typeof plugin === 'object' &&
+                plugin.plugin === '@nx/nuxt/plugin' &&
+                plugin.options.serveTargetName) {
+                e2eWebServerTarget = plugin.options
+                    .serveTargetName;
+            }
+        }
+    }
+    let e2ePort = 4200;
+    if (nxJson.targetDefaults?.[e2eWebServerTarget] &&
+        nxJson.targetDefaults?.[e2eWebServerTarget].options?.port) {
+        e2ePort = nxJson.targetDefaults?.[e2eWebServerTarget].options?.port;
+    }
+    const e2eProjectName = options.rootProject ? 'e2e' : `${appProjectName}-e2e`;
+    const e2eProjectRoot = options.rootProject ? 'e2e' : `${appProjectRoot}-e2e`;
+    const e2eWebServerAddress = `http://localhost:${e2ePort}`;
+    const parsedTags = options.tags
+        ? options.tags.split(',').map((s) => s.trim())
+        : [];
+    const normalized = {
+        ...options,
+        name: (0, devkit_1.names)(options.name).fileName,
+        projectName: appProjectName,
+        appProjectRoot,
+        e2eProjectName,
+        e2eProjectRoot,
+        e2eWebServerAddress,
+        e2eWebServerTarget,
+        e2ePort,
+        parsedTags,
+        style: options.style ?? 'none',
+    };
+    normalized.unitTestRunner ??= 'vitest';
+    normalized.e2eTestRunner = normalized.e2eTestRunner ?? 'cypress';
+    return normalized;
+}
+exports.normalizeOptions = normalizeOptions;

package/src/generators/application/schema.d.ts

@@ -0,0 +1,29 @@
+import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { Linter } from '@nx/eslint';
+
+export interface Schema {
+  name: string;
+  directory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  linter?: Linter;
+  skipFormat?: boolean;
+  unitTestRunner?: 'vitest' | 'none';
+  e2eTestRunner?: 'cypress' | 'playwright' | 'none';
+  tags?: string;
+  js?: boolean;
+  skipPackageJson?: boolean;
+  rootProject?: boolean;
+  setParserOptionsProject?: boolean;
+  style?: 'css' | 'scss' | 'less' | 'none';
+}
+
+export interface NormalizedSchema extends Schema {
+  projectName: string;
+  appProjectRoot: string;
+  e2eProjectName: string;
+  e2eProjectRoot: string;
+  e2eWebServerAddress: string;
+  e2eWebServerTarget: string;
+  e2ePort: number;
+  parsedTags: string[];
+}

package/src/generators/application/schema.json

@@ -0,0 +1,110 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxNuxtApp",
+  "title": "Create a Nuxt Application for Nx",
+  "description": "Create a Nuxt Application for Nx.",
+  "type": "object",
+  "properties": {
+    "name": {
+      "description": "The name of the application.",
+      "type": "string",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the application?",
+      "pattern": "^[a-zA-Z][^:]*$",
+      "x-priority": "important"
+    },
+    "directory": {
+      "description": "The directory of the new application.",
+      "type": "string",
+      "alias": "dir",
+      "x-priority": "important"
+    },
+    "projectNameAndRootFormat": {
+      "description": "Whether to generate the project name and root directory as provided (`as-provided`) or generate them composing their values and taking the configured layout into account (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
+    },
+    "linter": {
+      "description": "The tool to use for running lint checks.",
+      "type": "string",
+      "enum": ["eslint"],
+      "default": "eslint"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false,
+      "x-priority": "internal"
+    },
+    "unitTestRunner": {
+      "type": "string",
+      "enum": ["vitest", "none"],
+      "description": "Test runner to use for unit tests.",
+      "x-prompt": "Which unit test runner would you like to use?",
+      "default": "none"
+    },
+    "e2eTestRunner": {
+      "type": "string",
+      "enum": ["cypress", "playwright", "none"],
+      "description": "Test runner to use for end to end (E2E) tests.",
+      "x-prompt": "Which E2E test runner would you like to use?",
+      "default": "cypress"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the application (used for linting).",
+      "alias": "t"
+    },
+    "js": {
+      "type": "boolean",
+      "description": "Generate JavaScript files rather than TypeScript files.",
+      "default": false
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "rootProject": {
+      "description": "Create an application at the root of the workspace.",
+      "type": "boolean",
+      "default": false,
+      "hidden": true,
+      "x-priority": "internal"
+    },
+    "style": {
+      "description": "The file extension to be used for style files.",
+      "type": "string",
+      "alias": "s",
+      "default": "css",
+      "x-prompt": {
+        "message": "Which stylesheet format would you like to use?",
+        "type": "list",
+        "items": [
+          { "value": "css", "label": "CSS" },
+          {
+            "value": "scss",
+            "label": "SASS(.scss)       [ https://sass-lang.com          ]"
+          },
+          {
+            "value": "less",
+            "label": "LESS              [ https://lesscss.org            ]"
+          },
+          { "value": "none", "label": "None" }
+        ]
+      }
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint `parserOptions.project` option. We do not do this by default for lint performance reasons.",
+      "default": false
+    }
+  },
+  "required": [],
+  "examplesFile": "../../../docs/application-examples.md"
+}

package/src/generators/init/init.d.ts

@@ -0,0 +1,4 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { InitSchema } from './schema';
+export declare function nuxtInitGenerator(host: Tree, schema: InitSchema): Promise<GeneratorCallback>;
+export default nuxtInitGenerator;

package/src/generators/init/init.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nuxtInitGenerator = void 0;
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const plugin_1 = require("../../plugins/plugin");
+const utils_1 = require("./lib/utils");
+async function nuxtInitGenerator(host, schema) {
+    (0, utils_1.addPlugin)(host);
+    let installTask = () => { };
+    if (!schema.skipPackageJson) {
+        installTask = (0, utils_1.updateDependencies)(host, schema);
+    }
+    if (schema.updatePackageScripts) {
+        await (0, update_package_scripts_1.updatePackageScripts)(host, plugin_1.createNodes);
+    }
+    return installTask;
+}
+exports.nuxtInitGenerator = nuxtInitGenerator;
+exports.default = nuxtInitGenerator;

package/src/generators/init/lib/utils.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+import { InitSchema } from '../schema';
+export declare function updateDependencies(host: Tree, schema: InitSchema): import("@nx/devkit").GeneratorCallback;
+export declare function addVitestTargetDefaults(tree: Tree): void;
+export declare function addPlugin(tree: Tree): void;

package/src/generators/init/lib/utils.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPlugin = exports.addVitestTargetDefaults = exports.updateDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../../utils/versions");
+function updateDependencies(host, schema) {
+    return (0, devkit_1.addDependenciesToPackageJson)(host, {}, {
+        '@nx/nuxt': versions_1.nxVersion,
+        nuxt: versions_1.nuxtVersion,
+        '@nx/vite': versions_1.nxVersion,
+    }, undefined, schema.keepExistingVersions);
+}
+exports.updateDependencies = updateDependencies;
+function addVitestTargetDefaults(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const productionFileSet = nxJson.namedInputs?.production;
+    if (productionFileSet) {
+        productionFileSet.push('!{projectRoot}/**/?(*.)+(spec|test).[jt]s?(x)?(.snap)', '!{projectRoot}/tsconfig.spec.json');
+        nxJson.namedInputs.production = Array.from(new Set(productionFileSet));
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.addVitestTargetDefaults = addVitestTargetDefaults;
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    let hasNxNuxtPlugin = false;
+    let hasNxVitePlugin = false;
+    for (const plugin of nxJson.plugins) {
+        if (typeof plugin === 'string'
+            ? plugin === '@nx/nuxt/plugin'
+            : plugin.plugin === '@nx/nuxt/plugin') {
+            hasNxNuxtPlugin = true;
+        }
+        if (typeof plugin === 'string'
+            ? plugin === '@nx/vite/plugin'
+            : plugin.plugin === '@nx/vite/plugin') {
+            hasNxVitePlugin = true;
+        }
+    }
+    if (!hasNxNuxtPlugin) {
+        nxJson.plugins.push({
+            plugin: '@nx/nuxt/plugin',
+            options: {
+                buildTargetName: 'build',
+                serveTargetName: 'serve',
+                serveStaticTargetName: 'serve-static',
+            },
+        });
+    }
+    if (!hasNxVitePlugin) {
+        nxJson.plugins.push({
+            plugin: '@nx/vite/plugin',
+            options: {
+                buildTargetName: 'build',
+                previewTargetName: 'preview',
+                testTargetName: 'test',
+                serveTargetName: 'serve',
+                serveStaticTargetName: 'serve-static',
+            },
+        });
+    }
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.addPlugin = addPlugin;

package/src/generators/init/schema.d.ts

@@ -0,0 +1,6 @@
+export interface InitSchema {
+  skipFormat?: boolean;
+  skipPackageJson?: boolean;
+  keepExistingVersions?: boolean;
+  updatePackageScripts?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,33 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NxNuxtInit",
+  "title": "Init Nuxt Plugin",
+  "description": "Initialize a Nuxt Plugin.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false
+    },
+    "skipPackageJson": {
+      "description": "Do not add dependencies to `package.json`.",
+      "type": "boolean",
+      "default": false
+    },
+    "keepExistingVersions": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Keep existing dependencies versions",
+      "default": false
+    },
+    "updatePackageScripts": {
+      "type": "boolean",
+      "x-priority": "internal",
+      "description": "Update `package.json` scripts with inferred targets",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/generators/storybook-configuration/configuration.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function storybookConfigurationGenerator(tree: Tree, options: Schema): Promise<import("@nx/devkit").GeneratorCallback>;
+export default storybookConfigurationGenerator;

package/src/generators/storybook-configuration/configuration.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storybookConfigurationGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const vue_1 = require("@nx/vue");
+/*
+ * This generator is basically the Vue one, but for Nuxt we
+ * are just adding the styles in `.storybook/preview.ts`
+ */
+async function storybookConfigurationGenerator(tree, options) {
+    const storybookConfigurationGenerator = await (0, vue_1.storybookConfigurationGenerator)(tree, {
+        ...options,
+        addPlugin: true,
+    });
+    const { root } = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    tree.write((0, devkit_1.joinPathFragments)(root, '.storybook', 'preview.' + options.tsConfiguration ? 'ts' : 'js'), `import '../src/assets/css/styles.css';`);
+    (0, devkit_1.updateJson)(tree, `${root}/tsconfig.storybook.json`, (json) => {
+        json.compilerOptions = {
+            ...json.compilerOptions,
+            composite: true,
+        };
+        return json;
+    });
+    await (0, devkit_1.formatFiles)(tree);
+    return (0, devkit_1.runTasksInSerial)(storybookConfigurationGenerator);
+}
+exports.storybookConfigurationGenerator = storybookConfigurationGenerator;
+exports.default = storybookConfigurationGenerator;

package/src/generators/storybook-configuration/schema.d.ts

@@ -0,0 +1,12 @@
+import { Linter } from '@nx/eslint';
+
+export interface Schema {
+  project: string;
+  interactionTests?: boolean;
+  generateStories?: boolean;
+  js?: boolean;
+  tsConfiguration?: boolean;
+  linter?: Linter;
+  ignorePaths?: string[];
+  configureStaticServe?: boolean;
+}