@lovrozagar/honey 0.7.2 → 1.0.0-rc.1

package/src/honey-response.ts

@@ -1,379 +0,0 @@
-/** NodeRequest sets this so HoneyRes can skip `new Response()` on Node. */
-export const NODE_OUTBOUND = Symbol.for("honey.nodeOut")
-
-const HONEY_RESPONSE = Symbol.for("honey.response")
-
-export function isNodeOutbound(req: Request): boolean {
-	return (req as unknown as Record<symbol, unknown>)[NODE_OUTBOUND] === true
-}
-
-export function isHoneyResponse(value: unknown): value is HoneyResponse {
-	return typeof value === "object" && value !== null && HONEY_RESPONSE in value
-}
-
-/**
- * Headers view over a plain map. `get`/`has` stay on the record.
- * A real `Headers` is built only if something iterates or mutates.
- */
-export class HoneyOutHeaders {
-	#map: Record<string, string | string[]>
-	#native: Headers | null = null
-
-	constructor(map: Record<string, string | string[]>) {
-		this.#map = map
-	}
-
-	append(name: string, value: string): void {
-		this.#ensureNative().append(name, value)
-	}
-
-	delete(name: string): void {
-		this.#ensureNative().delete(name)
-	}
-
-	get(name: string): string | null {
-		if (this.#native) return this.#native.get(name)
-		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 = 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)
-		const key = name.toLowerCase()
-		return Object.hasOwn(this.#map, key) && this.#map[key] !== undefined
-	}
-
-	set(name: string, value: string): void {
-		this.#ensureNative().set(name, value)
-	}
-
-	forEach(callback: (value: string, key: string, parent: Headers) => void, thisArg?: unknown): void {
-		this.#ensureNative().forEach(callback, thisArg)
-	}
-
-	keys(): IterableIterator<string> {
-		return this.#ensureNative().keys()
-	}
-
-	values(): IterableIterator<string> {
-		return this.#ensureNative().values()
-	}
-
-	entries(): IterableIterator<[string, string]> {
-		return this.#ensureNative().entries()
-	}
-
-	[Symbol.iterator](): IterableIterator<[string, string]> {
-		if (this.#native) return this.#native[Symbol.iterator]()
-		return iterateRecord(this.#map)
-	}
-
-	get [Symbol.toStringTag](): string {
-		return "Headers"
-	}
-
-	toRecord(): Record<string, string | string[]> {
-		if (!this.#native) return this.#map
-		const out: Record<string, string | string[]> = {}
-		this.#native.forEach((value, key) => {
-			if (key === "set-cookie") return
-			out[key] = value
-		})
-		const cookies = this.#native.getSetCookie()
-		if (cookies.length > 0) out["set-cookie"] = cookies
-		return out
-	}
-
-	#ensureNative(): Headers {
-		if (this.#native) return this.#native
-		const headers = new Headers()
-		for (const [name, value] of iterateRecord(this.#map)) {
-			headers.append(name, value)
-		}
-		this.#native = headers
-		return headers
-	}
-}
-
-function* iterateRecord(map: Record<string, string | string[]>): IterableIterator<[string, string]> {
-	for (const key in map) {
-		const value = map[key]
-		if (Array.isArray(value)) {
-			for (const item of value) yield [key, item]
-		} else if (value !== undefined) {
-			yield [key, value]
-		}
-	}
-}
-
-/**
- * Response-shaped bag for Node. Avoids `new Response()` until something
- * needs a real Fetch body stream (cors/etag wrap, clone).
- */
-export class HoneyResponse {
-	readonly [HONEY_RESPONSE] = true
-	readonly ok: boolean
-	readonly redirected = false
-	readonly status: number
-	readonly statusText: string
-	readonly type = "default" as ResponseType
-	readonly url = ""
-
-	#headerMap: Record<string, string | string[]>
-	#headers: HoneyOutHeaders | null = null
-	#raw: string | Uint8Array | null
-	#stream: ReadableStream<Uint8Array> | null | undefined
-	#bodyUsed = false
-
-	constructor(init: {
-		headers: Record<string, string | string[]>
-		raw?: string | Uint8Array | null
-		status: number
-		statusText?: string
-		stream?: ReadableStream<Uint8Array> | null
-	}) {
-		this.status = init.status
-		this.statusText = init.statusText ?? ""
-		this.ok = init.status >= 200 && init.status < 300
-		this.#headerMap = init.headers
-		this.#raw = init.raw === undefined ? null : init.raw
-		this.#stream = init.stream
-	}
-
-	get headers(): HoneyOutHeaders {
-		if (!this.#headers) this.#headers = new HoneyOutHeaders(this.#headerMap)
-		return this.#headers
-	}
-
-	get body(): ReadableStream<Uint8Array> | null {
-		if (this.#stream !== undefined) return this.#stream
-		if (this.#raw === null) {
-			this.#stream = null
-			return null
-		}
-		const raw = this.#raw
-		this.#stream = new ReadableStream({
-			start(controller) {
-				controller.enqueue(typeof raw === "string" ? new TextEncoder().encode(raw) : raw)
-				controller.close()
-			},
-		})
-		return this.#stream
-	}
-
-	get bodyUsed(): boolean {
-		return this.#bodyUsed
-	}
-
-	/** Plain header map for `res.writeHead`. */
-	get plainHeaders(): Record<string, string | string[]> {
-		return this.#headers ? this.#headers.toRecord() : this.#headerMap
-	}
-
-	/** Known-size body for `res.end`. */
-	get rawBody(): string | Uint8Array | null {
-		return this.#raw
-	}
-
-	/** 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)
-		}
-		if (typeof this.#raw === "string") {
-			const bytes = new TextEncoder().encode(this.#raw)
-			return bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength) as ArrayBuffer
-		}
-		return this.#raw.buffer.slice(this.#raw.byteOffset, this.#raw.byteOffset + this.#raw.byteLength) as ArrayBuffer
-	}
-
-	async blob(): Promise<Blob> {
-		const buf = await this.arrayBuffer()
-		return new Blob([buf], { type: this.headers.get("content-type") ?? "" })
-	}
-
-	async bytes(): Promise<Uint8Array> {
-		const buf = await this.arrayBuffer()
-		return new Uint8Array(buf)
-	}
-
-	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,
-		}) as unknown as Response
-	}
-
-	async formData(): Promise<FormData> {
-		const body = this.body
-		this.#consume()
-		return new Response(body, {
-			headers: this.plainHeaders as HeadersInit,
-			status: this.status,
-		}).formData()
-	}
-
-	async json(): Promise<unknown> {
-		const text = await this.text()
-		return text.length === 0 ? null : JSON.parse(text)
-	}
-
-	async text(): Promise<string> {
-		this.#consume()
-		if (this.#raw === null) {
-			if (this.#stream) return new TextDecoder().decode(await streamToArrayBuffer(this.#stream))
-			return ""
-		}
-		return typeof this.#raw === "string" ? this.#raw : new TextDecoder().decode(this.#raw)
-	}
-
-	/** Copy this bag with new headers/status/body — keeps the Node `res.end` path. */
-	derive(init: {
-		headers?: Record<string, string | string[]> | Headers | HoneyOutHeaders
-		raw?: string | Uint8Array | null
-		status?: number
-		stream?: ReadableStream<Uint8Array> | null
-	}): HoneyResponse {
-		return new HoneyResponse({
-			headers: init.headers === undefined ? { ...this.plainHeaders } : headersInitToRecord(init.headers),
-			raw: init.raw === undefined ? this.#raw : init.raw,
-			status: init.status ?? this.status,
-			statusText: this.statusText,
-			stream: init.stream === undefined ? this.#stream : init.stream,
-		})
-	}
-}
-
-export function createHoneyResponse(init: {
-	headers: Record<string, string | string[]>
-	raw?: string | Uint8Array | null
-	status: number
-	stream?: ReadableStream<Uint8Array> | null
-}): Response {
-	return new HoneyResponse(init) as unknown as Response
-}
-
-/** Rebuild a response without dropping a HoneyResponse back to `new Response()`. */
-export function replaceResponse(
-	response: Response,
-	init: {
-		body?: BodyInit | null
-		headers?: Headers | HoneyOutHeaders | Record<string, string | string[]>
-		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
-		}
-		if (typeof init.body === "string" || init.body instanceof Uint8Array) {
-			return response.derive({
-				headers: init.headers,
-				raw: init.body,
-				status: init.status,
-				stream: null,
-			}) as unknown as Response
-		}
-		if (init.body instanceof ArrayBuffer) {
-			return response.derive({
-				headers: init.headers,
-				raw: new Uint8Array(init.body),
-				status: init.status,
-				stream: null,
-			}) as unknown as Response
-		}
-		if (init.body === null) {
-			return response.derive({
-				headers: init.headers,
-				raw: null,
-				status: init.status,
-				stream: null,
-			}) as unknown as Response
-		}
-	}
-	const status = init.status ?? response.status
-	return new Response(init.body !== undefined ? init.body : response.body, {
-		/* 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,
-	})
-}
-
-function headersToInit(headers: Headers | HoneyOutHeaders | Record<string, string | string[]>): HeadersInit {
-	if (headers instanceof HoneyOutHeaders) return headers.toRecord() as HeadersInit
-	if (headers instanceof Headers) return headers
-	return headers as HeadersInit
-}
-
-function headersInitToRecord(
-	headers: Record<string, string | string[]> | Headers | HoneyOutHeaders,
-): Record<string, string | string[]> {
-	if (headers instanceof HoneyOutHeaders) return headers.toRecord()
-	if (!(headers instanceof Headers) && !("forEach" in headers)) {
-		return { ...headers }
-	}
-	const out: Record<string, string | string[]> = {}
-	const h = headers as Headers
-	h.forEach((value, key) => {
-		if (key === "set-cookie") return
-		out[key] = value
-	})
-	if (typeof h.getSetCookie === "function") {
-		const cookies = h.getSetCookie()
-		if (cookies.length > 0) out["set-cookie"] = cookies
-	}
-	return out
-}
-
-async function streamToArrayBuffer(stream: ReadableStream<Uint8Array>): Promise<ArrayBuffer> {
-	const reader = stream.getReader()
-	const chunks: Uint8Array[] = []
-	let total = 0
-	while (true) {
-		const { done, value } = await reader.read()
-		if (done) break
-		chunks.push(value)
-		total += value.byteLength
-	}
-	const out = new Uint8Array(total)
-	let offset = 0
-	for (const chunk of chunks) {
-		out.set(chunk, offset)
-		offset += chunk.byteLength
-	}
-	return out.buffer
-}

package/src/i18n-slot.ts

@@ -1,30 +0,0 @@
-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.'
-
-let runtime: I18nRuntime | undefined
-
-export function registerI18nRuntime(next: I18nRuntime): void {
-	runtime = next
-}
-
-export function resetI18nRuntime(): void {
-	runtime = undefined
-}
-
-export function getI18nRuntime(): I18nRuntime {
-	if (!runtime) throw new Error(MISSING)
-	return runtime
-}

package/src/i18n.ts

@@ -1,300 +0,0 @@
-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.
- * "cause" is excluded (reserved by HoneyError).
- * Returns {} when no variables found — makes `vars` optional at call site.
- */
-export type ExtractICUVars<T extends string> = T extends `${string}{${infer Var}}${infer Rest}`
-	? Var extends "cause"
-		? ExtractICUVars<Rest>
-		: { [K in Var | keyof ExtractICUVars<Rest>]: string | number }
-	: {}
-
-type TranslationMap = Record<string, string>
-
-export type TranslationSource = (() => Promise<TranslationMap> | TranslationMap) | TranslationMap
-
-export class TranslationRegistry {
-	private cache = new Map<string, TranslationMap>()
-	private sources: Record<string, TranslationSource>
-
-	constructor(sources: Record<string, TranslationSource>) {
-		this.sources = sources
-	}
-
-	async get(locale: string): Promise<TranslationMap | undefined> {
-		if (this.cache.has(locale)) {
-			return this.cache.get(locale)
-		}
-
-		const source = Object.hasOwn(this.sources, locale) ? this.sources[locale] : undefined
-		if (source === undefined) {
-			return undefined
-		}
-
-		const map = typeof source === "function" ? await source() : source
-		this.cache.set(locale, map)
-		return map
-	}
-}
-
-/* ---- ICU MessageFormat parser ---- */
-
-const pluralRulesCache = new Map<string, Intl.PluralRules>()
-
-/** 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 }
-type ParsedNumber = { type: "number"; varName: string }
-type ParsedSimple = { type: "simple"; varName: string }
-type ParsedToken = ParsedBlock | ParsedNumber | ParsedSimple | string
-
-function findMatchingBrace(str: string, start: number): number {
-	let depth = 0
-	for (let i = start; i < str.length; i++) {
-		if (str[i] === "{") depth++
-		else if (str[i] === "}") {
-			depth--
-			if (depth === 0) return i
-		}
-	}
-	return -1
-}
-
-function parseBranches(content: string): 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++
-		if (i >= content.length) break
-
-		let category = ""
-		while (i < content.length && content[i] !== "{" && !/\s/.test(content[i] ?? "")) {
-			category += content[i]
-			i++
-		}
-		if (!category) break
-
-		while (i < content.length && /\s/.test(content[i] ?? "")) i++
-		if (i >= content.length || content[i] !== "{") break
-
-		const end = findMatchingBrace(content, i)
-		if (end === -1) break
-
-		branches[category] = content.slice(i + 1, end)
-		i = end + 1
-	}
-	return branches
-}
-
-function tokenize(message: string): ParsedToken[] {
-	const tokens: ParsedToken[] = []
-	let i = 0
-
-	while (i < message.length) {
-		const braceIdx = message.indexOf("{", i)
-		if (braceIdx === -1) {
-			tokens.push(message.slice(i))
-			break
-		}
-
-		if (braceIdx > i) {
-			tokens.push(message.slice(i, braceIdx))
-		}
-
-		const endBrace = findMatchingBrace(message, braceIdx)
-		if (endBrace === -1) {
-			tokens.push(message.slice(braceIdx))
-			break
-		}
-
-		const inner = message.slice(braceIdx + 1, endBrace)
-		const commaIdx = inner.indexOf(",")
-
-		if (commaIdx === -1) {
-			tokens.push({ type: "simple", varName: inner.trim() })
-		} else {
-			const varName = inner.slice(0, commaIdx).trim()
-			const rest = inner.slice(commaIdx + 1).trim()
-			const secondComma = rest.indexOf(",")
-
-			if (secondComma === -1) {
-				const formatType = rest.trim()
-				if (formatType === "number") {
-					tokens.push({ type: "number", varName })
-				} else {
-					tokens.push({ type: "simple", varName })
-				}
-			} else {
-				const formatType = rest.slice(0, secondComma).trim()
-				const branchContent = rest.slice(secondComma + 1).trim()
-				const branches = parseBranches(branchContent)
-
-				if (formatType === "plural" || formatType === "select") {
-					tokens.push({ branches, type: formatType, varName })
-				} else {
-					tokens.push({ type: "simple", varName })
-				}
-			}
-		}
-
-		i = endBrace + 1
-	}
-
-	return tokens
-}
-
-function resolveToken(token: ParsedToken, values: Record<string, unknown>, locale?: string): string {
-	if (typeof token === "string") return token
-
-	if (token.type === "simple") {
-		const val = own(values, token.varName)
-		return val !== undefined && val !== null ? String(val) : `{${token.varName}}`
-	}
-
-	if (token.type === "number") {
-		const val = own(values, token.varName)
-		if (val === undefined || val === null) return `{${token.varName}}`
-		return formatNumber(Number(val), locale)
-	}
-
-	/* plural or select */
-	const val = own(values, token.varName)
-
-	if (token.type === "plural") {
-		const num = Number(val ?? 0)
-		const exactKey = `=${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 = own(token.branches, strVal) ?? own(token.branches, "other") ?? ""
-	return interpolate(template, values, locale)
-}
-
-/**
- * ICU MessageFormat interpolation.
- * Supports: {var}, {var, plural, one{...} other{...}}, {var, select, ...}, {var, number}
- */
-export function interpolate(template: string, vars: Record<string, unknown>, locale?: string): string {
-	if (!template) return template
-	const tokens = tokenize(template)
-	return tokens.map((t) => resolveToken(t, vars, locale)).join("")
-}
-
-export async function resolveTranslation(
-	registry: TranslationRegistry,
-	locale: string,
-	key: string,
-	vars: Record<string, string | number>,
-): Promise<string> {
-	const map = await registry.get(locale)
-	if (map === undefined) return key
-	const template = own(map, key)
-	if (template === undefined) return key
-	return interpolate(template, vars, locale)
-}
-
-export async function resolveFieldName(
-	registry: TranslationRegistry,
-	locale: string,
-	fieldPath: string,
-): Promise<string> {
-	const map = await registry.get(locale)
-	if (map === undefined) return 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, translateError })
-}
-
-enableI18n()