@saykit/transform-jsx 0.6.1 → 0.8.0

package/dist/parser.mjs

@@ -1,4 +1,4 @@
-import { AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, validateBranchIdentifier } from "@saykit/config/features/messages";
+import { AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, ElementMessage, LiteralMessage, isArgumentType, validateArgumentStyle, validateBranchIdentifier } from "@saykit/config/features/messages";
 import { unwrapPlaceholder } from "@saykit/transform-js/parser";
 import * as t from "@babel/types";
 //#region src/parser.ts
@@ -14,21 +14,7 @@ function parseJSXContainerElement(element) {
 	const processed = processJSXOpeningElement(element.openingElement);
 	if (!processed) return null;
 	const [accessor] = processed;
-	const children = element.children.reduce((p, c, i, a) => {
-		if (t.isJSXText(c)) {
-			const text = normalizeJSXText(c.value, i === 0, i === a.length - 1);
-			if (text) p.push(new LiteralMessage(text));
-		}
-		if (t.isJSXElement(c)) p.push(parseJSXElement(c, true));
-		else if (t.isJSXFragment(c)) p.push(new ElementMessage(AUTO_INCREMENT_IDENTIFIER, [], c));
-		else if (t.isJSXExpressionContainer(c)) {
-			if (t.isExpression(c.expression)) {
-				const [identifier, value] = unwrapPlaceholder(c.expression);
-				p.push(new ArgumentMessage(identifier, value));
-			}
-		}
-		return p;
-	}, []);
+	const children = buildMessageChildren(element);
 	const descriptorId = findAttributeValueIfStringLiteralAsString(element.openingElement.attributes, "id");
 	const descriptorContext = findAttributeValueIfStringLiteralAsString(element.openingElement.attributes, "context");
 	const whitespace = findAttributeValueAsBoolean(element.openingElement.attributes, "whitespace");
@@ -42,15 +28,23 @@ function parseJSXOpeningElement(element) {
 	const processed = processJSXOpeningElement(element);
 	if (!processed) return null;
 	const [accessor, kind] = processed;
+	const descriptorId = findAttributeValueIfStringLiteralAsString(element.attributes, "id");
+	const descriptorContext = findAttributeValueIfStringLiteralAsString(element.attributes, "context");
+	const wrap = (children) => new CompositeMessage({
+		id: descriptorId,
+		context: descriptorContext
+	}, [], getReferences(element), children, accessor);
 	if (typeof kind === "string" && [
 		"select",
 		"ordinal",
 		"plural"
 	].includes(kind)) {
+		const offset = kind === "select" ? void 0 : findPluralOffset(element.attributes);
 		const branches = element.attributes.reduce((b, a) => {
 			if (!t.isJSXAttribute(a)) return b;
 			let identifier = getAttributeNameAsString(a);
 			if (identifier === "_" || identifier === "id" || identifier === "context") return b;
+			if (offset !== void 0 && identifier === "offset") return b;
 			if (identifier.startsWith("_") && identifier.length > 1 && !Number.isNaN(+identifier.slice(1))) identifier = identifier.slice(1);
 			if (t.isStringLiteral(a.value)) b.push({
 				identifier,
@@ -61,11 +55,13 @@ function parseJSXOpeningElement(element) {
 					identifier,
 					value: parseJSXElement(a.value.expression, true)
 				});
-				else if (t.isJSXFragment(a.value.expression)) b.push({
-					identifier,
-					value: new ElementMessage(AUTO_INCREMENT_IDENTIFIER, [], a.value.expression)
-				});
-				else if (t.isExpression(a.value.expression)) {
+				else if (t.isJSXFragment(a.value.expression)) {
+					const fragment = a.value.expression;
+					b.push({
+						identifier,
+						value: new CompositeMessage({}, [], [], buildMessageChildren(fragment), fragment)
+					});
+				} else if (t.isExpression(a.value.expression)) {
 					const [name, value] = unwrapPlaceholder(a.value.expression);
 					b.push({
 						identifier,
@@ -79,38 +75,88 @@ function parseJSXOpeningElement(element) {
 		const initialiser = findAttributeValueIfExpressionOrStringLiteral(element.attributes, "_");
 		if (!initialiser) return null;
 		const [identifier, selector] = unwrapPlaceholder(initialiser);
-		const choice = new ChoiceMessage(kind, identifier, branches, selector);
-		return new CompositeMessage({
-			id: findAttributeValueIfStringLiteralAsString(element.attributes, "id"),
-			context: findAttributeValueIfStringLiteralAsString(element.attributes, "context")
-		}, [], getReferences(element), [choice], accessor);
+		return wrap([new ChoiceMessage(kind, identifier, branches, selector, offset)]);
+	}
+	if (typeof kind === "string" && isArgumentType(kind)) {
+		const initialiser = findAttributeValueIfExpressionOrStringLiteral(element.attributes, "_");
+		if (!initialiser) return null;
+		const style = findAttributeValueIfStringLiteralAsString(element.attributes, "style");
+		if (style !== void 0) validateArgumentStyle(kind, style);
+		const [identifier, value] = unwrapPlaceholder(initialiser);
+		return wrap([new ArgumentMessage(identifier, value, {
+			type: kind,
+			style
+		})]);
 	}
 	return null;
 }
 /**
-* Punctuation that never takes a space in front of it. A formatter wrapping
-* long JSX regularly strands these at the start of a line, on their own or
-* ahead of the rest of a clause.
+* The `offset` a plural subtracts from its selector before `#` is formatted.
+* See the JS parser's counterpart — the constraints are the same, only the
+* syntax carrying it differs.
 */
-const CLOSING_PUNCTUATION = /^[.,;:!?)\]}»”’]/;
+function findPluralOffset(attributes) {
+	for (const attribute of attributes) {
+		if (!t.isJSXAttribute(attribute)) continue;
+		if (getAttributeNameAsString(attribute) !== "offset") continue;
+		if (!t.isJSXExpressionContainer(attribute.value)) continue;
+		const { expression } = attribute.value;
+		if (!t.isNumericLiteral(expression)) continue;
+		if (!Number.isInteger(expression.value) || expression.value < 0) continue;
+		return expression.value;
+	}
+}
 /**
-* Collapse the whitespace in a JSX text child the way the source reads.
-*
-* A line break between a word and its neighbour is only how a formatter wrapped
-* a long line, so it still means a space. Dropping it would run the words
-* together — and because ids are content hashes, silently orphan every existing
-* translation for the message.
+* The children the JSX transform itself would compile, so a message extracts as
+* the text that renders. Text children come back with their whitespace
+* collapsed the way JSX collapses it — a line break and the indentation around
+* it are layout and disappear, while two lines that both hold text rejoin with
+* the single space that separated the words — every expression container comes
+* back unwrapped, and a comment child comes back as nothing.
+*/
+function buildMessageChildren(element, into = []) {
+	return t.react.buildChildren(element).reduce((p, c) => {
+		const literal = getExpressionAsLiteralText(c);
+		if (literal !== void 0) pushLiteral(p, literal);
+		else if (t.isJSXElement(c)) p.push(parseJSXElement(c, true));
+		else if (t.isJSXFragment(c)) buildMessageChildren(c, p);
+		else if (t.isExpression(c)) {
+			const [identifier, value] = unwrapPlaceholder(c);
+			p.push(new ArgumentMessage(identifier, value));
+		}
+		return p;
+	}, into);
+}
+/**
+* Add text to the message, folding it into the literal in front of it when
+* there is one, so `Hello{' '}world` is three children in the source and one
+* run of text in the catalogue.
+*/
+function pushLiteral(messages, text) {
+	if (!text) return;
+	const last = messages.at(-1);
+	if (last instanceof LiteralMessage) messages[messages.length - 1] = new LiteralMessage(last.text + text);
+	else messages.push(new LiteralMessage(text));
+}
+/**
+* The text a child renders as, when that is knowable at build time — a text
+* child, which `buildChildren` has already collapsed into a string, or an
+* expression holding a literal with nothing interpolated into it.
 *
-* The exception is a line that begins with punctuation, which belongs tight
-* against whatever precedes it. Only an implicit break is treated this way: a
-* space the author wrote on the same line is deliberate and always survives.
+* The second is what makes `{' '}` the way to write whitespace that has to
+* survive a line break: it extracts as the space it renders as, rather than as
+* a placeholder a translator can neither see nor move.
 */
-function normalizeJSXText(value, isFirst, isLast) {
-	let text = value.replace(/\s+/g, " ");
-	if (isFirst) text = text.trimStart();
-	else if (text.startsWith(" ") && /^[^\S\n]*\n/.test(value) && CLOSING_PUNCTUATION.test(text.slice(1))) text = text.slice(1);
-	if (isLast) text = text.trimEnd();
-	return text;
+function getExpressionAsLiteralText(expression) {
+	if (t.isStringLiteral(expression)) return expression.value;
+	if (t.isNumericLiteral(expression)) return String(expression.value);
+	if (t.isUnaryExpression(expression) && (expression.operator === "-" || expression.operator === "+") && t.isNumericLiteral(expression.argument)) return String(expression.operator === "-" ? -expression.argument.value : expression.argument.value);
+	if (t.isBooleanLiteral(expression) || t.isNullLiteral(expression)) return "";
+	if (t.isTemplateLiteral(expression) && expression.expressions.length === 0) {
+		const [chunk] = expression.quasis;
+		/* v8 ignore next */
+		return chunk?.value.cooked ?? "";
+	}
 }
 function processJSXOpeningElement(element) {
 	if (t.isJSXIdentifier(element.name) && element.name.name === "Say") return [element.name, null];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saykit/transform-jsx",
-  "version": "0.6.1",
+  "version": "0.8.0",
   "description": "JSX and TSX source transformer for SayKit",
   "keywords": [
     "i18n",
@@ -47,8 +47,8 @@
     "@babel/parser": "^7.29.7",
     "@babel/traverse": "^7.29.7",
     "@babel/types": "^7.29.7",
-    "@saykit/config": "^0.6.1",
-    "@saykit/transform-js": "^0.6.1"
+    "@saykit/config": "^0.8.0",
+    "@saykit/transform-js": "^0.8.0"
   },
   "devDependencies": {
     "@babel/core": "^7.29.7",