@saykit/transform-js 0.4.1 → 0.6.0

package/dist/generator.d.mts

@@ -1,6 +1,5 @@
 import { CompositeMessage } from "@saykit/config/features/messages";
 import * as t from "@babel/types";
-
 //#region src/generator.d.ts
 declare function generateSayCallExpression(message: CompositeMessage): t.CallExpression;
 //#endregion

package/dist/generator.mjs

@@ -4,7 +4,7 @@ import * as t from "@babel/types";
 function generateSayCallExpression(message) {
 	const id = message.descriptor.id ?? message.toHashString();
 	const children = generateChildExpressions(message.children);
-	const properties = t.objectExpression([t.objectProperty(t.identifier("id"), t.stringLiteral(id)), ...children.map(([ident, expr]) => t.objectProperty(t.identifier(ident), expr))]);
+	const properties = t.objectExpression([t.objectProperty(t.identifier("id"), t.stringLiteral(id)), ...[...new Map(children).entries()].map(([ident, expr]) => t.objectProperty(t.identifier(`_${ident}`), expr))]);
 	return t.callExpression(t.memberExpression(message.accessor, t.identifier("call")), [properties]);
 }
 function generateChildExpressions(messages) {

package/dist/index.d.mts

@@ -1,5 +1,4 @@
 import { Transformer } from "@saykit/config";
-
 //#region src/index.d.ts
 declare function createJsTransformer(): Transformer;
 //#endregion

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { generateSayCallExpression } from "./generator.mjs";
-import { parseExpression } from "./parser.mjs";
+import { isEquivalentPlaceholder, parseExpression } from "./parser.mjs";
 import { generate } from "@babel/generator";
 import * as parser from "@babel/parser";
 import traverse_ from "@babel/traverse";
@@ -44,7 +44,7 @@ function createJsTransformer() {
 				path.node.leadingComments = path.node.leadingComments ?? [];
 				const message = parseExpression(path.node);
 				if (message) {
-					assignSequenceIdentifiers(message, { current: 0 });
+					assignSequenceIdentifiers(message, { current: 0 }, isEquivalentPlaceholder);
 					messages.push(message);
 					path.skip();
 				}
@@ -64,7 +64,7 @@ function createJsTransformer() {
 				path.node.leadingComments = path.node.leadingComments ?? [];
 				const message = parseExpression(path.node);
 				if (message) {
-					assignSequenceIdentifiers(message, { current: 0 });
+					assignSequenceIdentifiers(message, { current: 0 }, isEquivalentPlaceholder);
 					const replacement = generateSayCallExpression(message);
 					path.replaceWith(replacement);
 					path.skip();

package/dist/parser.d.mts

@@ -1,11 +1,32 @@
-import { ArgumentMessage, CompositeMessage } from "@saykit/config/features/messages";
+import { AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, CompositeMessage } from "@saykit/config/features/messages";
 import * as t from "@babel/types";
-
 //#region src/parser.d.ts
 declare function parseTaggedTemplateExpression(tagged: t.TaggedTemplateExpression): CompositeMessage | null;
 declare function parseCallExpression(call: t.CallExpression): CompositeMessage | null;
 declare function processExpression(expression: t.Node): [t.Expression, t.ObjectExpression | null, string | null] | null;
+/**
+ * Read the name off a value written as a single-key object and hand back the
+ * value alone, so the wrapper never reaches the output: `${{ total: sum() }}`
+ * is `{total}` rather than `{0}`.
+ *
+ * An inline one-key object is the only shape this claims, and it is a shape
+ * that could not mean anything else — interpolating an object stringifies it
+ * to `[object Object]`, and rendering one in JSX throws. Anything else is
+ * returned untouched and named the way it always was.
+ */
+declare function unwrapPlaceholder(expression: t.Expression): [string | typeof AUTO_INCREMENT_IDENTIFIER, t.Expression];
+/**
+ * Whether two placeholders sharing a name are the same placeholder, and so
+ * compile to one prop a translator can move around the sentence freely.
+ *
+ * A value is compared whole: the same variable interpolated twice is one value,
+ * while `${name}` beside `${{ name: author.name }}` is two things claiming one
+ * name. An element is compared on its opening element alone — `say-tag` has
+ * been stripped by the time this runs, and its children come from the
+ * translation rather than the source.
+ */
+declare function isEquivalentPlaceholder(a: any, b: any): boolean;
 declare function parseExpression(expression: t.Expression, fallback?: false): CompositeMessage | null;
 declare function parseExpression(expression: t.Expression, fallback: true): CompositeMessage | ArgumentMessage;
 //#endregion
-export { parseCallExpression, parseExpression, parseTaggedTemplateExpression, processExpression };
+export { isEquivalentPlaceholder, parseCallExpression, parseExpression, parseTaggedTemplateExpression, processExpression, unwrapPlaceholder };

package/dist/parser.mjs

@@ -1,6 +1,7 @@
 import { AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, LiteralMessage } from "@saykit/config/features/messages";
 import * as t from "@babel/types";
 //#region src/parser.ts
+const PLACEHOLDER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
 function parseTaggedTemplateExpression(tagged) {
 	const processed = processExpression(tagged.tag);
 	if (!processed) return null;
@@ -38,8 +39,8 @@ function parseCallExpression(call) {
 			});
 			return c;
 		}, []);
-		const value = call.arguments[0];
-		const choice = new ChoiceMessage(kind, getExpressionAsKey(value), branches, value);
+		const [identifier, value] = unwrapPlaceholder(call.arguments[0]);
+		const choice = new ChoiceMessage(kind, identifier, branches, value);
 		return new CompositeMessage({
 			id: descriptor ? findPropertyValueIfStringLiteralAsString(descriptor, "id") : void 0,
 			context: descriptor ? findPropertyValueIfStringLiteralAsString(descriptor, "context") : void 0
@@ -88,6 +89,44 @@ function getExpressionAsKey(node) {
 	if (t.isJSXIdentifier(node)) return node.name;
 	return AUTO_INCREMENT_IDENTIFIER;
 }
+/**
+* Read the name off a value written as a single-key object and hand back the
+* value alone, so the wrapper never reaches the output: `${{ total: sum() }}`
+* is `{total}` rather than `{0}`.
+*
+* An inline one-key object is the only shape this claims, and it is a shape
+* that could not mean anything else — interpolating an object stringifies it
+* to `[object Object]`, and rendering one in JSX throws. Anything else is
+* returned untouched and named the way it always was.
+*/
+function unwrapPlaceholder(expression) {
+	if (!t.isObjectExpression(expression) || expression.properties.length !== 1) return [getExpressionAsKey(expression), expression];
+	const [property] = expression.properties;
+	if (!t.isObjectProperty(property) || property.computed || !t.isExpression(property.value)) return [getExpressionAsKey(expression), expression];
+	const name = getPropertyNameAsString(property.key);
+	/* v8 ignore next */
+	if (typeof name !== "string") return [getExpressionAsKey(expression), expression];
+	if (!PLACEHOLDER_PATTERN.test(name)) throw new Error(`Invalid placeholder name '${name}', expected a letter or underscore followed by letters, digits, or underscores`);
+	return [name, property.value];
+}
+/**
+* Whether two placeholders sharing a name are the same placeholder, and so
+* compile to one prop a translator can move around the sentence freely.
+*
+* A value is compared whole: the same variable interpolated twice is one value,
+* while `${name}` beside `${{ name: author.name }}` is two things claiming one
+* name. An element is compared on its opening element alone — `say-tag` has
+* been stripped by the time this runs, and its children come from the
+* translation rather than the source.
+*/
+function isEquivalentPlaceholder(a, b) {
+	if (t.isJSXElement(a) || t.isJSXElement(b)) {
+		if (!t.isJSXElement(a) || !t.isJSXElement(b)) return false;
+		return t.isNodesEquivalent(a.openingElement, b.openingElement);
+	}
+	if (!t.isNode(a) || !t.isNode(b)) return false;
+	return t.isNodesEquivalent(a, b);
+}
 function parseExpression(expression, fallback) {
 	let message = null;
 	switch (true) {
@@ -99,8 +138,14 @@ function parseExpression(expression, fallback) {
 			break;
 	}
 	if (message) return message;
-	else if (fallback) return new ArgumentMessage(getExpressionAsKey(expression), expression);
-	else return null;
+	else if (fallback) {
+		const [key, value] = unwrapPlaceholder(expression);
+		if (value !== expression) {
+			const nested = parseExpression(value);
+			if (nested) return nested;
+		}
+		return new ArgumentMessage(key, value);
+	} else return null;
 }
 function getPropertyNameAsString(key) {
 	if (t.isIdentifier(key)) return key.name;
@@ -123,4 +168,4 @@ function getTranslatorComments(comments) {
 	}, []);
 }
 //#endregion
-export { parseCallExpression, parseExpression, parseTaggedTemplateExpression, processExpression };
+export { isEquivalentPlaceholder, parseCallExpression, parseExpression, parseTaggedTemplateExpression, processExpression, unwrapPlaceholder };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saykit/transform-js",
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "JavaScript and TypeScript transformer for SayKit",
   "keywords": [
     "i18n",
@@ -47,7 +47,7 @@
     "@babel/parser": "^7.29.7",
     "@babel/traverse": "^7.29.7",
     "@babel/types": "^7.29.7",
-    "@saykit/config": "^0.4.1"
+    "@saykit/config": "^0.6.0"
   },
   "devDependencies": {
     "@babel/core": "^7.29.7",