@linguanahq/compiler 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -1,7 +1,5 @@
-import generateImport from "@babel/generator";
-import { type Diagnostic, type ManifestMessage } from "@linguanahq/catalog";
 import { type Plugin } from "vite";
-declare const generate: typeof generateImport;
+export { type TransformOptions, type TransformResult, transformSource, } from "./transform";
 export type StrictPolicy = boolean | {
     ambiguous?: boolean;
     unsafe?: boolean;
@@ -25,16 +23,5 @@ export type LinguanaPluginOptions = {
         publish: "development";
     };
 };
-export type TransformResult = {
-    code: string;
-    map: ReturnType<typeof generate>["map"];
-    messages: ManifestMessage[];
-    diagnostics: Diagnostic[];
-};
-export declare function transformSource(code: string, filename: string, options: Pick<LinguanaPluginOptions, "sourceLocale"> & {
-    root?: string;
-    runtimePackage?: string;
-    compilerRuntime?: string;
-}): TransformResult;
 export declare function linguana(options: LinguanaPluginOptions): Plugin;
 export default linguana;

package/dist/index.js

@@ -1,21 +1,26 @@
 // src/index.ts
 import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { dirname, isAbsolute, relative as relative2, resolve } from "node:path";
+import {
+  contentHash as contentHash2,
+  manifestHash,
+  manifestSchema,
+  SCHEMA_VERSION
+} from "@linguanahq/catalog";
+import { createFilter } from "vite";
+
+// 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,
-  manifestHash,
-  manifestSchema,
   normalizeSource,
   parseMessagePlaceholders,
-  SCHEMA_VERSION,
   stableMessageId
 } from "@linguanahq/catalog";
-import { createFilter } from "vite";
-var COMPILER_VERSION = "0.1.1";
 var generate = generateImport.default ?? generateImport;
 var traverse = traverseImport.default ?? traverseImport;
 var EXCLUDED_ELEMENTS = /* @__PURE__ */ new Set(["script", "style", "code", "pre"]);
@@ -149,8 +154,15 @@ function isTranslationCall(path, runtimePackage = "@linguanahq/react") {
   }
   const declarator = binding.path.isVariableDeclarator() ? binding.path : binding.path.findParent((candidate) => candidate.isVariableDeclarator());
   if (!declarator?.isVariableDeclarator()) return false;
-  if (!t.isCallExpression(declarator.node.init) || !t.isIdentifier(declarator.node.init.callee, { name: "useTranslation" }) || !t.isObjectPattern(declarator.node.id))
+  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 })
   );
@@ -162,6 +174,25 @@ function transformSource(code, filename, options) {
     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;
@@ -236,7 +267,7 @@ function transformSource(code, filename, options) {
         t.jsxExpressionContainer(
           t.jsxElement(
             t.jsxOpeningElement(
-              t.jsxIdentifier("__LinguanaMessage"),
+              t.jsxIdentifier(messageName),
               [
                 t.jsxAttribute(t.jsxIdentifier("id"), t.stringLiteral(id)),
                 t.jsxAttribute(
@@ -373,7 +404,7 @@ function transformSource(code, filename, options) {
           if (t.isJSXAttribute(attribute) && t.isJSXIdentifier(attribute.name) && localizedNames.includes(attribute.name.name)) {
             attribute.value = t.jsxExpressionContainer(
               t.memberExpression(
-                t.identifier("__localized"),
+                t.identifier(localizedName),
                 t.stringLiteral(attribute.name.name),
                 true
               )
@@ -382,7 +413,7 @@ function transformSource(code, filename, options) {
         }
         const wrapper = t.jsxElement(
           t.jsxOpeningElement(
-            t.jsxIdentifier("__LinguanaAttributes"),
+            t.jsxIdentifier(attributesName),
             [
               t.jsxAttribute(
                 t.jsxIdentifier("descriptors"),
@@ -391,11 +422,11 @@ function transformSource(code, filename, options) {
             ],
             false
           ),
-          t.jsxClosingElement(t.jsxIdentifier("__LinguanaAttributes")),
+          t.jsxClosingElement(t.jsxIdentifier(attributesName)),
           [
             t.jsxExpressionContainer(
               t.arrowFunctionExpression(
-                [t.identifier("__localized")],
+                [t.identifier(localizedName)],
                 original
               )
             )
@@ -413,11 +444,11 @@ function transformSource(code, filename, options) {
           t.importDeclaration(
             [
               t.importSpecifier(
-                t.identifier("__LinguanaMessage"),
+                t.identifier(messageName),
                 t.identifier("LinguanaMessage")
               ),
               t.importSpecifier(
-                t.identifier("__LinguanaAttributes"),
+                t.identifier(attributesName),
                 t.identifier("LinguanaAttributes")
               )
             ],
@@ -443,6 +474,9 @@ function transformSource(code, filename, options) {
     diagnostics
   };
 }
+
+// src/index.ts
+var COMPILER_VERSION = "0.1.2";
 function shouldFail(strict, diagnostics) {
   if (!strict) return false;
   if (strict === true)
@@ -519,7 +553,7 @@ async function translateManifest(options, manifestId, hash, onProgress) {
   const translation = options.translation;
   if (!translation || !options.apiUrl || !options.token) return;
   const endpoint = options.apiUrl.replace(/\/$/, "");
-  const buildKey = contentHash({
+  const buildKey = contentHash2({
     manifestHash: hash,
     targetLocales: [...translation.targetLocales].sort(),
     publish: translation.publish
@@ -593,7 +627,7 @@ async function translateManifest(options, manifestId, hash, onProgress) {
       headers: {
         authorization: `Bearer ${options.token}`,
         "content-type": "application/json",
-        "idempotency-key": `${buildKey}:release:${contentHash(
+        "idempotency-key": `${buildKey}:release:${contentHash2(
           created.jobs.map(({ id }) => id).sort()
         ).slice(0, 16)}`
       },
@@ -661,7 +695,7 @@ function linguana(options) {
     },
     transform(code, id) {
       const cleanId = id.split("?", 1)[0] ?? id;
-      const projectRelativeId = relative(root, cleanId);
+      const projectRelativeId = relative2(root, cleanId);
       if (restrictToRoot && (projectRelativeId === ".." || projectRelativeId.startsWith("../") || projectRelativeId.startsWith("..\\") || isAbsolute(projectRelativeId)))
         return null;
       if (!filter(cleanId)) return null;

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,6 +1,6 @@
 {
   "name": "@linguanahq/compiler",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "type": "module",
   "description": "Linguana compiler integration",
   "exports": {
@@ -8,6 +8,11 @@
       "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": [
@@ -21,11 +26,16 @@
     "@babel/parser": "^7.28.5",
     "@babel/traverse": "^7.28.5",
     "@babel/types": "^7.29.8",
-    "@linguanahq/catalog": "0.1.1"
+    "@linguanahq/catalog": "0.1.2"
   },
   "peerDependencies": {
     "vite": ">=7 <9"
   },
+  "peerDependenciesMeta": {
+    "vite": {
+      "optional": true
+    }
+  },
   "publishConfig": {
     "access": "public"
   }