@edgekits/astro-i18n 0.2.0 → 0.2.2

package/CHANGELOG.md

@@ -4,6 +4,21 @@ All notable changes to this package are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the package uses
 [Semantic Versioning](https://semver.org/).
 
+## 0.2.2 — 2026-10-27
+
+### Fixed
+
+- `'prefix-except-default'` keeps the query string through its rewrites and redirects: `/?sent=1` renders the success state, and a form posted to `/?_action=…` runs its action.
+- In `'prefix'` mode the redirects keep the query string too (`/?utm=x` -> `/en/?utm=x`).
+- `'prefix-except-default'` serves the default locale's `[lang]` endpoints at the root whatever their extension (`/rss.xml` from `src/pages/[lang]/rss.xml.ts`; `/en/rss.xml` redirects to it); root routes such as `sitemap.xml` are served as they are.
+- The skill's no-JS form recipe (`redirectAfterNativePost`) answers its 303 at `ctx.originPathname`, the path the form was posted from; with `ctx.url.pathname` a root-mode post landed on `/<defaultLocale>/?sent=1` and one more redirect. A project that copied the recipe makes the same change in `src/ui/forms/native-post.ts`.
+
+## 0.2.1 — 2026-10-27
+
+### Changed
+
+- The Claude Code plugin is `edgekits-i18n` (was `astro-i18n`): install `edgekits-i18n@edgekits`. An existing `astro-i18n@edgekits` install is not updated: remove it and install the new name. No code change.
+
 ## 0.2.0 — 2026-10-27
 
 ### Changed

package/README.md

@@ -323,13 +323,18 @@ In `'prefix-except-default'` the default locale has no prefix here either: with
 - `'prefix-except-default'` (the default when `routing` is left out): the default locale at the
   root (`/`, `/about/`), every other locale under its prefix (`/de/about/`). The middleware
   serves a root URL by rewriting it internally to `/<defaultLocale>/…`, so the URL stays;
-  `/en/about/` redirects permanently to `/about/`. A root URL consults neither Accept-Language
-  nor the country: only a lang cookie for another locale (the visitor chose it in the switcher)
-  redirects, temporarily, to that locale.
+  `/en/about/` redirects permanently to `/about/`. An endpoint under `src/pages/[lang]/`
+  answers at the root too (`/rss.xml`, and `/en/rss.xml` redirects to it), while a root route
+  of its own (`sitemap.xml`, `robots.txt`) is served as is. A root URL consults neither
+  Accept-Language nor the country: only a lang cookie for another locale (the visitor chose it
+  in the switcher) redirects, temporarily, to that locale.
 - `'prefix'`: every URL starts with its locale (`/en/about/`); `/` and a URL without a locale
   redirect to the visitor's locale (cookie, Accept-Language, country, default). Projects that
   set `routing: 'prefix'` keep exactly this by leaving their config alone.
 
+In both modes, rewrites and redirects keep the query string (`/?utm=x` redirects to
+`/en/?utm=x` in `'prefix'`, and renders `/` with `?utm=x` in `'prefix-except-default'`).
+
 In `'prefix-except-default'`, build canonical and hreflang URLs from `Astro.originPathname`
 (the URL the visitor requested; `Astro.url` is the rewritten `/<defaultLocale>/…`) through
 `localizedPath` from `/runtime`. Astro's own `astro:i18n` URL helpers prefix the default locale
@@ -493,7 +498,7 @@ per render.
 `astro-i18n` is a free agent skill that sets up `@edgekits/astro-i18n` in your project and keeps
 working with it afterwards. It runs in Claude Code as a plugin, and in Cursor, OpenCode or any other
 coding agent that reads `SKILL.md`. Its source is in
-[`plugins/astro-i18n`](https://github.com/EdgeKits/i18n/tree/main/plugins/astro-i18n).
+[`plugins/edgekits-i18n`](https://github.com/EdgeKits/i18n/tree/main/plugins/edgekits-i18n).
 
 ### What it does
 
@@ -524,7 +529,7 @@ In Claude Code, add the EdgeKits marketplace once, then install the plugin:
 
 ```
 /plugin marketplace add EdgeKits/skills
-/plugin install astro-i18n@edgekits
+/plugin install edgekits-i18n@edgekits
 ```
 
 That installs it for you, in every project. To set it up for everyone working on one
@@ -532,11 +537,11 @@ repository, run these in the repository and commit `.claude/settings.json`:
 
 ```sh
 claude plugin marketplace add EdgeKits/skills --scope project
-claude plugin install astro-i18n@edgekits --scope project
+claude plugin install edgekits-i18n@edgekits --scope project
 ```
 
 The first command declares the EdgeKits marketplace in `.claude/settings.json`; the second
-turns the plugin on there, under `enabledPlugins` (`"astro-i18n@edgekits": true`). Claude Code
+turns the plugin on there, under `enabledPlugins` (`"edgekits-i18n@edgekits": true`). Claude Code
 honours those entries for a teammate once they trust the folder, but it does not download the
 plugin for them: each teammate runs the same `claude plugin install … --scope project` once.
 
@@ -547,7 +552,7 @@ adds the marketplace: `/plugin marketplace add EdgeKits/skills`, or the CLI line
 `--scope project` above. Declaring it in `.claude/settings.json` under `extraKnownMarketplaces`,
 keyed by the marketplace's name as in the block below, spares them that step once they trust the
 folder. In both cases the plugin itself is still installed once per contributor with
-`claude plugin install astro-i18n@edgekits --scope project`, as the paragraph above says.
+`claude plugin install edgekits-i18n@edgekits --scope project`, as the paragraph above says.
 
 ```json
 {
@@ -557,7 +562,7 @@ folder. In both cases the plugin itself is still installed once per contributor
     }
   },
   "enabledPlugins": {
-    "astro-i18n@edgekits": true
+    "edgekits-i18n@edgekits": true
   }
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edgekits/astro-i18n",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Edge-native i18n for Astro on Cloudflare Workers: translations in Workers KV, a per-namespace edge cache invalidated by the Purge API, and typed keys.",
   "keywords": [
     "astro",
@@ -57,7 +57,7 @@
     "format:check": "prettier --check ."
   },
   "dependencies": {
-    "@edgekits/i18n-core": "0.2.0"
+    "@edgekits/i18n-core": "0.2.2"
   },
   "peerDependencies": {
     "@astrojs/cloudflare": "^14.3.0",

package/src/middleware/i18n.ts

@@ -72,6 +72,8 @@ export type I18nMiddlewareDeps = {
 // dev and production alike: see negotiatedRedirect(). A browser keeps a 301 and never asks
 // the server again, so a language chosen later in the switcher would be bypassed on the
 // next visit to `/`, and the URL-wins cookie sync below would then overwrite that choice.
+//
+// Both kinds, in both routing modes, keep the query string (`?utm=…`, `?sent=1`).
 const REDIRECT_STATUS = import.meta.env?.DEV ? 302 : 301
 
 // A redirect whose target depends on the visitor: temporary, never stored by a shared
@@ -89,11 +91,24 @@ function negotiatedRedirect(target: string, vary = 'Cookie, Accept-Language'): R
   })
 }
 
+const isIgnoredPrefix = (pathname: string) => IGNORED_PREFIXES.some((p) => pathname.startsWith(p))
+
+// The project's localized routes live under `src/pages/[lang]/`. `context.routePattern` is
+// the route Astro matched for the original URL, before any rewrite: a locale-less
+// `/rss.xml` matches `/[lang]` (lang = "rss.xml") or nothing (the 404 route), never a
+// root route of its own, which `/sitemap.xml` does.
+const isLangRoute = (routePattern: string | undefined) =>
+  routePattern === '/[lang]' || !!routePattern?.startsWith('/[lang]/')
+
+// The pattern of the route Astro falls back to when nothing matched (a custom `404.astro`
+// or its built-in one): astro/dist/core/routing/internal/astro-designed-error-pages.js.
+const NOT_FOUND_ROUTE = '/404'
+
 // Determines if the current request path matches static assets or ignored prefixes.
 // Returns true to skip i18n processing for this request.
 function shouldBypassI18n(pathname: string): boolean {
   if (PUBLIC_FILE_REGEX.test(pathname)) return true
-  if (IGNORED_PREFIXES.some((p) => pathname.startsWith(p))) return true
+  if (isIgnoredPrefix(pathname)) return true
   // Markdown endpoints: /en/blog/slug.md/ (with or without trailing slash)
   if (MARKDOWN_PATH.test(pathname)) return true
   return false
@@ -155,7 +170,8 @@ export function createI18nMiddleware(deps: I18nMiddlewareDeps): MiddlewareHandle
     urlLocale: Locale,
     segments: string[],
   ): Promise<Response> {
-    const pathname = new URL(context.request.url).pathname
+    const url = new URL(context.request.url)
+    const pathname = url.pathname
     // Keep the lang cookie in sync with the URL locale — but ONLY update an
     // EXISTING cookie that differs or does not parse. Rationale (HTML edge cache, P1/P2):
     //   - The old unconditional set emitted `Set-Cookie` on EVERY localized
@@ -183,7 +199,7 @@ export function createI18nMiddleware(deps: I18nMiddlewareDeps): MiddlewareHandle
     // Normalize trailing slash and structure
     const normalized = buildLocalizedPath(urlLocale, segments.slice(1))
     if (pathname !== normalized) {
-      return context.redirect(normalized, REDIRECT_STATUS)
+      return context.redirect(normalized + url.search, REDIRECT_STATUS)
     }
 
     return await next()
@@ -196,12 +212,12 @@ export function createI18nMiddleware(deps: I18nMiddlewareDeps): MiddlewareHandle
     segments: string[],
     firstSegment: string | null,
   ): Promise<Response> {
-    const pathname = new URL(context.request.url).pathname
+    const { pathname, search } = new URL(context.request.url)
     const urlLocale = firstSegment ? deps.parseLocale(firstSegment) : null
 
     // The default locale's prefix is not canonical: one permanent hop to the path without it.
     if (urlLocale === deps.defaultLocale) {
-      return context.redirect(localizedPath(deps.defaultLocale, pathname, pathOptions), REDIRECT_STATUS)
+      return context.redirect(localizedPath(deps.defaultLocale, pathname, pathOptions) + search, REDIRECT_STATUS)
     }
 
     if (urlLocale) {
@@ -217,7 +233,7 @@ export function createI18nMiddleware(deps: I18nMiddlewareDeps): MiddlewareHandle
     const cookie = deps.readCookieLang(context.cookies)
     if (cookie.present && cookie.locale !== deps.defaultLocale) {
       if (cookie.locale) {
-        return negotiatedRedirect(localizedPath(cookie.locale, pathname, pathOptions), 'Cookie')
+        return negotiatedRedirect(localizedPath(cookie.locale, pathname, pathOptions) + search, 'Cookie')
       }
       // Present but invalid: corrected to the URL's locale, as serveLocalized does.
       deps.setCookieLang(context.cookies, deps.defaultLocale)
@@ -225,14 +241,16 @@ export function createI18nMiddleware(deps: I18nMiddlewareDeps): MiddlewareHandle
 
     const normalized = localizedPath(deps.defaultLocale, pathname, pathOptions)
     if (pathname !== normalized) {
-      return context.redirect(normalized, REDIRECT_STATUS)
+      return context.redirect(normalized + search, REDIRECT_STATUS)
     }
 
     // The project's pages live under `src/pages/[lang]/`: render `/<default>/…` while the
     // URL stays. `next(path)` rewrites without running the middleware again
     // (astro/dist/core/middleware/astro-middleware.js:33-40) and keeps `locals`;
     // `context.rewrite()` would re-run it (astro/dist/core/rewrites/handler.js:67-71).
-    return await next(`/${deps.defaultLocale}${pathname}`)
+    // The rewritten URL is built from the string alone (core/routing/rewrite.js:22), and
+    // `context.url`, Astro.url and Actions' `?_action=` read it: the query goes in too.
+    return await next(`/${deps.defaultLocale}${pathname}${search}`)
   }
 
   // Main i18n middleware handler. Intercepts incoming requests, manages routing,
@@ -265,14 +283,30 @@ export function createI18nMiddleware(deps: I18nMiddlewareDeps): MiddlewareHandle
       // (the core's markdown-path.ts). Without `markdownLocale` they pass through untouched.
       const target = markdownTarget(pathname)
       if (target) {
-        return context.redirect(target, REDIRECT_STATUS)
+        return context.redirect(target + url.search, REDIRECT_STATUS)
       }
 
-      // 'prefix-except-default': a `.md` path without a locale segment belongs to the
-      // default locale, whose endpoint lives under `[lang]`.
-      const rootMarkdown =
-        deps.routing !== 'prefix' && MARKDOWN_PATH.test(pathname) && (!firstSegment || !isLocale(firstSegment))
-      const response = rootMarkdown ? await next(`/${deps.defaultLocale}${pathname}`) : await next()
+      // 'prefix-except-default': the default locale's `[lang]` routes answer at the root,
+      // whatever the extension. A `.md` path without a locale segment always belongs to one;
+      // any other path outside the ignored prefixes when Astro matched it to a `[lang]`
+      // route or to none, while a root route of its own (`/sitemap.xml`) is served as is.
+      // The `/<default>/…` form of a `[lang]` route moves to the root, as a page's does
+      // (`.md` excepted: markdownTarget() above decides those).
+      let rewrite: string | undefined
+      if (deps.routing !== 'prefix') {
+        const markdown = MARKDOWN_PATH.test(pathname)
+        if (firstSegment === deps.defaultLocale && !markdown && isLangRoute(context.routePattern)) {
+          return context.redirect(pathname.slice(deps.defaultLocale.length + 1) + url.search, REDIRECT_STATUS)
+        }
+        const langRouteOrNone = isLangRoute(context.routePattern) || context.routePattern === NOT_FOUND_ROUTE
+        if (
+          (!firstSegment || !isLocale(firstSegment)) &&
+          (markdown || (langRouteOrNone && !isIgnoredPrefix(pathname)))
+        ) {
+          rewrite = `/${deps.defaultLocale}${pathname}${url.search}`
+        }
+      }
+      const response = rewrite ? await next(rewrite) : await next()
 
       const contentType = response.headers.get('content-type') || ''
       const isHtml = contentType.includes('text/html')
@@ -303,7 +337,7 @@ export function createI18nMiddleware(deps: I18nMiddlewareDeps): MiddlewareHandle
     if (!firstSegment) {
       const target = buildLocalizedPath(fallbackLocale, [])
       if (pathname !== target) {
-        return negotiatedRedirect(target)
+        return negotiatedRedirect(target + url.search)
       }
       return await next()
     }
@@ -319,7 +353,7 @@ export function createI18nMiddleware(deps: I18nMiddlewareDeps): MiddlewareHandle
     const target = buildLocalizedPath(fallbackLocale, segments)
 
     if (pathname !== target) {
-      return negotiatedRedirect(target)
+      return negotiatedRedirect(target + url.search)
     }
 
     return await next()