next-build-filter 0.2.2 → 0.2.5

package/lib/empty-module.js

@@ -1,35 +1,47 @@
 /**
  * Empty module to replace filtered pages
- * 
+ *
  * This module provides a custom 404 response with a detectable marker
  * that can be verified in tests and provides clear feedback to users.
- * 
+ *
  * Marker: NEXT_BUILD_FILTER_EXCLUDED_PAGE
  */
 
+// Marker string to identify filtered pages
+const FILTER_MARKER = 'NEXT_BUILD_FILTER_EXCLUDED_PAGE';
+
 // Try to import notFound for App Router (will fail gracefully for Pages Router)
-let notFound;
+let notFoundFn = null;
 try {
-  notFound = require('next/navigation').notFound;
+  notFoundFn = require('next/navigation').notFound;
 } catch (e) {
   // Not in App Router context or Next.js not available
-  notFound = null;
 }
 
-// Marker string to identify filtered pages
-const FILTER_MARKER = 'NEXT_BUILD_FILTER_EXCLUDED_PAGE';
+// Import React at module level for better compatibility
+let React = null;
+try {
+  React = require('react');
+} catch (e) {
+  // React not available
+}
 
-// For Pages Router: Return a component that renders 404
+/**
+ * Filtered page component
+ * Works with both Pages Router and App Router
+ */
 function FilteredPage() {
   // If we're in App Router and notFound is available, use it
-  if (notFound && typeof notFound === 'function') {
-    notFound();
+  if (notFoundFn && typeof notFoundFn === 'function') {
+    notFoundFn();
     return null; // notFound() throws, so this won't be reached
   }
-  
+
   // For Pages Router or fallback: Return a custom 404 component
-  // Using React.createElement to avoid JSX
-  const React = require('react');
+  if (!React) {
+    return null;
+  }
+
   return React.createElement(
     'div',
     {
@@ -42,18 +54,28 @@ function FilteredPage() {
         fontFamily: 'system-ui, -apple-system, sans-serif',
         backgroundColor: '#f5f5f5',
       },
-      'data-filter-marker': FILTER_MARKER
+      'data-filter-marker': FILTER_MARKER,
     },
     [
-      React.createElement('h1', { key: 'title', style: { fontSize: '3rem', margin: '0' } }, '404'),
+      React.createElement(
+        'h1',
+        { key: 'title', style: { fontSize: '3rem', margin: '0' } },
+        '404'
+      ),
       React.createElement(
         'p',
-        { key: 'message', style: { fontSize: '1.2rem', color: '#666', marginTop: '1rem' } },
+        {
+          key: 'message',
+          style: { fontSize: '1.2rem', color: '#666', marginTop: '1rem' },
+        },
         'Page Not Available'
       ),
       React.createElement(
         'p',
-        { key: 'detail', style: { fontSize: '0.9rem', color: '#999', marginTop: '0.5rem' } },
+        {
+          key: 'detail',
+          style: { fontSize: '0.9rem', color: '#999', marginTop: '0.5rem' },
+        },
         'This page has been filtered out during build.'
       ),
       React.createElement(
@@ -80,15 +102,16 @@ module.exports.default = FilteredPage;
 // Export the marker for testing
 module.exports.FILTER_MARKER = FILTER_MARKER;
 
-// Generate metadata for App Router if needed
-module.exports.generateMetadata = () => ({
+// Generate metadata for App Router (async for Next.js best practices)
+module.exports.generateMetadata = async () => ({
   title: 'Page Not Available - 404',
   description: 'This page has been filtered out during build',
 });
 
 // Generate static params for dynamic routes if needed
-module.exports.generateStaticParams = () => [];
+module.exports.generateStaticParams = async () => [];
 
 // Export all common App Router functions
-module.exports.generateViewport = () => ({});
-module.exports.revalidate = false;
+module.exports.generateViewport = async () => ({});
+module.exports.revalidate = false;
+module.exports.dynamic = 'force-static';

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

@@ -1,6 +1,5 @@
-const path = require('path');
-const fs = require('fs');
 const { minimatch } = require('minimatch');
+const path = require('path');
 
 /**
  * Next.js Build Filter Plugin
@@ -35,6 +34,13 @@ class NextBuildFilterPlugin {
       supportAppRouter: options.supportAppRouter !== false,
       supportPagesRouter: options.supportPagesRouter !== false
     };
+    
+    // Resolve the empty module path once and store it
+    // This ensures it resolves correctly regardless of where the plugin is loaded from
+    this.emptyModulePath = path.resolve(__dirname, 'empty-module.js');
+    
+    // Store original Module._resolveFilename if we need to intercept Node.js module resolution
+    this.originalResolveFilename = null;
   }
 
   apply(compiler) {
@@ -47,6 +53,11 @@ class NextBuildFilterPlugin {
 
     const pluginName = 'NextBuildFilterPlugin';
     
+    // Intercept Node.js module resolution to catch Next.js requirePage calls
+    // This is needed because Next.js uses requirePage which bypasses webpack
+    // Note: This is a workaround for Next.js's page collection phase
+    this.setupModuleResolutionInterceptor();
+    
     // Hook into the compilation process
     compiler.hooks.beforeCompile.tapAsync(pluginName, (params, callback) => {
       if (this.options.verbose) {
@@ -57,6 +68,8 @@ class NextBuildFilterPlugin {
 
     // Filter out pages during the resolve phase
     compiler.hooks.normalModuleFactory.tap(pluginName, (normalModuleFactory) => {
+      // Hook into beforeResolve to intercept page module requests
+      // Note: beforeResolve is a bailing hook - modify resolveData in place, don't return it
       normalModuleFactory.hooks.beforeResolve.tap(pluginName, (resolveData) => {
         if (!resolveData || !resolveData.request) {
           return;
@@ -81,33 +94,75 @@ class NextBuildFilterPlugin {
             }
             
             // Replace with empty module instead of blocking the request
-            resolveData.request = require.resolve('./empty-module.js');
-            return;
+            // Use the pre-resolved absolute path to ensure it works in all contexts
+            // Modify in place - don't return the object
+            resolveData.request = this.emptyModulePath;
+            return; // Continue processing with modified resolveData
           }
         }
         
-        // Don't return resolveData, just let it continue processing
+        // Don't return anything - let webpack continue with the original resolveData
       });
-    });
+      
+      // Also hook into afterResolve as a fallback
+      // Note: afterResolve is also a bailing hook
+      normalModuleFactory.hooks.afterResolve.tap(pluginName, (resolveData) => {
+        if (!resolveData || !resolveData.request) {
+          return;
+        }
 
-    // Additional hook to filter entries
-    compiler.hooks.entryOption.tap(pluginName, (context, entry) => {
-      if (typeof entry === 'object' && !Array.isArray(entry)) {
-        const filteredEntry = {};
+        const request = resolveData.request;
+        
+        if (typeof request !== 'string') {
+          return;
+        }
         
-        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}`);
+        // Check if this is a page file that should be excluded
+        if (this.isPageFile(request, resolveData.context)) {
+          const normalizedRequest = this.normalizePath(request);
+          const routePath = this.extractRoutePath(normalizedRequest);
+          const shouldExclude = this.shouldExcludePage(request);
+          
+          if (shouldExclude && request !== this.emptyModulePath) {
+            if (this.options.verbose) {
+              console.log(`📄 Filtering out (afterResolve): ${routePath || request}`);
+            }
+            
+            // Replace with empty module - modify in place
+            resolveData.request = this.emptyModulePath;
+            return; // Continue processing with modified resolveData
           }
         }
         
-        // Replace the entry object with filtered version
-        Object.keys(entry).forEach(key => delete entry[key]);
-        Object.assign(entry, filteredEntry);
-      }
+        // Don't return anything - let webpack continue
+      });
     });
+    
+    // Hook into compilation to intercept module building
+    compiler.hooks.compilation.tap(pluginName, (compilation) => {
+      compilation.hooks.buildModule.tap(pluginName, (module) => {
+        if (module.resource && typeof module.resource === 'string') {
+          if (this.isPageFile(module.resource, module.context)) {
+            const normalizedRequest = this.normalizePath(module.resource);
+            const routePath = this.extractRoutePath(normalizedRequest);
+            const shouldExclude = this.shouldExcludePage(module.resource);
+            
+            if (shouldExclude && module.resource !== this.emptyModulePath) {
+              if (this.options.verbose) {
+                console.log(`📄 Filtering module during build: ${routePath || module.resource}`);
+              }
+              // Mark module as filtered - this prevents it from being processed
+              module._filtered = true;
+            }
+          }
+        }
+      });
+    });
+
+    // NOTE: We intentionally do NOT filter entries here because Next.js still needs
+    // compiled modules to exist for page data collection. Instead, we let all entries
+    // compile but replace their content with empty modules via beforeResolve/afterResolve hooks.
+    // This ensures Next.js can find and load the modules, but they'll be empty stubs.
   }
 
   /**
@@ -251,16 +306,21 @@ class NextBuildFilterPlugin {
       routePath = routePath.replace(/\/?page\.(tsx|ts|jsx|js)$/, '');
       // Remove leading slash if present
       routePath = routePath.replace(/^\//, '');
+      // Handle route groups - remove (group) patterns like (auth), (admin)
+      routePath = routePath.replace(/\/?\([^)]+\)/g, '');
     } else {
       // For Pages Router, remove extension
       routePath = routePath.replace(/\.(tsx|ts|jsx|js)$/, '');
     }
-    
+
+    // Clean up empty segments and normalize
+    routePath = routePath.replace(/\/+/g, '/').replace(/^\/|\/$/g, '');
+
     // Handle root route
     if (!routePath || routePath === '') {
       return 'index';
     }
-    
+
     return routePath;
   }
 
@@ -269,15 +329,19 @@ class NextBuildFilterPlugin {
    */
   shouldExcludeEntryPoint(entryKey) {
     // Entry keys in Next.js typically follow patterns like:
-    // - pages/index
-    // - pages/about
-    // - pages/api/users
-    
-    if (entryKey.startsWith('pages/')) {
+    // Pages Router: pages/index, pages/about, pages/api/users
+    // App Router: app/page, app/about/page, app/admin/users/page
+
+    if (this.options.supportPagesRouter && entryKey.startsWith('pages/')) {
       const pagePath = entryKey.replace('pages/', '');
-      return this.shouldExcludePage(pagePath);
+      return this.shouldExcludePage(`/${this.options.pagesDir}/${pagePath}.js`);
     }
-    
+
+    if (this.options.supportAppRouter && entryKey.startsWith('app/')) {
+      const pagePath = entryKey.replace('app/', '');
+      return this.shouldExcludePage(`/${this.options.appDir}/${pagePath}.js`);
+    }
+
     return false;
   }
 
@@ -290,6 +354,114 @@ class NextBuildFilterPlugin {
     }
     return filePath.replace(/\\/g, '/').toLowerCase();
   }
+  
+  /**
+   * Setup Node.js module resolution interceptor to catch Next.js requirePage calls
+   * This is needed because Next.js uses requirePage which bypasses webpack
+   */
+  setupModuleResolutionInterceptor() {
+    const Module = require('module');
+    
+    // Only intercept if not already intercepted
+    if (this.originalResolveFilename) {
+      return;
+    }
+    
+    // Store the original resolveFilename
+    this.originalResolveFilename = Module._resolveFilename;
+    const self = this;
+    
+    // Intercept module resolution
+    Module._resolveFilename = function(request, parent, isMain, options) {
+      // Check if this request might be for a filtered page before trying to resolve
+      // Next.js requirePage uses paths like "/admin" or paths to page files
+      const normalizedRequest = self.normalizePath(request);
+      let routePath = self.extractRoutePath(normalizedRequest);
+      
+      // If we can't extract route path from request, try to infer it
+      // Next.js might be looking for pages like "/admin" or "/dev/debug"
+      if (!routePath && request && typeof request === 'string') {
+        // Check if request looks like a Next.js page path (starts with / but not /node_modules)
+        if (request.startsWith('/') && !request.startsWith('/node_modules') && !request.includes('node_modules')) {
+          routePath = request.replace(/^\//, '').replace(/\/$/, '');
+          if (!routePath) routePath = 'index';
+        }
+      }
+      
+      // Check if this route should be excluded
+      if (routePath) {
+        // Try multiple path formats that Next.js might use
+        const testPaths = [
+          request,
+          `/${self.options.pagesDir}/${routePath}.js`,
+          `/${self.options.pagesDir}/${routePath}.jsx`,
+          `/${self.options.pagesDir}/${routePath}.ts`,
+          `/${self.options.pagesDir}/${routePath}.tsx`,
+          `/${self.options.appDir}/${routePath}/page.js`,
+          `/${self.options.appDir}/${routePath}/page.jsx`,
+          `/${self.options.appDir}/${routePath}/page.ts`,
+          `/${self.options.appDir}/${routePath}/page.tsx`,
+          routePath,
+          `/${routePath}`,
+        ];
+        
+        const shouldExclude = testPaths.some(testPath => self.shouldExcludePage(testPath));
+        
+        if (shouldExclude) {
+          if (self.options.verbose) {
+            console.log(`📄 Intercepting module resolution for filtered page: ${routePath} (request: ${request})`);
+          }
+          // Return the empty module path instead
+          return self.emptyModulePath;
+        }
+      }
+      
+      // Try to resolve normally
+      try {
+        const resolvedPath = self.originalResolveFilename.call(this, request, parent, isMain, options);
+        
+        // Check if the resolved path is a page file that should be excluded
+        if (resolvedPath && self.isPageFile(resolvedPath, parent ? parent.filename : null)) {
+          const normalizedResolved = self.normalizePath(resolvedPath);
+          const resolvedRoutePath = self.extractRoutePath(normalizedResolved);
+          const shouldExclude = self.shouldExcludePage(resolvedPath);
+          
+          if (shouldExclude) {
+            if (self.options.verbose) {
+              console.log(`📄 Intercepting resolved module for filtered page: ${resolvedRoutePath || resolvedPath}`);
+            }
+            // Return the empty module path instead
+            return self.emptyModulePath;
+          }
+        }
+        
+        return resolvedPath;
+      } catch (e) {
+        // If resolution fails and it's a filtered page, return empty module
+        if (routePath) {
+          const testPaths = [
+            request,
+            `/${self.options.pagesDir}/${routePath}.js`,
+            `/${self.options.appDir}/${routePath}/page.js`,
+            routePath,
+            `/${routePath}`,
+          ];
+          
+          const shouldExclude = testPaths.some(testPath => self.shouldExcludePage(testPath));
+          
+          if (shouldExclude) {
+            if (self.options.verbose) {
+              console.log(`📄 Intercepting failed resolution for filtered page: ${routePath} (request: ${request})`);
+            }
+            return self.emptyModulePath;
+          }
+        }
+        
+        // Re-throw the original error if it's not a filtered page
+        throw e;
+      }
+    };
+  }
 }
 
 module.exports = NextBuildFilterPlugin;

package/lib/with-page-filter.js

@@ -1,25 +1,23 @@
-const path = require('path');
-const { minimatch } = require('minimatch');
-
 /**
  * Next.js Page Filter Plugin
- * 
+ *
  * Enhanced version that supports both Pages Router and App Router (Next.js 13+)
  * Supports glob patterns for includedPages and excludedPages options
  */
 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',
+      // Spread options first, then apply defaults for undefined values
+      ...options,
+      includedPages: options.includedPages ?? [],
+      excludedPages: options.excludedPages ?? [],
+      enabled: 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) {
@@ -32,14 +30,14 @@ function withPageFilter(options = {}) {
     return {
       ...nextConfig,
       
-      webpack: (config, { buildId, dev, isServer, defaultLoaders, webpack }) => {
+      webpack: (config, options) => {
         // Apply the existing webpack config if it exists
         if (nextConfig.webpack) {
-          config = nextConfig.webpack(config, { buildId, dev, isServer, defaultLoaders, webpack });
+          config = nextConfig.webpack(config, options);
         }
 
         // Don't apply filtering in development mode unless explicitly enabled
-        if (dev && !filterOptions.enableInDev) {
+        if (options.dev && !filterOptions.enableInDev) {
           return config;
         }
 
@@ -58,127 +56,4 @@ function withPageFilter(options = {}) {
   };
 }
 
-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);
-      // Try glob matching first
-      if (minimatch(routePath, normalizedPage)) {
-        return true;
-      }
-      // Fallback to exact match or substring match for backward compatibility
-      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);
-      // Try glob matching first
-      if (minimatch(routePath, normalizedPage)) {
-        return true;
-      }
-      // Fallback to exact match or substring match for backward compatibility
-      return routePath === normalizedPage || routePath.includes(normalizedPage);
-    });
-    if (isExcluded) return true;
-  }
-  
-  // Check exclude patterns (regex 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) {
-  if (!filePath || typeof filePath !== 'string') {
-    return '';
-  }
-  return filePath.replace(/\\/g, '/').toLowerCase();
-}
-
 module.exports = withPageFilter;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "next-build-filter",
-  "version": "0.2.2",
+  "version": "0.2.5",
   "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",
@@ -17,7 +17,7 @@
     "test:e2e": "node tests/e2e/run-e2e-tests.js",
     "test:all": "npm run test && npm run test:e2e",
     "prepublishOnly": "npm run build",
-    "postversion": "npm publish",
+    "postversion": "npm run test:all && npm publish && git push --follow-tags",
     "build": "echo \"No build process needed for now\""
   },
   "keywords": [