@formatjs/cli-lib 8.0.8 → 8.1.1

package/src/compile.js

@@ -1,91 +1,90 @@
-import { parse } from '@formatjs/icu-messageformat-parser';
-import { outputFile, readJSON } from 'fs-extra/esm';
-import * as stringifyNs from 'json-stable-stringify';
-import { debug, warn, writeStdout } from './console_utils.js';
-import { resolveBuiltinFormatter } from './formatters/index.js';
-import { generateENXA, generateENXB, generateXXAC, generateXXHA, generateXXLS, } from './pseudo_locale.js';
+import { parse } from "@formatjs/icu-messageformat-parser";
+import { outputFile, readJSON } from "fs-extra/esm";
+import * as stringifyNs from "json-stable-stringify";
+import { debug, warn, writeStdout } from "./console_utils.js";
+import { resolveBuiltinFormatter } from "./formatters/index.js";
+import { generateENXA, generateENXB, generateXXAC, generateXXHA, generateXXLS } from "./pseudo_locale.js";
 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
- */
+* 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
+*/
 export async function compile(inputFiles, opts = {}) {
-    debug('Compiling files:', inputFiles);
-    const { ast, format, pseudoLocale, skipErrors, ignoreTag } = opts;
-    const formatter = await resolveBuiltinFormatter(format);
-    const messages = {};
-    const messageAsts = {};
-    const idsWithFileName = {};
-    const compiledFiles = await Promise.all(inputFiles.map(f => readJSON(f).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:
+	debug("Compiling files:", inputFiles);
+	const { ast, format, pseudoLocale, skipErrors, ignoreTag } = opts;
+	const formatter = await resolveBuiltinFormatter(format);
+	const messages = {};
+	const messageAsts = {};
+	const idsWithFileName = {};
+	const compiledFiles = await Promise.all(inputFiles.map((f) => readJSON(f).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 || undefined,
-    }) ?? '');
+			}
+			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 || undefined
+	}) ?? "";
 }
 /**
- * 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
- */
+* 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
+*/
 export default 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);
+	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);
 }

package/src/compile_folder.d.ts

@@ -1,2 +1,2 @@
-import { Opts } from './compile.js';
+import { type Opts } from "./compile.js";
 export default function compileFolder(files: string[], outFolder: string, opts?: Opts): Promise<void[]>;

package/src/compile_folder.js

@@ -1,8 +1,8 @@
-import { outputFile } from 'fs-extra/esm';
-import { basename, join } from 'path';
-import { compile } from './compile.js';
+import { outputFile } from "fs-extra/esm";
+import { basename, join } from "path";
+import { compile } from "./compile.js";
 export default async function compileFolder(files, outFolder, opts = {}) {
-    const results = await Promise.all(files.map(f => compile([f], opts)));
-    const outFiles = files.map(f => join(outFolder, basename(f)));
-    return Promise.all(outFiles.map((outFile, i) => outputFile(outFile, results[i])));
+	const results = await Promise.all(files.map((f) => compile([f], opts)));
+	const outFiles = files.map((f) => join(outFolder, basename(f)));
+	return Promise.all(outFiles.map((outFile, i) => outputFile(outFile, results[i])));
 }

package/src/console_utils.d.ts

@@ -1,6 +1,8 @@
 export declare const writeStderr: (arg1: string | Uint8Array) => Promise<void>;
 export declare const writeStdout: (arg1: string | Uint8Array) => Promise<void>;
-export declare function clearLine(terminal: (typeof process)['stderr']): Promise<void>;
+// From:
+// https://github.com/yarnpkg/yarn/blob/53d8004229f543f342833310d5af63a4b6e59c8a/src/reporters/console/util.js
+export declare function clearLine(terminal: (typeof process)["stderr"]): Promise<void>;
 export declare function debug(message: string, ...args: any[]): Promise<void>;
 export declare function warn(message: string, ...args: any[]): Promise<void>;
 export declare function error(message: string, ...args: any[]): Promise<void>;

package/src/console_utils.js

@@ -1,6 +1,6 @@
-import * as chalkNs from 'chalk';
-import { clearLine as nativeClearLine, cursorTo as nativeCursorTo, } from 'readline';
-import { format, promisify } from 'util';
+import * as chalkNs from "chalk";
+import { clearLine as nativeClearLine, cursorTo as nativeCursorTo } from "readline";
+import { format, promisify } from "util";
 const chalk = chalkNs.default ?? chalkNs;
 const CLEAR_WHOLE_LINE = 0;
 export const writeStderr = promisify(process.stderr.write).bind(process.stderr);
@@ -8,59 +8,57 @@ export const writeStdout = promisify(process.stdout.write).bind(process.stdout);
 // From:
 // https://github.com/yarnpkg/yarn/blob/53d8004229f543f342833310d5af63a4b6e59c8a/src/reporters/console/util.js
 export async function clearLine(terminal) {
-    if (!chalk.supportsColor) {
-        if (terminal.isTTY) {
-            // terminal
-            if (terminal.columns > 0) {
-                await writeStderr(`\r${' '.repeat(terminal.columns - 1)}`);
-            }
-            await writeStderr(`\r`);
-        }
-        // ignore piping to file
-    }
-    else {
-        nativeClearLine(terminal, CLEAR_WHOLE_LINE);
-        nativeCursorTo(terminal, 0, undefined);
-    }
+	if (!chalk.supportsColor) {
+		if (terminal.isTTY) {
+			// terminal
+			if (terminal.columns > 0) {
+				await writeStderr(`\r${" ".repeat(terminal.columns - 1)}`);
+			}
+			await writeStderr(`\r`);
+		}
+	} else {
+		nativeClearLine(terminal, CLEAR_WHOLE_LINE);
+		nativeCursorTo(terminal, 0, undefined);
+	}
 }
 const LEVEL_COLORS = {
-    debug: chalk.green,
-    warn: chalk.yellow,
-    error: chalk.red,
+	debug: chalk.green,
+	warn: chalk.yellow,
+	error: chalk.red
 };
 function label(level, message) {
-    return `[@formatjs/cli] [${LEVEL_COLORS[level](level.toUpperCase())}] ${message}`;
+	return `[@formatjs/cli] [${LEVEL_COLORS[level](level.toUpperCase())}] ${message}`;
 }
 export async function debug(message, ...args) {
-    if (process.env.LOG_LEVEL !== 'debug') {
-        return;
-    }
-    await clearLine(process.stderr);
-    await writeStderr(format(label('debug', message), ...args));
-    await writeStderr('\n');
+	if (process.env.LOG_LEVEL !== "debug") {
+		return;
+	}
+	await clearLine(process.stderr);
+	await writeStderr(format(label("debug", message), ...args));
+	await writeStderr("\n");
 }
 export async function warn(message, ...args) {
-    await clearLine(process.stderr);
-    await writeStderr(format(label('warn', message), ...args));
-    await writeStderr('\n');
+	await clearLine(process.stderr);
+	await writeStderr(format(label("warn", message), ...args));
+	await writeStderr("\n");
 }
 export async function error(message, ...args) {
-    await clearLine(process.stderr);
-    await writeStderr(format(label('error', message), ...args));
-    await writeStderr('\n');
+	await clearLine(process.stderr);
+	await writeStderr(format(label("error", message), ...args));
+	await writeStderr("\n");
 }
 export function getStdinAsString() {
-    let result = '';
-    return new Promise(resolve => {
-        process.stdin.setEncoding('utf-8');
-        process.stdin.on('readable', () => {
-            let chunk;
-            while ((chunk = process.stdin.read())) {
-                result += chunk;
-            }
-        });
-        process.stdin.on('end', () => {
-            resolve(result);
-        });
-    });
+	let result = "";
+	return new Promise((resolve) => {
+		process.stdin.setEncoding("utf-8");
+		process.stdin.on("readable", () => {
+			let chunk;
+			while (chunk = process.stdin.read()) {
+				result += chunk;
+			}
+		});
+		process.stdin.on("end", () => {
+			resolve(result);
+		});
+	});
 }

package/src/extract.d.ts

@@ -1,78 +1,78 @@
-import { MessageDescriptor, Opts } from '@formatjs/ts-transformer';
-import { Formatter } from './formatters/index.js';
+import { type MessageDescriptor, type Opts } from "@formatjs/ts-transformer";
+import { type Formatter } from "./formatters/index.js";
 export interface ExtractionResult<M = Record<string, string>> {
-    /**
-     * List of extracted messages
-     */
-    messages: MessageDescriptor[];
-    /**
-     * Metadata extracted w/ `pragma`
-     */
-    meta?: M;
+	/**
+	* List of extracted messages
+	*/
+	messages: MessageDescriptor[];
+	/**
+	* Metadata extracted w/ `pragma`
+	*/
+	meta?: M;
 }
 export interface ExtractedMessageDescriptor extends MessageDescriptor {
-    /**
-     * Line number
-     */
-    line?: number;
-    /**
-     * Column number
-     */
-    col?: number;
-    /**
-     * Metadata extracted from pragma
-     */
-    meta?: Record<string, string>;
+	/**
+	* Line number
+	*/
+	line?: number;
+	/**
+	* Column number
+	*/
+	col?: number;
+	/**
+	* Metadata extracted from pragma
+	*/
+	meta?: Record<string, string>;
 }
-export type ExtractCLIOptions = Omit<ExtractOpts, 'overrideIdFn' | 'onMsgExtracted' | 'onMetaExtracted'> & {
-    /**
-     * Output File
-     */
-    outFile?: string;
-    /**
-     * Input File
-     */
-    inFile?: string;
-    /**
-     * Ignore file glob pattern
-     */
-    ignore?: string[];
+export type ExtractCLIOptions = Omit<ExtractOpts, "overrideIdFn" | "onMsgExtracted" | "onMetaExtracted"> & {
+	/**
+	* Output File
+	*/
+	outFile?: string;
+	/**
+	* Input File
+	*/
+	inFile?: string;
+	/**
+	* Ignore file glob pattern
+	*/
+	ignore?: string[];
 };
 export type ExtractOpts = Opts & {
-    /**
-     * Whether to throw an error if we had any issues with
-     * 1 of the source files
-     */
-    throws?: boolean;
-    /**
-     * Message ID interpolation pattern
-     */
-    idInterpolationPattern?: string;
-    /**
-     * Whether we read from stdin instead of a file
-     */
-    readFromStdin?: boolean;
-    /**
-     * Either path to a formatter file that controls the shape of JSON file from `outFile` or {@link Formatter} object.
-     */
-    format?: string | Formatter<any>;
-    /**
-     * Whether to hoist selectors & flatten sentences
-     */
-    flatten?: boolean;
-} & Pick<Opts, 'onMsgExtracted' | 'onMetaExtracted'>;
+	/**
+	* Whether to throw an error if we had any issues with
+	* 1 of the source files
+	*/
+	throws?: boolean;
+	/**
+	* Message ID interpolation pattern
+	*/
+	idInterpolationPattern?: string;
+	/**
+	* Whether we read from stdin instead of a file
+	*/
+	readFromStdin?: boolean;
+	/**
+	* Either path to a formatter file that controls the shape of JSON file from `outFile` or {@link Formatter} object.
+	*/
+	format?: string | Formatter<any>;
+	/**
+	* Whether to hoist selectors & flatten sentences
+	*/
+	flatten?: boolean;
+} & Pick<Opts, "onMsgExtracted" | "onMetaExtracted">;
 /**
- * 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`
- */
+* 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`
+*/
 export declare function extract(files: readonly string[], extractOpts: ExtractOpts): Promise<string>;
 /**
- * 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
- */
+* 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
+*/
 export default function extractAndWrite(files: readonly string[], extractOpts: ExtractCLIOptions): Promise<void>;