@ubean/content 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import ubeanContentPlugin, { UbeanContentOptions } from "./vite.js";
+import { A as ContentQueryBuilder, C as pathToTitle, D as ContentFieldSchema, E as ContentDocument, F as MarkdownNode, I as ParsedContentMeta, M as ContentSourceConfig, N as ContentTocItem, O as ContentModuleOptions, P as ContentType, S as parseMarkdown, T as ContentCollection, _ as getExtension, a as getContentItem, b as parseContent, c as queryCollection, d as createContentCollection, f as createQueryBuilder, g as getDirname, h as getBasename, i as getCollection, j as ContentSchema, k as ContentNavigationItem, l as registerContent, m as generateId, n as defineCollection, o as listCollections, p as defineContentCollection, r as fetchContentNavigation, s as parseContentFile, t as configureContentRuntime, u as buildNavigation, v as getStem, w as ContentBody, x as parseFrontmatter, y as normalizePath } from "./runtime-zD72Z3v3.js";
+export { type ContentBody, type ContentCollection, type ContentDocument, type ContentFieldSchema, type ContentModuleOptions, type ContentNavigationItem, type ContentQueryBuilder, type ContentSchema, type ContentSourceConfig, type ContentTocItem, type ContentType, type MarkdownNode, type ParsedContentMeta, type UbeanContentOptions, buildNavigation, configureContentRuntime, createContentCollection, createQueryBuilder, defineCollection, defineContentCollection, fetchContentNavigation, fetchContentNavigation as fetchNavigation, generateId, getBasename, getCollection, getContentItem, getDirname, getExtension, getStem, listCollections, normalizePath, parseContent, parseContentFile, parseFrontmatter, parseMarkdown, pathToTitle, queryCollection, queryCollection as queryContent, registerContent, ubeanContentPlugin };

package/dist/index.js

@@ -0,0 +1,3 @@
+import { C as pathToTitle, S as parseMarkdown, _ as getExtension, a as getContentItem, b as parseContent, c as queryCollection, d as createContentCollection, f as createQueryBuilder, g as getDirname, h as getBasename, i as getCollection, l as registerContent, m as generateId, n as defineCollection, o as listCollections, p as defineContentCollection, r as fetchContentNavigation, s as parseContentFile, t as configureContentRuntime, u as buildNavigation, v as getStem, x as parseFrontmatter, y as normalizePath } from "./runtime-C8qrycGf.js";
+import ubeanContentPlugin from "./vite.js";
+export { buildNavigation, configureContentRuntime, createContentCollection, createQueryBuilder, defineCollection, defineContentCollection, fetchContentNavigation, fetchContentNavigation as fetchNavigation, generateId, getBasename, getCollection, getContentItem, getDirname, getExtension, getStem, listCollections, normalizePath, parseContent, parseContentFile, parseFrontmatter, parseMarkdown, pathToTitle, queryCollection, queryCollection as queryContent, registerContent, ubeanContentPlugin };

package/dist/runtime-C8qrycGf.js

@@ -0,0 +1,558 @@
+import { kebabCase } from "scule";
+//#region src/core.ts
+function generateId(path, extension) {
+	const cleanPath = path.replace(/\\/g, "/").replace(/^\/+/, "");
+	if (extension) {
+		const ext = extension.startsWith(".") ? extension : `.${extension}`;
+		return `content:${cleanPath.replace(new RegExp(`${ext}$`), "")}`;
+	}
+	return `content:${cleanPath.replace(/\.[^.]+$/, "")}`;
+}
+function getDirname(path) {
+	const parts = path.split("/");
+	parts.pop();
+	return parts.join("/") || "/";
+}
+function getBasename(path) {
+	const parts = path.split("/");
+	return parts[parts.length - 1];
+}
+function getExtension(filename) {
+	const match = filename.match(/\.([^.]+)$/);
+	return match ? match[1].toLowerCase() : "";
+}
+function getStem(filename) {
+	return filename.replace(/\.[^.]+$/, "");
+}
+function normalizePath(path) {
+	return `/${path.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\/+$/, "").replace(/\/+/g, "/")}`;
+}
+function pathToTitle(path) {
+	const stem = getStem(getBasename(path));
+	if (stem === "index") return kebabCase(getBasename(getDirname(path)) || "home").split("-").map(capitalize).join(" ");
+	return kebabCase(stem).split("-").map(capitalize).join(" ");
+}
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function parseFrontmatter(content) {
+	const data = {};
+	const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/);
+	if (!fmMatch) return {
+		data,
+		content
+	};
+	const [, frontmatterStr, body] = fmMatch;
+	const lines = frontmatterStr.split("\n");
+	let currentKey = "";
+	let isArray = false;
+	for (const line of lines) {
+		const arrayItemMatch = line.match(/^\s*-\s*(.+)$/);
+		if (arrayItemMatch && currentKey && isArray) {
+			if (!Array.isArray(data[currentKey])) data[currentKey] = [];
+			data[currentKey].push(parseValue(arrayItemMatch[1].trim()));
+			continue;
+		}
+		const kvMatch = line.match(/^([\w.-]+):\s*(.*)$/);
+		if (kvMatch) {
+			const [, key, value] = kvMatch;
+			currentKey = key;
+			if (value.trim() === "") {
+				isArray = true;
+				data[key] = [];
+			} else if (value.trim() === "[]") {
+				isArray = false;
+				data[key] = [];
+			} else if (value.trim() === "{}") {
+				isArray = false;
+				data[key] = {};
+			} else {
+				isArray = false;
+				data[key] = parseValue(value.trim());
+			}
+		}
+	}
+	return {
+		data,
+		content: body
+	};
+}
+function parseValue(value) {
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (value === "null") return null;
+	if (value === "undefined") return void 0;
+	if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+	if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+	if (value.startsWith("\"") && value.endsWith("\"") || value.startsWith("'") && value.endsWith("'")) return value.slice(1, -1);
+	return value;
+}
+function parseMarkdown(content) {
+	const children = [];
+	const lines = content.split("\n");
+	const toc = [];
+	let excerpt = "";
+	let inCodeBlock = false;
+	let codeContent = "";
+	let paragraphLines = [];
+	function flushParagraph() {
+		if (paragraphLines.length > 0) {
+			const text = paragraphLines.join(" ").trim();
+			if (text) children.push({
+				type: "element",
+				tag: "p",
+				children: [{
+					type: "text",
+					value: text
+				}]
+			});
+			paragraphLines = [];
+		}
+	}
+	let foundExcerptSeparator = false;
+	let headingStack = [toc];
+	let headingDepths = [0];
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i];
+		if (line.startsWith("```")) {
+			flushParagraph();
+			if (inCodeBlock) {
+				children.push({
+					type: "element",
+					tag: "pre",
+					children: [{
+						type: "element",
+						tag: "code",
+						children: [{
+							type: "text",
+							value: codeContent
+						}]
+					}]
+				});
+				inCodeBlock = false;
+				codeContent = "";
+			} else {
+				inCodeBlock = true;
+				codeContent = "";
+			}
+			continue;
+		}
+		if (inCodeBlock) {
+			codeContent += (codeContent ? "\n" : "") + line;
+			continue;
+		}
+		if (line.trim() === "<!-- more -->") {
+			foundExcerptSeparator = true;
+			if (paragraphLines.length > 0) excerpt = paragraphLines.join(" ").trim();
+			else excerpt = [...children].reverse().find((c) => c.tag === "p" && c.children?.[0]?.value)?.children?.[0]?.value || "";
+			flushParagraph();
+			continue;
+		}
+		const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+		if (headingMatch) {
+			flushParagraph();
+			const depth = headingMatch[1].length;
+			const text = headingMatch[2].replace(/[#*_`~[\]]/g, "").trim();
+			const id = kebabCase(text);
+			while (headingDepths[headingDepths.length - 1] >= depth) {
+				headingDepths.pop();
+				headingStack.pop();
+			}
+			const item = {
+				id,
+				depth,
+				text,
+				children: []
+			};
+			headingStack[headingStack.length - 1].push(item);
+			headingStack.push(item.children);
+			headingDepths.push(depth);
+			children.push({
+				type: "element",
+				tag: `h${depth}`,
+				props: { id },
+				children: [{
+					type: "text",
+					value: text
+				}]
+			});
+			continue;
+		}
+		const listMatch = line.match(/^(\s*)[-*]\s+(.+)$/);
+		if (listMatch) {
+			flushParagraph();
+			const text = parseInlineMarkdown(listMatch[2].trim());
+			children.push({
+				type: "element",
+				tag: "li",
+				children: [{
+					type: "text",
+					value: text
+				}]
+			});
+			continue;
+		}
+		const orderedListMatch = line.match(/^(\s*)\d+\.\s+(.+)$/);
+		if (orderedListMatch) {
+			flushParagraph();
+			const text = parseInlineMarkdown(orderedListMatch[2].trim());
+			children.push({
+				type: "element",
+				tag: "li",
+				children: [{
+					type: "text",
+					value: text
+				}]
+			});
+			continue;
+		}
+		if (line.match(/^[-*_]{3,}$/)) {
+			flushParagraph();
+			children.push({
+				type: "element",
+				tag: "hr"
+			});
+			continue;
+		}
+		const blockquoteMatch = line.match(/^>\s*(.*)$/);
+		if (blockquoteMatch) {
+			flushParagraph();
+			children.push({
+				type: "element",
+				tag: "blockquote",
+				children: [{
+					type: "text",
+					value: blockquoteMatch[1].trim()
+				}]
+			});
+			continue;
+		}
+		if (line.trim() === "") {
+			flushParagraph();
+			continue;
+		}
+		paragraphLines.push(line);
+	}
+	flushParagraph();
+	if (!foundExcerptSeparator && paragraphLines.length === 0 && children.length > 0) {
+		const firstP = children.find((c) => c.tag === "p" && c.children?.[0]?.value);
+		if (firstP?.children?.[0]?.value) excerpt = firstP.children[0].value.slice(0, 200);
+	}
+	return {
+		type: "root",
+		children,
+		toc,
+		excerpt: excerpt || void 0
+	};
+}
+function parseInlineMarkdown(text) {
+	return text.replace(/\*\*(.+?)\*\*/g, "$1").replace(/\*(.+?)\*/g, "$1").replace(/`(.+?)`/g, "$1").replace(/\[(.+?)\]\(.+?\)/g, "$1");
+}
+function createQueryBuilder(documents) {
+	let result = [...documents];
+	const whereClauses = [];
+	let sortFields = [];
+	let limitCount = null;
+	let skipCount = 0;
+	let selectedFields = null;
+	let excludedFields = null;
+	const builder = {
+		where(fieldOrQuery, operator, value) {
+			if (typeof fieldOrQuery === "object") for (const [key, val] of Object.entries(fieldOrQuery)) whereClauses.push((doc) => getNestedValue(doc, key) === val);
+			else {
+				const field = fieldOrQuery;
+				let op = operator;
+				let val = value;
+				if (value === void 0 && operator !== void 0) {
+					op = "==";
+					val = operator;
+				}
+				whereClauses.push((doc) => {
+					const docValue = getNestedValue(doc, field);
+					switch (op) {
+						case "=":
+						case "==":
+						case void 0: return docValue === val;
+						case "!=": return docValue !== val;
+						case ">": return docValue > val;
+						case ">=": return docValue >= val;
+						case "<": return docValue < val;
+						case "<=": return docValue <= val;
+						case "contains": return String(docValue).includes(val);
+						case "in": return Array.isArray(val) && val.includes(docValue);
+						case "exists": return val ? docValue !== void 0 : docValue === void 0;
+						default: return docValue === val;
+					}
+				});
+			}
+			return builder;
+		},
+		sort(field, direction = "asc") {
+			sortFields.push({
+				field,
+				direction
+			});
+			return builder;
+		},
+		limit(count) {
+			limitCount = count;
+			return builder;
+		},
+		skip(count) {
+			skipCount = count;
+			return builder;
+		},
+		only(fields) {
+			selectedFields = fields;
+			return builder;
+		},
+		without(fields) {
+			excludedFields = fields;
+			return builder;
+		},
+		async find() {
+			applyWhere();
+			applySort();
+			applySkipLimit();
+			return applyFieldSelection(result);
+		},
+		async findOne() {
+			limitCount = 1;
+			return (await builder.find())[0] || null;
+		},
+		async findSurround(path, options = {}) {
+			const before = options.before ?? 1;
+			const after = options.after ?? 1;
+			applyWhere();
+			applySort();
+			const index = result.findIndex((doc) => doc._path === path);
+			if (index === -1) return [];
+			const start = Math.max(0, index - before);
+			const end = Math.min(result.length, index + after + 1);
+			return applyFieldSelection(result.slice(start, end).filter((_, i) => i !== before));
+		},
+		async count() {
+			applyWhere();
+			return result.length;
+		}
+	};
+	function applyWhere() {
+		result = result.filter((doc) => whereClauses.every((clause) => clause(doc)));
+	}
+	function applySort() {
+		if (sortFields.length === 0) sortFields = [{
+			field: "_path",
+			direction: "asc"
+		}];
+		result.sort((a, b) => {
+			for (const { field, direction } of sortFields) {
+				const aVal = getNestedValue(a, field);
+				const bVal = getNestedValue(b, field);
+				if (aVal === bVal) continue;
+				const cmp = aVal < bVal ? -1 : 1;
+				return direction === "desc" ? -cmp : cmp;
+			}
+			return 0;
+		});
+	}
+	function applySkipLimit() {
+		if (skipCount > 0) result = result.slice(skipCount);
+		if (limitCount !== null) result = result.slice(0, limitCount);
+	}
+	function applyFieldSelection(docs) {
+		if (!selectedFields && !excludedFields) return docs;
+		return docs.map((doc) => {
+			const newDoc = { ...doc };
+			if (excludedFields) for (const field of excludedFields) delete newDoc[field];
+			if (selectedFields) {
+				const kept = {};
+				for (const field of selectedFields) kept[field] = doc[field];
+				kept._id = doc._id;
+				kept._path = doc._path;
+				return kept;
+			}
+			return newDoc;
+		});
+	}
+	return builder;
+}
+function getNestedValue(obj, path) {
+	return path.split(".").reduce((o, key) => o?.[key], obj);
+}
+function buildNavigation(documents, _options = {}) {
+	const tree = [];
+	const map = /* @__PURE__ */ new Map();
+	const docs = documents.filter((d) => !d._draft && !d._partial && d.navigation !== false).sort((a, b) => a._path.localeCompare(b._path));
+	for (const doc of docs) {
+		const item = {
+			title: doc.title || pathToTitle(doc._file),
+			path: doc._path,
+			id: doc._id,
+			draft: doc._draft
+		};
+		map.set(doc._path, item);
+	}
+	for (const doc of docs) {
+		const item = map.get(doc._path);
+		if (doc._path === "/") {
+			tree.unshift(item);
+			continue;
+		}
+		const parentPath = doc._dir;
+		if (parentPath === "/") {
+			tree.push(item);
+			continue;
+		}
+		const parent = map.get(parentPath);
+		if (parent) {
+			if (!parent.children) parent.children = [];
+			parent.children.push(item);
+		} else tree.push(item);
+	}
+	return tree;
+}
+function parseContent(raw, filePath, options = {}) {
+	const extension = getExtension(filePath);
+	const type = options.type || extensionToType(extension);
+	const stem = getStem(getBasename(filePath));
+	const isDraft = stem.startsWith(".") || filePath.includes("/.") || filePath.includes("_draft");
+	const isPartial = stem.startsWith("_") || filePath.includes("_partial");
+	let meta = {
+		_id: generateId(filePath, extension),
+		_path: normalizePath(`${getDirname(filePath)}/${stem === "index" ? "" : stem}`),
+		_file: getBasename(filePath),
+		_dir: normalizePath(getDirname(filePath)),
+		_draft: isDraft,
+		_partial: isPartial,
+		_type: type,
+		_extension: extension,
+		_empty: raw.trim().length === 0
+	};
+	let body;
+	let extraMeta = {};
+	if (type === "markdown" || type === "mdx") {
+		const { data, content } = parseFrontmatter(raw);
+		extraMeta = data;
+		body = parseMarkdown(content);
+		if (body.excerpt) extraMeta.description = extraMeta.description || body.excerpt;
+	} else if (type === "json") try {
+		extraMeta = JSON.parse(raw);
+	} catch {
+		extraMeta = {};
+	}
+	else if (type === "yaml") extraMeta = parseSimpleYaml(raw);
+	return {
+		...meta,
+		...extraMeta,
+		title: extraMeta.title || (meta._path === "/" ? "Home" : pathToTitle(filePath)),
+		body,
+		_draft: extraMeta.draft || meta._draft,
+		_partial: extraMeta.partial || meta._partial
+	};
+}
+function extensionToType(ext) {
+	return {
+		md: "markdown",
+		mdx: "mdx",
+		json: "json",
+		yaml: "yaml",
+		yml: "yaml",
+		csv: "csv",
+		html: "html",
+		htm: "html"
+	}[ext] || "markdown";
+}
+function parseSimpleYaml(content) {
+	const result = {};
+	const lines = content.split("\n");
+	for (const line of lines) {
+		const kvMatch = line.match(/^([\w.-]+):\s*(.*)$/);
+		if (kvMatch) {
+			const [, key, value] = kvMatch;
+			result[key] = parseValue(value.trim() || "");
+		}
+	}
+	return result;
+}
+function defineContentCollection(collection) {
+	const docs = collection.documents || [];
+	return {
+		name: collection.name,
+		source: collection.source,
+		type: collection.type,
+		schema: collection.schema,
+		documents: docs,
+		list: async () => docs,
+		getItem: async (path) => docs.find((d) => d._path === path) || null,
+		query: () => createQueryBuilder(docs)
+	};
+}
+function createContentCollection(name, source, documents = []) {
+	return defineContentCollection({
+		name,
+		source,
+		documents
+	});
+}
+//#endregion
+//#region src/runtime.ts
+let collections = /* @__PURE__ */ new Map();
+let navigationCache = null;
+function configureContentRuntime(_options = {}) {
+	collections = /* @__PURE__ */ new Map();
+	navigationCache = null;
+}
+function defineCollection(config) {
+	const collection = createContentCollection(config.name, config.source);
+	collections.set(config.name, collection);
+	navigationCache = null;
+	return collection;
+}
+function getCollection(name) {
+	return collections.get(name);
+}
+function listCollections() {
+	return Array.from(collections.keys());
+}
+async function queryCollection(name) {
+	const collection = collections.get(name);
+	if (!collection) throw new Error(`Collection "${name}" not found. Available collections: ${listCollections().join(", ")}`);
+	return createQueryBuilder(await collection.list());
+}
+async function getContentItem(collection, path) {
+	const col = collections.get(collection);
+	if (!col) return null;
+	return col.getItem(path);
+}
+async function fetchContentNavigation(collectionName) {
+	if (navigationCache && !collectionName) return navigationCache;
+	let allDocs = [];
+	if (collectionName) {
+		const col = collections.get(collectionName);
+		if (col) allDocs = await col.list();
+	} else for (const col of collections.values()) {
+		const docs = await col.list();
+		allDocs.push(...docs);
+	}
+	const nav = buildNavigation(allDocs);
+	if (!collectionName) navigationCache = nav;
+	return nav;
+}
+function registerContent(collectionName, documents) {
+	let collection = collections.get(collectionName);
+	if (!collection) {
+		collection = defineContentCollection({
+			name: collectionName,
+			source: collectionName,
+			documents
+		});
+		collections.set(collectionName, collection);
+	} else collection.documents.push(...documents);
+	navigationCache = null;
+	return collection;
+}
+function parseContentFile(raw, filePath, options) {
+	return parseContent(raw, filePath, options);
+}
+//#endregion
+export { pathToTitle as C, parseMarkdown as S, getExtension as _, getContentItem as a, parseContent as b, queryCollection as c, createContentCollection as d, createQueryBuilder as f, getDirname as g, getBasename as h, getCollection as i, registerContent as l, generateId as m, defineCollection as n, listCollections as o, defineContentCollection as p, fetchContentNavigation as r, parseContentFile as s, configureContentRuntime as t, buildNavigation as u, getStem as v, parseFrontmatter as x, normalizePath as y };

package/dist/runtime-zD72Z3v3.d.ts

@@ -0,0 +1,195 @@
+//#region src/types.d.ts
+type ContentType = 'markdown' | 'mdx' | 'json' | 'yaml' | 'csv' | 'html';
+interface ContentDocument {
+  _id: string;
+  _path: string;
+  _dir: string;
+  _file: string;
+  _type: ContentType;
+  _extension: string;
+  _draft: boolean;
+  _partial: boolean;
+  _empty: boolean;
+  title?: string;
+  description?: string;
+  date?: string;
+  draft?: boolean;
+  partial?: boolean;
+  navigation?: boolean | {
+    title?: string;
+    order?: number;
+  };
+  body?: ContentBody;
+  [key: string]: any;
+}
+interface ContentBody {
+  type: 'root';
+  children: MarkdownNode[];
+  toc?: ContentTocItem[];
+  excerpt?: string;
+}
+interface MarkdownNode {
+  type: string;
+  tag?: string;
+  value?: string;
+  props?: Record<string, any>;
+  children?: MarkdownNode[];
+}
+interface ContentTocItem {
+  id: string;
+  depth: number;
+  text: string;
+  children: ContentTocItem[];
+}
+interface ContentCollection {
+  name: string;
+  source: string;
+  type?: ContentType;
+  schema?: ContentSchema;
+  documents: ContentDocument[];
+  list: () => Promise<ContentDocument[]>;
+  getItem: (path: string) => Promise<ContentDocument | null>;
+  query: () => ContentQueryBuilder;
+}
+interface ContentFieldSchema {
+  type: 'string' | 'number' | 'boolean' | 'date' | 'array' | 'object' | 'markdown' | 'json';
+  required?: boolean;
+  default?: any;
+  items?: ContentFieldSchema;
+  properties?: Record<string, ContentFieldSchema>;
+  description?: string;
+  enum?: any[];
+  format?: string;
+}
+interface ContentSchema {
+  title?: string;
+  description?: string;
+  type: 'object';
+  properties: Record<string, ContentFieldSchema>;
+  required?: string[];
+}
+interface ContentQueryBuilder {
+  where(field: string, operator: string, value: any): ContentQueryBuilder;
+  where(query: Record<string, any>): ContentQueryBuilder;
+  sort(field: string, direction?: 'asc' | 'desc'): ContentQueryBuilder;
+  limit(count: number): ContentQueryBuilder;
+  skip(count: number): ContentQueryBuilder;
+  only(fields: string[]): ContentQueryBuilder;
+  without(fields: string[]): ContentQueryBuilder;
+  find(): Promise<ContentDocument[]>;
+  findOne(): Promise<ContentDocument | null>;
+  findSurround(path: string, options?: {
+    before?: number;
+    after?: number;
+  }): Promise<ContentDocument[]>;
+  count(): Promise<number>;
+}
+interface ContentModuleOptions {
+  sources: Record<string, ContentSourceConfig>;
+  defaultSource: string;
+  markdown: MarkdownOptions;
+  highlight: HighlightOptions;
+  navigation: boolean;
+  experimental: {
+    advancedSyntax: boolean;
+  };
+}
+interface ContentSourceConfig {
+  driver: 'fs' | 'github' | 'http' | 'custom';
+  base?: string;
+  dirname?: string;
+  prefix?: string;
+  driverOptions?: Record<string, any>;
+}
+interface MarkdownOptions {
+  toc: {
+    depth: number;
+    searchDepth: number;
+  };
+  anchorLinks: boolean;
+  externalLinks: boolean;
+  tables: boolean;
+  footnotes: boolean;
+  mdc: boolean;
+  remarkPlugins: any[];
+  rehypePlugins: any[];
+}
+interface HighlightOptions {
+  theme: string | Record<string, string>;
+  preload: string[];
+  langs: string[];
+  wrapperStyle: boolean;
+}
+interface ParsedContentMeta {
+  _id: string;
+  _path: string;
+  _file: string;
+  _dir: string;
+  _draft: boolean;
+  _partial: boolean;
+  _type: ContentType;
+  _extension: string;
+  _empty: boolean;
+  title?: string;
+  description?: string;
+  date?: string;
+  draft?: boolean;
+  partial?: boolean;
+  navigation?: boolean;
+}
+interface ContentNavigationItem {
+  title: string;
+  path: string;
+  id: string;
+  draft?: boolean;
+  children?: ContentNavigationItem[];
+}
+//#endregion
+//#region src/core.d.ts
+declare function generateId(path: string, extension?: string): string;
+declare function getDirname(path: string): string;
+declare function getBasename(path: string): string;
+declare function getExtension(filename: string): string;
+declare function getStem(filename: string): string;
+declare function normalizePath(path: string): string;
+declare function pathToTitle(path: string): string;
+declare function parseFrontmatter(content: string): {
+  data: Record<string, any>;
+  content: string;
+};
+declare function parseMarkdown(content: string): ContentBody;
+declare function createQueryBuilder(documents: ContentDocument[]): ContentQueryBuilder;
+declare function buildNavigation(documents: ContentDocument[], _options?: {
+  fields?: string[];
+}): ContentNavigationItem[];
+declare function parseContent(raw: string, filePath: string, options?: {
+  type?: string;
+}): ContentDocument;
+declare function defineContentCollection(collection: {
+  name: string;
+  source: string;
+  type?: any;
+  schema?: ContentSchema;
+  documents?: ContentDocument[];
+}): ContentCollection;
+declare function createContentCollection(name: string, source: string, documents?: ContentDocument[]): ContentCollection;
+//#endregion
+//#region src/runtime.d.ts
+declare function configureContentRuntime(_options?: Partial<ContentModuleOptions>): void;
+declare function defineCollection(config: {
+  name: string;
+  source: string;
+  type?: any;
+  schema?: ContentSchema;
+}): ContentCollection;
+declare function getCollection(name: string): ContentCollection | undefined;
+declare function listCollections(): string[];
+declare function queryCollection(name: string): Promise<ContentQueryBuilder>;
+declare function getContentItem(collection: string, path: string): Promise<ContentDocument | null>;
+declare function fetchContentNavigation(collectionName?: string): Promise<ContentNavigationItem[]>;
+declare function registerContent(collectionName: string, documents: ContentDocument[]): ContentCollection;
+declare function parseContentFile(raw: string, filePath: string, options?: {
+  type?: string;
+}): ContentDocument;
+//#endregion
+export { ContentQueryBuilder as A, pathToTitle as C, ContentFieldSchema as D, ContentDocument as E, MarkdownNode as F, ParsedContentMeta as I, ContentSourceConfig as M, ContentTocItem as N, ContentModuleOptions as O, ContentType as P, parseMarkdown as S, ContentCollection as T, getExtension as _, getContentItem as a, parseContent as b, queryCollection as c, createContentCollection as d, createQueryBuilder as f, getDirname as g, getBasename as h, getCollection as i, ContentSchema as j, ContentNavigationItem as k, registerContent as l, generateId as m, defineCollection as n, listCollections as o, defineContentCollection as p, fetchContentNavigation as r, parseContentFile as s, configureContentRuntime as t, buildNavigation as u, getStem as v, ContentBody as w, parseFrontmatter as x, normalizePath as y };

package/dist/runtime.d.ts

@@ -0,0 +1,2 @@
+import { A as ContentQueryBuilder, C as pathToTitle, E as ContentDocument, F as MarkdownNode, M as ContentSourceConfig, N as ContentTocItem, O as ContentModuleOptions, P as ContentType, S as parseMarkdown, T as ContentCollection, a as getContentItem, b as parseContent, c as queryCollection, d as createContentCollection, f as createQueryBuilder, i as getCollection, j as ContentSchema, k as ContentNavigationItem, l as registerContent, m as generateId, n as defineCollection, o as listCollections, p as defineContentCollection, r as fetchContentNavigation, s as parseContentFile, t as configureContentRuntime, u as buildNavigation, w as ContentBody, x as parseFrontmatter, y as normalizePath } from "./runtime-zD72Z3v3.js";
+export { type ContentBody, type ContentCollection, type ContentDocument, type ContentModuleOptions, type ContentNavigationItem, type ContentQueryBuilder, type ContentSchema, type ContentSourceConfig, type ContentTocItem, type ContentType, type MarkdownNode, buildNavigation, configureContentRuntime, createContentCollection, createQueryBuilder, defineCollection, defineContentCollection, fetchContentNavigation, generateId, getCollection, getContentItem, listCollections, normalizePath, parseContent, parseContentFile, parseFrontmatter, parseMarkdown, pathToTitle, queryCollection, registerContent };

package/dist/runtime.js

@@ -0,0 +1,2 @@
+import { C as pathToTitle, S as parseMarkdown, a as getContentItem, b as parseContent, c as queryCollection, d as createContentCollection, f as createQueryBuilder, i as getCollection, l as registerContent, m as generateId, n as defineCollection, o as listCollections, p as defineContentCollection, r as fetchContentNavigation, s as parseContentFile, t as configureContentRuntime, u as buildNavigation, x as parseFrontmatter, y as normalizePath } from "./runtime-C8qrycGf.js";
+export { buildNavigation, configureContentRuntime, createContentCollection, createQueryBuilder, defineCollection, defineContentCollection, fetchContentNavigation, generateId, getCollection, getContentItem, listCollections, normalizePath, parseContent, parseContentFile, parseFrontmatter, parseMarkdown, pathToTitle, queryCollection, registerContent };

package/dist/vite.d.ts

@@ -0,0 +1,25 @@
+import { Plugin } from "vite";
+//#region src/vite.d.ts
+interface UbeanContentOptions {
+  sources?: Record<string, {
+    dir: string;
+    prefix?: string;
+    type?: string;
+  }>;
+  defaultDir?: string;
+  ignores?: string[];
+  markdown?: {
+    toc?: {
+      depth?: number;
+      searchDepth?: number;
+    };
+    anchorLinks?: boolean;
+  };
+  navigation?: boolean;
+  experimental?: {
+    watch?: boolean;
+  };
+}
+declare function ubeanContentPlugin(userOptions?: UbeanContentOptions): Plugin;
+//#endregion
+export { UbeanContentOptions, ubeanContentPlugin as default, ubeanContentPlugin };

package/dist/vite.js

@@ -0,0 +1,111 @@
+import { l as registerContent, s as parseContentFile, t as configureContentRuntime } from "./runtime-C8qrycGf.js";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { defu } from "defu";
+import { join, relative, resolve } from "pathe";
+//#region src/vite.ts
+const defaultOptions = {
+	sources: { content: { dir: "content" } },
+	defaultDir: "content",
+	ignores: [
+		"draft",
+		"partial",
+		"."
+	],
+	navigation: true,
+	experimental: { watch: true }
+};
+const VIRTUAL_CONTENT = "virtual:ubean-content";
+const RESOLVED_VIRTUAL_CONTENT = `\0${VIRTUAL_CONTENT}`;
+function ubeanContentPlugin(userOptions = {}) {
+	const options = defu(userOptions, defaultOptions);
+	let rootDir;
+	let loadedDocuments = {};
+	function walkDir(dir, baseDir, files = []) {
+		if (!existsSync(dir)) return files;
+		const entries = readdirSync(dir);
+		for (const entry of entries) {
+			const fullPath = join(dir, entry);
+			if (statSync(fullPath).isDirectory()) {
+				if (entry === "node_modules" || entry.startsWith(".")) continue;
+				walkDir(fullPath, baseDir, files);
+			} else if (/\.(md|mdx|json|ya?ml)$/.test(entry)) files.push(relative(baseDir, fullPath));
+		}
+		return files;
+	}
+	function scanContent() {
+		loadedDocuments = {};
+		configureContentRuntime();
+		for (const [name, sourceConfig] of Object.entries(options.sources || {})) {
+			const contentDir = resolve(rootDir, sourceConfig.dir || options.defaultDir);
+			if (!existsSync(contentDir)) continue;
+			const files = walkDir(contentDir, contentDir);
+			const documents = [];
+			for (const file of files) {
+				const fullPath = join(contentDir, file);
+				try {
+					const parsed = parseContentFile(readFileSync(fullPath, "utf-8"), file, { type: sourceConfig.type });
+					if (sourceConfig.prefix) parsed._path = sourceConfig.prefix + parsed._path;
+					documents.push(parsed);
+				} catch (err) {
+					console.warn(`[ubean-content] Failed to parse ${file}:`, err);
+				}
+			}
+			loadedDocuments[name] = documents;
+			registerContent(name, documents);
+		}
+	}
+	return {
+		name: "ubean:content",
+		enforce: "pre",
+		configResolved(resolvedConfig) {
+			rootDir = resolvedConfig.root;
+			scanContent();
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_CONTENT || id.startsWith(`${VIRTUAL_CONTENT}/`)) return `\0${id}`;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_VIRTUAL_CONTENT) return `${Object.entries(loadedDocuments).map(([name, docs]) => `export const ${name} = ${JSON.stringify(docs)};`).join("\n")}
+
+export const collections = {
+${Object.keys(loadedDocuments).map((n) => `  ${n}: ${n}`).join(",\n")}
+};
+
+export function getCollection(name) {
+  return collections[name] || [];
+}
+
+export default collections;
+`;
+			if (id.startsWith(`${RESOLVED_VIRTUAL_CONTENT}/`)) {
+				const collectionName = id.slice(RESOLVED_VIRTUAL_CONTENT.length + 1);
+				const docs = loadedDocuments[collectionName] || [];
+				return `export default ${JSON.stringify(docs)};`;
+			}
+			return null;
+		},
+		configureServer(server) {
+			if (options.experimental?.watch) {
+				const watchPatterns = Object.values(options.sources || {}).map((s) => {
+					return join(s.dir || options.defaultDir, "**/*.{md,mdx,json,yaml,yml}");
+				});
+				server.watcher.add(watchPatterns);
+				server.watcher.on("change", () => {
+					scanContent();
+					server.ws.send({ type: "full-reload" });
+				});
+				server.watcher.on("add", () => {
+					scanContent();
+					server.ws.send({ type: "full-reload" });
+				});
+				server.watcher.on("unlink", () => {
+					scanContent();
+					server.ws.send({ type: "full-reload" });
+				});
+			}
+		}
+	};
+}
+//#endregion
+export { ubeanContentPlugin as default, ubeanContentPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/content",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "File-based content module for ubean (markdown/MDX/YAML/JSON)",
   "files": [
     "dist"