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

package/src/plugins/plugin.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEsmModule = exports.createNodes = 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 cache_directory_1 = require("nx/src/utils/cache-directory");
+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, 'next.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 = [
+    '**/next.config.{js,cjs,mjs}',
+    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] ??
+            (await buildNextTargets(configFilePath, projectRoot, options, context));
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    root: projectRoot,
+                    targets,
+                },
+            },
+        };
+    },
+];
+async function buildNextTargets(nextConfigPath, projectRoot, options, context) {
+    const nextConfig = await getNextConfig(nextConfigPath, context);
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const targets = {};
+    targets[options.buildTargetName] = await getBuildTargetConfig(namedInputs, projectRoot, nextConfig);
+    targets[options.devTargetName] = getDevTargetConfig(projectRoot);
+    targets[options.startTargetName] = getStartTargetConfig(options, projectRoot);
+    targets[options.serveStaticTargetName] = getStaticServeTargetConfig(options);
+    return targets;
+}
+async function getBuildTargetConfig(namedInputs, projectRoot, nextConfig) {
+    const nextOutputPath = await getOutputs(projectRoot, nextConfig);
+    // Set output path here so that `withNx` can pick it up.
+    const targetConfig = {
+        command: `next build`,
+        options: {
+            cwd: projectRoot,
+        },
+        dependsOn: ['^build'],
+        cache: true,
+        inputs: getInputs(namedInputs),
+        outputs: [nextOutputPath, `${nextOutputPath}/!(cache)`],
+    };
+    return targetConfig;
+}
+function getDevTargetConfig(projectRoot) {
+    const targetConfig = {
+        command: `next dev`,
+        options: {
+            cwd: projectRoot,
+        },
+    };
+    return targetConfig;
+}
+function getStartTargetConfig(options, projectRoot) {
+    const targetConfig = {
+        command: `next start`,
+        options: {
+            cwd: projectRoot,
+        },
+        dependsOn: [options.buildTargetName],
+    };
+    return targetConfig;
+}
+function getStaticServeTargetConfig(options) {
+    const targetConfig = {
+        executor: '@nx/web:file-server',
+        options: {
+            buildTarget: options.buildTargetName,
+            staticFilePath: '{projectRoot}/out',
+            port: 3000,
+        },
+    };
+    return targetConfig;
+}
+async function getOutputs(projectRoot, nextConfig) {
+    let dir = '.next';
+    const { PHASE_PRODUCTION_BUILD } = require('next/constants');
+    if (typeof nextConfig === 'function') {
+        // Works for both async and sync functions.
+        const configResult = await Promise.resolve(nextConfig(PHASE_PRODUCTION_BUILD, { defaultConfig: {} }));
+        if (configResult?.distDir) {
+            dir = configResult?.distDir;
+        }
+    }
+    else if (typeof nextConfig === 'object' && nextConfig?.distDir) {
+        // If nextConfig is an object, directly use its 'distDir' property.
+        dir = nextConfig.distDir;
+    }
+    if (projectRoot === '.') {
+        return `{projectRoot}/${dir}`;
+    }
+    else {
+        return `{workspaceRoot}/${projectRoot}/${dir}`;
+    }
+}
+async function getNextConfig(configFilePath, context) {
+    const resolvedPath = (0, path_1.join)(context.workspaceRoot, configFilePath);
+    let module;
+    if ((0, path_1.extname)(configFilePath) === '.mjs') {
+        module = await loadEsmModule(resolvedPath);
+    }
+    else {
+        module = load(resolvedPath);
+    }
+    return module.default ?? module;
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.buildTargetName ??= 'build';
+    options.devTargetName ??= 'dev';
+    options.startTargetName ??= 'start';
+    options.serveStaticTargetName ??= 'serve-static';
+    return options;
+}
+function getInputs(namedInputs) {
+    return [
+        ...('production' in namedInputs
+            ? ['default', '^production']
+            : ['default', '^default']),
+        {
+            externalDependencies: ['next'],
+        },
+    ];
+}
+const packageInstallationDirectories = ['node_modules', '.yarn'];
+/**
+ * Load the module after ensuring that the require cache is cleared.
+ */
+function load(path) {
+    // Clear cache if the path is in the cache
+    if (require.cache[path]) {
+        for (const key of Object.keys(require.cache)) {
+            if (!packageInstallationDirectories.some((dir) => key.includes(dir))) {
+                delete require.cache[key];
+            }
+        }
+    }
+    // Then require
+    return require(path);
+}
+/**
+ * Lazily compiled dynamic import loader function.
+ */
+let dynamicLoad;
+function loadEsmModule(modulePath) {
+    const modulePathWithCacheBust = `${modulePath}?version=${Date.now()}`;
+    dynamicLoad ??= new Function('modulePath', `return import(modulePath);`);
+    return dynamicLoad(modulePathWithCacheBust);
+}
+exports.loadEsmModule = loadEsmModule;

package/src/utils/add-gitignore-entry.d.ts

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

package/src/utils/add-gitignore-entry.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addGitIgnoreEntry = void 0;
+const ignore_1 = require("ignore");
+function addGitIgnoreEntry(host) {
+    if (!host.exists('.gitignore')) {
+        return;
+    }
+    let content = host.read('.gitignore', 'utf-8').trimEnd();
+    const ig = (0, ignore_1.default)();
+    ig.add(host.read('.gitignore', 'utf-8'));
+    if (!ig.ignores('apps/example/.next')) {
+        content = `${content}\n\n# Next.js\n.next\nout\n`;
+    }
+    host.write('.gitignore', content);
+}
+exports.addGitIgnoreEntry = addGitIgnoreEntry;

package/src/utils/add-swc-to-custom-server.d.ts

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

package/src/utils/add-swc-to-custom-server.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureForSwc = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("./versions");
+const add_swc_config_1 = require("@nx/js/src/utils/swc/add-swc-config");
+function configureForSwc(tree, projectRoot) {
+    const swcConfigPath = (0, devkit_1.joinPathFragments)(projectRoot, '.swcrc');
+    const rootPackageJson = (0, devkit_1.readJson)(tree, 'package.json');
+    const hasSwcDepedency = rootPackageJson.dependencies?.['@swc/core'] ||
+        rootPackageJson.devDependencies?.['@swc/core'];
+    const hasSwcCliDependency = rootPackageJson.dependencies?.['@swc/cli'] ||
+        rootPackageJson.devDependencies?.['@swc/cli'];
+    if (!tree.exists(swcConfigPath)) {
+        (0, add_swc_config_1.addSwcConfig)(tree, projectRoot);
+    }
+    if (tree.exists(swcConfigPath)) {
+        (0, devkit_1.updateJson)(tree, swcConfigPath, (json) => {
+            return {
+                ...json,
+                exclude: [...json.exclude, '.*.d.ts$'],
+            };
+        });
+    }
+    if (!hasSwcDepedency || !hasSwcCliDependency) {
+        addSwcDependencies(tree);
+        return () => (0, devkit_1.installPackagesTask)(tree);
+    }
+}
+exports.configureForSwc = configureForSwc;
+function addSwcDependencies(tree) {
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {}, {
+        '@swc-node/register': versions_1.swcNodeVersion,
+        '@swc/cli': versions_1.swcCliVersion,
+        '@swc/core': versions_1.swcCoreVersion,
+    });
+}

package/src/utils/compose-plugins.d.ts

@@ -0,0 +1,3 @@
+import type { NextConfig } from 'next';
+import type { NextConfigFn, NextPlugin, NextPluginThatReturnsConfigFn } from './config';
+export declare function composePlugins(...plugins: (NextPlugin | NextPluginThatReturnsConfigFn)[]): (baseConfig: NextConfig) => NextConfigFn;

package/src/utils/compose-plugins.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.composePlugins = void 0;
+function composePlugins(...plugins) {
+    return function (baseConfig) {
+        return async function combined(phase, context) {
+            let config = baseConfig;
+            for (const plugin of plugins) {
+                const fn = await plugin;
+                const configOrFn = fn(config);
+                if (typeof configOrFn === 'function') {
+                    config = await configOrFn(phase, context);
+                }
+                else {
+                    config = configOrFn;
+                }
+            }
+            return config;
+        };
+    };
+}
+exports.composePlugins = composePlugins;

package/src/utils/config-invalid-function.fixture.js

@@ -0,0 +1 @@
+module.exports = () => { };

package/src/utils/config-not-a-function.fixture.js

@@ -0,0 +1 @@
+module.exports = 'BAD';

package/src/utils/config.d.ts

@@ -0,0 +1,13 @@
+import type { NextConfig } from 'next';
+import { Configuration } from 'webpack';
+import { FileReplacement } from './types';
+export interface NextConfigFn {
+    (phase: string, context?: any): Promise<NextConfig> | NextConfig;
+}
+export interface NextPlugin {
+    (config: NextConfig): NextConfig;
+}
+export interface NextPluginThatReturnsConfigFn {
+    (config: NextConfig): NextConfigFn;
+}
+export declare function createWebpackConfig(workspaceRoot: string, projectRoot: string, fileReplacements?: FileReplacement[], assets?: any): (a: any, b: any) => Configuration;

package/src/utils/config.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebpackConfig = void 0;
+const path_1 = require("path");
+const create_copy_plugin_1 = require("./create-copy-plugin");
+function createWebpackConfig(workspaceRoot, projectRoot, fileReplacements = [], assets = null) {
+    return function webpackConfig(config, { isServer, }) {
+        fileReplacements
+            .map((fileReplacement) => ({
+            replace: (0, path_1.resolve)(workspaceRoot, fileReplacement.replace),
+            with: (0, path_1.resolve)(workspaceRoot, fileReplacement.with),
+        }))
+            .reduce((alias, replacement) => {
+            alias[replacement.replace] = replacement.with;
+            return alias;
+        }, config.resolve.alias);
+        // Copy (shared) assets to `public` folder during client-side compilation
+        if (!isServer && Array.isArray(assets) && assets.length > 0) {
+            config.plugins.push((0, create_copy_plugin_1.createCopyPlugin)(assets, workspaceRoot, projectRoot));
+        }
+        return config;
+    };
+}
+exports.createWebpackConfig = createWebpackConfig;

package/src/utils/constants.d.ts

@@ -0,0 +1 @@
+export * from 'next/dist/shared/lib/constants';

package/src/utils/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("next/dist/shared/lib/constants"), exports);

package/src/utils/create-cli-options.d.ts

@@ -0,0 +1 @@
+export declare function createCliOptions(obj: Record<string, string | number | boolean>): string[];

package/src/utils/create-cli-options.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCliOptions = void 0;
+function createCliOptions(obj) {
+    return Object.entries(obj).reduce((arr, [key, value]) => {
+        if (value !== undefined) {
+            const kebabCase = key.replace(/[A-Z]/g, (m) => '-' + m.toLowerCase());
+            arr.push(`--${kebabCase}=${value}`);
+        }
+        return arr;
+    }, []);
+}
+exports.createCliOptions = createCliOptions;

package/src/utils/create-copy-plugin.d.ts

@@ -0,0 +1,2 @@
+import * as CopyWebpackPlugin from 'copy-webpack-plugin';
+export declare function createCopyPlugin(assets: any[], root: string, sourceRoot: string): CopyWebpackPlugin;

package/src/utils/create-copy-plugin.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCopyPlugin = void 0;
+const CopyWebpackPlugin = require("copy-webpack-plugin");
+const path_1 = require("nx/src/utils/path");
+const path_2 = require("path");
+const fs_1 = require("fs");
+function normalizeAssets(assets, root, sourceRoot) {
+    return assets.map((asset) => {
+        if (typeof asset === 'string') {
+            const assetPath = (0, path_1.normalizePath)(asset);
+            const resolvedAssetPath = (0, path_2.resolve)(root, assetPath);
+            const resolvedSourceRoot = (0, path_2.resolve)(root, sourceRoot);
+            if (!resolvedAssetPath.startsWith(resolvedSourceRoot)) {
+                throw new Error(`The ${resolvedAssetPath} asset path must start with the project source root: ${sourceRoot}`);
+            }
+            const isDirectory = (0, fs_1.statSync)(resolvedAssetPath).isDirectory();
+            const input = isDirectory
+                ? resolvedAssetPath
+                : (0, path_2.dirname)(resolvedAssetPath);
+            const output = (0, path_2.relative)(resolvedSourceRoot, (0, path_2.resolve)(root, input));
+            const glob = isDirectory ? '**/*' : (0, path_2.basename)(resolvedAssetPath);
+            return {
+                input,
+                output,
+                glob,
+            };
+        }
+        else {
+            if (asset.output.startsWith('..')) {
+                throw new Error('An asset cannot be written to a location outside of the output path.');
+            }
+            const assetPath = (0, path_1.normalizePath)(asset.input);
+            const resolvedAssetPath = (0, path_2.resolve)(root, assetPath);
+            return {
+                ...asset,
+                input: resolvedAssetPath,
+                // Now we remove starting slash to make Webpack place it from the output root.
+                output: asset.output.replace(/^\//, ''),
+            };
+        }
+    });
+}
+function createCopyPlugin(assets, root, sourceRoot) {
+    return new CopyWebpackPlugin({
+        patterns: normalizeAssets(assets, root, sourceRoot).map((asset) => {
+            return {
+                context: asset.input,
+                to: (0, path_2.join)('../public', asset.output),
+                from: asset.glob,
+                globOptions: {
+                    ignore: [
+                        '.gitkeep',
+                        '**/.DS_Store',
+                        '**/Thumbs.db',
+                        ...(asset.ignore ?? []),
+                    ],
+                    dot: true,
+                },
+            };
+        }),
+    });
+}
+exports.createCopyPlugin = createCopyPlugin;

package/src/utils/generate-globs.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Use createGlobPatterns instead
+ * @deprecated Use createGlobPatternsForDependencies instead
+ */
+export declare function createGlobPatternsOfDependentProjects(projectName: string, fileGlobPattern?: string): string[];

package/src/utils/generate-globs.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGlobPatternsOfDependentProjects = void 0;
+const devkit_1 = require("@nx/devkit");
+const devkit_2 = require("@nx/devkit");
+const project_graph_utils_1 = require("nx/src/utils/project-graph-utils");
+const path_1 = require("path");
+/**
+ * Use createGlobPatterns instead
+ * @deprecated Use createGlobPatternsForDependencies instead
+ */
+function createGlobPatternsOfDependentProjects(projectName, fileGlobPattern = '/**/!(*.stories|*.spec).tsx') {
+    devkit_1.logger.warn(`createGlobPatternsOfDependentProjects is deprecated. Use "createGlobPatternsForDependencies(__dirname)" from "@nx/next/tailwind" instead`);
+    try {
+        const [projectDirs, warnings] = (0, project_graph_utils_1.getSourceDirOfDependentProjects)(projectName);
+        if (warnings.length > 0) {
+            devkit_1.logger.warn(`
+[createGlobPatternsForDependencies] Failed to generate glob pattern for the following:
+${warnings.join('\n- ')}\n
+due to missing "sourceRoot" in the dependencies' project configuration
+      `);
+        }
+        return projectDirs.map((sourceDir) => (0, path_1.resolve)(devkit_2.workspaceRoot, (0, devkit_1.joinPathFragments)(sourceDir, fileGlobPattern)));
+    }
+    catch (e) {
+        throw new Error(`createGlobPatternsOfDependentProjects: Error when generating globs: ${e?.message}`);
+    }
+}
+exports.createGlobPatternsOfDependentProjects = createGlobPatternsOfDependentProjects;

package/src/utils/styles.d.ts

@@ -0,0 +1,67 @@
+import { GeneratorCallback, Tree } from '@nx/devkit';
+export declare const nextSpecificStyleDependenciesBabel: {
+    'styled-components': {
+        dependencies: import("../../../../build/packages/react/src/utils/dependencies").DependencyEntries;
+        devDependencies: {
+            'babel-plugin-styled-components': string;
+        };
+    };
+    '@emotion/styled': {
+        dependencies: {
+            '@emotion/server': string;
+        };
+        devDependencies: import("../../../../build/packages/react/src/utils/dependencies").DependencyEntries;
+    };
+    css: {
+        dependencies: {};
+        devDependencies: {};
+    };
+    scss: {
+        dependencies: {};
+        devDependencies: {
+            sass: string;
+        };
+    };
+    less: {
+        dependencies: {};
+        devDependencies: {
+            less: string;
+            'less-loader': string;
+        };
+    };
+};
+export declare const nextSpecificStyleDependenciesSwc: {
+    'styled-components': {
+        dependencies: import("../../../../build/packages/react/src/utils/dependencies").DependencyEntries;
+        devDependencies: {
+            'babel-plugin-styled-components': string;
+        };
+    };
+    '@emotion/styled': {
+        dependencies: {
+            '@emotion/server': string;
+        };
+        devDependencies: import("../../../../build/packages/react/src/utils/dependencies").DependencyEntries;
+    };
+    css: {
+        dependencies: {};
+        devDependencies: {};
+    };
+    scss: {
+        dependencies: {};
+        devDependencies: {
+            sass: string;
+        };
+    };
+    less: {
+        dependencies: {};
+        devDependencies: {
+            less: string;
+            'less-loader': string;
+        };
+    };
+};
+export declare function addStyleDependencies(host: Tree, options: {
+    style?: string;
+    swc?: boolean;
+}): GeneratorCallback;

package/src/utils/styles.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addStyleDependencies = exports.nextSpecificStyleDependenciesSwc = exports.nextSpecificStyleDependenciesBabel = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("@nx/react/src/utils/versions");
+const styled_1 = require("@nx/react/src/utils/styled");
+const versions_2 = require("./versions");
+const nextSpecificStyleDependenciesCommon = {
+    css: {
+        dependencies: {},
+        devDependencies: {},
+    },
+    scss: {
+        dependencies: {},
+        devDependencies: { sass: versions_2.sassVersion },
+    },
+    less: {
+        dependencies: {},
+        devDependencies: {
+            less: versions_1.lessVersion,
+            'less-loader': versions_2.lessLoader,
+        },
+    },
+};
+exports.nextSpecificStyleDependenciesBabel = {
+    ...nextSpecificStyleDependenciesCommon,
+    'styled-components': {
+        dependencies: styled_1.cssInJsDependenciesBabel['styled-components'].dependencies,
+        devDependencies: {
+            ...styled_1.cssInJsDependenciesBabel['styled-components'].devDependencies,
+            'babel-plugin-styled-components': versions_2.babelPluginStyledComponentsVersion,
+        },
+    },
+    '@emotion/styled': {
+        dependencies: {
+            ...styled_1.cssInJsDependenciesBabel['@emotion/styled'].dependencies,
+            '@emotion/server': versions_2.emotionServerVersion,
+        },
+        devDependencies: styled_1.cssInJsDependenciesBabel['@emotion/styled'].devDependencies,
+    },
+};
+exports.nextSpecificStyleDependenciesSwc = {
+    ...nextSpecificStyleDependenciesCommon,
+    'styled-components': {
+        dependencies: styled_1.cssInJsDependenciesSwc['styled-components'].dependencies,
+        devDependencies: {
+            ...styled_1.cssInJsDependenciesSwc['styled-components'].devDependencies,
+            'babel-plugin-styled-components': versions_2.babelPluginStyledComponentsVersion,
+        },
+    },
+    '@emotion/styled': {
+        dependencies: {
+            ...styled_1.cssInJsDependenciesSwc['@emotion/styled'].dependencies,
+            '@emotion/server': versions_2.emotionServerVersion,
+        },
+        devDependencies: styled_1.cssInJsDependenciesSwc['@emotion/styled'].devDependencies,
+    },
+};
+function addStyleDependencies(host, options) {
+    const extraDependencies = options.swc
+        ? exports.nextSpecificStyleDependenciesSwc[options.style]
+        : exports.nextSpecificStyleDependenciesBabel[options.style];
+    return extraDependencies
+        ? (0, devkit_1.addDependenciesToPackageJson)(host, extraDependencies.dependencies, extraDependencies.devDependencies)
+        : () => { };
+}
+exports.addStyleDependencies = addStyleDependencies;

package/src/utils/types.d.ts

@@ -0,0 +1,57 @@
+export type NextServer = (options: NextServerOptions, proxyConfig?: ProxyConfig) => Promise<void>;
+export interface ProxyConfig {
+    [path: string]: {
+        target: string;
+        pathRewrite?: any;
+        changeOrigin?: boolean;
+        secure?: boolean;
+    };
+}
+export interface NextServerOptions {
+    dev: boolean;
+    dir: string;
+    staticMarkup: boolean;
+    quiet: boolean;
+    port: number;
+    hostname: string;
+    customServer?: boolean;
+}
+export interface FileReplacement {
+    replace: string;
+    with: string;
+}
+export interface NextBuildBuilderOptions {
+    outputPath: string;
+    fileReplacements: FileReplacement[];
+    assets?: any[];
+    nextConfig?: string;
+    buildLibsFromSource?: boolean;
+    includeDevDependenciesInPackageJson?: boolean;
+    generateLockfile?: boolean;
+    watch?: boolean;
+    debug?: boolean;
+    profile?: boolean;
+    experimentalAppOnly?: boolean;
+}
+export interface NextServeBuilderOptions {
+    dev: boolean;
+    port: number;
+    staticMarkup: boolean;
+    quiet: boolean;
+    buildTarget: string;
+    customServerTarget?: string;
+    hostname?: string;
+    buildLibsFromSource?: boolean;
+    keepAliveTimeout?: number;
+    turbo?: boolean;
+    experimentalHttps?: boolean;
+}
+export interface NextExportBuilderOptions {
+    buildTarget: string;
+    silent: boolean;
+    threads: number;
+    buildLibsFromSource?: boolean;
+}
+export interface WebpackConfigOptions {
+    svgr?: boolean;
+}

package/src/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/utils/versions.d.ts

@@ -0,0 +1,12 @@
+export declare const nxVersion: any;
+export declare const nextVersion = "14.0.4";
+export declare const eslintConfigNextVersion = "14.0.4";
+export declare const sassVersion = "1.62.1";
+export declare const lessLoader = "11.1.0";
+export declare const emotionServerVersion = "11.11.0";
+export declare const babelPluginStyledComponentsVersion = "1.10.7";
+export declare const tsLibVersion = "^2.3.0";
+export declare const swcCliVersion = "~0.1.62";
+export declare const swcCoreVersion = "~1.3.85";
+export declare const swcHelpersVersion = "~0.5.2";
+export declare const swcNodeVersion = "~1.8.0";