@astrojs/starlight 0.41.11 → 0.42.0

package/dist/utils/plugins.js

@@ -0,0 +1,174 @@
+import { getCollectionPosixPath } from "./collection-fs.js";
+import { absolutePathToLang } from "../integrations/shared/absolutePathToLang.js";
+import { parseWithFriendlyErrors } from "./error-map.js";
+import { StarlightConfigSchema } from "./user-config.js";
+import { createTranslationSystemFromFs } from "./translations-fs.js";
+import { AstroError } from "astro/errors";
+import { z } from "astro/zod";
+//#region src/utils/plugins.ts
+/**
+* Runs Starlight plugins in the order that they are configured after validating the user-provided
+* configuration and returns the final validated user config that may have been updated by the
+* plugins and a list of any integrations added by the plugins.
+*/
+async function runPlugins(starlightUserConfig, pluginsUserConfig, context) {
+	let userConfig = starlightUserConfig;
+	let starlightConfig = parseWithFriendlyErrors(StarlightConfigSchema, userConfig, "Invalid config passed to starlight integration");
+	const pluginsConfig = parseWithFriendlyErrors(StarlightPluginsConfigSchema, pluginsUserConfig, "Invalid plugins config passed to starlight integration");
+	const pluginTranslations = {};
+	const routeMiddlewareConfigs = [];
+	for (const { hooks: { "i18n:setup": i18nSetup } } of pluginsConfig) if (i18nSetup) await i18nSetup({ injectTranslations(translations) {
+		for (const [locale, localeTranslations] of Object.entries(translations)) {
+			pluginTranslations[locale] ??= {};
+			Object.assign(pluginTranslations[locale], localeTranslations);
+		}
+	} });
+	const useTranslations = await createTranslationSystemFromFs(starlightConfig, context.config, pluginTranslations);
+	function absolutePathToLang$1(path) {
+		return absolutePathToLang(path, {
+			docsPath: getCollectionPosixPath("docs", context.config.srcDir),
+			starlightConfig
+		});
+	}
+	const integrations = [];
+	for (const { name, hooks: { "config:setup": configSetup, setup: deprecatedSetup } } of pluginsConfig) await (configSetup ?? deprecatedSetup)({
+		config: pluginsUserConfig ? {
+			...userConfig,
+			plugins: pluginsUserConfig
+		} : userConfig,
+		updateConfig(newConfig) {
+			if ("plugins" in newConfig) throw new AstroError(`The \`${name}\` plugin tried to update the \`plugins\` config key which is not supported.`);
+			if ("routeMiddleware" in newConfig) throw new AstroError(`The \`${name}\` plugin tried to update the \`routeMiddleware\` config key which is not supported.`, "Use the `addRouteMiddleware()` utility instead.\nSee https://starlight.astro.build/reference/plugins/#addroutemiddleware for more details.");
+			const mergedUserConfig = {
+				...userConfig,
+				...newConfig
+			};
+			const mergedConfig = parseWithFriendlyErrors(StarlightConfigSchema, mergedUserConfig, `Invalid config update provided by the '${name}' plugin`);
+			userConfig = mergedUserConfig;
+			starlightConfig = mergedConfig;
+		},
+		addIntegration(integration) {
+			integrations.push(integration);
+		},
+		addRouteMiddleware(middlewareConfig) {
+			routeMiddlewareConfigs.push(middlewareConfig);
+		},
+		astroConfig: {
+			...context.config,
+			integrations: [...context.config.integrations, ...integrations]
+		},
+		command: context.command,
+		isRestart: context.isRestart,
+		logger: context.logger.fork(name),
+		useTranslations,
+		absolutePathToLang: absolutePathToLang$1
+	});
+	applyPluginMiddleware(routeMiddlewareConfigs, starlightConfig);
+	return {
+		integrations,
+		starlightConfig,
+		pluginTranslations,
+		useTranslations,
+		absolutePathToLang: absolutePathToLang$1
+	};
+}
+/** Updates `routeMiddleware` in the Starlight config to add plugin middlewares in the correct order. */
+function applyPluginMiddleware(routeMiddlewareConfigs, starlightConfig) {
+	const middlewareBuckets = routeMiddlewareConfigs.reduce((buckets, { entrypoint, order = "default" }) => {
+		buckets[order].push(entrypoint);
+		return buckets;
+	}, {
+		pre: [],
+		default: [],
+		post: []
+	});
+	starlightConfig.routeMiddleware.unshift(...middlewareBuckets.pre);
+	starlightConfig.routeMiddleware.push(...middlewareBuckets.default, ...middlewareBuckets.post);
+}
+function injectPluginTranslationsTypes(translations, injectTypes) {
+	const allKeys = /* @__PURE__ */ new Set();
+	for (const localeTranslations of Object.values(translations)) for (const key of Object.keys(localeTranslations)) allKeys.add(key);
+	if (allKeys.size === 0) return;
+	injectTypes({
+		filename: "i18n-plugins.d.ts",
+		content: `declare namespace StarlightApp {
+	type PluginUIStringKeys = {
+		${[...allKeys].map((key) => `'${key}': string;`).join("\n		")}
+	};
+	interface I18n extends PluginUIStringKeys {}
+}`
+	});
+}
+const astroIntegrationSchema = z.object({
+	name: z.string(),
+	hooks: z.looseObject({}).default({})
+});
+const routeMiddlewareConfigSchema = z.object({
+	entrypoint: z.string(),
+	order: z.enum([
+		"pre",
+		"post",
+		"default"
+	]).default("default")
+});
+const baseStarlightPluginSchema = z.object({ name: z.string() });
+const configSetupHookSchema = z.function({
+	input: [z.object({
+		config: z.any(),
+		updateConfig: z.function({
+			input: [z.record(z.string(), z.any())],
+			output: z.void()
+		}),
+		addIntegration: z.function({
+			input: [astroIntegrationSchema],
+			output: z.void()
+		}),
+		addRouteMiddleware: z.function({
+			input: [routeMiddlewareConfigSchema],
+			output: z.void()
+		}),
+		astroConfig: z.any(),
+		command: z.any(),
+		isRestart: z.any(),
+		logger: z.any(),
+		useTranslations: z.any(),
+		absolutePathToLang: z.function({
+			input: [z.string()],
+			output: z.string()
+		})
+	})],
+	output: z.promise(z.void())
+}).optional();
+/**
+* A plugin `config` and `updateConfig` argument are purposely not validated using the Starlight
+* user config schema but properly typed for user convenience because we do not want to run any of
+* the Zod `transform`s used in the user config schema when running plugins.
+*/
+const starlightPluginSchema = z.object({
+	...baseStarlightPluginSchema.shape,
+	hooks: z.object({
+		"i18n:setup": z.function({
+			input: [z.object({ injectTranslations: z.function({
+				input: [z.record(z.string(), z.record(z.string(), z.string()))],
+				output: z.void()
+			}) })],
+			output: z.promise(z.void())
+		}).optional(),
+		"config:setup": configSetupHookSchema,
+		setup: configSetupHookSchema
+	})
+}).superRefine((plugin, ctx) => {
+	if (!plugin.hooks["config:setup"] && !plugin.hooks.setup) ctx.issues.push({
+		code: "custom",
+		message: "A plugin must define at least a `config:setup` hook.",
+		input: plugin
+	});
+	else if (plugin.hooks["config:setup"] && plugin.hooks.setup) ctx.issues.push({
+		code: "custom",
+		message: "A plugin cannot define both a `config:setup` and `setup` hook. As `setup` is deprecated and will be removed in a future version, consider using `config:setup` instead.",
+		input: plugin
+	});
+});
+const StarlightPluginsConfigSchema = z.array(starlightPluginSchema).default([]);
+//#endregion
+export { StarlightPluginsConfigSchema, injectPluginTranslationsTypes, runPlugins };

package/dist/utils/routing/data.d.ts

@@ -0,0 +1,20 @@
+import { Route, StarlightRouteData } from "./types.js";
+import { RenderResult } from "astro:content";
+import { APIContext, MarkdownHeading } from "astro";
+//#region src/utils/routing/data.d.ts
+interface PageProps extends Route {
+  headings: MarkdownHeading[];
+}
+type RouteDataContext = Pick<APIContext, 'generator' | 'site' | 'url'>;
+declare function getRoute(context: APIContext): Promise<Route>;
+declare function useRouteData(context: APIContext, route: Route, { Content, headings }: RenderResult): StarlightRouteData;
+declare function generateRouteData({ props, context }: {
+  props: PageProps;
+  context: RouteDataContext;
+}): StarlightRouteData;
+declare function getToC({ entry, lang, headings }: PageProps): any;
+/** Get the site title for a given language. **/
+declare function getSiteTitle(lang: string): string;
+declare function getSiteTitleHref(locale: string | undefined): string;
+//#endregion
+export { PageProps, RouteDataContext, generateRouteData, getRoute, getSiteTitle, getSiteTitleHref, getToC, useRouteData };

package/dist/utils/routing/data.js

@@ -0,0 +1,127 @@
+import { getCollectionPathFromRoot } from "../collection.js";
+import { ensureTrailingSlash } from "../path.js";
+import { BuiltInDefaultLocale } from "../i18n.js";
+import { useTranslations } from "../translations.js";
+import { formatPath } from "../format-path.js";
+import { generateToC } from "../generateToC.js";
+import { getHead } from "../head.js";
+import { getRouteBySlugParam, normalizeCollectionEntry } from "./index.js";
+import { getPrevNextLinks, getSidebar } from "../navigation.js";
+import { getEntry } from "astro:content";
+import config from "virtual:starlight/user-config";
+import project from "virtual:starlight/project-context";
+import { getNewestCommitDate } from "virtual:starlight/git-info";
+//#region src/utils/routing/data.ts
+async function getRoute(context) {
+	return "slug" in context.params && getRouteBySlugParam(context.params.slug) || await get404Route(context.locals);
+}
+function useRouteData(context, route, { Content, headings }) {
+	return {
+		...generateRouteData({
+			props: {
+				...route,
+				headings
+			},
+			context
+		}),
+		Content
+	};
+}
+function generateRouteData({ props, context }) {
+	const { entry, locale, lang } = props;
+	const sidebar = getSidebar(context.url.pathname, locale);
+	const siteTitle = getSiteTitle(lang);
+	return {
+		...props,
+		siteTitle,
+		siteTitleHref: getSiteTitleHref(locale),
+		sidebar,
+		hasSidebar: entry.data.template !== "splash",
+		pagination: getPrevNextLinks(sidebar, config.pagination, entry.data),
+		toc: getToC(props),
+		lastUpdated: getLastUpdated(props),
+		editUrl: getEditUrl(props),
+		head: getHead(props, context, siteTitle)
+	};
+}
+function getToC({ entry, lang, headings }) {
+	const tocConfig = entry.data.template === "splash" ? false : entry.data.tableOfContents !== void 0 ? entry.data.tableOfContents : config.tableOfContents;
+	if (!tocConfig) return;
+	const t = useTranslations(lang);
+	return {
+		...tocConfig,
+		items: generateToC(headings, {
+			...tocConfig,
+			title: t("tableOfContents.overview")
+		})
+	};
+}
+function getLastUpdated({ entry }) {
+	const { lastUpdated: frontmatterLastUpdated } = entry.data;
+	const { lastUpdated: configLastUpdated } = config;
+	if (frontmatterLastUpdated ?? configLastUpdated) try {
+		return frontmatterLastUpdated instanceof Date ? frontmatterLastUpdated : getNewestCommitDate(entry.filePath);
+	} catch {
+		return;
+	}
+}
+function getEditUrl({ entry }) {
+	const { editUrl } = entry.data;
+	if (editUrl === false) return;
+	let url;
+	if (typeof editUrl === "string") url = editUrl;
+	else if (config.editLink.baseUrl) url = ensureTrailingSlash(config.editLink.baseUrl) + entry.filePath;
+	return url ? new URL(url) : void 0;
+}
+/** Get the site title for a given language. **/
+function getSiteTitle(lang) {
+	const defaultLang = config.defaultLocale.lang;
+	if (lang && config.title[lang]) return config.title[lang];
+	return config.title[defaultLang];
+}
+function getSiteTitleHref(locale) {
+	return formatPath(locale || "/");
+}
+/** Generate a route object for Starlight’s 404 page. */
+async function get404Route(locals) {
+	const { lang = BuiltInDefaultLocale.lang, dir = BuiltInDefaultLocale.dir } = config.defaultLocale || {};
+	let locale = config.defaultLocale?.locale;
+	if (locale === "root") locale = void 0;
+	const entryMeta = {
+		dir,
+		lang,
+		locale
+	};
+	const fallbackEntry = {
+		id: "404",
+		body: "",
+		collection: "docs",
+		data: {
+			title: "404",
+			template: "splash",
+			editUrl: false,
+			head: [],
+			hero: {
+				tagline: locals.t("404.text"),
+				actions: []
+			},
+			pagefind: false,
+			sidebar: {
+				hidden: false,
+				attrs: {}
+			},
+			draft: false
+		},
+		filePath: `${getCollectionPathFromRoot("docs", project)}/404.md`
+	};
+	const userEntry = await getEntry("docs", "404");
+	const entry = userEntry ? normalizeCollectionEntry(userEntry) : fallbackEntry;
+	return {
+		...entryMeta,
+		entryMeta,
+		entry,
+		id: entry.id
+	};
+}
+//#endregion
+export { generateRouteData, getRoute, getSiteTitle, getSiteTitleHref, getToC, useRouteData };

package/dist/utils/routing/index.d.ts

@@ -0,0 +1,21 @@
+import { Route, StarlightDocsCollectionEntry, StarlightDocsEntry } from "./types.js";
+import { GetStaticPathsItem } from "astro";
+//#region src/utils/routing/index.d.ts
+interface Path extends GetStaticPathsItem {
+  params: {
+    slug: string | undefined;
+  };
+}
+/** Normalize a collection entry. */
+declare function normalizeCollectionEntry(entry: StarlightDocsCollectionEntry): StarlightDocsEntry;
+declare const routes: Route[];
+declare function getRouteById(id: string): Route | undefined;
+declare function getRouteBySlugParam(slugParam: string | undefined): Route | undefined;
+declare const paths: Path[];
+/**
+ * Get all routes for a specific locale.
+ * A locale of `undefined` is treated as the “root” locale, if configured.
+ */
+declare function getLocaleRoutes(locale: string | undefined): Route[];
+//#endregion
+export { getLocaleRoutes, getRouteById, getRouteBySlugParam, normalizeCollectionEntry, paths, routes };

package/dist/utils/routing/index.js

@@ -0,0 +1,106 @@
+import { BuiltInDefaultLocale } from "../i18n.js";
+import { localizedSlug, slugToLocaleData, slugToParam } from "../slugs.js";
+import { validateLogoImports } from "../validateLogoImports.js";
+import { getCollection } from "astro:content";
+import config from "virtual:starlight/user-config";
+//#region src/utils/routing/index.ts
+validateLogoImports();
+/**
+* Astro is inconsistent in its `index.md` slug generation. In most cases,
+* `index` is stripped, but in the root of a collection, we get a slug of `index`.
+* We map that to an empty string for consistent behaviour.
+*/
+const normalizeIndexSlug = (slug) => slug === "index" ? "" : slug;
+/** Normalize a collection entry. */
+function normalizeCollectionEntry(entry) {
+	return {
+		...entry,
+		id: normalizeIndexSlug(entry.id),
+		filePath: entry.filePath
+	};
+}
+/** All entries in the docs content collection. */
+const docs = (await getCollection("docs", ({ data }) => {
+	return import.meta.env.MODE !== "production" || data.draft === false;
+}) ?? []).map(normalizeCollectionEntry);
+function getRoutes() {
+	const routes = docs.map((entry) => ({
+		entry,
+		id: entry.id,
+		entryMeta: slugToLocaleData(entry.id),
+		...slugToLocaleData(entry.id)
+	}));
+	if (config.isMultilingual) {
+		/** Entries in the docs content collection for the default locale. */
+		const defaultLocaleDocs = getLocaleDocs(config.defaultLocale?.locale === "root" ? void 0 : config.defaultLocale?.locale);
+		for (const key in config.locales) {
+			if (key === config.defaultLocale.locale) continue;
+			const localeConfig = config.locales[key];
+			if (!localeConfig) continue;
+			const locale = key === "root" ? void 0 : key;
+			const localeDocs = getLocaleDocs(locale);
+			const localeDocIds = new Set(localeDocs.map(({ id }) => id));
+			for (const fallback of defaultLocaleDocs) {
+				const id = localizedSlug(fallback.id, locale);
+				if (localeDocIds.has(id)) continue;
+				routes.push({
+					entry: fallback,
+					id,
+					isFallback: true,
+					lang: localeConfig.lang || BuiltInDefaultLocale.lang,
+					locale,
+					dir: localeConfig.dir,
+					entryMeta: slugToLocaleData(fallback.id)
+				});
+			}
+		}
+	}
+	return routes;
+}
+const routes = getRoutes();
+const routesById = new Map(routes.map((route) => [route.id, route]));
+function getRouteById(id) {
+	return routesById.get(id);
+}
+function getParamRouteMapping() {
+	const map = /* @__PURE__ */ new Map();
+	for (const route of routes) map.set(slugToParam(route.id), route);
+	return map;
+}
+const routesBySlugParam = getParamRouteMapping();
+function getRouteBySlugParam(slugParam) {
+	return routesBySlugParam.get(slugParam?.replace(/\/$/, "") || void 0);
+}
+function getPaths() {
+	return routes.map((route) => ({ params: { slug: slugToParam(route.id) } }));
+}
+const paths = getPaths();
+/**
+* Get all routes for a specific locale.
+* A locale of `undefined` is treated as the “root” locale, if configured.
+*/
+function getLocaleRoutes(locale) {
+	return filterByLocale(routes, locale);
+}
+/**
+* Get all entries in the docs content collection for a specific locale.
+* A locale of `undefined` is treated as the “root” locale, if configured.
+*/
+function getLocaleDocs(locale) {
+	return filterByLocale(docs, locale);
+}
+/** Filter an array to find items whose slug matches the passed locale. */
+function filterByLocale(items, locale) {
+	if (config.locales) {
+		if (locale && locale in config.locales) return items.filter((i) => i.id === locale || i.id.startsWith(locale + "/"));
+		else if (config.locales.root) {
+			const langKeys = Object.keys(config.locales).filter((k) => k !== "root");
+			const isLangIndex = new RegExp(`^(${langKeys.join("|")})$`);
+			const isLangDir = new RegExp(`^(${langKeys.join("|")})/`);
+			return items.filter((i) => !isLangIndex.test(i.id) && !isLangDir.test(i.id));
+		}
+	}
+	return items;
+}
+//#endregion
+export { getLocaleRoutes, getRouteById, getRouteBySlugParam, normalizeCollectionEntry, paths, routes };

package/dist/utils/routing/middleware.d.ts

@@ -0,0 +1,11 @@
+import { StarlightRouteData } from "./types.js";
+import { APIContext } from "astro";
+//#region src/utils/routing/middleware.d.ts
+/**
+ * Adds a deep clone of the passed `routeData` object to locals and then runs middleware.
+ * @param context Astro context object
+ * @param routeData Initial route data object to attach.
+ */
+declare function attachRouteDataAndRunMiddleware(context: APIContext, routeData: StarlightRouteData): Promise<void>;
+//#endregion
+export { attachRouteDataAndRunMiddleware };

package/dist/utils/routing/middleware.js

@@ -0,0 +1,65 @@
+import { klona } from "klona/lite";
+import { routeMiddleware } from "virtual:starlight/route-middleware";
+//#region src/utils/routing/middleware.ts
+/**
+* Adds a deep clone of the passed `routeData` object to locals and then runs middleware.
+* @param context Astro context object
+* @param routeData Initial route data object to attach.
+*/
+async function attachRouteDataAndRunMiddleware(context, routeData) {
+	context.locals.starlightRoute = klona(routeData);
+	await new MiddlewareRunner(context, routeMiddleware).run();
+}
+/**
+* A middleware function wrapper that only allows a single execution of the wrapped function.
+* Subsequent calls to `run()` are no-ops.
+*/
+var MiddlewareRunnerStep = class {
+	#callback;
+	constructor(callback) {
+		this.#callback = callback;
+	}
+	async run(context, next) {
+		if (this.#callback) {
+			await this.#callback(context, next);
+			this.#callback = null;
+		}
+	}
+};
+/**
+* Class that runs a stack of middleware handlers with an initial context object.
+* Middleware functions can mutate properties of the `context` object, but cannot replace it.
+*
+* @example
+* const context = { value: 10 };
+* const timesTwo = async (ctx, next) => {
+*   await next();
+*   ctx.value *= 2;
+* };
+* const addFive = async (ctx) => {
+*   ctx.value += 5;
+* }
+* const runner = new MiddlewareRunner(context, [timesTwo, addFive]);
+* runner.run();
+* console.log(context); // { value: 30 }
+*/
+var MiddlewareRunner = class {
+	#context;
+	#steps;
+	constructor(context, stack = []) {
+		this.#context = context;
+		this.#steps = stack.map((callback) => new MiddlewareRunnerStep(callback));
+	}
+	async #stepThrough(steps) {
+		let currentStep;
+		while (steps.length > 0) {
+			[currentStep, ...steps] = steps;
+			await currentStep.run(this.#context, async () => this.#stepThrough(steps));
+		}
+	}
+	async run() {
+		await this.#stepThrough(this.#steps);
+	}
+};
+//#endregion
+export { attachRouteDataAndRunMiddleware };

package/dist/utils/routing/types.d.ts

@@ -0,0 +1,93 @@
+import { Badge } from "../../schemas/badge.js";
+import { LinkHTMLAttributes } from "../../schemas/sidebar.js";
+import { HeadConfig } from "../../schemas/head.js";
+import { TocItem } from "../generateToC.js";
+import { CollectionEntry, RenderResult } from "astro:content";
+import { MarkdownHeading } from "astro";
+//#region src/utils/routing/types.d.ts
+interface LocaleData {
+  /** Writing direction. */
+  dir: 'ltr' | 'rtl';
+  /** BCP-47 language tag. */
+  lang: string;
+  /** The base path at which a language is served. `undefined` for root locale slugs. */
+  locale: string | undefined;
+}
+interface SidebarAutogenerateRouteData {
+  directory: string;
+}
+interface SidebarManualLink {
+  type: 'link';
+  label: string;
+  href: string;
+  isCurrent: boolean;
+  badge: Badge | undefined;
+  attrs: LinkHTMLAttributes;
+}
+interface SidebarAutoLink extends SidebarManualLink {
+  autogenerate: SidebarAutogenerateRouteData;
+}
+interface SidebarManualGroup {
+  type: 'group';
+  label: string;
+  entries: (SidebarLink | SidebarGroup)[];
+  collapsed: boolean;
+  badge: Badge | undefined;
+}
+interface SidebarAutoGroup extends SidebarManualGroup {
+  autogenerate: SidebarAutogenerateRouteData;
+}
+type SidebarLink = SidebarManualLink | SidebarAutoLink;
+type SidebarGroup = SidebarManualGroup | SidebarAutoGroup;
+type SidebarEntry = SidebarLink | SidebarGroup;
+interface PaginationLinks {
+  /** Link to previous page in the sidebar. */
+  prev: SidebarLink | undefined;
+  /** Link to next page in the sidebar. */
+  next: SidebarLink | undefined;
+}
+type StarlightDocsCollectionEntry = CollectionEntry<'docs'>;
+type StarlightDocsEntry = StarlightDocsCollectionEntry & {
+  filePath: string;
+};
+interface Route extends LocaleData {
+  /** Content collection entry for the current page. Includes frontmatter at `data`. */
+  entry: StarlightDocsEntry;
+  /** Locale metadata for the page content. Can be different from top-level locale values when a page is using fallback content. */
+  entryMeta: LocaleData;
+  /** The slug. */
+  id: string;
+  /** Whether this page is untranslated in the current language and using fallback content from the default locale. */
+  isFallback?: boolean;
+  [key: string]: unknown;
+}
+interface StarlightRouteData extends Route {
+  /** Title of the site. */
+  siteTitle: string;
+  /** URL or path used as the link when clicking on the site title. */
+  siteTitleHref: string;
+  /** Array of Markdown headings extracted from the current page. */
+  headings: MarkdownHeading[];
+  /** Site navigation sidebar entries for this page. */
+  sidebar: SidebarEntry[];
+  /** Whether or not the sidebar should be displayed on this page. */
+  hasSidebar: boolean;
+  /** Links to the previous and next page in the sidebar if enabled. */
+  pagination: PaginationLinks;
+  /** Table of contents for this page if enabled. */
+  toc: {
+    minHeadingLevel: number;
+    maxHeadingLevel: number;
+    items: TocItem[];
+  } | undefined;
+  /** JS Date object representing when this page was last updated if enabled. */
+  lastUpdated: Date | undefined;
+  /** URL object for the address where this page can be edited if enabled. */
+  editUrl: URL | undefined;
+  /** An Astro component to render the current page’s content if this route is a Markdown page. */
+  Content?: RenderResult['Content'];
+  /** Array of tags to include in the `<head>` of the current page. */
+  head: HeadConfig;
+}
+//#endregion
+export { LocaleData, PaginationLinks, Route, SidebarAutoGroup, SidebarAutoLink, SidebarAutogenerateRouteData, SidebarEntry, SidebarGroup, SidebarLink, SidebarManualGroup, SidebarManualLink, StarlightDocsCollectionEntry, StarlightDocsEntry, StarlightRouteData };

package/dist/utils/routing/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/slugs.d.ts

@@ -0,0 +1,45 @@
+import { LocaleData } from "./routing/types.js";
+//#region src/utils/slugs.d.ts
+/** Get locale information for a given slug. */
+declare function slugToLocaleData(slug: string): LocaleData;
+/**
+ * Get the BCP-47 language tag for the given locale.
+ * @param locale Locale string or `undefined` for the root locale.
+ */
+declare function localeToLang(locale: string | undefined): string;
+/**
+ * Convert a content collection slug to a param as expected by Astro’s router.
+ * This utility handles stripping `index` from file names and matches
+ * [Astro’s param sanitization logic](https://github.com/withastro/astro/blob/687d25365a41ff8a9e6da155d3527f841abb70dd/packages/astro/src/core/routing/manifest/generator.ts#L4-L18)
+ * by normalizing strings to their canonical representations.
+ * @param slug Content collection slug
+ * @returns Param compatible with Astro’s router
+ */
+declare function slugToParam(slug: string): string | undefined;
+declare function slugToPathname(slug: string): string;
+/**
+ * Convert a slug to a different locale.
+ * For example, passing a slug of `en/home` and a locale of `fr` results in `fr/home`.
+ * An undefined locale is treated as the root locale, resulting in `home`
+ * @param slug A collection entry slug
+ * @param locale The target locale
+ * @example
+ * localizedSlug('en/home', 'fr')       // => 'fr/home'
+ * localizedSlug('en/home', undefined)  // => 'home'
+ */
+declare function localizedSlug(slug: string, locale: string | undefined): string;
+/**
+ * Convert a file path relative to the collection root to a different locale.
+ * For example, passing a file path of `en/home.md` and a locale of `fr` results in `fr/home.md`.
+ * An undefined locale is treated as the root locale, resulting in `home.md`.
+ * @param filePath A collection entry file path relative to the collection root
+ * @param locale The target locale
+ * @example
+ * localizedFilePath('en/home.md', 'fr')       // => 'fr/home.md'
+ * localizedFilePath('en/home.md', undefined)  // => 'home.md'
+ */
+declare function localizedFilePath(filePath: string, locale: string | undefined): string;
+/** Extract the slug from a URL. */
+declare function urlToSlug(url: URL): string;
+//#endregion
+export { localeToLang, localizedFilePath, localizedSlug, slugToLocaleData, slugToParam, slugToPathname, urlToSlug };