@onruntime/next-sitemap 0.6.2 → 0.8.0

package/dist/app/index.js

@@ -1,9 +1,168 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { createJiti } from 'jiti';
-import stripJsonComments from 'strip-json-comments';
+import { existsSync, readdirSync } from 'fs';
+import { dirname, join, isAbsolute, relative, delimiter } from 'path';
+import * as childProcess from 'child_process';
+import { fileURLToPath } from 'url';
 
 // src/app/index.ts
+var NO_STATIC_PARAMS = "NO_STATIC_PARAMS";
+var spawnProcess = childProcess.spawn;
+var __dirname$1 = dirname(fileURLToPath(import.meta.url));
+var paramsCache = /* @__PURE__ */ new Map();
+var isDev = process.env.NODE_ENV === "development";
+async function executeWorker(directory, fileKey, debug) {
+  const absolutePath = join(directory, fileKey.replace("./", ""));
+  const projectRoot = process.cwd();
+  const distRoot = join(__dirname$1, "..");
+  const workerPath = join(distRoot, "worker.cjs");
+  const loaderPath = join(distRoot, "loader.js");
+  if (debug) {
+    console.log(`[next-sitemap] Worker path: ${workerPath}`);
+    console.log(`[next-sitemap] Worker exists: ${existsSync(workerPath)}`);
+    console.log(`[next-sitemap] Loader path: ${loaderPath}`);
+    console.log(`[next-sitemap] Loader exists: ${existsSync(loaderPath)}`);
+  }
+  return new Promise((resolve) => {
+    const nodePath = [
+      join(projectRoot, "node_modules"),
+      join(__dirname$1, "..", "node_modules")
+    ].join(delimiter);
+    const importFlag = ["--import", loaderPath];
+    const args = [...importFlag, workerPath, absolutePath, projectRoot];
+    const child = spawnProcess("node", args, {
+      cwd: projectRoot,
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, NODE_PATH: nodePath }
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (debug && stderr) {
+        console.warn(`[next-sitemap] Worker stderr: ${stderr}`);
+      }
+      if (code !== 0 && code !== null) {
+        if (debug) console.warn(`[next-sitemap] Worker exited with code ${code}`);
+        resolve(null);
+        return;
+      }
+      try {
+        const lines = stdout.trim().split("\n");
+        const result = JSON.parse(lines[lines.length - 1]);
+        if (result.success) {
+          resolve(result.params);
+        } else {
+          if (result.error !== NO_STATIC_PARAMS && debug) {
+            console.warn(`[next-sitemap] Worker error: ${result.error}`);
+          }
+          resolve(null);
+        }
+      } catch {
+        if (debug) console.warn(`[next-sitemap] Failed to parse worker output: ${stdout}`);
+        resolve(null);
+      }
+    });
+    child.on("error", (err) => {
+      if (debug) console.warn(`[next-sitemap] Failed to spawn worker: ${err.message}`);
+      resolve(null);
+    });
+  });
+}
+async function getRouteParams(route, directory, debug) {
+  const cacheKey = route.fileKey;
+  if (paramsCache.has(cacheKey)) {
+    return paramsCache.get(cacheKey);
+  }
+  if (debug) {
+    console.log(`[next-sitemap] ${route.pathname}: executing static params via worker`);
+  }
+  const params = await executeWorker(directory, route.fileKey, debug);
+  paramsCache.set(cacheKey, params);
+  if (debug && params) {
+    console.log(`[next-sitemap] ${route.pathname}: got ${params.length} params`);
+  }
+  return params;
+}
+async function generateAllPaths(routes, directory, debug) {
+  const staticPaths = ["/"];
+  const dynamicRoutes = [];
+  for (const route of routes) {
+    if (route.dynamicSegments.length === 0) {
+      if (route.pathname !== "/") {
+        staticPaths.push(route.pathname);
+      }
+    } else {
+      dynamicRoutes.push(route);
+    }
+  }
+  const startTime = isDev ? Date.now() : 0;
+  if (isDev && dynamicRoutes.length > 0) {
+    console.log(`[next-sitemap] Generating sitemap for ${dynamicRoutes.length} dynamic routes (dev only, instant in production)...`);
+  }
+  const dynamicResults = await Promise.all(
+    dynamicRoutes.map(async (route) => {
+      const params = await getRouteParams(route, directory, debug);
+      if (!params || params.length === 0) {
+        if (debug) {
+          console.warn(`[next-sitemap] Skipping dynamic route ${route.pathname}: no static params or empty result.`);
+        }
+        return [];
+      }
+      const paths = [];
+      for (const param of params) {
+        let path = route.pathname;
+        let valid = true;
+        for (const segment of route.dynamicSegments) {
+          const value = param[segment];
+          if (value === void 0) {
+            if (debug) {
+              console.warn(`[next-sitemap] ${route.pathname}: missing param "${segment}" in`, param);
+            }
+            valid = false;
+            break;
+          }
+          path = path.replace(`[${segment}]`, value);
+        }
+        if (valid) paths.push(path);
+      }
+      return paths;
+    })
+  );
+  const allPaths = new Set(staticPaths);
+  for (const paths of dynamicResults) {
+    for (const path of paths) {
+      allPaths.add(path);
+    }
+  }
+  if (isDev && dynamicRoutes.length > 0) {
+    const elapsed = Date.now() - startTime;
+    console.log(`[next-sitemap] Done! Found ${allPaths.size} total URLs in ${elapsed}ms.`);
+  }
+  return Array.from(allPaths);
+}
+function pathsToEntries(paths, config) {
+  const { baseUrl, locales = [], defaultLocale, exclude, priority, changeFreq } = config;
+  return paths.filter((pathname) => !shouldExclude(pathname, exclude)).map((pathname) => {
+    const entry = {
+      url: buildUrl(baseUrl, pathname, defaultLocale, defaultLocale),
+      lastModified: /* @__PURE__ */ new Date(),
+      changeFrequency: getChangeFreq(pathname, changeFreq),
+      priority: getPriority(pathname, priority)
+    };
+    if (locales.length > 0) {
+      entry.alternates = {
+        languages: Object.fromEntries(
+          locales.map((locale) => [locale, buildUrl(baseUrl, pathname, locale, defaultLocale)])
+        )
+      };
+    }
+    return entry;
+  });
+}
 
 // src/index.ts
 function calculateDepthPriority(pathname) {
@@ -52,7 +211,8 @@ function buildUrl(baseUrl, pathname, locale, defaultLocale) {
   }
   return `${baseUrl}/${locale}${normalizedPath}`;
 }
-function generateSitemapXml(entries) {
+function generateSitemapXml(entries, options) {
+  const { poweredBy = true } = options || {};
   const hasAlternates = entries.some((e) => e.alternates?.languages);
   const xmlns = hasAlternates ? 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml"' : 'xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"';
   const urlEntries = entries.map((entry) => {
@@ -76,13 +236,14 @@ function generateSitemapXml(entries) {
 ${parts.join("\n")}
   </url>`;
   }).join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
+  const comment = poweredBy ? "\n<!-- Powered by @onruntime/next-sitemap -->" : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>${comment}
 <urlset ${xmlns}>
 ${urlEntries}
 </urlset>`;
 }
 function generateSitemapIndexXml(baseUrl, sitemapCount, options) {
-  const { sitemapPattern = "/sitemap-{id}.xml", additionalSitemaps = [] } = options || {};
+  const { sitemapPattern = "/sitemap-{id}.xml", additionalSitemaps = [], poweredBy = true } = options || {};
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const paginatedEntries = Array.from({ length: sitemapCount }, (_, i) => {
     const loc = `${baseUrl}${sitemapPattern.replace("{id}", String(i))}`;
@@ -99,24 +260,24 @@ function generateSitemapIndexXml(baseUrl, sitemapCount, options) {
   </sitemap>`;
   });
   const allEntries = [...paginatedEntries, ...additionalEntries].join("\n");
-  return `<?xml version="1.0" encoding="UTF-8"?>
+  const comment = poweredBy ? "\n<!-- Powered by @onruntime/next-sitemap -->" : "";
+  return `<?xml version="1.0" encoding="UTF-8"?>${comment}
 <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
 ${allEntries}
 </sitemapindex>`;
 }
 
 // src/app/index.ts
-var joinPath = (...segments) => path.join(...segments);
 function findPageFiles(dir, baseDir = dir) {
   const files = [];
   try {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    const entries = readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = path.join(dir, entry.name);
+      const fullPath = join(dir, entry.name);
       if (entry.isDirectory()) {
         files.push(...findPageFiles(fullPath, baseDir));
       } else if (/^page\.(tsx?|jsx?)$/.test(entry.name)) {
-        const relativePath = "./" + path.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = "./" + relative(baseDir, fullPath).replace(/\\/g, "/");
         files.push(relativePath);
       }
     }
@@ -124,83 +285,12 @@ function findPageFiles(dir, baseDir = dir) {
   }
   return files;
 }
-function detectAppDirectory() {
-  const srcApp = path.join(process.cwd(), "src/app");
-  if (fs.existsSync(srcApp)) {
-    return srcApp;
-  }
-  return path.join(process.cwd(), "app");
-}
-function resolveAppDirectory(options) {
-  if (options.appDirectory) {
-    return path.isAbsolute(options.appDirectory) ? options.appDirectory : path.join(process.cwd(), options.appDirectory);
+function resolveAppDirectory(appDirectory) {
+  if (appDirectory) {
+    return isAbsolute(appDirectory) ? appDirectory : join(process.cwd(), appDirectory);
   }
-  return detectAppDirectory();
-}
-function getPageKeys(options) {
-  return findPageFiles(resolveAppDirectory(options));
-}
-var jitiCache = /* @__PURE__ */ new Map();
-function getTsconfigPaths(projectRoot, debug = false) {
-  const alias = {};
-  try {
-    const tsconfigPath = path.join(projectRoot, "tsconfig.json");
-    if (debug) {
-      console.log("[next-sitemap] Looking for tsconfig at:", tsconfigPath);
-      console.log("[next-sitemap] tsconfig exists:", fs.existsSync(tsconfigPath));
-    }
-    if (fs.existsSync(tsconfigPath)) {
-      const content = fs.readFileSync(tsconfigPath, "utf-8");
-      const withoutComments = stripJsonComments(content);
-      const cleaned = withoutComments.replace(/,(\s*[}\]])/g, "$1");
-      if (debug) {
-        console.log("[next-sitemap] Cleaned tsconfig (first 500 chars):", cleaned.slice(0, 500));
-      }
-      const tsconfig = JSON.parse(cleaned);
-      if (debug) {
-        console.log("[next-sitemap] Parsed tsconfig paths:", tsconfig.compilerOptions?.paths);
-      }
-      const baseUrl = tsconfig.compilerOptions?.baseUrl || ".";
-      const paths = tsconfig.compilerOptions?.paths || {};
-      for (const [key, values] of Object.entries(paths)) {
-        if (values.length > 0) {
-          const aliasKey = key.replace(/\*$/, "");
-          const aliasValue = joinPath(projectRoot, baseUrl, values[0].replace(/\*$/, ""));
-          alias[aliasKey] = aliasValue;
-        }
-      }
-    }
-  } catch (error) {
-    if (debug) {
-      console.error("[next-sitemap] Error parsing tsconfig:", error);
-    }
-  }
-  return alias;
-}
-function getJiti(projectRoot, debug = false) {
-  if (jitiCache.has(projectRoot)) {
-    return jitiCache.get(projectRoot);
-  }
-  const alias = getTsconfigPaths(projectRoot, debug);
-  if (debug) {
-    console.log("[next-sitemap] Final alias config:", JSON.stringify(alias));
-  }
-  const jiti = createJiti(import.meta.url, {
-    moduleCache: false,
-    interopDefault: true,
-    jsx: true,
-    alias
-  });
-  jitiCache.set(projectRoot, jiti);
-  return jiti;
-}
-async function importPage(appDirectory, key, debug = false) {
-  const relativePath = key.replace("./", "");
-  const absolutePath = path.join(appDirectory, relativePath);
-  const projectRoot = process.cwd();
-  const jiti = getJiti(projectRoot, debug);
-  const module = await jiti.import(absolutePath);
-  return module.default || module;
+  const srcApp = join(process.cwd(), "src/app");
+  return existsSync(srcApp) ? srcApp : join(process.cwd(), "app");
 }
 function extractRoutes(pageKeys, localeSegment) {
   const routes = [];
@@ -208,163 +298,64 @@ function extractRoutes(pageKeys, localeSegment) {
     if (key.includes("[...")) continue;
     let pathname = key.replace("./", "/").replace(/\/page\.(tsx?|jsx?)$/, "");
     if (localeSegment) {
-      pathname = pathname.replace(
-        new RegExp(`^/${localeSegment.replace(/[[\]]/g, "\\$&")}`),
-        ""
-      );
+      const escapedSegment = localeSegment.replace(/[[\]]/g, "\\$&");
+      pathname = pathname.replace(new RegExp(`^/${escapedSegment}`), "");
     }
     pathname = pathname.replace(/\/\([^)]+\)/g, "");
     if (/(?:^|\/)(src|app)(?:\/|$)/.test(pathname)) continue;
-    if (!pathname || pathname === "") {
-      pathname = "/";
-    } else if (!pathname.startsWith("/")) {
+    pathname = pathname || "/";
+    if (pathname !== "/" && !pathname.startsWith("/")) {
       pathname = "/" + pathname;
     }
-    const dynamicSegments = pathname.match(/\[([^\]]+)\]/g)?.map((s) => s.slice(1, -1)) || [];
-    routes.push({
-      pathname,
-      dynamicSegments,
-      key
-    });
+    const dynamicSegments = pathname.match(/\[([^\]]+)\]/g)?.map((s) => s.slice(1, -1)) ?? [];
+    routes.push({ pathname, dynamicSegments, fileKey: key });
   }
   return routes;
 }
-async function getAllPaths(routes, appDirectory, debug = false) {
-  const allPaths = ["/"];
-  const seenPaths = /* @__PURE__ */ new Set(["/"]);
-  for (const route of routes) {
-    if (route.dynamicSegments.length === 0) {
-      if (route.pathname !== "/" && !seenPaths.has(route.pathname)) {
-        allPaths.push(route.pathname);
-        seenPaths.add(route.pathname);
-      }
-    } else {
-      let getParams = null;
-      try {
-        if (debug) {
-          console.log(`[next-sitemap] ${route.pathname}: importing ${route.key}`);
-        }
-        const module = await importPage(appDirectory, route.key, debug);
-        getParams = module.generateStaticParams || null;
-      } catch (error) {
-        if (debug) {
-          console.warn(`[next-sitemap] ${route.pathname}: import failed:`, error);
-        }
-      }
-      if (getParams) {
-        try {
-          const params = await getParams();
-          if (debug) {
-            console.log(`[next-sitemap] ${route.pathname}: generateStaticParams returned ${params.length} params`);
-          }
-          for (const param of params) {
-            let dynamicPath = route.pathname;
-            for (const segment of route.dynamicSegments) {
-              const value = param[segment];
-              if (value === void 0) {
-                if (debug) {
-                  console.warn(`[next-sitemap] ${route.pathname}: missing param "${segment}" in`, param);
-                }
-                continue;
-              }
-              dynamicPath = dynamicPath.replace(`[${segment}]`, value);
-            }
-            if (!seenPaths.has(dynamicPath)) {
-              allPaths.push(dynamicPath);
-              seenPaths.add(dynamicPath);
-            }
-          }
-        } catch (error) {
-          console.error(`[next-sitemap] Error calling generateStaticParams for ${route.pathname}:`, error);
-        }
-      } else {
-        if (debug) {
-          console.warn(
-            `[next-sitemap] Skipping dynamic route ${route.pathname}: no generateStaticParams exported. Use additionalSitemaps for routes that fetch data at runtime.`
-          );
-        }
-      }
-    }
-  }
-  return allPaths;
-}
-function pathsToEntries(paths, config) {
-  const { baseUrl, locales = [], defaultLocale, exclude, priority, changeFreq } = config;
-  const filteredPaths = paths.filter((pathname) => !shouldExclude(pathname, exclude));
-  return filteredPaths.map((pathname) => {
-    const entry = {
-      url: buildUrl(baseUrl, pathname, defaultLocale, defaultLocale),
-      lastModified: /* @__PURE__ */ new Date(),
-      changeFrequency: getChangeFreq(pathname, changeFreq),
-      priority: getPriority(pathname, priority)
-    };
-    if (locales.length > 0) {
-      entry.alternates = {
-        languages: Object.fromEntries(
-          locales.map((locale) => [
-            locale,
-            buildUrl(baseUrl, pathname, locale, defaultLocale)
-          ])
-        )
-      };
-    }
-    return entry;
-  });
-}
 function createSitemapIndexHandler(options) {
   const { urlsPerSitemap = 5e3, locales = [], defaultLocale, additionalSitemaps, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
-  const appDir = resolveAppDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const appDir = resolveAppDirectory(options.appDirectory);
+  const pageKeys = findPageFiles(appDir);
   const routes = extractRoutes(pageKeys, localeSegment);
   return {
     GET: async () => {
       if (debug) {
-        console.log(`[next-sitemap] Found ${routes.length} routes:`);
-        routes.forEach((r) => {
-          const isDynamic = r.dynamicSegments.length > 0;
-          const segments = isDynamic ? ` [${r.dynamicSegments.join(", ")}]` : "";
-          console.log(`  ${r.pathname}${segments}${isDynamic ? " (dynamic)" : ""}`);
-        });
+        console.log(`[next-sitemap] Found ${routes.length} routes`);
       }
-      const allPaths = await getAllPaths(routes, appDir, debug);
-      const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+      const allPaths = await generateAllPaths(routes, appDir, debug);
+      const filteredPaths = allPaths.filter((p) => !shouldExclude(p, exclude));
       const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
-      const xml = generateSitemapIndexXml(options.baseUrl, sitemapCount, {
-        additionalSitemaps
-      });
-      return new Response(xml, {
-        headers: { "Content-Type": "application/xml" }
-      });
+      return new Response(
+        generateSitemapIndexXml(options.baseUrl, sitemapCount, { additionalSitemaps, poweredBy: options.poweredBy }),
+        { headers: { "Content-Type": "application/xml" } }
+      );
     }
   };
 }
 function createSitemapHandler(options) {
   const { urlsPerSitemap = 5e3, locales = [], defaultLocale, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? (locales.length > 0 || defaultLocale ? "[locale]" : "");
-  const appDir = resolveAppDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const appDir = resolveAppDirectory(options.appDirectory);
+  const pageKeys = findPageFiles(appDir);
   const routes = extractRoutes(pageKeys, localeSegment);
   const getFilteredPaths = async () => {
-    const allPaths = await getAllPaths(routes, appDir, debug);
-    return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+    const allPaths = await generateAllPaths(routes, appDir, debug);
+    return allPaths.filter((p) => !shouldExclude(p, exclude));
   };
   return {
     generateStaticParams: async () => {
       const filteredPaths = await getFilteredPaths();
-      const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
-      return Array.from({ length: sitemapCount }, (_, i) => ({ id: String(i) }));
+      const count = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
+      return Array.from({ length: count }, (_, i) => ({ id: String(i) }));
     },
     GET: async (_request, { params }) => {
       const { id } = await params;
       const sitemapId = parseInt(id, 10);
       const filteredPaths = await getFilteredPaths();
-      const start = sitemapId * urlsPerSitemap;
-      const end = start + urlsPerSitemap;
-      const paths = filteredPaths.slice(start, end);
+      const paths = filteredPaths.slice(sitemapId * urlsPerSitemap, (sitemapId + 1) * urlsPerSitemap);
       const entries = pathsToEntries(paths, { ...options, exclude: void 0 });
-      const xml = generateSitemapXml(entries);
-      return new Response(xml, {
+      return new Response(generateSitemapXml(entries, { poweredBy: options.poweredBy }), {
         headers: { "Content-Type": "application/xml" }
       });
     }