vite-plugin-smart-prefetch 0.3.6 → 0.3.8

package/dist/index.js

@@ -126,6 +126,7 @@ ${"\u2550".repeat(60)}`);
       let filteredCount = 0;
       let emptyPathCount = 0;
       let lowCountCount = 0;
+      let selfTransitionCount = 0;
       const rawData = rows.map((row) => ({
         previous_page_path: row.previous_page_path,
         page_path: row.page_path,
@@ -149,7 +150,7 @@ ${"\u2550".repeat(60)}`);
         if (this.debug && index < 5) {
           console.log(`     Normalized: "${normalizedPrevious}" \u2192 "${normalizedCurrent}"`);
         }
-        if (normalizedCurrent && transitionCount >= minSessions) {
+        if (normalizedCurrent && transitionCount >= minSessions && normalizedPrevious !== normalizedCurrent) {
           navigationData.push({
             from: normalizedPrevious,
             to: normalizedCurrent,
@@ -171,6 +172,11 @@ ${"\u2550".repeat(60)}`);
             if (this.debug && index < 5) {
               console.log(`     \u274C FILTERED: transition count ${transitionCount} < minSessions ${minSessions}`);
             }
+          } else if (normalizedPrevious === normalizedCurrent) {
+            selfTransitionCount++;
+            if (this.debug && index < 5) {
+              console.log(`     \u274C FILTERED: self-to-self transition (user stayed on same page)`);
+            }
           }
         }
       });
@@ -181,6 +187,7 @@ ${"\u2550".repeat(60)}`);
       console.log(`   \u274C Filtered out: ${filteredCount}`);
       console.log(`      \u2022 Empty paths: ${emptyPathCount}`);
       console.log(`      \u2022 Low transition count: ${lowCountCount}`);
+      console.log(`      \u2022 Self-to-self transitions: ${selfTransitionCount}`);
       this.saveDataForInspection(rawData, navigationData);
       console.log(`
 ${"\u2550".repeat(60)}`);
@@ -428,6 +435,7 @@ ${"\u2550".repeat(60)}`);
       const navigationData = [];
       let processedCount = 0;
       let filteredCount = 0;
+      let selfTransitionCount = 0;
       const segmentCounts = /* @__PURE__ */ new Map();
       console.log(`
    ${"\u2500".repeat(56)}`);
@@ -448,7 +456,7 @@ ${"\u2550".repeat(60)}`);
         if (this.debug && index < 3) {
           console.log(`     Normalized: "${normalizedPrevious}" \u2192 "${normalizedCurrent}" | segment: "${segment}"`);
         }
-        if (normalizedCurrent && transitionCount >= 1) {
+        if (normalizedCurrent && transitionCount >= 1 && normalizedPrevious !== normalizedCurrent) {
           navigationData.push({
             from: normalizedPrevious,
             to: normalizedCurrent,
@@ -462,6 +470,9 @@ ${"\u2550".repeat(60)}`);
           }
         } else {
           filteredCount++;
+          if (normalizedPrevious === normalizedCurrent) {
+            selfTransitionCount++;
+          }
           if (this.debug && index < 3) {
             console.log(`     \u274C FILTERED`);
           }
@@ -472,6 +483,7 @@ ${"\u2550".repeat(60)}`);
       console.log(`   Processing Summary:`);
       console.log(`   \u2705 Accepted: ${processedCount}`);
       console.log(`   \u274C Filtered out: ${filteredCount}`);
+      console.log(`      \u2022 Self-to-self transitions: ${selfTransitionCount}`);
       console.log(`
 ${"\u2550".repeat(60)}`);
       console.log(`\u{1F4CA} STAGE 4: FINAL RESULTS (SEGMENTED)`);
@@ -763,7 +775,15 @@ var MarkovChainTrainer = class {
 };
 
 // src/plugin/config-generator.ts
-var _ConfigGenerator = class _ConfigGenerator {
+var ConfigGenerator = class {
+  /**
+   * NOTE: Hardcoded route/component mappings have been REMOVED to make the plugin generic.
+   * The plugin now uses dynamic strategies (direct match, pattern match, fuzzy match)
+   * to discover routes from the Vite manifest and actual file structure.
+   *
+   * This allows the plugin to work with ANY project structure without project-specific
+   * configuration hardcoded in the plugin code.
+   */
   constructor(manifest, manualRules = {}, debug = false, vite) {
     this.vite = null;
     this.isDev = false;
@@ -952,224 +972,69 @@ var _ConfigGenerator = class _ConfigGenerator {
     return merged;
   }
   /**
-   * NEW STRATEGY 0: Route to Chunk Name Mapping
-   * Maps route → component name → chunk name → manifest file
-   * This is the most reliable method as it uses the actual vite.config.ts chunking strategy
-   */
-  routeToChunkViaName(route) {
-    const normalizedRoute = route.toLowerCase();
-    const componentName = _ConfigGenerator.ROUTE_TO_COMPONENT_NAME[normalizedRoute];
-    if (!componentName) {
-      if (this.debug) {
-        console.log(`      \u274C Route ${route} not in ROUTE_TO_COMPONENT_NAME mapping`);
-      }
-      return null;
-    }
-    const chunkName = _ConfigGenerator.COMPONENT_TO_CHUNK_NAME[componentName];
-    if (!chunkName) {
-      if (this.debug) {
-        console.log(`      \u274C Component ${componentName} not in COMPONENT_TO_CHUNK_NAME mapping`);
-      }
-      return null;
-    }
-    const chunkEntry = Object.entries(this.manifest).find(
-      ([key, entry]) => entry.name === chunkName || key.includes(chunkName)
-    );
-    if (!chunkEntry) {
-      if (this.debug) {
-        console.log(`      \u274C Chunk name ${chunkName} not found in manifest`);
-      }
-      return null;
-    }
-    const chunkFile = chunkEntry[1].file;
-    if (this.debug) {
-      console.log(
-        `      \u2705 Via-Name Strategy: ${route} \u2192 ${componentName} \u2192 ${chunkName} \u2192 ${chunkFile}`
-      );
-    }
-    return chunkFile;
-  }
-  /**
-   * Map route to chunk file using Vite manifest
-   * Tries multiple strategies to find the correct chunk
+   * Map BigQuery route to Vite manifest chunk file
+   *
+   * The routes come from BigQuery navigation data (e.g., /purchase-order, /dispatch-order/:id)
+   * We match them directly to manifest entries without trying to discover routes.
+   *
+   * Strategy: Match route segments against manifest file paths, ignoring hash suffixes
+   * Example:
+   *   Route: /purchase-order/:id
+   *   Normalized: /purchase-order
+   *   Manifest: src/pages/purchase-order/index.tsx → {file: assets/purchase-order-abc123.js}
+   *   Match: YES → return assets/purchase-order-abc123.js
    */
   routeToChunk(route) {
-    const viaName = this.routeToChunkViaName(route);
-    if (viaName) {
-      return viaName;
-    }
-    const directMatch = this.findDirectMatch(route);
-    if (directMatch) {
-      return directMatch;
-    }
-    const patternMatch = this.findPatternMatch(route);
-    if (patternMatch) {
-      return patternMatch;
-    }
-    const fuzzyMatch = this.findFuzzyMatch(route);
-    if (fuzzyMatch) {
-      return fuzzyMatch;
-    }
-    return null;
-  }
-  /**
-   * Strategy 1: Direct path match
-   */
-  findDirectMatch(route) {
     const normalizedRoute = route.replace(/\/[:$]\w+/g, "");
-    const cleanRoutePath = normalizedRoute.replace(/^\//, "");
     const routeSegments = normalizedRoute.split("/").filter(Boolean);
-    const pascalCaseComponent = routeSegments.map((segment) => {
-      const words = segment.split("-");
-      return words.map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-    }).join("/");
-    let singleSegmentPascal = null;
-    if (routeSegments.length === 1) {
-      const segment = routeSegments[0];
-      const words = segment.split("-");
-      singleSegmentPascal = words.map((w) => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
-    }
-    const patterns = [
-      // HIGHEST PRIORITY: Exact page component name matches
-      singleSegmentPascal ? `src/pages/${singleSegmentPascal}.tsx` : null,
-      singleSegmentPascal ? `src/pages/${singleSegmentPascal}.ts` : null,
-      singleSegmentPascal ? `src/pages/${singleSegmentPascal}.jsx` : null,
-      singleSegmentPascal ? `src/pages/${singleSegmentPascal}.js` : null,
-      // For multi-segment routes with hyphens
-      `src/pages/${pascalCaseComponent}.tsx`,
-      `src/pages/${pascalCaseComponent}.ts`,
-      `src/pages/${pascalCaseComponent}.jsx`,
-      `src/pages/${pascalCaseComponent}.js`,
-      // Features folder
-      `src/features${normalizedRoute}/index.ts`,
-      `src/features${normalizedRoute}/index.tsx`,
-      `src/features${normalizedRoute}/index.js`,
-      `src/features${normalizedRoute}/index.jsx`,
-      // Pages folder - try both directory and file formats
-      `src/pages${normalizedRoute}/index.tsx`,
-      `src/pages${normalizedRoute}/index.ts`,
-      `src/pages${normalizedRoute}/index.jsx`,
-      `src/pages${normalizedRoute}/index.js`,
-      `src/pages${normalizedRoute}.tsx`,
-      `src/pages${normalizedRoute}.ts`,
-      `src/pages${normalizedRoute}.jsx`,
-      `src/pages${normalizedRoute}.js`,
-      // Fallback to old capitalize method (single capital letter)
-      `src/pages/${this.capitalize(cleanRoutePath)}.tsx`,
-      `src/pages/${this.capitalize(cleanRoutePath)}.ts`,
-      // Full paths with app prefix
-      `apps/farmart-pro/src/features${normalizedRoute}/index.ts`,
-      `apps/farmart-pro/src/features${normalizedRoute}/index.tsx`,
-      `apps/farmart-pro/src/pages${normalizedRoute}/index.tsx`
-    ].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;
-      }
-    }
-    return null;
-  }
-  /**
-   * Capitalize first letter of string
-   */
-  capitalize(str) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-  /**
-   * Strategy 2: Pattern matching with wildcards
-   */
-  findPatternMatch(route) {
-    const routeSegments = route.split("/").filter(Boolean);
-    if (routeSegments.length === 0) return null;
-    const candidates = Object.entries(this.manifest).filter(([path2]) => {
-      const pathSegments = path2.split("/").filter(Boolean);
-      return routeSegments.every(
-        (segment) => pathSegments.some(
-          (ps) => ps.toLowerCase().includes(segment.replace(/[:$]\w+/, "").toLowerCase())
-        )
+    if (routeSegments.length === 0) {
+      const candidates2 = Object.entries(this.manifest).filter(
+        ([path2]) => path2 === "src/pages/index.tsx" || path2 === "src/app.tsx" || path2 === "src/App.tsx" || path2 === "src/main.tsx"
       );
-    }).sort(([pathA], [pathB]) => {
-      if (pathA.includes("/pages/") && !pathB.includes("/pages/")) return -1;
-      if (!pathA.includes("/pages/") && pathB.includes("/pages/")) return 1;
-      const aIsEntry = pathA.includes("index.tsx") || pathA.includes("index.ts");
-      const bIsEntry = pathB.includes("index.tsx") || pathB.includes("index.ts");
-      if (aIsEntry && !bIsEntry) return -1;
-      if (!aIsEntry && bIsEntry) return 1;
-      if (pathA.includes(".tsx") && !pathB.includes(".tsx")) return -1;
-      if (!pathA.includes(".tsx") && pathB.includes(".tsx")) return 1;
-      return 0;
-    });
-    if (candidates.length > 0) {
-      if (this.debug) {
-        console.log(`      \u2705 Pattern match found: ${candidates[0][0]} \u2192 ${candidates[0][1].file}`);
-      }
-      return candidates[0][1].file;
-    }
-    if (this.debug) {
-      console.log(`      No pattern match found`);
-    }
-    return null;
-  }
-  /**
-   * Strategy 3: Fuzzy matching
-   * Converts route to camelCase/PascalCase and searches
-   */
-  findFuzzyMatch(route) {
-    const cleanRoute = route.replace(/\/[:$]\w+/g, "");
-    const routeSegments = cleanRoute.split("/").filter(Boolean);
-    const pascalCase = routeSegments.map((segment) => {
-      const words = segment.split("-");
-      return words.map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-    }).join("");
-    const camelCase = pascalCase.charAt(0).toLowerCase() + pascalCase.slice(1);
-    if (this.debug) {
-      console.log(`      Fuzzy match - Route: ${route}`);
-      console.log(`      Trying PascalCase: ${pascalCase}, camelCase: ${camelCase}`);
+      if (candidates2.length > 0) return candidates2[0][1].file;
+      return null;
     }
-    const candidates = Object.entries(this.manifest).filter(([path2, entry]) => {
-      if (path2.startsWith("_") || path2.startsWith("node_modules")) {
+    const candidates = Object.entries(this.manifest).filter(([path2]) => {
+      if (path2.startsWith("node_modules") || path2.startsWith("_")) {
         return false;
       }
-      const fileName = path2.split("/").pop() || "";
-      const fileNameWithoutExt = fileName.replace(/\.[^.]+$/, "");
-      if (fileNameWithoutExt === pascalCase || fileNameWithoutExt === camelCase) {
-        return true;
-      }
-      if (fileName.includes(pascalCase) || fileName.includes(camelCase)) {
-        return true;
-      }
-      const pathSegments = path2.toLowerCase().split("/");
-      const lowerPascal = pascalCase.toLowerCase();
-      const lowerCamel = camelCase.toLowerCase();
-      return pathSegments.some(
-        (seg) => seg.includes(lowerPascal) || seg.includes(lowerCamel)
+      const pathLower = path2.toLowerCase();
+      return routeSegments.every(
+        (segment) => pathLower.includes(segment.toLowerCase())
       );
-    }).sort(([pathA, entryA], [pathB, entryB]) => {
-      const aHasSrc = entryA.src ? 1 : 0;
-      const bHasSrc = entryB.src ? 1 : 0;
-      if (aHasSrc !== bHasSrc) return bHasSrc - aHasSrc;
-      const fileA = pathA.split("/").pop()?.replace(/\.[^.]+$/, "") || "";
-      const fileB = pathB.split("/").pop()?.replace(/\.[^.]+$/, "") || "";
-      if (fileA === pascalCase) return -1;
-      if (fileB === pascalCase) return 1;
-      if (fileA === camelCase) return -1;
-      if (fileB === camelCase) return 1;
-      if (pathA.includes("/pages/") && !pathB.includes("/pages/")) return -1;
-      if (!pathA.includes("/pages/") && pathB.includes("/pages/")) return 1;
-      return 0;
+    }).sort(([pathA], [pathB]) => {
+      let scoreA = 0;
+      let scoreB = 0;
+      if (pathA.includes("/pages/")) scoreA += 10;
+      if (pathB.includes("/pages/")) scoreB += 10;
+      if (pathA.includes("index.tsx")) scoreA += 8;
+      if (pathB.includes("index.tsx")) scoreB += 8;
+      if (pathA.includes("index.ts")) scoreA += 7;
+      if (pathB.includes("index.ts")) scoreB += 7;
+      const pathASegments = pathA.split("/").map((s) => s.toLowerCase()).filter((s) => s && !s.startsWith("."));
+      const pathBSegments = pathB.split("/").map((s) => s.toLowerCase()).filter((s) => s && !s.startsWith("."));
+      const matchCountA = routeSegments.filter(
+        (seg) => pathASegments.some((ps) => ps.includes(seg.toLowerCase()))
+      ).length;
+      const matchCountB = routeSegments.filter(
+        (seg) => pathBSegments.some((ps) => ps.includes(seg.toLowerCase()))
+      ).length;
+      scoreA += matchCountA * 5;
+      scoreB += matchCountB * 5;
+      return scoreB - scoreA;
     });
     if (candidates.length > 0) {
-      const result = candidates[0][1].file;
+      const manifestEntry = candidates[0][1];
       if (this.debug) {
-        console.log(`      \u2705 Fuzzy match found: ${candidates[0][0]} \u2192 ${result}`);
+        console.log(`      \u2705 Found chunk for route ${route}`);
+        console.log(`         Manifest: ${candidates[0][0]}`);
+        console.log(`         Chunk file: ${manifestEntry.file}`);
       }
-      return result;
+      return manifestEntry.file;
     }
     if (this.debug) {
-      console.log(`      No fuzzy match found`);
+      console.log(`      \u26A0\uFE0F  No chunk found for route: ${route}`);
+      console.log(`         Searched for segments: ${routeSegments.join(", ")}`);
     }
     return null;
   }
@@ -1287,90 +1152,6 @@ var _ConfigGenerator = class _ConfigGenerator {
     return segmentConfigs;
   }
 };
-/**
- * Maps routes to their component names based on vite.config.ts chunk strategy
- * This is derived from the route configuration in src/routes/index.ts
- * Note: These are the core routes from vite.config.ts chunking strategy
- * Routes not listed here will fall through to fuzzy matching
- */
-_ConfigGenerator.ROUTE_TO_COMPONENT_NAME = {
-  "/": "Home",
-  "/home": "Home",
-  "/dashboard": "Dashboard",
-  "/profile": "Profile",
-  "/settings": "Settings",
-  "/preferences": "Preferences",
-  "/privacy": "Privacy",
-  "/security": "Security",
-  "/analytics": "Analytics",
-  "/reports": "Reports",
-  "/metrics": "Metrics",
-  "/projects": "Projects",
-  "/tasks": "Tasks",
-  "/teams": "Teams",
-  "/workspaces": "Workspaces",
-  "/workflows": "Workflows",
-  "/templates": "Templates",
-  "/logs": "Logs",
-  "/audit-logs": "AuditLogs",
-  "/integrations": "Integrations",
-  "/api-docs": "ApiDocs",
-  "/api-documentation": "ApiDocs",
-  // Alias for space-separated variant
-  "/support": "Support",
-  "/help": "Help",
-  "/billing": "Billing",
-  "/plans": "Plans",
-  "/usage": "Usage",
-  "/permissions": "Permissions",
-  "/notifications": "Notifications"
-};
-/**
- * Maps component names to chunk names based on vite.config.ts manualChunks strategy
- * Each component is assigned to a specific chunk group for code splitting
- *
- * Note: Core components (Home, Dashboard) are not in manual chunks - they're part of main bundle
- * For these, we return the main bundle file path 'js/index-*.js' which will be resolved from manifest
- */
-_ConfigGenerator.COMPONENT_TO_CHUNK_NAME = {
-  // Core components - loaded with main bundle (not code-split)
-  Home: "index",
-  // Special marker for main entry point
-  Dashboard: "index",
-  // User Profile & Settings chunk
-  Profile: "chunk-user-profile",
-  Settings: "chunk-user-profile",
-  Preferences: "chunk-user-profile",
-  Privacy: "chunk-user-profile",
-  Security: "chunk-user-profile",
-  // Analytics & Reporting chunk
-  Analytics: "chunk-analytics",
-  Reports: "chunk-analytics",
-  Metrics: "chunk-analytics",
-  // Project Management chunk
-  Projects: "chunk-projects",
-  Tasks: "chunk-projects",
-  Teams: "chunk-projects",
-  Workspaces: "chunk-projects",
-  // Workflows & Operations chunk
-  Workflows: "chunk-operations",
-  Templates: "chunk-operations",
-  Logs: "chunk-operations",
-  AuditLogs: "chunk-operations",
-  // Integration chunk
-  Integrations: "chunk-integrations",
-  ApiDocs: "chunk-integrations",
-  Support: "chunk-integrations",
-  Help: "chunk-integrations",
-  // Billing & Plans chunk
-  Billing: "chunk-billing",
-  Plans: "chunk-billing",
-  Usage: "chunk-billing",
-  // Admin & Notifications chunk
-  Permissions: "chunk-admin",
-  Notifications: "chunk-admin"
-};
-var ConfigGenerator = _ConfigGenerator;
 
 // src/plugin/cache-manager.ts
 import * as fs from "fs";
@@ -1792,6 +1573,37 @@ function smartPrefetch(options = {}) {
               framework: '${framework}',
               debug: ${debug},
             };
+
+            // Initialize prefetch manager after page load
+            // This allows the app to be built first, then PrefetchManager can load the config
+            if (document.readyState === 'loading') {
+              document.addEventListener('DOMContentLoaded', initPrefetch);
+            } else {
+              initPrefetch();
+            }
+
+            async function initPrefetch() {
+              try {
+                // Dynamically import PrefetchManager from the bundled app
+                // The app should have @farmart/vite-plugin-smart-prefetch/runtime in its dependencies
+                const { PrefetchManager } = await import('@farmart/vite-plugin-smart-prefetch/runtime');
+                const manager = new PrefetchManager('${strategy}', ${debug});
+                await manager.init();
+
+                // Expose manager globally for debugging
+                window.__PREFETCH_MANAGER__ = manager;
+                if (${debug}) {
+                  console.log('\u2705 Smart Prefetch Manager initialized');
+                }
+              } catch (error) {
+                if (${debug}) {
+                  console.warn('\u26A0\uFE0F  Could not initialize Smart Prefetch Manager:', error);
+                  console.log('This is expected if:');
+                  console.log('1. @farmart/vite-plugin-smart-prefetch/runtime is not installed');
+                  console.log('2. prefetch-config.json was not generated (BigQuery data fetch failed)');
+                }
+              }
+            }
           `,
           injectTo: "head"
         }