@lonik/prestige 0.0.0

package/dist/vite.js

@@ -0,0 +1,685 @@
+import { join, parse, relative } from "pathe";
+import picomatch from "picomatch";
+import { z } from "zod";
+import { mkdir, readFile, readdir, stat, unlink, writeFile } from "node:fs/promises";
+import { genArrayFromRaw, genObjectFromValues } from "knitwork";
+import { compile } from "@mdx-js/mdx";
+import rehypeShiki from "@shikijs/rehype";
+import rehypeSlug from "rehype-slug";
+import remarkFlexibleToc from "remark-flexible-toc";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkGfm from "remark-gfm";
+import remarkDirective from "remark-directive";
+import { matter } from "vfile-matter";
+import { visit } from "unist-util-visit";
+import { h } from "hastscript";
+import { basename, join as join$1 } from "node:path";
+import { createLogger } from "vite";
+import { pathToFileURL } from "node:url";
+import { glob } from "tinyglobby";
+import { read } from "to-vfile";
+
+//#region src/vite/utils/errors.ts
+var PrestigeError = class extends Error {};
+/**
+* Parse data with zod schema and if fails throw PrestigeError that is friendly error
+* for prestige ecosystem
+*/
+function parseWithFriendlyErrors(s, input, message) {
+	try {
+		return s.parse(input);
+	} catch (e) {
+		if (e instanceof Error) throw new PrestigeError(`Prestige error cause: ${message}, with error: ${e.message} `);
+		else throw new PrestigeError(`Prestige error cause: ${message} `);
+	}
+}
+
+//#endregion
+//#region src/vite/core/content/content.types.ts
+const ContentFrontmatterSchema = z.object({
+	title: z.string().describe("The title of the article"),
+	description: z.string().optional().describe("The description of the article"),
+	label: z.string().optional().describe("The label of the content")
+});
+const ContentSchema = z.object({
+	matter: ContentFrontmatterSchema,
+	html: z.string().describe("The html of the content")
+});
+const InternalCollectionLinkSchema = z.union([z.object({
+	label: z.string(),
+	slug: z.string()
+}), z.string()]);
+const ExternalCollectionLinkSchema = z.object({
+	label: z.string(),
+	link: z.string()
+});
+const CollectionGroupSchema = z.object({
+	label: z.string(),
+	items: z.lazy(() => z.array(CollectionItemSchema)).optional(),
+	collapsible: z.boolean().optional(),
+	autogenerate: z.object({ directory: z.string() }).optional()
+});
+const CollectionItemSchema = z.union([
+	ExternalCollectionLinkSchema,
+	InternalCollectionLinkSchema,
+	z.lazy(() => CollectionGroupSchema)
+]);
+const CollectionSchema = z.object({
+	id: z.string().min(1, { message: "Folder name cannot be empty" }).max(50, { message: "Folder name too long" }).regex(/^[a-zA-Z0-9-_]+$/, { message: "Only alphanumeric, hyphens, and underscores allowed" }).describe("The id of the collection, must match the folder name"),
+	items: z.array(CollectionItemSchema),
+	label: z.string().optional().describe("The label of the collection"),
+	defaultLink: z.string().optional().describe("The default link of the collection")
+});
+const CollectionsSchema = z.array(CollectionSchema);
+
+//#endregion
+//#region src/vite/config/config.types.ts
+const PrestigeConfigSchema = z.object({
+	title: z.string().describe("Title of the website"),
+	github: z.string().optional().describe("Github repo"),
+	algolia: z.object({
+		appId: z.string().describe("Algolia app id"),
+		apiKey: z.string().describe("Algolia api key"),
+		indices: z.array(z.string()).describe("Algolia indices")
+	}).optional().describe("Algolia options"),
+	license: z.object({
+		label: z.string().describe("License label"),
+		url: z.string().describe("License url")
+	}).optional().describe("License options"),
+	collections: CollectionsSchema,
+	markdown: z.object({
+		shikiOptions: z.custom().optional().describe("Options for Shiki syntax highlighting"),
+		gfmOptions: z.custom().optional().describe("Options for remark-gfm"),
+		rehypePlugins: z.custom().optional().describe("Additional rehype plugins"),
+		remarkPlugins: z.custom().optional().describe("Additional remark plugins"),
+		remarkFlexibleToc: z.custom().optional().describe("Options for remark-flexible-toc"),
+		rehypeSlug: z.custom().optional().describe("Options for rehype-slug")
+	}).optional().describe("Markdown options, configure how markdown is parsed")
+});
+
+//#endregion
+//#region src/vite/utils/file-utils.ts
+async function pathExists(path) {
+	try {
+		await stat(path);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function extractVirtualId(fullId, virtualPrefix) {
+	const startIndex = fullId.indexOf(virtualPrefix);
+	if (startIndex !== -1) return "\0" + fullId.slice(startIndex);
+	return null;
+}
+
+//#endregion
+//#region src/vite/config/config.ts
+function validateConfig(config) {
+	return parseWithFriendlyErrors(PrestigeConfigSchema, config, "Invalid schema");
+}
+async function resolvePrestigeConfig(configInput, root) {
+	if (!configInput) throw new PrestigeError("Prestige config is required");
+	const validatedConfig = validateConfig(configInput);
+	const docsDirPath = join(root, "src/content");
+	if (!await pathExists(docsDirPath)) throw new PrestigeError(`Docs! directory not found: ${docsDirPath}`);
+	return {
+		config: validatedConfig,
+		fullDocsDir: docsDirPath
+	};
+}
+
+//#endregion
+//#region src/vite/content/content-compiler.ts
+function remarkAdmonitions() {
+	return (tree) => {
+		visit(tree, (node) => {
+			if (node.type === "textDirective" || node.type === "leafDirective" || node.type === "containerDirective") {
+				if (node.type !== "containerDirective") {
+					const data$1 = node.data || (node.data = {});
+					const hast = h(node.type === "textDirective" ? "span" : "aside", {
+						className: ["admonition", `admonition-${node.name}`],
+						...node.attributes
+					});
+					data$1.hName = hast.tagName;
+					data$1.hProperties = hast.properties;
+					return;
+				}
+				const type = [
+					"note",
+					"tip",
+					"caution",
+					"danger"
+				].includes(node.name) ? node.name : "note";
+				const typeMap = {
+					note: "bg-blue-50/50 dark:bg-blue-900/20 border-blue-500 text-blue-900 dark:text-blue-200",
+					tip: "bg-purple-50/50 dark:bg-purple-900/20 border-purple-500 text-purple-900 dark:text-purple-200",
+					caution: "bg-yellow-50/50 dark:bg-yellow-900/20 border-yellow-500 text-yellow-900 dark:text-yellow-200",
+					danger: "bg-red-50/50 dark:bg-red-900/20 border-red-500 text-red-900 dark:text-red-200"
+				};
+				const data = node.data || (node.data = {});
+				data.hName = "aside";
+				data.hProperties = {
+					"aria-label": type.charAt(0).toUpperCase() + type.slice(1),
+					className: [
+						"relative",
+						"my-6",
+						"px-4",
+						"py-3",
+						"border-l-4",
+						"rounded-lg",
+						...(typeMap[type] || typeMap["note"]).split(" ")
+					],
+					...node.attributes
+				};
+				let titleNodeIndex = node.children.findIndex((c) => c.data?.directiveLabel);
+				let titleChildren;
+				if (titleNodeIndex !== -1) {
+					titleChildren = node.children[titleNodeIndex].children;
+					node.children.splice(titleNodeIndex, 1);
+				} else titleChildren = [{
+					type: "text",
+					value: type.charAt(0).toUpperCase() + type.slice(1)
+				}];
+				const getIconHast = (t) => {
+					const props = {
+						xmlns: "http://www.w3.org/2000/svg",
+						width: "24",
+						height: "24",
+						viewBox: "0 0 24 24",
+						fill: "none",
+						stroke: "currentColor",
+						strokeWidth: "2",
+						strokeLinecap: "round",
+						strokeLinejoin: "round",
+						className: [
+							"w-5",
+							"h-5",
+							"flex-shrink-0"
+						]
+					};
+					if (t === "note") return h("svg", props, [
+						h("circle", {
+							cx: "12",
+							cy: "12",
+							r: "10"
+						}),
+						h("path", { d: "M12 16v-4" }),
+						h("path", { d: "M12 8h.01" })
+					]);
+					if (t === "tip") return h("svg", props, [
+						h("path", { d: "M4.5 16.5c-1.5 1.26-2 5-2 5s3.74-.5 5-2c.71-.84.7-2.13-.09-2.91a2.18 2.18 0 0 0-2.91-.09z" }),
+						h("path", { d: "m12 15-3-3a22 22 0 0 1 2-3.95A12.88 12.88 0 0 1 22 2c0 2.72-.78 7.5-6 11a22.35 22.35 0 0 1-4 2z" }),
+						h("path", { d: "M9 12H4s.55-3.03 2-4c1.62-1.08 5 0 5 0" }),
+						h("path", { d: "M12 15v5s3.03-.55 4-2c1.08-1.62 0-5 0-5" })
+					]);
+					if (t === "caution") return h("svg", props, [
+						h("path", { d: "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3Z" }),
+						h("path", { d: "M12 9v4" }),
+						h("path", { d: "M12 17h.01" })
+					]);
+					if (t === "danger") return h("svg", props, [
+						h("polygon", { points: "7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2" }),
+						h("path", { d: "M12 8v4" }),
+						h("path", { d: "M12 16h.01" })
+					]);
+					return null;
+				};
+				node.children = [{
+					type: "paragraph",
+					data: {
+						hName: "p",
+						hProperties: { className: [
+							"flex",
+							"items-center",
+							"gap-2",
+							"mb-2",
+							"mt-0",
+							"font-bold",
+							"text-lg"
+						] }
+					},
+					children: [{
+						type: "text",
+						value: "",
+						data: {
+							hName: "span",
+							hChildren: [getIconHast(type)]
+						}
+					}, ...titleChildren]
+				}, {
+					type: "paragraph",
+					data: {
+						hName: "section",
+						hProperties: { className: [
+							"[&>p]:mt-0",
+							"[&>p]:mb-2",
+							"[&>p:last-child]:mb-0",
+							"text-sm"
+						] }
+					},
+					children: node.children
+				}];
+			}
+		});
+	};
+}
+async function compileMarkdown(content, baseUrl, options) {
+	const toc = [];
+	const shikiOptions = {
+		themes: {
+			light: "github-light",
+			dark: "github-dark"
+		},
+		...options?.shikiOptions
+	};
+	const code = await compile(content, {
+		outputFormat: "program",
+		rehypePlugins: [
+			...options?.rehypePlugins ?? [],
+			[rehypeShiki, shikiOptions],
+			rehypeSlug
+		],
+		remarkPlugins: [
+			...options?.remarkPlugins ?? [],
+			remarkFrontmatter,
+			[remarkGfm, options?.gfmOptions || {}],
+			remarkDirective,
+			remarkAdmonitions,
+			[remarkFlexibleToc, { tocRef: toc }]
+		],
+		baseUrl
+	});
+	return {
+		code: String(code),
+		toc
+	};
+}
+async function compileFrontmatter(vFile) {
+	matter(vFile, { strip: true });
+	return vFile.data["matter"] || {};
+}
+function warmupCompiler(options) {
+	compileMarkdown("```js\n```", "http://localhost", options).catch(() => {});
+}
+
+//#endregion
+//#region src/vite/content/content-links.ts
+function resolveContentInternalLinks(sidebars) {
+	const links = /* @__PURE__ */ new Map();
+	for (const [key, sidebar] of sidebars) {
+		const sidebarLinks = [];
+		for (const item of sidebar.items) processItem$1(item, sidebarLinks);
+		links.set(key, sidebarLinks);
+	}
+	return links;
+}
+function processItem$1(item, links = []) {
+	if ("slug" in item) links.push(item);
+	else if ("items" in item) for (const childItem of item.items) processItem$1(childItem, links);
+	return links;
+}
+
+//#endregion
+//#region src/vite/utils/logger.ts
+const logger = createLogger(void 0, { prefix: "[Prestige]" });
+var logger_default = logger;
+
+//#endregion
+//#region src/vite/content/content.store.ts
+const CONTENT_VIRTUAL_ID = "virtual:prestige/content/";
+function resolveSiblings(base, slug, linksMap) {
+	const links = linksMap.get(base);
+	if (!links?.length) return {
+		prev: void 0,
+		next: void 0
+	};
+	const linkIndex = links.filter((l) => "slug" in l).findIndex((link) => link.slug === slug);
+	let prev;
+	let next;
+	if (linkIndex > 0) prev = links[linkIndex - 1];
+	if (linkIndex < links.length - 1) next = links[linkIndex + 1];
+	return {
+		prev,
+		next
+	};
+}
+async function resolveMarkdown(slug, contentDir) {
+	const filePath = await getPathBySlug(slug, contentDir);
+	const baseUrl = pathToFileURL(filePath).href;
+	const file = await read(filePath);
+	const frontmatter = await compileFrontmatter(file);
+	const { code, toc } = await compileMarkdown(file, baseUrl);
+	return {
+		code,
+		toc,
+		frontmatter
+	};
+}
+async function resolveContent(id, linksMap, contentDir) {
+	const slug = id.replace(CONTENT_VIRTUAL_ID, "").replace("\0", "");
+	const base = slug.split("/")[0];
+	const { prev, next } = resolveSiblings(base, slug, linksMap);
+	const { toc, code, frontmatter } = await resolveMarkdown(slug, contentDir);
+	let resolvedCode = code;
+	resolvedCode += `\n export const toc = ${JSON.stringify(toc)}\n`;
+	resolvedCode += `\n export const prev = ${JSON.stringify(prev)}\n`;
+	resolvedCode += `\n export const next = ${JSON.stringify(next)}\n`;
+	resolvedCode += `\n export const frontmatter = ${JSON.stringify(frontmatter)}\n`;
+	return resolvedCode;
+}
+async function getPathBySlug(slug, contentDir) {
+	const pathMatch = join$1(contentDir, slug);
+	const matches = await glob(`${pathMatch}.{md,mdx}`);
+	if (matches.length === 0) throw new PrestigeError(`[Prestige] Could not find markdown file for slug: "${slug}". Searched at: ${pathMatch}.{md,mdx}. If you want to link to a custom page, use 'link: "${slug}"' instead of 'slug: "${slug}"' in your collection config.`);
+	return matches[0];
+}
+async function getFileBySlug(slug, contentDir) {
+	return await read(await getPathBySlug(slug, contentDir));
+}
+function getSlugByPath(path, contentDir) {
+	const pathInfo = parse(relative(contentDir, path));
+	return join$1(pathInfo.dir, pathInfo.name);
+}
+
+//#endregion
+//#region src/vite/content/content-sidebar.store.ts
+const SIDEBAR_VIRTUAL_ID = "virtual:prestige/sidebar/";
+function resolveDefaultLink(items, defaultLink) {
+	if (defaultLink) return defaultLink;
+	for (const item of items) if ("slug" in item) return item.slug;
+	else if ("link" in item) return item.link;
+	else if ("items" in item && item.items.length > 0) {
+		const link = resolveDefaultLink(item.items);
+		if (link) return link;
+	}
+}
+async function resolveSidebars(collections, contentDir) {
+	const store = /* @__PURE__ */ new Map();
+	for (const collection of collections) {
+		const sidebar = await processCollection(collection, contentDir);
+		store.set(collection.id, sidebar);
+	}
+	return store;
+}
+/** @visibleForTesting */
+async function processCollection(collection, contentDir) {
+	const items = [];
+	for (const item of collection.items) items.push(await processItem(item, contentDir));
+	const defaultLink = resolveDefaultLink(items, collection.defaultLink);
+	if (!defaultLink) throw new PrestigeError(`No default link found in collection, it means there are no links in the collection. Please define one in ${collection.id}`);
+	return {
+		items,
+		defaultLink
+	};
+}
+/** @visibleForTesting */
+async function processItem(item, contentDir) {
+	if (typeof item === "string" || "slug" in item) return resolveInternalSidebarLink(item, contentDir);
+	else if ("link" in item) return resolveSidebarLink(item, contentDir);
+	else return resolveSidebarGroup(item, contentDir);
+}
+/** @visibleForTesting */
+async function resolveSidebarGroup(group, contentDir) {
+	const label = await resolveLabel(group, contentDir);
+	const items = [];
+	if (group.items?.length && group.autogenerate) logger_default.warn(`${group.label} has both items and autogenerate. Only items will be used.`);
+	if (group.items) for (const childItem of group.items) items.push(await processItem(childItem, contentDir));
+	else if (group.autogenerate?.directory) {
+		const generatedItems = await autogenerateSidebar(group.autogenerate.directory, contentDir);
+		items.push(...generatedItems);
+	}
+	return {
+		label,
+		collapsible: group.collapsible,
+		items
+	};
+}
+/** @visibleForTesting */
+async function resolveInternalSidebarLink(item, contentDir) {
+	const label = await resolveLabel(item, contentDir);
+	const slug = resolveSlug(item);
+	if (slug.startsWith("/") || slug.endsWith("/")) throw new PrestigeError(`The slug ${slug} cannot start or end with a slash. Remove it and try again.`);
+	if (!slug) throw new PrestigeError(`The slug cannot be empty. Remove it and try again. link label is ${label}`);
+	return {
+		label,
+		slug
+	};
+}
+/** @visibleForTesting */
+async function resolveSidebarLink(item, contentDir) {
+	const label = await resolveLabel(item, contentDir);
+	const link = resolveLink(item);
+	if (!link) throw new PrestigeError(`The link cannot be empty. Remove it and try again. link label is ${label}`);
+	return {
+		label,
+		link
+	};
+}
+/** @visibleForTesting */
+async function autogenerateSidebar(directory, contentDir) {
+	const fileExtRegex = /\.mdx?$/i;
+	const items = [];
+	const dirPath = join(contentDir, directory);
+	if (!await pathExists(dirPath)) {
+		logger_default.warn(`Directory doesn't exist: ${directory}`);
+		return [];
+	}
+	const dirents = await readdir(dirPath, { withFileTypes: true });
+	dirents.sort((a, b) => a.name.localeCompare(b.name));
+	for (const dirent of dirents) if (dirent.isDirectory()) {
+		const subDir = join(directory, dirent.name);
+		const group = {
+			label: dirent.name,
+			autogenerate: { directory: subDir }
+		};
+		items.push(await resolveSidebarGroup(group, contentDir));
+	} else if (dirent.isFile() && fileExtRegex.test(dirent.name)) {
+		const slug = join(directory, dirent.name).replace(fileExtRegex, "");
+		items.push(await resolveInternalSidebarLink(slug, contentDir));
+	}
+	return items;
+}
+/** @visibleForTesting */
+async function resolveLabel(item, contentDir) {
+	if (typeof item !== "string" && "label" in item && item.label) return item.label;
+	if (typeof item === "string" || "slug" in item) {
+		const slug = resolveSlug(item);
+		const file = await getFileBySlug(slug, contentDir);
+		if (!file) throw new PrestigeError(`markdown file not found with slug: ${slug} add one in content folder or update config`);
+		const data = await compileFrontmatter(file);
+		if (data?.label) return data?.label;
+		return basename(slug);
+	}
+	if (typeof item !== "string" && ("items" in item || "autogenerate" in item)) return item.label;
+	return "";
+}
+/** @visibleForTesting */
+function resolveSlug(item) {
+	if (typeof item === "string") return item;
+	else {
+		if ("slug" in item) return item.slug;
+		return "";
+	}
+}
+/** @visibleForTesting */
+function resolveLink(item) {
+	if (typeof item === "object" && "link" in item) return item.link;
+	return "";
+}
+
+//#endregion
+//#region src/vite/content/router-compiler.ts
+async function compileRoutes(linksMap, routesDir) {
+	const prestigeFullPath = join$1(routesDir, "(prestige)");
+	try {
+		await mkdir(prestigeFullPath, { recursive: true });
+		const generatedFiles = /* @__PURE__ */ new Map();
+		for (const [key, links] of linksMap) {
+			const onlyInternalLinks = links.filter((l) => "slug" in l);
+			const sidebarFile = key + ".lazy.tsx";
+			generatedFiles.set(sidebarFile, createLayoutRoute(key));
+			for (const l of onlyInternalLinks) {
+				const pathified = l.slug.replaceAll("/", ".") + ".lazy.tsx";
+				generatedFiles.set(pathified, createContentRoute(l.slug));
+			}
+		}
+		await Promise.all([...generatedFiles.entries()].map(async ([fileName, contents]) => {
+			const filePath = join$1(prestigeFullPath, fileName);
+			try {
+				if (await readFile(filePath, "utf-8") === contents) return;
+			} catch (e) {}
+			logger_default.info(`Writing route file: ${fileName}`, { timestamp: true });
+			return writeFile(filePath, contents);
+		}));
+		const staleFiles = (await readdir(prestigeFullPath)).filter((fileName) => fileName.endsWith(".lazy.tsx") && !generatedFiles.has(fileName));
+		await Promise.all(staleFiles.map((fileName) => {
+			logger_default.info(`Removing stale route file: ${fileName}`, { timestamp: true });
+			return unlink(join$1(prestigeFullPath, fileName));
+		}));
+	} catch (error) {
+		logger_default.error(`[Prestige Router Compiler] Failed to compile routes: ${error}`, { timestamp: true });
+		console.error("[Prestige Router Compiler] Failed to compile routes:", error);
+	}
+}
+function createLayoutRoute(id) {
+	return `
+import { createLazyFileRoute } from '@tanstack/react-router';
+import sidebar from "virtual:prestige/sidebar/${id}";
+import { CollectionRoute } from "@lonik/prestige/ui";
+
+export const Route = createLazyFileRoute('/(prestige)/${id}')(CollectionRoute(sidebar, "${id}"));
+`.trim() + "\n";
+}
+function createContentRoute(slug) {
+	return `
+import { createLazyFileRoute } from "@tanstack/react-router";
+import * as contentData from "virtual:prestige/content/${slug}";
+import { ContentRoute } from "@lonik/prestige/ui";
+
+export const Route = createLazyFileRoute('/(prestige)/${slug}')(ContentRoute(contentData));
+`.trim() + "\n";
+}
+
+//#endregion
+//#region src/vite/utils/code-generation.ts
+function genExportDefault(specifier) {
+	return `export default ${specifier};`;
+}
+/** exports default undefined */
+function genExportUndefined() {
+	return genExportDefault("undefined");
+}
+
+//#endregion
+//#region src/vite/core/content/content-collection.store.ts
+const COLLECTION_VIRTUAL_ID = "virtual:prestige/collection-all";
+function resolveCollectionNavigations(inlineCollections, linksMap) {
+	const collections = inlineCollections.map((c) => ({
+		id: c.id,
+		label: c.label ?? c.id,
+		defaultLink: c.defaultLink ?? ""
+	}));
+	if (collections.length === 0) throw new PrestigeError(`No collections found, add one in prestige plugin config`);
+	for (const coll of collections) {
+		const firstLink = linksMap.get(coll.id)?.[0];
+		if (coll.defaultLink || !firstLink) continue;
+		coll.defaultLink = firstLink.slug;
+	}
+	for (const coll of collections) if (!coll.defaultLink) console.warn(`No default link found for collection ${coll.id}, it won't be displayed in the header navigation`);
+	return genExportDefault(genArrayFromRaw(collections.filter((c) => c.defaultLink).map((c) => genObjectFromValues(c))));
+}
+
+//#endregion
+//#region src/vite/plugin.ts
+const CONFIG_VIRTUAL_ID = "virtual:prestige/config";
+function prestige(inlineConfig) {
+	let config;
+	let contentDir;
+	let isDocsMatcher;
+	let collections = [];
+	let internalLinksMap;
+	let collectionNavigations;
+	let sidebarsMap;
+	return {
+		name: "vite-plugin-prestige",
+		enforce: "pre",
+		async configResolved(resolvedConfig) {
+			logger_default.info("Resolving Prestige configuration...", { timestamp: true });
+			const { config: loadedConfig } = await resolvePrestigeConfig(inlineConfig, resolvedConfig.root);
+			config = loadedConfig;
+			contentDir = join(resolvedConfig.root, "src/content");
+			isDocsMatcher = picomatch(join(contentDir, "**/*.{md,mdx}"));
+			collections = config.collections ?? [];
+			logger_default.info("Resolving sidebars...", { timestamp: true });
+			sidebarsMap = await resolveSidebars(collections, contentDir);
+			logger_default.info("Resolving content links...", { timestamp: true });
+			internalLinksMap = resolveContentInternalLinks(sidebarsMap);
+			logger_default.info("Resolving collection navigations...", { timestamp: true });
+			collectionNavigations = resolveCollectionNavigations(collections, internalLinksMap);
+			const routesDir = join(resolvedConfig.root, "src", "routes");
+			logger_default.info("Compiling routes...", { timestamp: true });
+			await compileRoutes(internalLinksMap, routesDir);
+			logger_default.info("Warming up compiler...", { timestamp: true });
+			warmupCompiler(config.markdown);
+		},
+		resolveId(id) {
+			if (id.includes(CONFIG_VIRTUAL_ID)) {
+				logger_default.info(`Resolving config virtual ID: ${id}`, { timestamp: true });
+				return extractVirtualId(id, CONFIG_VIRTUAL_ID);
+			}
+			if (id.includes(CONTENT_VIRTUAL_ID)) {
+				logger_default.info(`Resolving content virtual ID: ${id}`, { timestamp: true });
+				return extractVirtualId(id, CONTENT_VIRTUAL_ID);
+			}
+			if (id.includes(COLLECTION_VIRTUAL_ID)) {
+				logger_default.info(`Resolving collection virtual ID: ${id}`, { timestamp: true });
+				return extractVirtualId(id, COLLECTION_VIRTUAL_ID);
+			}
+			if (id.includes(SIDEBAR_VIRTUAL_ID)) {
+				logger_default.info(`Resolving sidebar virtual ID: ${id}`, { timestamp: true });
+				return extractVirtualId(id, SIDEBAR_VIRTUAL_ID);
+			}
+			return null;
+		},
+		async load(id) {
+			if (id === `\0${CONFIG_VIRTUAL_ID}`) {
+				logger_default.info(`Loading config virtual module: ${id}`, { timestamp: true });
+				return genExportDefault(JSON.stringify(config));
+			}
+			if (id.includes(CONTENT_VIRTUAL_ID)) {
+				logger_default.info(`Loading content virtual module: ${id}`, { timestamp: true });
+				return await resolveContent(id, internalLinksMap, contentDir);
+			}
+			if (id.includes(COLLECTION_VIRTUAL_ID)) {
+				logger_default.info(`Loading collection virtual module: ${id}`, { timestamp: true });
+				return collectionNavigations;
+			}
+			if (id.includes(SIDEBAR_VIRTUAL_ID)) {
+				logger_default.info(`Loading sidebar virtual module: ${id}`, { timestamp: true });
+				const sidebarId = id.replace(SIDEBAR_VIRTUAL_ID, "").replace("\0", "");
+				const sidebar = sidebarsMap.get(sidebarId);
+				if (!sidebar) return genExportUndefined();
+				return genExportDefault(genObjectFromValues(sidebar));
+			}
+			return null;
+		},
+		async hotUpdate({ file, timestamp }) {
+			if (isDocsMatcher(file)) {
+				logger_default.info(`Invalidating module ${file}...`, { timestamp: true });
+				const invalidatedModules = /* @__PURE__ */ new Set();
+				const virtualModuleId = `\0${CONTENT_VIRTUAL_ID}${getSlugByPath(file, contentDir)}`;
+				const module = this.environment.moduleGraph.getModuleById(virtualModuleId);
+				if (module) {
+					this.environment.moduleGraph.invalidateModule(module, invalidatedModules, timestamp, true);
+					logger_default.info(`Reloading application...`, { timestamp: true });
+					this.environment.hot.send({ type: "full-reload" });
+				}
+			}
+		}
+	};
+}
+
+//#endregion
+export { prestige };
+//# sourceMappingURL=vite.js.map