@saykit/transform-js 0.0.0 → 0.1.0

package/README.md

@@ -0,0 +1,34 @@
+# @saykit/transform-js
+
+> JavaScript and TypeScript transformer for [SayKit](https://saykit.js.org).
+
+Extracts and rewrites SayKit macros in `.js`, `.cjs`, `.mjs`, `.ts`, `.mts`, and `.cts` files. Used inside a `saykit.config.ts` bucket.
+
+## Install
+
+```sh
+pnpm add -D @saykit/transform-js
+```
+
+## Usage
+
+```ts title="saykit.config.ts"
+import js from '@saykit/transform-js';
+
+// inside a bucket:
+transformer: js();
+```
+
+For JSX/TSX, combine with [`@saykit/transform-jsx`](https://github.com/k0d13/saykit/tree/main/packages/transform-jsx):
+
+```ts
+import js from '@saykit/transform-js';
+import jsx from '@saykit/transform-jsx';
+
+// inside a bucket:
+transformer: [js(), jsx()];
+```
+
+## Documentation
+
+See [saykit.js.org](https://saykit.js.org).

package/dist/generator.d.mts

@@ -0,0 +1,7 @@
+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
+export { generateSayCallExpression };

package/dist/generator.mjs

@@ -0,0 +1,26 @@
+import { ArgumentMessage, ChoiceMessage, CompositeMessage, ElementMessage } from "@saykit/config/features/messages";
+import * as t from "@babel/types";
+//#region src/generator.ts
+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))]);
+	return t.callExpression(t.memberExpression(message.accessor, t.identifier("call")), [properties]);
+}
+function generateChildExpressions(messages) {
+	return messages.reduce((c, m) => {
+		if (m instanceof ArgumentMessage) c.push([String(m.identifier), m.expression]);
+		if (m instanceof ElementMessage) {
+			c.push([String(m.identifier), m.expression]);
+			c.push(...generateChildExpressions(m.children));
+		}
+		if (m instanceof ChoiceMessage) {
+			c.push([String(m.identifier), m.expression]);
+			c.push(...generateChildExpressions(m.branches.map((b) => b.value)));
+		}
+		if (m instanceof CompositeMessage) c.push(...generateChildExpressions(m.children));
+		return c;
+	}, []);
+}
+//#endregion
+export { generateSayCallExpression };

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -0,0 +1,78 @@
+import { generateSayCallExpression } from "./generator.mjs";
+import { parseExpression } from "./parser.mjs";
+import { generate } from "@babel/generator";
+import * as parser from "@babel/parser";
+import traverse_ from "@babel/traverse";
+import { assignSequenceIdentifiers } from "@saykit/config/features/messages";
+//#region src/index.ts
+const traverse = traverse_.default || traverse_;
+function createProgram(code, id) {
+	const program = parser.parse(code, {
+		sourceType: "module",
+		sourceFilename: id,
+		plugins: ["typescript"],
+		allowImportExportEverywhere: false,
+		allowReturnOutsideFunction: true,
+		ranges: true,
+		attachComment: true,
+		tokens: true
+	});
+	return Object.assign(program, { toString() {
+		return generate(program, {
+			retainLines: true,
+			comments: true,
+			compact: false
+		}).code;
+	} });
+}
+function createJsTransformer() {
+	return {
+		match(id) {
+			return [
+				".js",
+				".cjs",
+				".mjs",
+				".ts",
+				".mts",
+				".cts"
+			].some((e) => id.endsWith(e));
+		},
+		extract(code, id) {
+			const program = createProgram(code, id);
+			const messages = [];
+			traverse(program, { Expression(path) {
+				path.node.leadingComments = path.node.leadingComments ?? [];
+				const message = parseExpression(path.node);
+				if (message) {
+					assignSequenceIdentifiers(message, { current: 0 });
+					messages.push(message);
+					path.skip();
+				}
+			} });
+			return messages.map((message) => ({
+				message: message.toICUString(),
+				translation: void 0,
+				id: message.descriptor.id,
+				context: message.descriptor.context,
+				comments: message.comments,
+				references: message.references
+			}));
+		},
+		transform(code, id) {
+			const program = createProgram(code, id);
+			traverse(program, { Expression(path) {
+				path.node.leadingComments = path.node.leadingComments ?? [];
+				const message = parseExpression(path.node);
+				if (message) {
+					assignSequenceIdentifiers(message, { current: 0 });
+					const replacement = generateSayCallExpression(message);
+					path.replaceWith(replacement);
+					path.skip();
+				}
+			} });
+			return program.toString();
+		}
+	};
+}
+//#endregion
+export { createJsTransformer as default };

package/dist/parser.d.mts

@@ -0,0 +1,11 @@
+import { 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;
+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 };

package/dist/parser.mjs

@@ -0,0 +1,125 @@
+import { AUTO_INCREMENT_IDENTIFIER, ArgumentMessage, ChoiceMessage, CompositeMessage, LiteralMessage } from "@saykit/config/features/messages";
+import * as t from "@babel/types";
+//#region src/parser.ts
+function parseTaggedTemplateExpression(tagged) {
+	const processed = processExpression(tagged.tag);
+	if (!processed) return null;
+	const [accessor, descriptor] = processed;
+	const children = tagged.quasi.quasis.reduce((c, q, i) => {
+		c.push(new LiteralMessage(q.value.cooked ?? q.value.raw));
+		if (t.isExpression(tagged.quasi.expressions[i])) c.push(parseExpression(tagged.quasi.expressions[i], true));
+		return c;
+	}, []);
+	return new CompositeMessage({
+		id: descriptor ? findPropertyValueIfStringLiteralAsString(descriptor, "id") : void 0,
+		context: descriptor ? findPropertyValueIfStringLiteralAsString(descriptor, "context") : void 0
+	}, getTranslatorComments(tagged.leadingComments ?? []), tagged.loc ? [`${tagged.loc.filename}:${tagged.loc.start.line}`] : [], children, accessor);
+}
+function parseCallExpression(call) {
+	const processed = processExpression(call.callee);
+	if (!processed) return null;
+	const [accessor, descriptor, kind] = processed;
+	if (typeof kind === "string" && [
+		"select",
+		"ordinal",
+		"plural"
+	].includes(kind)) {
+		if (call.arguments.length !== 2) return null;
+		if (!t.isExpression(call.arguments[0])) return null;
+		if (!t.isObjectExpression(call.arguments[1])) return null;
+		const branches = call.arguments[1].properties.reduce((c, p) => {
+			if (!t.isObjectProperty(p) || !t.isExpression(p.value)) return c;
+			let message = null;
+			if (!message && t.isStringLiteral(p.value)) message = new LiteralMessage(p.value.value);
+			if (!message) message = parseExpression(p.value, true);
+			c.push({
+				identifier: getPropertyNameAsString(p.key),
+				value: message
+			});
+			return c;
+		}, []);
+		const value = call.arguments[0];
+		const choice = new ChoiceMessage(kind, getExpressionAsKey(value), branches, value);
+		return new CompositeMessage({
+			id: descriptor ? findPropertyValueIfStringLiteralAsString(descriptor, "id") : void 0,
+			context: descriptor ? findPropertyValueIfStringLiteralAsString(descriptor, "context") : void 0
+		}, [], call.loc ? [`${call.loc.filename}:${call.loc.start.line}`] : [], [choice], accessor);
+	}
+	return null;
+}
+function processExpression(expression) {
+	if (t.isIdentifier(expression) && expression.name === "say") return [
+		expression,
+		null,
+		null
+	];
+	if (t.isCallExpression(expression)) {
+		const inner = processExpression(expression.callee);
+		if (inner && expression.arguments.length === 1 && t.isObjectExpression(expression.arguments[0])) return [
+			inner[0],
+			expression.arguments[0],
+			null
+		];
+		else if (inner) return [
+			inner[0],
+			null,
+			null
+		];
+	}
+	if (t.isMemberExpression(expression)) {
+		const innerProperty = processExpression(expression.property);
+		if (innerProperty) return [
+			expression,
+			innerProperty[1],
+			null
+		];
+		const innerObject = processExpression(expression.object);
+		if (innerObject && t.isIdentifier(expression.property)) return [
+			innerObject[0],
+			innerObject[1],
+			expression.property.name
+		];
+	}
+	return null;
+}
+function getExpressionAsKey(node) {
+	if (t.isIdentifier(node)) return node.name;
+	if (t.isJSXIdentifier(node)) return node.name;
+	return AUTO_INCREMENT_IDENTIFIER;
+}
+function parseExpression(expression, fallback) {
+	let message = null;
+	switch (true) {
+		case t.isTaggedTemplateExpression(expression):
+			message = parseTaggedTemplateExpression(expression);
+			break;
+		case t.isCallExpression(expression):
+			message = parseCallExpression(expression);
+			break;
+	}
+	if (message) return message;
+	else if (fallback) return new ArgumentMessage(getExpressionAsKey(expression), expression);
+	else return null;
+}
+function getPropertyNameAsString(key) {
+	if (t.isIdentifier(key)) return key.name;
+	if (t.isStringLiteral(key)) return key.value;
+	if (t.isNumericLiteral(key)) return key.value.toString();
+	if (t.isBigIntLiteral(key)) return key.value.toString();
+	return AUTO_INCREMENT_IDENTIFIER;
+}
+function findPropertyValueIfStringLiteralAsString(object, key) {
+	for (const property of object.properties) {
+		if (!t.isObjectProperty(property)) continue;
+		if (t.isIdentifier(property.key) && property.key.name === key && t.isStringLiteral(property.value)) return property.value.value;
+	}
+}
+function getTranslatorComments(comments) {
+	return comments.reduce((a, c) => {
+		const text = c.value.trim();
+		if (text.toLowerCase().startsWith("translators:")) a.push(text.slice(12).trim());
+		return a;
+	}, []);
+}
+//#endregion
+export { parseCallExpression, parseExpression, parseTaggedTemplateExpression, processExpression };

package/package.json

@@ -1,4 +1,64 @@
-{
-  "name": "@saykit/transform-js",
-  "version": "0.0.0"
+{
+  "name": "@saykit/transform-js",
+  "version": "0.1.0",
+  "description": "JavaScript and TypeScript transformer for SayKit",
+  "keywords": [
+    "i18n",
+    "javascript",
+    "saykit",
+    "transformer",
+    "typescript"
+  ],
+  "homepage": "https://github.com/k0d13/saykit#readme",
+  "bugs": {
+    "url": "https://github.com/k0d13/saykit/issues"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/k0d13/saykit.git",
+    "directory": "packages/transform-js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    },
+    "./parser": {
+      "types": "./dist/parser.d.mts",
+      "default": "./dist/parser.mjs"
+    },
+    "./generator": {
+      "types": "./dist/generator.d.mts",
+      "default": "./dist/generator.mjs"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "@babel/generator": "^7.29.1",
+    "@babel/parser": "^7.29.3",
+    "@babel/traverse": "^7.29.0",
+    "@babel/types": "^7.29.0",
+    "@saykit/config": "^0.1.0"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.29.0",
+    "@types/babel__core": "^7.20.5",
+    "@types/babel__generator": "^7.27.0",
+    "@types/babel__traverse": "^7.28.0"
+  },
+  "scripts": {
+    "check": "tsc --noEmit",
+    "test": "vitest",
+    "coverage": "vitest run --coverage",
+    "build": "tsdown"
+  }
 }