vite-plugin-smart-prefetch 0.1.0 → 0.3.0

package/dist/index.d.cts

@@ -111,6 +111,8 @@ interface DataSourceMetadata {
     totalRoutes?: number;
 }
 interface RoutePrediction {
+    /** Route pattern variants (for matching dynamic routes like /order/:id) */
+    patterns?: string[];
     /** Routes to prefetch from this source (default/common rules) */
     prefetch: PrefetchTarget[];
     /** Segment-specific prefetch rules */
@@ -131,6 +133,8 @@ interface PrefetchTarget {
     count: number;
     /** Chunk file to prefetch (set by config generator) */
     chunk?: string;
+    /** Production chunk file path (for production builds) */
+    chunk_prod?: string;
     /** Dependency chunks to prefetch (extracted from Vite manifest imports) */
     imports?: string[];
     /** Priority level */
@@ -162,9 +166,13 @@ interface PrefetchConfig {
         maxPrefetch: number;
         accuracy?: number;
     };
+    /** Global route patterns for dynamic route matching */
+    routePatterns?: Record<string, string[]>;
     /** Route predictions with chunk mappings */
     routes: {
         [sourceRoute: string]: {
+            /** Route pattern variants (for matching dynamic routes like /order/:id) */
+            patterns?: string[];
             /** Default/common prefetch rules (works for all users) */
             prefetch: Array<PrefetchTarget & {
                 chunk: string;

package/dist/index.d.ts

@@ -111,6 +111,8 @@ interface DataSourceMetadata {
     totalRoutes?: number;
 }
 interface RoutePrediction {
+    /** Route pattern variants (for matching dynamic routes like /order/:id) */
+    patterns?: string[];
     /** Routes to prefetch from this source (default/common rules) */
     prefetch: PrefetchTarget[];
     /** Segment-specific prefetch rules */
@@ -131,6 +133,8 @@ interface PrefetchTarget {
     count: number;
     /** Chunk file to prefetch (set by config generator) */
     chunk?: string;
+    /** Production chunk file path (for production builds) */
+    chunk_prod?: string;
     /** Dependency chunks to prefetch (extracted from Vite manifest imports) */
     imports?: string[];
     /** Priority level */
@@ -162,9 +166,13 @@ interface PrefetchConfig {
         maxPrefetch: number;
         accuracy?: number;
     };
+    /** Global route patterns for dynamic route matching */
+    routePatterns?: Record<string, string[]>;
     /** Route predictions with chunk mappings */
     routes: {
         [sourceRoute: string]: {
+            /** Route pattern variants (for matching dynamic routes like /order/:id) */
+            patterns?: string[];
             /** Default/common prefetch rules (works for all users) */
             prefetch: Array<PrefetchTarget & {
                 chunk: string;

package/dist/index.js

@@ -645,10 +645,14 @@ var MarkovChainTrainer = class {
 
 // src/plugin/config-generator.ts
 var _ConfigGenerator = class _ConfigGenerator {
-  constructor(manifest, manualRules = {}, debug = false) {
+  constructor(manifest, manualRules = {}, debug = false, vite) {
+    this.vite = null;
+    this.isDev = false;
     this.manifest = manifest;
     this.manualRules = manualRules;
     this.debug = debug;
+    this.vite = vite || null;
+    this.isDev = !!vite;
   }
   /**
    * Generate final prefetch configuration with chunk mappings
@@ -666,6 +670,7 @@ var _ConfigGenerator = class _ConfigGenerator {
       }
     }
     const mergedModel = this.mergeManualRules(model);
+    const routePatterns = this.extractRoutePatterns(Object.keys(mergedModel.routes));
     const config = {
       version: model.version,
       generatedAt: model.generatedAt,
@@ -676,6 +681,8 @@ var _ConfigGenerator = class _ConfigGenerator {
         threshold: model.config.threshold,
         maxPrefetch: model.config.maxPrefetch
       },
+      routePatterns,
+      // NEW: Include route patterns for dynamic matching
       routes: {},
       chunks: {}
     };
@@ -701,6 +708,8 @@ var _ConfigGenerator = class _ConfigGenerator {
           prefetchTargets.push({
             ...target,
             chunk: chunkFile,
+            chunk_prod: chunkFile,
+            // NEW: Include production chunk path
             imports
             // Include dependency chunks (resolved to file paths)
           });
@@ -736,6 +745,8 @@ var _ConfigGenerator = class _ConfigGenerator {
               segmentPrefetchTargets.push({
                 ...target,
                 chunk: chunkFile,
+                chunk_prod: chunkFile,
+                // NEW: Include production chunk path
                 imports
               });
               config.chunks[target.route] = chunkFile;
@@ -750,8 +761,11 @@ var _ConfigGenerator = class _ConfigGenerator {
           console.log(`   \u{1F465} Segment configs for ${sourceRoute}: ${Object.keys(segmentConfigs).join(", ")}`);
         }
       }
+      const patterns = routePatterns[sourceRoute] || [sourceRoute];
       if (prefetchTargets.length > 0 || Object.keys(segmentConfigs).length > 0) {
         config.routes[sourceRoute] = {
+          patterns,
+          // NEW: Include patterns for dynamic route matching
           prefetch: prefetchTargets,
           ...Object.keys(segmentConfigs).length > 0 && {
             segments: segmentConfigs
@@ -931,6 +945,7 @@ var _ConfigGenerator = class _ConfigGenerator {
     ].filter(Boolean);
     for (let i = 0; i < patterns.length; i++) {
       const pattern = patterns[i];
+      if (!pattern) continue;
       const entry = this.manifest[pattern];
       if (entry) {
         return entry.file;
@@ -1067,6 +1082,65 @@ var _ConfigGenerator = class _ConfigGenerator {
       missing
     };
   }
+  /**
+   * Extract route patterns for dynamic route matching
+   * Groups routes by their base path and includes pattern variants
+   * E.g., /purchase-order and /purchase-order/:id become patterns for matching
+   */
+  extractRoutePatterns(routes) {
+    const patterns = {};
+    for (const route of routes) {
+      if (route.includes(":") || route.includes("$")) {
+        patterns[route] = [route];
+        const base = route.split(/[:$]/)[0];
+        if (base && base !== route) {
+          if (!patterns[base]) {
+            patterns[base] = [base, route];
+          } else if (!patterns[base].includes(route)) {
+            patterns[base].push(route);
+          }
+        }
+      } else {
+        patterns[route] = [route];
+      }
+    }
+    if (this.debug && Object.keys(patterns).length > 0) {
+      console.log(`
+\u{1F50D} Extracted route patterns for dynamic matching:`);
+      Object.entries(patterns).forEach(([route, patternList]) => {
+        if (patternList.length > 1) {
+          console.log(`   ${route} \u2192 [${patternList.join(", ")}]`);
+        }
+      });
+    }
+    return patterns;
+  }
+  /**
+   * Match a pathname against route patterns
+   * Supports both static routes and dynamic routes with parameters
+   */
+  matchRoutePattern(pathname, pattern) {
+    const patternRegex = new RegExp(
+      "^" + pattern.replace(/:[^/]+/g, "[^/]+").replace(/\$[^/]+/g, "[^/]+").replace(/\*/g, ".*") + // Match wildcard
+      "$"
+    );
+    return patternRegex.test(pathname);
+  }
+  /**
+   * Find matching route pattern for a given pathname
+   * Used by hooks to match actual navigation paths to config routes
+   */
+  findMatchingPattern(pathname, routes) {
+    for (const [route, config] of Object.entries(routes)) {
+      const patterns = config.patterns || [route];
+      for (const pattern of patterns) {
+        if (this.matchRoutePattern(pathname, pattern)) {
+          return route;
+        }
+      }
+    }
+    return null;
+  }
   /**
    * Generate segment-specific prefetch configurations
    * Creates one config per user segment/role
@@ -1427,7 +1501,7 @@ function smartPrefetch(options = {}) {
                 imports: []
               };
             });
-            const generator = new ConfigGenerator(devManifest, manualRules, debug);
+            const generator = new ConfigGenerator(devManifest, manualRules, debug, server);
             const finalConfig = generator.generate(prefetchModel);
             res.setHeader("Content-Type", "application/json");
             res.setHeader("Access-Control-Allow-Origin", "*");