next-build-filter 0.1.0

package/README.md

@@ -0,0 +1,357 @@
+# Next.js Build Filter Plugin
+
+A powerful Next.js plugin that allows you to exclude specific pages/routes from the build process without removing the files from your project. **Supports both Next.js Pages Router and App Router (Next.js 13+)**. This is perfect for speeding up development builds, creating different build configurations, or excluding admin/debug pages from production builds.
+
+## Features
+
+- 🚀 **Speed up builds** by excluding unnecessary pages/routes
+- 📱 **App Router Support** - Full Next.js 13+ App Router compatibility
+- 📄 **Pages Router Support** - Traditional Pages Router support
+- 🎯 **Flexible filtering** with multiple configuration options
+- 🔄 **Non-destructive** - files remain in your codebase
+- 🌍 **Environment-aware** - different configurations for dev/prod
+- 📝 **Verbose logging** to see what's being filtered
+- 🎨 **Pattern matching** support with regex
+- 🔧 **TypeScript support** with full type definitions
+
+## Installation
+
+```bash
+npm install next-build-filter
+```
+
+## Quick Start
+
+### For Pages Router (Traditional Next.js)
+
+```javascript
+// next.config.js
+const withPageFilter = require('next-build-filter');
+
+const filterConfig = {
+  enabled: process.env.FILTER_PAGES === 'true',
+  verbose: true,
+  supportPagesRouter: true,
+  supportAppRouter: false,
+  excludedPages: [
+    'admin',
+    'dev/debug',
+  ],
+};
+
+module.exports = withPageFilter(filterConfig)({
+  reactStrictMode: true,
+});
+```
+
+### For App Router (Next.js 13+)
+
+```javascript
+// next.config.js
+const withPageFilter = require('next-build-filter');
+
+const filterConfig = {
+  enabled: process.env.FILTER_PAGES === 'true',
+  verbose: true,
+  supportAppRouter: true,
+  supportPagesRouter: false,
+  excludedPages: [
+    'admin',        // Excludes app/admin/page.tsx
+    'dev/debug',    // Excludes app/dev/debug/page.tsx
+  ],
+};
+
+module.exports = withPageFilter(filterConfig)({
+  reactStrictMode: true,
+  experimental: {
+    appDir: true,
+  },
+});
+```
+
+### For Mixed Router Support (Both App Router and Pages Router)
+
+```javascript
+// next.config.js
+const withPageFilter = require('next-build-filter');
+
+const filterConfig = {
+  enabled: process.env.FILTER_PAGES === 'true',
+  verbose: true,
+  supportAppRouter: true,
+  supportPagesRouter: true,
+  excludedPages: [
+    'admin',        // Excludes both pages/admin.js and app/admin/page.tsx
+    'dev/debug',    // Excludes both pages/dev/debug.js and app/dev/debug/page.tsx
+  ],
+};
+
+module.exports = withPageFilter(filterConfig)({
+  reactStrictMode: true,
+  experimental: {
+    appDir: true,
+  },
+});
+```
+
+3. **Run filtered builds:**
+```bash
+# Normal build (all pages included)
+npm run build
+
+# Filtered build (excludes configured pages)
+FILTER_PAGES=true npm run build
+
+# Or use the predefined script
+npm run build:filtered
+```
+
+## Configuration Options
+
+### Basic Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `enabled` | boolean | `process.env.FILTER_PAGES === 'true'` | Enable/disable page filtering |
+| `verbose` | boolean | `false` | Show detailed logging of filtered pages |
+| `enableInDev` | boolean | `false` | Apply filtering in development mode |
+
+### Router Support Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `supportAppRouter` | boolean | `true` | Enable filtering for App Router (Next.js 13+) |
+| `supportPagesRouter` | boolean | `true` | Enable filtering for Pages Router |
+| `appDir` | string | `'app'` | App Router directory name |
+| `pagesDir` | string | `'pages'` | Pages Router directory name |
+
+### Filtering Options
+
+#### 1. Include Only Specific Pages
+```javascript
+const filterConfig = {
+  enabled: true,
+  includedPages: [
+    'index',      // /
+    'about',      // /about
+    'contact',    // /contact
+  ],
+};
+```
+
+#### 2. Exclude Specific Pages
+```javascript
+const filterConfig = {
+  enabled: true,
+  excludedPages: [
+    'admin',           // /admin
+    'dev/debug',       // /dev/debug
+    'api/internal',    // /api/internal
+  ],
+};
+```
+
+#### 3. Pattern-Based Exclusion
+```javascript
+const filterConfig = {
+  enabled: true,
+  excludePatterns: [
+    'dev/.*',          // All pages in /dev/ directory
+    '.*admin.*',       // Any page with 'admin' in the path
+    '.*test.*',        // Any page with 'test' in the path
+  ],
+};
+```
+
+## Usage Examples
+
+### Development Speed Build
+Perfect for large projects where you only need a few pages during development:
+
+```javascript
+// next.config.js
+const withPageFilter = require('./plugins/withPageFilter');
+
+const filterConfig = {
+  enabled: process.env.NODE_ENV === 'development',
+  verbose: true,
+  includedPages: [
+    'index',
+    'dashboard',
+    'profile',
+  ],
+};
+
+module.exports = withPageFilter(filterConfig)({
+  reactStrictMode: true,
+});
+```
+
+### Production Admin Exclusion
+Exclude admin and debug pages from production builds:
+
+```javascript
+const filterConfig = {
+  enabled: process.env.NODE_ENV === 'production',
+  excludedPages: [
+    'admin',
+    'debug',
+    'dev/tools',
+  ],
+  excludePatterns: [
+    'admin/.*',
+    'dev/.*',
+  ],
+};
+```
+
+### Environment Variable Control
+Use environment variables for flexible configuration:
+
+```javascript
+const filterConfig = {
+  enabled: process.env.FILTER_PAGES === 'true',
+  verbose: process.env.NODE_ENV === 'development',
+  excludedPages: process.env.EXCLUDED_PAGES ? 
+    process.env.EXCLUDED_PAGES.split(',') : [],
+  includedPages: process.env.INCLUDED_PAGES ? 
+    process.env.INCLUDED_PAGES.split(',') : [],
+};
+```
+
+Then use it:
+```bash
+# Include only specific pages
+FILTER_PAGES=true INCLUDED_PAGES=index,about,contact npm run build
+
+# Exclude specific pages
+FILTER_PAGES=true EXCLUDED_PAGES=admin,debug npm run build
+```
+
+## Available Scripts
+
+The project includes several npm scripts for different build scenarios:
+
+```bash
+# Development server
+npm run dev
+
+# Normal build (all pages)
+npm run build
+
+# Filtered build (respects FILTER_PAGES environment variable)
+npm run build:filtered
+
+# Start production server
+npm start
+```
+
+## How It Works
+
+The plugin works by integrating with Next.js's webpack configuration and build process:
+
+1. **Webpack Plugin Integration**: The plugin hooks into webpack's module resolution process
+2. **Page Detection**: It identifies page files in the `/pages` directory
+3. **Filtering Logic**: Based on your configuration, it determines which pages to exclude
+4. **Module Resolution**: Excluded pages are replaced with empty modules during the build process
+5. **Build Optimization**: The final bundle only includes the pages you want
+
+## Project Structure
+
+```
+next-build-filter/                    # Main plugin package
+├── lib/                              # Plugin source code
+│   ├── with-page-filter.js          # Main plugin wrapper
+│   ├── next-build-filter-plugin.js  # Webpack plugin
+│   ├── advanced-next-build-filter-plugin.js # Advanced filtering
+│   └── empty-module.js              # Replacement for filtered pages
+├── demo/                            # Demo projects
+│   ├── pages-router-demo/           # Pages Router demo
+│   │   ├── pages/                   # Traditional Next.js pages
+│   │   │   ├── index.js            # Home page
+│   │   │   ├── about.js            # About page
+│   │   │   ├── admin.js            # Admin page (filtered)
+│   │   │   └── dev/debug.js        # Debug page (filtered)
+│   │   ├── next.config.js          # Pages Router configuration
+│   │   └── package.json            # Demo dependencies
+│   └── app-router-demo/             # App Router demo (Next.js 13+)
+│       ├── app/                     # App Router structure
+│       │   ├── page.tsx            # Home route
+│       │   ├── layout.tsx          # Root layout
+│       │   ├── about/page.tsx      # About route
+│       │   ├── admin/page.tsx      # Admin route (filtered)
+│       │   └── dev/debug/page.tsx  # Debug route (filtered)
+│       ├── next.config.js          # App Router configuration
+│       └── package.json            # Demo dependencies
+├── index.js                         # Main entry point
+├── index.d.ts                       # TypeScript definitions
+├── package.json                     # Plugin package configuration
+└── README.md                        # This file
+```
+
+## Demo Projects
+
+This package includes two complete demo projects to showcase the filtering capabilities:
+
+### Pages Router Demo
+```bash
+cd demo/pages-router-demo
+npm install
+npm run build:filtered
+```
+
+### App Router Demo
+```bash
+cd demo/app-router-demo
+npm install
+npm run build:filtered
+```
+
+## Real-World Use Cases
+
+### 1. Large E-commerce Sites
+- Include only product pages during catalog development
+- Exclude admin pages from customer-facing builds
+
+### 2. Multi-tenant Applications
+- Build tenant-specific versions with only relevant pages
+- Exclude unused features per tenant
+
+### 3. Development Teams
+- Speed up local development by including only pages you're working on
+- Create lightweight builds for testing specific features
+
+### 4. Staging Environments
+- Create builds with debug pages for staging
+- Exclude debug pages from production
+
+## Tips and Best Practices
+
+1. **Start Small**: Begin by excluding just a few pages and gradually expand
+2. **Use Verbose Mode**: Enable verbose logging during development to see what's being filtered
+3. **Environment-Specific**: Use different configurations for different environments
+4. **Test Thoroughly**: Always test your filtered builds to ensure functionality
+5. **Document Configuration**: Keep your filtering logic well-documented for your team
+
+## Troubleshooting
+
+### Pages Still Appearing in Build
+- Check that `enabled: true` is set in your configuration
+- Verify the page paths match exactly (case-sensitive)
+- Enable verbose logging to see what's being processed
+
+### Build Errors
+- Ensure all required pages (like `_app.js`, `_document.js`) are not being filtered
+- Check that your regex patterns are valid if using `excludePatterns`
+
+### Development vs Production Differences
+- Set `enableInDev: true` if you want consistent behavior across environments
+- Use environment variables to control filtering per environment
+
+## Contributing
+
+Feel free to submit issues, feature requests, or pull requests to improve this plugin.
+
+## License
+
+MIT

package/index.d.ts

@@ -0,0 +1,42 @@
+declare module 'next-build-filter' {
+  import { NextConfig } from 'next';
+  
+  interface FilterOptions {
+    /** Enable/disable page filtering */
+    enabled?: boolean;
+    
+    /** Show detailed logging of filtered pages */
+    verbose?: boolean;
+    
+    /** Apply filtering in development mode */
+    enableInDev?: boolean;
+    
+    /** Pages to include (if specified, only these will be built) */
+    includedPages?: string[];
+    
+    /** Pages to exclude from build */
+    excludedPages?: string[];
+    
+    /** Regex patterns for page exclusion */
+    excludePatterns?: string[];
+    
+    /** Pages directory name (default: 'pages') */
+    pagesDir?: string;
+    
+    /** App directory name (default: 'app') */
+    appDir?: string;
+    
+    /** Support App Router (Next.js 13+) */
+    supportAppRouter?: boolean;
+    
+    /** Support Pages Router */
+    supportPagesRouter?: boolean;
+  }
+  
+  type NextConfigFunction = (nextConfig?: NextConfig) => NextConfig;
+  
+  function withPageFilter(options?: FilterOptions): NextConfigFunction;
+  
+  export = withPageFilter;
+  export { FilterOptions, NextConfigFunction };
+}

package/index.js

@@ -0,0 +1,6 @@
+const NextBuildFilterPlugin = require('./lib/next-build-filter-plugin');
+const withPageFilter = require('./lib/with-page-filter');
+
+module.exports = withPageFilter;
+module.exports.NextBuildFilterPlugin = NextBuildFilterPlugin;
+module.exports.withPageFilter = withPageFilter;

package/lib/advanced-next-build-filter-plugin.js

@@ -0,0 +1,204 @@
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Advanced Next.js Build Filter Plugin
+ * 
+ * This version integrates more deeply with Next.js's build process
+ * to provide better filtering capabilities.
+ */
+class AdvancedNextBuildFilterPlugin {
+  constructor(options = {}) {
+    this.options = {
+      includedPages: options.includedPages || [],
+      excludedPages: options.excludedPages || [],
+      enabled: options.enabled !== undefined ? options.enabled : process.env.FILTER_PAGES === 'true',
+      excludePatterns: options.excludePatterns || [],
+      verbose: options.verbose || false,
+      pagesDir: options.pagesDir || 'pages',
+      ...options
+    };
+
+    this.filteredPages = new Set();
+  }
+
+  apply(compiler) {
+    if (!this.options.enabled) {
+      if (this.options.verbose) {
+        console.log('📄 AdvancedNextBuildFilterPlugin: Filtering disabled');
+      }
+      return;
+    }
+
+    const pluginName = 'AdvancedNextBuildFilterPlugin';
+
+    // Hook into the entry option to filter pages at the entry level
+    compiler.hooks.entryOption.tap(pluginName, (context, entry) => {
+      if (typeof entry === 'object' && !Array.isArray(entry)) {
+        this.filterEntries(entry);
+      }
+    });
+
+    // Hook into the compilation to filter modules
+    compiler.hooks.compilation.tap(pluginName, (compilation) => {
+      compilation.hooks.buildModule.tap(pluginName, (module) => {
+        if (module.resource && this.shouldFilterModule(module.resource)) {
+          if (this.options.verbose) {
+            console.log(`📄 Filtering module: ${module.resource}`);
+          }
+          // Mark the module as filtered
+          module._filtered = true;
+        }
+      });
+    });
+
+    // Hook into normal module factory to intercept page imports
+    compiler.hooks.normalModuleFactory.tap(pluginName, (nmf) => {
+      nmf.hooks.beforeResolve.tap(pluginName, (resolveData) => {
+        if (!resolveData) return;
+
+        const request = resolveData.request;
+        const context = resolveData.context;
+
+        if (this.isPageModule(request, context) && this.shouldFilterPage(request)) {
+          if (this.options.verbose) {
+            console.log(`📄 Intercepting page request: ${request}`);
+          }
+          
+          // Replace with empty module
+          resolveData.request = path.resolve(__dirname, 'empty-module.js');
+          this.filteredPages.add(request);
+        }
+
+        return resolveData;
+      });
+    });
+
+    // Log summary after compilation
+    compiler.hooks.done.tap(pluginName, () => {
+      if (this.options.verbose && this.filteredPages.size > 0) {
+        console.log(`📄 Filtered ${this.filteredPages.size} pages:`);
+        this.filteredPages.forEach(page => {
+          console.log(`   - ${page}`);
+        });
+      }
+    });
+  }
+
+  filterEntries(entry) {
+    const keysToRemove = [];
+    
+    for (const [key, value] of Object.entries(entry)) {
+      if (this.isPageEntry(key) && this.shouldFilterPageEntry(key)) {
+        keysToRemove.push(key);
+        if (this.options.verbose) {
+          console.log(`📄 Filtering entry: ${key}`);
+        }
+      }
+    }
+
+    // Remove filtered entries
+    keysToRemove.forEach(key => {
+      delete entry[key];
+      this.filteredPages.add(key);
+    });
+  }
+
+  isPageEntry(entryKey) {
+    // Next.js page entries typically start with 'pages/'
+    return entryKey.startsWith('pages/') || entryKey.startsWith('static/chunks/pages/');
+  }
+
+  isPageModule(request, context) {
+    if (!request || !context) return false;
+
+    // Check if it's in the pages directory
+    const isInPages = request.includes(`/${this.options.pagesDir}/`) || 
+                     context.includes(`/${this.options.pagesDir}/`);
+
+    // Check for page-like file extensions
+    const pageExtensions = ['.js', '.jsx', '.ts', '.tsx'];
+    const hasPageExtension = pageExtensions.some(ext => request.endsWith(ext));
+
+    // Exclude API routes and special Next.js files
+    const isApiRoute = request.includes('/api/');
+    const isSpecialFile = ['_app', '_document', '_error', '404', '500'].some(special => 
+      request.includes(special)
+    );
+
+    return isInPages && hasPageExtension && !isApiRoute && !isSpecialFile;
+  }
+
+  shouldFilterModule(resourcePath) {
+    if (!resourcePath) return false;
+    
+    const normalizedPath = this.normalizePath(resourcePath);
+    
+    // Extract page path from full resource path
+    const pagesIndex = normalizedPath.indexOf(`/${this.options.pagesDir}/`);
+    if (pagesIndex === -1) return false;
+    
+    const pagePath = normalizedPath.substring(pagesIndex + `/${this.options.pagesDir}/`.length);
+    return this.shouldFilterPage(pagePath);
+  }
+
+  shouldFilterPage(pagePath) {
+    const normalizedPath = this.normalizePath(pagePath);
+    
+    // Remove file extension for comparison
+    const pathWithoutExt = normalizedPath.replace(/\.(js|jsx|ts|tsx)$/, '');
+    
+    // If includedPages is specified, only include those
+    if (this.options.includedPages.length > 0) {
+      const isIncluded = this.options.includedPages.some(page => {
+        const normalizedPage = this.normalizePath(page);
+        return pathWithoutExt === normalizedPage || pathWithoutExt.endsWith(`/${normalizedPage}`);
+      });
+      return !isIncluded;
+    }
+    
+    // Check excluded pages
+    if (this.options.excludedPages.length > 0) {
+      const isExcluded = this.options.excludedPages.some(page => {
+        const normalizedPage = this.normalizePath(page);
+        return pathWithoutExt === normalizedPage || pathWithoutExt.endsWith(`/${normalizedPage}`);
+      });
+      if (isExcluded) return true;
+    }
+    
+    // Check exclude patterns
+    if (this.options.excludePatterns.length > 0) {
+      const isPatternExcluded = this.options.excludePatterns.some(pattern => {
+        try {
+          const regex = new RegExp(pattern);
+          return regex.test(pathWithoutExt);
+        } catch (e) {
+          console.warn(`📄 Invalid regex pattern: ${pattern}`);
+          return false;
+        }
+      });
+      if (isPatternExcluded) return true;
+    }
+    
+    return false;
+  }
+
+  shouldFilterPageEntry(entryKey) {
+    // Extract page path from entry key
+    let pagePath = entryKey;
+    
+    if (entryKey.startsWith('pages/')) {
+      pagePath = entryKey.substring(6); // Remove 'pages/' prefix
+    } else if (entryKey.startsWith('static/chunks/pages/')) {
+      pagePath = entryKey.substring(20); // Remove 'static/chunks/pages/' prefix
+    }
+    
+    return this.shouldFilterPage(pagePath);
+  }
+
+  normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/').toLowerCase();
+  }
+}
+
+module.exports = AdvancedNextBuildFilterPlugin;

package/lib/empty-module.js

@@ -0,0 +1,29 @@
+// Empty module to replace filtered pages
+// This module provides a default export that's compatible with both Pages Router and App Router
+
+function EmptyPage() {
+  return null;
+}
+
+// For React components (Pages Router)
+module.exports = EmptyPage;
+module.exports.default = EmptyPage;
+
+// For App Router (ES6 export)
+if (typeof exports !== 'undefined') {
+  exports.default = EmptyPage;
+}
+
+// Generate metadata for App Router if needed
+module.exports.generateMetadata = () => ({
+  title: 'Page Not Available',
+  description: 'This page has been filtered out during build'
+});
+
+// Generate static params for dynamic routes if needed
+module.exports.generateStaticParams = () => [];
+
+// Export all common App Router functions as empty
+module.exports.generateViewport = () => ({});
+module.exports.generateStaticParams = () => [];
+module.exports.revalidate = false;

package/lib/next-build-filter-plugin.js

@@ -0,0 +1,272 @@
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Next.js Build Filter Plugin
+ * 
+ * This plugin allows you to exclude specific pages from the build process
+ * without actually removing the files from your project.
+ */
+class NextBuildFilterPlugin {
+  constructor(options = {}) {
+    this.options = {
+      // Pages to include (if specified, only these pages will be built)
+      includedPages: options.includedPages || [],
+      
+      // Pages to exclude (these pages will be skipped during build)
+      excludedPages: options.excludedPages || [],
+      
+      // Whether to enable filtering (can be controlled by environment variable)
+      enabled: options.enabled !== undefined ? options.enabled : process.env.FILTER_PAGES === 'true',
+      
+      // Pattern matching for page exclusion
+      excludePatterns: options.excludePatterns || [],
+      
+      // Verbose logging
+      verbose: options.verbose || false,
+      
+      // Directory configurations
+      pagesDir: options.pagesDir || 'pages',
+      appDir: options.appDir || 'app',
+      
+      // Router support
+      supportAppRouter: options.supportAppRouter !== false,
+      supportPagesRouter: options.supportPagesRouter !== false
+    };
+  }
+
+  apply(compiler) {
+    if (!this.options.enabled) {
+      if (this.options.verbose) {
+        console.log('📄 NextBuildFilterPlugin: Filtering disabled');
+      }
+      return;
+    }
+
+    const pluginName = 'NextBuildFilterPlugin';
+    
+    // Hook into the compilation process
+    compiler.hooks.beforeCompile.tapAsync(pluginName, (params, callback) => {
+      if (this.options.verbose) {
+        console.log('📄 NextBuildFilterPlugin: Starting page filtering...');
+      }
+      callback();
+    });
+
+    // Filter out pages during the resolve phase
+    compiler.hooks.normalModuleFactory.tap(pluginName, (normalModuleFactory) => {
+      normalModuleFactory.hooks.beforeResolve.tap(pluginName, (resolveData) => {
+        if (!resolveData || !resolveData.request) {
+          return;
+        }
+
+        const request = resolveData.request;
+        
+        // Check if this is a page file
+        if (this.isPageFile(request, resolveData.context)) {
+          const shouldExclude = this.shouldExcludePage(request);
+          
+          if (shouldExclude) {
+            if (this.options.verbose) {
+              console.log(`📄 NextBuildFilterPlugin: Replacing page with empty module: ${request}`);
+            }
+            
+            // Replace with empty module instead of blocking the request
+            resolveData.request = require.resolve('./empty-module.js');
+            return;
+          }
+        }
+        
+        // Don't return resolveData, just let it continue processing
+      });
+    });
+
+    // Additional hook to filter entries
+    compiler.hooks.entryOption.tap(pluginName, (context, entry) => {
+      if (typeof entry === 'object' && !Array.isArray(entry)) {
+        const filteredEntry = {};
+        
+        for (const [key, value] of Object.entries(entry)) {
+          if (!this.shouldExcludeEntryPoint(key)) {
+            filteredEntry[key] = value;
+          } else if (this.options.verbose) {
+            console.log(`📄 NextBuildFilterPlugin: Excluding entry point: ${key}`);
+          }
+        }
+        
+        // Replace the entry object with filtered version
+        Object.keys(entry).forEach(key => delete entry[key]);
+        Object.assign(entry, filteredEntry);
+      }
+    });
+  }
+
+  /**
+   * Check if a request is for a page/route file
+   */
+  isPageFile(request, context) {
+    if (!request) return false;
+    
+    // Check for common page file extensions
+    const pageExtensions = ['.js', '.jsx', '.ts', '.tsx'];
+    const hasPageExtension = pageExtensions.some(ext => request.endsWith(ext));
+    
+    if (!hasPageExtension) return false;
+    
+    // Check if the request is in the pages directory (Pages Router)
+    // Next.js uses 'private-next-pages/' prefix for page imports
+    const isInPages = this.options.supportPagesRouter && (
+      request.includes(`/${this.options.pagesDir}/`) || 
+      request.includes(`private-next-pages/`) ||
+      (context && context.includes(`/${this.options.pagesDir}/`))
+    );
+    
+    // Check if the request is in the app directory (App Router)
+    const isInApp = this.options.supportAppRouter && (
+      request.includes(`/${this.options.appDir}/`) || 
+      (context && context.includes(`/${this.options.appDir}/`))
+    );
+    
+    // For App Router, only filter page.tsx files, not layout.tsx or other special files
+    if (isInApp) {
+      // Don't filter layout.tsx, loading.tsx, error.tsx, etc.
+      const appRouterSpecialFiles = ['layout.tsx', 'layout.ts', 'layout.jsx', 'layout.js',
+                                     'loading.tsx', 'loading.ts', 'loading.jsx', 'loading.js',
+                                     'error.tsx', 'error.ts', 'error.jsx', 'error.js',
+                                     'not-found.tsx', 'not-found.ts', 'not-found.jsx', 'not-found.js',
+                                     'template.tsx', 'template.ts', 'template.jsx', 'template.js'];
+      
+      const isSpecialFile = appRouterSpecialFiles.some(file => request.endsWith(file));
+      if (isSpecialFile) {
+        return false; // Don't filter special App Router files
+      }
+      
+      // Only filter page.tsx files in App Router
+      const isPageFile = request.endsWith('page.tsx') || request.endsWith('page.ts') || 
+                        request.endsWith('page.jsx') || request.endsWith('page.js');
+      return isPageFile;
+    }
+    
+    return isInPages;
+  }
+
+  /**
+   * Determine if a page should be excluded from the build
+   */
+  shouldExcludePage(request) {
+    const normalizedRequest = this.normalizePath(request);
+    
+    // Extract the route path from the request
+    const routePath = this.extractRoutePath(normalizedRequest);
+    if (!routePath) return false;
+    
+    // If includedPages is specified, only include those pages
+    if (this.options.includedPages.length > 0) {
+      const isIncluded = this.options.includedPages.some(page => {
+        const normalizedPage = this.normalizePath(page);
+        return routePath === normalizedPage || routePath.startsWith(normalizedPage + '/');
+      });
+      return !isIncluded;
+    }
+    
+    // Check excluded pages
+    if (this.options.excludedPages.length > 0) {
+      const isExcluded = this.options.excludedPages.some(page => {
+        const normalizedPage = this.normalizePath(page);
+        return routePath === normalizedPage || routePath.startsWith(normalizedPage + '/');
+      });
+      if (isExcluded) return true;
+    }
+    
+    // Check exclude patterns
+    if (this.options.excludePatterns.length > 0) {
+      const isPatternExcluded = this.options.excludePatterns.some(pattern => {
+        try {
+          const regex = new RegExp(pattern);
+          return regex.test(routePath);
+        } catch (e) {
+          console.warn(`📄 Invalid regex pattern: ${pattern}`);
+          return false;
+        }
+      });
+      if (isPatternExcluded) return true;
+    }
+    
+    return false;
+  }
+
+  /**
+   * Extract route path from a request
+   */
+  extractRoutePath(normalizedRequest) {
+    let routePath = null;
+    
+    // Check for App Router path
+    if (this.options.supportAppRouter) {
+      const appIndex = normalizedRequest.indexOf(`/${this.options.appDir}/`);
+      if (appIndex !== -1) {
+        routePath = normalizedRequest.substring(appIndex + `/${this.options.appDir}/`.length);
+      }
+    }
+    
+    // Check for Pages Router path
+    if (!routePath && this.options.supportPagesRouter) {
+      // Check for Next.js internal private-next-pages/ prefix
+      const privateIndex = normalizedRequest.indexOf('private-next-pages/');
+      if (privateIndex !== -1) {
+        routePath = normalizedRequest.substring(privateIndex + 'private-next-pages/'.length);
+      } else {
+        const pagesIndex = normalizedRequest.indexOf(`/${this.options.pagesDir}/`);
+        if (pagesIndex !== -1) {
+          routePath = normalizedRequest.substring(pagesIndex + `/${this.options.pagesDir}/`.length);
+        }
+      }
+    }
+    
+    if (!routePath) return null;
+    
+    // Remove file name and extension for App Router
+    if (this.options.supportAppRouter && normalizedRequest.includes(`/${this.options.appDir}/`)) {
+      // Remove /page.tsx, /page.js, etc.
+      routePath = routePath.replace(/\/page\.(tsx|ts|jsx|js)$/, '');
+      // Remove leading slash if present
+      routePath = routePath.replace(/^\//, '');
+    } else {
+      // For Pages Router, remove extension
+      routePath = routePath.replace(/\.(tsx|ts|jsx|js)$/, '');
+    }
+    
+    // Handle root route
+    if (!routePath || routePath === '') {
+      return 'index';
+    }
+    
+    return routePath;
+  }
+
+  /**
+   * Determine if an entry point should be excluded
+   */
+  shouldExcludeEntryPoint(entryKey) {
+    // Entry keys in Next.js typically follow patterns like:
+    // - pages/index
+    // - pages/about
+    // - pages/api/users
+    
+    if (entryKey.startsWith('pages/')) {
+      const pagePath = entryKey.replace('pages/', '');
+      return this.shouldExcludePage(pagePath);
+    }
+    
+    return false;
+  }
+
+  /**
+   * Normalize file paths for consistent comparison
+   */
+  normalizePath(filePath) {
+    return filePath.replace(/\\/g, '/').toLowerCase();
+  }
+}
+
+module.exports = NextBuildFilterPlugin;

package/lib/with-page-filter.js

@@ -0,0 +1,169 @@
+const path = require('path');
+
+/**
+ * Next.js Page Filter Plugin
+ * 
+ * Enhanced version that supports both Pages Router and App Router (Next.js 13+)
+ */
+function withPageFilter(options = {}) {
+  return (nextConfig = {}) => {
+    const filterOptions = {
+      includedPages: options.includedPages || [],
+      excludedPages: options.excludedPages || [],
+      enabled: options.enabled !== undefined ? options.enabled : process.env.FILTER_PAGES === 'true',
+      excludePatterns: options.excludePatterns || [],
+      verbose: options.verbose || false,
+      pagesDir: options.pagesDir || 'pages',
+      appDir: options.appDir || 'app',
+      supportAppRouter: options.supportAppRouter !== false, // Default to true
+      supportPagesRouter: options.supportPagesRouter !== false, // Default to true
+      ...options
+    };
+
+    if (!filterOptions.enabled) {
+      if (filterOptions.verbose) {
+        console.log('📄 Page filtering disabled');
+      }
+      return nextConfig;
+    }
+
+    return {
+      ...nextConfig,
+      
+      webpack: (config, { buildId, dev, isServer, defaultLoaders, webpack }) => {
+        // Apply the existing webpack config if it exists
+        if (nextConfig.webpack) {
+          config = nextConfig.webpack(config, { buildId, dev, isServer, defaultLoaders, webpack });
+        }
+
+        // Don't apply filtering in development mode unless explicitly enabled
+        if (dev && !filterOptions.enableInDev) {
+          return config;
+        }
+
+        // Add our custom plugin
+        const NextBuildFilterPlugin = require('./next-build-filter-plugin');
+        config.plugins.push(new NextBuildFilterPlugin(filterOptions));
+
+        return config;
+      },
+
+      // Preserve existing experimental settings
+      experimental: {
+        ...nextConfig.experimental
+      }
+    };
+  };
+}
+
+function isPageFile(request, context, options) {
+  if (!request) return false;
+  
+  const pageExtensions = ['.js', '.jsx', '.ts', '.tsx'];
+  const hasPageExtension = pageExtensions.some(ext => request.endsWith(ext));
+  
+  if (!hasPageExtension) return false;
+  
+  // Check for Pages Router
+  const isInPagesDir = options.supportPagesRouter && (
+    request.includes(`/${options.pagesDir}/`) || 
+    (context && context.includes(`/${options.pagesDir}/`))
+  );
+  
+  // Check for App Router
+  const isInAppDir = options.supportAppRouter && (
+    request.includes(`/${options.appDir}/`) || 
+    (context && context.includes(`/${options.appDir}/`))
+  );
+  
+  return isInPagesDir || isInAppDir;
+}
+
+function shouldExcludePage(request, options) {
+  const normalizedRequest = normalizePath(request);
+  
+  // Extract route path from request
+  const routePath = extractRoutePath(normalizedRequest, options);
+  
+  if (!routePath) return false;
+  
+  // If includedPages is specified, only include those pages
+  if (options.includedPages && options.includedPages.length > 0) {
+    const isIncluded = options.includedPages.some(page => {
+      const normalizedPage = normalizePath(page);
+      return routePath === normalizedPage || routePath.includes(normalizedPage);
+    });
+    return !isIncluded;
+  }
+  
+  // Check excluded pages
+  if (options.excludedPages && options.excludedPages.length > 0) {
+    const isExcluded = options.excludedPages.some(page => {
+      const normalizedPage = normalizePath(page);
+      return routePath === normalizedPage || routePath.includes(normalizedPage);
+    });
+    if (isExcluded) return true;
+  }
+  
+  // Check exclude patterns
+  if (options.excludePatterns && options.excludePatterns.length > 0) {
+    const isPatternExcluded = options.excludePatterns.some(pattern => {
+      try {
+        const regex = new RegExp(pattern);
+        return regex.test(routePath);
+      } catch (e) {
+        console.warn(`📄 Invalid regex pattern: ${pattern}`);
+        return false;
+      }
+    });
+    if (isPatternExcluded) return true;
+  }
+  
+  return false;
+}
+
+function extractRoutePath(normalizedRequest, options) {
+  // Extract route path from either /pages/ or /app/ directory
+  let routePath = null;
+  
+  // Check for Pages Router path
+  if (options.supportPagesRouter) {
+    const pagesIndex = normalizedRequest.indexOf(`/${options.pagesDir}/`);
+    if (pagesIndex !== -1) {
+      routePath = normalizedRequest.substring(pagesIndex + `/${options.pagesDir}/`.length);
+    }
+  }
+  
+  // Check for App Router path
+  if (!routePath && options.supportAppRouter) {
+    const appIndex = normalizedRequest.indexOf(`/${options.appDir}/`);
+    if (appIndex !== -1) {
+      routePath = normalizedRequest.substring(appIndex + `/${options.appDir}/`.length);
+    }
+  }
+  
+  if (!routePath) return null;
+  
+  // Remove file extension
+  routePath = routePath.replace(/\.(js|jsx|ts|tsx)$/, '');
+  
+  // Handle special App Router files
+  if (options.supportAppRouter) {
+    // Remove App Router special files (page.tsx, layout.tsx, etc.)
+    routePath = routePath.replace(/\/(page|layout|loading|error|not-found|template|default)$/, '');
+    
+    // Handle route groups - remove (group) patterns
+    routePath = routePath.replace(/\/\([^)]+\)/g, '');
+  }
+  
+  // Clean up empty segments and normalize
+  routePath = routePath.replace(/\/+/g, '/').replace(/^\/|\/$/g, '');
+  
+  return routePath || 'index';
+}
+
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, '/').toLowerCase();
+}
+
+module.exports = withPageFilter;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "next-build-filter",
+  "version": "0.1.0",
+  "description": "A Next.js plugin to exclude pages/routes during build without removing files. Supports both Pages Router and App Router (Next.js 13+).",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "lib/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepublishOnly": "npm run build",
+    "build": "echo \"No build process needed for now\""
+  },
+  "keywords": [
+    "nextjs",
+    "next.js",
+    "webpack",
+    "plugin",
+    "build",
+    "filter",
+    "pages",
+    "app-router",
+    "pages-router",
+    "optimization",
+    "bundle"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "next": ">=12.0.0",
+    "react": ">=17.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/your-username/next-build-filter.git"
+  },
+  "bugs": {
+    "url": "https://github.com/your-username/next-build-filter/issues"
+  },
+  "homepage": "https://github.com/your-username/next-build-filter#readme",
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}