@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/concurrency-C9UUWuDC.js

@@ -0,0 +1,96 @@
+//#region src/ai/concurrency.ts
+/**
+* Adaptive concurrency (PLAN §5.20, INTERNALS §2.15): requests start at
+* `ai.concurrency` in flight; a rate limit halves that and holds every new
+* request for the delay the server asked (`RetryInfo`, `Retry-After`), and
+* each full window of requests without one gives a slot back (AIMD). The
+* provider retries the limited request itself; this only decides how many
+* others may start. One instance spans a whole `vi18n translate` run, so a
+* quota learnt on one locale is not rediscovered on the next.
+*/
+/** Hold after a rate limit whose answer named no delay. */
+const DEFAULT_HOLD_MS = 1e3;
+function adaptiveConcurrency(max, now = Date.now) {
+	const ceiling = Math.max(1, Math.floor(max));
+	let limit = ceiling;
+	let inFlight = 0;
+	let holdUntil = 0;
+	let successes = 0;
+	let rateLimits = 0;
+	let epoch = 0;
+	const waiters = [];
+	let timer = null;
+	const pump = () => {
+		if (timer !== null) {
+			clearTimeout(timer);
+			timer = null;
+		}
+		while (waiters.length > 0 && inFlight < limit) {
+			const wait = holdUntil - now();
+			if (wait > 0) {
+				timer = setTimeout(pump, wait);
+				return;
+			}
+			waiters.shift().grant();
+		}
+	};
+	const slot = () => {
+		const started = epoch;
+		let limited = false;
+		let released = false;
+		inFlight++;
+		return {
+			rateLimited(retryAfterMs) {
+				rateLimits++;
+				limited = true;
+				if (started === epoch) {
+					limit = Math.max(1, Math.floor(limit / 2));
+					successes = 0;
+					epoch++;
+				}
+				holdUntil = Math.max(holdUntil, now() + (retryAfterMs ?? DEFAULT_HOLD_MS));
+			},
+			release() {
+				if (released) return;
+				released = true;
+				inFlight--;
+				if (!limited && started === epoch && ++successes >= limit && limit < ceiling) {
+					limit++;
+					successes = 0;
+				}
+				pump();
+			}
+		};
+	};
+	return {
+		max: ceiling,
+		get limit() {
+			return limit;
+		},
+		get rateLimits() {
+			return rateLimits;
+		},
+		acquire(signal) {
+			return new Promise((resolve, reject) => {
+				if (signal?.aborted === true) {
+					reject(signal.reason);
+					return;
+				}
+				const onAbort = () => {
+					const index = waiters.indexOf(waiter);
+					if (index !== -1) waiters.splice(index, 1);
+					reject(signal?.reason);
+				};
+				const waiter = { grant: () => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve(slot());
+				} };
+				signal?.addEventListener("abort", onAbort, { once: true });
+				waiters.push(waiter);
+				pump();
+			});
+		}
+	};
+}
+//#endregion
+export { adaptiveConcurrency as t };

package/dist/concurrency-DONL7t4V.js

@@ -0,0 +1 @@
+export { t as adaptiveConcurrency } from "./concurrency-C9UUWuDC.js";

package/dist/config.d.ts

@@ -0,0 +1,21 @@
+import { a as Vi18nConfig, c as OpenAICompatibleOptions, d as ProviderResponse, f as Tier, l as ProviderOptions, m as TranslationProvider, n as OutputOptions, o as AiItem, p as TranslateOptions, r as PseudoLocale, s as BatchOptions, t as Level, u as ProviderRequest, v as LocaleStrategy, y as UrlStrategy } from "./types-CgUCkFU1.js";
+//#region src/config/index.d.ts
+/**
+ * Types a `vi18n.config.ts`. The config is validated when it is loaded
+ * (`vi18n` plugin, CLI), where errors can name the file.
+ */
+export declare function defineConfig(config: Vi18nConfig): Vi18nConfig;
+/**
+ * Every path in every configured locale, for prerendering and sitemaps at
+ * build time (the request-time `localizedPaths` of `/server` reads the
+ * registered config instead), each locale's localized path where
+ * `routing.paths` has one. Defaults are applied to the routing keys by
+ * plain merging; the app base is not part of a route path, so it is `/`.
+ * Domains play no part: the list is the paths any unlisted host serves.
+ */
+export declare function localizedPaths(paths: readonly string[], config: Vi18nConfig): string[];
+//#endregion
+//#region src/ai/openai.d.ts
+export declare function openaiCompatible(options: OpenAICompatibleOptions): TranslationProvider;
+//#endregion
+export type { AiItem, BatchOptions, Level, LocaleStrategy, OpenAICompatibleOptions, OutputOptions, ProviderOptions, ProviderRequest, ProviderResponse, PseudoLocale, Tier, TranslateOptions, TranslationProvider, UrlStrategy, Vi18nConfig };

package/dist/config.js

@@ -0,0 +1,39 @@
+import { n as DEFAULT_CONFIG } from "./types-D3QGM8XO.js";
+import { i as localizedPathsFor } from "./url-CRfCOhUI.js";
+import { n as openaiCompatible } from "./openai-CTaMDcl-.js";
+//#region src/config/index.ts
+/**
+* `@menapo/vi18n/config` implementation (docs/INTERNALS.md §3.4). Loaded by
+* every `vi18n.config.ts` under Node, so it stays a few lines: no zod, no file
+* system, and only the pure URL codec from the runtime.
+*/
+/**
+* Types a `vi18n.config.ts`. The config is validated when it is loaded
+* (`vi18n` plugin, CLI), where errors can name the file.
+*/
+function defineConfig(config) {
+	return config;
+}
+/**
+* Every path in every configured locale, for prerendering and sitemaps at
+* build time (the request-time `localizedPaths` of `/server` reads the
+* registered config instead), each locale's localized path where
+* `routing.paths` has one. Defaults are applied to the routing keys by
+* plain merging; the app base is not part of a route path, so it is `/`.
+* Domains play no part: the list is the paths any unlisted host serves.
+*/
+function localizedPaths(paths, config) {
+	const sourceLocale = config.sourceLocale ?? DEFAULT_CONFIG.sourceLocale;
+	return localizedPathsFor(paths, {
+		sourceLocale,
+		locales: config.locales ?? [sourceLocale],
+		pseudoLocales: config.pseudoLocales ?? DEFAULT_CONFIG.pseudoLocales,
+		routing: {
+			url: config.routing?.url ?? DEFAULT_CONFIG.routing.url,
+			base: "/",
+			paths: config.routing?.paths
+		}
+	});
+}
+//#endregion
+export { defineConfig, localizedPaths, openaiCompatible };

package/dist/dir-zw6bGMKQ.js

@@ -0,0 +1,290 @@
+//#region src/runtime/ctx.ts
+/** Dev helpers shared by the runtime modules. */
+/**
+* Dev mode, from the plugin's `define` (INTERNALS §6 D44): code bundled
+* without the plugin behaves as production. A module constant, so the define
+* folds every `if (DEV)` branch out of production bundles.
+*/
+const DEV = typeof __VI18N_DEV__ !== "undefined" && !!__VI18N_DEV__;
+/**
+* A production build the plugin made (`__VI18N_DEV__` defined false). Its
+* client registrations are always the build boot's (`mode: "build"`, INTERNALS
+* §2.11.4), never a dev or Vitest one, so the dev catalog, test and fetch
+* restoring branches fold out of it (PLAN §6). Code bundled without the
+* plugin keeps them.
+*/
+const BUILD = typeof __VI18N_DEV__ !== "undefined" && !__VI18N_DEV__;
+/** True in a document (browser main thread). */
+const browser = () => typeof document === "object";
+/**
+* One binding the core's modules share: fewer bytes than `Object.hasOwn` at
+* each use. The engine keeps its own, which measured smaller in its bundle.
+*/
+const own = Object.hasOwn;
+/**
+* Bounds a cache before an insertion: past `max` entries the oldest goes
+* (insertion order), so keys from requests or apps cycling through values
+* evict their own stale entries instead of growing without bound.
+*/
+const trim = (cache, max) => cache.size > max && cache.delete(cache.keys().next().value);
+const warned = /* @__PURE__ */ new Set();
+/** Dev only: warn once per distinct text. */
+const warnOnce = (text) => {
+	const seen = warned.delete(text);
+	if (!seen) trim(warned, 499);
+	warned.add(text);
+	if (!seen) console.warn("vi18n: " + text);
+};
+//#endregion
+//#region src/runtime/scope.ts
+function createScope(kind, locale, messages, options = {}) {
+	return {
+		kind,
+		locale,
+		messages,
+		timeZone: options.timeZone,
+		now: options.now,
+		timeZoneSource: options.timeZoneSource,
+		formattedTime: false,
+		used: options.trackUsed ? /* @__PURE__ */ new Set() : void 0,
+		sources: options.sources,
+		labels: options.labels
+	};
+}
+//#endregion
+//#region src/runtime/types.ts
+/**
+* Opcodes of the IR. The runtime may inline the literal numbers to save
+* bytes; 9 (`list`) and 10 (MF2 `.match`) are reserved and never emitted in 1.0.
+*/
+const OP = {
+	select: 1,
+	plural: 2,
+	selectordinal: 3,
+	number: 4,
+	date: 5,
+	time: 6,
+	tag: 7,
+	tagStandalone: 8,
+	list: 9,
+	match: 10
+};
+/** The `globalThis[Symbol.for("menapo.vi18n")]` key. */
+const STATE_KEY = "menapo.vi18n";
+//#endregion
+//#region src/runtime/state.ts
+/**
+* The page-wide state on `globalThis[Symbol.for("menapo.vi18n")]`
+* (INTERNALS §2.11.1). The first runtime copy to evaluate creates it, or
+* upgrades the SPA boot script's stub in place, and installs methods that
+* close over its private data; later copies only count themselves. Methods
+* never use `this`, so glue may pass them unbound.
+*
+* This module holds only what `t()`, `fmt` and `/server` need: scope
+* resolution, trackers, `untracked` and missing reports. The client engine
+* (loading, skew, switching, navigation, `fetch` wrapper, persistence) is
+* `loader.ts`, behind the internal `@menapo/vi18n/engine` entry that the
+* generated client boot module imports first: it hooks into `register`
+* through `setEngine` and replaces the inert client methods installed here.
+* Neither the `.` entry nor `/server` carries it (PLAN §6, revision 4.3).
+*/
+/** This copy created the state (or upgraded the boot stub), so its engine may install. */
+let created = false;
+const resolved = Promise.resolve();
+const noop = () => {};
+/**
+* The browser's one scope; the engine flips its locale and messages. "und"
+* (the root locale) until registration, so early formatting cannot throw on
+* an empty tag.
+*/
+const page = createScope("page", "und", /* @__PURE__ */ new Map());
+const trackers = /* @__PURE__ */ new Set();
+let epoch = 0;
+const handlers = /* @__PURE__ */ new Set();
+const reported = /* @__PURE__ */ new Set();
+let fallback;
+/** `untracked()` depth: `t()` records nothing into `scope.used` while above 0. */
+let quiet = 0;
+/**
+* `subscribe()` listeners and the `setNavigator()` function. The core keeps
+* them and the engine only reads them, so app code that ran between the `.`
+* entry and the engine (a library imported ahead of the boot module) is not
+* silently dropped when the engine installs.
+*/
+const subs = /* @__PURE__ */ new Set();
+let nav;
+let engine;
+/**
+* Installs the engine's half of `register`. The core half runs first, so
+* `/server`'s wrapper sees `S.registration` set as soon as `register`
+* returns, and a server that registered before the `.` entry evaluated still
+* has a registration for the engine to catch up on.
+*/
+const setEngine = (e) => {
+	engine = e;
+};
+/** Bumps the epoch; with `trigger`, re-renders every tracked computation. */
+function changed(trigger) {
+	epoch++;
+	if (trigger) for (const t of [...trackers]) t.trigger();
+}
+/**
+* `onMissing` handlers hear of each (key, locale) once. Keys can come from
+* requests (`t(props.label)` on a server), so the memory is bounded, but
+* generously and oldest first: never the whole set at once.
+*/
+function report(key, locale, reason) {
+	const k = key + "\0" + locale;
+	if (reported.has(k) || !handlers.size) return;
+	trim(reported, 9999);
+	reported.add(k);
+	for (const h of handlers) try {
+		h({
+			key,
+			locale,
+			reason
+		});
+	} catch (e) {
+		if (DEV) console.error(e);
+	}
+}
+function createState(stub) {
+	/** A request-less `t()` on the server (§2.11.1 `resolve`). */
+	const noScope = () => {
+		const reg = S.registration;
+		if (!BUILD && reg?.test) return page;
+		if (DEV) throw new Error("vi18n: t() called outside a request scope");
+		const locale = reg?.config.sourceLocale ?? "und";
+		report("", locale, "no-scope");
+		return S.serverFallback ?? (fallback ??= createScope("request", locale, /* @__PURE__ */ new Map()));
+	};
+	/**
+	* Dev: a client page that should have the engine. Servers run without it by
+	* design, and so does everything outside a document.
+	*/
+	const clientPage = () => browser() && !S.serverResolver && S.registration?.consumer !== "server";
+	/**
+	* Dev: says why a client page renders no translations when the engine never
+	* evaluated (code the plugin did not process, a suite without the boot
+	* module).
+	*/
+	const noEngine = () => {
+		if (clientPage()) warnOnce("the client engine is not loaded, so nothing is fetched or switched and t() renders no translations; the plugin's boot module imports \"@menapo/vi18n/engine\" first. Is this code processed by vi18n()?");
+	};
+	/**
+	* The engine's client methods where it never evaluated: on servers and on
+	* pages the plugin did not process. One function for all that return
+	* nothing or a settled promise (a promise where `void` is declared is
+	* harmless), so the core pays a few bytes, not five stubs (PLAN §6). The
+	* engine replaces `need` and `ready` with two different functions, so
+	* `need === ready` means no engine is installed.
+	*/
+	const idle = () => {
+		if (DEV) noEngine();
+		return resolved;
+	};
+	const core = {
+		protocol: 1,
+		registration: null,
+		copies: 1,
+		serverResolver: null,
+		serverFallback: null,
+		richKey: null,
+		locales: [],
+		need: idle,
+		lazy(load) {
+			if (DEV) noEngine();
+			return load();
+		},
+		prefetch: idle,
+		ready: idle,
+		replace: idle,
+		subscribe(listener) {
+			subs.add(listener);
+			return () => void subs.delete(listener);
+		},
+		setNavigator(navigate) {
+			nav = navigate;
+		},
+		register(r) {
+			S.registration = r;
+			S.locales.length = 0;
+			S.locales.push(...r.config.locales);
+			page.locale = r.config.sourceLocale;
+			return engine ? engine(r) : resolved;
+		},
+		setLocale() {
+			throw new Error("vi18n: setLocale() is client-only" + (DEV ? clientPage() ? " and needs the client engine (\"@menapo/vi18n/engine\", imported by the boot module)" : "; use withLocale() or scopeLocale() on the server" : ""));
+		},
+		resolve: () => {
+			const r = S.serverResolver;
+			return r ? r() ?? noScope() : page;
+		},
+		untracked(fn) {
+			quiet++;
+			try {
+				return fn();
+			} finally {
+				quiet--;
+			}
+		},
+		track() {
+			for (const t of trackers) t.track();
+		},
+		addTracker(tracker) {
+			trackers.add(tracker);
+			return () => void trackers.delete(tracker);
+		},
+		epoch: () => epoch,
+		onMissing(handler) {
+			handlers.add(handler);
+			return () => void handlers.delete(handler);
+		},
+		missing(scope, key, reason) {
+			if (DEV && scope === page) noEngine();
+			report(key, scope.locale, reason);
+		}
+	};
+	const S = stub ? Object.assign(stub, core) : core;
+	return S;
+}
+/** Creates the global state, or upgrades the boot stub, or joins another copy's state. */
+function init() {
+	const g = globalThis;
+	const key = Symbol.for(STATE_KEY);
+	const existing = g[key];
+	if (existing?.register) {
+		existing.copies++;
+		if (DEV) console.warn(`vi18n: ${existing.copies} copies of @menapo/vi18n are loaded; they share one state, but dedupe the package`);
+		return existing;
+	}
+	created = true;
+	return g[key] = createState(existing);
+}
+/** The state, for runtime modules. Evaluating the runtime is what creates (or joins) it. */
+const S = init();
+/** The global state this copy created or joined. Pinned for `/server` and generated glue. */
+function getState() {
+	return S;
+}
+//#endregion
+//#region src/runtime/dir.ts
+/** Text direction of a locale (PLAN §4.16). */
+const RTL_SCRIPTS = "AdlmArabHebrMandMendNkooRohgSamrSyrcThaaYezi";
+const cache = /* @__PURE__ */ new Map();
+function textDirection(locale) {
+	let d = cache.get(locale);
+	if (!d) {
+		d = "ltr";
+		try {
+			const l = new Intl.Locale(locale);
+			const info = l.getTextInfo?.() ?? l.textInfo;
+			if (info ? info.direction === "rtl" : RTL_SCRIPTS.includes(l.maximize().script)) d = "rtl";
+		} catch {}
+		trim(cache, 127);
+		cache.set(locale, d);
+	}
+	return d;
+}
+//#endregion
+export { DEV as _, getState as a, trim as b, page as c, resolved as d, setEngine as f, BUILD as g, createScope as h, created as i, quiet as l, OP as m, S as n, nav as o, subs as p, changed as r, noop as s, textDirection as t, report as u, browser as v, warnOnce as x, own as y };

package/dist/duplicates-yuRljQ6h.js

@@ -0,0 +1,185 @@
+import { S as entryKey } from "./library-D5CWvTQs.js";
+//#region src/core/catalog/duplicates.ts
+const RANK = {
+	translated: 2,
+	ai: 1,
+	untranslated: 0
+};
+/** Entries grouped by key; only keys seen more than once. Null when there are none. */
+function duplicateGroups(catalog, codec) {
+	const first = /* @__PURE__ */ new Map();
+	let groups = null;
+	const entries = catalog.entries;
+	for (let i = 0; i < entries.length; i++) {
+		const key = entryKey(entries[i], catalog.layout, codec);
+		if (key === null) continue;
+		const seen = first.get(key);
+		if (seen === void 0) {
+			first.set(key, i);
+			continue;
+		}
+		groups ??= /* @__PURE__ */ new Map();
+		const group = groups.get(key);
+		if (group === void 0) groups.set(key, [seen, i]);
+		else group.push(i);
+	}
+	return groups;
+}
+/** `translated` over `ai` over `untranslated`, then the first in the file. */
+function winnerOf(entries, indexes) {
+	let best = indexes[0];
+	for (const index of indexes) if (RANK[entries[index].state] > RANK[entries[best].state]) best = index;
+	return best;
+}
+/**
+* The read-side pick: one entry per key, the losers dropped. Returns the
+* input catalog itself when it has no duplicates, so the common case
+* allocates nothing.
+*/
+function resolveDuplicates(catalog, codec) {
+	const groups = duplicateGroups(catalog, codec);
+	if (groups === null) return {
+		catalog,
+		duplicates: []
+	};
+	const entries = catalog.entries;
+	const dropped = /* @__PURE__ */ new Set();
+	const duplicates = [];
+	for (const [key, indexes] of groups) {
+		const winner = winnerOf(entries, indexes);
+		const lines = [entries[winner].line];
+		for (const index of indexes) {
+			if (index === winner) continue;
+			dropped.add(index);
+			lines.push(entries[index].line);
+		}
+		duplicates.push({
+			locale: catalog.locale,
+			key,
+			lines
+		});
+	}
+	return {
+		catalog: {
+			...catalog,
+			entries: entries.filter((_, index) => !dropped.has(index))
+		},
+		duplicates
+	};
+}
+/**
+* The `catalog-duplicate` warnings for {@link resolveDuplicates}' reports,
+* for callers that surface them (`compileLocales`, `check`, `status`).
+*/
+function duplicateDiagnostics(duplicates, file) {
+	return duplicates.map((duplicate) => {
+		const [winner, ...others] = duplicate.lines;
+		const diagnostic = {
+			code: "catalog-duplicate",
+			severity: "warning",
+			message: `${duplicate.key} appears ${duplicate.lines.length} times; the entry on line ${winner} is used and vi18n extract merges the copies (other lines: ${others.join(", ")})`,
+			locale: duplicate.locale,
+			id: duplicate.key
+		};
+		if (file !== void 0) diagnostic.file = file;
+		if (winner !== void 0 && winner > 0) diagnostic.line = winner;
+		return diagnostic;
+	});
+}
+/**
+* Appends the values of `from` that `seen` lacks, in order. `seen` holds
+* what `into` has, so a merge costs one lookup per value, not a search of
+* everything kept so far: a file is input, and may repeat one key with any
+* number of notes.
+*/
+function appendNew(into, seen, from) {
+	for (const value of from) {
+		if (seen.has(value)) continue;
+		seen.add(value);
+		into.push(value);
+	}
+}
+/**
+* Copies `from`'s fields onto `into` in place, not by a spread per copy
+* (which would copy everything kept so far each time); defineProperty keeps
+* a `__proto__` field data, as the JSON reader does.
+*/
+function defineFields(into, from) {
+	for (const field of Object.keys(from)) Object.defineProperty(into, field, {
+		value: from[field],
+		enumerable: true,
+		writable: true,
+		configurable: true
+	});
+	return into;
+}
+/**
+* The winner with every other copy merged in, in file order: as merging the
+* copies one by one would, but with one pass over each copy, so the cost
+* stays linear in the group's size however many copies there are.
+*/
+function mergeGroup(winner, others) {
+	const contexts = winner.contexts.slice();
+	const seenContexts = new Set(contexts);
+	const comments = winner.comments.slice();
+	const seenComments = new Set(comments);
+	const flags = winner.flags.slice();
+	const seenFlags = new Set(flags.map((flag) => flag.line + flag.name));
+	const refs = new Set(winner.refs);
+	let maxLength = winner.maxLength;
+	let extra;
+	for (let i = others.length - 1; i >= 0; i--) {
+		const other = others[i].extra;
+		if (other !== void 0) extra = defineFields(extra ?? {}, other);
+	}
+	if (extra !== void 0 && winner.extra !== void 0) defineFields(extra, winner.extra);
+	for (const other of others) {
+		appendNew(contexts, seenContexts, other.contexts);
+		appendNew(comments, seenComments, other.comments);
+		for (const flag of other.flags) {
+			const key = flag.line + flag.name;
+			if (seenFlags.has(key)) continue;
+			seenFlags.add(key);
+			flags.push(flag);
+		}
+		for (const ref of other.refs) refs.add(ref);
+		if (other.maxLength !== null) maxLength = maxLength === null ? other.maxLength : Math.min(maxLength, other.maxLength);
+	}
+	const merged = {
+		...winner,
+		contexts,
+		comments,
+		flags,
+		refs: [...refs].sort((x, y) => x < y ? -1 : x > y ? 1 : 0),
+		maxLength
+	};
+	if (extra !== void 0) merged.extra = extra;
+	return merged;
+}
+/**
+* What a full extract does with duplicates: one entry per key at the
+* winner's position, keeping its translation, state and fuzzy flag and the
+* union of every copy's references, notes, comments and flags.
+*/
+function mergeDuplicates(catalog, codec) {
+	const groups = duplicateGroups(catalog, codec);
+	if (groups === null) return catalog;
+	const entries = catalog.entries.slice();
+	const dropped = /* @__PURE__ */ new Set();
+	for (const indexes of groups.values()) {
+		const winner = winnerOf(entries, indexes);
+		const others = [];
+		for (const index of indexes) {
+			if (index === winner) continue;
+			others.push(entries[index]);
+			dropped.add(index);
+		}
+		entries[winner] = mergeGroup(entries[winner], others);
+	}
+	return {
+		...catalog,
+		entries: entries.filter((_, index) => !dropped.has(index))
+	};
+}
+//#endregion
+export { mergeDuplicates as n, resolveDuplicates as r, duplicateDiagnostics as t };