@formatjs/cli-lib 8.3.2 → 8.4.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@formatjs/cli-lib",
   "description": "Lib for CLI for formatjs.",
-  "version": "8.3.2",
+  "version": "8.4.0",
   "license": "MIT",
   "author": "Linjie Ding <linjie@airtable.com>",
   "type": "module",
@@ -23,13 +23,14 @@
     "loud-rejection": "^2",
     "typescript": "^5.6.0",
     "@formatjs/icu-messageformat-parser": "3.5.2",
-    "@formatjs/icu-skeleton-parser": "2.1.2",
-    "@formatjs/ts-transformer": "4.4.1"
+    "@formatjs/ts-transformer": "4.4.1",
+    "@formatjs/icu-skeleton-parser": "2.1.2"
   },
   "peerDependencies": {
     "@glimmer/syntax": "^0.84.3 || ^0.95.0",
     "@vue/compiler-core": "^3.5.0",
     "content-tag": "^4.1.0",
+    "svelte": "^5.0.0",
     "vue": "^3.5.0"
   },
   "bugs": "https://github.com/formatjs/formatjs/issues",
@@ -73,6 +74,9 @@
     },
     "content-tag": {
       "optional": true
+    },
+    "svelte": {
+      "optional": true
     }
   },
   "repository": "formatjs/formatjs.git"

package/src/compile.d.ts

@@ -33,6 +33,10 @@ export interface Opts {
 	* any attributes
 	*/
 	ignoreTag?: boolean;
+	/**
+	* An AbortSignal to cancel the compilation
+	*/
+	signal?: AbortSignal;
 }
 /**
 * Aggregate `inputFiles` into a single JSON blob and compile.

package/src/compile.js

@@ -1,5 +1,6 @@
 import { parse } from "@formatjs/icu-messageformat-parser";
-import { outputFile, readJSON } from "fs-extra/esm";
+import { outputFile } from "fs-extra/esm";
+import { readFile } from "fs/promises";
 import * as stringifyNs from "json-stable-stringify";
 import { debug, warn, writeStdout } from "./console_utils.js";
 import { resolveBuiltinFormatter } from "./formatters/index.js";
@@ -16,12 +17,16 @@ const stringify = stringifyNs.default || stringifyNs;
 */
 export async function compile(inputFiles, opts = {}) {
 	debug("Compiling files:", inputFiles);
-	const { ast, format, pseudoLocale, skipErrors, ignoreTag } = opts;
+	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) => readJSON(f).then(formatter.compile)));
+	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];

package/src/extract.d.ts

@@ -60,6 +60,10 @@ export type ExtractOpts = Opts & {
 	* Whether to hoist selectors & flatten sentences
 	*/
 	flatten?: boolean;
+	/**
+	* An AbortSignal to cancel the extraction
+	*/
+	signal?: AbortSignal;
 } & Pick<Opts, "onMsgExtracted" | "onMetaExtracted">;
 /**
 * Extract strings from source files

package/src/extract.js

@@ -60,6 +60,10 @@ async function processFile(source, fn, { idInterpolationPattern, ...opts }) {
 		debug("Processing %s using vue extractor", fn);
 		const { parseFile } = await import("./vue_extractor.js");
 		parseFile(source, fn, scriptParseFn);
+	} else if (fn.endsWith(".svelte")) {
+		debug("Processing %s using svelte extractor", fn);
+		const { parseFile } = await import("./svelte_extractor.js");
+		parseFile(source, fn, scriptParseFn);
 	} else if (fn.endsWith(".hbs")) {
 		debug("Processing %s using hbs extractor", fn);
 		const { parseFile } = await import("./hbs_extractor.js");
@@ -90,7 +94,7 @@ async function processFile(source, fn, { idInterpolationPattern, ...opts }) {
 * matters for some `format`
 */
 export async function extract(files, extractOpts) {
-	const { throws, readFromStdin, ...opts } = extractOpts;
+	const { throws, readFromStdin, signal, ...opts } = extractOpts;
 	// When throws is not explicitly true, we want to collect partial results
 	const shouldThrow = throws === true;
 	// Pass throws option to transformer for per-message error handling
@@ -114,7 +118,10 @@ export async function extract(files, extractOpts) {
 			if (!shouldThrow) {
 				const settledResults = await Promise.allSettled(files.map(async (fn) => {
 					debug("Extracting file:", fn);
-					const source = await readFile(fn, "utf8");
+					const source = await readFile(fn, {
+						encoding: "utf8",
+						signal
+					});
 					return processFile(source, fn, optsWithThrows);
 				}));
 				rawResults = settledResults.map((result) => {
@@ -128,7 +135,10 @@ export async function extract(files, extractOpts) {
 			} else {
 				rawResults = await Promise.all(files.map(async (fn) => {
 					debug("Extracting file:", fn);
-					const source = await readFile(fn, "utf8");
+					const source = await readFile(fn, {
+						encoding: "utf8",
+						signal
+					});
 					return processFile(source, fn, optsWithThrows);
 				}));
 			}

package/src/svelte_extractor.d.ts

@@ -0,0 +1,2 @@
+export type ScriptParseFn = (source: string) => void;
+export declare function parseFile(source: string, filename: string, parseScriptFn: ScriptParseFn): void;

package/src/svelte_extractor.js

@@ -0,0 +1,117 @@
+import { parse } from "svelte/compiler";
+function walkFragment(fragment, source, parseScriptFn) {
+	if (!fragment || !fragment.nodes) {
+		return;
+	}
+	for (const node of fragment.nodes) {
+		walkNode(node, source, parseScriptFn);
+	}
+}
+function extractExpression(expression, source, parseScriptFn) {
+	if (!expression || expression.start == null || expression.end == null) {
+		return;
+	}
+	const content = source.slice(expression.start, expression.end);
+	try {
+		parseScriptFn(`(${content})`);
+	} catch (e) {
+		console.warn(`Failed to parse "${content}". Ignore this if content has no extractable message`, e);
+	}
+}
+function walkNode(node, source, parseScriptFn) {
+	switch (node.type) {
+		case "ExpressionTag":
+			extractExpression(node.expression, source, parseScriptFn);
+			break;
+		case "ConstTag":
+			// {@const x = expr} — the declaration contains the expression
+			if (node.declaration) {
+				const content = source.slice(node.declaration.start, node.declaration.end);
+				try {
+					parseScriptFn(content);
+				} catch (e) {
+					console.warn(`Failed to parse const declaration. Ignore this if content has no extractable message`, e);
+				}
+			}
+			break;
+		case "IfBlock":
+			extractExpression(node.test, source, parseScriptFn);
+			walkFragment(node.consequent, source, parseScriptFn);
+			walkFragment(node.alternate, source, parseScriptFn);
+			break;
+		case "EachBlock":
+			extractExpression(node.expression, source, parseScriptFn);
+			if (node.key) {
+				extractExpression(node.key, source, parseScriptFn);
+			}
+			walkFragment(node.body, source, parseScriptFn);
+			walkFragment(node.fallback, source, parseScriptFn);
+			break;
+		case "AwaitBlock":
+			extractExpression(node.expression, source, parseScriptFn);
+			walkFragment(node.pending, source, parseScriptFn);
+			walkFragment(node.then, source, parseScriptFn);
+			walkFragment(node.catch, source, parseScriptFn);
+			break;
+		case "KeyBlock":
+			extractExpression(node.expression, source, parseScriptFn);
+			walkFragment(node.fragment, source, parseScriptFn);
+			break;
+		case "SnippetBlock":
+			walkFragment(node.body, source, parseScriptFn);
+			break;
+		case "RegularElement":
+		case "Component":
+		case "SvelteComponent":
+		case "SvelteElement":
+		case "SvelteHead":
+		case "SvelteBody":
+		case "SvelteWindow":
+		case "SvelteDocument":
+		case "SlotElement":
+		case "SvelteSelf":
+		case "SvelteFragment":
+			// Process attributes
+			if (node.attributes) {
+				for (const attr of node.attributes) {
+					if (attr.type === "Attribute") {
+						if (Array.isArray(attr.value)) {
+							for (const v of attr.value) {
+								if (v.type === "ExpressionTag") {
+									extractExpression(v.expression, source, parseScriptFn);
+								}
+							}
+						} else if (typeof attr.value === "object" && attr.value !== null && attr.value.type === "ExpressionTag") {
+							extractExpression(attr.value.expression, source, parseScriptFn);
+						}
+					} else if (attr.type === "SpreadAttribute") {
+						extractExpression(attr.expression, source, parseScriptFn);
+					} else if (attr.expression) {
+						// Directive nodes (OnDirective, BindDirective, etc.)
+						extractExpression(attr.expression, source, parseScriptFn);
+					}
+				}
+			}
+			// Process children
+			walkFragment(node.fragment, source, parseScriptFn);
+			break;
+	}
+}
+export function parseFile(source, filename, parseScriptFn) {
+	const ast = parse(source, {
+		modern: true,
+		filename
+	});
+	// Walk the template fragment
+	walkFragment(ast.fragment, source, parseScriptFn);
+	// Process <script> block
+	if (ast.instance) {
+		const program = ast.instance.content;
+		parseScriptFn(source.slice(program.start, program.end));
+	}
+	// Process <script context="module"> / <script module> block
+	if (ast.module) {
+		const program = ast.module.content;
+		parseScriptFn(source.slice(program.start, program.end));
+	}
+}