@lovrozagar/honey 0.6.5 → 0.7.0

package/src/honey-response.ts

@@ -33,21 +33,25 @@ export class HoneyOutHeaders {
 
 	get(name: string): string | null {
 		if (this.#native) return this.#native.get(name)
-		const raw = this.#map[name.toLowerCase()]
+		const key = name.toLowerCase()
+		/* own keys only: `get("constructor")` must not return Object */
+		if (!Object.hasOwn(this.#map, key)) return null
+		const raw = this.#map[key]
 		if (raw === undefined) return null
 		return Array.isArray(raw) ? raw.join(", ") : raw
 	}
 
 	getSetCookie(): string[] {
 		if (this.#native) return this.#native.getSetCookie()
-		const raw = this.#map["set-cookie"]
+		const raw = Object.hasOwn(this.#map, "set-cookie") ? this.#map["set-cookie"] : undefined
 		if (raw === undefined) return []
 		return Array.isArray(raw) ? raw : [raw]
 	}
 
 	has(name: string): boolean {
 		if (this.#native) return this.#native.has(name)
-		return this.#map[name.toLowerCase()] !== undefined
+		const key = name.toLowerCase()
+		return Object.hasOwn(this.#map, key) && this.#map[key] !== undefined
 	}
 
 	set(name: string, value: string): void {
@@ -182,8 +186,16 @@ export class HoneyResponse {
 		return this.#raw
 	}
 
-	async arrayBuffer(): Promise<ArrayBuffer> {
+	/** A body is read once, as with Fetch: a second read throws instead of returning nothing. */
+	#consume(): void {
+		if (this.#bodyUsed || (this.#stream?.locked ?? false)) {
+			throw new TypeError("Body has already been used")
+		}
 		this.#bodyUsed = true
+	}
+
+	async arrayBuffer(): Promise<ArrayBuffer> {
+		this.#consume()
 		if (this.#raw === null) {
 			if (this.#stream) return streamToArrayBuffer(this.#stream)
 			return new ArrayBuffer(0)
@@ -206,17 +218,27 @@ export class HoneyResponse {
 	}
 
 	clone(): Response {
+		if (this.#bodyUsed) throw new TypeError("Body has already been used")
+		let stream = this.#stream
+		if (stream !== undefined && stream !== null) {
+			/* tee, keep one branch: the original stays readable */
+			const [mine, theirs] = stream.tee()
+			this.#stream = mine
+			stream = theirs
+		}
 		return new HoneyResponse({
 			headers: { ...this.plainHeaders },
 			raw: this.#raw,
 			status: this.status,
 			statusText: this.statusText,
-			stream: this.#stream === undefined || this.#stream === null ? this.#stream : this.#stream.tee()[1],
+			stream,
 		}) as unknown as Response
 	}
 
 	async formData(): Promise<FormData> {
-		return new Response(this.body, {
+		const body = this.body
+		this.#consume()
+		return new Response(body, {
 			headers: this.plainHeaders as HeadersInit,
 			status: this.status,
 		}).formData()
@@ -228,7 +250,7 @@ export class HoneyResponse {
 	}
 
 	async text(): Promise<string> {
-		this.#bodyUsed = true
+		this.#consume()
 		if (this.#raw === null) {
 			if (this.#stream) return new TextDecoder().decode(await streamToArrayBuffer(this.#stream))
 			return ""
@@ -271,6 +293,8 @@ export function replaceResponse(
 		status?: number
 	},
 ): Response {
+	/* an upgrade response belongs to the runtime: rebuilding it throws (RangeError) or breaks the socket */
+	if (response.status === 101) return response
 	if (isHoneyResponse(response)) {
 		if (init.body === undefined) {
 			return response.derive({ headers: init.headers, status: init.status }) as unknown as Response
@@ -300,9 +324,12 @@ export function replaceResponse(
 			}) as unknown as Response
 		}
 	}
+	const status = init.status ?? response.status
 	return new Response(init.body !== undefined ? init.body : response.body, {
-		headers: init.headers === undefined ? undefined : headersToInit(init.headers),
-		status: init.status ?? response.status,
+		/* left out, the headers carry over: a status change must not drop them */
+		headers: headersToInit(init.headers ?? response.headers),
+		status,
+		statusText: status === response.status ? response.statusText : undefined,
 	})
 }
 

package/src/i18n-slot.ts

@@ -1,5 +1,15 @@
+import type { HoneyError } from "./error.ts"
+
+/** The translations `errorI18n()` holds, keyed by locale. */
+export type ErrorTranslations = {
+	errors?: Record<string, Record<string, string>>
+	fieldNames?: Record<string, Record<string, string>>
+}
+
 export type I18nRuntime = {
 	interpolate: (template: string, vars: Record<string, unknown>, locale?: string) => string
+	/** `error` in `locale`, or `error` itself when nothing translates */
+	translateError: (error: HoneyError, translations: ErrorTranslations, locale: string) => HoneyError
 }
 
 const MISSING = 'Honey.errorI18n() requires `import "@lovrozagar/honey/i18n"` in the app entry.'

package/src/i18n.ts

@@ -1,4 +1,7 @@
-import { registerI18nRuntime } from "./i18n-slot.ts"
+import { dict } from "./dict.ts"
+import { HoneyError } from "./error.ts"
+import { registerI18nRuntime, type ErrorTranslations } from "./i18n-slot.ts"
+import type { FieldError } from "./types.ts"
 
 /**
  * Extracts {varName} patterns from ICU MessageFormat string literals at the type level.
@@ -28,7 +31,7 @@ export class TranslationRegistry {
 			return this.cache.get(locale)
 		}
 
-		const source = this.sources[locale]
+		const source = Object.hasOwn(this.sources, locale) ? this.sources[locale] : undefined
 		if (source === undefined) {
 			return undefined
 		}
@@ -41,11 +44,34 @@ export class TranslationRegistry {
 
 /* ---- ICU MessageFormat parser ---- */
 
-type PluralCategory = "few" | "many" | "one" | "other" | "two" | "zero"
+const pluralRulesCache = new Map<string, Intl.PluralRules>()
 
-function getPluralCategory(n: number): PluralCategory {
-	if (n === 1) return "one"
-	return "other"
+/** CLDR plural category for `n` in `locale` ("one", "few", "many", ...); English rules when the locale is unknown. */
+function getPluralCategory(n: number, locale?: string): Intl.LDMLPluralRule {
+	const cacheKey = locale ?? "en"
+	let rules = pluralRulesCache.get(cacheKey)
+	if (rules === undefined) {
+		try {
+			rules = new Intl.PluralRules(cacheKey)
+		} catch {
+			rules = new Intl.PluralRules("en")
+		}
+		if (pluralRulesCache.size < 256) pluralRulesCache.set(cacheKey, rules)
+	}
+	return rules.select(n)
+}
+
+/** Own-property lookup: message branches and variables are keyed by data, so `constructor` must not hit the prototype. */
+function own<T>(record: Record<string, T>, key: string): T | undefined {
+	return Object.hasOwn(record, key) ? record[key] : undefined
+}
+
+function formatNumber(n: number, locale?: string): string {
+	try {
+		return new Intl.NumberFormat(locale).format(n)
+	} catch {
+		return String(n)
+	}
 }
 
 type ParsedBlock = { branches: Record<string, string>; type: "plural" | "select"; varName: string }
@@ -66,7 +92,7 @@ function findMatchingBrace(str: string, start: number): number {
 }
 
 function parseBranches(content: string): Record<string, string> {
-	const branches: Record<string, string> = {}
+	const branches: Record<string, string> = Object.create(null) as Record<string, string>
 	let i = 0
 	while (i < content.length) {
 		while (i < content.length && /\s/.test(content[i] ?? "")) i++
@@ -152,35 +178,33 @@ function resolveToken(token: ParsedToken, values: Record<string, unknown>, local
 	if (typeof token === "string") return token
 
 	if (token.type === "simple") {
-		const val = values[token.varName]
+		const val = own(values, token.varName)
 		return val !== undefined && val !== null ? String(val) : `{${token.varName}}`
 	}
 
 	if (token.type === "number") {
-		const val = values[token.varName]
+		const val = own(values, token.varName)
 		if (val === undefined || val === null) return `{${token.varName}}`
-		try {
-			return new Intl.NumberFormat(locale).format(Number(val))
-		} catch {
-			return String(val)
-		}
+		return formatNumber(Number(val), locale)
 	}
 
 	/* plural or select */
-	const val = values[token.varName]
+	const val = own(values, token.varName)
 
 	if (token.type === "plural") {
 		const num = Number(val ?? 0)
 		const exactKey = `=${num}`
-		const category = getPluralCategory(num)
-		const template = token.branches[exactKey] ?? token.branches[category] ?? token.branches["other"] ?? ""
-		const resolved = template.replace(/#/g, String(num))
+		const category = getPluralCategory(num, locale)
+		const template =
+			own(token.branches, exactKey) ?? own(token.branches, category) ?? own(token.branches, "other") ?? ""
+		/* ICU formats `#` for the locale; without one, keep the plain digits (host locale would make output vary). */
+		const resolved = template.replace(/#/g, locale === undefined ? String(num) : formatNumber(num, locale))
 		return interpolate(resolved, values, locale)
 	}
 
 	/* select */
 	const strVal = val !== undefined && val !== null ? String(val) : ""
-	const template = token.branches[strVal] ?? token.branches["other"] ?? ""
+	const template = own(token.branches, strVal) ?? own(token.branches, "other") ?? ""
 	return interpolate(template, values, locale)
 }
 
@@ -202,7 +226,7 @@ export async function resolveTranslation(
 ): Promise<string> {
 	const map = await registry.get(locale)
 	if (map === undefined) return key
-	const template = map[key]
+	const template = own(map, key)
 	if (template === undefined) return key
 	return interpolate(template, vars, locale)
 }
@@ -214,12 +238,63 @@ export async function resolveFieldName(
 ): Promise<string> {
 	const map = await registry.get(locale)
 	if (map === undefined) return fieldPath
-	const name = map[fieldPath]
-	return name ?? fieldPath
+	return own(map, fieldPath) ?? fieldPath
+}
+
+/* the locale can come from request data: own keys only */
+function ownValue<T>(obj: Record<string, T> | undefined, key: string): T | undefined {
+	return obj !== undefined && Object.hasOwn(obj, key) ? obj[key] : undefined
+}
+
+/** A copy of `error` with a translated message and field paths; same key, status, data and cause. */
+function translatedError(
+	error: HoneyError,
+	message: string | undefined,
+	fields: Record<string, FieldError[]> | undefined,
+): HoneyError {
+	const copy = new HoneyError({
+		cause: error.cause,
+		data: error.data,
+		errorKey: error.errorKey,
+		fields: fields ?? error.fields,
+		headers: error.headers,
+		status: error.statusKey,
+		vars: error.vars,
+	})
+	copy.message = message ?? error.message
+	if (error.stack !== undefined) copy.stack = error.stack
+	return copy
+}
+
+export function translateError(error: HoneyError, translations: ErrorTranslations, locale: string): HoneyError {
+	const messages = ownValue(translations.errors, locale)
+	const template = messages ? ownValue(messages, error.errorKey) : undefined
+	const message = template ? interpolate(template, error.vars ?? {}, locale) : undefined
+
+	const fieldTranslations = ownValue(translations.fieldNames, locale)
+	let fields: Record<string, FieldError[]> | undefined
+	if (fieldTranslations && Object.keys(error.fields).length > 0) {
+		fields = dict<FieldError[]>()
+		for (const name of Object.keys(error.fields)) {
+			fields[name] = error.fields[name].map((fe) => {
+				let candidate = fe.path
+				while (candidate) {
+					const translated = ownValue(fieldTranslations, candidate)
+					if (translated) return { ...fe, path: translated }
+					const dotIdx = candidate.indexOf(".")
+					if (dotIdx === -1) break
+					candidate = candidate.slice(dotIdx + 1)
+				}
+				return fe
+			})
+		}
+	}
+	if (message === undefined && fields === undefined) return error
+	return translatedError(error, message, fields)
 }
 
 export function enableI18n(): void {
-	registerI18nRuntime({ interpolate })
+	registerI18nRuntime({ interpolate, translateError })
 }
 
 enableI18n()