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

package/src/generators/custom-server/custom-server.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customServerGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const add_swc_to_custom_server_1 = require("../../utils/add-swc-to-custom-server");
+async function customServerGenerator(host, options) {
+    const project = (0, devkit_1.readProjectConfiguration)(host, options.project);
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    const hasPlugin = nxJson.plugins?.some((p) => typeof p === 'string'
+        ? p === '@nx/next/plugin'
+        : p.plugin === '@nx/next/plugin');
+    if (project.targets?.build?.executor !== '@nx/next:build' &&
+        project.targets?.build?.executor !== '@nrwl/next:build' &&
+        !hasPlugin) {
+        devkit_1.logger.error(`Project ${options.project} is not a Next.js project. Did you generate it with "nx g @nx/next:app"?`);
+        return;
+    }
+    // In Nx 18 next artifacts are inside the project root .next/ & dist/ (for custom server)
+    const outputPath = hasPlugin
+        ? `dist/${project.root}`
+        : project.targets?.build?.options?.outputPath;
+    const root = project.root;
+    if ((!root ||
+        !outputPath ||
+        !project.targets?.build?.configurations?.development ||
+        !project.targets?.build?.configurations?.production) &&
+        !hasPlugin) {
+        devkit_1.logger.error(`Project ${options.project} has invalid config. Did you generate it with "nx g @nx/next:app"?`);
+        return;
+    }
+    if (project.targets?.['build-custom-server'] ||
+        project.targets?.['serve-custom-server']) {
+        devkit_1.logger.warn(`Project ${options.project} has custom server targets already: build-custom-server, serve-custom-server. Remove these targets from project and try again.`);
+        return;
+    }
+    // In Nx 18 next artifacts are inside the project root .next/ & dist/ (for custom server)
+    // So we need ensure the mapping is correct from dist to the project root
+    const projectPathFromDist = `../../${(0, devkit_1.offsetFromRoot)(project.root)}${project.root}`;
+    (0, devkit_1.generateFiles)(host, (0, path_1.join)(__dirname, 'files'), project.root, {
+        ...options,
+        hasPlugin,
+        projectPathFromDist,
+        offsetFromRoot: (0, devkit_1.offsetFromRoot)(project.root),
+        projectRoot: project.root,
+        tmpl: '',
+    });
+    if (!hasPlugin) {
+        project.targets.build.dependsOn = ['build-custom-server'];
+        project.targets.serve.options.customServerTarget = `${options.project}:serve-custom-server`;
+        project.targets.serve.configurations.development.customServerTarget = `${options.project}:serve-custom-server:development`;
+        project.targets.serve.configurations.production.customServerTarget = `${options.project}:serve-custom-server:production`;
+    }
+    else {
+        project.targets['build'] = {
+            dependsOn: ['^build', 'build-custom-server'],
+        };
+    }
+    project.targets['build-custom-server'] = {
+        executor: options.compiler === 'tsc' ? '@nx/js:tsc' : '@nx/js:swc',
+        defaultConfiguration: 'production',
+        options: {
+            outputPath,
+            main: `${root}/server/main.ts`,
+            tsConfig: `${root}/tsconfig.server.json`,
+            clean: false,
+            assets: [],
+        },
+        configurations: {
+            development: {},
+            production: {},
+        },
+    };
+    project.targets['serve-custom-server'] = {
+        executor: '@nx/js:node',
+        defaultConfiguration: 'production',
+        options: {
+            buildTarget: `${options.project}:build-custom-server`,
+        },
+        configurations: {
+            development: {
+                buildTarget: `${options.project}:build-custom-server:development`,
+            },
+            production: {
+                buildTarget: `${options.project}:build-custom-server:production`,
+            },
+        },
+    };
+    (0, devkit_1.updateProjectConfiguration)(host, options.project, project);
+    (0, devkit_1.updateJson)(host, 'nx.json', (json) => {
+        if (!json.tasksRunnerOptions?.default?.options?.cacheableOperations?.includes('build-custom-server') &&
+            json.tasksRunnerOptions?.default?.options?.cacheableOperations) {
+            json.tasksRunnerOptions.default.options.cacheableOperations.push('build-custom-server');
+        }
+        json.targetDefaults ??= {};
+        json.targetDefaults['build-custom-server'] ??= {};
+        json.targetDefaults['build-custom-server'].cache ??= true;
+        return json;
+    });
+    if (options.compiler === 'swc') {
+        return (0, add_swc_to_custom_server_1.configureForSwc)(host, project.root);
+    }
+}
+exports.customServerGenerator = customServerGenerator;

package/src/generators/custom-server/files/server/main.ts__tmpl__

@@ -0,0 +1,46 @@
+/*
+ * This is only a minimal custom server to get started.
+ * You may want to consider using Express or another server framework, and enable security features such as CORS.
+ *
+ * For an example, see the Next.js repo:
+ * Node - https://github.com/vercel/next.js/blob/canary/examples/custom-server
+ */
+import { createServer } from 'http';
+import { parse } from 'node:url';
+import * as path from 'path';
+import next from 'next';
+
+// Next.js server options:
+// - The environment variable is set by `@nx/next:server` when running the dev server.
+// - The fallback `__dirname` is for production builds.
+// - Feel free to change this to suit your needs.
+
+const dir = process.env.NX_NEXT_DIR || <%- hasPlugin ? `path.join(__dirname, '${projectPathFromDist}')` : `path.join(__dirname, '..')`; %> 
+const dev = process.env.NODE_ENV === 'development';
+
+// HTTP Server options:
+// - Feel free to change this to suit your needs.
+const hostname = process.env.HOST || 'localhost';
+const port = process.env.PORT ? parseInt(process.env.PORT) : 4200;
+
+async function main() {
+  const nextApp = next({ dev, dir });
+  const handle = nextApp.getRequestHandler();
+
+  await nextApp.prepare();
+
+  const server = createServer((req, res) => {
+    const parsedUrl = parse(req.url ?? '', true);
+    handle(req, res, parsedUrl);
+  });
+
+  server.listen(port, hostname);
+
+  console.log(`[ ready ] on http://${hostname}:${port}`)
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+

package/src/generators/custom-server/files/tsconfig.server.json__tmpl__

@@ -0,0 +1,17 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "noEmit": false,
+    "incremental": true,
+    <% if(hasPlugin && compiler === 'tsc') { %>
+    "tsBuildInfoFile": "<%= offsetFromRoot %>tmp/buildcache/<%= projectRoot %>/server",
+    <% } %>
+    "types": [
+      "node"
+    ]
+  },
+  "include": [
+    "server/**/*.ts"
+  ]
+}

package/src/generators/custom-server/schema.d.ts

@@ -0,0 +1,4 @@
+export interface CustomServerSchema {
+  project: string;
+  compiler?: 'tsc' | 'swc';
+}

package/src/generators/custom-server/schema.json

@@ -0,0 +1,30 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxNextCustomServer",
+  "title": "Add custom server",
+  "description": "Add a custom server to existing Next.js application.",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project.",
+      "alias": "p",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-dropdown": "project",
+      "x-prompt": "What is the name of the project to set up a custom server for?",
+      "x-priority": "important"
+    },
+    "compiler": {
+      "type": "string",
+      "enum": ["tsc", "swc"],
+      "default": "tsc",
+      "description": "The compiler used to build the custom server."
+    }
+  },
+  "required": ["project"],
+  "examplesFile": "../../../docs/custom-server-examples.md"
+}

package/src/generators/cypress-component-configuration/cypress-component-configuration.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { CypressComponentConfigurationGeneratorSchema } from './schema';
+export declare function cypressComponentConfiguration(tree: Tree, options: CypressComponentConfigurationGeneratorSchema): Promise<GeneratorCallback>;
+export declare function cypressComponentConfigurationInternal(tree: Tree, options: CypressComponentConfigurationGeneratorSchema): Promise<GeneratorCallback>;
+export default cypressComponentConfiguration;

package/src/generators/cypress-component-configuration/cypress-component-configuration.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cypressComponentConfigurationInternal = exports.cypressComponentConfiguration = void 0;
+const devkit_1 = require("@nx/devkit");
+const ct_utils_1 = require("@nx/react/src/utils/ct-utils");
+const versions_1 = require("../../utils/versions");
+const react_1 = require("@nx/react");
+const path_1 = require("path");
+function cypressComponentConfiguration(tree, options) {
+    return cypressComponentConfigurationInternal(tree, {
+        addPlugin: false,
+        ...options,
+    });
+}
+exports.cypressComponentConfiguration = cypressComponentConfiguration;
+async function cypressComponentConfigurationInternal(tree, options) {
+    const tasks = [];
+    const { componentConfigurationGenerator: baseCyCtConfig } = (0, devkit_1.ensurePackage)('@nx/cypress', versions_1.nxVersion);
+    tasks.push(await baseCyCtConfig(tree, {
+        project: options.project,
+        skipFormat: true,
+        framework: 'next',
+        jsx: true,
+        addPlugin: options.addPlugin,
+    }));
+    const { webpackInitGenerator } = (0, devkit_1.ensurePackage)('@nx/webpack', versions_1.nxVersion);
+    tasks.push(await webpackInitGenerator(tree, {
+        skipFormat: true,
+        addPlugin: options.addPlugin,
+    }));
+    const { ensureDependencies } = await Promise.resolve().then(() => require('@nx/webpack/src/utils/ensure-dependencies'));
+    tasks.push(ensureDependencies(tree, { compiler: 'swc', uiFramework: 'react' }));
+    const projectConfig = (0, devkit_1.readProjectConfiguration)(tree, options.project);
+    if (projectConfig.targets?.['component-test']?.executor ===
+        '@nx/cypress:cypress') {
+        projectConfig.targets['component-test'].options = {
+            ...projectConfig.targets['component-test'].options,
+            skipServe: true,
+        };
+        (0, devkit_1.updateProjectConfiguration)(tree, options.project, projectConfig);
+    }
+    await addFiles(tree, projectConfig, options);
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(tree);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.cypressComponentConfigurationInternal = cypressComponentConfigurationInternal;
+async function addFiles(tree, projectConfig, opts) {
+    const { addMountDefinition, addDefaultCTConfig } = await Promise.resolve().then(() => require('@nx/cypress/src/utils/config'));
+    const ctFile = (0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress', 'support', 'component.ts');
+    const updatedCommandFile = await addMountDefinition(tree.read(ctFile, 'utf-8'));
+    tree.write(ctFile, `import { mount } from 'cypress/react18';\nimport './styles.ct.css';\n${updatedCommandFile}`);
+    const cyFile = (0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress.config.ts');
+    const updatedCyConfig = await addDefaultCTConfig(tree.read(cyFile, 'utf-8'));
+    tree.write(cyFile, `import { nxComponentTestingPreset } from '@nx/next/plugins/component-testing';\n${updatedCyConfig}`);
+    const isUsingTailwind = ['js', 'cjs'].some((ext) => tree.exists((0, devkit_1.joinPathFragments)(projectConfig.root, `tailwind.config.${ext}`)));
+    tree.write((0, devkit_1.joinPathFragments)(projectConfig.root, 'cypress', 'support', 'styles.ct.css'), `/* This is where you can load global styles to apply to all components. */
+${isUsingTailwind
+        ? `@tailwind base;
+@tailwind components;
+@tailwind utilities;`
+        : ''}
+`);
+    if (opts.generateTests) {
+        const filePaths = [];
+        (0, devkit_1.visitNotIgnoredFiles)(tree, projectConfig.sourceRoot, (filePath) => {
+            const fromProjectRootPath = (0, path_1.relative)(projectConfig.root, filePath);
+            // we don't generate tests for pages/server-side/appDir components
+            if (fromProjectRootPath.includes('pages') ||
+                fromProjectRootPath.includes('server') ||
+                fromProjectRootPath.includes('app')) {
+                return;
+            }
+            if ((0, ct_utils_1.isComponent)(tree, filePath)) {
+                filePaths.push(filePath);
+            }
+        });
+        for (const filePath of filePaths) {
+            await (0, react_1.componentTestGenerator)(tree, {
+                project: opts.project,
+                componentPath: filePath,
+            });
+        }
+    }
+}
+exports.default = cypressComponentConfiguration;

package/src/generators/cypress-component-configuration/schema.d.ts

@@ -0,0 +1,6 @@
+export interface CypressComponentConfigurationGeneratorSchema {
+  project: string;
+  generateTests: boolean;
+  skipFormat?: boolean;
+  addPlugin?: boolean;
+}

package/src/generators/cypress-component-configuration/schema.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "CypressComponentConfiguration",
+  "title": "NextJS Component Testing Configuration",
+  "description": "Add Cypress Componet Testing to an existing NextJS project.",
+  "type": "object",
+  "examples": [
+    {
+      "command": "nx g @nx/next:cypress-component-configuration --project=my-next-project",
+      "description": "Add component testing to your Next project"
+    },
+    {
+      "command": "nx g @nx/next:cypress-component-configuration --project=my-next-project --generate-tests",
+      "description": "Add component testing to your Next project and generate component tests for your existing components"
+    }
+  ],
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project to add cypress component testing configuration to",
+      "x-dropdown": "projects",
+      "x-prompt": "What project should we add Cypress component testing to?",
+      "x-priority": "important"
+    },
+    "generateTests": {
+      "type": "boolean",
+      "description": "Generate default component tests for existing components in the project",
+      "x-prompt": "Automatically generate tests for components declared in this project?",
+      "default": false,
+      "x-priority": "important"
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Skip formatting files",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["project"],
+  "examplesFile": "../../../docs/cypress-component-configuration-examples.md"
+}

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

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

package/src/generators/init/init.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nextInitGeneratorInternal = exports.nextInitGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const update_package_scripts_1 = require("@nx/devkit/src/utils/update-package-scripts");
+const versions_1 = require("@nx/react/src/utils/versions");
+const add_gitignore_entry_1 = require("../../utils/add-gitignore-entry");
+const versions_2 = require("../../utils/versions");
+const add_plugin_1 = require("./lib/add-plugin");
+function updateDependencies(host, schema) {
+    const tasks = [];
+    tasks.push((0, devkit_1.removeDependenciesFromPackageJson)(host, ['@nx/next'], []));
+    tasks.push((0, devkit_1.addDependenciesToPackageJson)(host, {
+        next: versions_2.nextVersion,
+        react: versions_1.reactVersion,
+        'react-dom': versions_1.reactDomVersion,
+    }, {
+        '@nx/next': versions_2.nxVersion,
+    }, undefined, schema.keepExistingVersions));
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+function nextInitGenerator(tree, schema) {
+    return nextInitGeneratorInternal(tree, { addPlugin: false, ...schema });
+}
+exports.nextInitGenerator = nextInitGenerator;
+async function nextInitGeneratorInternal(host, schema) {
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    schema.addPlugin ??= addPluginDefault;
+    if (schema.addPlugin) {
+        (0, add_plugin_1.addPlugin)(host);
+    }
+    (0, add_gitignore_entry_1.addGitIgnoreEntry)(host);
+    let installTask = () => { };
+    if (!schema.skipPackageJson) {
+        installTask = updateDependencies(host, schema);
+    }
+    if (schema.updatePackageScripts) {
+        const { createNodes } = await Promise.resolve().then(() => require('../../plugins/plugin'));
+        await (0, update_package_scripts_1.updatePackageScripts)(host, createNodes);
+    }
+    return installTask;
+}
+exports.nextInitGeneratorInternal = nextInitGeneratorInternal;
+exports.default = nextInitGenerator;

package/src/generators/init/lib/add-plugin.d.ts

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

package/src/generators/init/lib/add-plugin.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addPlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+function addPlugin(tree) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    nxJson.plugins ??= [];
+    for (const plugin of nxJson.plugins) {
+        if (typeof plugin === 'string'
+            ? plugin === '@nx/next/plugin'
+            : plugin.plugin === '@nx/next/plugin') {
+            return;
+        }
+    }
+    nxJson.plugins.push({
+        plugin: '@nx/next/plugin',
+        options: {
+            buildTargetName: 'build',
+            devTargetName: 'dev',
+            startTargetName: 'start',
+            serveStaticTargetName: 'serve-static',
+        },
+    });
+    (0, devkit_1.updateNxJson)(tree, nxJson);
+}
+exports.addPlugin = addPlugin;

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

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

package/src/generators/init/schema.json

@@ -0,0 +1,34 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "NxNextNgInit",
+  "title": "Init Next Plugin",
+  "description": "Init Next Plugin.",
+  "type": "object",
+  "properties": {
+    "skipFormat": {
+      "description": "Skip formatting files.",
+      "type": "boolean",
+      "default": false
+    },
+    "skipPackageJson": {
+      "type": "boolean",
+      "default": false,
+      "description": "Do not add dependencies to `package.json`.",
+      "x-priority": "internal"
+    },
+    "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/library/lib/normalize-options.d.ts

@@ -0,0 +1,7 @@
+import { Tree } from '@nx/devkit';
+import { Schema } from '../schema';
+export interface NormalizedSchema extends Schema {
+    importPath: string;
+    projectRoot: string;
+}
+export declare function normalizeOptions(host: Tree, options: Schema): Promise<NormalizedSchema>;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeOptions = 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");
+async function normalizeOptions(host, options) {
+    const { projectRoot, importPath, projectNameAndRootFormat } = await (0, project_name_and_root_utils_1.determineProjectNameAndRootOptions)(host, {
+        name: options.name,
+        projectType: 'library',
+        directory: options.directory,
+        importPath: options.importPath,
+        projectNameAndRootFormat: options.projectNameAndRootFormat,
+        callingGenerator: '@nx/next:library',
+    });
+    options.projectNameAndRootFormat = projectNameAndRootFormat;
+    const nxJson = (0, devkit_1.readNxJson)(host);
+    const addPlugin = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    options.addPlugin ??= addPlugin;
+    return {
+        ...options,
+        importPath,
+        projectRoot,
+    };
+}
+exports.normalizeOptions = normalizeOptions;

package/src/generators/library/library.d.ts

@@ -0,0 +1,5 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+import { Schema } from './schema';
+export declare function libraryGenerator(host: Tree, rawOptions: Schema): Promise<GeneratorCallback>;
+export declare function libraryGeneratorInternal(host: Tree, rawOptions: Schema): Promise<GeneratorCallback>;
+export default libraryGenerator;

package/src/generators/library/library.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.libraryGeneratorInternal = exports.libraryGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+const library_1 = require("@nx/react/src/generators/library/library");
+const js_1 = require("@nx/js");
+const versions_1 = require("@nx/react/src/utils/versions");
+const init_1 = require("../init/init");
+const normalize_options_1 = require("./lib/normalize-options");
+const versions_2 = require("../../utils/versions");
+async function libraryGenerator(host, rawOptions) {
+    return await libraryGeneratorInternal(host, {
+        addPlugin: false,
+        projectNameAndRootFormat: 'derived',
+        ...rawOptions,
+    });
+}
+exports.libraryGenerator = libraryGenerator;
+async function libraryGeneratorInternal(host, rawOptions) {
+    const options = await (0, normalize_options_1.normalizeOptions)(host, rawOptions);
+    const tasks = [];
+    const jsInitTask = await (0, js_1.initGenerator)(host, {
+        js: options.js,
+        skipPackageJson: options.skipPackageJson,
+        skipFormat: true,
+    });
+    tasks.push(jsInitTask);
+    const initTask = await (0, init_1.nextInitGenerator)(host, {
+        ...options,
+        skipFormat: true,
+    });
+    tasks.push(initTask);
+    const libTask = await (0, library_1.libraryGenerator)(host, {
+        ...options,
+        compiler: 'swc',
+        skipFormat: true,
+    });
+    tasks.push(libTask);
+    if (!options.skipPackageJson) {
+        const devDependencies = {};
+        if (options.linter === 'eslint') {
+            devDependencies['eslint-config-next'] = versions_2.eslintConfigNextVersion;
+        }
+        if (options.unitTestRunner && options.unitTestRunner !== 'none') {
+            devDependencies['@testing-library/react'] = versions_1.testingLibraryReactVersion;
+        }
+        tasks.push((0, devkit_1.addDependenciesToPackageJson)(host, { tslib: versions_2.tsLibVersion }, devDependencies));
+    }
+    const indexPath = (0, devkit_1.joinPathFragments)(options.projectRoot, 'src', `index.${options.js ? 'js' : 'ts'}`);
+    const indexContent = host.read(indexPath, 'utf-8');
+    host.write(indexPath, `// Use this file to export React client components (e.g. those with 'use client' directive) or other non-server utilities\n${indexContent}`);
+    // Additional entry for Next.js libraries so React Server Components are exported from a separate entry point.
+    // This is needed because RSC exported from `src/index.ts` will mark the entire file as server-only and throw an error when used from a client component.
+    // See: https://github.com/nrwl/nx/issues/15830
+    const serverEntryPath = (0, devkit_1.joinPathFragments)(options.projectRoot, './src', 'server.' + (options.js ? 'js' : 'ts'));
+    host.write((0, devkit_1.joinPathFragments)(options.projectRoot, 'src', `server.${options.js ? 'js' : 'ts'}`), `// Use this file to export React server components
+    export * from './lib/hello-server';`);
+    host.write((0, devkit_1.joinPathFragments)(options.projectRoot, 'src/lib', `hello-server.${options.js ? 'js' : 'tsx'}`), `// React server components are async so you make database or API calls.
+      export async function HelloServer() {
+        return <h1>Hello Server</h1>
+      }
+    `);
+    (0, js_1.addTsConfigPath)(host, `${options.importPath}/server`, [serverEntryPath]);
+    (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.json'), (json) => {
+        if (options.style === '@emotion/styled') {
+            json.compilerOptions.jsxImportSource = '@emotion/react';
+        }
+        return json;
+    });
+    (0, devkit_1.updateJson)(host, (0, devkit_1.joinPathFragments)(options.projectRoot, 'tsconfig.lib.json'), (json) => {
+        if (!json.compilerOptions) {
+            json.compilerOptions = {
+                types: [],
+            };
+        }
+        if (!json.compilerOptions.types) {
+            json.compilerOptions.types = [];
+        }
+        json.compilerOptions.types = [
+            ...json.compilerOptions.types,
+            'next',
+            '@nx/next/typings/image.d.ts',
+        ];
+        return json;
+    });
+    if (!options.skipFormat) {
+        await (0, devkit_1.formatFiles)(host);
+    }
+    return (0, devkit_1.runTasksInSerial)(...tasks);
+}
+exports.libraryGeneratorInternal = libraryGeneratorInternal;
+exports.default = libraryGenerator;

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

@@ -0,0 +1,28 @@
+import type { ProjectNameAndRootFormat } from '@nx/devkit/src/generators/project-name-and-root-utils';
+import type { Linter } from '@nx/eslint';
+import type { SupportedStyles } from '@nx/react';
+
+export interface Schema {
+  name: string;
+  directory?: string;
+  projectNameAndRootFormat?: ProjectNameAndRootFormat;
+  style: SupportedStyles;
+  skipTsConfig?: boolean;
+  skipFormat?: boolean;
+  tags?: string;
+  pascalCaseFiles?: boolean;
+  routing?: boolean;
+  appProject?: string;
+  unitTestRunner: 'jest' | 'none';
+  linter: Linter;
+  component?: boolean;
+  publishable?: boolean;
+  buildable?: boolean;
+  importPath?: string;
+  js?: boolean;
+  globalCss?: boolean;
+  strict?: boolean;
+  setParserOptionsProject?: boolean;
+  skipPackageJson?: boolean;
+  addPlugin?: boolean;
+}