@onruntime/next-sitemap 0.6.2 → 0.7.0

package/dist/pages/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/pages/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) {
@@ -144,18 +303,17 @@ function generateRobotsTxt(config) {
 }
 
 // src/pages/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()) {
         if (entry.name === "api") continue;
         files.push(...findPageFiles(fullPath, baseDir));
       } else if (/\.(tsx?|jsx?)$/.test(entry.name) && !entry.name.startsWith("_")) {
-        const relativePath = "./" + path.relative(baseDir, fullPath).replace(/\\/g, "/");
+        const relativePath = "./" + relative(baseDir, fullPath).replace(/\\/g, "/");
         files.push(relativePath);
       }
     }
@@ -163,67 +321,12 @@ function findPageFiles(dir, baseDir = dir) {
   }
   return files;
 }
-function detectPagesDirectory() {
-  const srcPages = path.join(process.cwd(), "src/pages");
-  if (fs.existsSync(srcPages)) {
-    return srcPages;
-  }
-  return path.join(process.cwd(), "pages");
-}
-function resolvePagesDirectory(options) {
-  if (options.pagesDirectory) {
-    return path.isAbsolute(options.pagesDirectory) ? options.pagesDirectory : path.join(process.cwd(), options.pagesDirectory);
+function resolvePagesDirectory(pagesDirectory) {
+  if (pagesDirectory) {
+    return isAbsolute(pagesDirectory) ? pagesDirectory : join(process.cwd(), pagesDirectory);
   }
-  return detectPagesDirectory();
-}
-function getPageKeys(options) {
-  return findPageFiles(resolvePagesDirectory(options));
-}
-var jitiCache = /* @__PURE__ */ new Map();
-function getTsconfigPaths(projectRoot) {
-  const alias = {};
-  try {
-    const tsconfigPath = path.join(projectRoot, "tsconfig.json");
-    if (fs.existsSync(tsconfigPath)) {
-      const content = fs.readFileSync(tsconfigPath, "utf-8");
-      const withoutComments = stripJsonComments(content);
-      const cleaned = withoutComments.replace(/,(\s*[}\]])/g, "$1");
-      const tsconfig = JSON.parse(cleaned);
-      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 {
-  }
-  return alias;
-}
-function getJiti(projectRoot) {
-  if (jitiCache.has(projectRoot)) {
-    return jitiCache.get(projectRoot);
-  }
-  const alias = getTsconfigPaths(projectRoot);
-  const jiti = createJiti(import.meta.url, {
-    moduleCache: false,
-    interopDefault: true,
-    jsx: true,
-    alias
-  });
-  jitiCache.set(projectRoot, jiti);
-  return jiti;
-}
-async function importPage(pagesDirectory, key) {
-  const relativePath = key.replace("./", "");
-  const absolutePath = path.join(pagesDirectory, relativePath);
-  const projectRoot = process.cwd();
-  const jiti = getJiti(projectRoot);
-  const module = await jiti.import(absolutePath);
-  return module.default || module;
+  const srcPages = join(process.cwd(), "src/pages");
+  return existsSync(srcPages) ? srcPages : join(process.cwd(), "pages");
 }
 function extractRoutes(pageKeys, localeSegment) {
   const routes = [];
@@ -232,10 +335,8 @@ function extractRoutes(pageKeys, localeSegment) {
     let pathname = key.replace(/^\.\//, "/").replace(/\.(tsx?|jsx?)$/, "").replace(/\/index$/, "/");
     if (pathname === "") pathname = "/";
     if (localeSegment) {
-      pathname = pathname.replace(
-        new RegExp(`^/${localeSegment.replace(/[[\]]/g, "\\$&")}`),
-        ""
-      );
+      const escapedSegment = localeSegment.replace(/[[\]]/g, "\\$&");
+      pathname = pathname.replace(new RegExp(`^/${escapedSegment}`), "");
     }
     if (/(?:^|\/)(src|pages)(?:\/|$)/.test(pathname)) continue;
     if (!pathname || pathname === "") {
@@ -243,160 +344,57 @@ function extractRoutes(pageKeys, localeSegment) {
     } else if (!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, pagesDirectory, 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(pagesDirectory, route.key);
-        const getStaticPaths = module.getStaticPaths;
-        if (getStaticPaths) {
-          getParams = async () => {
-            const result = await getStaticPaths();
-            return result.paths.map((p) => p.params);
-          };
-        } else if (module.generateStaticParams) {
-          getParams = module.generateStaticParams;
-        }
-      } 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}: getStaticPaths 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 getStaticPaths for ${route.pathname}:`, error);
-        }
-      } else {
-        if (debug) {
-          console.warn(
-            `[next-sitemap] Skipping dynamic route ${route.pathname}: no getStaticPaths 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 createSitemapIndexApiHandler(options) {
   const { urlsPerSitemap = 5e3, additionalSitemaps, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? "";
-  const pagesDir = resolvePagesDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const pagesDir = resolvePagesDirectory(options.pagesDirectory);
+  const pageKeys = findPageFiles(pagesDir);
   const routes = extractRoutes(pageKeys, localeSegment);
-  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)" : ""}`);
-    });
-  }
   return async function handler(_req, res) {
-    const allPaths = await getAllPaths(routes, pagesDir, debug);
-    const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+    if (debug) {
+      console.log(`[next-sitemap] Found ${routes.length} routes`);
+    }
+    const allPaths = await generateAllPaths(routes, pagesDir, 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
-    });
     res.setHeader("Content-Type", "application/xml");
-    res.status(200).send(xml);
+    res.status(200).send(
+      generateSitemapIndexXml(options.baseUrl, sitemapCount, { additionalSitemaps })
+    );
   };
 }
 function createSitemapApiHandler(options) {
   const { urlsPerSitemap = 5e3, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? "";
-  const pagesDir = resolvePagesDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const pagesDir = resolvePagesDirectory(options.pagesDirectory);
+  const pageKeys = findPageFiles(pagesDir);
   const routes = extractRoutes(pageKeys, localeSegment);
   const getFilteredPaths = async () => {
-    const allPaths = await getAllPaths(routes, pagesDir, debug);
-    return allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
+    const allPaths = await generateAllPaths(routes, pagesDir, debug);
+    return allPaths.filter((p) => !shouldExclude(p, exclude));
   };
   return async function handler(req, res) {
     const { id } = req.query;
     const sitemapId = parseInt(Array.isArray(id) ? id[0] : id || "0", 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);
     res.setHeader("Content-Type", "application/xml");
-    res.status(200).send(xml);
+    res.status(200).send(generateSitemapXml(entries));
   };
 }
 async function getSitemapStaticPaths(options) {
   const { urlsPerSitemap = 5e3, exclude, debug = false } = options;
   const localeSegment = options.localeSegment ?? "";
-  const pagesDir = resolvePagesDirectory(options);
-  const pageKeys = getPageKeys(options);
+  const pagesDir = resolvePagesDirectory(options.pagesDirectory);
+  const pageKeys = findPageFiles(pagesDir);
   const routes = extractRoutes(pageKeys, localeSegment);
-  const allPaths = await getAllPaths(routes, pagesDir, debug);
+  const allPaths = await generateAllPaths(routes, pagesDir, debug);
   const filteredPaths = allPaths.filter((pathname) => !shouldExclude(pathname, exclude));
   const sitemapCount = Math.max(1, Math.ceil(filteredPaths.length / urlsPerSitemap));
   return {
@@ -408,9 +406,8 @@ async function getSitemapStaticPaths(options) {
 }
 function createRobotsApiHandler(config) {
   return function handler(_req, res) {
-    const robotsTxt = generateRobotsTxt(config);
     res.setHeader("Content-Type", "text/plain");
-    res.status(200).send(robotsTxt);
+    res.status(200).send(generateRobotsTxt(config));
   };
 }
 

package/dist/worker.cjs

@@ -0,0 +1,207 @@
+'use strict';
+
+var fs = require('fs');
+var module$1 = require('module');
+var path = require('path');
+var jiti = require('jiti');
+require('child_process');
+var url = require('url');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+// src/worker.ts
+
+// ../../node_modules/.pnpm/strip-json-comments@5.0.3/node_modules/strip-json-comments/index.js
+var singleComment = /* @__PURE__ */ Symbol("singleComment");
+var multiComment = /* @__PURE__ */ Symbol("multiComment");
+var stripWithoutWhitespace = () => "";
+var stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/[^ \t\r\n]/g, " ");
+var isEscaped = (jsonString, quotePosition) => {
+  let index = quotePosition - 1;
+  let backslashCount = 0;
+  while (jsonString[index] === "\\") {
+    index -= 1;
+    backslashCount += 1;
+  }
+  return Boolean(backslashCount % 2);
+};
+function stripJsonComments(jsonString, { whitespace = true, trailingCommas = false } = {}) {
+  if (typeof jsonString !== "string") {
+    throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+  }
+  const strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace;
+  let isInsideString = false;
+  let isInsideComment = false;
+  let offset = 0;
+  let buffer = "";
+  let result = "";
+  let commaIndex = -1;
+  for (let index = 0; index < jsonString.length; index++) {
+    const currentCharacter = jsonString[index];
+    const nextCharacter = jsonString[index + 1];
+    if (!isInsideComment && currentCharacter === '"') {
+      const escaped = isEscaped(jsonString, index);
+      if (!escaped) {
+        isInsideString = !isInsideString;
+      }
+    }
+    if (isInsideString) {
+      continue;
+    }
+    if (!isInsideComment && currentCharacter + nextCharacter === "//") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = singleComment;
+      index++;
+    } else if (isInsideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+      continue;
+    } else if (isInsideComment === singleComment && currentCharacter === "\n") {
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+    } else if (!isInsideComment && currentCharacter + nextCharacter === "/*") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = multiComment;
+      index++;
+      continue;
+    } else if (isInsideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index + 1);
+      offset = index + 1;
+      continue;
+    } else if (trailingCommas && !isInsideComment) {
+      if (commaIndex !== -1) {
+        if (currentCharacter === "}" || currentCharacter === "]") {
+          buffer += jsonString.slice(offset, index);
+          result += strip(buffer, 0, 1) + buffer.slice(1);
+          buffer = "";
+          offset = index;
+          commaIndex = -1;
+        } else if (currentCharacter !== " " && currentCharacter !== "	" && currentCharacter !== "\r" && currentCharacter !== "\n") {
+          buffer += jsonString.slice(offset, index);
+          offset = index;
+          commaIndex = -1;
+        }
+      } else if (currentCharacter === ",") {
+        result += buffer + jsonString.slice(offset, index);
+        buffer = "";
+        offset = index;
+        commaIndex = index;
+      }
+    }
+  }
+  const remaining = isInsideComment === singleComment ? strip(jsonString, offset) : jsonString.slice(offset);
+  return result + buffer + remaining;
+}
+var JS_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".cjs",
+  ".mjs",
+  ".jsx",
+  ".ts",
+  ".cts",
+  ".mts",
+  ".tsx",
+  ".json",
+  ".node"
+]);
+var NO_STATIC_PARAMS = "NO_STATIC_PARAMS";
+path.dirname(url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('worker.cjs', document.baseURI).href))));
+process.env.NODE_ENV === "development";
+
+// src/worker.ts
+var joinPath = (...segments) => path.join(...segments);
+installMockLoader();
+main();
+function installMockLoader() {
+  const ModuleInternal = module$1.Module;
+  const originalLoad = ModuleInternal._load;
+  ModuleInternal._load = function(request, parent, isMain) {
+    let resolvedPath;
+    try {
+      resolvedPath = ModuleInternal._resolveFilename(request, parent, isMain);
+    } catch {
+      return originalLoad(request, parent, isMain);
+    }
+    const ext = path.extname(resolvedPath).toLowerCase();
+    if (ext && !JS_EXTENSIONS.has(ext)) {
+      return {};
+    }
+    return originalLoad(request, parent, isMain);
+  };
+}
+function parseTsconfigAliases(projectRoot) {
+  const aliases = {};
+  try {
+    const tsconfigPath = path.join(projectRoot, "tsconfig.json");
+    if (!fs.existsSync(tsconfigPath)) return aliases;
+    const content = fs.readFileSync(tsconfigPath, "utf-8");
+    const withoutComments = stripJsonComments(content);
+    const cleaned = withoutComments.replace(/,(\s*[}\]])/g, "$1");
+    const tsconfig = JSON.parse(cleaned);
+    const baseUrl = tsconfig.compilerOptions?.baseUrl ?? ".";
+    const paths = tsconfig.compilerOptions?.paths ?? {};
+    if (baseUrl === ".") {
+      const srcPath = joinPath(projectRoot, "src");
+      if (fs.existsSync(srcPath)) {
+        aliases["src/"] = `${srcPath}/`;
+      }
+    }
+    for (const [pattern, targets] of Object.entries(paths)) {
+      const target = targets[0];
+      if (!target) continue;
+      if (target.includes("@types") || target.includes("node_modules/@types")) {
+        continue;
+      }
+      if (!pattern.includes("*") && !pattern.startsWith("@") && !pattern.includes("/")) {
+        continue;
+      }
+      const aliasKey = pattern.replace(/\*$/, "");
+      const aliasValue = joinPath(projectRoot, baseUrl, target.replace(/\*$/, ""));
+      aliases[aliasKey] = aliasValue;
+    }
+  } catch {
+  }
+  return aliases;
+}
+function output(result, exitCode = 0) {
+  console.log(JSON.stringify(result));
+  process.exit(exitCode);
+}
+async function main() {
+  const [absolutePath, projectRoot] = process.argv.slice(2);
+  if (!absolutePath || !projectRoot) {
+    output({ success: false, error: "Usage: worker.cjs <absolutePath> <projectRoot>" }, 1);
+  }
+  try {
+    process.chdir(projectRoot);
+    const jiti$1 = jiti.createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('worker.cjs', document.baseURI).href)), {
+      moduleCache: false,
+      interopDefault: true,
+      jsx: true,
+      alias: parseTsconfigAliases(projectRoot),
+      tryNative: false
+    });
+    const module = jiti$1(absolutePath);
+    const generateStaticParams = module.generateStaticParams;
+    if (generateStaticParams) {
+      const params = await generateStaticParams();
+      output({ success: true, params: params ?? [] });
+    }
+    const getStaticPaths = module.getStaticPaths;
+    if (getStaticPaths) {
+      const result = await getStaticPaths();
+      const params = result.paths.map((p) => p.params);
+      output({ success: true, params });
+    }
+    output({ success: false, error: NO_STATIC_PARAMS });
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    output({ success: false, error: message }, 1);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onruntime/next-sitemap",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "description": "Dynamic sitemap generation for Next.js with automatic route discovery",
   "author": "onRuntime Studio <contact@onruntime.com>",
   "repository": {
@@ -67,6 +67,6 @@
     "build": "tsup",
     "dev": "tsup --watch",
     "type-check": "tsc --noEmit",
-    "test": "tsx --test tests/index.ts"
+    "test": "tsup && tsx --test tests/index.ts"
   }
 }