npm - @flyo/nitro-next - Versions diffs - 2.0.1 → 2.2.0 - Mend

@flyo/nitro-next 2.0.1 → 2.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/server.d.mts CHANGED Viewed

@@ -1,14 +1,91 @@
 import * as react from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { MetadataRoute, Metadata } from 'next';
-import { Entity, ConfigResponse, PagesApi, EntitiesApi, SitemapApi, SearchApi, Page, Block } from '@flyo/nitro-typescript';
+import { Translation, Entity, ConfigResponse, PagesApi, EntitiesApi, SitemapApi, SearchApi, Page, Block } from '@flyo/nitro-typescript';
+export { Translation } from '@flyo/nitro-typescript';
+/**
+ * A single language option for a language switcher, derived from a page's or
+ * entity's `translation[]`. Framework-agnostic plain data — render it however
+ * you like.
+ */
+interface FlyoLanguageLink {
+    /** Locale shortcode, e.g. `"de"`. */
+    shortcode: string;
+    /** Full language name from the CMS translation, e.g. `"Deutsch"` (when available). */
+    name?: string;
+    /** Fully-resolved localized href, or `null` when this locale has no linked translation. */
+    href: string | null;
+    /** Localized page/entity title, when available. */
+    title?: string;
+    /** `true` when this entry is the currently active locale. */
+    isCurrent: boolean;
+    /** `true` when a linked translation actually exists for this locale. */
+    exists: boolean;
+}
+/**
+ * Map a page's or entity's `translation[]` into a switcher-ready array of typed
+ * links — the building block for a language switcher.
+ *
+ * Flyo only returns `translation` entries for languages that actually have a
+ * translation. Pass `options.locales` (e.g. `flyo.state.locales`) to also get an
+ * entry for every configured locale that is *missing* a translation — those come
+ * back as `{ href: null, exists: false }` so you can render a fallback (a disabled
+ * item, a link to the home page, …).
+ *
+ * Pure — no React or server-only APIs, so it is safe to call from server *or*
+ * client components.
+ *
+ * This is a pure *data* helper — it maps a `translation[]` to switcher links and
+ * renders nothing. **The Flyo route helpers already call it for you and publish
+ * the result**, so page and entity routes need no switcher code at all; the
+ * footer just reads the store (see `publishLanguageLinks` / `readLanguageLinks`
+ * in `@flyo/nitro-next/server`). Call this directly only when you publish links
+ * by hand from a raw `translation[]` — e.g. on a custom route Flyo doesn't
+ * resolve:
+ *
+ * ```tsx
+ * getLanguageLinks(translations, { currentLang, locales });
+ * ```
+ *
+ * **Render each link as a native `<a>`, not `next/link`'s `<Link>`.** A language
+ * switch must refresh the shared chrome — the localized nav, footer and
+ * `<html lang>` — that lives in the root layout. In the Next.js App Router, soft
+ * (client-side) navigation re-renders only the page segment, *not* shared
+ * layouts, so a `<Link>` would leave that chrome in the previous language while
+ * only the page body updates. A plain `<a>` triggers a full-document navigation,
+ * forcing a fresh server render in the new locale so every part updates. (Regular
+ * nav links can stay `<Link>` — the nav is identical within a language.)
+ *
+ * @example
+ * ```tsx
+ * const links = getLanguageLinks(page.translation, {
+ *   currentLang: lang,
+ *   locales: flyo.state.locales,
+ * });
+ * // Native <a> (full-document nav) — NOT next/link, so shared layout chrome
+ * // re-renders in the new locale.
+ * // links.map(l => l.exists
+ * //   ? <a key={l.shortcode} href={l.href!} aria-current={l.isCurrent || undefined}>{l.name ?? l.shortcode}</a>
+ * //   : <span key={l.shortcode} aria-disabled>{l.shortcode}</span>)
+ * ```
+ */
+declare function getLanguageLinks(translations: Translation[] | undefined, options?: {
+    currentLang?: string;
+    locales?: string[];
+}): FlyoLanguageLink[];
 /**
  * Read-only configuration state
  */
 interface NitroState {
     readonly accessToken: string;
+    /** The single default language (back-compat). Prefer `defaultLocale` for i18n. */
     readonly lang: string | null;
+    /** All locale shortcodes the site supports, e.g. `['de', 'en']`. Empty for single-language setups. */
+    readonly locales: string[];
+    /** The primary/default locale (no URL prefix). Matches `config.nitro.primary_language`. */
+    readonly defaultLocale: string | null;
     readonly baseUrl: string | null;
     readonly components: Record<string, any>;
     readonly showMissingComponentAlert: boolean;
@@ -42,8 +119,12 @@ type EntityResolver<T = any> = (params: Promise<T>) => Promise<Entity>;
 interface FlyoInstance {
     /** Read-only configuration state */
     readonly state: NitroState;
-    /** Fetch and cache the Nitro CMS configuration (React-cached per request) */
-    getNitroConfig(): Promise<ConfigResponse>;
+    /**
+     * Fetch and cache the Nitro CMS configuration (React-cached per requested locale).
+     * When `lang` is omitted, the active request locale is used (from the `x-flyo-locale`
+     * header set by the proxy), falling back to `defaultLocale`.
+     */
+    getNitroConfig(lang?: string): Promise<ConfigResponse>;
     /** Create a PagesApi client */
     getNitroPages(): PagesApi;
     /** Create an EntitiesApi client */
@@ -52,10 +133,17 @@ interface FlyoInstance {
     getNitroSitemap(): SitemapApi;
     /** Create a SearchApi client */
     getNitroSearch(): SearchApi;
+    /**
+     * Resolve the active request locale from the `x-flyo-locale` header (set by the
+     * proxy middleware), falling back to `defaultLocale`. Use it inside entity
+     * resolvers or to set `<html lang>`.
+     */
+    getRequestLocale(): Promise<string | undefined>;
     /** Resolve a page from catch-all route params (React-cached per request) */
     pageResolveRoute(props: RouteParams): Promise<{
         page: Page;
         path: string;
+        lang: string | undefined;
         cfg: ConfigResponse;
     }>;
     /** Generate a Next.js sitemap from Flyo Nitro content */
@@ -82,9 +170,13 @@ interface FlyoInstance {
  * });
  * ```
  */
-declare function initNitro({ accessToken, lang, baseUrl, components, showMissingComponentAlert, liveEdit, serverCacheTtl, clientCacheTtl, }: {
+declare function initNitro({ accessToken, lang, locales, defaultLocale, baseUrl, components, showMissingComponentAlert, liveEdit, serverCacheTtl, clientCacheTtl, }: {
     accessToken: string;
     lang?: string;
+    /** All supported locale shortcodes, e.g. `['de', 'en']`. Enables per-request i18n. */
+    locales?: string[];
+    /** The primary/default locale (no URL prefix). Defaults to `lang`. Should match `config.nitro.primary_language`. */
+    defaultLocale?: string;
     baseUrl?: string;
     components?: Record<string, any>;
     showMissingComponentAlert?: boolean;
@@ -92,6 +184,63 @@ declare function initNitro({ accessToken, lang, baseUrl, components, showMissing
     serverCacheTtl?: number;
     clientCacheTtl?: number;
 }): FlyoInstance;
+interface LanguageLinksStore {
+    /** Publish the links once. Later calls are ignored (first publish wins). */
+    publish(links: FlyoLanguageLink[]): void;
+    /** A promise that resolves when the links are published. */
+    read(): Promise<FlyoLanguageLink[]>;
+}
+/**
+ * Create a single deferred language-links channel: one writer, many readers,
+ * order-independent. Low-level — most code uses {@link publishLanguageLinks} /
+ * {@link readLanguageLinks}, which wrap this in a per-request `cache()`.
+ */
+declare function createLanguageLinksStore(): LanguageLinksStore;
+/**
+ * Publish the current route's language-switcher links into the request-scoped
+ * store, so a switcher rendered in shared chrome (e.g. a footer in the root
+ * layout) can read them via {@link readLanguageLinks}.
+ *
+ * The Flyo route helpers call this for you: `pageResolveRoute` (and therefore
+ * `nitroPageRoute`) publishes the page's links, and `nitroEntityRoute` /
+ * `nitroEntityGenerateMetadata` publish the entity's. You only need to call it
+ * yourself on routes that render the shared switcher **without** going through
+ * those helpers — a custom page, or `not-found.tsx` — where you would otherwise
+ * leave the footer waiting forever. Pass a fallback there, e.g.
+ * `publishLanguageLinks(getLanguageLinks(undefined, { currentLang, locales }))`.
+ *
+ * Only the first call per request takes effect.
+ */
+declare function publishLanguageLinks(links: FlyoLanguageLink[]): void;
+/**
+ * Await the current route's language-switcher links from shared chrome — a
+ * footer, header, or any component in the root layout. Resolves with whatever
+ * the active page/entity route passed to {@link publishLanguageLinks}.
+ *
+ * Because it awaits, the reader suspends until the links are published, so it
+ * works no matter whether the layout or the page renders first. Wrap the reading
+ * component in `<Suspense>` so the rest of the layout can stream while it waits.
+ *
+ * @example
+ * ```tsx
+ * // components/LanguageSwitcher.tsx  (server component)
+ * import { readLanguageLinks } from '@flyo/nitro-next/server';
+ *
+ * export async function LanguageSwitcher() {
+ *   const links = await readLanguageLinks();
+ *   return (
+ *     <nav aria-label="Language">
+ *       {links.map((l) =>
+ *         l.exists
+ *           ? <a key={l.shortcode} href={l.href!} aria-current={l.isCurrent || undefined}>{l.name ?? l.shortcode}</a>
+ *           : <span key={l.shortcode} aria-disabled>{l.shortcode}</span>,
+ *       )}
+ *     </nav>
+ *   );
+ * }
+ * ```
+ */
+declare function readLanguageLinks(): Promise<FlyoLanguageLink[]>;
 /**
  * NitroDebugInfo Component
  *
@@ -232,4 +381,4 @@ declare function nitroEntityGenerateMetadata<T = any>(flyo: FlyoInstance, option
     resolver: EntityResolver<T>;
 }): (props: EntityRouteParams<T>) => Promise<Metadata>;
-export { type EntityResolver, type FlyoInstance, NitroBlock, NitroDebugInfo, NitroEntityJsonLd, NitroPage, NitroSlot, type NitroState, initNitro, nitroEntityGenerateMetadata, nitroEntityRoute, nitroPageGenerateMetadata, nitroPageGenerateStaticParams, nitroPageRoute };
+export { type EntityResolver, type FlyoInstance, type FlyoLanguageLink, type LanguageLinksStore, NitroBlock, NitroDebugInfo, NitroEntityJsonLd, NitroPage, NitroSlot, type NitroState, createLanguageLinksStore, getLanguageLinks, initNitro, nitroEntityGenerateMetadata, nitroEntityRoute, nitroPageGenerateMetadata, nitroPageGenerateStaticParams, nitroPageRoute, publishLanguageLinks, readLanguageLinks };

package/dist/server.d.ts CHANGED Viewed

@@ -1,14 +1,91 @@
 import * as react from 'react';
 import * as react_jsx_runtime from 'react/jsx-runtime';
 import { MetadataRoute, Metadata } from 'next';
-import { Entity, ConfigResponse, PagesApi, EntitiesApi, SitemapApi, SearchApi, Page, Block } from '@flyo/nitro-typescript';
+import { Translation, Entity, ConfigResponse, PagesApi, EntitiesApi, SitemapApi, SearchApi, Page, Block } from '@flyo/nitro-typescript';
+export { Translation } from '@flyo/nitro-typescript';
+/**
+ * A single language option for a language switcher, derived from a page's or
+ * entity's `translation[]`. Framework-agnostic plain data — render it however
+ * you like.
+ */
+interface FlyoLanguageLink {
+    /** Locale shortcode, e.g. `"de"`. */
+    shortcode: string;
+    /** Full language name from the CMS translation, e.g. `"Deutsch"` (when available). */
+    name?: string;
+    /** Fully-resolved localized href, or `null` when this locale has no linked translation. */
+    href: string | null;
+    /** Localized page/entity title, when available. */
+    title?: string;
+    /** `true` when this entry is the currently active locale. */
+    isCurrent: boolean;
+    /** `true` when a linked translation actually exists for this locale. */
+    exists: boolean;
+}
+/**
+ * Map a page's or entity's `translation[]` into a switcher-ready array of typed
+ * links — the building block for a language switcher.
+ *
+ * Flyo only returns `translation` entries for languages that actually have a
+ * translation. Pass `options.locales` (e.g. `flyo.state.locales`) to also get an
+ * entry for every configured locale that is *missing* a translation — those come
+ * back as `{ href: null, exists: false }` so you can render a fallback (a disabled
+ * item, a link to the home page, …).
+ *
+ * Pure — no React or server-only APIs, so it is safe to call from server *or*
+ * client components.
+ *
+ * This is a pure *data* helper — it maps a `translation[]` to switcher links and
+ * renders nothing. **The Flyo route helpers already call it for you and publish
+ * the result**, so page and entity routes need no switcher code at all; the
+ * footer just reads the store (see `publishLanguageLinks` / `readLanguageLinks`
+ * in `@flyo/nitro-next/server`). Call this directly only when you publish links
+ * by hand from a raw `translation[]` — e.g. on a custom route Flyo doesn't
+ * resolve:
+ *
+ * ```tsx
+ * getLanguageLinks(translations, { currentLang, locales });
+ * ```
+ *
+ * **Render each link as a native `<a>`, not `next/link`'s `<Link>`.** A language
+ * switch must refresh the shared chrome — the localized nav, footer and
+ * `<html lang>` — that lives in the root layout. In the Next.js App Router, soft
+ * (client-side) navigation re-renders only the page segment, *not* shared
+ * layouts, so a `<Link>` would leave that chrome in the previous language while
+ * only the page body updates. A plain `<a>` triggers a full-document navigation,
+ * forcing a fresh server render in the new locale so every part updates. (Regular
+ * nav links can stay `<Link>` — the nav is identical within a language.)
+ *
+ * @example
+ * ```tsx
+ * const links = getLanguageLinks(page.translation, {
+ *   currentLang: lang,
+ *   locales: flyo.state.locales,
+ * });
+ * // Native <a> (full-document nav) — NOT next/link, so shared layout chrome
+ * // re-renders in the new locale.
+ * // links.map(l => l.exists
+ * //   ? <a key={l.shortcode} href={l.href!} aria-current={l.isCurrent || undefined}>{l.name ?? l.shortcode}</a>
+ * //   : <span key={l.shortcode} aria-disabled>{l.shortcode}</span>)
+ * ```
+ */
+declare function getLanguageLinks(translations: Translation[] | undefined, options?: {
+    currentLang?: string;
+    locales?: string[];
+}): FlyoLanguageLink[];
 /**
  * Read-only configuration state
  */
 interface NitroState {
     readonly accessToken: string;
+    /** The single default language (back-compat). Prefer `defaultLocale` for i18n. */
     readonly lang: string | null;
+    /** All locale shortcodes the site supports, e.g. `['de', 'en']`. Empty for single-language setups. */
+    readonly locales: string[];
+    /** The primary/default locale (no URL prefix). Matches `config.nitro.primary_language`. */
+    readonly defaultLocale: string | null;
     readonly baseUrl: string | null;
     readonly components: Record<string, any>;
     readonly showMissingComponentAlert: boolean;
@@ -42,8 +119,12 @@ type EntityResolver<T = any> = (params: Promise<T>) => Promise<Entity>;
 interface FlyoInstance {
     /** Read-only configuration state */
     readonly state: NitroState;
-    /** Fetch and cache the Nitro CMS configuration (React-cached per request) */
-    getNitroConfig(): Promise<ConfigResponse>;
+    /**
+     * Fetch and cache the Nitro CMS configuration (React-cached per requested locale).
+     * When `lang` is omitted, the active request locale is used (from the `x-flyo-locale`
+     * header set by the proxy), falling back to `defaultLocale`.
+     */
+    getNitroConfig(lang?: string): Promise<ConfigResponse>;
     /** Create a PagesApi client */
     getNitroPages(): PagesApi;
     /** Create an EntitiesApi client */
@@ -52,10 +133,17 @@ interface FlyoInstance {
     getNitroSitemap(): SitemapApi;
     /** Create a SearchApi client */
     getNitroSearch(): SearchApi;
+    /**
+     * Resolve the active request locale from the `x-flyo-locale` header (set by the
+     * proxy middleware), falling back to `defaultLocale`. Use it inside entity
+     * resolvers or to set `<html lang>`.
+     */
+    getRequestLocale(): Promise<string | undefined>;
     /** Resolve a page from catch-all route params (React-cached per request) */
     pageResolveRoute(props: RouteParams): Promise<{
         page: Page;
         path: string;
+        lang: string | undefined;
         cfg: ConfigResponse;
     }>;
     /** Generate a Next.js sitemap from Flyo Nitro content */
@@ -82,9 +170,13 @@ interface FlyoInstance {
  * });
  * ```
  */
-declare function initNitro({ accessToken, lang, baseUrl, components, showMissingComponentAlert, liveEdit, serverCacheTtl, clientCacheTtl, }: {
+declare function initNitro({ accessToken, lang, locales, defaultLocale, baseUrl, components, showMissingComponentAlert, liveEdit, serverCacheTtl, clientCacheTtl, }: {
     accessToken: string;
     lang?: string;
+    /** All supported locale shortcodes, e.g. `['de', 'en']`. Enables per-request i18n. */
+    locales?: string[];
+    /** The primary/default locale (no URL prefix). Defaults to `lang`. Should match `config.nitro.primary_language`. */
+    defaultLocale?: string;
     baseUrl?: string;
     components?: Record<string, any>;
     showMissingComponentAlert?: boolean;
@@ -92,6 +184,63 @@ declare function initNitro({ accessToken, lang, baseUrl, components, showMissing
     serverCacheTtl?: number;
     clientCacheTtl?: number;
 }): FlyoInstance;
+interface LanguageLinksStore {
+    /** Publish the links once. Later calls are ignored (first publish wins). */
+    publish(links: FlyoLanguageLink[]): void;
+    /** A promise that resolves when the links are published. */
+    read(): Promise<FlyoLanguageLink[]>;
+}
+/**
+ * Create a single deferred language-links channel: one writer, many readers,
+ * order-independent. Low-level — most code uses {@link publishLanguageLinks} /
+ * {@link readLanguageLinks}, which wrap this in a per-request `cache()`.
+ */
+declare function createLanguageLinksStore(): LanguageLinksStore;
+/**
+ * Publish the current route's language-switcher links into the request-scoped
+ * store, so a switcher rendered in shared chrome (e.g. a footer in the root
+ * layout) can read them via {@link readLanguageLinks}.
+ *
+ * The Flyo route helpers call this for you: `pageResolveRoute` (and therefore
+ * `nitroPageRoute`) publishes the page's links, and `nitroEntityRoute` /
+ * `nitroEntityGenerateMetadata` publish the entity's. You only need to call it
+ * yourself on routes that render the shared switcher **without** going through
+ * those helpers — a custom page, or `not-found.tsx` — where you would otherwise
+ * leave the footer waiting forever. Pass a fallback there, e.g.
+ * `publishLanguageLinks(getLanguageLinks(undefined, { currentLang, locales }))`.
+ *
+ * Only the first call per request takes effect.
+ */
+declare function publishLanguageLinks(links: FlyoLanguageLink[]): void;
+/**
+ * Await the current route's language-switcher links from shared chrome — a
+ * footer, header, or any component in the root layout. Resolves with whatever
+ * the active page/entity route passed to {@link publishLanguageLinks}.
+ *
+ * Because it awaits, the reader suspends until the links are published, so it
+ * works no matter whether the layout or the page renders first. Wrap the reading
+ * component in `<Suspense>` so the rest of the layout can stream while it waits.
+ *
+ * @example
+ * ```tsx
+ * // components/LanguageSwitcher.tsx  (server component)
+ * import { readLanguageLinks } from '@flyo/nitro-next/server';
+ *
+ * export async function LanguageSwitcher() {
+ *   const links = await readLanguageLinks();
+ *   return (
+ *     <nav aria-label="Language">
+ *       {links.map((l) =>
+ *         l.exists
+ *           ? <a key={l.shortcode} href={l.href!} aria-current={l.isCurrent || undefined}>{l.name ?? l.shortcode}</a>
+ *           : <span key={l.shortcode} aria-disabled>{l.shortcode}</span>,
+ *       )}
+ *     </nav>
+ *   );
+ * }
+ * ```
+ */
+declare function readLanguageLinks(): Promise<FlyoLanguageLink[]>;
 /**
  * NitroDebugInfo Component
  *
@@ -232,4 +381,4 @@ declare function nitroEntityGenerateMetadata<T = any>(flyo: FlyoInstance, option
     resolver: EntityResolver<T>;
 }): (props: EntityRouteParams<T>) => Promise<Metadata>;
-export { type EntityResolver, type FlyoInstance, NitroBlock, NitroDebugInfo, NitroEntityJsonLd, NitroPage, NitroSlot, type NitroState, initNitro, nitroEntityGenerateMetadata, nitroEntityRoute, nitroPageGenerateMetadata, nitroPageGenerateStaticParams, nitroPageRoute };
+export { type EntityResolver, type FlyoInstance, type FlyoLanguageLink, type LanguageLinksStore, NitroBlock, NitroDebugInfo, NitroEntityJsonLd, NitroPage, NitroSlot, type NitroState, createLanguageLinksStore, getLanguageLinks, initNitro, nitroEntityGenerateMetadata, nitroEntityRoute, nitroPageGenerateMetadata, nitroPageGenerateStaticParams, nitroPageRoute, publishLanguageLinks, readLanguageLinks };

package/dist/server.js CHANGED Viewed

@@ -25,21 +25,54 @@ __export(server_exports, {
   NitroEntityJsonLd: () => NitroEntityJsonLd,
   NitroPage: () => NitroPage,
   NitroSlot: () => NitroSlot,
+  createLanguageLinksStore: () => createLanguageLinksStore,
+  getLanguageLinks: () => getLanguageLinks,
   initNitro: () => initNitro,
   nitroEntityGenerateMetadata: () => nitroEntityGenerateMetadata,
   nitroEntityRoute: () => nitroEntityRoute,
   nitroPageGenerateMetadata: () => nitroPageGenerateMetadata,
   nitroPageGenerateStaticParams: () => nitroPageGenerateStaticParams,
-  nitroPageRoute: () => nitroPageRoute
+  nitroPageRoute: () => nitroPageRoute,
+  publishLanguageLinks: () => publishLanguageLinks,
+  readLanguageLinks: () => readLanguageLinks
 });
 module.exports = __toCommonJS(server_exports);
 var import_react = require("react");
 var import_navigation = require("next/navigation");
+var import_headers = require("next/headers");
 var import_nitro_typescript = require("@flyo/nitro-typescript");
+// src/i18n.ts
+function getLanguageLinks(translations, options) {
+  const currentLang = options?.currentLang;
+  const byShortcode = /* @__PURE__ */ new Map();
+  for (const t of translations ?? []) {
+    const shortcode = t.language?.shortcode;
+    if (shortcode) {
+      byShortcode.set(shortcode, t);
+    }
+  }
+  const toLink = (shortcode, t) => ({
+    shortcode,
+    name: t?.language?.name,
+    href: t?.href ?? null,
+    title: t?.title,
+    isCurrent: shortcode === currentLang,
+    exists: t?.href != null
+  });
+  if (options?.locales && options.locales.length > 0) {
+    return options.locales.map((shortcode) => toLink(shortcode, byShortcode.get(shortcode)));
+  }
+  return (translations ?? []).filter((t) => t.language?.shortcode).map((t) => toLink(t.language.shortcode, t));
+}
+// src/server.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 function initNitro({
   accessToken,
   lang,
+  locales,
+  defaultLocale,
   baseUrl,
   components,
   showMissingComponentAlert,
@@ -48,9 +81,13 @@ function initNitro({
   clientCacheTtl
 }) {
   const configuration = new import_nitro_typescript.Configuration({ apiKey: accessToken });
+  const resolvedDefaultLocale = defaultLocale ?? lang ?? null;
+  const resolvedLocales = locales ?? (resolvedDefaultLocale ? [resolvedDefaultLocale] : []);
   const state = {
     accessToken,
     lang: lang ?? null,
+    locales: resolvedLocales,
+    defaultLocale: resolvedDefaultLocale,
     baseUrl: baseUrl ?? null,
     components: components ?? {},
     showMissingComponentAlert: showMissingComponentAlert ?? liveEdit ?? false,
@@ -58,26 +95,44 @@ function initNitro({
     serverCacheTtl: serverCacheTtl ?? 1200,
     clientCacheTtl: clientCacheTtl ?? 900
   };
-  const getNitroConfig = (0, import_react.cache)(async () => {
+  const getRequestLocale = async () => {
+    try {
+      const requestHeaders = await (0, import_headers.headers)();
+      const headerLocale = requestHeaders.get("x-flyo-locale");
+      if (headerLocale) {
+        return headerLocale;
+      }
+    } catch {
+    }
+    return state.defaultLocale ?? state.lang ?? void 0;
+  };
+  const fetchConfig = (0, import_react.cache)(async (lang2) => {
     const configApi = new import_nitro_typescript.ConfigApi(configuration);
-    const useLang = state.lang ?? void 0;
-    return configApi.config({ lang: useLang });
+    return configApi.config({ lang: lang2 ?? void 0 });
   });
+  const getNitroConfig = async (lang2) => {
+    const useLang = lang2 ?? await getRequestLocale();
+    return fetchConfig(useLang);
+  };
   const pageResolveRoute = (0, import_react.cache)(async ({ params }) => {
     const { slug } = await params;
-    const path = slug?.join("/") ?? "";
-    const cfg = await getNitroConfig();
+    const segments = slug ?? [];
+    const path = segments.join("/");
+    const firstSegment = segments[0];
+    const lang2 = firstSegment && state.locales.includes(firstSegment) ? firstSegment : state.defaultLocale ?? void 0;
+    const cfg = await getNitroConfig(lang2);
     if (!cfg.pages?.includes(path)) {
       (0, import_navigation.notFound)();
     }
-    const page = await new import_nitro_typescript.PagesApi(configuration).page({ slug: path }).catch((error) => {
+    const page = await new import_nitro_typescript.PagesApi(configuration).page({ slug: path, lang: lang2 }).catch((error) => {
       console.error("Error fetching page:", path, error);
       (0, import_navigation.notFound)();
     });
     if (!page) {
       (0, import_navigation.notFound)();
     }
-    return { page, path, cfg };
+    publishLanguageLinks(getLanguageLinks(page.translation, { currentLang: lang2, locales: state.locales }));
+    return { page, path, lang: lang2, cfg };
   });
   const sitemap = async () => {
     const sitemapApi = new import_nitro_typescript.SitemapApi(configuration);
@@ -108,6 +163,7 @@ function initNitro({
   return {
     state,
     getNitroConfig,
+    getRequestLocale,
     getNitroPages: () => new import_nitro_typescript.PagesApi(configuration),
     getNitroEntities: () => new import_nitro_typescript.EntitiesApi(configuration),
     getNitroSitemap: () => new import_nitro_typescript.SitemapApi(configuration),
@@ -116,6 +172,31 @@ function initNitro({
     sitemap
   };
 }
+function createLanguageLinksStore() {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = r;
+  });
+  let settled = false;
+  return {
+    publish(links) {
+      if (!settled) {
+        settled = true;
+        resolve(links);
+      }
+    },
+    read() {
+      return promise;
+    }
+  };
+}
+var languageLinksStore = (0, import_react.cache)(createLanguageLinksStore);
+function publishLanguageLinks(links) {
+  languageLinksStore().publish(links);
+}
+function readLanguageLinks() {
+  return languageLinksStore().read();
+}
 var readEnv = (key, fallback = "") => {
   const value = process.env[key];
   if (value !== void 0 && value !== "") {
@@ -123,12 +204,32 @@ var readEnv = (key, fallback = "") => {
   }
   return fallback;
 };
-function createCachedEntityResolver(resolver) {
+function buildLanguageAlternates(translations, currentLang) {
+  const languages = {};
+  let canonical;
+  for (const t of translations ?? []) {
+    const shortcode = t.language?.shortcode;
+    if (shortcode && t.href) {
+      languages[shortcode] = t.href;
+      if (currentLang && shortcode === currentLang) {
+        canonical = t.href;
+      }
+    }
+  }
+  if (Object.keys(languages).length === 0) {
+    return void 0;
+  }
+  return canonical ? { canonical, languages } : { languages };
+}
+function createCachedEntityResolver(flyo, resolver) {
   return (0, import_react.cache)(async ({ params }) => {
     const entity = await resolver(params);
     if (!entity) {
       (0, import_navigation.notFound)();
     }
+    publishLanguageLinks(
+      getLanguageLinks(entity.translation, { currentLang: entity.language, locales: flyo.state.locales })
+    );
     return entity;
   });
 }
@@ -245,16 +346,18 @@ function nitroPageRoute(flyo) {
 }
 function nitroPageGenerateMetadata(flyo) {
   return async (props) => {
-    const { page } = await flyo.pageResolveRoute(props);
+    const { page, lang } = await flyo.pageResolveRoute(props);
     const meta = page.meta_json;
     const title = meta?.title || page.title || "";
     const description = meta?.description ?? "";
     const image = meta?.image ?? "";
     const ogImage = image ? `${image}/thumb/1200x630?format=jpg` : void 0;
     const twImage = image ? `${image}/thumb/1200x600?format=jpg` : void 0;
+    const alternates = buildLanguageAlternates(page.translation, lang);
     return {
       title,
       description,
+      ...alternates ? { alternates } : {},
       openGraph: {
         title,
         description,
@@ -280,7 +383,7 @@ function nitroPageGenerateStaticParams(flyo) {
   };
 }
 function nitroEntityRoute(flyo, options) {
-  const cachedResolver = createCachedEntityResolver(options.resolver);
+  const cachedResolver = createCachedEntityResolver(flyo, options.resolver);
   async function entityRoute(props) {
     const entity = await cachedResolver(props);
     if (options.render) {
@@ -291,7 +394,7 @@ function nitroEntityRoute(flyo, options) {
   return entityRoute;
 }
 function nitroEntityGenerateMetadata(flyo, options) {
-  const cachedResolver = createCachedEntityResolver(options.resolver);
+  const cachedResolver = createCachedEntityResolver(flyo, options.resolver);
   return async (props) => {
     const entity = await cachedResolver(props);
     const title = entity.entity?.entity_title || "";
@@ -299,9 +402,11 @@ function nitroEntityGenerateMetadata(flyo, options) {
     const image = entity.entity?.entity_image ?? "";
     const ogImage = image ? `${image}/thumb/1200x630?format=jpg` : void 0;
     const twImage = image ? `${image}/thumb/1200x600?format=jpg` : void 0;
+    const alternates = buildLanguageAlternates(entity.translation, entity.language);
     return {
       title,
       description,
+      ...alternates ? { alternates } : {},
       openGraph: {
         title,
         description,
@@ -324,11 +429,15 @@ function nitroEntityGenerateMetadata(flyo, options) {
   NitroEntityJsonLd,
   NitroPage,
   NitroSlot,
+  createLanguageLinksStore,
+  getLanguageLinks,
   initNitro,
   nitroEntityGenerateMetadata,
   nitroEntityRoute,
   nitroPageGenerateMetadata,
   nitroPageGenerateStaticParams,
-  nitroPageRoute
+  nitroPageRoute,
+  publishLanguageLinks,
+  readLanguageLinks
 });
 //# sourceMappingURL=server.js.map