docs/utils/pages.ts

import indexJson from "@/index.json";
import {
    BOT_INVITE_REQUEST_URL,
    DISCORD_URL,
    DONATION_URL,
    SUPPORT_EMAIL_ADDRESS,
} from "./links";
import { toTitleCase } from "./utils";

export type DocsPage = {
    name: string;
    url?: string;
    children?: DocsPageWithoutChildren[];
};

export type DocsPageWithoutChildren = Omit<DocsPage, "children">;

export const pages = [
    {
        name: "Home",
        url: "/",
    },
    {
        name: "FAQ",
        url: "/faq",
    },
    {
        name: "Invite",
        url: BOT_INVITE_REQUEST_URL,
    },
    {
        name: "Support",
        url: SUPPORT_EMAIL_ADDRESS,
    },
    {
        name: "Donate",
        url: DONATION_URL,
    },
    {
        name: "Discord",
        url: DISCORD_URL,
    },
];

export function resolveDocsURL(url: string) {
    return url.startsWith("/") ? url : `/${url}`;
}

export type Index = {
    title?: string;
    description?: string;
    data: string;
};

let index: Index[] | null = null,
    lowercasedIndex: Index[] | null = null;

function loadIndex() {
    if (index !== null) {
        return;
    }

    index = indexJson;
    lowercasedIndex =
        index?.map(entry => ({
            data: entry.data.toLowerCase(),
            title: entry.title?.toLowerCase(),
            description: entry.description?.toLowerCase(),
        })) ?? null;
}

export const getIndex = (lower = false) => {
    if (!index) {
        loadIndex();
    }

    return lower ? lowercasedIndex! : index!;
};

let docsPages: DocsPage[] | null = null;

export const getDocsPages = () => {
    if (!docsPages) {
        loadDocsPages();
    }

    return docsPages!;
};

const excludedFromGrouping = ["features", "getting-started"];
const forceGrouping = ["extensions"];
const hoistedPages = [
    "getting-started",
    "features",
    "features/screenshots",
].map(a => `/${a}`);

function loadDocsPages() {
    if (docsPages) {
        return;
    }

    docsPages = [];

    const flattenedPages = indexJson.map(
        page =>
            ({
                name: page.short_name ?? "Unnamed",
                url: page.url,
            } satisfies DocsPageWithoutChildren),
    );
    const pages: Record<string, DocsPageWithoutChildren[]> = {};

    for (const page of flattenedPages) {
        const splitted = page.url.split("/");
        const [, firstDirectory] = splitted;

        const key =
            (forceGrouping.includes(firstDirectory) ||
                (!excludedFromGrouping.includes(firstDirectory) &&
                    firstDirectory !== "")) &&
            splitted.length > 3
                ? toTitleCase(firstDirectory)
                : "_";

        pages[key] ??= [];
        pages[key].push({
            name: page.name,
            url:
                page.url !== "/" && page.url.endsWith("/")
                    ? page.url.substring(0, page.url.length - 1)
                    : page.url,
        });
    }

    if (pages._) {
        docsPages?.push(
            ...pages._.sort(
                (a, b) => a.name.charCodeAt(0) - b.name.charCodeAt(0),
            ),
        );
    }

    for (const key in pages) {
        if (key === "_") {
            continue;
        }

        docsPages?.push({
            name: key,
            children: pages[key].sort(
                (a, b) => a.name.charCodeAt(0) - b.name.charCodeAt(0),
            ),
        });
    }

    docsPages.sort((a, b) => {
        const aIndex = hoistedPages.indexOf(a.url ?? "");
        const bIndex = hoistedPages.indexOf(b.url ?? "");

        if (a.url === "/") {
            return -1;
        }

        if (b.url === "/") {
            return 1;
        }

        if (aIndex !== -1 && bIndex !== -1) {
            return aIndex - bIndex;
        }

        if (aIndex !== -1) {
            return -1;
        }

        if (bIndex !== -1) {
            return 1;
        }

        return a.name.localeCompare(b.name);
    });
}
1	import indexJson from "@/index.json";
2	import {
3	BOT_INVITE_REQUEST_URL,
4	DISCORD_URL,
5	DONATION_URL,
6	SUPPORT_EMAIL_ADDRESS,
7	} from "./links";
8	import { toTitleCase } from "./utils";
9
10	export type DocsPage = {
11	name: string;
12	url?: string;
13	children?: DocsPageWithoutChildren[];
14	};
15
16	export type DocsPageWithoutChildren = Omit<DocsPage, "children">;
17
18	export const pages = [
19	{
20	name: "Home",
21	url: "/",
22	},
23	{
24	name: "FAQ",
25	url: "/faq",
26	},
27	{
28	name: "Invite",
29	url: BOT_INVITE_REQUEST_URL,
30	},
31	{
32	name: "Support",
33	url: SUPPORT_EMAIL_ADDRESS,
34	},
35	{
36	name: "Donate",
37	url: DONATION_URL,
38	},
39	{
40	name: "Discord",
41	url: DISCORD_URL,
42	},
43	];
44
45	export function resolveDocsURL(url: string) {
46	return url.startsWith("/") ? url : `/${url}`;
47	}
48
49	export type Index = {
50	title?: string;
51	description?: string;
52	data: string;
53	};
54
55	let index: Index[] \| null = null,
56	lowercasedIndex: Index[] \| null = null;
57
58	function loadIndex() {
59	if (index !== null) {
60	return;
61	}
62
63	index = indexJson;
64	lowercasedIndex =
65	index?.map(entry => ({
66	data: entry.data.toLowerCase(),
67	title: entry.title?.toLowerCase(),
68	description: entry.description?.toLowerCase(),
69	})) ?? null;
70	}
71
72	export const getIndex = (lower = false) => {
73	if (!index) {
74	loadIndex();
75	}
76
77	return lower ? lowercasedIndex! : index!;
78	};
79
80	let docsPages: DocsPage[] \| null = null;
81
82	export const getDocsPages = () => {
83	if (!docsPages) {
84	loadDocsPages();
85	}
86
87	return docsPages!;
88	};
89
90	const excludedFromGrouping = ["features", "getting-started"];
91	const forceGrouping = ["extensions"];
92	const hoistedPages = [
93	"getting-started",
94	"features",
95	"features/screenshots",
96	].map(a => `/${a}`);
97
98	function loadDocsPages() {
99	if (docsPages) {
100	return;
101	}
102
103	docsPages = [];
104
105	const flattenedPages = indexJson.map(
106	page =>
107	({
108	name: page.short_name ?? "Unnamed",
109	url: page.url,
110	} satisfies DocsPageWithoutChildren),
111	);
112	const pages: Record<string, DocsPageWithoutChildren[]> = {};
113
114	for (const page of flattenedPages) {
115	const splitted = page.url.split("/");
116	const [, firstDirectory] = splitted;
117
118	const key =
119	(forceGrouping.includes(firstDirectory) \|\|
120	(!excludedFromGrouping.includes(firstDirectory) &&
121	firstDirectory !== "")) &&
122	splitted.length > 3
123	? toTitleCase(firstDirectory)
124	: "_";
125
126	pages[key] ??= [];
127	pages[key].push({
128	name: page.name,
129	url:
130	page.url !== "/" && page.url.endsWith("/")
131	? page.url.substring(0, page.url.length - 1)
132	: page.url,
133	});
134	}
135
136	if (pages._) {
137	docsPages?.push(
138	...pages._.sort(
139	(a, b) => a.name.charCodeAt(0) - b.name.charCodeAt(0),
140	),
141	);
142	}
143
144	for (const key in pages) {
145	if (key === "_") {
146	continue;
147	}
148
149	docsPages?.push({
150	name: key,
151	children: pages[key].sort(
152	(a, b) => a.name.charCodeAt(0) - b.name.charCodeAt(0),
153	),
154	});
155	}
156
157	docsPages.sort((a, b) => {
158	const aIndex = hoistedPages.indexOf(a.url ?? "");
159	const bIndex = hoistedPages.indexOf(b.url ?? "");
160
161	if (a.url === "/") {
162	return -1;
163	}
164
165	if (b.url === "/") {
166	return 1;
167	}
168
169	if (aIndex !== -1 && bIndex !== -1) {
170	return aIndex - bIndex;
171	}
172
173	if (aIndex !== -1) {
174	return -1;
175	}
176
177	if (bIndex !== -1) {
178	return 1;
179	}
180
181	return a.name.localeCompare(b.name);
182	});
183	}