@djangocfg/seo 2.1.50

package/src/content/sitemap-generator.ts

@@ -0,0 +1,321 @@
+/**
+ * Universal Sitemap Generator for Next.js App Router projects
+ * Supports both Nextra (MDX content) and standard Next.js projects
+ */
+
+import fs from 'fs';
+import path from 'path';
+import type { SitemapItem, SitemapData, ContentConfig } from './types.js';
+import { scanRoutes, type RouteInfo } from '../routes/scanner.js';
+import { detectProjectType } from './scanner.js';
+
+/**
+ * Dynamically import _meta.ts file (Nextra pattern)
+ */
+async function getMeta(dir: string): Promise<Record<string, unknown>> {
+  const metaPath = path.join(dir, '_meta.ts');
+  if (!fs.existsSync(metaPath)) return {};
+
+  try {
+    const meta = await import(metaPath);
+    return meta.default || {};
+  } catch {
+    // Fallback: try to parse with regex for simple cases
+    try {
+      const content = fs.readFileSync(metaPath, 'utf-8');
+      const matches = content.matchAll(/'([^']+)':\s*['"]([^'"]+)['"]/g);
+      const result: Record<string, string> = {};
+      for (const match of matches) {
+        const key = match[1];
+        const value = match[2];
+        if (key && value) {
+          result[key] = value;
+        }
+      }
+      return result;
+    } catch {
+      return {};
+    }
+  }
+}
+
+/**
+ * Get title from meta object
+ */
+function getTitleFromMeta(key: string, meta: Record<string, unknown>): string {
+  const value = meta[key];
+  if (!value) return key;
+  if (typeof value === 'string') return value;
+  if (typeof value === 'object' && value !== null && 'title' in value) {
+    return String((value as { title: unknown }).title);
+  }
+  return key;
+}
+
+/**
+ * Scan Nextra content directory recursively
+ */
+async function scanContent(
+  dir: string,
+  baseUrl: string = '/docs'
+): Promise<SitemapItem[]> {
+  const items: SitemapItem[] = [];
+
+  if (!fs.existsSync(dir)) return items;
+
+  const meta = await getMeta(dir);
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+  // Build file map
+  const fileMap = new Map<string, fs.Dirent>();
+  for (const entry of entries) {
+    const key = entry.name.replace(/\.mdx?$/, '');
+    fileMap.set(key, entry);
+  }
+
+  // Process meta keys first to preserve order
+  const metaKeys = Object.keys(meta);
+  for (const key of metaKeys) {
+    const entry = fileMap.get(key);
+    if (!entry) continue;
+
+    fileMap.delete(key);
+    const fullPath = path.join(dir, entry.name);
+    const itemPath = path.join(baseUrl, key).replace(/\\/g, '/');
+
+    if (entry.isDirectory()) {
+      const children = await scanContent(fullPath, itemPath);
+      items.push({
+        title: getTitleFromMeta(key, meta),
+        path: itemPath,
+        children: children.length > 0 ? children : undefined,
+      });
+    } else if (entry.isFile() && (entry.name.endsWith('.md') || entry.name.endsWith('.mdx'))) {
+      if (entry.name !== 'index.mdx' && entry.name !== 'index.md') {
+        items.push({
+          title: getTitleFromMeta(key, meta),
+          path: itemPath,
+        });
+      }
+    }
+  }
+
+  // Process remaining entries not in meta
+  for (const [key, entry] of fileMap.entries()) {
+    if (key.startsWith('_') || key.startsWith('.')) continue;
+
+    const fullPath = path.join(dir, entry.name);
+    const itemPath = path.join(baseUrl, key).replace(/\\/g, '/');
+
+    if (entry.isDirectory()) {
+      const children = await scanContent(fullPath, itemPath);
+      items.push({
+        title: key,
+        path: itemPath,
+        children: children.length > 0 ? children : undefined,
+      });
+    } else if (entry.isFile() && (entry.name.endsWith('.md') || entry.name.endsWith('.mdx'))) {
+      if (entry.name !== 'index.mdx' && entry.name !== 'index.md') {
+        items.push({
+          title: key,
+          path: itemPath,
+        });
+      }
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Convert route path to title
+ */
+function routeToTitle(routePath: string): string {
+  const segment = routePath.split('/').filter(Boolean).pop() || 'Home';
+  // Skip dynamic segments
+  if (segment.startsWith('[')) return segment;
+  // Capitalize and replace hyphens
+  return segment
+    .split('-')
+    .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+/**
+ * Convert routes to sitemap items (tree structure)
+ * Uses existing routes/scanner.ts for universal Next.js support
+ */
+function routesToSitemapItems(routes: RouteInfo[]): SitemapItem[] {
+  // Build tree from flat routes
+  const root: Map<string, SitemapItem> = new Map();
+  const items: SitemapItem[] = [];
+
+  // Sort routes by path depth
+  const sortedRoutes = [...routes]
+    .filter(r => r.type === 'page' && !r.isDynamic) // Only static pages
+    .sort((a, b) => a.path.split('/').length - b.path.split('/').length);
+
+  for (const route of sortedRoutes) {
+    const segments = route.path.split('/').filter(Boolean);
+
+    if (segments.length === 0) {
+      // Root path
+      items.push({
+        title: 'Home',
+        path: '/',
+      });
+      continue;
+    }
+
+    // Find or create parent
+    let currentPath = '';
+    let parentChildren: SitemapItem[] = items;
+
+    for (let i = 0; i < segments.length - 1; i++) {
+      currentPath += '/' + segments[i];
+      let parent = root.get(currentPath);
+
+      if (!parent) {
+        parent = {
+          title: routeToTitle(currentPath),
+          path: currentPath,
+          children: [],
+        };
+        root.set(currentPath, parent);
+        parentChildren.push(parent);
+      }
+
+      parentChildren = parent.children || (parent.children = []);
+    }
+
+    // Add current item
+    const item: SitemapItem = {
+      title: routeToTitle(route.path),
+      path: route.path,
+    };
+    parentChildren.push(item);
+  }
+
+  return items;
+}
+
+/**
+ * Generate sitemap data from project
+ * Auto-detects project type (Nextra vs standard Next.js)
+ */
+export async function generateSitemapData(
+  cwd: string,
+  config?: Partial<ContentConfig>
+): Promise<SitemapData> {
+  const projectType = detectProjectType(cwd);
+  const contentDir = path.join(cwd, config?.contentDir || 'content');
+  const appDir = path.join(cwd, config?.appDir || 'app');
+  const basePath = config?.basePath || '/docs';
+
+  let docsItems: SitemapItem[] = [];
+  let appItems: SitemapItem[] = [];
+
+  // Scan content/ for Nextra projects
+  if (projectType === 'nextra' && fs.existsSync(contentDir)) {
+    docsItems = await scanContent(contentDir, basePath);
+  }
+
+  // Scan app/ using routes scanner (universal)
+  if (fs.existsSync(appDir)) {
+    try {
+      const scanResult = scanRoutes({ appDir, includeApi: false });
+      appItems = routesToSitemapItems(scanResult.routes);
+    } catch {
+      // Fallback to simple scan if routes scanner fails
+      appItems = [];
+    }
+  }
+
+  return {
+    app: appItems,
+    docs: docsItems,
+  };
+}
+
+/**
+ * Generate TypeScript file content
+ */
+function generateTsContent(data: SitemapData): string {
+  return `
+// This file is auto-generated by @djangocfg/seo
+// Do not edit manually
+
+export interface SitemapItem {
+  title: string;
+  path: string;
+  children?: SitemapItem[];
+}
+
+export const sitemap: { app: SitemapItem[], docs: SitemapItem[] } = ${JSON.stringify(data, null, 2)};
+`;
+}
+
+/**
+ * Generate and save sitemap file
+ */
+export async function generateSitemap(
+  cwd: string,
+  options: {
+    output?: string;
+    config?: Partial<ContentConfig>;
+  } = {}
+): Promise<{ outputPath: string; data: SitemapData }> {
+  const output = options.output || 'app/_core/sitemap.ts';
+  const outputPath = path.join(cwd, output);
+
+  // Generate data
+  const data = await generateSitemapData(cwd, options.config);
+
+  // Ensure output directory exists
+  const outputDir = path.dirname(outputPath);
+  if (!fs.existsSync(outputDir)) {
+    fs.mkdirSync(outputDir, { recursive: true });
+  }
+
+  // Write file
+  const content = generateTsContent(data);
+  fs.writeFileSync(outputPath, content);
+
+  return { outputPath, data };
+}
+
+/**
+ * Flatten sitemap items to list of paths
+ */
+export function flattenSitemap(items: SitemapItem[]): string[] {
+  const paths: string[] = [];
+
+  function traverse(item: SitemapItem) {
+    paths.push(item.path);
+    if (item.children) {
+      for (const child of item.children) {
+        traverse(child);
+      }
+    }
+  }
+
+  for (const item of items) {
+    traverse(item);
+  }
+
+  return paths;
+}
+
+/**
+ * Count total items in sitemap
+ */
+export function countSitemapItems(data: SitemapData): { app: number; docs: number; total: number } {
+  const appPaths = flattenSitemap(data.app);
+  const docsPaths = flattenSitemap(data.docs);
+
+  return {
+    app: appPaths.length,
+    docs: docsPaths.length,
+    total: appPaths.length + docsPaths.length,
+  };
+}

package/src/content/types.ts

@@ -0,0 +1,140 @@
+/**
+ * Content module types for MDX/Nextra projects
+ */
+
+export interface ContentConfig {
+  /** Content directory path (default: 'content') */
+  contentDir: string;
+  /** App directory path (default: 'app') */
+  appDir: string;
+  /** Base URL path for docs (default: '/docs') */
+  basePath: string;
+  /** File extensions to scan (default: ['.mdx', '.md']) */
+  extensions: string[];
+  /** Asset extensions to ignore in links */
+  assetExtensions: string[];
+}
+
+export interface SitemapConfig {
+  /** Output file path (default: 'app/_core/sitemap.ts') */
+  output: string;
+  /** Include app pages in sitemap */
+  includeApp: boolean;
+  /** Include content pages in sitemap */
+  includeContent: boolean;
+}
+
+export interface SitemapItem {
+  title: string;
+  path: string;
+  children?: SitemapItem[];
+}
+
+export interface SitemapData {
+  app: SitemapItem[];
+  docs: SitemapItem[];
+}
+
+export interface FileInfo {
+  /** Full path to the file */
+  fullPath: string;
+  /** Path relative to content directory */
+  relativePath: string;
+  /** Whether this is an index file */
+  isIndex: boolean;
+  /** Parent folder path */
+  folder: string;
+  /** File name without extension */
+  name: string;
+}
+
+export type LinkType = 'absolute' | 'dotslash' | 'parent' | 'simple';
+
+export interface ExtractedLink {
+  /** Raw link as found in file */
+  raw: string;
+  /** Resolved absolute path */
+  resolved: string;
+  /** Type of link syntax */
+  type: LinkType;
+  /** Line number in file */
+  line: number;
+}
+
+export interface BrokenLink {
+  /** File containing the broken link */
+  file: string;
+  /** Full link path (e.g., /docs/path) */
+  link: string;
+  /** Link type */
+  type: LinkType;
+  /** Raw link text */
+  raw: string;
+  /** Line number */
+  line: number;
+}
+
+export interface LinkCheckResult {
+  /** Total files checked */
+  filesChecked: number;
+  /** Unique links checked */
+  uniqueLinks: number;
+  /** Broken links found */
+  brokenLinks: BrokenLink[];
+  /** All links are valid */
+  success: boolean;
+}
+
+export interface LinkFix {
+  /** Original link */
+  from: string;
+  /** Replacement link */
+  to: string;
+  /** Line number */
+  line: number;
+}
+
+export interface LinkFixResult {
+  /** File path */
+  file: string;
+  /** Full path to file */
+  fullPath: string;
+  /** Fixes applied/suggested */
+  fixes: LinkFix[];
+}
+
+export interface FixLinksResult {
+  /** Total changes made/suggested */
+  totalChanges: number;
+  /** Files with changes */
+  fileChanges: LinkFixResult[];
+  /** Whether fixes were applied */
+  applied: boolean;
+}
+
+export interface ContentScanResult {
+  /** Project type detected */
+  projectType: 'nextra' | 'nextjs' | 'unknown';
+  /** Content directory found */
+  hasContent: boolean;
+  /** App directory found */
+  hasApp: boolean;
+  /** MDX files found */
+  mdxFiles: string[];
+  /** Page files found in app/ */
+  pageFiles: string[];
+}
+
+export const DEFAULT_CONFIG: ContentConfig = {
+  contentDir: 'content',
+  appDir: 'app',
+  basePath: '/docs',
+  extensions: ['.mdx', '.md'],
+  assetExtensions: ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico', '.pdf', '.zip', '.tar', '.gz'],
+};
+
+export const DEFAULT_SITEMAP_CONFIG: SitemapConfig = {
+  output: 'app/_core/sitemap.ts',
+  includeApp: true,
+  includeContent: true,
+};