@formatjs/cli-lib 8.5.0 → 8.5.2

package/index.js

@@ -1,2 +1,633 @@
-export { default as extractAndWrite, extract } from "./src/extract.js";
-export { default as compileAndWrite, compile } from "./src/compile.js";
+import { a as writeStdout, i as warn, n as debug, r as getStdinAsString, t as parseScript } from "./parse_script-EspfGgzZ.js";
+import { interpolateName } from "@formatjs/ts-transformer";
+import { outputFile } from "fs-extra/esm";
+import * as stringifyNs from "json-stable-stringify";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+import { readFile } from "fs/promises";
+import { TYPE, isLiteralElement, isPluralElement, isSelectElement, isTagElement, parse } from "@formatjs/icu-messageformat-parser";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+//#region packages/cli-lib/formatters/crowdin.ts
+var crowdin_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile$6,
+	format: () => format$5
+});
+const format$5 = (msgs) => {
+	const results = {};
+	for (const [id, msg] of Object.entries(msgs)) results[id] = {
+		message: msg.defaultMessage,
+		description: typeof msg.description === "string" ? msg.description : JSON.stringify(msg.description)
+	};
+	return results;
+};
+const compile$6 = (msgs) => {
+	const results = {};
+	for (const [id, msg] of Object.entries(msgs)) {
+		if (id === "smartling") continue;
+		results[id] = msg.message;
+	}
+	return results;
+};
+//#endregion
+//#region packages/cli-lib/formatters/default.ts
+var default_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile$5,
+	format: () => format$4
+});
+const format$4 = (msgs) => msgs;
+const compile$5 = (msgs) => {
+	const results = {};
+	for (const k in msgs) results[k] = msgs[k].defaultMessage;
+	return results;
+};
+//#endregion
+//#region packages/cli-lib/formatters/lokalise.ts
+var lokalise_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile$4,
+	format: () => format$3
+});
+const format$3 = (msgs) => {
+	const results = {};
+	for (const [id, msg] of Object.entries(msgs)) results[id] = {
+		translation: msg.defaultMessage,
+		notes: typeof msg.description === "string" ? msg.description : JSON.stringify(msg.description)
+	};
+	return results;
+};
+const compile$4 = (msgs) => {
+	const results = {};
+	for (const [id, msg] of Object.entries(msgs)) results[id] = msg.translation;
+	return results;
+};
+//#endregion
+//#region packages/cli-lib/formatters/simple.ts
+var simple_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile$3,
+	format: () => format$2
+});
+const format$2 = (msgs) => {
+	return Object.keys(msgs).reduce((all, k) => {
+		all[k] = msgs[k].defaultMessage;
+		return all;
+	}, {});
+};
+const compile$3 = (msgs) => msgs;
+//#endregion
+//#region packages/cli-lib/formatters/smartling.ts
+var smartling_exports = /* @__PURE__ */ __exportAll({
+	compareMessages: () => compareMessages,
+	compile: () => compile$2,
+	format: () => format$1
+});
+const format$1 = (msgs) => {
+	const results = { smartling: {
+		translate_paths: [{
+			path: "*/message",
+			key: "{*}/message",
+			instruction: "*/description"
+		}],
+		variants_enabled: true,
+		string_format: "icu"
+	} };
+	for (const [id, msg] of Object.entries(msgs)) results[id] = {
+		message: msg.defaultMessage,
+		description: typeof msg.description === "string" ? msg.description : JSON.stringify(msg.description)
+	};
+	return results;
+};
+const compareMessages = (el1, el2) => {
+	if (el1.key === "smartling") return -1;
+	if (el2.key === "smartling") return 1;
+	return el1.key < el2.key ? -1 : el1.key === el2.key ? 0 : 1;
+};
+const compile$2 = (msgs) => {
+	const results = {};
+	for (const [id, msg] of Object.entries(msgs)) {
+		if (id === "smartling") continue;
+		results[id] = msg.message;
+	}
+	return results;
+};
+//#endregion
+//#region packages/cli-lib/formatters/transifex.ts
+var transifex_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile$1,
+	format: () => format
+});
+const format = (msgs) => {
+	const results = {};
+	for (const [id, msg] of Object.entries(msgs)) results[id] = {
+		string: msg.defaultMessage,
+		developer_comment: typeof msg.description === "string" ? msg.description : JSON.stringify(msg.description)
+	};
+	return results;
+};
+const compile$1 = (msgs) => {
+	const results = {};
+	for (const [id, msg] of Object.entries(msgs)) results[id] = msg.string;
+	return results;
+};
+//#endregion
+//#region packages/cli-lib/formatters/index.ts
+async function resolveBuiltinFormatter(format) {
+	if (!format) return default_exports;
+	if (typeof format !== "string") return format;
+	switch (format) {
+		case "transifex": return transifex_exports;
+		case "smartling": return smartling_exports;
+		case "simple": return simple_exports;
+		case "lokalise": return lokalise_exports;
+		case "crowdin": return crowdin_exports;
+	}
+	try {
+		return import(pathToFileURL(resolve(process.cwd(), format)).href);
+	} catch (e) {
+		console.error(`Cannot resolve formatter ${format}`);
+		throw e;
+	}
+}
+//#endregion
+//#region packages/cli-lib/extract.ts
+const stringify$1 = stringifyNs.default || stringifyNs;
+function calculateLineColFromOffset(text, start) {
+	if (!start) return {
+		line: 1,
+		col: 1
+	};
+	const lines = text.slice(0, start).split("\n");
+	const lastLine = lines[lines.length - 1];
+	return {
+		line: lines.length,
+		col: lastLine.length
+	};
+}
+async function processFile(source, fn, { idInterpolationPattern, ...opts }) {
+	let messages = [];
+	let meta;
+	const onMsgExtracted = opts.onMsgExtracted;
+	const onMetaExtracted = opts.onMetaExtracted;
+	opts = {
+		...opts,
+		additionalComponentNames: ["$formatMessage", ...opts.additionalComponentNames || []],
+		onMsgExtracted(filePath, msgs) {
+			if (opts.extractSourceLocation) msgs = msgs.map((msg) => ({
+				...msg,
+				...calculateLineColFromOffset(source, msg.start)
+			}));
+			messages = messages.concat(msgs);
+			if (onMsgExtracted) onMsgExtracted(filePath, msgs);
+		},
+		onMetaExtracted(filePath, m) {
+			meta = m;
+			if (onMetaExtracted) onMetaExtracted(filePath, m);
+		}
+	};
+	if (!opts.overrideIdFn && idInterpolationPattern) opts = {
+		...opts,
+		overrideIdFn: (id, defaultMessage, description, fileName) => id || interpolateName({ resourcePath: fileName }, idInterpolationPattern, { content: description ? `${defaultMessage}#${typeof description === "string" ? description : stringify$1(description)}` : defaultMessage })
+	};
+	debug("Processing opts for %s: %s", fn, opts);
+	const scriptParseFn = parseScript(opts, fn);
+	if (fn.endsWith(".vue")) {
+		debug("Processing %s using vue extractor", fn);
+		const { parseFile } = await import("./vue_extractor-Btw05cfG.js");
+		parseFile(source, fn, scriptParseFn);
+	} else if (fn.endsWith(".svelte")) {
+		debug("Processing %s using svelte extractor", fn);
+		const { parseFile } = await import("./svelte_extractor-Fr1Z3JHX.js");
+		parseFile(source, fn, scriptParseFn);
+	} else if (fn.endsWith(".hbs")) {
+		debug("Processing %s using hbs extractor", fn);
+		const { parseFile } = await import("./hbs_extractor-Eiqkz4d7.js");
+		parseFile(source, fn, opts);
+	} else if (fn.endsWith(".gts") || fn.endsWith(".gjs")) {
+		debug("Processing %s as gts/gjs file", fn);
+		const { parseFile } = await import("./gts_extractor-Dc-C_f4R.js");
+		parseFile(source, fn, opts);
+	} else {
+		debug("Processing %s using typescript extractor", fn);
+		scriptParseFn(source);
+	}
+	debug("Done extracting %s messages: %s", fn, messages);
+	if (meta) {
+		debug("Extracted meta:", meta);
+		messages.forEach((m) => m.meta = meta);
+	}
+	return {
+		messages,
+		meta
+	};
+}
+/**
+* Extract strings from source files
+* @param files list of files
+* @param extractOpts extract options
+* @returns messages serialized as JSON string since key order
+* matters for some `format`
+*/
+async function extract(files, extractOpts) {
+	const { throws, readFromStdin, signal, ...opts } = extractOpts;
+	const shouldThrow = throws === true;
+	const optsWithThrows = {
+		...opts,
+		throws: shouldThrow,
+		onMsgError: !shouldThrow ? (_, e) => warn(e.message) : void 0
+	};
+	let rawResults = [];
+	try {
+		if (readFromStdin) {
+			debug(`Reading input from stdin`);
+			if (process.stdin.isTTY) warn("Reading source file from TTY.");
+			rawResults = [await processFile(await getStdinAsString(), "dummy", optsWithThrows)];
+		} else if (!shouldThrow) rawResults = (await Promise.allSettled(files.map(async (fn) => {
+			debug("Extracting file:", fn);
+			return processFile(await readFile(fn, {
+				encoding: "utf8",
+				signal
+			}), fn, optsWithThrows);
+		}))).map((result) => {
+			if (result.status === "fulfilled") return result.value;
+			else {
+				warn(String(result.reason));
+				return;
+			}
+		});
+		else rawResults = await Promise.all(files.map(async (fn) => {
+			debug("Extracting file:", fn);
+			return processFile(await readFile(fn, {
+				encoding: "utf8",
+				signal
+			}), fn, optsWithThrows);
+		}));
+	} catch (e) {
+		if (shouldThrow) throw e;
+		else warn(String(e));
+	}
+	const formatter = await resolveBuiltinFormatter(opts.format);
+	const extractionResults = rawResults.filter((r) => !!r);
+	const extractedMessages = /* @__PURE__ */ new Map();
+	for (const { messages } of extractionResults) for (const message of messages) {
+		const { id, description, defaultMessage } = message;
+		if (!id) {
+			const error = /* @__PURE__ */ new Error(`[FormatJS CLI] Missing message id for message:
+${JSON.stringify(message, void 0, 2)}`);
+			if (throws) throw error;
+			else warn(error.message);
+			continue;
+		}
+		if (extractedMessages.has(id)) {
+			const existing = extractedMessages.get(id);
+			if (stringify$1(description) !== stringify$1(existing.description) || defaultMessage !== existing.defaultMessage) {
+				const error = /* @__PURE__ */ new Error(`[FormatJS CLI] Duplicate message id: "${id}", but the \`description\` and/or \`defaultMessage\` are different.`);
+				if (throws) throw error;
+				else warn(error.message);
+			}
+		}
+		extractedMessages.set(id, message);
+	}
+	const results = {};
+	const messages = Array.from(extractedMessages.values());
+	for (const { id, ...msg } of messages) results[id] = msg;
+	if (typeof formatter.serialize === "function") return formatter.serialize(formatter.format(results));
+	return stringify$1(formatter.format(results), {
+		space: 2,
+		cmp: formatter.compareMessages || void 0
+	}) ?? "";
+}
+/**
+* Extract strings from source files, also writes to a file.
+* @param files list of files
+* @param extractOpts extract options
+* @returns A Promise that resolves if output file was written successfully
+*/
+async function extractAndWrite(files, extractOpts) {
+	const { outFile, ...opts } = extractOpts;
+	const serializedResult = await extract(files, opts) + "\n";
+	if (outFile) {
+		debug("Writing output file:", outFile);
+		return outputFile(outFile, serializedResult);
+	}
+	await writeStdout(serializedResult);
+}
+//#endregion
+//#region packages/cli-lib/pseudo_locale.ts
+function forEachLiteralElement(ast, fn) {
+	ast.forEach((el) => {
+		if (isLiteralElement(el)) fn(el);
+		else if (isPluralElement(el) || isSelectElement(el)) for (const opt of Object.values(el.options)) forEachLiteralElement(opt.value, fn);
+		else if (isTagElement(el)) forEachLiteralElement(el.children, fn);
+	});
+}
+function generateXXLS(msg) {
+	const ast = typeof msg === "string" ? parse(msg) : msg;
+	const lastChunk = ast[ast.length - 1];
+	if (lastChunk && isLiteralElement(lastChunk)) {
+		lastChunk.value += "SSSSSSSSSSSSSSSSSSSSSSSSS";
+		return ast;
+	}
+	return [...ast, {
+		type: TYPE.literal,
+		value: "SSSSSSSSSSSSSSSSSSSSSSSSS"
+	}];
+}
+function generateXXAC(msg) {
+	const ast = typeof msg === "string" ? parse(msg) : msg;
+	forEachLiteralElement(ast, (el) => {
+		el.value = el.value.toUpperCase();
+	});
+	return ast;
+}
+function generateXXHA(msg) {
+	const ast = typeof msg === "string" ? parse(msg) : msg;
+	const [firstChunk, ...rest] = ast;
+	if (firstChunk && isLiteralElement(firstChunk)) {
+		firstChunk.value = "[javascript]" + firstChunk.value;
+		return [firstChunk, ...rest];
+	}
+	return [{
+		type: TYPE.literal,
+		value: "[javascript]"
+	}, ...ast];
+}
+const ACCENTED_MAP = {
+	"caps": [
+		550,
+		385,
+		391,
+		7698,
+		7702,
+		401,
+		403,
+		294,
+		298,
+		308,
+		310,
+		319,
+		7742,
+		544,
+		510,
+		420,
+		586,
+		344,
+		350,
+		358,
+		364,
+		7804,
+		7814,
+		7818,
+		7822,
+		7824
+	],
+	"small": [
+		551,
+		384,
+		392,
+		7699,
+		7703,
+		402,
+		608,
+		295,
+		299,
+		309,
+		311,
+		320,
+		7743,
+		414,
+		511,
+		421,
+		587,
+		345,
+		351,
+		359,
+		365,
+		7805,
+		7815,
+		7819,
+		7823,
+		7825
+	]
+};
+const FLIPPED_MAP = {
+	"caps": [
+		8704,
+		1296,
+		8579,
+		5601,
+		398,
+		8498,
+		8513,
+		72,
+		73,
+		383,
+		1276,
+		8514,
+		87,
+		78,
+		79,
+		1280,
+		210,
+		7450,
+		83,
+		8869,
+		8745,
+		581,
+		77,
+		88,
+		8516,
+		90
+	],
+	"small": [
+		592,
+		113,
+		596,
+		112,
+		477,
+		607,
+		387,
+		613,
+		305,
+		638,
+		670,
+		645,
+		623,
+		117,
+		111,
+		100,
+		98,
+		633,
+		115,
+		647,
+		110,
+		652,
+		653,
+		120,
+		654,
+		122
+	]
+};
+/**
+* Based on: https://hg.mozilla.org/mozilla-central/file/a1f74e8c8fb72390d22054d6b00c28b1a32f6c43/intl/l10n/L10nRegistry.jsm#l425
+*/
+function transformString(map, elongate = false, msg) {
+	return msg.replace(/[a-z]/gi, (ch) => {
+		const cc = ch.charCodeAt(0);
+		if (cc >= 97 && cc <= 122) {
+			const newChar = String.fromCodePoint(map.small[cc - 97]);
+			if (elongate && (cc === 97 || cc === 101 || cc === 111 || cc === 117)) return newChar + newChar;
+			return newChar;
+		}
+		if (cc >= 65 && cc <= 90) return String.fromCodePoint(map.caps[cc - 65]);
+		return ch;
+	});
+}
+/**
+* accented - Ȧȧƈƈḗḗƞŧḗḗḓ Ḗḗƞɠŀīīşħ
+* --------------------------------
+*
+* This locale replaces all Latin characters with their accented equivalents, and duplicates some
+* vowels to create roughly 30% longer strings. Strings are wrapped in markers (square brackets),
+* which help with detecting truncation.
+*/
+function generateENXA(msg) {
+	const ast = typeof msg === "string" ? parse(msg) : msg;
+	forEachLiteralElement(ast, (el) => {
+		el.value = transformString(ACCENTED_MAP, true, el.value);
+	});
+	return [
+		{
+			type: TYPE.literal,
+			value: "["
+		},
+		...ast,
+		{
+			type: TYPE.literal,
+			value: "]"
+		}
+	];
+}
+/**
+* bidi - ɥsıʅƃuƎ ıpıԐ
+* -------------------
+*
+* This strategy replaces all Latin characters with their 180 degree rotated versions and enforces
+* right to left text flow using Unicode UAX#9 Explicit Directional Embeddings. In this mode, the UI
+* directionality will also be set to right-to-left.
+*/
+function generateENXB(msg) {
+	const ast = typeof msg === "string" ? parse(msg) : msg;
+	forEachLiteralElement(ast, (el) => {
+		el.value = transformString(FLIPPED_MAP, false, el.value);
+	});
+	return [
+		{
+			type: TYPE.literal,
+			value: "‮"
+		},
+		...ast,
+		{
+			type: TYPE.literal,
+			value: "‬"
+		}
+	];
+}
+//#endregion
+//#region packages/cli-lib/compile.ts
+const stringify = stringifyNs.default || stringifyNs;
+/**
+* Aggregate `inputFiles` into a single JSON blob and compile.
+* Also checks for conflicting IDs.
+* Then returns the serialized result as a `string` since key order
+* makes a difference in some vendor.
+* @param inputFiles Input files
+* @param opts Options
+* @returns serialized result in string format
+*/
+async function compile(inputFiles, opts = {}) {
+	debug("Compiling files:", inputFiles);
+	const { ast, format, pseudoLocale, skipErrors, ignoreTag, signal } = opts;
+	signal?.throwIfAborted();
+	const formatter = await resolveBuiltinFormatter(format);
+	const messages = {};
+	const messageAsts = {};
+	const idsWithFileName = {};
+	const compiledFiles = await Promise.all(inputFiles.map((f) => readFile(f, {
+		encoding: "utf8",
+		signal
+	}).then((content) => JSON.parse(content)).then(formatter.compile)));
+	debug("Compiled files:", compiledFiles);
+	for (let i = 0; i < inputFiles.length; i++) {
+		const inputFile = inputFiles[i];
+		debug("Processing file:", inputFile);
+		const compiled = compiledFiles[i];
+		for (const id in compiled) {
+			if (messages[id] && messages[id] !== compiled[id]) throw new Error(`Conflicting ID "${id}" with different translation found in these 2 files:
+ID: ${id}
+Message from ${idsWithFileName[id]}: ${messages[id]}
+Message from ${inputFile}: ${compiled[id]}
+`);
+			try {
+				const msgAst = parse(compiled[id], { ignoreTag });
+				messages[id] = compiled[id];
+				switch (pseudoLocale) {
+					case "xx-LS":
+						messageAsts[id] = generateXXLS(msgAst);
+						break;
+					case "xx-AC":
+						messageAsts[id] = generateXXAC(msgAst);
+						break;
+					case "xx-HA":
+						messageAsts[id] = generateXXHA(msgAst);
+						break;
+					case "en-XA":
+						messageAsts[id] = generateENXA(msgAst);
+						break;
+					case "en-XB":
+						messageAsts[id] = generateENXB(msgAst);
+						break;
+					default:
+						messageAsts[id] = msgAst;
+						break;
+				}
+				idsWithFileName[id] = inputFile;
+			} catch (e) {
+				warn("Error validating message \"%s\" with ID \"%s\" in file \"%s\"", compiled[id], id, inputFile);
+				if (!skipErrors) throw e;
+			}
+		}
+	}
+	return stringify(ast ? messageAsts : messages, {
+		space: 2,
+		cmp: formatter.compareMessages || void 0
+	}) ?? "";
+}
+/**
+* Aggregate `inputFiles` into a single JSON blob and compile.
+* Also checks for conflicting IDs and write output to `outFile`.
+* @param inputFiles Input files
+* @param compileOpts options
+* @returns A `Promise` that resolves if file was written successfully
+*/
+async function compileAndWrite(inputFiles, compileOpts = {}) {
+	const { outFile, ...opts } = compileOpts;
+	const serializedResult = await compile(inputFiles, opts) + "\n";
+	if (outFile) {
+		debug("Writing output file:", outFile);
+		return outputFile(outFile, serializedResult);
+	}
+	await writeStdout(serializedResult);
+}
+//#endregion
+export { compile, compileAndWrite, extract, extractAndWrite };
+
+//# sourceMappingURL=index.js.map