@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/types-wSh9fCBY.js

@@ -0,0 +1,11 @@
+//#region src/cli/types.ts
+/** Exit codes of every command. */
+const EXIT = {
+	ok: 0,
+	/** Errors found, drift, a safety refusal, failed translations. */
+	failure: 1,
+	/** Bad flags, no config, invalid config. */
+	usage: 2
+};
+//#endregion
+export { EXIT as t };

package/dist/units-CQ5Q99RC.js

@@ -0,0 +1,150 @@
+import { o as isDiagnosticError } from "./types-D3QGM8XO.js";
+import { C as usableTranslation, S as entryKey, x as entryCanonical } from "./library-D5CWvTQs.js";
+import { r as resolveDuplicates } from "./duplicates-yuRljQ6h.js";
+//#region src/core/exchange/units.ts
+/**
+* Catalog exchange (PLAN §4.4, §5.19, INTERNALS §2.6.9): one format-neutral
+* view of a locale's entries that every export format writes, and the
+* source-identity rules that export, import and restore share. A unit's
+* source is always the text its translation was made for: for an `"id"`-layout
+* target that is the source locale's text when its label still fingerprints
+* it, else the entry's `#. source:` note, else nothing.
+*/
+const EXCHANGE_FORMATS = [
+	"po",
+	"json",
+	"flat",
+	"xliff2",
+	"arb",
+	"csv"
+];
+/** File extension per format; `vi18n import` infers the format from it. */
+const EXTENSIONS = {
+	po: ".po",
+	json: ".json",
+	flat: ".json",
+	xliff2: ".xliff",
+	arb: ".arb",
+	csv: ".csv"
+};
+/** `"id"`-layout targets join the source locale's entries by key (INTERNALS §2.6.1). */
+function sourceIndexOf(sourceCatalog, layout, codec) {
+	if (layout !== "id" || sourceCatalog === null) return null;
+	const index = /* @__PURE__ */ new Map();
+	for (const entry of sourceCatalog.entries) {
+		const key = entryKey(entry, layout, codec);
+		if (key !== null && entry.source !== null && !index.has(key)) index.set(key, entry.source);
+	}
+	return index;
+}
+function canonicalOrNull(text, codec) {
+	try {
+		return codec.canonicalize(text);
+	} catch (error) {
+		if (isDiagnosticError(error)) return null;
+		throw error;
+	}
+}
+/**
+* The canonical source and label an entry's translation belongs to, or null
+* when the catalog cannot say (an `"id"`-layout entry whose label no known
+* text fingerprints, or a source that does not parse).
+*/
+function entrySource(entry, key, context) {
+	const { codec, layout } = context;
+	if (layout === "id") {
+		if (entry.label === null) return null;
+		for (const text of [context.sourceIndex?.get(key) ?? null, entry.source]) {
+			if (text === null) continue;
+			const canonical = canonicalOrNull(text, codec);
+			if (canonical !== null && codec.label(canonical) === entry.label) return {
+				canonical,
+				label: entry.label
+			};
+		}
+		return null;
+	}
+	const canonical = entryCanonical(entry, codec);
+	return canonical === null ? null : {
+		canonical,
+		label: codec.label(canonical)
+	};
+}
+/**
+* The units of one locale's catalog, in catalog order, one per key (the
+* read-side duplicate pick). Foreign contexts, and entries whose source is
+* unknown, are counted in `unsourced` and left out.
+*/
+function exchangeUnits(input) {
+	const { catalog, context, locale, isSourceLocale } = input;
+	if (catalog === null) return {
+		units: [],
+		unsourced: 0
+	};
+	const { codec, layout } = context;
+	const resolved = resolveDuplicates(catalog, codec).catalog;
+	const units = [];
+	const seen = /* @__PURE__ */ new Set();
+	let unsourced = 0;
+	for (const entry of resolved.entries) {
+		const key = entryKey(entry, layout, codec);
+		if (key === null) {
+			unsourced++;
+			continue;
+		}
+		if (seen.has(key)) continue;
+		seen.add(key);
+		const source = entrySource(entry, key, context);
+		if (source === null) {
+			unsourced++;
+			continue;
+		}
+		const manual = entry.manualId !== null;
+		const translation = isSourceLocale ? "" : entry.translation;
+		const usable = !isSourceLocale && usableTranslation(entry, layout, {
+			id: key,
+			manual,
+			canonical: source.canonical,
+			sourceHash: codec.sourceHash(source.canonical),
+			label: layout === "id" ? entry.label : source.label
+		}, codec, locale).ok;
+		units.push({
+			id: key,
+			manual,
+			source: source.canonical,
+			label: source.label,
+			translation,
+			state: isSourceLocale ? "untranslated" : entry.state,
+			fuzzy: !isSourceLocale && entry.fuzzy,
+			usable,
+			entry
+		});
+	}
+	return {
+		units,
+		unsourced
+	};
+}
+/**
+* Key-only formats (flat JSON, ARB, CSV) carry no source, so a manual id is
+* keyed with its source's label (PLAN §5.19): a row translated against older
+* text no longer matches and is reported instead of imported. A generated
+* id is already its source's label.
+*/
+function exchangeKey(unit) {
+	return unit.manual ? `${unit.id}~${unit.label}` : unit.id;
+}
+/** `hero.cta~Hpi4JmqaQa60` → the manual id and the label; a plain key has no label. */
+function parseExchangeKey(raw) {
+	const at = raw.lastIndexOf("~");
+	if (at === -1) return {
+		key: raw,
+		label: null
+	};
+	return {
+		key: raw.slice(0, at),
+		label: raw.slice(at + 1)
+	};
+}
+//#endregion
+export { exchangeKey as a, sourceIndexOf as c, entrySource as i, EXTENSIONS as n, exchangeUnits as o, canonicalOrNull as r, parseExchangeKey as s, EXCHANGE_FORMATS as t };

package/dist/url-CRfCOhUI.js

@@ -0,0 +1,172 @@
+//#region src/runtime/url.ts
+/**
+* Whether localized paths and domains are compiled in (§6 D134). The plugin
+* defines `__VI18N_ROUTES__` false for a config with neither, which folds
+* every `ROUTES` branch out of the app, so a default app ships the codec it
+* shipped before; code bundled without the plugin (servers registered with
+* `registerCatalogs()`, `/config` under Node) keeps them.
+*/
+const ROUTES = typeof __VI18N_ROUTES__ === "undefined" || !!__VI18N_ROUTES__;
+/** The base as a path starting and ending with `/`; a relative Vite base has no path to strip. */
+const baseOf = (config) => {
+	const b = config.routing.base;
+	return b[0] === "/" ? b.replace(/\/?$/, "/") : "/";
+};
+/** The part of `pathname` after the base, or null when the pathname is outside it. */
+const rest = (pathname, base) => pathname.startsWith(base) ? pathname.slice(base.length) : pathname + "/" === base ? "" : null;
+/**
+* Collapses leading slashes and backslashes to one `/`. Browsers read `//host`
+* and `/\host` as another origin, so a same-origin path such as
+* `/de//evil.example/` must never come out of the codec in that form: its
+* output becomes page loads, router navigations and the server's
+* canonical redirect.
+*/
+const local = (path) => path.replace(/^[/\\]{2,}/, "/");
+/**
+* Splits the locale segment off a pathname. Only a segment equal to a
+* configured locale (case-sensitive) is a locale; `path` keeps the base and
+* any trailing slash, and a localized root (`/de`, `/de/`) becomes the base.
+*/
+function splitLocalePath(pathname, config) {
+	const base = baseOf(config);
+	const p = pathname + "/";
+	if (config.routing.url !== "no_prefix" && p.startsWith(base)) {
+		const r = p.slice(base.length);
+		const i = r.indexOf("/");
+		const seg = r.slice(0, i);
+		if (config.locales.includes(seg)) {
+			if (ROUTES) return {
+				locale: seg,
+				path: translate(local(base + r.slice(i + 1, -1)), seg, config, 1)
+			};
+			return {
+				locale: seg,
+				path: local(base + r.slice(i + 1, -1))
+			};
+		}
+	}
+	if (ROUTES) return {
+		locale: null,
+		path: translate(pathname, unprefixed(config), config, 1)
+	};
+	return {
+		locale: null,
+		path: pathname
+	};
+}
+/**
+* The pathname of `path` in `locale`. Any locale segment already in `path` is
+* replaced, so localizing is idempotent. An unconfigured locale, `no_prefix`
+* and pathnames outside the base leave `path` unchanged.
+*/
+function localizePath(path, locale, config) {
+	const url = config.routing.url;
+	let p = path;
+	if (url !== "no_prefix" && config.locales.includes(locale)) {
+		p = splitLocalePath(path, config).path;
+		if (ROUTES) p = translate(p, locale, config, 0);
+		if (locale !== (ROUTES && config.routing.home || config.sourceLocale) || url === "prefix") {
+			const base = baseOf(config);
+			const q = p + "/";
+			if (q.startsWith(base)) {
+				const r = q.slice(base.length, -1);
+				p = base + locale + (r && "/" + r);
+			}
+		}
+	}
+	return local(p);
+}
+/**
+* Every path in every configured locale: per path in order, one entry per
+* locale in `locales` order, duplicates dropped. Pseudo-locales are never
+* prerendered or advertised, so they are left out.
+*/
+function localizedPathsFor(paths, config) {
+	const out = /* @__PURE__ */ new Set();
+	const pseudo = config.pseudoLocales ?? [];
+	for (const path of paths) for (const l of config.locales) if (!pseudo.includes(l)) out.add(localizePath(path, l, config));
+	return [...out];
+}
+/** Segments of a path as a pathname spells them: `/über-uns` → `%C3%BCber-uns`. */
+const segmentsOf = (path) => new URL(path, "http://h").pathname.split("/").slice(1);
+/**
+* `from` as a pattern and `to` as its template: a `*` segment matches one
+* segment and a final `**` any number (with their slashes), and the
+* template puts them back in order (`$1`, `$2`). A template never has a
+* digit right after `$n`: a slash or its end follows.
+*/
+function pathRule(from, to) {
+	let source = "";
+	let template = "";
+	let n = 0;
+	for (const s of segmentsOf(from)) source += s === "**" ? "((?:/[^/]+)*)" : s === "*" ? "/([^/]+)" : "/" + s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	for (const s of segmentsOf(to)) template += s === "**" ? "$" + ++n : s === "*" ? "/$" + ++n : "/" + s.replace(/\$/g, "$$$$");
+	return [new RegExp("^" + source + "$"), template];
+}
+/**
+* `routing.paths` as rules, for the codec, the SPA boot script and the CLI.
+* Exact paths come before patterns (each group in config order), so
+* `/blog/new` wins over `/blog/*` in both directions, as routers rank them.
+*/
+function pathTable(paths) {
+	const table = {
+		to: {},
+		from: {}
+	};
+	const wild = (p) => +p.includes("*");
+	for (const key of Object.keys(paths).sort((a, b) => wild(a) - wild(b))) {
+		const entry = paths[key];
+		for (const l of Object.keys(entry)) {
+			(table.to[l] ??= []).push(pathRule(key, entry[l]));
+			(table.from[l] ??= []).push(pathRule(entry[l], key));
+		}
+	}
+	return table;
+}
+const compiled = /* @__PURE__ */ new WeakMap();
+/** The locale of an unprefixed path: the host's, else the source locale; none under `prefix`. */
+const unprefixed = (config) => {
+	const url = config.routing.url;
+	return url === "prefix" || url === "no_prefix" ? void 0 : config.routing.home ?? config.sourceLocale;
+};
+/**
+* `path` (a pathname with base) in locale `l` (`back` 0: from a route path)
+* or back to its route path (`back` 1). A path outside the base, the root
+* and paths no rule matches are left alone; a trailing slash is kept.
+*/
+function translate(path, l, config, back) {
+	const paths = config.routing.paths;
+	if (!paths || l === void 0) return path;
+	let table = compiled.get(paths);
+	if (!table) compiled.set(paths, table = pathTable(paths));
+	const rules = back ? table.from : table.to;
+	const list = Object.hasOwn(rules, l) ? rules[l] : void 0;
+	const base = baseOf(config);
+	const r = list ? rest(path, base) : null;
+	if (!list || !r) return path;
+	const end = r.endsWith("/") ? "/" : "";
+	const p = "/" + (end ? r.slice(0, -1) : r);
+	for (const [re, template] of list) if (re.test(p)) return local(base + p.replace(re, template).slice(1) + end);
+	return path;
+}
+/** Where links to `locale` go: its first listed origin. */
+function localeOrigin(locale, config) {
+	const domains = config.routing.domains;
+	if (domains) {
+		for (const o in domains) if (domains[o] === locale) return o;
+	}
+}
+/**
+* `config` for a page whose host serves `home` (undefined: an unlisted
+* host). The copy shares every table with `config`, so compiled path rules
+* and route-glob keys stay cached across copies.
+*/
+const atHome = (config, home) => home === config.routing.home ? config : {
+	...config,
+	routing: {
+		...config.routing,
+		home
+	}
+};
+//#endregion
+export { pathTable as a, localizedPathsFor as i, localeOrigin as n, localizePath as r, atHome as t };

package/dist/url-CsBkRaJy.js

@@ -0,0 +1,225 @@
+//#region src/runtime/url.ts
+/**
+* Whether localized paths and domains are compiled in (§6 D134). The plugin
+* defines `__VI18N_ROUTES__` false for a config with neither, which folds
+* every `ROUTES` branch out of the app, so a default app ships the codec it
+* shipped before; code bundled without the plugin (servers registered with
+* `registerCatalogs()`, `/config` under Node) keeps them.
+*/
+const ROUTES = typeof __VI18N_ROUTES__ === "undefined" || !!__VI18N_ROUTES__;
+/** The base as a path starting and ending with `/`; a relative Vite base has no path to strip. */
+const baseOf = (config) => {
+	const b = config.routing.base;
+	return b[0] === "/" ? b.replace(/\/?$/, "/") : "/";
+};
+/** The part of `pathname` after the base, or null when the pathname is outside it. */
+const rest = (pathname, base) => pathname.startsWith(base) ? pathname.slice(base.length) : pathname + "/" === base ? "" : null;
+/**
+* Collapses leading slashes and backslashes to one `/`. Browsers read `//host`
+* and `/\host` as another origin, so a same-origin path such as
+* `/de//evil.example/` must never come out of the codec in that form: its
+* output becomes page loads, router navigations and the server's
+* canonical redirect.
+*/
+const local = (path) => path.replace(/^[/\\]{2,}/, "/");
+/**
+* Splits the locale segment off a pathname. Only a segment equal to a
+* configured locale (case-sensitive) is a locale; `path` keeps the base and
+* any trailing slash, and a localized root (`/de`, `/de/`) becomes the base.
+*/
+function splitLocalePath(pathname, config) {
+	const base = baseOf(config);
+	const p = pathname + "/";
+	if (config.routing.url !== "no_prefix" && p.startsWith(base)) {
+		const r = p.slice(base.length);
+		const i = r.indexOf("/");
+		const seg = r.slice(0, i);
+		if (config.locales.includes(seg)) {
+			if (ROUTES) return {
+				locale: seg,
+				path: translate(local(base + r.slice(i + 1, -1)), seg, config, 1)
+			};
+			return {
+				locale: seg,
+				path: local(base + r.slice(i + 1, -1))
+			};
+		}
+	}
+	if (ROUTES) return {
+		locale: null,
+		path: translate(pathname, unprefixed(config), config, 1)
+	};
+	return {
+		locale: null,
+		path: pathname
+	};
+}
+/**
+* The pathname of `path` in `locale`. Any locale segment already in `path` is
+* replaced, so localizing is idempotent. An unconfigured locale, `no_prefix`
+* and pathnames outside the base leave `path` unchanged.
+*/
+function localizePath(path, locale, config) {
+	const url = config.routing.url;
+	let p = path;
+	if (url !== "no_prefix" && config.locales.includes(locale)) {
+		p = splitLocalePath(path, config).path;
+		if (ROUTES) p = translate(p, locale, config, 0);
+		if (locale !== (ROUTES && config.routing.home || config.sourceLocale) || url === "prefix") {
+			const base = baseOf(config);
+			const q = p + "/";
+			if (q.startsWith(base)) {
+				const r = q.slice(base.length, -1);
+				p = base + locale + (r && "/" + r);
+			}
+		}
+	}
+	return local(p);
+}
+/**
+* Every path in every configured locale: per path in order, one entry per
+* locale in `locales` order, duplicates dropped. Pseudo-locales are never
+* prerendered or advertised, so they are left out.
+*/
+function localizedPathsFor(paths, config) {
+	const out = /* @__PURE__ */ new Set();
+	const pseudo = config.pseudoLocales ?? [];
+	for (const path of paths) for (const l of config.locales) if (!pseudo.includes(l)) out.add(localizePath(path, l, config));
+	return [...out];
+}
+/** Segments of a path as a pathname spells them: `/über-uns` → `%C3%BCber-uns`. */
+const segmentsOf = (path) => new URL(path, "http://h").pathname.split("/").slice(1);
+/**
+* `from` as a pattern and `to` as its template: a `*` segment matches one
+* segment and a final `**` any number (with their slashes), and the
+* template puts them back in order (`$1`, `$2`). A template never has a
+* digit right after `$n`: a slash or its end follows.
+*/
+function pathRule(from, to) {
+	let source = "";
+	let template = "";
+	let n = 0;
+	for (const s of segmentsOf(from)) source += s === "**" ? "((?:/[^/]+)*)" : s === "*" ? "/([^/]+)" : "/" + s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	for (const s of segmentsOf(to)) template += s === "**" ? "$" + ++n : s === "*" ? "/$" + ++n : "/" + s.replace(/\$/g, "$$$$");
+	return [new RegExp("^" + source + "$"), template];
+}
+/**
+* `routing.paths` as rules, for the codec, the SPA boot script and the CLI.
+* Exact paths come before patterns (each group in config order), so
+* `/blog/new` wins over `/blog/*` in both directions, as routers rank them.
+*/
+function pathTable(paths) {
+	const table = {
+		to: {},
+		from: {}
+	};
+	const wild = (p) => +p.includes("*");
+	for (const key of Object.keys(paths).sort((a, b) => wild(a) - wild(b))) {
+		const entry = paths[key];
+		for (const l of Object.keys(entry)) {
+			(table.to[l] ??= []).push(pathRule(key, entry[l]));
+			(table.from[l] ??= []).push(pathRule(entry[l], key));
+		}
+	}
+	return table;
+}
+const compiled = /* @__PURE__ */ new WeakMap();
+/** The locale of an unprefixed path: the host's, else the source locale; none under `prefix`. */
+const unprefixed = (config) => {
+	const url = config.routing.url;
+	return url === "prefix" || url === "no_prefix" ? void 0 : config.routing.home ?? config.sourceLocale;
+};
+/**
+* `path` (a pathname with base) in locale `l` (`back` 0: from a route path)
+* or back to its route path (`back` 1). A path outside the base, the root
+* and paths no rule matches are left alone; a trailing slash is kept.
+*/
+function translate(path, l, config, back) {
+	const paths = config.routing.paths;
+	if (!paths || l === void 0) return path;
+	let table = compiled.get(paths);
+	if (!table) compiled.set(paths, table = pathTable(paths));
+	const rules = back ? table.from : table.to;
+	const list = Object.hasOwn(rules, l) ? rules[l] : void 0;
+	const base = baseOf(config);
+	const r = list ? rest(path, base) : null;
+	if (!list || !r) return path;
+	const end = r.endsWith("/") ? "/" : "";
+	const p = "/" + (end ? r.slice(0, -1) : r);
+	for (const [re, template] of list) if (re.test(p)) return local(base + p.replace(re, template).slice(1) + end);
+	return path;
+}
+/** The locale a listed host (`example.de`, `localhost:5173`) serves; undefined for any other host. */
+function hostLocale(host, config) {
+	const domains = config.routing.domains;
+	if (domains) {
+		const h = host.toLowerCase();
+		for (const o in domains) if (o.slice(o.indexOf("//") + 2) === h) return domains[o];
+	}
+}
+/** Where links to `locale` go: its first listed origin. */
+function localeOrigin(locale, config) {
+	const domains = config.routing.domains;
+	if (domains) {
+		for (const o in domains) if (domains[o] === locale) return o;
+	}
+}
+/**
+* `config` for a page whose host serves `home` (undefined: an unlisted
+* host). The copy shares every table with `config`, so compiled path rules
+* and route-glob keys stay cached across copies.
+*/
+const atHome = (config, home) => home === config.routing.home ? config : {
+	...config,
+	routing: {
+		...config.routing,
+		home
+	}
+};
+/** `config` for a page on `host`: a listed host's locale is its unprefixed one. */
+const atHost = (config, host) => config.routing.domains ? atHome(config, hostLocale(host, config)) : config;
+/**
+* The absolute URL of `route` (a route path with base) in `locale`, when
+* the page is on a listed host and `locale` lives on another: that host's
+* origin and the locale's unprefixed path. Null on the same host, on an
+* unlisted host (dev servers keep their prefixes) and for a locale without
+* a host (pseudo-locales). Only configured origins ever come out.
+*/
+function awayHref(route, locale, config) {
+	const home = config.routing.home;
+	const o = home !== void 0 && home !== locale ? localeOrigin(locale, config) : void 0;
+	return o ? o + localizePath(route, locale, atHome(config, locale)) : null;
+}
+/** `p` without a trailing slash; the root stays `/`. */
+const trail = (p) => p.length > 1 && p.endsWith("/") ? p.slice(0, -1) : p;
+/**
+* The pathname as route globs see it (INTERNALS §2.7.3): delocalized, without
+* the base and without a trailing slash; the root is `/`.
+*/
+function routePath(pathname, config) {
+	const p = splitLocalePath(pathname, config).path;
+	const r = rest(p, baseOf(config));
+	return trail(r === null ? p : "/" + r);
+}
+const globs = /* @__PURE__ */ new Map();
+const globToRegExp = (pattern) => {
+	let src = "";
+	for (const seg of (pattern[0] === "/" ? pattern : "/" + pattern).split("/").slice(1)) src += seg === "**" ? "(?:/.*)?" : "/" + seg.split("*").map((s) => s.replace(/[.+?^${}()|[\]\\]/g, "\\$&")).join("[^/]+");
+	return new RegExp("^" + (src || "/") + "$");
+};
+/**
+* The first pattern (in the given order) matching `path`: `*` is one or more
+* characters other than `/`, a `**` segment is any number of whole segments.
+* Case-sensitive. A trailing slash on `path` is ignored.
+*/
+function matchRoute(patterns, path) {
+	const p = trail(path);
+	for (const pattern of patterns) {
+		let re = globs.get(pattern);
+		if (!re) globs.set(pattern, re = globToRegExp(pattern));
+		if (re.test(p)) return pattern;
+	}
+	return null;
+}
+//#endregion
+export { hostLocale as a, localizedPathsFor as c, splitLocalePath as d, awayHref as i, matchRoute as l, atHome as n, localeOrigin as o, atHost as r, localizePath as s, ROUTES as t, routePath as u };