@onruntime/next-sitemap 0.6.1 → 0.7.0

package/dist/index.d.cts

@@ -1,4 +1,54 @@
+/**
+ * Shared utilities, constants, and types for the sitemap package
+ */
+
+/**
+ * File extensions that Node.js/jiti can actually process.
+ * Any other extension will be mocked as an empty module.
+ */
+declare const JS_EXTENSIONS: Set<string>;
+/**
+ * Special error code when a page doesn't export generateStaticParams or getStaticPaths
+ */
+declare const NO_STATIC_PARAMS = "NO_STATIC_PARAMS";
+/**
+ * Worker result types
+ */
+interface WorkerSuccess {
+    success: true;
+    params: Record<string, string>[];
+}
+interface WorkerFailure {
+    success: false;
+    error: string;
+}
+type WorkerOutput = WorkerSuccess | WorkerFailure;
+declare const paramsCache: Map<string, Record<string, string>[] | null>;
+declare const isDev: boolean;
+interface RouteInfo$1 {
+    pathname: string;
+    dynamicSegments: string[];
+    fileKey: string;
+}
+/**
+ * Execute worker via child process to get static params
+ */
+declare function executeWorker(directory: string, fileKey: string, debug: boolean): Promise<Record<string, string>[] | null>;
+/**
+ * Get params for a dynamic route (with caching)
+ */
+declare function getRouteParams(route: RouteInfo$1, directory: string, debug: boolean): Promise<Record<string, string>[] | null>;
+/**
+ * Generate all URL paths from routes (parallel execution for dynamic routes)
+ */
+declare function generateAllPaths(routes: RouteInfo$1[], directory: string, debug: boolean): Promise<string[]>;
+/**
+ * Convert paths to sitemap entries
+ */
+declare function pathsToEntries(paths: string[], config: SitemapConfig): SitemapEntry[];
+
 type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+
 interface SitemapConfig {
     /**
      * Base URL of the site (e.g., "https://example.com")
@@ -51,6 +101,11 @@ interface SitemapConfig {
      * @example additionalSitemaps: ["/products-sitemap.xml", "/blog-sitemap.xml"]
      */
     additionalSitemaps?: string[];
+    /**
+     * Enable debug logging to diagnose issues with route discovery
+     * @default false
+     */
+    debug?: boolean;
 }
 interface SitemapEntry {
     url: string;
@@ -107,4 +162,4 @@ declare function generateSitemapIndexXml(baseUrl: string, sitemapCount: number,
     additionalSitemaps?: string[];
 }): string;
 
-export { type ChangeFrequency, type PageModule, type RouteInfo, type SitemapConfig, type SitemapEntry, buildUrl, calculateDepthPriority, generateSitemapIndexXml, generateSitemapXml, getChangeFreq, getPriority, normalizePath, shouldExclude };
+export { type ChangeFrequency, JS_EXTENSIONS, NO_STATIC_PARAMS, type PageModule, type RouteInfo, type SitemapConfig, type SitemapEntry, type WorkerFailure, type WorkerOutput, type WorkerSuccess, buildUrl, calculateDepthPriority, executeWorker, generateAllPaths, generateSitemapIndexXml, generateSitemapXml, getChangeFreq, getPriority, getRouteParams, isDev, normalizePath, paramsCache, pathsToEntries, shouldExclude };

package/dist/index.d.ts

@@ -1,4 +1,54 @@
+/**
+ * Shared utilities, constants, and types for the sitemap package
+ */
+
+/**
+ * File extensions that Node.js/jiti can actually process.
+ * Any other extension will be mocked as an empty module.
+ */
+declare const JS_EXTENSIONS: Set<string>;
+/**
+ * Special error code when a page doesn't export generateStaticParams or getStaticPaths
+ */
+declare const NO_STATIC_PARAMS = "NO_STATIC_PARAMS";
+/**
+ * Worker result types
+ */
+interface WorkerSuccess {
+    success: true;
+    params: Record<string, string>[];
+}
+interface WorkerFailure {
+    success: false;
+    error: string;
+}
+type WorkerOutput = WorkerSuccess | WorkerFailure;
+declare const paramsCache: Map<string, Record<string, string>[] | null>;
+declare const isDev: boolean;
+interface RouteInfo$1 {
+    pathname: string;
+    dynamicSegments: string[];
+    fileKey: string;
+}
+/**
+ * Execute worker via child process to get static params
+ */
+declare function executeWorker(directory: string, fileKey: string, debug: boolean): Promise<Record<string, string>[] | null>;
+/**
+ * Get params for a dynamic route (with caching)
+ */
+declare function getRouteParams(route: RouteInfo$1, directory: string, debug: boolean): Promise<Record<string, string>[] | null>;
+/**
+ * Generate all URL paths from routes (parallel execution for dynamic routes)
+ */
+declare function generateAllPaths(routes: RouteInfo$1[], directory: string, debug: boolean): Promise<string[]>;
+/**
+ * Convert paths to sitemap entries
+ */
+declare function pathsToEntries(paths: string[], config: SitemapConfig): SitemapEntry[];
+
 type ChangeFrequency = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
+
 interface SitemapConfig {
     /**
      * Base URL of the site (e.g., "https://example.com")
@@ -51,6 +101,11 @@ interface SitemapConfig {
      * @example additionalSitemaps: ["/products-sitemap.xml", "/blog-sitemap.xml"]
      */
     additionalSitemaps?: string[];
+    /**
+     * Enable debug logging to diagnose issues with route discovery
+     * @default false
+     */
+    debug?: boolean;
 }
 interface SitemapEntry {
     url: string;
@@ -107,4 +162,4 @@ declare function generateSitemapIndexXml(baseUrl: string, sitemapCount: number,
     additionalSitemaps?: string[];
 }): string;
 
-export { type ChangeFrequency, type PageModule, type RouteInfo, type SitemapConfig, type SitemapEntry, buildUrl, calculateDepthPriority, generateSitemapIndexXml, generateSitemapXml, getChangeFreq, getPriority, normalizePath, shouldExclude };
+export { type ChangeFrequency, JS_EXTENSIONS, NO_STATIC_PARAMS, type PageModule, type RouteInfo, type SitemapConfig, type SitemapEntry, type WorkerFailure, type WorkerOutput, type WorkerSuccess, buildUrl, calculateDepthPriority, executeWorker, generateAllPaths, generateSitemapIndexXml, generateSitemapXml, getChangeFreq, getPriority, getRouteParams, isDev, normalizePath, paramsCache, pathsToEntries, shouldExclude };

package/dist/index.js

@@ -1,3 +1,181 @@
+import { existsSync } from 'fs';
+import { dirname, join, delimiter } from 'path';
+import * as childProcess from 'child_process';
+import { fileURLToPath } from 'url';
+
+// src/shared.ts
+var JS_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".cjs",
+  ".mjs",
+  ".jsx",
+  ".ts",
+  ".cts",
+  ".mts",
+  ".tsx",
+  ".json",
+  ".node"
+]);
+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) {
   if (pathname === "/") return 1;
@@ -98,4 +276,4 @@ ${allEntries}
 </sitemapindex>`;
 }
 
-export { buildUrl, calculateDepthPriority, generateSitemapIndexXml, generateSitemapXml, getChangeFreq, getPriority, normalizePath, shouldExclude };
+export { JS_EXTENSIONS, NO_STATIC_PARAMS, buildUrl, calculateDepthPriority, executeWorker, generateAllPaths, generateSitemapIndexXml, generateSitemapXml, getChangeFreq, getPriority, getRouteParams, isDev, normalizePath, paramsCache, pathsToEntries, shouldExclude };

package/dist/loader.js

@@ -0,0 +1,38 @@
+// src/shared.ts
+import { existsSync } from "fs";
+import { dirname, join, delimiter } from "path";
+import * as childProcess from "child_process";
+import { fileURLToPath } from "url";
+var JS_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".js",
+  ".cjs",
+  ".mjs",
+  ".jsx",
+  ".ts",
+  ".cts",
+  ".mts",
+  ".tsx",
+  ".json",
+  ".node"
+]);
+var __dirname = dirname(fileURLToPath(import.meta.url));
+var isDev = process.env.NODE_ENV === "development";
+
+// src/loader.ts
+function resolve(specifier, context, nextResolve) {
+  const ext = specifier.match(/\.[a-z0-9]+$/i)?.[0]?.toLowerCase();
+  if (ext && !JS_EXTENSIONS.has(ext)) {
+    return { shortCircuit: true, url: `mock:${specifier}` };
+  }
+  return nextResolve(specifier, context);
+}
+function load(url, context, nextLoad) {
+  if (url.startsWith("mock:")) {
+    return { shortCircuit: true, format: "module", source: "export default {};" };
+  }
+  return nextLoad(url, context);
+}
+export {
+  load,
+  resolve
+};