@menapo/vi18n 0.0.0-stage → 0.1.0

package/dist/pseudo-DRv30iN5.js

@@ -0,0 +1,145 @@
+//#region src/core/ir/pseudo.ts
+/**
+* Accented look-alikes of `A–Z` then `a–z` (one precomposed code point each),
+* readable at a glance yet impossible to mistake for untranslated text.
+*/
+const ACCENTED = "ÁƁÇÐÉƑĜĤÍĴĶĻṀÑÓÞǪŔŠŢÚṼŴẊÝŽáƀçðéƒĝĥíĵķļɱñóþǫŕšţúṽŵẋýž";
+const ACCENTED_BY_CODE = (() => {
+	const table = [];
+	for (let i = 0; i < 26; i++) {
+		table[65 + i] = ACCENTED.charAt(i);
+		table[97 + i] = ACCENTED.charAt(26 + i);
+	}
+	return table;
+})();
+const IS_VOWEL = (() => {
+	const table = [];
+	for (const vowel of "AEIOUaeiou") table[vowel.charCodeAt(0)] = true;
+	return table;
+})();
+/**
+* A pseudo-localised copy of a source message (INTERNALS §2.3).
+*
+* Only literal text changes: arguments, option keys, tags and `#` are kept, so
+* the result has the source's structure and renders with the same values.
+* `en-XA` accents ASCII letters and lengthens each literal that has letters by
+* ⌈35 %⌉ of its length (PLAN §4.7), the typical growth from English to German
+* or French, so layouts meet the overflow real translations cause; `ar-XB` keeps
+* the letters and forces right-to-left display. Both bracket the whole
+* message, so text on screen without brackets was not translated and brackets
+* inside a sentence reveal concatenation (PLAN §5.21).
+*/
+function pseudoLocalize(message, locale) {
+	return locale === "en-XA" ? wrap(mapNodes(message, accent), "[", "]") : wrap(mapNodes(message, identity), "[‮", "‬]");
+}
+/**
+* Rebuilds a node with `text` applied to its literal text. Output nodes carry
+* no `loc`: offsets into the source mean nothing for generated text.
+*/
+function mapNode(node, text) {
+	switch (node.type) {
+		case "literal": return {
+			type: "literal",
+			value: text(node.value)
+		};
+		case "argument": return {
+			type: "argument",
+			name: node.name
+		};
+		case "pound": return { type: "pound" };
+		case "number":
+		case "date":
+		case "time": return {
+			type: node.type,
+			name: node.name,
+			style: node.style === null ? null : { ...node.style },
+			options: node.options === null ? null : { ...node.options }
+		};
+		case "select": return {
+			type: "select",
+			name: node.name,
+			options: mapOptions(node.options, text)
+		};
+		case "plural": return {
+			type: "plural",
+			pluralType: node.pluralType,
+			name: node.name,
+			offset: node.offset,
+			options: mapOptions(node.options, text)
+		};
+		case "tag": return {
+			type: "tag",
+			name: node.name,
+			children: node.children === null ? null : mapNodes(node.children, text)
+		};
+	}
+}
+function mapNodes(nodes, text) {
+	const out = [];
+	for (const node of nodes) out.push(mapNode(node, text));
+	return out;
+}
+function mapOptions(options, text) {
+	const out = [];
+	for (const option of options) out.push({
+		key: option.key,
+		value: mapNodes(option.value, text)
+	});
+	return out;
+}
+function identity(value) {
+	return value;
+}
+/** Extra characters per literal, in percent of its length (PLAN §4.7). */
+const EXPANSION_PERCENT = 35;
+function accent(value) {
+	const chars = Array.from(value);
+	let letters = 0;
+	let vowels = 0;
+	for (const char of chars) {
+		const code = char.charCodeAt(0);
+		if (char.length !== 1 || code >= 128 || ACCENTED_BY_CODE[code] === void 0) continue;
+		letters++;
+		if (IS_VOWEL[code] === true) vowels++;
+	}
+	const extra = letters === 0 ? 0 : Math.ceil(chars.length * EXPANSION_PERCENT / 100);
+	const byVowel = vowels > 0 && extra <= 2 * vowels;
+	const carriers = byVowel ? vowels : letters;
+	let out = "";
+	let seen = 0;
+	for (const char of chars) {
+		const code = char.charCodeAt(0);
+		const mapped = char.length === 1 && code < 128 ? ACCENTED_BY_CODE[code] : void 0;
+		if (mapped === void 0) {
+			out += char;
+			continue;
+		}
+		out += mapped;
+		if (byVowel && IS_VOWEL[code] !== true) continue;
+		const copies = Math.floor((seen + 1) * extra / carriers) - Math.floor(seen * extra / carriers);
+		seen++;
+		if (copies > 0) out += mapped.repeat(copies);
+	}
+	return out;
+}
+/**
+* Adds the brackets as literal text, merged into a literal at either end so
+* the result keeps the AST invariant that adjacent literals are one node.
+*/
+function wrap(nodes, open, close) {
+	const first = nodes[0];
+	if (first?.type === "literal") first.value = open + first.value;
+	else nodes.unshift({
+		type: "literal",
+		value: open
+	});
+	const last = nodes[nodes.length - 1];
+	if (last.type === "literal") last.value += close;
+	else nodes.push({
+		type: "literal",
+		value: close
+	});
+	return nodes;
+}
+//#endregion
+export { pseudoLocalize as t };