vite-plugin-smart-prefetch 0.4.0 → 0.4.2

package/dist/index.d.ts

@@ -117,17 +117,11 @@ interface DataSourceMetadata {
 interface RoutePrediction {
     /** Route pattern variants (for matching dynamic routes like /order/:id) */
     patterns?: string[];
-    /** Routes to prefetch from this source (default/common rules) */
+    /** Routes to prefetch from this source */
     prefetch: PrefetchTarget[];
-    /** Segment-specific prefetch rules */
-    segments?: SegmentPrefetchRules;
     /** Additional metadata about this route */
     metadata?: RouteMetadata;
 }
-interface SegmentPrefetchRules {
-    /** Prefetch rules by user segment (free, premium, enterprise, etc.) */
-    [segmentName: string]: PrefetchTarget[];
-}
 interface PrefetchTarget {
     /** Target route to prefetch */
     route: string;
@@ -177,16 +171,10 @@ interface PrefetchConfig {
         [sourceRoute: string]: {
             /** Route pattern variants (for matching dynamic routes like /order/:id) */
             patterns?: string[];
-            /** Default/common prefetch rules (works for all users) */
+            /** Prefetch rules for this route */
             prefetch: Array<PrefetchTarget & {
                 chunk: string;
             }>;
-            /** Segment-specific rules (different per user segment) */
-            segments?: {
-                [segmentName: string]: Array<PrefetchTarget & {
-                    chunk: string;
-                }>;
-            };
             /** Metadata about this route */
             metadata?: RouteMetadata;
         };
@@ -195,11 +183,6 @@ interface PrefetchConfig {
     chunks: {
         [route: string]: string;
     };
-    /** Available segments (for client-side selection) */
-    segmentInfo?: {
-        available: string[];
-        description?: string;
-    };
 }
 interface ViteManifest {
     [key: string]: {

package/dist/index.js

@@ -537,7 +537,7 @@ ${"\u2550".repeat(60)}`);
   }
 };
 
-// src/plugin/model/guessjs-ml-trainer.ts
+// src/plugin/model/prefetch-ml-trainer.ts
 var MarkovChainTrainer = class {
   constructor(config, debug = false) {
     this.config = config;
@@ -717,57 +717,6 @@ var MarkovChainTrainer = class {
       topDestination
     };
   }
-  /**
-   * Train segment-specific Markov models from navigation data with segment field
-   * Creates separate models for each user segment/role
-   */
-  trainSegmentedModels(navigationDataWithSegments, environment) {
-    if (this.debug) {
-      console.log(`
-\u{1F916} Training Segment-Specific Markov Models...`);
-    }
-    const dataBySegment = /* @__PURE__ */ new Map();
-    navigationDataWithSegments.forEach((data) => {
-      const segment = data.segment || "default";
-      if (!dataBySegment.has(segment)) {
-        dataBySegment.set(segment, []);
-      }
-      dataBySegment.get(segment).push({
-        from: data.from,
-        to: data.to,
-        count: data.count
-      });
-    });
-    if (this.debug) {
-      console.log(`
-   \u{1F4CA} Detected segments:`);
-      dataBySegment.forEach((data, segment) => {
-        console.log(`   \u2022 ${segment}: ${data.length} transitions`);
-      });
-    }
-    const segmentModels = /* @__PURE__ */ new Map();
-    dataBySegment.forEach((navigationData, segment) => {
-      if (this.debug) {
-        console.log(`
-   \u{1F504} Training model for segment: "${segment}"`);
-      }
-      const model = this.trainMLModel(navigationData, environment);
-      model.dataSource.provider = `markov-chain[${segment}]`;
-      segmentModels.set(segment, model);
-      if (this.debug) {
-        const totalTargets = Object.values(model.routes).reduce(
-          (sum, route) => sum + (route.prefetch?.length || 0),
-          0
-        );
-        console.log(`   \u2705 Model for "${segment}" trained with ${totalTargets} prefetch targets`);
-      }
-    });
-    if (this.debug) {
-      console.log(`
-   \u2705 All ${segmentModels.size} segment models trained successfully`);
-    }
-    return segmentModels;
-  }
   /**
    * Get date range string
    */
@@ -800,7 +749,6 @@ var ConfigGenerator = class {
   }
   /**
    * Generate final prefetch configuration with chunk mappings
-   * Includes common prefetch rules and segment-specific rules if available
    */
   generate(model) {
     if (this.debug) {
@@ -809,9 +757,6 @@ var ConfigGenerator = class {
       console.log(`   Manifest entries: ${Object.keys(this.manifest).length}`);
       console.log(`   Model routes: ${Object.keys(model.routes).length}`);
       console.log(`   Manual rules: ${Object.keys(this.manualRules).length}`);
-      if (Object.values(model.routes).some((r) => r.segments)) {
-        console.log(`   \u2139\uFE0F  Segment-based rules detected`);
-      }
     }
     const mergedModel = this.mergeManualRules(model);
     const routePatterns = this.extractRoutePatterns(Object.keys(mergedModel.routes));
@@ -832,10 +777,8 @@ var ConfigGenerator = class {
     };
     let mappedRoutes = 0;
     let unmappedRoutes = 0;
-    let totalSegmentRules = 0;
     Object.entries(mergedModel.routes).forEach(([sourceRoute, prediction]) => {
       const prefetchTargets = [];
-      const segmentConfigs = {};
       const sourceChunk = this.routeToChunk(sourceRoute);
       if (sourceChunk && !config.chunks[sourceRoute]) {
         config.chunks[sourceRoute] = sourceChunk;
@@ -874,46 +817,12 @@ var ConfigGenerator = class {
           unmappedRoutes++;
         }
       });
-      if (prediction.segments) {
-        Object.entries(prediction.segments).forEach(([segment, segmentTargets]) => {
-          const segmentPrefetchTargets = [];
-          segmentTargets.forEach((target) => {
-            const chunkFile = this.routeToChunk(target.route);
-            if (chunkFile) {
-              const manifestEntry = this.getManifestEntryByFile(chunkFile);
-              const importChunkIds = manifestEntry?.imports || [];
-              const imports = importChunkIds.map((chunkId) => {
-                const entry = this.manifest[chunkId];
-                return entry?.file;
-              }).filter((file) => !!file);
-              segmentPrefetchTargets.push({
-                ...target,
-                chunk: chunkFile,
-                chunk_prod: chunkFile,
-                // NEW: Include production chunk path
-                imports
-              });
-              config.chunks[target.route] = chunkFile;
-              totalSegmentRules++;
-            }
-          });
-          if (segmentPrefetchTargets.length > 0) {
-            segmentConfigs[segment] = segmentPrefetchTargets;
-          }
-        });
-        if (this.debug && Object.keys(segmentConfigs).length > 0) {
-          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) {
+      if (prefetchTargets.length > 0) {
         config.routes[sourceRoute] = {
           patterns,
-          // NEW: Include patterns for dynamic route matching
+          // Include patterns for dynamic route matching
           prefetch: prefetchTargets,
-          ...Object.keys(segmentConfigs).length > 0 && {
-            segments: segmentConfigs
-          },
           metadata: prediction.metadata
         };
       }
@@ -922,21 +831,8 @@ var ConfigGenerator = class {
       console.log(`\u2705 Configuration generated`);
       console.log(`   Routes with prefetch: ${Object.keys(config.routes).length}`);
       console.log(`   Mapped chunks: ${mappedRoutes}`);
-      console.log(`   Segment-specific rules: ${totalSegmentRules}`);
       console.log(`   Unmapped routes: ${unmappedRoutes}`);
     }
-    const allSegments = /* @__PURE__ */ new Set();
-    Object.values(config.routes).forEach((route) => {
-      if (route.segments) {
-        Object.keys(route.segments).forEach((seg) => allSegments.add(seg));
-      }
-    });
-    if (allSegments.size > 0) {
-      config.segmentInfo = {
-        available: Array.from(allSegments),
-        description: "Load segment-specific config based on user role/segment"
-      };
-    }
     return config;
   }
   /**
@@ -1130,32 +1026,6 @@ var ConfigGenerator = class {
     }
     return null;
   }
-  /**
-   * Generate segment-specific prefetch configurations
-   * Creates one config per user segment/role
-   */
-  generateSegmentConfigs(segmentModels) {
-    const segmentConfigs = /* @__PURE__ */ new Map();
-    segmentModels.forEach((model, segment) => {
-      if (this.debug) {
-        console.log(`
-\u{1F4E6} Generating config for segment: "${segment}"`);
-      }
-      const config = this.generate(model);
-      config.segment = segment;
-      segmentConfigs.set(segment, config);
-      if (this.debug) {
-        console.log(`   \u2705 Config generated for "${segment}"`);
-        console.log(`      Routes: ${Object.keys(config.routes).length}`);
-        console.log(`      Chunks: ${Object.keys(config.chunks).length}`);
-      }
-    });
-    if (this.debug) {
-      console.log(`
-\u2705 Generated ${segmentConfigs.size} segment-specific configurations`);
-    }
-    return segmentConfigs;
-  }
 };
 
 // src/plugin/cache-manager.ts
@@ -1331,7 +1201,6 @@ function smartPrefetch(options = {}) {
   let config;
   let cacheManager;
   let prefetchModel = null;
-  let segmentModels = null;
   return {
     name: "@farmart/vite-plugin-smart-prefetch",
     enforce: "post",
@@ -1412,9 +1281,6 @@ function smartPrefetch(options = {}) {
             res.setHeader("Access-Control-Allow-Origin", "*");
             res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
             res.end(JSON.stringify(finalConfig, null, 2));
-            if (debug) {
-              console.log("\u{1F4E4} Serving fresh prefetch-config.json from development server");
-            }
             return;
           } catch (error) {
             if (debug) {
@@ -1452,37 +1318,30 @@ function smartPrefetch(options = {}) {
           debug,
           analytics.credentials.keyFilePath
         );
-        console.log("\n\u{1F3AF} Using real navigation data from BigQuery GA4 export...");
+        if (debug) {
+          console.log("\n\u{1F3AF} Using real navigation data from BigQuery GA4 export...");
+        }
         const navigationData = await bqConnector.fetchNavigationSequences(analytics.dataRange);
         if (navigationData.length === 0) {
           console.warn("\u26A0\uFE0F  No navigation data found, using manual rules only");
           prefetchModel = createManualModel(manualRules, environment);
           return;
         }
-        console.log(`
+        if (debug) {
+          console.log(`
 \u{1F916} Training model using Markov Chain ML...`);
+        }
         const mlTrainer = new MarkovChainTrainer(analytics.model, debug);
         const prefetchModelResult = mlTrainer.trainMLModel(navigationData, environment);
         prefetchModel = prefetchModelResult;
         await cacheManager.set(environment, prefetchModel);
-        try {
-          const navigationWithSegments = await bqConnector.fetchNavigationWithSegments(analytics.dataRange);
-          if (navigationWithSegments.length > 0) {
-            console.log(`
-\u{1F465} Training segment-specific models...`);
-            segmentModels = mlTrainer.trainSegmentedModels(navigationWithSegments, environment);
-            if (debug && segmentModels.size > 0) {
-              console.log(`   \u2705 Trained ${segmentModels.size} segment-specific models`);
-            }
-          }
-        } catch (error) {
-          if (debug) {
-            console.warn(`\u26A0\uFE0F  Could not train segment models:`, error instanceof Error ? error.message : "Unknown error");
-          }
-        }
       } catch (error) {
-        console.error("\u274C Failed to fetch analytics data:", error);
-        console.log("\u26A0\uFE0F  Falling back to manual rules only");
+        if (debug) {
+          console.error("\u274C Failed to fetch analytics data:", error);
+        }
+        if (debug) {
+          console.log("\u26A0\uFE0F  Falling back to manual rules only");
+        }
         prefetchModel = createManualModel(manualRules, environment);
         if (debug) {
           console.error("Error details:", error);
@@ -1491,7 +1350,9 @@ function smartPrefetch(options = {}) {
     },
     async writeBundle(outputOptions) {
       if (!prefetchModel) {
-        console.warn("\u26A0\uFE0F  No prefetch model available, skipping config generation");
+        if (debug) {
+          console.warn("\u26A0\uFE0F  No prefetch model available, skipping config generation");
+        }
         return;
       }
       const fs2 = await import("fs");
@@ -1499,7 +1360,9 @@ function smartPrefetch(options = {}) {
       const outDir = outputOptions.dir || "dist";
       const manifestPath = path2.join(outDir, ".vite", "manifest.json");
       if (!fs2.existsSync(manifestPath)) {
-        console.warn("\u26A0\uFE0F  Vite manifest not found at:", manifestPath);
+        if (debug) {
+          console.warn("\u26A0\uFE0F  Vite manifest not found at:", manifestPath);
+        }
         return;
       }
       const manifestContent = fs2.readFileSync(manifestPath, "utf-8");
@@ -1511,10 +1374,10 @@ function smartPrefetch(options = {}) {
       const generator = new ConfigGenerator(manifest, manualRules, debug);
       const finalConfig = generator.generate(prefetchModel);
       const validation = generator.validateChunks(finalConfig);
-      if (!validation.valid) {
+      if (!validation.valid && debug) {
         console.warn("\u26A0\uFE0F  Some chunks could not be mapped:");
         validation.missing.forEach((m) => console.warn(`   ${m}`));
-      } else {
+      } else if (debug) {
         console.log(`\u2705 All ${Object.keys(finalConfig.chunks).length} chunks successfully mapped with real build hashes`);
       }
       const configPath = path2.join(outDir, "prefetch-config.json");
@@ -1527,37 +1390,6 @@ function smartPrefetch(options = {}) {
         console.log(`\u{1F4CA} Total routes configured: ${Object.keys(finalConfig.routes).length}`);
         console.log(`\u{1F4E6} Total chunks: ${Object.keys(finalConfig.chunks).length}`);
       }
-      if (segmentModels && segmentModels.size > 0) {
-        console.log(`
-\u{1F4C1} Generating segment-specific prefetch configurations...`);
-        const segmentGenerator = new ConfigGenerator(manifest, manualRules, debug);
-        const segmentConfigs = segmentGenerator.generateSegmentConfigs(segmentModels);
-        const segmentDir = path2.join(outDir, "prefetch-configs");
-        if (!fs2.existsSync(segmentDir)) {
-          fs2.mkdirSync(segmentDir, { recursive: true });
-        }
-        segmentConfigs.forEach((segConfig, segment) => {
-          const segmentPath = path2.join(segmentDir, `${segment}.json`);
-          fs2.writeFileSync(segmentPath, JSON.stringify(segConfig, null, 2));
-          if (debug) {
-            console.log(`   \u2705 Emitted ${segment}.json (${Object.keys(segConfig.routes).length} routes)`);
-          }
-        });
-        const segmentIndex = {
-          generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-          environment: analytics?.environment || (config.command === "serve" ? "development" : "production"),
-          segments: Array.from(segmentConfigs.keys()),
-          description: "Segment-specific prefetch configurations. Use based on user role/segment."
-        };
-        const segmentIndexPath = path2.join(segmentDir, "index.json");
-        fs2.writeFileSync(segmentIndexPath, JSON.stringify(segmentIndex, null, 2));
-        if (debug) {
-          console.log(`
-\u2705 Emitted ${segmentConfigs.size} segment-specific configurations`);
-          console.log(`   Location: ${segmentDir}`);
-          console.log(`   Segments: ${Array.from(segmentConfigs.keys()).join(", ")}`);
-        }
-      }
       if (analytics?.dashboard) {
         const dashboardHtml = generateDashboard(finalConfig);
         const dashboardPath = path2.join(outDir, "prefetch-report.html");