@soubiran/vite 0.0.0 → 0.1.2

package/dist/vite.config.d.mts

@@ -0,0 +1,79 @@
+import { UserConfig } from "vite";
+import { Options } from "unplugin-vue-markdown/types";
+
+//#region src/assert.d.ts
+type AssertFn = (id: string, frontmatter: Record<string, any>) => void;
+//#endregion
+//#region src/structured-data/breadcrumb.d.ts
+
+interface BreadcrumbItem {
+  title: string;
+  type?: 'WebSite' | 'WebPage';
+  url?: string;
+}
+//#endregion
+//#region src/structured-data/person.d.ts
+interface PersonOptions {
+  name: string;
+  sameAs: string[];
+}
+//#endregion
+//#region src/structured-data/index.d.ts
+interface StructuredDataPageConfig {
+  type: 'article' | 'collection' | 'default';
+  breadcrumbItems?: BreadcrumbItem[];
+}
+//#endregion
+//#region vite.config.d.ts
+/**
+ * Main configuration interface for the infrastructure status app.
+ */
+interface Options$1 {
+  /**
+   * Extracts the page identifier from a given file path or id.
+   * @param id - The file path or identifier.
+   * @returns The extracted page name, or null if not found.
+   */
+  extractPage: (id: string) => string | null;
+  /**
+   * Markdown rendering options for unplugin-vue-markdown.
+   */
+  markdown?: Options;
+  /**
+   * SEO and structured data configuration.
+   */
+  seo: {
+    /**
+     * Person information for Schema.org structured data.
+     */
+    person: PersonOptions;
+    /**
+     * Custom validation rules for frontmatter fields.
+     */
+    assert?: {
+      /**
+       * Validation rules function for frontmatter.
+       */
+      rules?: AssertFn;
+    };
+    /**
+     * Structured data generation configuration.
+     */
+    structuredData?: {
+      /**
+       * Callback to determine page type and configuration for structured data generation.
+       * @param page - The page name or null.
+       * @param frontmatter - The frontmatter data for the page.
+       * @returns Structured data configuration for the page.
+       */
+      pageConfig?: (page: string | null, frontmatter: Record<string, any>) => StructuredDataPageConfig;
+    };
+  };
+  /**
+   * Categories to generate API JSON files for (e.g., ['websites', 'platforms']).
+   */
+  apiCategories?: string[];
+}
+declare const _default: (title: string, hostname: string, options: Options$1, config?: UserConfig) => Record<string, any>;
+//#endregion
+export { type BreadcrumbItem, type PersonOptions, type StructuredDataPageConfig, _default as default };

package/dist/vite.config.mjs

@@ -0,0 +1,754 @@
+import { createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import ui from "@nuxt/ui/vite";
+import soubiranComposablesImports from "@soubiran/ui/imports";
+import soubiranResolver from "@soubiran/ui/resolver";
+import { unheadVueComposablesImports } from "@unhead/vue";
+import vue from "@vitejs/plugin-vue";
+import matter from "gray-matter";
+import fonts from "unplugin-fonts/vite";
+import icons from "unplugin-icons/vite";
+import markdown from "unplugin-vue-markdown/vite";
+import vueRouter from "unplugin-vue-router/vite";
+import { defineConfig, mergeConfig } from "vite";
+import { joinURL, withoutTrailingSlash } from "ufo";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { blurhashToDataUri } from "@unpic/placeholder";
+import MarkdownItGitHubAlerts from "markdown-it-github-alerts";
+import implicitFigures from "markdown-it-image-figures";
+import linkAttributes from "markdown-it-link-attributes";
+import { fromAsyncCodeToHtml } from "@shikijs/markdown-it/async";
+import { codeToHtml } from "shiki";
+import { defaultOptions, findHeadlineElements, flatHeadlineItemsToNestedTree, getTokensText, slugify } from "markdown-it-table-of-contents";
+import { Buffer } from "node:buffer";
+import fs from "fs-extra";
+import sharp from "sharp";
+import { cwd } from "node:process";
+import { cyan, dim, green, yellow } from "ansis";
+import { createHash } from "node:crypto";
+import { SitemapStream } from "sitemap";
+
+//#region src/assert.ts
+function createAssert(customAssert) {
+	return (id, frontmatter) => {
+		if (frontmatter.description) {
+			const descLength = frontmatter.description.length;
+			if (descLength < 110 || descLength > 160) throw new Error(`Description length must be between 110 and 160 characters. Current length: ${descLength} in file: ${id}`);
+		}
+		customAssert?.(id, frontmatter);
+	};
+}
+
+//#endregion
+//#region src/utils.ts
+function getUri(id) {
+	return withoutTrailingSlash(id.split("/pages/")[1].replace(/\.md$/, "").replace(/\.vue$/, "").replace(/index$/, ""));
+}
+function toUrl(hostname, ...paths) {
+	return joinURL(`https://${hostname}`, ...paths);
+}
+
+//#endregion
+//#region src/canonical.ts
+function getCanonicalUrl(id, hostname) {
+	return joinURL(toUrl(hostname), getUri(id));
+}
+function canonical(id, frontmatter, hostname) {
+	const url = getCanonicalUrl(id, hostname);
+	frontmatter.meta ??= [];
+	frontmatter.meta.push({
+		property: "og:url",
+		content: url
+	});
+	frontmatter.link ??= [];
+	frontmatter.link.push({
+		rel: "canonical",
+		href: url
+	});
+}
+
+//#endregion
+//#region src/markdown-it/custom-image.ts
+function customImage(md, hostname) {
+	md.use((md$1) => {
+		const imageRule = md$1.renderer.rules.image;
+		md$1.renderer.rules.image = async (tokens, idx, options, env, self) => {
+			const token = tokens[idx];
+			const src = token.attrGet("src");
+			if (src) {
+				if (!src.startsWith("http")) {
+					const remoteSrc = `https://assets.${hostname}`;
+					const metadataFilename = `${src}.json`;
+					const cachedMetadataFilename = join(".cache", metadataFilename);
+					let metadata = await readFile(cachedMetadataFilename, "utf-8").then((text) => JSON.parse(text)).catch(() => void 0);
+					if (!metadata) {
+						metadata = await fetch(joinURL(remoteSrc, metadataFilename)).then((res) => res.json());
+						await mkdir(dirname(cachedMetadataFilename), { recursive: true });
+						await writeFile(cachedMetadataFilename, JSON.stringify(metadata, null, 2));
+					}
+					token.attrSet("loading", "lazy");
+					token.attrSet("width", metadata.width.toString());
+					token.attrSet("height", metadata.height.toString());
+					token.attrSet("style", `background-size: cover; background-image: url(${blurhashToDataUri(metadata.blurhash)});`);
+					token.attrSet("src", joinURL(`https://${hostname}`, "cdn-cgi/image", "width=1200,quality=80,format=auto", remoteSrc, src));
+				}
+			}
+			return imageRule(tokens, idx, options, env, self);
+		};
+	});
+}
+
+//#endregion
+//#region src/markdown-it/custom-link.ts
+function customLink(md, hostname) {
+	md.use((md$1) => {
+		const linkRule = md$1.renderer.rules.link_open;
+		md$1.renderer.rules.link_open = (tokens, idx, options, env, self) => {
+			const token = tokens[idx];
+			const href = token.attrGet("href");
+			if (href && /^https?:\/\/(?:[a-z0-9-]+\.)?soubiran\.dev(?:[/?#]|$)/.test(href)) {
+				let linkText = "";
+				let nextIdx = idx + 1;
+				while (nextIdx < tokens.length && tokens[nextIdx].type !== "link_close") {
+					if (tokens[nextIdx].type === "text" || tokens[nextIdx].type === "code_inline") linkText += tokens[nextIdx].content;
+					else if (tokens[nextIdx].children) {
+						for (const child of tokens[nextIdx].children) if (child.type === "text" || child.type === "code_inline") linkText += child.content;
+					}
+					nextIdx++;
+				}
+				const url = new URL(href);
+				url.searchParams.set("utm_source", hostname);
+				url.searchParams.set("utm_medium", "link");
+				url.searchParams.set("utm_content", "textlink");
+				if (linkText) url.searchParams.set("utm_term", linkText);
+				token.attrSet("href", url.toString());
+			}
+			return linkRule(tokens, idx, options, env, self);
+		};
+	});
+}
+
+//#endregion
+//#region src/markdown-it/github-alerts.ts
+function githubAlerts(md) {
+	md.use(MarkdownItGitHubAlerts);
+}
+
+//#endregion
+//#region src/markdown-it/implicit-figures.ts
+function implicitFiguresRule(md) {
+	md.use(implicitFigures, { figcaption: "alt" });
+}
+
+//#endregion
+//#region src/markdown-it/link-attributes.ts
+function linkAttributesRule(md) {
+	md.use(linkAttributes, [{
+		matcher: (link) => /^https?:\/\/(?:[a-z0-9-]+\.)?soubiran\.dev(?:[/?#]|$)/.test(link),
+		attrs: { target: "_blank" }
+	}, {
+		matcher: (link) => /^https?:\/\//.test(link),
+		attrs: {
+			target: "_blank",
+			rel: "noopener"
+		}
+	}]);
+}
+
+//#endregion
+//#region src/markdown-it/shiki-highlight.ts
+async function shikiHighlight(md) {
+	md.use(fromAsyncCodeToHtml(codeToHtml, {
+		defaultColor: false,
+		themes: {
+			light: "github-light",
+			dark: "github-dark"
+		}
+	}));
+}
+
+//#endregion
+//#region src/markdown-it/table-of-contents.ts
+function tableOfContentsRule(md) {
+	md.use((md$1) => {
+		md$1.renderer.rules.heading_open = (tokens, idx, options, _env, self) => {
+			const token = tokens[idx];
+			if (token.tag === "h2" || token.tag === "h3") {
+				const inlineToken = tokens[idx + 1];
+				const textContent = getTokensText(inlineToken.children);
+				token.attrSet("id", slugify(textContent));
+				return `<Heading :level="${token.tag.slice(1)}"${self.renderAttrs(token)}>`;
+			}
+			return self.renderToken(tokens, idx, options);
+		};
+		md$1.renderer.rules.heading_close = (tokens, idx, options, _env, self) => {
+			const token = tokens[idx];
+			if (token.tag === "h2" || token.tag === "h3") return "</Heading>";
+			return self.renderToken(tokens, idx, options);
+		};
+	});
+	md.use((md$1) => {
+		md$1.core.ruler.push("toc_to_env", (state) => {
+			const options = defaultOptions;
+			const tocTree = flatHeadlineItemsToNestedTree(findHeadlineElements(options.includeLevel, state.tokens, options));
+			state.env.frontmatter = state.env.frontmatter || {};
+			state.env.frontmatter.toc = tocTree.children || [];
+			return true;
+		});
+	});
+}
+
+//#endregion
+//#region src/promise.ts
+const promises = [];
+async function resolveAll() {
+	await Promise.all(promises);
+}
+
+//#endregion
+//#region src/og.ts
+const ogSVG = fs.readFileSync(new URL("./og-template.svg", import.meta.url), "utf-8");
+async function generate(title, hostname, output) {
+	if (fs.existsSync(output)) return;
+	await fs.mkdir(dirname(output), { recursive: true });
+	const lines = title.trim().split(/(.{0,30})(?:\s|$)/g).filter(Boolean);
+	const data = {
+		line1: lines[0],
+		line2: lines[1],
+		line3: lines[2],
+		headline: "",
+		hostname
+	};
+	const svg = ogSVG.replace(/\{\{([^}]+)\}\}/g, (_, name) => data[name] || "");
+	console.log(`Generating ${output}`);
+	try {
+		await sharp(Buffer.from(svg)).resize(1200 * 1.1, 630 * 1.1).png().toFile(output);
+	} catch (e) {
+		console.error("Failed to generate og image", e);
+	}
+}
+function og(id, frontmatter, hostname) {
+	(() => {
+		const path = `og/${basename(id, ".md")}.png`;
+		promises.push(generate(frontmatter.title.replace(/\s-\s.*$/, "").trim(), hostname, `public/${path}`));
+		frontmatter.image = `https://${hostname}/${path}`;
+	})();
+}
+
+//#endregion
+//#region src/plugins/api.ts
+/**
+* Recursively scan a directory for markdown files
+*/
+function scanMarkdownFiles(dir, baseDir) {
+	const files = [];
+	try {
+		const entries = readdirSync(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = join(dir, entry.name);
+			if (entry.isDirectory()) files.push(...scanMarkdownFiles(fullPath, baseDir));
+			else if (entry.isFile() && entry.name.endsWith(".md") && entry.name !== "index.md") files.push(fullPath);
+		}
+	} catch {}
+	return files;
+}
+/**
+* Process a markdown file and extract its frontmatter
+*/
+function processMarkdownFile(filePath, category) {
+	const { data } = matter(readFileSync(filePath, "utf-8"));
+	return {
+		path: `/${category}/${filePath.split("/").pop()?.replace(/\.md$/, "") || ""}`,
+		...data
+	};
+}
+/**
+* Generates the pages API JSON files in dist/api directory
+*/
+async function api(config, categories) {
+	const pagesDir = resolve(cwd(), "pages");
+	const distDir = resolve(cwd(), config.build.outDir);
+	for (const name of categories) {
+		const processedFiles = scanMarkdownFiles(join(pagesDir, name)).map((file) => processMarkdownFile(file, name));
+		const apiDir = join(distDir, "api");
+		const path = join(apiDir, `${name}.json`);
+		mkdirSync(apiDir, { recursive: true });
+		writeFileSync(path, JSON.stringify(processedFiles, null, 2));
+		config.logger.info(`${dim(`${config.build.outDir}/`)}${cyan(path.replace(`${distDir}/`, ""))}`);
+	}
+}
+function apiPlugin(categories = []) {
+	let config;
+	return {
+		name: "api",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		closeBundle() {
+			if (this.environment.name !== "client") return;
+			if (categories.length === 0) return;
+			const time = /* @__PURE__ */ new Date();
+			config.logger.info(yellow("Generate API files"));
+			api(config, categories);
+			config.logger.info(green(`✓ generated in ${(/* @__PURE__ */ new Date()).getTime() - time.getTime()}ms`));
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/markdown.ts
+/**
+* Sanitize markdown content for LLM consumption
+* - Removes HTML tags while preserving content inside paired tags
+* - Adds title as H1 heading at the top
+* - Safe for build-time processing
+*/
+function sanitizeMarkdown(content, title) {
+	let sanitized = content;
+	let prevSanitized = "";
+	while (sanitized !== prevSanitized) {
+		prevSanitized = sanitized;
+		sanitized = sanitized.replace(/<[^>]+>([^<]*)<\/[^>]+>/g, "$1");
+		sanitized = sanitized.replace(/<[^>]*>/g, "");
+	}
+	if (title) sanitized = `# ${title}\n\n${sanitized}`;
+	return sanitized.trim();
+}
+/**
+* Recursively copy and sanitize markdown files from source to target directory
+* - Parses frontmatter and removes it
+* - Sanitizes HTML tags
+* - Preserves directory structure
+* - Converts /<something>/index.md to /<something>.md (except for root /index.md)
+*/
+function copyAndSanitizeMarkdownFiles(config, sourceDir, targetDir, isRoot = true) {
+	const outDir = join(resolve(cwd()), config.build.outDir);
+	const entries = readdirSync(sourceDir);
+	for (const entry of entries) {
+		const sourcePath = join(sourceDir, entry);
+		if (statSync(sourcePath).isDirectory()) {
+			const newTargetDir = join(targetDir, entry);
+			if (!existsSync(newTargetDir)) mkdirSync(newTargetDir, { recursive: true });
+			copyAndSanitizeMarkdownFiles(config, sourcePath, newTargetDir, false);
+		} else if (entry.endsWith(".md")) {
+			let targetPath;
+			if (entry === "index.md" && !isRoot) {
+				const parentDirName = basename(sourceDir);
+				targetPath = join(dirname(targetDir), `${parentDirName}.md`);
+			} else targetPath = join(targetDir, entry);
+			const targetDirPath = dirname(targetPath);
+			if (!existsSync(targetDirPath)) mkdirSync(targetDirPath, { recursive: true });
+			const { data, content } = matter(readFileSync(sourcePath, "utf-8"));
+			const sanitizedContent = sanitizeMarkdown(content, data.title);
+			writeFileSync(targetPath, sanitizedContent, "utf-8");
+			config.logger.info(`${dim(`${config.build.outDir}/`)}${cyan(targetPath.replace(`${outDir}/`, ""))}`);
+		}
+	}
+}
+function markdownPlugin() {
+	let config;
+	return {
+		name: "markdown",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		closeBundle() {
+			if (this.environment.name !== "client") return;
+			const pagesDir = resolve(cwd(), "pages");
+			const distDir = resolve(cwd(), config.build.outDir);
+			const time = /* @__PURE__ */ new Date();
+			config.logger.info(yellow("Copy and Sanitize Markdown"));
+			copyAndSanitizeMarkdownFiles(config, pagesDir, distDir);
+			config.logger.info(green(`✓ copied in ${(/* @__PURE__ */ new Date()).getTime() - time.getTime()}ms`));
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/meta.ts
+/**
+* Generate a hash of the content for change detection
+*/
+function generateContentHash(content) {
+	return createHash("sha256").update(content).digest("hex");
+}
+/**
+* Recursively scan all markdown files and extract metadata
+*/
+function scanPagesForMeta(pagesDir, baseUri = "") {
+	const pages = [];
+	if (!existsSync(pagesDir)) return pages;
+	const entries = readdirSync(pagesDir);
+	for (const entry of entries) {
+		const fullPath = join(pagesDir, entry);
+		if (statSync(fullPath).isDirectory()) {
+			const subPages = scanPagesForMeta(fullPath, `${baseUri}/${entry}`);
+			pages.push(...subPages);
+		} else if (entry.endsWith(".md")) {
+			const parsed = matter(readFileSync(fullPath, "utf-8"));
+			let uri = baseUri;
+			if (entry !== "index.md") uri = joinURL(baseUri, entry.replace(/\.md$/, ""));
+			uri = withoutTrailingSlash(uri);
+			pages.push({
+				uri,
+				title: parsed.data.title,
+				description: parsed.data.description,
+				content: parsed.content,
+				id: parsed.data.id,
+				filePath: fullPath
+			});
+		}
+	}
+	return pages;
+}
+/**
+* Generate meta.json file with all pages metadata
+*/
+async function generateMeta(config, hostname) {
+	const pagesDir = resolve(cwd(), "pages");
+	const distDir = resolve(cwd(), config.build.outDir);
+	const pages = scanPagesForMeta(pagesDir).filter((page) => page.title).map((page) => ({
+		id: page.id,
+		title: page.title,
+		description: page.description,
+		uri: page.uri,
+		url: joinURL(`https://${hostname}`, page.uri),
+		hash: generateContentHash(page.content)
+	}));
+	pages.sort((a, b) => a.uri.localeCompare(b.uri));
+	const metaPath = join(distDir, "meta.json");
+	writeFileSync(metaPath, JSON.stringify(pages, null, 2));
+	config.logger.info(`${dim(`${config.build.outDir}/`)}${cyan(metaPath.replace(`${distDir}/`, ""))}`);
+}
+function metaPlugin(hostname) {
+	let config;
+	return {
+		name: "meta",
+		configResolved(resolvedConfig) {
+			config = resolvedConfig;
+		},
+		closeBundle() {
+			if (this.environment.name !== "client") return;
+			const time = /* @__PURE__ */ new Date();
+			config.logger.info(yellow("Generate meta.json"));
+			generateMeta(config, hostname);
+			config.logger.info(green(`✓ generated in ${(/* @__PURE__ */ new Date()).getTime() - time.getTime()}ms`));
+		}
+	};
+}
+
+//#endregion
+//#region src/sitemap.ts
+const routes = /* @__PURE__ */ new Set();
+function sitemap(config, hostname, routes$1) {
+	const sitemapStream = new SitemapStream({ hostname: `https://${hostname}` });
+	const writeStream = createWriteStream(join(config.build.outDir, "sitemap.xml"));
+	sitemapStream.pipe(writeStream);
+	routes$1.forEach((item) => sitemapStream.write(item));
+	sitemapStream.end();
+}
+
+//#endregion
+//#region src/structured-data/article.ts
+/**
+* @see https://developer.yoast.com/features/schema/pieces/article/
+*/
+function article(id, structuredData$1, properties, options) {
+	const { title, description } = properties;
+	return { data: {
+		"@type": "Article",
+		"@id": joinURL(toUrl(options.hostname), "#", "schema", "Article", getUri(id)),
+		"headline": title,
+		"description": description,
+		"isPartOf": { "@id": structuredData$1.webpage.data["@id"] },
+		"mainEntityOfPage": { "@id": structuredData$1.webpage.data["@id"] },
+		"datePublished": structuredData$1.webpage.data.datePublished ? structuredData$1.webpage.data.datePublished : void 0,
+		"author": { "@id": structuredData$1.person.data["@id"] },
+		"publisher": { "@id": structuredData$1.person.data["@id"] },
+		"inLanguage": structuredData$1.webpage.data.inLanguage
+	} };
+}
+
+//#endregion
+//#region src/structured-data/breadcrumb.ts
+/**
+* @see https://developer.yoast.com/features/schema/pieces/breadcrumb/
+*/
+function breadcrumb(id, items, options) {
+	return { data: {
+		"@type": "BreadcrumbList",
+		"@id": joinURL(toUrl(options.hostname), "#", "schema", "BreadcrumbList", getUri(id)),
+		"itemListElement": items.map((item, index) => ({
+			"@type": "ListItem",
+			"position": index + 1,
+			"name": item.title,
+			...item.type && item.url ? { item: {
+				"@type": item.type,
+				"@id": item.url
+			} } : {}
+		}))
+	} };
+}
+
+//#endregion
+//#region src/structured-data/person.ts
+/**
+* @see https://developer.yoast.com/features/schema/pieces/person/
+*/
+function person(options, personOptions) {
+	return { data: {
+		"@type": "Person",
+		"@id": joinURL(options.url, "#", "schema", "Person", "1"),
+		"name": personOptions.name,
+		"sameAs": personOptions.sameAs
+	} };
+}
+
+//#endregion
+//#region src/structured-data/webpage.ts
+/**
+* @see https://developer.yoast.com/features/schema/pieces/webpage/
+*/
+function webpage(id, structuredData$1, properties, options) {
+	const { title, description, datePublished, keywords } = properties;
+	const canonicalUrl = getCanonicalUrl(id, options.hostname);
+	const data = {
+		"@type": "WebPage",
+		"@id": canonicalUrl,
+		"url": canonicalUrl,
+		"name": title,
+		"description": description,
+		"isPartOf": { "@id": structuredData$1.website.data["@id"] },
+		"inLanguage": "en-US",
+		"potentialAction": [{
+			"@type": "ReadAction",
+			"target": [canonicalUrl]
+		}],
+		...datePublished ? { datePublished: datePublished.toISOString() } : {},
+		...keywords ? { keywords } : {}
+	};
+	return {
+		data,
+		setBreadcrumb(breadcrumbData) {
+			data.breadcrumb = { "@id": breadcrumbData.data["@id"] };
+		},
+		setCollection() {
+			data["@type"] = "CollectionPage";
+			delete data.potentialAction;
+		}
+	};
+}
+
+//#endregion
+//#region src/structured-data/website.ts
+/**
+* @see https://developer.yoast.com/features/schema/pieces/website/
+*/
+function website(structuredData$1, options) {
+	return { data: {
+		"@type": "WebSite",
+		"@id": joinURL(options.url, "#", "schema", "WebSite", "1"),
+		"url": options.url,
+		"name": options.name,
+		"inLanguage": ["en-US"],
+		"publisher": { "@id": structuredData$1.person.data["@id"] }
+	} };
+}
+
+//#endregion
+//#region src/structured-data/index.ts
+function structuredData(id, frontmatter, options) {
+	const { name, hostname, extractPage, getPageConfig } = options;
+	const graph = {
+		"@context": "https://schema.org",
+		"@graph": []
+	};
+	const structuredDataOptions = {
+		name,
+		hostname,
+		url: toUrl(hostname)
+	};
+	const personData = person(structuredDataOptions, options.person);
+	const websiteData = website({ person: personData }, structuredDataOptions);
+	const webpageData = webpage(id, { website: websiteData }, {
+		title: frontmatter.title,
+		description: frontmatter.description,
+		datePublished: frontmatter.date ? new Date(frontmatter.date) : void 0,
+		keywords: frontmatter.tags
+	}, structuredDataOptions);
+	const page = extractPage(id);
+	const pageConfig = getPageConfig?.(page, frontmatter);
+	if (pageConfig?.type === "article") {
+		const articleData = article(id, {
+			person: personData,
+			webpage: webpageData
+		}, {
+			title: frontmatter.title,
+			description: frontmatter.description
+		}, structuredDataOptions);
+		graph["@graph"].push(articleData.data);
+		if (pageConfig.breadcrumbItems) {
+			const breadcrumbData = breadcrumb(id, pageConfig.breadcrumbItems, structuredDataOptions);
+			graph["@graph"].push(breadcrumbData.data);
+			webpageData.setBreadcrumb(breadcrumbData);
+		}
+	} else if (pageConfig?.type === "collection") webpageData.setCollection();
+	graph["@graph"].push(personData.data, websiteData.data, webpageData.data);
+	frontmatter.script ??= [];
+	frontmatter.script.push({
+		type: "application/ld+json",
+		innerHTML: JSON.stringify(graph)
+	});
+}
+
+//#endregion
+//#region vite.config.ts
+var vite_config_default = (title, hostname, options, config = {}) => mergeConfig(defineConfig({
+	plugins: [
+		vueRouter({
+			extensions: [".vue", ".md"],
+			routesFolder: "pages",
+			dts: "src/typed-router.d.ts",
+			extendRoute(route) {
+				const path = route.components.get("default");
+				if (!path) return;
+				if (path.endsWith(".vue")) route.addToMeta({ frontmatter: { page: options.extractPage(path) } });
+				if (path.endsWith(".md")) {
+					const { data } = matter(readFileSync(path, "utf-8"));
+					route.addToMeta({ frontmatter: data });
+				}
+			}
+		}),
+		vue({ include: [/\.vue$/, /\.md$/] }),
+		ui({
+			autoImport: {
+				dts: "src/auto-imports.d.ts",
+				dirs: ["src/composables"],
+				imports: [
+					"vue",
+					"vue-router",
+					"@vueuse/core",
+					unheadVueComposablesImports,
+					{
+						from: "tailwind-variants",
+						imports: ["tv"]
+					},
+					soubiranComposablesImports
+				]
+			},
+			components: {
+				include: [
+					/\.vue$/,
+					/\.vue\?vue/,
+					/\.md$/
+				],
+				dts: "src/components.d.ts",
+				resolvers: [soubiranResolver()]
+			},
+			ui: { colors: { neutral: "neutral" } }
+		}),
+		markdown({
+			headEnabled: true,
+			wrapperClasses: [
+				"slide-enter-content",
+				"max-w-none",
+				"prose prose-neutral dark:prose-invert",
+				"prose-headings:text-default prose-h2:text-[1.125em] prose-h2:mb-[0.5em] prose-h3:text-[1em]",
+				"prose-p:my-[1em] dark:prose-p:text-muted",
+				"dark:prose-ul:text-muted dark:prose-ol:text-muted",
+				"dark:prose-strong:text-default",
+				"dark:prose-a:text-muted prose-a:font-semibold prose-a:no-underline prose-a:border-b prose-a:border-muted prose-a:transition-colors prose-a:duration-300 prose-a:ease-out prose-a:hover:border-[var(--ui-text-dimmed)]",
+				"prose-hr:max-w-1/2 prose-hr:mx-auto prose-hr:my-[2em]",
+				"prose-figure:bg-neutral-100 dark:prose-figure:bg-neutral-800 prose-figure:rounded-lg",
+				"prose-img:rounded-lg prose-img:border prose-img:border-accented prose-img:shadow-md",
+				"prose-video:rounded-lg prose-video:border prose-video:border-accented prose-video:shadow-md",
+				"prose-figcaption:text-center prose-figcaption:py-1 prose-figcaption:m-0",
+				"[&_:first-child]:mt-0 [&_:last-child]:mb-0"
+			],
+			transforms: options.markdown?.transforms ?? {},
+			wrapperComponent: options.markdown?.wrapperComponent,
+			async markdownItSetup(md) {
+				githubAlerts(md);
+				implicitFiguresRule(md);
+				linkAttributesRule(md);
+				tableOfContentsRule(md);
+				customLink(md, hostname);
+				customImage(md, hostname);
+				await shikiHighlight(md);
+			},
+			frontmatterPreprocess(frontmatter, frontmatterOptions, id, defaults) {
+				createAssert(options.seo.assert?.rules)(id, frontmatter);
+				og(id, frontmatter, hostname);
+				canonical(id, frontmatter, hostname);
+				structuredData(id, frontmatter, {
+					name: title,
+					hostname,
+					person: options.seo.person,
+					extractPage: options.extractPage,
+					getPageConfig: options.seo.structuredData?.pageConfig
+				});
+				frontmatter.page = options.extractPage(id);
+				return {
+					head: defaults(frontmatter, frontmatterOptions),
+					frontmatter
+				};
+			}
+		}),
+		fonts({ google: { families: [
+			{
+				name: "DM Sans",
+				styles: "ital,opsz,wght@0,9..40,100..1000;1,9..40,100..1000"
+			},
+			{
+				name: "DM Mono",
+				styles: "ital,wght@0,300;0,400;0,500;1,300;1,400;1,500"
+			},
+			{
+				name: "Sofia Sans",
+				styles: "ital,wght@0,1..1000;1,1..1000"
+			}
+		] } }),
+		icons({ autoInstall: true }),
+		apiPlugin(options.apiCategories),
+		markdownPlugin(),
+		metaPlugin(hostname),
+		{
+			name: "await",
+			async closeBundle() {
+				await resolveAll();
+			}
+		},
+		{
+			name: "extract-config",
+			configResolved(resolvedConfig) {
+				Object.assign(config, resolvedConfig);
+			}
+		}
+	],
+	optimizeDeps: {
+		include: [
+			"vue",
+			"ofetch",
+			"reka-ui",
+			"vue-router",
+			"@unhead/vue",
+			"partysocket",
+			"@iconify/vue"
+		],
+		exclude: ["@soubiran/ui"]
+	},
+	resolve: { alias: { "@": resolve("./src") } },
+	ssgOptions: {
+		formatting: "minify",
+		onPageRendered(route, renderedHTML) {
+			routes.add(route);
+			return renderedHTML;
+		},
+		onFinished() {
+			sitemap(config, hostname, Array.from(routes));
+		}
+	}
+}), config);
+
+//#endregion
+export { vite_config_default as default };

package/package.json

@@ -1,4 +1,65 @@
 {
   "name": "@soubiran/vite",
-  "version": "0.0.0"
-}
+  "type": "module",
+  "version": "0.1.2",
+  "author": "Estéban Soubiran <esteban@soubiran.dev>",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/Barbapapazes",
+  "homepage": "https://github.com/Barbapapazes/.soubiran.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Barbapapazes/.soubiran.dev"
+  },
+  "bugs": "https://github.com/Barbapapazes/.soubiran.dev/issues",
+  "exports": {
+    ".": {
+      "types": "./dist/vite.config.d.ts",
+      "import": "./dist/vite.config.mjs"
+    }
+  },
+  "main": "dist/vite.config.mjs",
+  "types": "dist/vite.config.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@nuxt/ui": "^4.2.0",
+    "@shikijs/markdown-it": "^3.15.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/markdown-it": "^14.1.2",
+    "@types/markdown-it-link-attributes": "^3.0.5",
+    "@types/node": "^24.10.1",
+    "@unhead/vue": "^2.0.19",
+    "@unpic/placeholder": "^0.1.2",
+    "@vitejs/plugin-vue": "^6.0.2",
+    "ansis": "^4.2.0",
+    "fs-extra": "^11.3.2",
+    "gray-matter": "^4.0.3",
+    "markdown-it": "^14.1.0",
+    "markdown-it-async": "^2.2.0",
+    "markdown-it-github-alerts": "^1.0.0",
+    "markdown-it-image-figures": "^2.1.1",
+    "markdown-it-link-attributes": "^4.0.1",
+    "markdown-it-table-of-contents": "^1.1.0",
+    "sharp": "^0.34.5",
+    "shiki": "^3.15.0",
+    "sitemap": "^8.0.2",
+    "typescript": "^5.9.3",
+    "ufo": "^1.6.1",
+    "unhead": "^2.0.19",
+    "unplugin-fonts": "^1.4.0",
+    "unplugin-icons": "^22.5.0",
+    "unplugin-vue-markdown": "^29.2.0",
+    "unplugin-vue-router": "^0.16.2",
+    "vite": "npm:rolldown-vite@7.1.20",
+    "vite-ssg": "^28.2.2",
+    "vue-router": "^4.6.3",
+    "@soubiran/ui": "0.1.2"
+  },
+  "devDependencies": {
+    "tsdown": "^0.18.3"
+  },
+  "scripts": {
+    "build": "tsdown"
+  }
+}