@edgekits/astro-i18n 0.1.7 → 0.2.0

package/src/cli/wrangler.ts

@@ -1,96 +0,0 @@
-import fs from 'node:fs'
-import { createRequire } from 'node:module'
-import path from 'node:path'
-
-import { parse as parseJsonc, printParseErrorCode, type ParseError } from 'jsonc-parser'
-
-// ---------------------------------------------------------------------------
-// Wrangler config reader
-// Parses wrangler.jsonc to extract KV namespace IDs and vars by key.
-// Single source of truth — no hardcoded IDs or zone IDs in package.json.
-// ---------------------------------------------------------------------------
-
-export const KV_BINDING = 'TRANSLATIONS'
-
-function readWranglerConfig(root: string): Record<string, unknown> {
-  const wranglerConfigPath = path.join(root, 'wrangler.jsonc')
-
-  if (!fs.existsSync(wranglerConfigPath)) {
-    console.error(`[i18n] wrangler.jsonc not found at ${wranglerConfigPath}`)
-    process.exit(1)
-  }
-
-  const raw = fs.readFileSync(wranglerConfigPath, 'utf8')
-
-  const errors: ParseError[] = []
-  const config = parseJsonc(raw, errors, { allowTrailingComma: true })
-
-  if (!config || typeof config !== 'object') {
-    console.error('[i18n] Failed to parse wrangler.jsonc — result is empty.')
-    for (const err of errors) {
-      const snippet = raw.slice(Math.max(0, err.offset - 10), err.offset + 20)
-      console.error(`  ${printParseErrorCode(err.error)} at offset ${err.offset}: ...${JSON.stringify(snippet)}...`)
-    }
-    process.exit(1)
-  }
-
-  return config
-}
-
-export function getKvNamespaceId(root: string, binding: string): string {
-  const config = readWranglerConfig(root)
-  const kvNamespaces = config.kv_namespaces as
-    | Array<{
-        binding: string
-        id: string
-      }>
-    | undefined
-
-  const entry = kvNamespaces?.find((kv) => kv.binding === binding)
-
-  if (!entry) {
-    console.error(`[i18n] KV binding "${binding}" not found in wrangler.jsonc`)
-    process.exit(1)
-  }
-
-  return entry.id
-}
-
-export function getWranglerVar(root: string, key: string): string | undefined {
-  const config = readWranglerConfig(root)
-  const vars = config.vars as Record<string, string> | undefined
-  return vars?.[key]
-}
-
-// ---------------------------------------------------------------------------
-// Wrangler binary
-// The CLI runs wrangler's JavaScript entry with the current Node binary, never through
-// a shell (no `.cmd` shim on Windows, nothing for a shell to interpret).
-// ---------------------------------------------------------------------------
-
-/**
- * The absolute path of the project's wrangler entry (`bin.wrangler` in its package.json),
- * resolved from `root` as the project itself would resolve it. `wrangler/package.json` is
- * an exported subpath; `bin/` is not, hence the detour through the manifest. Throws when
- * the project has no wrangler or its manifest declares no `bin.wrangler`.
- */
-export function resolveWranglerBin(root: string): string {
-  const requireFromRoot = createRequire(path.join(root, 'package.json'))
-
-  let manifestPath: string
-  try {
-    manifestPath = requireFromRoot.resolve('wrangler/package.json')
-  } catch {
-    throw new Error(
-      `wrangler is not installed in ${root}. The CLI runs the project's own wrangler: install it there (npm i -D wrangler).`,
-    )
-  }
-
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')) as { bin?: string | Record<string, string> }
-  const bin = typeof manifest.bin === 'string' ? manifest.bin : manifest.bin?.wrangler
-  if (!bin) {
-    throw new Error(`wrangler at ${path.dirname(manifestPath)} declares no bin.wrangler in its package.json.`)
-  }
-
-  return path.join(path.dirname(manifestPath), bin)
-}

package/src/deep-merge.ts

@@ -1,38 +0,0 @@
-function isObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-// Keys that would reach an object's prototype instead of its own properties. JSON.parse
-// creates `__proto__` as an own key, so a KV value could carry one.
-const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype'])
-
-/**
- * Deep-merge two dictionaries.
- * - `base` provides known structure (fallback)
- * - `overrides` can provide partial values
- * - Both types are preserved and merged correctly
- * - `__proto__`, `constructor` and `prototype` keys in `overrides` are skipped
- */
-export function deepMerge<A extends object, B extends Partial<A>>(base: A, overrides: B): A {
-  const result: any = { ...base }
-
-  for (const key of Object.keys(overrides) as (keyof A)[]) {
-    if (UNSAFE_KEYS.has(key as string)) continue
-
-    const overrideValue = overrides[key]
-    const baseValue = base[key]
-
-    if (overrideValue === undefined) continue
-
-    // For primitives or different types — override directly
-    if (!isObject(baseValue) || !isObject(overrideValue)) {
-      result[key] = overrideValue
-      continue
-    }
-
-    // Both are objects — recurse
-    result[key] = deepMerge(baseValue as any, overrideValue as any)
-  }
-
-  return result
-}

package/src/key-format.ts

@@ -1,17 +0,0 @@
-/**
- * The translation KV key and edge-cache URL formats, as pure functions of the key
- * prefix. Shared by the runtime (`translations-keys.ts`, prefix from the virtual config)
- * and the CLI (prefix from the loaded config), so the key a value is stored under and
- * the URL a purge targets can never drift apart. Pinned by `test/i18n-keys.test.ts`.
- */
-
-// Format: <keyPrefix>:<namespace>:<locale>
-export function formatTranslationKvKey(keyPrefix: string, locale: string, ns: string): string {
-  return `${keyPrefix}:${ns}:${locale}`
-}
-
-// Format: https://<keyPrefix>/<encodeURIComponent(i18n:<locale>:<namespace>)>
-export function formatTranslationCacheUrl(keyPrefix: string, locale: string, ns: string): string {
-  const cacheId = `i18n:${locale}:${ns}`
-  return `https://${keyPrefix}/${encodeURIComponent(cacheId)}`
-}

package/src/locale-fallback.ts

@@ -1,58 +0,0 @@
-/**
- * The middleware's fallback cascade for a request whose URL carries no valid locale,
- * as a pure function: the request-bound inputs arrive as getters, so each one is read
- * exactly when, and only if, the cascade reaches it (same split as `env` in the fetcher).
- *
- * Order (unchanged from the middleware):
- *   1. the lang cookie, if valid;
- *   2. the Accept-Language header (the middleware passes the request header): each tag in
- *      `q` order, full tag, then its language part ('es-mx' -> 'es'); the first tag that
- *      names a supported locale wins (accept-language.ts);
- *   3. ONLY when no tag matched (or there is no header): the Cloudflare geo-IP country,
- *      through the project's `countryToLocale` table (skipped without one);
- *   4. the default locale.
- */
-
-import { matchAcceptLanguage } from './accept-language'
-
-export type FallbackInputs<L extends string> = {
-  cookieLocale: () => L | null
-  acceptLanguage: () => string | null
-  country: () => unknown
-}
-
-export type FallbackOptions<L extends string> = {
-  // Returns the locale when the value is a supported one, otherwise null.
-  parseLocale: (value: unknown) => L | null
-  defaultLocale: L
-  countryToLocale?: Readonly<Record<string, string>>
-}
-
-export function resolveFallbackLocale<L extends string>(inputs: FallbackInputs<L>, options: FallbackOptions<L>): L {
-  const cookieLocale = inputs.cookieLocale()
-  if (cookieLocale) return cookieLocale
-
-  const browser = matchAcceptLanguage(inputs.acceptLanguage(), options.parseLocale)
-  if (browser) return browser
-
-  if (options.countryToLocale) {
-    // 3) Cloudflare Geo-IP Strategy
-    // cf is undefined in local dev unless simulated
-    const geo = options.parseLocale(mapCountryToLocale(inputs.country(), options.countryToLocale))
-    if (geo) return geo
-  }
-
-  return options.defaultLocale
-}
-
-/**
- * Maps a Cloudflare country code (`request.cf.country`) to a locale through the
- * project's table. Returns undefined if the country is not in it.
- */
-export function mapCountryToLocale(country: unknown, table: Readonly<Record<string, string>>): string | undefined {
-  // Safety: In dev mode (localhost), 'country' might be null or undefined.
-  if (typeof country !== 'string') return undefined
-
-  // Cloudflare always sends uppercase (e.g., 'US', 'DE'), but safety first.
-  return table[country.toUpperCase()]
-}

package/src/markdown-path.ts

@@ -1,31 +0,0 @@
-/**
- * The middleware's `.md` normalisation, as a pure function. Markdown endpoints
- * (`/de/blog/x.md/`, `/blog/x.md`) are served in one locale, the project's
- * `markdownLocale`; this returns the single redirect target for such a path, or null
- * when there is nothing to redirect:
- *   - not a `.md` path, or the project has no `markdownLocale`: null (the middleware
- *     lets the request through untouched);
- *   - a leading segment that is a locale is replaced, any other leading segment is kept
- *     (`/foo.md` -> `/<markdownLocale>/foo.md`, never the homepage);
- *   - a trailing slash is dropped, in the same redirect;
- *   - a path already in canonical form: null.
- */
-
-export const MARKDOWN_PATH = /\.md\/?$/
-
-export type MarkdownOptions = {
-  // True when the segment is a supported locale.
-  isLocale: (segment: string) => boolean
-  markdownLocale?: string
-}
-
-export function markdownRedirectTarget(pathname: string, options: MarkdownOptions): string | null {
-  if (!options.markdownLocale || !MARKDOWN_PATH.test(pathname)) return null
-
-  const segments = pathname.split('/').filter(Boolean)
-  const first = segments[0]
-  const contentSegments = first !== undefined && options.isLocale(first) ? segments.slice(1) : segments
-  const target = `/${options.markdownLocale}/${contentSegments.join('/')}`
-
-  return target === pathname ? null : target
-}

package/src/parse-boolean.ts

@@ -1,20 +0,0 @@
-// Engine-owned copy of src/utils/shared/parse-boolean.ts: the package ships its own.
-// The project copy stays for its other consumers (seo/utils.ts, htmlCacheMiddleware.ts).
-
-/**
- * Parse a boolean flag from Wrangler-env string.
- *
- * Accepts:
- *   "1", "true", "on"   → true
- *   "0", "false", "off" → false
- *   undefined           → defaultValue
- */
-export function parseBooleanFlag(value: string | undefined, defaultValue: boolean): boolean {
-  if (value === undefined) return defaultValue
-
-  const v = value.toLowerCase()
-  if (v === '1' || v === 'true' || v === 'on') return true
-  if (v === '0' || v === 'false' || v === 'off') return false
-
-  return defaultValue
-}