@lupinum/ginko-content 0.1.0

package/dist/features/collections/resolve.d.ts

@@ -0,0 +1,63 @@
+import type { ParsedContent } from '../../types/content';
+import type { ContentPageResult, ContentRouteMeta } from '../../types/query';
+import { type GenerateSearchSectionsOptions } from '../search/sections';
+import type { RuntimeContentI18nInput } from '../localization/config';
+export interface CollectionResolveRuntime extends RuntimeContentI18nInput {
+    localeFallback?: Record<string, string[]>;
+    translatedSlugs?: boolean;
+}
+export declare const resolveCollectionNavigationData: (_collection: string, _runtime: CollectionResolveRuntime, options: {
+    fields?: string[];
+    locale?: string;
+    canonical?: boolean;
+    activeLocale?: string;
+    loadNavigation: () => Promise<any[]>;
+}) => Promise<any[]>;
+export declare const resolveCollectionItemSurroundingsData: (collection: string, path: string, runtime: CollectionResolveRuntime, options: {
+    before?: number;
+    after?: number;
+    fields?: string[];
+    locale?: string;
+    canonical?: boolean;
+    activeLocale?: string;
+    loadNavigation: (options: {
+        fields?: string[];
+        locale?: string;
+        canonical?: boolean;
+    }) => Promise<any[]>;
+}) => Promise<(import("../../types/content").NavItem | null)[]>;
+export declare const resolveCollectionSearchSectionsData: (collection: string, runtime: CollectionResolveRuntime, options: (GenerateSearchSectionsOptions & {
+    locale?: string;
+    canonical?: boolean;
+    activeLocale?: string;
+}) & {
+    loadPages: (extraFields: string[]) => Promise<Array<Pick<ParsedContent, "_path" | "title" | "description" | "body"> & Record<string, unknown>>>;
+}) => Promise<{
+    id: string;
+    title: string;
+    titles: string[];
+    level: number;
+    content: string;
+}[]>;
+export declare const resolveCollectionPageData: <T = ParsedContent>(collection: string, routeOrPath: string | undefined, runtime: CollectionResolveRuntime, options: {
+    locale?: string;
+    fallback?: string[] | boolean;
+    canonical?: boolean;
+    fallbackRoute?: string;
+    loadVariantPage: (input: {
+        path: string;
+        locale?: string;
+        fallback?: string[] | boolean;
+    }) => Promise<(T & ParsedContent) | null>;
+    loadPathPage: (path: string) => Promise<(T & ParsedContent) | null>;
+}) => Promise<ContentPageResult<T> | null>;
+export declare const resolveCollectionRouteMetaData: (collection: string, runtime: CollectionResolveRuntime, options: {
+    routeOrPath?: string;
+    locale?: string;
+    fallback?: string[] | boolean;
+    loadPage: (routeOrPath?: string, options?: {
+        locale?: string;
+        fallback?: string[] | boolean;
+        canonical?: boolean;
+    }) => Promise<ContentPageResult<any> | null>;
+}) => Promise<ContentRouteMeta | null>;

package/dist/features/collections/resolve.js

@@ -0,0 +1,76 @@
+import { createCollectionSurroundings } from "../navigation/tree.js";
+import { createSearchSections } from "../search/sections.js";
+import { normalizeContentPath, resolveCollectionI18n, resolveRouteContent } from "../localization/path.js";
+import { createRouteMeta, localizePageResult, localizeSearchSections } from "../localization/results.js";
+export const resolveCollectionNavigationData = async (_collection, _runtime, options) => {
+  return await options.loadNavigation();
+};
+export const resolveCollectionItemSurroundingsData = async (collection, path, runtime, options) => {
+  const { locales, defaultLocale } = resolveCollectionI18n(collection, runtime);
+  const resolved = resolveRouteContent(path, locales, defaultLocale, options.locale);
+  const navigation = await options.loadNavigation({
+    fields: options.fields || [],
+    locale: resolved.locale || options.activeLocale,
+    canonical: options.canonical
+  });
+  const localizedPath = options.canonical ? normalizeContentPath(resolved.path) : normalizeContentPath(resolved.routePath);
+  return createCollectionSurroundings(navigation, localizedPath, options);
+};
+export const resolveCollectionSearchSectionsData = async (collection, runtime, options) => {
+  const { locales, defaultLocale } = resolveCollectionI18n(collection, runtime);
+  const locale = options.locale || options.activeLocale || defaultLocale;
+  const pages = await options.loadPages(options.extraFields || []);
+  const sections = createSearchSections(pages, options);
+  return options.canonical ? sections : localizeSearchSections(sections, locale, defaultLocale, locales);
+};
+export const resolveCollectionPageData = async (collection, routeOrPath, runtime, options) => {
+  const { locales, defaultLocale } = resolveCollectionI18n(collection, runtime);
+  const targetPath = routeOrPath || options.fallbackRoute || "/";
+  const resolved = resolveRouteContent(targetPath, locales, defaultLocale, options.locale);
+  const shouldResolveVariant = Boolean(locales.length || runtime.translatedSlugs || Object.keys(runtime.localeFallback || {}).length);
+  const page = shouldResolveVariant ? await options.loadVariantPage({
+    path: resolved.path,
+    locale: resolved.locale,
+    fallback: options.fallback ?? (resolved.locale && runtime.localeFallback?.[resolved.locale] || [])
+  }) : await options.loadPathPage(resolved.path);
+  if (!page) {
+    return null;
+  }
+  if (options.canonical) {
+    const canonicalPath = normalizeContentPath(page._path || "/");
+    const resolvedLocale = page._resolvedLocale || page._locale || resolved.locale || defaultLocale || "";
+    const requestedLocale = page._requestedLocale || resolved.locale;
+    const fallback = Boolean(page._fallback || requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale);
+    return {
+      ...page,
+      path: canonicalPath,
+      canonicalPath,
+      locale: resolved.locale || resolvedLocale,
+      defaultLocale: defaultLocale || "",
+      variants: [],
+      localePaths: {},
+      resolved: {
+        locale: resolvedLocale,
+        ...requestedLocale ? { requestedLocale } : {},
+        fallback,
+        ...fallback ? { fallbackLocale: resolvedLocale } : {},
+        path: canonicalPath,
+        ...page._requestedPath ? { requestedPath: page._requestedPath } : {},
+        ...page._requestedRoute ? { requestedRoute: page._requestedRoute } : {},
+        ...page._requestedRef ? { requestedRef: page._requestedRef } : {},
+        availableLocales: page._availableLocales || Object.keys(page._variantPaths || {})
+      },
+      stem: canonicalPath.replace(/^\/+/, "") || "index",
+      extension: page._extension
+    };
+  }
+  return localizePageResult(page, resolved.locale, defaultLocale, locales);
+};
+export const resolveCollectionRouteMetaData = async (collection, runtime, options) => {
+  const page = await options.loadPage(options.routeOrPath, { locale: options.locale, fallback: options.fallback });
+  if (!page) {
+    return null;
+  }
+  const { defaultLocale } = resolveCollectionI18n(collection, runtime);
+  return createRouteMeta(page, page.locale, defaultLocale);
+};

package/dist/features/localization/config

@@ -0,0 +1 @@
+export * from './config.js'

package/dist/features/localization/config.d.ts

@@ -0,0 +1,18 @@
+import type { ContentCollectionI18nConfig } from '../../types/config';
+export interface ContentI18nConfigInput {
+    defaultLocale?: string;
+    locales?: string[];
+}
+export interface CollectionI18nInput {
+    source?: string | string[];
+    i18n?: true | ContentI18nConfigInput;
+}
+export type RuntimeCollectionI18nInput = CollectionI18nInput;
+export interface RuntimeContentI18nInput extends ContentI18nConfigInput {
+    collections?: Record<string, RuntimeCollectionI18nInput | undefined>;
+}
+export declare const normalizeI18nConfig: (config?: ContentI18nConfigInput) => ContentCollectionI18nConfig | undefined;
+export declare const resolveCollectionI18nConfig: (collection?: CollectionI18nInput, globalI18n?: ContentI18nConfigInput, options?: {
+    warnMissingGlobal?: boolean;
+}) => ContentCollectionI18nConfig | undefined;
+export declare const resolveRuntimeCollectionI18nConfig: (collection: string, content: RuntimeContentI18nInput) => ContentCollectionI18nConfig | undefined;

package/dist/features/localization/config.js

@@ -0,0 +1,25 @@
+export const normalizeI18nConfig = (config) => {
+  if (!config?.defaultLocale || !config.locales?.length) {
+    return void 0;
+  }
+  return {
+    defaultLocale: config.defaultLocale,
+    locales: config.locales
+  };
+};
+export const resolveCollectionI18nConfig = (collection, globalI18n, options = {}) => {
+  if (collection?.i18n && collection.i18n !== true) {
+    return normalizeI18nConfig(collection.i18n);
+  }
+  const inherited = normalizeI18nConfig(globalI18n);
+  if (inherited) {
+    return inherited;
+  }
+  if (collection?.i18n === true && options.warnMissingGlobal) {
+    console.warn(`[content] Collection source "${collection.source}" set i18n: true but no content.i18n config was found in nuxt.config.ts. i18n is disabled for this collection.`);
+  }
+  return void 0;
+};
+export const resolveRuntimeCollectionI18nConfig = (collection, content) => {
+  return resolveCollectionI18nConfig(content.collections?.[collection], content);
+};

package/dist/features/localization/links

@@ -0,0 +1 @@
+export * from './links.js'

package/dist/features/localization/links.d.ts

@@ -0,0 +1 @@
+export declare const localizeLinkProps: (props: Record<string, unknown>, locale?: string, defaultLocale?: string, locales?: string[]) => void;

package/dist/features/localization/links.js

@@ -0,0 +1,69 @@
+import { localizePath } from "./path.js";
+const LOCALIZED_PROP_KEYS = /* @__PURE__ */ new Set(["href", "to", "path", "_path"]);
+const LOCALIZED_BOUND_PREFIXES = [":", "v-bind:"];
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const getBoundPropName = (key) => {
+  for (const prefix of LOCALIZED_BOUND_PREFIXES) {
+    if (key.startsWith(prefix)) {
+      return key.slice(prefix.length);
+    }
+  }
+  return null;
+};
+const localizeSerializedBoundProp = (key, value, locale, defaultLocale, locales = []) => {
+  const boundProp = getBoundPropName(key);
+  if (!boundProp) {
+    return value;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed === "string" && LOCALIZED_PROP_KEYS.has(boundProp)) {
+      return JSON.stringify(localizePath(parsed, locale, defaultLocale, locales));
+    }
+    if (Array.isArray(parsed)) {
+      for (const item of parsed) {
+        if (isRecord(item)) {
+          localizeLinkProps(item, locale, defaultLocale, locales);
+        }
+      }
+      return JSON.stringify(parsed);
+    }
+    if (isRecord(parsed)) {
+      localizeLinkProps(parsed, locale, defaultLocale, locales);
+      return JSON.stringify(parsed);
+    }
+  } catch {
+    return value;
+  }
+  return value;
+};
+const localizeDirectLinkKeys = (props, locale, defaultLocale, locales = []) => {
+  for (const [key, value] of Object.entries(props)) {
+    if (typeof value === "string" && LOCALIZED_PROP_KEYS.has(key)) {
+      props[key] = localizePath(value, locale, defaultLocale, locales);
+      continue;
+    }
+    if (typeof value === "string") {
+      const localizedValue = localizeSerializedBoundProp(key, value, locale, defaultLocale, locales);
+      if (localizedValue !== value) {
+        props[key] = localizedValue;
+      }
+    }
+  }
+};
+export const localizeLinkProps = (props, locale, defaultLocale, locales = []) => {
+  localizeDirectLinkKeys(props, locale, defaultLocale, locales);
+  for (const value of Object.values(props)) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (isRecord(item)) {
+          localizeLinkProps(item, locale, defaultLocale, locales);
+        }
+      }
+      continue;
+    }
+    if (isRecord(value)) {
+      localizeLinkProps(value, locale, defaultLocale, locales);
+    }
+  }
+};

package/dist/features/localization/path

@@ -0,0 +1 @@
+export * from './path.js'

package/dist/features/localization/path.d.ts

@@ -0,0 +1,32 @@
+import { type RuntimeContentI18nInput } from './config';
+import { mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale, projectContentPathToLocale, routeRemainder, routeToContentPathCandidates, stripLocalePrefix, type RouteMounts } from '../../core/content/path';
+export { mountContentPath, normalizeContentPath, normalizeRouteMounts, prefixPathWithLocale, projectContentPathToLocale, routeRemainder, routeToContentPathCandidates, stripLocalePrefix, type RouteMounts };
+export declare const fallbackStem: (path: string) => string;
+export declare const getContentStem: (path: string, file?: string) => string;
+export declare const resolveCollectionI18n: (collection: string, content: RuntimeContentI18nInput) => {
+    locales: string[];
+    defaultLocale: string | undefined;
+};
+/**
+ * Split a URL path into its locale prefix and underlying content path.
+ *
+ * Example: `/de/guide/intro` with locales `['de', 'en']` and defaultLocale `en`
+ * returns `{ locale: 'de', path: '/guide/intro', routePath: '/de/guide/intro' }`.
+ *
+ * `explicitLocale` wins over the path-derived locale when provided - callers
+ * that know the active locale should pass it so `/guide/intro` is treated as
+ * the default-locale variant rather than an unprefixed non-default page.
+ */
+export declare const resolveRouteContent: (path: string, locales?: string[], defaultLocale?: string, explicitLocale?: string) => {
+    locale: string | undefined;
+    path: string;
+    routePath: string;
+};
+/**
+ * Add a locale prefix to a link-like string, preserving any `?query#hash` suffix.
+ *
+ * Returns `value` unchanged when the string is not a locale-able path:
+ * external/protocol-relative URLs, already locale-prefixed URLs, reserved API
+ * prefixes, and file-extension assets.
+ */
+export declare const localizePath: (value: string | undefined, locale?: string, defaultLocale?: string, locales?: string[]) => string | undefined;

package/dist/features/localization/path.js

@@ -0,0 +1,80 @@
+import { resolveRuntimeCollectionI18nConfig } from "./config.js";
+import {
+  mountContentPath,
+  normalizeContentPath,
+  normalizeRouteMounts,
+  pathHasLocalePrefix,
+  prefixPathWithLocale,
+  projectContentPathToLocale,
+  routeRemainder,
+  routeToContentPathCandidates,
+  stripLocalePrefix
+} from "../../core/content/path";
+export {
+  mountContentPath,
+  normalizeContentPath,
+  normalizeRouteMounts,
+  prefixPathWithLocale,
+  projectContentPathToLocale,
+  routeRemainder,
+  routeToContentPathCandidates,
+  stripLocalePrefix
+};
+const NON_LOCALIZED_PREFIXES = ["/api", "/llms", "/raw"];
+const HAS_FILE_EXTENSION = /\/[^/]+\.[^/]+$/;
+const stripExtension = (file) => file?.replace(/\.[^/.]+$/, "") || "";
+export const fallbackStem = (path) => {
+  if (path === "/") {
+    return "index";
+  }
+  return `${path.replace(/^\/+/, "")}/index`;
+};
+export const getContentStem = (path, file) => stripExtension(file) || fallbackStem(path);
+export const resolveCollectionI18n = (collection, content) => {
+  const resolved = resolveRuntimeCollectionI18nConfig(collection, content);
+  return {
+    locales: resolved?.locales || [],
+    defaultLocale: resolved?.defaultLocale
+  };
+};
+export const resolveRouteContent = (path, locales = [], defaultLocale, explicitLocale) => {
+  const normalized = normalizeContentPath(path);
+  const segments = normalized.split("/").filter(Boolean);
+  const routeLocale = segments[0] && locales.includes(segments[0]) && segments[0] !== defaultLocale ? segments[0] : void 0;
+  const locale = explicitLocale && locales.includes(explicitLocale) ? explicitLocale : routeLocale || defaultLocale;
+  const contentPath = routeLocale ? normalizeContentPath("/" + segments.slice(1).join("/")) : normalized;
+  return {
+    locale,
+    path: contentPath || "/",
+    routePath: normalized
+  };
+};
+const splitPathSuffix = (value) => {
+  const match = value.match(/^([^?#]*)(.*)$/);
+  return {
+    pathname: match?.[1] || value,
+    suffix: match?.[2] || ""
+  };
+};
+const shouldLocalizePath = (value, locales) => {
+  if (!value || !value.startsWith("/")) {
+    return false;
+  }
+  if (value.startsWith("//")) {
+    return false;
+  }
+  if (pathHasLocalePrefix(value, locales)) {
+    return false;
+  }
+  return !NON_LOCALIZED_PREFIXES.some((prefix) => value === prefix || value.startsWith(`${prefix}/`)) && !HAS_FILE_EXTENSION.test(value);
+};
+export const localizePath = (value, locale, defaultLocale, locales = []) => {
+  if (!value) {
+    return value;
+  }
+  const { pathname, suffix } = splitPathSuffix(value);
+  if (!shouldLocalizePath(pathname, locales)) {
+    return value;
+  }
+  return `${prefixPathWithLocale(pathname, locale, defaultLocale)}${suffix}`;
+};

package/dist/features/localization/results

@@ -0,0 +1 @@
+export * from './results.js'

package/dist/features/localization/results.d.ts

@@ -0,0 +1,42 @@
+import type { ContentNavigationItem, ParsedContent } from '../../types/content';
+import type { ContentLocaleEntry, ContentPageResult, ContentRouteMeta, LocalePathEntry } from '../../types/query';
+import type { SearchSection } from '../search/sections';
+import { type RouteMounts } from './path';
+export declare const createLocaleVariants: (variants: Record<string, string> | ContentLocaleEntry[] | undefined, defaultLocale?: string, routeMounts?: RouteMounts) => {
+    locale: string;
+    canonicalPath: string;
+    path: string;
+}[];
+/**
+ * Build the per-locale path map attached to localized documents.
+ *
+ * `variants` here only enumerates locales that actually have a concrete
+ * variant — `translated` is therefore always `true` in this map. When a
+ * caller (e.g. `localizePageResultWithFallbacks`) wants to expose every
+ * configured locale (including ones backed by fallback), it should fill in
+ * the missing entries with `{ path: <fallback path>, translated: false, fallback }`.
+ */
+export declare const createLocalePaths: (variants: ReturnType<typeof createLocaleVariants>) => Record<string, LocalePathEntry>;
+/**
+ * Decorate a `localePaths` map so every configured locale has an entry. Any
+ * locale missing a concrete variant is back-filled with the fallback locale's
+ * path and `translated: false`.
+ */
+export declare const decorateLocalePathsWithFallbacks: (localePaths: Record<string, LocalePathEntry>, configuredLocales: string[], fallbackLocale?: string, defaultLocale?: string, routeMounts?: RouteMounts) => Record<string, LocalePathEntry>;
+/**
+ * Shape a parsed page into the `ContentPageResult` used by current route
+ * helpers: locale-prefixed route path, variants,
+ * localePaths, and localized top-level link metadata. The page body is never
+ * mutated.
+ */
+export declare const localizePageResult: <T extends ParsedContent & Record<string, unknown>>(page: T, locale?: string, defaultLocale?: string, locales?: string[], routeMounts?: RouteMounts) => ContentPageResult<T>;
+export declare const localizeNavigation: (navigation?: ContentNavigationItem[], locale?: string, defaultLocale?: string, locales?: string[], routeMounts?: RouteMounts) => import("../../types/content").NavItem[];
+export declare const localizeSurround: <T extends Record<string, unknown>>(items?: Array<T | null>, locale?: string, defaultLocale?: string, _locales?: string[], routeMounts?: RouteMounts) => Array<T | null>;
+export declare const localizeSearchSections: (sections?: SearchSection[], locale?: string, defaultLocale?: string, locales?: string[]) => {
+    id: string;
+    title: string;
+    titles: string[];
+    level: number;
+    content: string;
+}[];
+export declare const createRouteMeta: <T extends ParsedContent & Record<string, unknown>>(page: T, locale?: string, defaultLocale?: string, routeMounts?: RouteMounts) => ContentRouteMeta;

package/dist/features/localization/results.js

@@ -0,0 +1,149 @@
+import { localizeLinkProps } from "./links.js";
+import { getContentStem, localizePath, normalizeContentPath, projectContentPathToLocale } from "./path.js";
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+export const createLocaleVariants = (variants, defaultLocale, routeMounts) => {
+  if (!variants) {
+    return [];
+  }
+  const entries = Array.isArray(variants) ? variants : Object.entries(variants).map(([locale, path]) => ({
+    canonicalKey: path,
+    locale,
+    path
+  }));
+  return entries.filter((entry) => entry.path).map((entry) => ({
+    locale: entry.locale,
+    canonicalPath: normalizeContentPath(entry.path || "/"),
+    path: projectContentPathToLocale(entry.path || "/", entry.locale, defaultLocale, routeMounts)
+  }));
+};
+export const createLocalePaths = (variants) => {
+  return Object.fromEntries(
+    variants.map((variant) => [variant.locale, { path: variant.path, translated: true }])
+  );
+};
+export const decorateLocalePathsWithFallbacks = (localePaths, configuredLocales, fallbackLocale, defaultLocale, routeMounts) => {
+  if (!configuredLocales.length) {
+    return localePaths;
+  }
+  const result = { ...localePaths };
+  const fallbackPath = fallbackLocale ? localePaths[fallbackLocale]?.path : void 0;
+  for (const locale of configuredLocales) {
+    if (result[locale]) continue;
+    if (fallbackLocale && fallbackPath) {
+      result[locale] = {
+        path: projectContentPathToLocale(fallbackPath, locale, defaultLocale, routeMounts),
+        translated: false,
+        fallback: fallbackLocale
+      };
+    }
+  }
+  return result;
+};
+export const localizePageResult = (page, locale, defaultLocale, locales = [], routeMounts) => {
+  const canonicalPath = normalizeContentPath(page._path || "/");
+  const variants = createLocaleVariants(page._variantPaths, defaultLocale, routeMounts);
+  const path = projectContentPathToLocale(canonicalPath, locale || page._resolvedLocale || page._locale, defaultLocale, routeMounts);
+  const resolvedLocale = page._resolvedLocale || page._locale || locale || defaultLocale || "";
+  const requestedLocale = page._requestedLocale || locale;
+  const fallback = Boolean(page._fallback || requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale);
+  const result = {
+    ...page,
+    path,
+    canonicalPath,
+    locale: locale || page._resolvedLocale || page._locale || defaultLocale || "",
+    defaultLocale: defaultLocale || "",
+    variants,
+    localePaths: createLocalePaths(variants),
+    resolved: {
+      locale: resolvedLocale,
+      ...requestedLocale ? { requestedLocale } : {},
+      fallback,
+      ...fallback ? { fallbackLocale: resolvedLocale } : {},
+      path,
+      ...page._requestedPath ? { requestedPath: page._requestedPath } : {},
+      ...page._requestedRoute ? { requestedRoute: page._requestedRoute } : {},
+      ...page._requestedRef ? { requestedRef: page._requestedRef } : {},
+      availableLocales: page._availableLocales || Object.keys(page._variantPaths || {})
+    },
+    stem: getContentStem(canonicalPath, page._file),
+    extension: page._extension
+  };
+  const links = result.links;
+  if (Array.isArray(links)) {
+    ;
+    result.links = links.map((link) => {
+      if (!isRecord(link)) {
+        return link;
+      }
+      const localizedLink = structuredClone(link);
+      localizeLinkProps(localizedLink, locale, defaultLocale, locales);
+      return localizedLink;
+    });
+  }
+  return result;
+};
+const localizeNavigationItem = (item, locale, defaultLocale, locales = [], routeMounts) => {
+  const rawPath = typeof item._path === "string" ? item._path : typeof item.path === "string" ? item.path : void 0;
+  if (!rawPath) {
+    return {
+      ...item,
+      children: item.children?.map((child) => localizeNavigationItem(child, locale, defaultLocale, locales, routeMounts))
+    };
+  }
+  const canonicalPath = normalizeContentPath(rawPath);
+  const localizedPath = projectContentPathToLocale(canonicalPath, locale, defaultLocale, routeMounts);
+  const file = typeof item._file === "string" ? item._file : void 0;
+  return {
+    ...item,
+    _path: canonicalPath,
+    path: localizedPath,
+    canonicalPath,
+    stem: item.stem || getContentStem(canonicalPath, file),
+    children: item.children?.map((child) => localizeNavigationItem(child, locale, defaultLocale, locales, routeMounts))
+  };
+};
+export const localizeNavigation = (navigation = [], locale, defaultLocale, locales = [], routeMounts) => navigation.map((item) => localizeNavigationItem(item, locale, defaultLocale, locales, routeMounts));
+export const localizeSurround = (items = [], locale, defaultLocale, _locales = [], routeMounts) => items.map((item) => {
+  if (!item) {
+    return item;
+  }
+  const canonicalPath = normalizeContentPath(String(item._path || item.path || "/"));
+  return {
+    ...item,
+    _path: canonicalPath,
+    path: projectContentPathToLocale(canonicalPath, locale, defaultLocale, routeMounts),
+    canonicalPath,
+    stem: item.stem || getContentStem(canonicalPath, typeof item._file === "string" ? item._file : void 0)
+  };
+});
+export const localizeSearchSections = (sections = [], locale, defaultLocale, locales = []) => sections.map((section) => ({
+  ...section,
+  id: localizePath(section.id, locale, defaultLocale, locales) || section.id
+}));
+export const createRouteMeta = (page, locale, defaultLocale, routeMounts) => {
+  const canonicalPath = normalizeContentPath(page._path || "/");
+  const resolvedLocale = page._resolvedLocale || page._locale || locale || defaultLocale || "";
+  const requestedLocale = page._requestedLocale || locale;
+  const fallback = Boolean(page._fallback || requestedLocale && resolvedLocale && requestedLocale !== resolvedLocale);
+  const variants = createLocaleVariants(page._variantPaths, defaultLocale, routeMounts);
+  const path = projectContentPathToLocale(canonicalPath, locale || resolvedLocale, defaultLocale, routeMounts);
+  return {
+    locale: locale || resolvedLocale,
+    defaultLocale: defaultLocale || "",
+    path,
+    canonicalPath,
+    variants,
+    localePaths: createLocalePaths(variants),
+    resolved: {
+      locale: resolvedLocale,
+      ...requestedLocale ? { requestedLocale } : {},
+      fallback,
+      ...fallback ? { fallbackLocale: resolvedLocale } : {},
+      path,
+      ...page._requestedPath ? { requestedPath: page._requestedPath } : {},
+      ...page._requestedRoute ? { requestedRoute: page._requestedRoute } : {},
+      ...page._requestedRef ? { requestedRef: page._requestedRef } : {},
+      availableLocales: page._availableLocales || Object.keys(page._variantPaths || {})
+    }
+  };
+};

package/dist/features/localization/translated-slugs

@@ -0,0 +1 @@
+export * from './translated-slugs.js'

package/dist/features/localization/translated-slugs.d.ts

@@ -0,0 +1,11 @@
+import type { ParsedContent } from '../../types/content';
+export type TranslatedSlugValidationIssue = {
+    level: 'warn' | 'error';
+    file: string;
+    reason: string;
+    details?: string;
+};
+export declare const collectTranslatedSlugValidationIssues: (contents: ParsedContent[], options: {
+    translatedSlugs?: boolean;
+    locales?: string[];
+}) => TranslatedSlugValidationIssue[];