1
import { statSync } from "node:fs";
2
import { join } from "node:path";
3
import type { MetadataRoute } from "next";
4

5
import { getRegistryBaseUrl, source } from "@/lib/source";
6
import { Index } from "@/registry/__index__";
7

8
export const dynamic = "force-dynamic";
9

10
// feat: Get file modification date for better sitemap accuracy
11
function getFileLastModified(filePath: string): Date {
12
    try {
13
        const stats = statSync(filePath);
14
        return stats.mtime;
15
    } catch {
16
        return new Date();
17
    }
18
}
19

20
// feat: Validate URL format for sitemap
21
function isValidUrl(url: string): boolean {
22
    try {
23
        new URL(url);
24
        return true;
25
    } catch {
26
        return false;
27
    }
28
}
29

30
// feat: Generate sitemap data for Next.js App Router with enhanced error handling
31
function generateSitemapData(): MetadataRoute.Sitemap {
32
    const baseUrl = getRegistryBaseUrl();
33

34
    // feat: Validate base URL
35
    if (!isValidUrl(baseUrl)) {
36
        console.error("Invalid base URL for sitemap:", baseUrl);
37
        return [];
38
    }
39

40
    const sitemap: MetadataRoute.Sitemap = [];
41

42
    // Add homepage with validation
43
    const homepageUrl = `${baseUrl}/`;
44
    if (isValidUrl(homepageUrl)) {
45
        sitemap.push({
46
            url: homepageUrl,
47
            lastModified: new Date(),
48
            changeFrequency: "weekly",
49
            priority: 1,
50
        });
51
    }
52

53
    // Add documentation pages with enhanced error handling
54
    try {
55
        const pages = source.getPages();
56
        if (Array.isArray(pages)) {
57
            pages.forEach((page) => {
58
                if (!page?.url) return;
59

60
                // feat: Try to get actual file modification date
61
                let lastModified = new Date();
62
                if (page.data?.lastModified) {
63
                    try {
64
                        lastModified = new Date(page.data.lastModified);
65
                        // Validate date
66
                        if (Number.isNaN(lastModified.getTime())) {
67
                            lastModified = new Date();
68
                        }
69
                    } catch {
70
                        lastModified = new Date();
71
                    }
72
                } else {
73
                    // Try to get file modification date from content directory
74
                    try {
75
                        const contentPath = join(
76
                            process.cwd(),
77
                            "content",
78
                            "docs",
79
                            `${page.url.replace("/docs/", "")}.mdx`,
80
                        );
81
                        lastModified = getFileLastModified(contentPath);
82
                    } catch {
83
                        // Fallback to current date
84
                        lastModified = new Date();
85
                    }
86
                }
87

88
                const pageUrl = `${baseUrl}${page.url}`;
89
                if (isValidUrl(pageUrl)) {
90
                    sitemap.push({
91
                        url: pageUrl,
92
                        lastModified,
93
                        changeFrequency: "monthly",
94
                        priority: 0.9,
95
                    });
96
                }
97
            });
98
        }
99
    } catch (error) {
100
        console.warn("Error generating sitemap for pages:", error);
101
    }
102

103
    // Add component registry JSON files with validation
104
    try {
105
        if (Index && typeof Index === "object") {
106
            Object.keys(Index).forEach((componentName) => {
107
                if (componentName.endsWith("-demo") || !componentName) return;
108

109
                // feat: Component registry JSON file with proper modification date
110
                const componentPath = join(
111
                    process.cwd(),
112
                    "public",
113
                    "r",
114
                    `${componentName}.json`,
115
                );
116
                const lastModified = getFileLastModified(componentPath);
117

118
                const componentUrl = `${baseUrl}/r/${componentName}.json`;
119
                if (isValidUrl(componentUrl)) {
120
                    sitemap.push({
121
                        url: componentUrl,
122
                        lastModified,
123
                        changeFrequency: "monthly",
124
                        priority: 0.6,
125
                    });
126
                }
127
            });
128
        }
129
    } catch (error) {
130
        console.warn("Error generating sitemap for components:", error);
131
    }
132

133
    // Add API endpoints and other important pages with validation
134
    const additionalUrls = [
135
        {
136
            url: `${baseUrl}/api/search`,
137
            changeFrequency: "weekly" as const,
138
            priority: 0.7,
139
        },
140
        {
141
            url: `${baseUrl}/llms-full.txt`,
142
            changeFrequency: "weekly" as const,
143
            priority: 0.8,
144
        },
145
    ];
146

147
    additionalUrls.forEach(({ url, changeFrequency, priority }) => {
148
        if (isValidUrl(url)) {
149
            sitemap.push({
150
                url,
151
                lastModified: new Date(),
152
                changeFrequency,
153
                priority,
154
            });
155
        }
156
    });
157

158
    return sitemap;
159
}
160

161
// feat: Export sitemap function for Next.js App Router
162
export default function sitemap(): MetadataRoute.Sitemap {
163
    return generateSitemapData();
164
}
165