sidebars.ts

// [<] i think this code could be cleaner but then again my expertise
// [<] isn't JS/TS so im sorry if this triggers anyone or something

import fs from 'node:fs';
import path from 'node:path';

interface ApiNode {
	name: string,
	children: Record<string, ApiNode>,
	docId: string | null,
	_cachedItems?: SidebarItem[]
}

interface CategoryItem {
	type: 'category',
	label: string,
	collapsed: boolean,
	link?: { type: 'doc', id: string },
	items: SidebarItem[]
}

type SidebarItem = string | CategoryItem;

function frameworkSortKey(fw: string): { tier: number; value: number; } {
	const version = fw.slice(3); // [i] we couldn't care less about the "net" part

	if (version.includes('.')) {
		// [i] just a float conversion
		return { tier: 0, value: Number.parseFloat(version) || 0 };
	}

	// [i] we treat PATCH as part of MINOR
	const major = version.slice(0, 1);
	const rest = version.slice(1);
	return { tier: 1, value: Number.parseFloat(`${major}.${rest}`) };
}

function compareFrameworks(a: string, b: string) {
	const ka = frameworkSortKey(a);
	const kb = frameworkSortKey(b);

	if (ka.tier !== kb.tier)
		return ka.tier - kb.tier;

	return kb.value - ka.value;
}

function compareStrings(a: string, b: string): number {
	if (a < b) return -1;
	if (a > b) return 1;
	return 0;
}

function generateApiSidebar(): CategoryItem[] {
	const apiDir = path.resolve(__dirname, 'docs/api');
	if (!fs.existsSync(apiDir)) return [];

	const frameworks = fs
		.readdirSync(apiDir, { withFileTypes: true })
		.filter(d => d.isDirectory())
		.map(d => d.name)
		.sort(compareFrameworks);

	const results: CategoryItem[] = [];

	for (const fw of frameworks) {
		const fwDir = path.join(apiDir, fw);
		if (!fs.existsSync(fwDir)) continue;

		const files = fs
			.readdirSync(fwDir)
			.filter(f => f.endsWith('.md'))
			.map(f => f.replace(/\.md$/, ''));

		const root = buildNamespaceTree(files, fw);
		const assemblyNode = findAssemblyRoot(root);

		const category: CategoryItem = {
			type: 'category',
			label: formatFrameworkLabel(fw),
			collapsed: fw !== frameworks[0],
			link: assemblyNode.docId ? { type: 'doc', id: assemblyNode.docId } : undefined,
			items: childrenToItems(assemblyNode)
		}

		results.push(category);
	};

	return results;
}

function buildNamespaceTree(files: string[], fw: string) {
	const root: ApiNode = {
		name: '',
		children: Object.create(null) as Record<string, ApiNode>,
		docId: null
	};

	for (const fileName of files) {
		const parts = fileName.split('.');
		let node = root;

		for (const part of parts) {
			if (!node.children[part]) {
				node.children[part] = {
					name: part,
					children: Object.create(null) as Record<string, ApiNode>,
					docId: null,
				};
			}
			node = node.children[part];
		}

		node.docId = `api/${fw}/${fileName}`;
	}

	return root;
}

function findAssemblyRoot(root: ApiNode): ApiNode {
	let node = root;
	while (true) {
		const keys = Object.keys(node.children);
		if (keys.length !== 1) break;
		node = node.children[keys[0]];
	}
	return node;
}

function childrenToItems(node: ApiNode): SidebarItem[] {
	if (node._cachedItems) return node._cachedItems;

	const keys = Object.keys(node.children).sort(compareStrings);
	const categoryItems: CategoryItem[] = [];
	const typeItems: string[] = [];

	for (const key of keys) {
		const child = node.children[key];

		const hasChildren = Object.keys(child.children).length > 0;

		if (hasChildren) {
			const items = childrenToItems(child);
			if (items.length > 0 || child.docId) {
				categoryItems.push({
					type: 'category',
					label: child.name,
					collapsed: true,
					link: child.docId ? { type: 'doc', id: child.docId } : undefined,
					items,
				});
			} else {
				console.warn('Skipping empty category for', child.name);
			}
		} else if (child.docId != null) {
			typeItems.push(child.docId);
		}
	}

	const result: SidebarItem[] = [...categoryItems, ...typeItems];
	node._cachedItems = result;
	return result;
}

function formatFrameworkLabel(fw: string) {
	if (!fw.startsWith('net'))
		return fw;

	const version = fw.slice(3); // [i] ignore the net prefix ofc

	if (version.includes('.'))
		return `.NET ${version}`;

	return `.NET Framework ${version.split('').join('.')}`;
}

const sidebars = {
	bindingSidebar: [{ type: 'autogenerated', dirName: 'bindings' }],
	tutorialSidebar: [{ type: 'autogenerated', dirName: 'tutorials' }],
	languageSidebar: [{ type: 'autogenerated', dirName: 'language' }],
	nativeSidebar: [{ type: 'autogenerated', dirName: 'native' }],
	toolSidebar: [{ type: 'autogenerated', dirName: 'tools' }],
	apiSidebar: generateApiSidebar()
};

export default sidebars;