semajsx 0.1.1 → 0.1.2

package/dist/src-DR-EWgVP.mjs

@@ -0,0 +1,868 @@
+import { a as jsxs, i as jsx } from "./src-DW3tIczg.mjs";
+import { s as createApp } from "./src-DuSN6go_.mjs";
+import { n as renderDocument } from "./document-BOJDaiBc.mjs";
+import { createRequire } from "node:module";
+import { dirname, join, relative, resolve } from "path";
+import { mkdir, readFile, rm, watch, writeFile } from "fs/promises";
+import { compile } from "@mdx-js/mdx";
+import { glob } from "glob";
+import matter from "gray-matter";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { z as z$1 } from "zod";
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region ../ssg/src/document.tsx
+/**
+* Default HTML document template for SSG
+*/
+const DefaultDocument = ({ children, title = "SSG Page", scripts, css }) => /* @__PURE__ */ jsxs("html", {
+	lang: "en",
+	children: [/* @__PURE__ */ jsxs("head", { children: [
+		/* @__PURE__ */ jsx("meta", { charSet: "UTF-8" }),
+		/* @__PURE__ */ jsx("meta", {
+			name: "viewport",
+			content: "width=device-width, initial-scale=1.0"
+		}),
+		/* @__PURE__ */ jsx("title", { children: title }),
+		css?.map((href) => /* @__PURE__ */ jsx("link", {
+			rel: "stylesheet",
+			href
+		}))
+	] }), /* @__PURE__ */ jsxs("body", { children: [children, scripts] })]
+});
+
+//#endregion
+//#region ../ssg/src/types.ts
+/**
+* Raw HTML VNode that can be used directly in JSX or converted to string
+*/
+var RawHTML = class {
+	constructor(html) {
+		this.html = html;
+		this.type = "div";
+		this.children = [];
+		this.props = { dangerouslySetInnerHTML: { __html: html } };
+	}
+	toString() {
+		return this.html;
+	}
+};
+
+//#endregion
+//#region ../ssg/src/mdx/processor.ts
+/**
+* MDX Processor for compiling MDX content to JSX components
+*/
+var MDXProcessor = class {
+	constructor(config = {}) {
+		this.config = config;
+	}
+	/**
+	* Compile MDX content to a JSX component
+	*/
+	async compile(content, frontmatter = {}) {
+		const headings = this.extractHeadings(content);
+		const compiled = await compile(content, {
+			outputFormat: "function-body",
+			development: false,
+			remarkPlugins: this.config.remarkPlugins ?? [],
+			rehypePlugins: this.config.rehypePlugins ?? [],
+			jsxImportSource: "semajsx/dom"
+		});
+		const jsxRuntime = await import("semajsx/dom/jsx-runtime");
+		return {
+			Content: this.createComponent(String(compiled), this.config.components ?? {}, jsxRuntime),
+			frontmatter,
+			headings
+		};
+	}
+	/**
+	* Create a component from compiled MDX code
+	*/
+	createComponent(code, components, jsxRuntime) {
+		return (props = {}) => {
+			try {
+				return new Function(code + "\nreturn MDXContent;").call(null, jsxRuntime).default({
+					...props,
+					components
+				});
+			} catch (e) {
+				throw new Error(`MDX rendering failed: ${e.message}`);
+			}
+		};
+	}
+	/**
+	* Extract headings from markdown content
+	*/
+	extractHeadings(content) {
+		const headings = [];
+		const headingRegex = /^(#{1,6})\s+(.+)$/gm;
+		let match;
+		while ((match = headingRegex.exec(content)) !== null) {
+			const hashes = match[1];
+			const rawText = match[2];
+			if (!hashes || !rawText) continue;
+			const depth = hashes.length;
+			const text = rawText.trim();
+			const slug = this.slugify(text);
+			headings.push({
+				depth,
+				text,
+				slug
+			});
+		}
+		return headings;
+	}
+	/**
+	* Convert text to URL-friendly slug
+	*/
+	slugify(text) {
+		return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").trim();
+	}
+};
+/**
+* Create an MDX processor instance
+*/
+function createMDXProcessor(config) {
+	return new MDXProcessor(config);
+}
+
+//#endregion
+//#region ../ssg/src/mdx/vite-plugin.ts
+/**
+* Vite plugin for MDX support
+* Transforms .mdx files to JSX modules
+*/
+function viteMDXPlugin(options = {}) {
+	return {
+		name: "semajsx-mdx",
+		async transform(code, id) {
+			if (!id.endsWith(".mdx")) return null;
+			try {
+				const compiled = await compile(code, {
+					jsxImportSource: "semajsx/dom",
+					outputFormat: "program",
+					development: false,
+					remarkPlugins: options.remarkPlugins ?? [],
+					rehypePlugins: options.rehypePlugins ?? []
+				});
+				return {
+					code: String(compiled),
+					map: null
+				};
+			} catch (error) {
+				const err = error;
+				throw new Error(`MDX compilation failed for ${id}: ${err.message}`);
+			}
+		}
+	};
+}
+
+//#endregion
+//#region ../ssg/src/ssg.ts
+/**
+* Sort plugins by enforce order: 'pre' → normal → 'post'
+*/
+function sortPlugins(plugins) {
+	const pre = [];
+	const normal = [];
+	const post = [];
+	for (const plugin of plugins) if (plugin.enforce === "pre") pre.push(plugin);
+	else if (plugin.enforce === "post") post.push(plugin);
+	else normal.push(plugin);
+	return [
+		...pre,
+		...normal,
+		...post
+	];
+}
+/**
+* Merge a partial MDX config into an existing one.
+*/
+function mergeMdxConfig(base, partial) {
+	return {
+		remarkPlugins: [...base.remarkPlugins ?? [], ...partial.remarkPlugins ?? []],
+		rehypePlugins: [...base.rehypePlugins ?? [], ...partial.rehypePlugins ?? []],
+		components: {
+			...base.components,
+			...partial.components
+		}
+	};
+}
+/**
+* Run config hooks on all plugins, then merge with user config.
+*
+* Plugin arrays are flattened Vite-style: plugin factories may return
+* `SSGPlugin | SSGPlugin[]`, and the top-level array is `.flat()`-ed
+* before sorting and processing.
+*
+* Merge strategies:
+* - mdx: merge (concat arrays, merge component objects)
+* - document: override (last writer wins, user config last)
+* - routes: concat (plugin routes first, then user routes)
+* - collections: concat (plugin collections first, then user collections)
+*/
+function resolvePlugins(plugins, config) {
+	const sorted = sortPlugins(plugins.flat());
+	let mdx = {
+		remarkPlugins: [],
+		rehypePlugins: [],
+		components: {}
+	};
+	let document;
+	const routes = [];
+	const collections = [];
+	for (const plugin of sorted) {
+		if (!plugin.config) continue;
+		const partial = plugin.config(config);
+		if (!partial) continue;
+		if (partial.mdx) mdx = mergeMdxConfig(mdx, partial.mdx);
+		if (partial.document) document = partial.document;
+		if (partial.routes) routes.push(...partial.routes);
+		if (partial.collections) collections.push(...partial.collections);
+	}
+	if (config.mdx) mdx = mergeMdxConfig(mdx, config.mdx);
+	if (config.document) document = config.document;
+	if (config.routes) routes.push(...config.routes);
+	if (config.collections) collections.push(...config.collections);
+	return {
+		config: {
+			mdx,
+			document,
+			routes,
+			collections
+		},
+		allPlugins: sorted
+	};
+}
+/**
+* SSG (Static Site Generator) core class
+* Built on top of server's createApp
+*/
+var SSG = class {
+	constructor(config) {
+		this.mdxModules = /* @__PURE__ */ new Map();
+		this.rootDir = config.rootDir ?? process.cwd();
+		const { config: resolved, allPlugins } = resolvePlugins(config.plugins ?? [], config);
+		this.plugins = allPlugins;
+		this.config = {
+			base: "/",
+			...config,
+			mdx: resolved.mdx,
+			document: resolved.document,
+			routes: resolved.routes,
+			collections: resolved.collections,
+			outDir: resolve(this.rootDir, config.outDir)
+		};
+		for (const plugin of this.plugins) plugin.configResolved?.(this.config);
+		this.collections = /* @__PURE__ */ new Map();
+		this.entriesCache = /* @__PURE__ */ new Map();
+		this.app = createApp({
+			root: this.rootDir,
+			vite: { plugins: [{
+				name: "ssg-virtual-mdx",
+				resolveId: (id) => {
+					if (id.startsWith("virtual:mdx:")) return "\0" + id;
+				},
+				load: (id) => {
+					if (id.startsWith("\0virtual:mdx:")) {
+						const mdxId = id.replace("\0virtual:mdx:", "");
+						return this.mdxModules.get(mdxId);
+					}
+				}
+			}, viteMDXPlugin(resolved.mdx)] }
+		});
+		for (const collection of this.config.collections ?? []) this.collections.set(collection.name, collection);
+	}
+	getRootDir() {
+		return this.rootDir;
+	}
+	async getCollection(name) {
+		const collection = this.collections.get(name);
+		if (!collection) throw new Error(`Collection "${name}" not found`);
+		if (this.entriesCache.has(name)) return this.entriesCache.get(name);
+		const validatedEntries = (await collection.source.getEntries()).map((entry) => {
+			const result = collection.schema.safeParse(entry.data);
+			if (!result.success) throw new Error(`Validation error in ${name}/${entry.id}: ${result.error.message}`);
+			return {
+				...entry,
+				data: result.data,
+				render: async () => {
+					const vite = this.app.getViteServer();
+					if (!vite) throw new Error("Vite server not initialized");
+					const mdxId = `${name}/${entry.id}.mdx`;
+					this.mdxModules.set(mdxId, entry.body);
+					try {
+						const moduleExports = await vite.ssrLoadModule(`virtual:mdx:${mdxId}`);
+						const Content = (props = {}) => moduleExports.default({
+							...props,
+							components: this.config.mdx?.components ?? {}
+						});
+						return {
+							Content,
+							headings: this.extractHeadings(entry.body)
+						};
+					} finally {
+						this.mdxModules.delete(mdxId);
+					}
+				}
+			};
+		});
+		this.entriesCache.set(name, validatedEntries);
+		return validatedEntries;
+	}
+	async getEntry(name, id) {
+		return (await this.getCollection(name)).find((e) => e.id === id || e.slug === id) ?? null;
+	}
+	async build(options = {}) {
+		const { incremental = false, state: prevState } = options;
+		const outDir = this.config.outDir;
+		for (const plugin of this.plugins) await plugin.buildStart?.();
+		await this.app.prepare();
+		try {
+			await this.registerRoutes();
+			const result = await this.buildPages(incremental, prevState, outDir);
+			const documentTemplate = this.config.document ?? DefaultDocument;
+			await this.app.build({
+				outDir,
+				mode: "full",
+				minify: true,
+				renderHtml: ({ html, css, scripts, title, path: routePath }) => {
+					const scriptsHtml = scripts.map((s) => `<script type="module" src="${s.src}"><\/script>`).join("\n");
+					return renderDocument(documentTemplate({
+						children: new RawHTML(html),
+						title,
+						base: this.config.base ?? "/",
+						path: routePath,
+						props: {},
+						scripts: scriptsHtml ? new RawHTML(scriptsHtml) : void 0,
+						css: css ?? []
+					}));
+				},
+				vite: { build: { rollupOptions: { external: [] } } }
+			});
+			for (const plugin of this.plugins) await plugin.buildEnd?.(result);
+			return result;
+		} finally {
+			await this.app.close();
+		}
+	}
+	async registerRoutes() {
+		const routes = this.config.routes ?? [];
+		for (const route of routes) if (route.getStaticPaths) {
+			const staticPaths = await route.getStaticPaths(this);
+			for (const sp of staticPaths) {
+				const path = this.applyParams(route.path, sp.params);
+				const props = {
+					...sp.props,
+					params: sp.params
+				};
+				this.app.route(path, (_context) => {
+					return route.component(props);
+				}, { title: props.title });
+			}
+		} else {
+			let props = {};
+			if (typeof route.props === "function") props = await route.props(this);
+			else if (route.props) props = route.props;
+			this.app.route(route.path, (_context) => {
+				return route.component(props);
+			}, { title: props.title });
+		}
+	}
+	async buildPages(incremental, prevState, outDir) {
+		const state = {
+			cursors: {},
+			pageHashes: {},
+			timestamp: Date.now()
+		};
+		const stats = {
+			added: 0,
+			updated: 0,
+			deleted: 0,
+			unchanged: 0
+		};
+		const builtPaths = [];
+		if (!incremental) await rm(outDir, {
+			recursive: true,
+			force: true
+		});
+		await mkdir(outDir, { recursive: true });
+		this.entriesCache.clear();
+		const allPaths = await this.generateAllPaths();
+		const currentPaths = new Set(allPaths.map((p) => p.path));
+		if (incremental && prevState) {
+			for (const oldPath of Object.keys(prevState.pageHashes)) if (!currentPaths.has(oldPath)) {
+				const filePath = this.pathToFilePath(oldPath);
+				try {
+					await rm(join(outDir, filePath));
+					stats.deleted++;
+				} catch {}
+			}
+		}
+		for (const { path, props } of allPaths) {
+			const html = await this.renderPage(path, props);
+			const hash = this.hashContent(html);
+			const prevHash = prevState?.pageHashes[path];
+			if (!incremental || !prevHash || prevHash !== hash) {
+				const fullPath = join(outDir, this.pathToFilePath(path));
+				await mkdir(dirname(fullPath), { recursive: true });
+				await writeFile(fullPath, html);
+				builtPaths.push(path);
+				if (!prevHash) stats.added++;
+				else stats.updated++;
+			} else stats.unchanged++;
+			state.pageHashes[path] = hash;
+		}
+		for (const [name, collection] of this.collections) if (collection.source.getChanges) state.cursors[name] = Date.now().toString();
+		return {
+			state,
+			paths: builtPaths,
+			stats
+		};
+	}
+	async renderPage(path, props) {
+		const result = await this.app.render(path);
+		const documentProps = {
+			children: new RawHTML(result.html),
+			title: props.title,
+			base: this.config.base ?? "/",
+			path,
+			props,
+			scripts: result.scripts ? new RawHTML(result.scripts) : void 0,
+			css: result.css ?? []
+		};
+		return renderDocument((this.config.document ?? DefaultDocument)(documentProps));
+	}
+	async generateAllPaths() {
+		const paths = [];
+		const routes = this.config.routes ?? [];
+		for (const route of routes) if (route.getStaticPaths) {
+			const staticPaths = await route.getStaticPaths(this);
+			for (const sp of staticPaths) {
+				const path = this.applyParams(route.path, sp.params);
+				paths.push({
+					path,
+					props: {
+						...sp.props,
+						params: sp.params
+					}
+				});
+			}
+		} else {
+			let props = {};
+			if (typeof route.props === "function") props = await route.props(this);
+			else if (route.props) props = route.props;
+			paths.push({
+				path: route.path,
+				props
+			});
+		}
+		return paths;
+	}
+	watch(options = {}) {
+		const unsubscribers = [];
+		for (const [name, collection] of this.collections) if (collection.source.watch) {
+			const unsubscribe = collection.source.watch(async () => {
+				try {
+					this.entriesCache.delete(name);
+					const result = await this.build({ incremental: true });
+					options.onRebuild?.(result);
+				} catch (error) {
+					options.onError?.(error);
+				}
+			});
+			unsubscribers.push(unsubscribe);
+		}
+		return { close: () => unsubscribers.forEach((fn) => fn()) };
+	}
+	pathToFilePath(urlPath) {
+		if (urlPath === "/") return "index.html";
+		return `${urlPath.slice(1)}/index.html`;
+	}
+	applyParams(pattern, params) {
+		let path = pattern;
+		for (const [key, value] of Object.entries(params)) path = path.replace(`:${key}`, value);
+		return path;
+	}
+	hashContent(content) {
+		let hash = 0;
+		for (let i = 0; i < content.length; i++) {
+			const char = content.charCodeAt(i);
+			hash = (hash << 5) - hash + char;
+			hash = hash & hash;
+		}
+		return hash.toString(16);
+	}
+	extractHeadings(content) {
+		const headings = [];
+		const regex = /^(#{1,6})\s+(.+)$/gm;
+		let match;
+		while ((match = regex.exec(content)) !== null) {
+			if (!match[1] || !match[2]) continue;
+			const depth = match[1].length;
+			const text = match[2].trim();
+			const slug = text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/\s+/g, "-");
+			headings.push({
+				depth,
+				text,
+				slug
+			});
+		}
+		return headings;
+	}
+};
+function createSSG(config) {
+	return new SSG(config);
+}
+
+//#endregion
+//#region ../ssg/src/collection/index.ts
+/**
+* Define a collection with schema validation
+*/
+function defineCollection(config) {
+	return {
+		name: config.name,
+		source: config.source,
+		schema: config.schema
+	};
+}
+
+//#endregion
+//#region ../ssg/src/sources/base.ts
+/**
+* Base class for collection sources
+*/
+var BaseSource = class {
+	async getEntry(id) {
+		return (await this.getEntries()).find((e) => e.id === id) ?? null;
+	}
+};
+
+//#endregion
+//#region ../ssg/src/sources/file.ts
+/**
+* File system source for collections
+*/
+var FileSource = class extends BaseSource {
+	constructor(options, contentRoot = process.cwd()) {
+		super();
+		this.directory = options.directory;
+		this.include = options.include ?? "**/*.{md,mdx}";
+		this.shouldWatch = options.watch ?? false;
+		this.contentRoot = contentRoot;
+		this.id = `file:${this.directory}`;
+	}
+	async getEntries() {
+		const dir = join(this.contentRoot, this.directory);
+		const files = await glob(join(dir, this.include));
+		return await Promise.all(files.map(async (filePath) => {
+			const { data, content: body } = matter(await readFile(filePath, "utf-8"));
+			const id = relative(dir, filePath).replace(/\.(md|mdx)$/, "");
+			return {
+				id,
+				slug: id.replace(/\\/g, "/"),
+				data,
+				body,
+				render: async () => {
+					return { Content: () => {
+						throw new Error("MDX rendering not yet implemented");
+					} };
+				}
+			};
+		}));
+	}
+	watch(callback) {
+		if (!this.shouldWatch) return () => {};
+		const dir = join(this.contentRoot, this.directory);
+		const abortController = new AbortController();
+		const startWatching = async () => {
+			try {
+				const watcher = watch(dir, {
+					recursive: true,
+					signal: abortController.signal
+				});
+				for await (const _event of watcher) {
+					const entries = await this.getEntries();
+					callback({
+						cursor: Date.now().toString(),
+						added: [],
+						updated: entries,
+						deleted: []
+					});
+				}
+			} catch (err) {
+				if (err.name !== "AbortError") throw err;
+			}
+		};
+		startWatching();
+		return () => {
+			abortController.abort();
+		};
+	}
+	async getChanges(_since) {
+		const entries = await this.getEntries();
+		return {
+			cursor: Date.now().toString(),
+			added: [],
+			updated: entries,
+			deleted: []
+		};
+	}
+};
+/**
+* Create a file system source
+*/
+function fileSource(options, contentRoot) {
+	return new FileSource(options, contentRoot);
+}
+
+//#endregion
+//#region ../ssg/src/sources/git.ts
+const execAsync = promisify(exec);
+/**
+* Git source for collections
+*/
+var GitSource = class extends BaseSource {
+	constructor(options, cwd = process.cwd()) {
+		super();
+		this.options = options;
+		this.cwd = cwd;
+		this.id = `git:${options.type}`;
+	}
+	async getEntries() {
+		if (this.options.type === "commits") return this.getCommits(this.options);
+		else return this.getTags(this.options);
+	}
+	async getCommits(options) {
+		const args = ["log", "--format=%H|%s|%an|%ae|%aI"];
+		if (options.filter?.since) args.push(`--since=${options.filter.since}`);
+		if (options.filter?.until) args.push(`--until=${options.filter.until}`);
+		if (options.filter?.author) args.push(`--author=${options.filter.author}`);
+		if (options.limit) args.push(`-n`, options.limit.toString());
+		if (options.filter?.paths?.length) args.push("--", ...options.filter.paths);
+		const { stdout } = await execAsync(`git ${args.join(" ")}`, { cwd: this.cwd });
+		return stdout.trim().split("\n").filter(Boolean).map((line) => {
+			const parts = line.split("|");
+			const hash = parts[0] ?? "";
+			const message = parts[1] ?? "";
+			const author = parts[2] ?? "";
+			const email = parts[3] ?? "";
+			const dateStr = parts[4] ?? "";
+			const data = {
+				hash,
+				message,
+				author,
+				email,
+				date: new Date(dateStr)
+			};
+			return {
+				id: hash,
+				slug: hash.slice(0, 7),
+				data,
+				body: message,
+				render: async () => ({ Content: () => {
+					throw new Error("Git commits cannot be rendered as content");
+				} })
+			};
+		});
+	}
+	async getTags(options) {
+		const { stdout } = await execAsync(`git tag -l "${options.pattern ?? "*"}" --format="%(refname:short)|%(objectname:short)|%(creatordate:iso)|%(contents:subject)"`, { cwd: this.cwd });
+		return stdout.trim().split("\n").filter(Boolean).map((line) => {
+			const parts = line.split("|");
+			const tag = parts[0] ?? "";
+			const hash = parts[1] ?? "";
+			const dateStr = parts[2] ?? "";
+			const message = parts[3] ?? "";
+			return {
+				id: tag,
+				slug: tag,
+				data: {
+					tag,
+					hash,
+					date: new Date(dateStr),
+					message: message || void 0
+				},
+				body: message,
+				render: async () => ({ Content: () => {
+					throw new Error("Git tags cannot be rendered as content");
+				} })
+			};
+		});
+	}
+};
+/**
+* Create a Git source
+*/
+function gitSource(options, cwd) {
+	return new GitSource(options, cwd);
+}
+
+//#endregion
+//#region ../ssg/src/sources/remote.ts
+/**
+* Remote API source for collections
+*/
+var RemoteSource = class extends BaseSource {
+	constructor(options, id = "remote") {
+		super();
+		this.options = options;
+		this.id = `remote:${id}`;
+	}
+	async getEntries() {
+		return (await this.options.fetch()).map((item, index) => {
+			const id = item.id?.toString() ?? index.toString();
+			return {
+				id,
+				slug: item.slug?.toString() ?? id,
+				data: item,
+				body: item.content?.toString() ?? "",
+				render: async () => ({ Content: () => {
+					throw new Error("Remote content rendering not yet implemented");
+				} })
+			};
+		});
+	}
+	async getEntry(id) {
+		if (this.options.fetchOne) {
+			const item = await this.options.fetchOne(id);
+			if (!item) return null;
+			return {
+				id,
+				slug: item.slug?.toString() ?? id,
+				data: item,
+				body: item.content?.toString() ?? "",
+				render: async () => ({ Content: () => {
+					throw new Error("Remote content rendering not yet implemented");
+				} })
+			};
+		}
+		return super.getEntry(id);
+	}
+	watch(callback) {
+		if (this.options.pollInterval) {
+			this.pollTimer = setInterval(async () => {
+				const entries = await this.getEntries();
+				callback({
+					cursor: Date.now().toString(),
+					added: [],
+					updated: entries,
+					deleted: []
+				});
+			}, this.options.pollInterval);
+			return () => {
+				if (this.pollTimer) clearInterval(this.pollTimer);
+			};
+		}
+		return () => {};
+	}
+	async getChanges(since) {
+		if (this.options.fetchChanges) return this.options.fetchChanges(since);
+		const entries = await this.getEntries();
+		return {
+			cursor: Date.now().toString(),
+			added: [],
+			updated: entries,
+			deleted: []
+		};
+	}
+	/**
+	* Get webhook configuration for external integration
+	*/
+	getWebhookConfig() {
+		return this.options.webhook;
+	}
+};
+/**
+* Create a remote API source
+*/
+function remoteSource(options, id) {
+	return new RemoteSource(options, id);
+}
+
+//#endregion
+//#region ../ssg/src/sources/custom.ts
+/**
+* Custom source for collections
+*/
+var CustomSource = class extends BaseSource {
+	constructor(options) {
+		super();
+		this.options = options;
+		this.id = options.id;
+	}
+	async getEntries() {
+		return (await this.options.getEntries()).map((item, index) => {
+			const id = item.id?.toString() ?? index.toString();
+			return {
+				id,
+				slug: item.slug?.toString() ?? id,
+				data: item,
+				body: item.body?.toString() ?? "",
+				render: async () => ({ Content: () => {
+					throw new Error("Custom content rendering not yet implemented");
+				} })
+			};
+		});
+	}
+	async getEntry(id) {
+		if (this.options.getEntry) {
+			const item = await this.options.getEntry(id);
+			if (!item) return null;
+			return {
+				id,
+				slug: item.slug?.toString() ?? id,
+				data: item,
+				body: item.body?.toString() ?? "",
+				render: async () => ({ Content: () => {
+					throw new Error("Custom content rendering not yet implemented");
+				} })
+			};
+		}
+		return super.getEntry(id);
+	}
+	watch(callback) {
+		if (this.options.watch) return this.options.watch(callback);
+		return () => {};
+	}
+	async getChanges(since) {
+		if (this.options.getChanges) return this.options.getChanges(since);
+		const entries = await this.getEntries();
+		return {
+			cursor: Date.now().toString(),
+			added: [],
+			updated: entries,
+			deleted: []
+		};
+	}
+};
+/**
+* Create a custom source
+*/
+function createSource(options) {
+	return new CustomSource(options);
+}
+
+//#endregion
+export { DefaultDocument as _, remoteSource as a, FileSource as c, defineCollection as d, SSG as f, RawHTML as g, createMDXProcessor as h, RemoteSource as i, fileSource as l, MDXProcessor as m, CustomSource as n, GitSource as o, createSSG as p, createSource as r, gitSource as s, z$1 as t, BaseSource as u, __exportAll as v, __require as y };
+//# sourceMappingURL=src-DR-EWgVP.mjs.map