@minidocs/astro 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,275 @@
+import { t as contentOptions } from "./routing-D28b92w8.mjs";
+import { a as registry, c as renderConfigTypes, i as namedCollections, n as remarkContentLinks, o as findUnbuiltPages, r as satteriContentLinks } from "./links-Dp7d5R-O.mjs";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseFilePath } from "@minidocs/core";
+import remarkDirective from "remark-directive";
+//#region src/callouts.ts
+/** Callout types, shared by `:::type` directives, `> [!TYPE]` alerts and the `Callout` component. */
+const CALLOUT_TYPES = [
+	"note",
+	"tip",
+	"important",
+	"warning",
+	"caution"
+];
+const isType = (name) => CALLOUT_TYPES.includes(name);
+/** Same markup as the Callout component renders, as mdast data for the HTML conversion. */
+const calloutData = (type) => ({
+	hName: "div",
+	hProperties: {
+		className: ["md-callout"],
+		dataType: type,
+		role: "note"
+	}
+});
+const titleData = {
+	hName: "p",
+	hProperties: { className: ["md-callout-title"] }
+};
+const ALERT = /^\[!(\w+)\][ \t]*(?:\n|$)/;
+function unknownDirective(name) {
+	return /* @__PURE__ */ new Error(`[minidocs] Unknown callout type ":::${name}". Use one of ${CALLOUT_TYPES.join(", ")}, or handle it with your own plugin.`);
+}
+/** Reads the type of a `> [!TYPE]` alert and what is left of its first line, or `undefined` for plain blockquotes. */
+function parseAlert(blockquote) {
+	const paragraph = blockquote.children?.[0];
+	const text = paragraph?.type === "paragraph" ? paragraph.children?.[0] : void 0;
+	const match = text?.type === "text" ? ALERT.exec(text.value ?? "") : null;
+	const type = match?.[1]?.toLowerCase();
+	if (!match || !type || !isType(type)) return void 0;
+	const rest = text.value.slice(match[0].length);
+	return {
+		type,
+		paragraph,
+		text,
+		rest,
+		empty: !rest && paragraph.children.length === 1
+	};
+}
+/**
+* Turning on directives also parses `:name` in text and `::name` lines, which would silently drop `10:30` or `a:hover`.
+* Only `:::` blocks are callouts, so the others go back to their source text.
+*/
+function restoreSatteri(block) {
+	return (node, context) => {
+		const text = {
+			type: "text",
+			value: context.source.slice(node.position.start.offset, node.position.end.offset)
+		};
+		context.replaceNode(node, block ? {
+			type: "paragraph",
+			children: [text]
+		} : text);
+	};
+}
+/** Plugin for Sätteri, Astro's default Markdown processor. */
+function satteriCallouts(options) {
+	return {
+		name: "minidocs-callouts",
+		options: { position: true },
+		...options.directives && {
+			containerDirective(node, context) {
+				if (node.data?.hName) return;
+				const name = node.name ?? "";
+				if (!isType(name)) throw unknownDirective(name);
+				const label = node.children?.[0];
+				if (label?.type === "paragraph" && label.data?.directiveLabel) context.setProperty(label, "data", titleData);
+				context.setProperty(node, "data", calloutData(name));
+			},
+			leafDirective: restoreSatteri(true),
+			textDirective: restoreSatteri(false)
+		},
+		...options.alerts && { blockquote(node, context) {
+			const alert = parseAlert(node);
+			if (!alert) return;
+			if (alert.empty) context.removeNode(alert.paragraph);
+			else context.setProperty(alert.text, "value", alert.rest);
+			context.setProperty(node, "data", calloutData(alert.type));
+		} }
+	};
+}
+/** Remark plugin for the unified processor. Directive parsing comes from `remark-directive`, added before it. */
+function remarkCallouts(options) {
+	return () => (tree, file) => {
+		const source = String(file.value ?? "");
+		const visit = (node) => {
+			const children = node.children ?? [];
+			for (let index = 0; index < children.length; index++) {
+				const child = children[index];
+				if (options.directives && (child.type === "textDirective" || child.type === "leafDirective")) {
+					const text = {
+						type: "text",
+						value: source.slice(child.position?.start.offset, child.position?.end.offset)
+					};
+					children[index] = child.type === "leafDirective" ? {
+						type: "paragraph",
+						children: [text]
+					} : text;
+					continue;
+				}
+				if (options.directives && child.type === "containerDirective" && !child.data?.hName) {
+					const name = child.name ?? "";
+					if (!isType(name)) throw unknownDirective(name);
+					const label = child.children?.[0];
+					if (label?.type === "paragraph" && label.data?.directiveLabel) label.data = {
+						...label.data,
+						...titleData
+					};
+					child.data = {
+						...child.data,
+						...calloutData(name)
+					};
+				}
+				if (options.alerts && child.type === "blockquote") {
+					const alert = parseAlert(child);
+					if (alert) {
+						if (alert.empty) child.children.shift();
+						else alert.text.value = alert.rest;
+						child.data = {
+							...child.data,
+							...calloutData(alert.type)
+						};
+					}
+				}
+				visit(child);
+			}
+		};
+		visit(tree);
+	};
+}
+//#endregion
+//#region src/markdown.ts
+/**
+* Adds minidocs' Markdown features to the configured processor, which MDX uses too unless given its own.
+* Processors are meant to be extended in place. Returns `false` for processors minidocs does not know.
+*/
+function extendProcessor(processor, callouts) {
+	const options = processor.options;
+	if (processor.name === "satteri") {
+		if (callouts.directives) options.features = {
+			...options.features,
+			directive: true
+		};
+		options.mdastPlugins = [
+			...options.mdastPlugins ?? [],
+			satteriContentLinks,
+			satteriCallouts(callouts)
+		];
+		return true;
+	}
+	if (processor.name === "unified") {
+		options.remarkPlugins = [
+			...options.remarkPlugins ?? [],
+			...callouts.directives ? [remarkDirective] : [],
+			remarkContentLinks,
+			remarkCallouts(callouts)
+		];
+		return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/settings.ts
+const trim = (path) => path.replace(/^\/+|\/+$/g, "");
+function resolveSettings(config, options) {
+	return {
+		base: trim(config.base),
+		trailingSlash: config.trailingSlash === "always" || config.trailingSlash === "ignore" && config.build.format === "directory",
+		i18n: resolveI18n(config.i18n, options),
+		site: config.site ? config.site.replace(/\/+$/, "") : null
+	};
+}
+function resolveI18n(i18n, options) {
+	if (!i18n) {
+		if (options.fallback) throw new Error("[minidocs] `fallback` requires `i18n` in your Astro config.");
+		return null;
+	}
+	if (i18n.fallback && Object.keys(i18n.fallback).length > 0) throw new Error("[minidocs] Astro's `i18n.fallback` works per route file and produces wrong pages for content-driven docs routes in static builds. Remove it and declare fallback with `minidocs({ fallback })` instead.");
+	if (i18n.routing === "manual") throw new Error("[minidocs] `i18n.routing: \"manual\"` is not supported yet.");
+	const locales = i18n.locales.map((locale) => {
+		if (typeof locale !== "string") throw new Error("[minidocs] Locales with custom paths are not supported yet. Use plain locale strings.");
+		return locale;
+	});
+	const fallback = options.fallback ?? {};
+	for (const [locale, targets] of Object.entries(fallback)) for (const target of [locale, ...[targets].flat()]) if (!locales.includes(target)) throw new Error(`[minidocs] Fallback refers to "${target}", which is not one of i18n.locales (${locales.join(", ")}).`);
+	return {
+		locales,
+		defaultLocale: i18n.defaultLocale,
+		prefixDefaultLocale: i18n.routing?.prefixDefaultLocale ?? false,
+		fallback
+	};
+}
+//#endregion
+//#region src/index.ts
+const CONFIG_ID = "virtual:minidocs/config";
+const RENDERERS_ID = "virtual:minidocs/renderers";
+function minidocs(options = {}) {
+	let hasMdx = false;
+	let isStatic = false;
+	return {
+		name: "minidocs",
+		hooks: {
+			"astro:config:setup"({ config, updateConfig, logger }) {
+				const callouts = {
+					directives: options.markdown?.directives ?? true,
+					alerts: options.markdown?.alerts ?? true
+				};
+				if (!extendProcessor(config.markdown.processor, callouts)) logger.warn(`Content links and callouts are not supported with the "${config.markdown.processor.name}" Markdown processor.`);
+				updateConfig({ vite: {
+					plugins: [{
+						name: "minidocs:config",
+						resolveId: (id) => id === CONFIG_ID ? `\0${CONFIG_ID}` : void 0,
+						load: (id) => id === `\0${CONFIG_ID}` ? `export default ${JSON.stringify({
+							...registry.settings,
+							collections: Object.fromEntries(Object.entries(namedCollections()).map(([name, collection]) => [name, {
+								base: collection.base,
+								prefix: collection.prefix,
+								pageIds: pageIds(collection)
+							}]))
+						})};` : void 0
+					}, {
+						name: "minidocs:renderers",
+						resolveId: (id) => id === RENDERERS_ID ? `\0${RENDERERS_ID}` : void 0,
+						load: (id) => id === `\0${RENDERERS_ID}` ? hasMdx ? `import { getContainerRenderer } from '@astrojs/mdx/container-renderer';\nexport default [getContainerRenderer()];` : "export default [];" : void 0
+					}],
+					ssr: { noExternal: ["@minidocs/astro", "@minidocs/core"] }
+				} });
+			},
+			"astro:config:done"({ config, injectTypes }) {
+				registry.settings = resolveSettings(config, options);
+				registry.root = fileURLToPath(config.root);
+				hasMdx = config.integrations.some(({ name }) => name === "@astrojs/mdx");
+				isStatic = config.output === "static" && !config.adapter;
+				const injected = injectTypes({
+					filename: "types.d.ts",
+					content: renderConfigTypes(registry.settings)
+				});
+				registry.typesFile = new URL("./collections.d.ts", injected);
+				const path = fileURLToPath(registry.typesFile);
+				if (!existsSync(path)) {
+					mkdirSync(dirname(path), { recursive: true });
+					writeFileSync(path, "export {};\n");
+				}
+			},
+			"astro:build:done"({ pages }) {
+				if (!isStatic || !registry.settings) return;
+				const built = new Set(pages.map(({ pathname }) => pathname.replace(/^\/+|\/+$/g, "")));
+				const missing = findUnbuiltPages(registry.settings, namedCollections(), built);
+				if (missing.length === 0) return;
+				const shown = missing.slice(0, 10).map((page) => `  ${page}`);
+				if (missing.length > shown.length) shown.push(`  and ${missing.length - shown.length} more`);
+				throw new Error(`[minidocs] No route built these pages, so links to them are broken. Check that each collection's route file sits in the folder its prefix names.\n${shown.join("\n")}`);
+			}
+		}
+	};
+}
+/** Ids of every page in a collection, in any locale. */
+function pageIds(collection) {
+	if (!registry.settings) return [];
+	const { locales, localeDirs } = contentOptions(registry.settings, collection.base);
+	return [...new Set(collection.filePaths.map((filePath) => parseFilePath(filePath, collection.base, locales, localeDirs).id))];
+}
+//#endregion
+export { minidocs as default };

package/dist/links-Dp7d5R-O.mjs

@@ -0,0 +1,242 @@
+import { i as markdownHref, n as href, o as routePath, t as contentOptions } from "./routing-D28b92w8.mjs";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, posix, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { listPages, parseFilePath } from "@minidocs/core";
+//#region src/codegen.ts
+const union = (values) => {
+	const list = [...new Set(values)].sort().map((value) => JSON.stringify(value));
+	return list.length > 0 ? list.join(" | ") : "never";
+};
+const byName = (collections) => Object.entries(collections).sort(([a], [b]) => a < b ? -1 : 1);
+/** Every page a collection needs a route for, with the locale its URL is built with. */
+function pagesOf(settings, collection) {
+	return listPages(collection.filePaths.map((filePath) => ({ filePath })), contentOptions(settings, collection.base)).map((page) => ({
+		...page,
+		urlLocale: settings.i18n ? page.locale : void 0
+	}));
+}
+/** Renders the site-wide types, known as soon as the config is resolved. */
+function renderConfigTypes(settings) {
+	return [
+		"// Generated by minidocs. Do not edit.",
+		"/// <reference path=\"./collections.d.ts\" />",
+		"declare module '@minidocs/astro/runtime' {",
+		`\tinterface Config { ${settings.i18n ? `i18n: true; locale: ${union(settings.i18n.locales)};` : "i18n: false;"} }`,
+		"}",
+		"export {};",
+		""
+	].join("\n");
+}
+/** Renders the declaration file that types page ids and directories per collection, and per locale for multilingual sites. */
+function renderTypes(settings, collections) {
+	const lines = [
+		"// Generated by minidocs. Do not edit.",
+		"declare module '@minidocs/astro/runtime' {",
+		"	interface Collections {"
+	];
+	for (const [name, collection] of byName(collections)) {
+		const options = contentOptions(settings, collection.base);
+		const pages = pagesOf(settings, collection);
+		const idsAndDirs = (locale) => {
+			const inLocale = pages.filter((page) => page.locale === locale);
+			const dirs = /* @__PURE__ */ new Set([""]);
+			for (const page of inLocale) {
+				const { dir } = parseFilePath(page.entry.filePath, collection.base, options.locales, options.localeDirs);
+				const segments = dir.split("/").filter(Boolean);
+				for (let i = 1; i <= segments.length; i++) dirs.add(segments.slice(0, i).join("/"));
+			}
+			return {
+				ids: union(inLocale.map((page) => page.id)),
+				dirs: union(dirs)
+			};
+		};
+		lines.push(`\t\t${JSON.stringify(name)}: {`);
+		if (settings.i18n) {
+			const perLocale = options.locales.map((locale) => [JSON.stringify(locale), idsAndDirs(locale)]);
+			lines.push("			pages: {", ...perLocale.map(([locale, { ids }]) => `\t\t\t\t${locale}: ${ids};`), "			};");
+			lines.push("			dirs: {", ...perLocale.map(([locale, { dirs }]) => `\t\t\t\t${locale}: ${dirs};`), "			};");
+		} else {
+			const { ids, dirs } = idsAndDirs(options.locales[0]);
+			lines.push(`\t\t\tpages: ${ids};`, `\t\t\tdirs: ${dirs};`);
+		}
+		lines.push("		};");
+	}
+	lines.push("	}", "}", "export {};", "");
+	return lines.join("\n");
+}
+/**
+* Finds pages that would be served at the same URL, across all collections, for HTML pages and Markdown versions alike.
+* Returns one message per pair of files.
+*/
+function findUrlConflicts(settings, collections) {
+	const owners = /* @__PURE__ */ new Map();
+	const conflicts = /* @__PURE__ */ new Map();
+	for (const [name, collection] of byName(collections)) for (const page of pagesOf(settings, collection)) {
+		const owner = `${page.entry.filePath} (${name})`;
+		const urls = [href(settings, collection, page.id, page.urlLocale), markdownHref(settings, collection, page.id, page.urlLocale)];
+		for (const url of urls) {
+			const other = owners.get(url);
+			if (other === void 0) owners.set(url, owner);
+			else if (!conflicts.has(`${other}\n${owner}`)) conflicts.set(`${other}\n${owner}`, `"${url}" is the URL of two pages:\n  ${other}\n  ${owner}`);
+		}
+	}
+	return [...conflicts.values()];
+}
+/**
+* Finds pages that no route generated, given the paths of built pages below `base`.
+* A route file outside the folder that `prefix` names builds its pages elsewhere, and every link to them breaks.
+*/
+function findUnbuiltPages(settings, collections, built) {
+	const missing = [];
+	for (const [name, collection] of byName(collections)) for (const page of pagesOf(settings, collection)) {
+		const path = routePath(settings, collection, page.id, page.urlLocale) ?? "";
+		if (!built.has(path)) missing.push(`/${path} for ${page.entry.filePath} (${name}, prefix "${collection.prefix}")`);
+	}
+	return missing;
+}
+//#endregion
+//#region src/registry.ts
+const key = Symbol.for("minidocs.registry");
+const scope = globalThis;
+scope[key] ??= {
+	collections: {},
+	pendingLinks: []
+};
+const registry = scope[key];
+/** Collections whose loader has run, keyed by collection name. */
+function namedCollections() {
+	return Object.fromEntries(Object.values(registry.collections).filter((state) => state.name !== void 0).map((state) => [state.name, state]));
+}
+//#endregion
+//#region src/links.ts
+/** Link to another page from a page in the same locale, relative so it stays in whatever locale the page is shown in. */
+function relativeHref(settings, from, to, locale) {
+	const fromHref = href(settings, from.collection, from.id, locale);
+	const toHref = href(settings, to.collection, to.id, locale);
+	const fromDir = fromHref.slice(0, fromHref.lastIndexOf("/") + 1);
+	if (toHref.endsWith("/")) return `${posix.relative(fromDir, toHref) || "."}/`;
+	return posix.join(posix.relative(fromDir, posix.dirname(toHref)), posix.basename(toHref));
+}
+/** The collection whose root holds a project-relative file, the innermost one if roots are nested. */
+function collectionOf(collections, file) {
+	return collections.filter(({ base }) => file.startsWith(`${base}/`)).reduce((best, collection) => best && best.base.length > collection.base.length ? best : collection, void 0);
+}
+const EXCLUDED = "points to a page that the collection's filter excludes.";
+/**
+* Rewrites a relative link to a content file, in any collection, into the URL of its page.
+* Links within one locale become relative URLs, so pages shown through fallback keep linking within the shown locale.
+* Returns `undefined` for links that are not to `.md` or `.mdx` files. Throws when the target does not exist.
+*/
+function resolveContentLink(settings, source, url, root) {
+	const match = /^([^#?]+\.mdx?)(#.*)?$/i.exec(url);
+	if (!match || /^([a-z][a-z\d+.-]*:|\/)/i.test(url)) return void 0;
+	const [, path, hash = ""] = match;
+	const absolute = resolve(root, dirname(source.file), decodeURI(path));
+	const target = relative(root, absolute).split(sep).join("/");
+	const collection = collectionOf(source.collections, target);
+	if (!collection) throw new Error(`"${url}" points outside every collection loaded with minidocs' glob, so it has no page.`);
+	if (!existsSync(absolute)) throw new Error(`"${url}" points to a file that does not exist.`);
+	if (source.isExcluded?.(target, collection)) throw new Error(`"${url}" ${EXCLUDED}`);
+	const parse = (file, of) => {
+		const { locales, localeDirs } = contentOptions(settings, of.base);
+		return parseFilePath(file, of.base, locales, localeDirs);
+	};
+	const from = parse(source.file, source.collection);
+	const to = parse(target, collection);
+	return (from.locale === to.locale ? relativeHref(settings, {
+		collection: source.collection,
+		id: from.id
+	}, {
+		collection,
+		id: to.id
+	}, settings.i18n ? from.locale : void 0) : href(settings, collection, to.id, to.locale)) + hash;
+}
+/**
+* Resolves a link found in a Markdown file, or returns `undefined` to leave it alone.
+* Only files inside a collection loaded with minidocs' glob are rewritten.
+*/
+function rewrite(filePath, url) {
+	const { settings, root } = registry;
+	if (!settings || !root) return void 0;
+	const file = relative(root, filePath).split(sep).join("/");
+	const collections = Object.values(registry.collections);
+	const collection = collectionOf(collections, file);
+	if (!collection) return void 0;
+	const ready = (state) => state.loaded && !state.loading;
+	const isExcluded = (target, to) => {
+		if (!ready(collection) || !ready(to)) {
+			registry.pendingLinks.push({
+				file,
+				url,
+				target,
+				source: collection,
+				to
+			});
+			return false;
+		}
+		return to.excluded.has(target);
+	};
+	return resolveContentLink(settings, {
+		file,
+		collection,
+		collections,
+		isExcluded
+	}, url, root);
+}
+/** Checks links rendered while a collection involved was loading, once both collections have loaded. */
+function checkPendingLinks() {
+	const ready = (state) => state.loaded && !state.loading;
+	const due = registry.pendingLinks.filter(({ source, to }) => ready(source) && ready(to));
+	registry.pendingLinks = registry.pendingLinks.filter((link) => !due.includes(link));
+	const broken = due.filter(({ file, target, source, to }) => !source.excluded.has(file) && to.excluded.has(target));
+	if (broken.length === 0) return;
+	const root = registry.root ?? "";
+	throw new Error(broken.map(({ file, url }) => failure(resolve(root, file), url, /* @__PURE__ */ new Error(`"${url}" ${EXCLUDED}`)).message).join("\n"));
+}
+/** Points at the line of the source file with the link. Processors may count lines from after the frontmatter. */
+function failure(filePath, url, error) {
+	let line;
+	try {
+		const index = readFileSync(filePath, "utf8").split("\n").findIndex((text) => text.includes(url));
+		if (index !== -1) line = index + 1;
+	} catch {}
+	const location = `${relative(registry.root ?? "", filePath)}${line ? `:${line}` : ""}`;
+	return /* @__PURE__ */ new Error(`[minidocs] ${location}: ${error.message}`);
+}
+/** Plugin for Sätteri, Astro's default Markdown processor. */
+const satteriContentLinks = (() => {
+	const visit = (node, context) => {
+		if (!context.fileURL) return;
+		const filePath = fileURLToPath(context.fileURL);
+		try {
+			const url = rewrite(filePath, node.url);
+			if (url !== void 0) context.setProperty(node, "url", url);
+		} catch (error) {
+			throw failure(filePath, node.url, error);
+		}
+	};
+	return {
+		name: "minidocs-content-links",
+		link: visit,
+		definition: visit
+	};
+})();
+/** Remark plugin for the unified processor from `@astrojs/markdown-remark`. */
+function remarkContentLinks() {
+	return (tree, file) => {
+		const filePath = file.path;
+		if (!filePath) return;
+		const visit = (node) => {
+			if ((node.type === "link" || node.type === "definition") && node.url) try {
+				node.url = rewrite(filePath, node.url) ?? node.url;
+			} catch (error) {
+				throw failure(filePath, node.url, error);
+			}
+			for (const child of node.children ?? []) visit(child);
+		};
+		visit(tree);
+	};
+}
+//#endregion
+export { registry as a, renderConfigTypes as c, namedCollections as i, renderTypes as l, remarkContentLinks as n, findUnbuiltPages as o, satteriContentLinks as r, findUrlConflicts as s, checkPendingLinks as t };

package/dist/loaders.d.mts

@@ -0,0 +1,25 @@
+import { Loader, glob as glob$1 } from "astro/loaders";
+//#region src/loaders.d.ts
+type GlobOptions = Parameters<typeof glob$1>[0];
+/** An entry as the filter sees it, after the collection schema has parsed its data. */
+export interface FilterEntry {
+  id: string;
+  data: Record<string, unknown>;
+  filePath?: string | undefined;
+}
+export interface MinidocsGlobOptions {
+  /** Path segment the pages live under, e.g. `docs` for `/docs/...`. Defaults to the site root. */
+  prefix?: string;
+  /** Entries for which it returns `false` never reach the collection. */
+  filter?: (entry: FilterEntry) => boolean;
+}
+/**
+ * Astro's `glob()` loader, plus recording of the collection root and URL prefix so minidocs can
+ * derive locales, page ids and URLs, and generate types for them.
+ * Entries rejected by `filter` never reach the collection, so types, links and pages all agree on what exists.
+ */
+export declare function glob({ prefix, filter, ...options }: GlobOptions & {
+  base: string | URL;
+} & MinidocsGlobOptions): Loader;
+//#endregion
+export {};

package/dist/loaders.mjs

@@ -0,0 +1,88 @@
+import { a as registry, i as namedCollections, l as renderTypes, s as findUrlConflicts, t as checkPendingLinks } from "./links-Dp7d5R-O.mjs";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { glob as glob$1 } from "astro/loaders";
+//#region src/loaders.ts
+/** Collection root relative to the project, as Astro's glob resolves `base`. */
+const relativeBase = (base, root) => relative(root, base instanceof URL ? fileURLToPath(base) : resolve(root, base)).replaceAll("\\", "/");
+function register(base, declared) {
+	registry.collections[base] ??= {
+		base,
+		...declared,
+		filePaths: [],
+		excluded: /* @__PURE__ */ new Set(),
+		loading: false,
+		loaded: false
+	};
+	return Object.assign(registry.collections[base], declared);
+}
+/**
+* Astro's `glob()` loader, plus recording of the collection root and URL prefix so minidocs can
+* derive locales, page ids and URLs, and generate types for them.
+* Entries rejected by `filter` never reach the collection, so types, links and pages all agree on what exists.
+*/
+function glob({ prefix = "", filter, ...options }) {
+	const inner = glob$1(options);
+	const declared = { prefix: prefix.replace(/^\/+|\/+$/g, "") };
+	if (registry.root) register(relativeBase(options.base, registry.root), declared);
+	return {
+		...inner,
+		name: "minidocs-glob",
+		async load(context) {
+			const state = register(relativeBase(options.base, fileURLToPath(context.config.root)), declared);
+			if (state.name !== void 0 && state.name !== context.collection) throw new Error(`[minidocs] Collections "${state.name}" and "${context.collection}" are both loaded from ${state.base}.`);
+			state.name = context.collection;
+			let scheduled;
+			const update = () => {
+				clearTimeout(scheduled);
+				scheduled = setTimeout(() => writeTypes(context, state, (message) => context.logger.error(message)), 50);
+			};
+			const store = new Proxy(context.store, { get(target, property, receiver) {
+				const value = Reflect.get(target, property, receiver);
+				if (property !== "set" && property !== "delete" && property !== "clear") return value;
+				return (...args) => {
+					update();
+					if (property === "set" && filter) {
+						const entry = args[0];
+						if (!filter(entry)) {
+							if (entry.filePath) state.excluded.add(entry.filePath);
+							if (target.has(entry.id)) target.delete(entry.id);
+							return false;
+						}
+						if (entry.filePath) state.excluded.delete(entry.filePath);
+					}
+					return value.apply(target, args);
+				};
+			} });
+			state.loading = true;
+			try {
+				await inner.load({
+					...context,
+					store
+				});
+			} finally {
+				state.loading = false;
+			}
+			state.loaded = true;
+			clearTimeout(scheduled);
+			writeTypes(context, state, (message) => {
+				throw new Error(message);
+			});
+			checkPendingLinks();
+		}
+	};
+}
+function writeTypes(context, state, report) {
+	const { settings, typesFile } = registry;
+	if (!settings || !typesFile) throw new Error("[minidocs] Add the minidocs() integration to your Astro config to use glob from '@minidocs/astro/loaders'.");
+	state.filePaths = context.store.values().map((entry) => entry.filePath).filter((filePath) => Boolean(filePath));
+	const collections = namedCollections();
+	const path = fileURLToPath(typesFile);
+	mkdirSync(dirname(path), { recursive: true });
+	writeFileSync(path, renderTypes(settings, collections));
+	const conflicts = findUrlConflicts(settings, collections);
+	if (conflicts.length > 0) report(conflicts.map((conflict) => `[minidocs] ${conflict}`).join("\n"));
+}
+//#endregion
+export { glob };