@i18n-micro/astro 1.3.24 → 2.0.0

package/src/request.ts

@@ -0,0 +1,177 @@
+import { externalLinkHref, pathEnd, withoutDots } from '@i18n-micro/core'
+import { trimTrailingSlashes, withoutAppBaseURL } from '@i18n-micro/utils/app-path'
+import { localeFromPath } from '@i18n-micro/utils/resolve-locale'
+import type { I18nRoutingStrategy } from './router/types'
+
+/**
+ * The one request model. Everything below works on the page's path without Astro's `base`:
+ * the middleware strips it once, every URL that goes out gets it back from {@link withBase}.
+ */
+export interface I18nRouting {
+  defaultLocale: string
+  /** Codes of the locales in service: a disabled one is neither a URL's locale nor a redirect target. */
+  locales: string[]
+  /** `''` or `/docs`, no trailing slash. */
+  base: string
+  strategy: I18nRoutingStrategy
+}
+
+/** The parts of an Astro context a request is read from: also a mock in tests. */
+export interface RequestContext {
+  url: URL
+  params?: Record<string, string | undefined>
+  routePattern?: string
+  isPrerendered?: boolean
+  request: { headers: Headers; method?: string }
+}
+
+export interface I18nRequest {
+  /** The page this request is for: another URL than `context.url` for a server island or action. */
+  url: URL
+  /** A server island or action: it belongs to the page in `url`, and is no page view itself. */
+  partOfPage: boolean
+  /** `url.pathname` without `base`. */
+  path: string
+  /** The locale `url` names, `null` for an unprefixed URL. */
+  urlLocale: string | null
+  /** The URL's locale, else the default one: an unprefixed URL is the default locale's page. */
+  locale: string
+  route: string
+}
+
+export const normalizeBase = (base: string | undefined): string => trimTrailingSlashes(base ?? '')
+
+/** `path`, which has no `base`, as a URL of the site. */
+export function withBase(path: string, base: string): string {
+  if (!base) return path
+  return path === '/' ? base : `${base}${path}`
+}
+
+/** A request header, or null where there is none (static prerendering). */
+export function header(context: Pick<RequestContext, 'request'>, name: string): string | null {
+  try {
+    return context.request.headers.get(name)
+  } catch {
+    return null
+  }
+}
+
+/** The URL of the page this request comes from. A malformed header is no page, and prerendering has no visitor. */
+function refererUrl(context: RequestContext): URL | null {
+  const referer = context.isPrerendered ? null : header(context, 'referer')
+  if (!referer) return null
+  try {
+    return new URL(referer)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Whether `from` is this site. The browser's word first: behind a TLS proxy `context.url` may be the
+ * internal URL. Without that header the host decides, and a proxy needs `security.allowedDomains`.
+ */
+function isSameSite(context: RequestContext, from: URL): boolean {
+  const site = header(context, 'sec-fetch-site')
+  return site ? site === 'same-origin' : from.host === context.url.host
+}
+
+/**
+ * A server island or action has no locale in its URL: it is a part of the page that asked for it.
+ * Any origin counts here: a forged `Referer` changes only the forger's own answer, and the internal
+ * URL behind a proxy matches no public one. The page's path, on this server's origin.
+ * ponytail: without a `Referer` (a `no-referrer` policy) it renders in the default locale, and on a
+ * dynamic page its route name comes from the URL; route patterns in the config would settle that.
+ */
+function pageOfPart(context: RequestContext): URL | null {
+  const from = refererUrl(context)
+  return from && new URL(from.pathname + from.search, context.url)
+}
+
+const isPartOfPage = (pattern: string | undefined): boolean =>
+  pattern?.startsWith('/_server-islands/') === true || pattern?.startsWith('/_actions/') === true
+
+/** The route's pattern, a `[locale]` param replaced by its value so the locale drops out of the name. */
+function pagePattern(context: RequestContext, locales: string[]): string | undefined {
+  const { routePattern: pattern, params } = context
+  if (!pattern) return undefined
+  const first = /^\/\[([^\].]+)\]/.exec(pattern)
+  const value = first ? params?.[first[1]!] : undefined
+  if (!value) return pattern
+  const rest = pattern.slice(first![0].length)
+  if (locales.includes(value)) return `/${value}${rest}`
+  // a disabled locale still matches `[locale]`: it is no part of the page's name
+  return first![1] === 'locale' ? rest || '/' : pattern
+}
+
+/**
+ * Locale a path names: its prefix, or what the strategy reads from it when that is not the default
+ * (a strategy's `getLocaleFromPath` answers the default for a URL without a locale).
+ */
+export function localeOfPath(path: string, { defaultLocale, locales, strategy }: Omit<I18nRouting, 'base'>): string | null {
+  const prefix = localeFromPath(path, locales)
+  if (prefix) return prefix
+  const read = strategy.getLocaleFromPath?.(path, defaultLocale, locales) ?? null
+  return read !== defaultLocale && read !== null && locales.includes(read) ? read : null
+}
+
+export function resolveRequest(context: RequestContext, routing: I18nRouting): I18nRequest {
+  const { strategy, locales, defaultLocale, base } = routing
+  const partOfPage = isPartOfPage(context.routePattern)
+  const url = (partOfPage && pageOfPart(context)) || context.url
+  const path = withoutAppBaseURL(url.pathname, base)
+  const urlLocale = localeOfPath(path, routing)
+  const pattern = partOfPage ? undefined : pagePattern(context, locales)
+  return { url, partOfPage, path, urlLocale, locale: urlLocale ?? defaultLocale, route: strategy.getRouteName!(path, locales, pattern) }
+}
+
+/** Whether the visitor comes from a page of this site in another locale. */
+export function isSwitch(context: RequestContext, request: I18nRequest, routing: I18nRouting): boolean {
+  const from = refererUrl(context)
+  if (!from || !isSameSite(context, from)) return false
+  const locale = localeOfPath(withoutAppBaseURL(from.pathname, routing.base), routing) ?? routing.defaultLocale
+  return locale !== request.locale
+}
+
+/** A document may be asked for by this request: an island, an action or a form post is no landing. */
+export function asksForPage(context: RequestContext, request: I18nRequest): boolean {
+  const method = context.request.method ?? 'GET'
+  return !request.partOfPage && !context.isPrerendered && (method === 'GET' || method === 'HEAD')
+}
+
+/**
+ * The visitor did see this response as a page: no endpoint, image, 404 or redirect, and not a
+ * prefetch of a link they may never follow.
+ * ponytail: a `fetch` of an HTML fragment from a page of another locale still counts; `<ClientRouter>`
+ * navigates by `fetch` too, and the two look the same from here.
+ */
+export function isPageView(context: RequestContext, response: Response): boolean {
+  if (!response.ok || !response.headers.get('content-type')?.startsWith('text/html')) return false
+  return !`${header(context, 'sec-purpose')} ${header(context, 'purpose')}`.includes('prefetch')
+}
+
+/** A scheme this router has no business with: `sms:`, `ftp:`, `javascript:`. `externalLinkHref` handles the common ones. */
+const SCHEME = /^[a-z][a-z\d+.-]*:/i
+
+export interface HrefContext extends Pick<I18nRouting, 'base' | 'defaultLocale' | 'strategy'> {
+  codes: string[]
+  /** What a relative `href` resolves against: the page's path. */
+  from?: string
+}
+
+/**
+ * `href` as a link to `locale`. What leaves the app, and a bare `#hash` or `?query`, stays as
+ * written; a route is localized and keeps its query, hash and trailing slash.
+ */
+export function localizeHref(href: string, locale: string, context: HrefContext): string {
+  if (href === '' || href[0] === '#' || href[0] === '?') return href
+  const external = externalLinkHref(href) ?? (SCHEME.test(href) ? href : undefined)
+  if (external) return external
+  const { strategy, codes, defaultLocale, base, from = '/' } = context
+  const cut = pathEnd(href)
+  const raw = cut === -1 ? href : href.slice(0, cut)
+  const path = withoutDots(raw[0] === '/' ? withoutAppBaseURL(raw, base) : `${trimTrailingSlashes(from)}/${raw}`)
+  const localized = strategy.localizePath!(path, locale, codes, defaultLocale)
+  const slash = raw.length > 1 && raw.endsWith('/') && !localized.endsWith('/') ? '/' : ''
+  return `${withBase(localized + slash, base)}${cut === -1 ? '' : href.slice(cut)}`
+}

package/src/router/adapter.ts

@@ -1,166 +1,64 @@
+import { pathSegments, urlPath } from '@i18n-micro/core'
 import type { Locale } from '@i18n-micro/types'
+import { trimLeadingSlashes } from '@i18n-micro/utils/app-path'
+import { localeFromPath } from '@i18n-micro/utils/resolve-locale'
 import type { I18nRoutingStrategy } from './types'
 
-/**
- * Factory for Astro router adapter
- * Implements routing utilities for Astro file-based routing
- * Uses standard Astro APIs: Astro.url, context.url
- */
-export function createAstroRouterAdapter(locales: Locale[], defaultLocale: string, getCurrentUrl?: () => URL): I18nRoutingStrategy {
-  const localeCodes = locales.map((loc) => loc.code)
-
-  /**
-   * Get route name from Astro path
-   * Extracts route name from path (e.g., /en/about -> about)
-   */
-  const getRouteName = (path: string, locales: string[] = []): string => {
-    const cleanPath = path.replace(/^\//, '').replace(/\/$/, '')
-
-    if (!cleanPath) {
-      return 'index'
-    }
-
-    const segments = cleanPath.split('/').filter(Boolean)
-
-    // Remove locale from path if present
-    const firstSegment = segments[0]
-    if (firstSegment && locales.includes(firstSegment)) {
-      segments.shift()
-    }
-
-    if (segments.length === 0) {
-      return 'index'
-    }
-
-    return segments.join('-')
-  }
-
-  /**
-   * Get locale from path
-   * Checks if first segment is a locale code
-   */
-  const getLocaleFromPath = (path: string, defaultLocale: string = 'en', locales: string[] = []): string => {
-    const segments = path.split('/').filter(Boolean)
-    const firstSegment = segments[0]
-    if (firstSegment && locales.includes(firstSegment)) {
-      return firstSegment
-    }
-
-    return defaultLocale
-  }
-
-  /**
-   * Switch locale in path
-   * Replaces or adds locale prefix to path
-   */
-  const switchLocalePath = (path: string, newLocale: string, locales: string[] = [], defaultLocale?: string): string => {
-    const segments = path.split('/').filter(Boolean)
+/** A dynamic segment by its name: `[slug]` and `[...slug]` are `slug`, as a page dictionary's folder names them. */
+const PARAM = /\[(?:\.\.\.)?([^\]]+)\]/g
 
-    // Remove existing locale if present
-    const firstSegment = segments[0]
-    if (firstSegment && locales.includes(firstSegment)) {
-      segments.shift()
-    }
-
-    // Add new locale if not default or if default should be included
-    if (newLocale !== defaultLocale || defaultLocale === undefined) {
-      segments.unshift(newLocale)
-    }
-
-    return `/${segments.join('/')}`
-  }
-
-  /**
-   * Localize path with locale prefix
-   */
-  const localizePath = (path: string, locale: string, locales: string[] = [], defaultLocale?: string): string => {
-    const cleanPath = path.replace(/^\//, '').replace(/\/$/, '') || ''
-    const segments = cleanPath.split('/').filter(Boolean)
+function segmentsOf(path: string, locales: readonly string[]): string[] {
+  const segments = pathSegments(urlPath(path))
+  if (segments[0] !== undefined && locales.includes(segments[0])) segments.shift()
+  return segments
+}
 
-    // Remove existing locale if present
-    const firstSegment = segments[0]
-    if (firstSegment && locales.includes(firstSegment)) {
-      segments.shift()
-    }
+/** The query and the hash of `path`, as they are. */
+const extrasOf = (path: string): string => path.slice(urlPath(path).length)
 
-    // Add locale if not default or if defaultLocale should be included
-    if (locale !== defaultLocale || defaultLocale === undefined) {
-      segments.unshift(locale)
-    }
+/** `/en/blog/post` → `blog-post`, `/blog/[slug]` → `blog-slug`, `/` → `index`. */
+export function routeNameFromPath(path: string, locales: readonly string[] = []): string {
+  const segments = segmentsOf(path, locales)
+  if (segments.length === 0) return 'index'
+  const name = segments.join('-')
+  return name.includes('[') ? name.replace(PARAM, '$1') : name
+}
 
-    return `/${segments.join('/')}`
-  }
+const removeLocale = (path: string, locales: readonly string[] = []): string => `/${segmentsOf(path, locales).join('/')}${extrasOf(path)}`
 
-  /**
-   * Remove locale from path
-   */
-  const removeLocaleFromPath = (path: string, locales: string[] = []): string => {
-    const segments = path.split('/').filter(Boolean)
-    const firstSegment = segments[0]
-    if (firstSegment && locales.includes(firstSegment)) {
-      segments.shift()
-    }
-    return `/${segments.join('/')}`
-  }
+/** `path` in `locale`: no prefix for the default locale, or for every locale when no default is given and `locale` is empty. */
+function addLocale(path: string, locale: string, locales: readonly string[] = [], defaultLocale?: string): string {
+  const segments = segmentsOf(path, locales)
+  if (locale !== defaultLocale) segments.unshift(locale)
+  return `/${segments.join('/')}${extrasOf(path)}`
+}
 
-  /**
-   * Resolve path for specific locale
-   */
-  const resolvePath = (to: string | { path?: string }, locale: string): string | { path?: string } => {
-    const path = typeof to === 'string' ? to : to.path || '/'
-    return localizePath(path, locale, localeCodes, defaultLocale)
-  }
+/**
+ * Prefix-except-default routing over plain paths. Paths here never carry Astro's `base`: the
+ * middleware strips it from what comes in and adds it to what goes out.
+ */
+export function createAstroRouterAdapter(locales: Locale[], defaultLocale: string, getCurrentUrl?: () => URL): I18nRoutingStrategy {
+  const localeCodes = locales.map((locale) => locale.code)
+  const currentUrl = () => getCurrentUrl?.() ?? (typeof window !== 'undefined' ? new URL(window.location.href) : null)
 
   return {
-    getCurrentPath: () => {
-      // Use provided URL getter (from Astro.url or context.url)
-      if (getCurrentUrl) {
-        return getCurrentUrl().pathname
-      }
-      // Fallback for client-side islands
-      if (typeof window !== 'undefined') {
-        return window.location.pathname
-      }
-      return '/'
-    },
-    getRouteName,
-    getLocaleFromPath,
-    switchLocalePath,
-    localizePath,
-    removeLocaleFromPath,
-    resolvePath,
+    getCurrentPath: () => currentUrl()?.pathname ?? '/',
+    // the pattern names one route for every URL it matches: `/blog/hello` is `blog-slug`
+    getRouteName: (path, codes = [], pattern) => routeNameFromPath(pattern ?? path, codes),
+    getLocaleFromPath: (path, fallback = 'en', codes = []) => localeFromPath(`/${trimLeadingSlashes(path)}`, codes) ?? fallback,
+    switchLocalePath: addLocale,
+    localizePath: addLocale,
+    removeLocaleFromPath: removeLocale,
+    resolvePath: (to, locale) => addLocale(typeof to === 'string' ? to : to.path || '/', locale, localeCodes, defaultLocale),
     getRoute: () => {
-      // Use provided URL getter (from Astro.url or context.url)
-      if (getCurrentUrl) {
-        const url = getCurrentUrl()
-        return {
-          fullPath: url.pathname + url.search,
-          query: Object.fromEntries(url.searchParams),
-        }
-      }
-      // Fallback for client-side islands
-      if (typeof window !== 'undefined') {
-        const url = new URL(window.location.href)
-        return {
-          fullPath: url.pathname + url.search,
-          query: Object.fromEntries(url.searchParams),
-        }
-      }
-      return {
-        fullPath: '/',
-        query: {},
-      }
+      const url = currentUrl()
+      return url ? { fullPath: url.pathname + url.search, query: Object.fromEntries(url.searchParams) } : { fullPath: '/', query: {} }
     },
-    // Optional: client-side navigation for islands
-    push: (target: { path: string }) => {
-      if (typeof window !== 'undefined') {
-        window.location.href = target.path
-      }
+    push: (target) => {
+      if (typeof window !== 'undefined') window.location.href = target.path
     },
-    replace: (target: { path: string }) => {
-      if (typeof window !== 'undefined') {
-        window.location.replace(target.path)
-      }
+    replace: (target) => {
+      if (typeof window !== 'undefined') window.location.replace(target.path)
     },
   }
 }

package/src/router/types.ts

@@ -18,9 +18,10 @@ export interface I18nRoutingStrategy {
 
   /**
    * Get route name from path (e.g., /en/about -> about)
-   * Used in middleware to set route name
+   * Used in middleware to set route name. `routePattern` is the page's pattern (`/blog/[slug]`), with
+   * a `[locale]` param already replaced by its value: use it to give every URL of a page one name.
    */
-  getRouteName?: (path: string, locales: string[]) => string
+  getRouteName?: (path: string, locales: string[], routePattern?: string) => string
 
   /**
    * Get locale from path