@linguanahq/compiler 0.1.0 → 0.1.2

package/dist/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/transform.d.ts

@@ -0,0 +1,17 @@
+import generateImport from "@babel/generator";
+import { type Diagnostic, type ManifestMessage } from "@linguanahq/catalog";
+export type TransformOptions = {
+    sourceLocale: string;
+    root?: string;
+    runtimePackage?: string;
+    compilerRuntime?: string;
+};
+declare const generate: typeof generateImport;
+export type TransformResult = {
+    code: string;
+    map: ReturnType<typeof generate>["map"];
+    messages: ManifestMessage[];
+    diagnostics: Diagnostic[];
+};
+export declare function transformSource(code: string, filename: string, options: TransformOptions): TransformResult;
+export {};

package/dist/transform.js

@@ -0,0 +1,468 @@
+// src/transform.ts
+import { relative } from "node:path";
+import generateImport from "@babel/generator";
+import { parse } from "@babel/parser";
+import traverseImport from "@babel/traverse";
+import * as t from "@babel/types";
+import {
+  contentHash,
+  normalizeSource,
+  parseMessagePlaceholders,
+  stableMessageId
+} from "@linguanahq/catalog";
+var generate = generateImport.default ?? generateImport;
+var traverse = traverseImport.default ?? traverseImport;
+var EXCLUDED_ELEMENTS = /* @__PURE__ */ new Set(["script", "style", "code", "pre"]);
+var ALLOWED_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "title",
+  "placeholder",
+  "aria-label",
+  "alt",
+  "label",
+  "value"
+]);
+var MACHINE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "id",
+  "class",
+  "className",
+  "name",
+  "role",
+  "href",
+  "src",
+  "action",
+  "method",
+  "data-testid",
+  "data-test-id",
+  "data-analytics",
+  "data-event"
+]);
+function jsxName(node) {
+  if (t.isJSXIdentifier(node)) return node.name;
+  if (t.isJSXMemberExpression(node)) return jsxName(node.property);
+  return `${node.namespace.name}:${node.name.name}`;
+}
+function renderedJsxText(value) {
+  const lines = value.replace(/\r\n?/g, "\n").split("\n");
+  let result = "";
+  for (let index = 0; index < lines.length; index += 1) {
+    let line = lines[index]?.replace(/\t/g, " ") ?? "";
+    if (index !== 0) line = line.replace(/^\s+/, "");
+    if (index !== lines.length - 1) line = line.replace(/\s+$/, "");
+    if (!line) continue;
+    if (result && !result.endsWith(" ")) result += " ";
+    result += line;
+  }
+  return result;
+}
+function location(path, root, filename) {
+  const start = path.node.loc?.start;
+  return {
+    file: relative(root, filename).replaceAll("\\", "/"),
+    line: start?.line ?? 1,
+    column: start?.column ?? 0
+  };
+}
+function getLiteralAttribute(opening, name) {
+  for (const attribute of opening.attributes) {
+    if (t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name) && attribute.name.name === name && t.isStringLiteral(attribute.value)) {
+      return attribute.value.value;
+    }
+  }
+  return void 0;
+}
+function hasAttribute(opening, name) {
+  return opening.attributes.some(
+    (attribute) => t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name) && attribute.name.name === name
+  );
+}
+function attributeValue(opening, name) {
+  for (const attribute of opening.attributes) {
+    if (!t.isJSXAttribute(attribute) || !t.isJSXIdentifier(attribute.name, { name }))
+      continue;
+    if (attribute.value === null) return true;
+    if (t.isStringLiteral(attribute.value)) return attribute.value.value;
+  }
+}
+function isUnsafeStaticCopy(source) {
+  const normalized = normalizeSource(source);
+  return /^(?:https?:\/\/|mailto:|tel:|www\.)/i.test(normalized) || /^\/?[\w.-]+(?:\/[\w./-]+)+(?:\?\S*)?$/.test(normalized) || /^[a-z0-9]+(?:[_:.][a-z0-9-]+)+$/i.test(normalized);
+}
+function isExcluded(path) {
+  return Boolean(
+    path.findParent((parent) => {
+      if (!parent.isJSXElement()) return false;
+      const opening = parent.node.openingElement;
+      const tag = jsxName(opening.name);
+      return tag === "T" || EXCLUDED_ELEMENTS.has(tag.toLowerCase()) || hasAttribute(opening, "data-no-translate") || hasAttribute(opening, "hidden") || attributeValue(opening, "aria-hidden") === "true" || tag.toLowerCase() === "input" && attributeValue(opening, "type") === "hidden";
+    })
+  );
+}
+function isExcludedElement(opening) {
+  const tag = jsxName(opening.name);
+  return EXCLUDED_ELEMENTS.has(tag.toLowerCase()) || hasAttribute(opening, "data-no-translate") || hasAttribute(opening, "hidden") || attributeValue(opening, "aria-hidden") === "true" || tag.toLowerCase() === "input" && attributeValue(opening, "type") === "hidden";
+}
+function hasMixedRichChildren(path) {
+  return Boolean(
+    path.findParent((parent) => {
+      if (!parent.isJSXElement()) return false;
+      const children = parent.node.children;
+      const hasElement = children.some(
+        (child) => t.isJSXElement(child) || t.isJSXExpressionContainer(child) && !t.isJSXEmptyExpression(child.expression)
+      );
+      const hasText = children.some(
+        (child) => t.isJSXText(child) && Boolean(renderedJsxText(child.value))
+      );
+      return hasElement && hasText;
+    })
+  );
+}
+function placeholders(source) {
+  try {
+    return parseMessagePlaceholders(source);
+  } catch {
+    return [];
+  }
+}
+function stringProperty(object, name) {
+  for (const property of object.properties) {
+    if (!t.isObjectProperty(property)) continue;
+    const key = t.isIdentifier(property.key) ? property.key.name : t.isStringLiteral(property.key) ? property.key.value : void 0;
+    if (key === name && t.isStringLiteral(property.value))
+      return property.value.value;
+  }
+  return void 0;
+}
+function isTranslationCall(path, runtimePackage = "@linguanahq/react") {
+  if (!t.isIdentifier(path.node.callee)) return false;
+  const name = path.node.callee.name;
+  const binding = path.scope.getBinding(name);
+  if (!binding) return false;
+  if (binding.path.isImportSpecifier()) {
+    const declaration = binding.path.parentPath;
+    return declaration.isImportDeclaration() && declaration.node.source.value === runtimePackage && t.isIdentifier(binding.path.node.imported, { name: "t" });
+  }
+  const declarator = binding.path.isVariableDeclarator() ? binding.path : binding.path.findParent((candidate) => candidate.isVariableDeclarator());
+  if (!declarator?.isVariableDeclarator()) return false;
+  const init = t.isAwaitExpression(declarator.node.init) ? declarator.node.init.argument : declarator.node.init;
+  if (!t.isCallExpression(init) || !t.isIdentifier(init.callee) || !t.isObjectPattern(declarator.node.id))
+    return false;
+  const factory = path.scope.getBinding(init.callee.name);
+  const imported = factory?.path;
+  const nextFactory = imported?.isImportSpecifier() && imported.parentPath.isImportDeclaration() && ["@linguanahq/next/client", "@linguanahq/next/server"].includes(
+    imported.parentPath.node.source.value
+  ) && t.isIdentifier(imported.node.imported) && ["useTranslation", "getTranslations"].includes(imported.node.imported.name);
+  if (!nextFactory && init.callee.name !== "useTranslation") return false;
+  return declarator.node.id.properties.some(
+    (property) => t.isObjectProperty(property) && t.isIdentifier(property.key, { name: "t" }) && t.isIdentifier(property.value, { name })
+  );
+}
+function transformSource(code, filename, options) {
+  const root = options.root ?? process.cwd();
+  const ast = parse(code, {
+    sourceType: "module",
+    sourceFilename: filename,
+    plugins: ["jsx", "typescript"]
+  });
+  const names = /* @__PURE__ */ new Set();
+  traverse(ast, {
+    Identifier(path) {
+      names.add(path.node.name);
+    },
+    JSXIdentifier(path) {
+      names.add(path.node.name);
+    }
+  });
+  const unique = (base) => {
+    let name = base;
+    let suffix = 0;
+    while (names.has(name)) name = `${base}${++suffix}`;
+    names.add(name);
+    return name;
+  };
+  const messageName = unique("__LinguanaMessage");
+  const attributesName = unique("__LinguanaAttributes");
+  const localizedName = unique("__localized");
+  const messages = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  let needsRuntime = false;
+  const richDiagnosticLocations = /* @__PURE__ */ new Set();
+  const addMessage = (message) => {
+    const existing = messages.get(message.id);
+    if (existing && existing.contentHash !== message.contentHash) {
+      diagnostics.push({
+        code: "duplicate-id",
+        severity: "error",
+        message: `Message ID ${message.id} refers to incompatible source content`,
+        location: message.locations[0],
+        remediation: "Choose a unique explicit ID or make the source messages identical."
+      });
+      return;
+    }
+    if (existing) {
+      existing.locations.push(...message.locations);
+      return;
+    }
+    messages.set(message.id, message);
+  };
+  traverse(ast, {
+    JSXText(path) {
+      const source = renderedJsxText(path.node.value);
+      if (!source || isExcluded(path)) return;
+      if (isUnsafeStaticCopy(source)) {
+        diagnostics.push({
+          code: "unsafe-static-copy",
+          severity: "info",
+          message: "URL-like or machine-readable text was excluded from extraction.",
+          location: location(path, root, filename)
+        });
+        return;
+      }
+      if (hasMixedRichChildren(path)) {
+        const itemLocation = location(path, root, filename);
+        const key = `${itemLocation.file}:${itemLocation.line}:${itemLocation.column}`;
+        if (!richDiagnosticLocations.has(key)) {
+          richDiagnosticLocations.add(key);
+          diagnostics.push({
+            code: "ambiguous-rich-text",
+            severity: "warning",
+            message: "Mixed text and JSX elements require an explicit <T> message.",
+            location: itemLocation,
+            remediation: "Use <T defaultMessage components> or data-no-translate."
+          });
+        }
+        return;
+      }
+      const parent = path.findParent((candidate) => candidate.isJSXElement());
+      if (!parent?.isJSXElement()) return;
+      const element = jsxName(parent.node.openingElement.name);
+      const context = { kind: "text", element };
+      const id = stableMessageId({
+        sourceLocale: options.sourceLocale,
+        source,
+        context
+      });
+      addMessage({
+        id,
+        source,
+        normalized: normalizeSource(source),
+        contentHash: contentHash(source),
+        context,
+        placeholders: placeholders(source),
+        confidence: "high",
+        locations: [location(path, root, filename)]
+      });
+      needsRuntime = true;
+      path.replaceWith(
+        t.jsxExpressionContainer(
+          t.jsxElement(
+            t.jsxOpeningElement(
+              t.jsxIdentifier(messageName),
+              [
+                t.jsxAttribute(t.jsxIdentifier("id"), t.stringLiteral(id)),
+                t.jsxAttribute(
+                  t.jsxIdentifier("defaultMessage"),
+                  t.stringLiteral(source)
+                )
+              ],
+              true
+            ),
+            null,
+            [],
+            true
+          )
+        )
+      );
+    },
+    JSXExpressionContainer(path) {
+      if (isExcluded(path) || t.isJSXEmptyExpression(path.node.expression) || !path.parentPath.isJSXElement())
+        return;
+      if (t.isConditionalExpression(path.node.expression) || t.isBinaryExpression(path.node.expression) || t.isTemplateLiteral(path.node.expression)) {
+        diagnostics.push({
+          code: "dynamic-candidate",
+          severity: "warning",
+          message: "Dynamic JSX copy was not automatically extracted.",
+          location: location(path, root, filename),
+          remediation: "Use t(), <T>, data-no-translate, or an explicit annotation."
+        });
+      }
+    },
+    CallExpression(path) {
+      if (!isTranslationCall(path, options.runtimePackage)) return;
+      const [sourceNode, , optionsNode] = path.node.arguments;
+      if (!t.isStringLiteral(sourceNode)) return;
+      const explicitId = t.isObjectExpression(optionsNode) ? stringProperty(optionsNode, "id") : void 0;
+      const developer = t.isObjectExpression(optionsNode) ? stringProperty(optionsNode, "context") : void 0;
+      const context = { kind: "explicit", developer };
+      const id = stableMessageId({
+        sourceLocale: options.sourceLocale,
+        source: sourceNode.value,
+        context,
+        explicitId
+      });
+      addMessage({
+        id,
+        source: sourceNode.value,
+        normalized: normalizeSource(sourceNode.value),
+        contentHash: contentHash(sourceNode.value),
+        context,
+        placeholders: placeholders(sourceNode.value),
+        confidence: "explicit",
+        locations: [location(path, root, filename)]
+      });
+    },
+    JSXElement: {
+      exit(path) {
+        if (isExcluded(path) || isExcludedElement(path.node.openingElement))
+          return;
+        const opening = path.node.openingElement;
+        const tag = jsxName(opening.name);
+        if (tag === "T") {
+          const source = getLiteralAttribute(opening, "defaultMessage");
+          if (!source) return;
+          const explicitId = getLiteralAttribute(opening, "id");
+          const developer = getLiteralAttribute(opening, "context");
+          const context = { kind: "explicit", developer };
+          const id = stableMessageId({
+            sourceLocale: options.sourceLocale,
+            source,
+            context,
+            explicitId
+          });
+          addMessage({
+            id,
+            source,
+            normalized: normalizeSource(source),
+            contentHash: contentHash(source),
+            context,
+            placeholders: placeholders(source),
+            confidence: "explicit",
+            locations: [location(path, root, filename)]
+          });
+          return;
+        }
+        const descriptors = [];
+        const localizedNames = [];
+        for (const attribute of opening.attributes) {
+          if (!t.isJSXAttribute(attribute) || !t.isJSXIdentifier(attribute.name) || !t.isStringLiteral(attribute.value))
+            continue;
+          const name = attribute.name.name;
+          if (MACHINE_ATTRIBUTES.has(name) || name.startsWith("on") || name === "data-translate")
+            continue;
+          const optInValue = attributeValue(opening, "data-translate");
+          const optedIn = typeof optInValue === "string" && optInValue.split(/[\s,]+/).includes(name);
+          if (!ALLOWED_ATTRIBUTES.has(name) && !optedIn) continue;
+          if (name === "value" && tag.toLowerCase() !== "button") continue;
+          const source = attribute.value.value;
+          if (!source || isUnsafeStaticCopy(source)) continue;
+          const context = {
+            kind: "attribute",
+            element: tag,
+            attribute: name
+          };
+          const id = stableMessageId({
+            sourceLocale: options.sourceLocale,
+            source,
+            context
+          });
+          addMessage({
+            id,
+            source,
+            normalized: normalizeSource(source),
+            contentHash: contentHash(source),
+            context,
+            placeholders: placeholders(source),
+            confidence: "high",
+            locations: [location(path, root, filename)]
+          });
+          localizedNames.push(name);
+          descriptors.push(
+            t.objectExpression([
+              t.objectProperty(t.identifier("name"), t.stringLiteral(name)),
+              t.objectProperty(t.identifier("id"), t.stringLiteral(id)),
+              t.objectProperty(
+                t.identifier("defaultMessage"),
+                t.stringLiteral(source)
+              )
+            ])
+          );
+        }
+        if (!descriptors.length) return;
+        needsRuntime = true;
+        const original = t.cloneNode(path.node, true);
+        for (const attribute of original.openingElement.attributes) {
+          if (t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name) && localizedNames.includes(attribute.name.name)) {
+            attribute.value = t.jsxExpressionContainer(
+              t.memberExpression(
+                t.identifier(localizedName),
+                t.stringLiteral(attribute.name.name),
+                true
+              )
+            );
+          }
+        }
+        const wrapper = t.jsxElement(
+          t.jsxOpeningElement(
+            t.jsxIdentifier(attributesName),
+            [
+              t.jsxAttribute(
+                t.jsxIdentifier("descriptors"),
+                t.jsxExpressionContainer(t.arrayExpression(descriptors))
+              )
+            ],
+            false
+          ),
+          t.jsxClosingElement(t.jsxIdentifier(attributesName)),
+          [
+            t.jsxExpressionContainer(
+              t.arrowFunctionExpression(
+                [t.identifier(localizedName)],
+                original
+              )
+            )
+          ]
+        );
+        path.replaceWith(wrapper);
+        path.skip();
+      }
+    },
+    Program: {
+      exit(path) {
+        if (!needsRuntime) return;
+        path.unshiftContainer(
+          "body",
+          t.importDeclaration(
+            [
+              t.importSpecifier(
+                t.identifier(messageName),
+                t.identifier("LinguanaMessage")
+              ),
+              t.importSpecifier(
+                t.identifier(attributesName),
+                t.identifier("LinguanaAttributes")
+              )
+            ],
+            t.stringLiteral(
+              options.compilerRuntime ?? "@linguanahq/react/compiler-runtime"
+            )
+          )
+        );
+      }
+    }
+  });
+  const output = generate(
+    ast,
+    { sourceMaps: true, sourceFileName: filename },
+    code
+  );
+  return {
+    code: output.code,
+    map: output.map,
+    messages: [...messages.values()].sort(
+      (left, right) => left.id.localeCompare(right.id)
+    ),
+    diagnostics
+  };
+}
+export {
+  transformSource
+};

package/package.json

@@ -1,33 +1,42 @@
 {
-	"name": "@linguanahq/compiler",
-	"version": "0.1.0",
-	"publishConfig": {
-		"access": "public"
-	},
-	"type": "module",
-	"exports": {
-		".": "./src/index.ts"
-	},
-	"scripts": {
-		"check-types": "tsc --noEmit",
-		"test": "bun test"
-	},
-	"dependencies": {
-		"@babel/generator": "^7.28.5",
-		"@babel/parser": "^7.28.5",
-		"@babel/traverse": "^7.28.5",
-		"@babel/types": "^7.28.5",
-		"@linguanahq/catalog": "0.1.0"
-	},
-	"devDependencies": {
-		"@linguana/config": "0.0.0",
-		"@types/babel__generator": "^7.27.0",
-		"@types/babel__traverse": "^7.28.0",
-		"@types/bun": "^1.3.14",
-		"typescript": "^6",
-		"vite": "^8.1.3"
-	},
-	"peerDependencies": {
-		"vite": ">=7 <9"
-	}
+  "name": "@linguanahq/compiler",
+  "version": "0.1.2",
+  "type": "module",
+  "description": "Linguana compiler integration",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./transform": {
+      "types": "./dist/transform.d.ts",
+      "import": "./dist/transform.js",
+      "default": "./dist/transform.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.28.5",
+    "@babel/parser": "^7.28.5",
+    "@babel/traverse": "^7.28.5",
+    "@babel/types": "^7.29.8",
+    "@linguanahq/catalog": "0.1.2"
+  },
+  "peerDependencies": {
+    "vite": ">=7 <9"
+  },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
 }