next.config.ts

import path from "path";
import fs from "fs";
import { NextConfig } from "next";
import { CSPGenerator, CSPDirectiveOptions } from "@Library/CSP";
import { jsonc } from "jsonc";

let tsconfig: any = jsonc.parse(fs.readFileSync(path.resolve(__dirname, "tsconfig.json"), "utf-8"));

let Extensions = [".tsx", ".ts", ".jsx", ".js", ".sass", ".ico", ".svg", ".webp", ".mdx", ".json", ".css", ".png", ".jpg"];

// Development performance optimization
const isDev = process.env.NODE_ENV === "development";
const useTurbopack = process.env.TURBOPACK === "1";

const nextConfig: NextConfig = {
    reactStrictMode: false,
    typedRoutes: false,
    typescript: {
        // TypeScript OOMs the build worker on this project size.
        // Run `bun typecheck` separately for full TS validation.
        ignoreBuildErrors: true
    },
    devIndicators: {
        position: "bottom-right"
    },
    productionBrowserSourceMaps: false,
    reactProductionProfiling: false,

    // SWC compiler options
    // compiler: {
    //     removeConsole: process.env.NODE_ENV === 'production',
    //     styledComponents: true,
    // },

    // Experimental features - cleaned up for latest Next.js
    experimental: {
        // Better memory management
        workerThreads: false,

        // Optimize bundling - these work with both webpack and turbopack
        optimizePackageImports: ["motion", "@heroicons/react", "react-icons", "@mui/icons-material", "@mui/material"],

        // Other performance features
        optimisticClientCache: true,
        serverMinification: true
    },

    // Enhanced images config for dev performance
    images: {
        loader: "custom",
        loaderFile: "./src/Utils/Load_Remote_Images.ts",
        minimumCacheTTL: isDev ? 3600 : 60,
        unoptimized: true,
        remotePatterns: [
            {
                protocol: "https",
                hostname: "*"
            },
            {
                protocol: "https",
                hostname: "lh3.googleusercontent.com"
            },
            {
                protocol: "https",
                hostname: "avatars.githubusercontent.com"
            }
        ],
        formats: ["image/webp", "image/avif"]
    },

    // Only apply headers in production to speed up dev
    async headers() {
        if (isDev) return [];

        return [
            {
                source: "/(.*)",
                headers: [
                    {
                        key: "X-Frame-Options",
                        value: "SAMEORIGIN"
                    },
                    {
                        key: "X-Content-Type-Options",
                        value: "nosniff"
                    },
                    {
                        key: "Referrer-Policy",
                        value: "same-origin"
                    },
                    {
                        key: "Strict-Transport-Security",
                        value: "max-age=31536000; includeSubDomains; preload"
                    },
                    {
                        key: "Content-Security-Policy",
                        value: CSPGenerator({
                            directive: {
                                [CSPDirectiveOptions.ObjectSrc]: {
                                    None: true
                                },
                                [CSPDirectiveOptions.FrameSrc]: {
                                    Domains: ["*"],
                                    Self: true
                                },
                                [CSPDirectiveOptions.FrameAncestors]: {
                                    Self: true
                                },
                                [CSPDirectiveOptions.ImgSrc]: {
                                    Self: true,
                                    Data: true,
                                    Blob: true,
                                    Domains: ["*"]
                                },
                                [CSPDirectiveOptions.ScriptSrc]: {
                                    Self: true,
                                    Inline: true,
                                    Eval: true,
                                    Domains: [
                                        "https://pagead2.googlesyndication.com",
                                        "https://ep2.adtrafficquality.google",
                                        "https://va.vercel-scripts.com",
                                        "https://cdn.jsdelivr.net",
                                        "https://unpkg.com",
                                        "https://suggestqueries.google.com",
                                        "https://api.bing.com",
                                        "https://duckduckgo.com"
                                    ]
                                },
                                [CSPDirectiveOptions.ConnectSrc]: {
                                    Self: true,
                                    Domains: ["https://suggestqueries.google.com", "https://api.bing.com", "https://duckduckgo.com", "*"]
                                },
                                [CSPDirectiveOptions.WorkerSrc]: {
                                    Self: true,
                                    Blob: true,
                                    Domains: ["https://meetbhingradiya.in", "https://beta.meetbhingradiya.in"]
                                },
                                [CSPDirectiveOptions.StyleSrc]: {
                                    Self: true,
                                    Inline: true
                                }
                            },
                            minify: true
                        }) as string
                    }
                ]
            }
        ];
    },

    // Enhanced SASS options
    sassOptions: {
        silenceDeprecations: ["legacy-js-api"],
        implementation: "sass",
        includePaths: [path.join(__dirname, "src", "Styles")],
        ...(isDev && {
            outputStyle: "expanded",
            sourceMap: true
        })
    },

    // Turbopack config - only valid options
    turbopack: {
        resolveExtensions: Extensions
        // Memory limit is handled by NODE_OPTIONS in your .env.local
        // No memoryLimit option exists here
    },

    // Webpack config - only when NOT using Turbopack
    ...(!useTurbopack && {
        webpack: (config: any, { buildId, dev, isServer, defaultLoaders, webpack }: any) => {
            // Development optimizations for webpack
            if (dev) {
                // Faster file watching
                config.watchOptions = {
                    poll: 1000,
                    aggregateTimeout: 300,
                    ignored: ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**", "**/.next/**", "**/coverage/**", "**/*.log"]
                };

                // Memory optimizations for large projects
                config.optimization = {
                    ...config.optimization,
                    removeAvailableModules: false,
                    removeEmptyChunks: false,
                    splitChunks: {
                        chunks: "async",
                        cacheGroups: {
                            default: false,
                            vendors: false
                        }
                    }
                };

                // Faster rebuilds
                config.snapshot = {
                    module: {
                        timestamp: true
                    },
                    resolve: {
                        timestamp: true
                    }
                };

                // Enhanced caching for development
                config.cache = {
                    type: "filesystem",
                    allowCollectingMemory: true,
                    buildDependencies: {
                        config: [__filename]
                    },
                    cacheDirectory: path.resolve(".next/cache")
                };
            }

            // Enhanced resolve configuration
            const Config = {
                ...config,
                resolve: {
                    ...config.resolve,
                    fallback: {
                        ...config.resolve.fallback,
                        // Prevent fflate/jspdf from pulling in Node.js worker_threads during SSR
                        worker_threads: false
                    },
                    alias: {
                        ...Object.fromEntries(
                            Object.entries(tsconfig.compilerOptions.paths).map(([key, value]: any) => [
                                key.replace("/*", ""),
                                path.resolve(path.resolve(), value[0].replace("/*", ""))
                            ])
                        ),
                        ...config.resolve.alias,
                        canvas: false
                    },
                    extensions: [...Extensions, ...config.resolve.extensions],
                    // Faster module resolution
                    symlinks: false,
                    cacheWithContext: false,
                    modules: ["node_modules"]
                },
                experiments: {
                    ...config.experiments,
                    topLevelAwait: true,
                    layers: true
                }
            };

            return Config;
        }
    }),

    serverExternalPackages: ["sharp", "jspdf"],

    // Additional dev optimizations
    onDemandEntries: {
        maxInactiveAge: 25 * 1000,
        pagesBufferLength: 2
    }
};

export default nextConfig;