@lingo.dev/_compiler 0.2.1 → 0.2.3

package/build/index.mjs

@@ -4,7 +4,7 @@ import { createUnplugin } from "unplugin";
 // package.json
 var package_default = {
   name: "@lingo.dev/_compiler",
-  version: "0.2.1",
+  version: "0.2.3",
   description: "Lingo.dev Compiler",
   private: false,
   publishConfig: {
@@ -1766,7 +1766,39 @@ function collectCallExpressions(path7, importNames, result, functionName) {
 }
 
 // src/rsc-dictionary-loader.ts
+import * as t13 from "@babel/types";
+
+// src/_utils.ts
+import path5 from "path";
+var getDictionaryPath = (params) => {
+  const absolute = path5.resolve(
+    params.sourceRoot,
+    params.lingoDir,
+    LCP_DICTIONARY_FILE_NAME
+  );
+  const rel = path5.relative(params.relativeFilePath, absolute);
+  return rel.split(path5.sep).join(path5.posix.sep);
+};
+
+// src/utils/create-locale-import-map.ts
 import * as t12 from "@babel/types";
+function createLocaleImportMap(allLocales, dictionaryPath) {
+  return t12.objectExpression(
+    allLocales.map(
+      (locale) => t12.objectProperty(
+        t12.stringLiteral(locale),
+        t12.arrowFunctionExpression(
+          [],
+          t12.callExpression(t12.identifier("import"), [
+            t12.stringLiteral(`${dictionaryPath}?locale=${locale}`)
+          ])
+        )
+      )
+    )
+  );
+}
+
+// src/rsc-dictionary-loader.ts
 var rscDictionaryLoaderMutation = createCodeMutation((payload) => {
   const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
   if (mode === "client") {
@@ -1784,31 +1816,22 @@ var rscDictionaryLoaderMutation = createCodeMutation((payload) => {
       moduleName: "lingo.dev/react/rsc" /* ReactRSC */,
       exportedName: "loadDictionary_internal"
     });
-    if (t12.isIdentifier(invokation.callee)) {
+    if (t13.isIdentifier(invokation.callee)) {
       invokation.callee.name = internalDictionaryLoader.importedName;
     }
-    const localeImportMap = t12.objectExpression(
-      allLocales.map(
-        (locale) => t12.objectProperty(
-          t12.identifier(locale),
-          t12.arrowFunctionExpression(
-            [],
-            t12.callExpression(t12.identifier("import"), [
-              t12.stringLiteral(
-                `@/${payload.params.lingoDir}/${LCP_DICTIONARY_FILE_NAME}?locale=${locale}`
-              )
-            ])
-          )
-        )
-      )
-    );
+    const dictionaryPath = getDictionaryPath({
+      sourceRoot: payload.params.sourceRoot,
+      lingoDir: payload.params.lingoDir,
+      relativeFilePath: payload.relativeFilePath
+    });
+    const localeImportMap = createLocaleImportMap(allLocales, dictionaryPath);
     invokation.arguments.push(localeImportMap);
   }
   return payload;
 });
 
 // src/react-router-dictionary-loader.ts
-import * as t13 from "@babel/types";
+import * as t14 from "@babel/types";
 var reactRouterDictionaryLoaderMutation = createCodeMutation(
   (payload) => {
     const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
@@ -1827,24 +1850,15 @@ var reactRouterDictionaryLoaderMutation = createCodeMutation(
         moduleName: "lingo.dev/react/react-router" /* ReactRouter */,
         exportedName: "loadDictionary_internal"
       });
-      if (t13.isIdentifier(invokation.callee)) {
+      if (t14.isIdentifier(invokation.callee)) {
         invokation.callee.name = internalDictionaryLoader.importedName;
       }
-      const localeImportMap = t13.objectExpression(
-        allLocales.map(
-          (locale) => t13.objectProperty(
-            t13.identifier(locale),
-            t13.arrowFunctionExpression(
-              [],
-              t13.callExpression(t13.identifier("import"), [
-                t13.stringLiteral(
-                  `~/${payload.params.lingoDir}/${LCP_DICTIONARY_FILE_NAME}?locale=${locale}`
-                )
-              ])
-            )
-          )
-        )
-      );
+      const dictionaryPath = getDictionaryPath({
+        sourceRoot: payload.params.sourceRoot,
+        lingoDir: payload.params.lingoDir,
+        relativeFilePath: payload.relativeFilePath
+      });
+      const localeImportMap = createLocaleImportMap(allLocales, dictionaryPath);
       invokation.arguments.push(localeImportMap);
     }
     return payload;
@@ -1853,7 +1867,7 @@ var reactRouterDictionaryLoaderMutation = createCodeMutation(
 
 // src/jsx-fragment.ts
 import traverse7 from "@babel/traverse";
-import * as t14 from "@babel/types";
+import * as t15 from "@babel/types";
 function jsxFragmentMutation(payload) {
   const { ast } = payload;
   let foundFragments = false;
@@ -1862,7 +1876,7 @@ function jsxFragmentMutation(payload) {
     ImportDeclaration(path7) {
       if (path7.node.source.value !== "react") return;
       for (const specifier of path7.node.specifiers) {
-        if (t14.isImportSpecifier(specifier) && t14.isIdentifier(specifier.imported) && specifier.imported.name === "Fragment") {
+        if (t15.isImportSpecifier(specifier) && t15.isIdentifier(specifier.imported) && specifier.imported.name === "Fragment") {
           fragmentImportName = specifier.local.name;
           path7.stop();
         }
@@ -1879,9 +1893,9 @@ function jsxFragmentMutation(payload) {
         });
         fragmentImportName = result.importedName;
       }
-      const fragmentElement = t14.jsxElement(
-        t14.jsxOpeningElement(t14.jsxIdentifier(fragmentImportName), [], false),
-        t14.jsxClosingElement(t14.jsxIdentifier(fragmentImportName)),
+      const fragmentElement = t15.jsxElement(
+        t15.jsxOpeningElement(t15.jsxIdentifier(fragmentImportName), [], false),
+        t15.jsxClosingElement(t15.jsxIdentifier(fragmentImportName)),
         path7.node.children,
         false
       );
@@ -1893,7 +1907,7 @@ function jsxFragmentMutation(payload) {
 
 // src/jsx-html-lang.ts
 import traverse8 from "@babel/traverse";
-import * as t15 from "@babel/types";
+import * as t16 from "@babel/types";
 var jsxHtmlLangMutation = createCodeMutation((payload) => {
   traverse8(payload.ast, {
     JSXElement: (path7) => {
@@ -1904,11 +1918,11 @@ var jsxHtmlLangMutation = createCodeMutation((payload) => {
           moduleName: packagePath,
           exportedName: "LingoHtmlComponent"
         });
-        path7.node.openingElement.name = t15.jsxIdentifier(
+        path7.node.openingElement.name = t16.jsxIdentifier(
           lingoHtmlComponentImport.importedName
         );
         if (path7.node.closingElement) {
-          path7.node.closingElement.name = t15.jsxIdentifier(
+          path7.node.closingElement.name = t16.jsxIdentifier(
             lingoHtmlComponentImport.importedName
           );
         }
@@ -1951,18 +1965,22 @@ function jsxAttributeScopesExportMutation(payload) {
   for (const [scope, attributes] of attributeScopes) {
     for (const attributeDefinition of attributes) {
       const [attribute, scopeKey] = attributeDefinition.split(":");
-      lcp.resetScope(payload.fileKey, scopeKey);
+      lcp.resetScope(payload.relativeFilePath, scopeKey);
       const attributeValue = getJsxAttributeValue(scope, attribute);
       if (!attributeValue) {
         continue;
       }
-      lcp.setScopeType(payload.fileKey, scopeKey, "attribute");
+      lcp.setScopeType(payload.relativeFilePath, scopeKey, "attribute");
       const hash = getJsxAttributeValueHash(String(attributeValue));
-      lcp.setScopeHash(payload.fileKey, scopeKey, hash);
-      lcp.setScopeContext(payload.fileKey, scopeKey, "");
-      lcp.setScopeSkip(payload.fileKey, scopeKey, false);
-      lcp.setScopeOverrides(payload.fileKey, scopeKey, {});
-      lcp.setScopeContent(payload.fileKey, scopeKey, String(attributeValue));
+      lcp.setScopeHash(payload.relativeFilePath, scopeKey, hash);
+      lcp.setScopeContext(payload.relativeFilePath, scopeKey, "");
+      lcp.setScopeSkip(payload.relativeFilePath, scopeKey, false);
+      lcp.setScopeOverrides(payload.relativeFilePath, scopeKey, {});
+      lcp.setScopeContent(
+        payload.relativeFilePath,
+        scopeKey,
+        String(attributeValue)
+      );
     }
   }
   lcp.save();
@@ -1973,7 +1991,7 @@ function jsxAttributeScopesExportMutation(payload) {
 import _10 from "lodash";
 
 // src/utils/jsx-content.ts
-import * as t16 from "@babel/types";
+import * as t17 from "@babel/types";
 import _9 from "lodash";
 var WHITESPACE_PLACEHOLDER = "[lingo-whitespace-placeholder]";
 function extractJsxContent(nodePath, replaceWhitespacePlaceholders = true) {
@@ -1995,39 +2013,39 @@ function extractJsxContent(nodePath, replaceWhitespacePlaceholders = true) {
         return;
       }
       const expr = path7.node.expression;
-      if (t16.isCallExpression(expr)) {
+      if (t17.isCallExpression(expr)) {
         let key = "";
-        if (t16.isIdentifier(expr.callee)) {
+        if (t17.isIdentifier(expr.callee)) {
           key = `${expr.callee.name}`;
-        } else if (t16.isMemberExpression(expr.callee)) {
+        } else if (t17.isMemberExpression(expr.callee)) {
           let firstCallee = expr.callee;
-          while (t16.isMemberExpression(firstCallee) && t16.isCallExpression(firstCallee.object)) {
+          while (t17.isMemberExpression(firstCallee) && t17.isCallExpression(firstCallee.object)) {
             firstCallee = firstCallee.object.callee;
           }
           let current = firstCallee;
           const parts = [];
-          while (t16.isMemberExpression(current)) {
-            if (t16.isIdentifier(current.property)) {
+          while (t17.isMemberExpression(current)) {
+            if (t17.isIdentifier(current.property)) {
               parts.unshift(current.property.name);
             }
             current = current.object;
           }
-          if (t16.isIdentifier(current)) {
+          if (t17.isIdentifier(current)) {
             parts.unshift(current.name);
           }
-          if (t16.isMemberExpression(firstCallee) && t16.isNewExpression(firstCallee.object) && t16.isIdentifier(firstCallee.object.callee)) {
+          if (t17.isMemberExpression(firstCallee) && t17.isNewExpression(firstCallee.object) && t17.isIdentifier(firstCallee.object.callee)) {
             parts.unshift(firstCallee.object.callee.name);
           }
           key = parts.join(".");
         }
         chunks.push(`<function:${key}/>`);
-      } else if (t16.isIdentifier(expr)) {
+      } else if (t17.isIdentifier(expr)) {
         chunks.push(`{${expr.name}}`);
-      } else if (t16.isMemberExpression(expr)) {
+      } else if (t17.isMemberExpression(expr)) {
         let current = expr;
         const parts = [];
-        while (t16.isMemberExpression(current)) {
-          if (t16.isIdentifier(current.property)) {
+        while (t17.isMemberExpression(current)) {
+          if (t17.isIdentifier(current.property)) {
             if (current.computed) {
               parts.unshift(`[${current.property.name}]`);
             } else {
@@ -2036,7 +2054,7 @@ function extractJsxContent(nodePath, replaceWhitespacePlaceholders = true) {
           }
           current = current.object;
         }
-        if (t16.isIdentifier(current)) {
+        if (t17.isIdentifier(current)) {
           parts.unshift(current.name);
           chunks.push(`{${parts.join(".").replaceAll(".[", "[")}}`);
         }
@@ -2057,12 +2075,12 @@ function extractJsxContent(nodePath, replaceWhitespacePlaceholders = true) {
 }
 var compilerProps = ["data-jsx-attribute-scope", "data-jsx-scope"];
 function isExpression2(nodePath) {
-  const isCompilerExpression = !_9.isArray(nodePath.container) && t16.isJSXAttribute(nodePath.container) && t16.isJSXIdentifier(nodePath.container.name) && compilerProps.includes(nodePath.container.name.name);
-  return !isCompilerExpression && !t16.isJSXEmptyExpression(nodePath.node.expression);
+  const isCompilerExpression = !_9.isArray(nodePath.container) && t17.isJSXAttribute(nodePath.container) && t17.isJSXIdentifier(nodePath.container.name) && compilerProps.includes(nodePath.container.name.name);
+  return !isCompilerExpression && !t17.isJSXEmptyExpression(nodePath.node.expression);
 }
 function isWhitespace(nodePath) {
   const expr = nodePath.node.expression;
-  return t16.isStringLiteral(expr) && expr.value === " ";
+  return t17.isStringLiteral(expr) && expr.value === " ";
 }
 function normalizeJsxWhitespace(input) {
   const lines = input.split("\n");
@@ -2093,28 +2111,36 @@ function jsxScopesExportMutation(payload) {
   });
   for (const scope of scopes) {
     const scopeKey = getAstKey(scope);
-    lcp.resetScope(payload.fileKey, scopeKey);
-    lcp.setScopeType(payload.fileKey, scopeKey, "element");
+    lcp.resetScope(payload.relativeFilePath, scopeKey);
+    lcp.setScopeType(payload.relativeFilePath, scopeKey, "element");
     const hash = getJsxElementHash(scope);
-    lcp.setScopeHash(payload.fileKey, scopeKey, hash);
+    lcp.setScopeHash(payload.relativeFilePath, scopeKey, hash);
     const context = getJsxAttributeValue(scope, "data-lingo-context");
-    lcp.setScopeContext(payload.fileKey, scopeKey, String(context || ""));
+    lcp.setScopeContext(
+      payload.relativeFilePath,
+      scopeKey,
+      String(context || "")
+    );
     const skip = getJsxAttributeValue(scope, "data-lingo-skip");
-    lcp.setScopeSkip(payload.fileKey, scopeKey, Boolean(skip || false));
+    lcp.setScopeSkip(
+      payload.relativeFilePath,
+      scopeKey,
+      Boolean(skip || false)
+    );
     const attributesMap = getJsxAttributesMap(scope);
     const overrides = _10.chain(attributesMap).entries().filter(
       ([attributeKey]) => attributeKey.startsWith("data-lingo-override-")
     ).map(([k, v]) => [k.split("data-lingo-override-")[1], v]).filter(([k]) => !!k).filter(([, v]) => !!v).fromPairs().value();
-    lcp.setScopeOverrides(payload.fileKey, scopeKey, overrides);
+    lcp.setScopeOverrides(payload.relativeFilePath, scopeKey, overrides);
     const content = extractJsxContent(scope);
-    lcp.setScopeContent(payload.fileKey, scopeKey, content);
+    lcp.setScopeContent(payload.relativeFilePath, scopeKey, content);
   }
   lcp.save();
   return payload;
 }
 
 // src/jsx-attribute-scope-inject.ts
-import * as t17 from "@babel/types";
+import * as t18 from "@babel/types";
 var lingoJsxAttributeScopeInjectMutation = createCodeMutation(
   (payload) => {
     const mode = getModuleExecutionMode(payload.ast, payload.params.rsc);
@@ -2129,34 +2155,34 @@ var lingoJsxAttributeScopeInjectMutation = createCodeMutation(
       if (!originalJsxElementName) {
         continue;
       }
-      jsxScope.node.openingElement.name = t17.jsxIdentifier(
+      jsxScope.node.openingElement.name = t18.jsxIdentifier(
         lingoComponentImport.importedName
       );
       if (jsxScope.node.closingElement) {
-        jsxScope.node.closingElement.name = t17.jsxIdentifier(
+        jsxScope.node.closingElement.name = t18.jsxIdentifier(
           lingoComponentImport.importedName
         );
       }
-      const as = /^[A-Z]/.test(originalJsxElementName) ? t17.jsxExpressionContainer(t17.identifier(originalJsxElementName)) : t17.stringLiteral(originalJsxElementName);
+      const as = /^[A-Z]/.test(originalJsxElementName) ? t18.jsxExpressionContainer(t18.identifier(originalJsxElementName)) : t18.stringLiteral(originalJsxElementName);
       jsxScope.node.openingElement.attributes.push(
-        t17.jsxAttribute(t17.jsxIdentifier("$attrAs"), as)
+        t18.jsxAttribute(t18.jsxIdentifier("$attrAs"), as)
       );
       jsxScope.node.openingElement.attributes.push(
-        t17.jsxAttribute(
-          t17.jsxIdentifier("$fileKey"),
-          t17.stringLiteral(payload.fileKey)
+        t18.jsxAttribute(
+          t18.jsxIdentifier("$fileKey"),
+          t18.stringLiteral(payload.relativeFilePath)
         )
       );
       jsxScope.node.openingElement.attributes.push(
-        t17.jsxAttribute(
-          t17.jsxIdentifier("$attributes"),
-          t17.jsxExpressionContainer(
-            t17.objectExpression(
+        t18.jsxAttribute(
+          t18.jsxIdentifier("$attributes"),
+          t18.jsxExpressionContainer(
+            t18.objectExpression(
               attributes.map((attributeDefinition) => {
                 const [attribute, key = ""] = attributeDefinition.split(":");
-                return t17.objectProperty(
-                  t17.stringLiteral(attribute),
-                  t17.stringLiteral(key)
+                return t18.objectProperty(
+                  t18.stringLiteral(attribute),
+                  t18.stringLiteral(key)
                 );
               })
             )
@@ -2169,14 +2195,14 @@ var lingoJsxAttributeScopeInjectMutation = createCodeMutation(
           moduleName: "lingo.dev/react/rsc" /* ReactRSC */
         });
         jsxScope.node.openingElement.attributes.push(
-          t17.jsxAttribute(
-            t17.jsxIdentifier("$loadDictionary"),
-            t17.jsxExpressionContainer(
-              t17.arrowFunctionExpression(
-                [t17.identifier("locale")],
-                t17.callExpression(
-                  t17.identifier(loadDictionaryImport.importedName),
-                  [t17.identifier("locale")]
+          t18.jsxAttribute(
+            t18.jsxIdentifier("$loadDictionary"),
+            t18.jsxExpressionContainer(
+              t18.arrowFunctionExpression(
+                [t18.identifier("locale")],
+                t18.callExpression(
+                  t18.identifier(loadDictionaryImport.importedName),
+                  [t18.identifier("locale")]
                 )
               )
             )
@@ -2189,10 +2215,10 @@ var lingoJsxAttributeScopeInjectMutation = createCodeMutation(
 );
 
 // src/jsx-scope-inject.ts
-import * as t21 from "@babel/types";
+import * as t22 from "@babel/types";
 
 // src/utils/jsx-variables.ts
-import * as t18 from "@babel/types";
+import * as t19 from "@babel/types";
 var getJsxVariables = (nodePath) => {
   const variables = /* @__PURE__ */ new Set();
   nodePath.traverse({
@@ -2200,13 +2226,13 @@ var getJsxVariables = (nodePath) => {
       path7.skip();
     },
     JSXExpressionContainer(path7) {
-      if (t18.isIdentifier(path7.node.expression)) {
+      if (t19.isIdentifier(path7.node.expression)) {
         variables.add(path7.node.expression.name);
-      } else if (t18.isMemberExpression(path7.node.expression)) {
+      } else if (t19.isMemberExpression(path7.node.expression)) {
         let current = path7.node.expression;
         const parts = [];
-        while (t18.isMemberExpression(current)) {
-          if (t18.isIdentifier(current.property)) {
+        while (t19.isMemberExpression(current)) {
+          if (t19.isIdentifier(current.property)) {
             if (current.computed) {
               parts.unshift(`[${current.property.name}]`);
             } else {
@@ -2215,7 +2241,7 @@ var getJsxVariables = (nodePath) => {
           }
           current = current.object;
         }
-        if (t18.isIdentifier(current)) {
+        if (t19.isIdentifier(current)) {
           parts.unshift(current.name);
           variables.add(parts.join(".").replaceAll(".[", "["));
         }
@@ -2224,14 +2250,14 @@ var getJsxVariables = (nodePath) => {
     }
   });
   const properties = Array.from(variables).map(
-    (name) => t18.objectProperty(t18.stringLiteral(name), t18.identifier(name))
+    (name) => t19.objectProperty(t19.stringLiteral(name), t19.identifier(name))
   );
-  const result = t18.objectExpression(properties);
+  const result = t19.objectExpression(properties);
   return result;
 };
 
 // src/utils/jsx-functions.ts
-import * as t19 from "@babel/types";
+import * as t20 from "@babel/types";
 var getJsxFunctions = (nodePath) => {
   const functions = /* @__PURE__ */ new Map();
   let fnCounter = 0;
@@ -2240,27 +2266,27 @@ var getJsxFunctions = (nodePath) => {
       path7.skip();
     },
     JSXExpressionContainer(path7) {
-      if (t19.isCallExpression(path7.node.expression)) {
+      if (t20.isCallExpression(path7.node.expression)) {
         let key = "";
-        if (t19.isIdentifier(path7.node.expression.callee)) {
+        if (t20.isIdentifier(path7.node.expression.callee)) {
           key = `${path7.node.expression.callee.name}`;
-        } else if (t19.isMemberExpression(path7.node.expression.callee)) {
+        } else if (t20.isMemberExpression(path7.node.expression.callee)) {
           let firstCallee = path7.node.expression.callee;
-          while (t19.isMemberExpression(firstCallee) && t19.isCallExpression(firstCallee.object)) {
+          while (t20.isMemberExpression(firstCallee) && t20.isCallExpression(firstCallee.object)) {
             firstCallee = firstCallee.object.callee;
           }
           let current = firstCallee;
           const parts = [];
-          while (t19.isMemberExpression(current)) {
-            if (t19.isIdentifier(current.property)) {
+          while (t20.isMemberExpression(current)) {
+            if (t20.isIdentifier(current.property)) {
               parts.unshift(current.property.name);
             }
             current = current.object;
           }
-          if (t19.isIdentifier(current)) {
+          if (t20.isIdentifier(current)) {
             parts.unshift(current.name);
           }
-          if (t19.isMemberExpression(firstCallee) && t19.isNewExpression(firstCallee.object) && t19.isIdentifier(firstCallee.object.callee)) {
+          if (t20.isMemberExpression(firstCallee) && t20.isNewExpression(firstCallee.object) && t20.isIdentifier(firstCallee.object.callee)) {
             parts.unshift(firstCallee.object.callee.name);
           }
           key = parts.join(".");
@@ -2273,13 +2299,13 @@ var getJsxFunctions = (nodePath) => {
     }
   });
   const properties = Array.from(functions.entries()).map(
-    ([name, callExpr]) => t19.objectProperty(t19.stringLiteral(name), t19.arrayExpression(callExpr))
+    ([name, callExpr]) => t20.objectProperty(t20.stringLiteral(name), t20.arrayExpression(callExpr))
   );
-  return t19.objectExpression(properties);
+  return t20.objectExpression(properties);
 };
 
 // src/utils/jsx-expressions.ts
-import * as t20 from "@babel/types";
+import * as t21 from "@babel/types";
 var getJsxExpressions = (nodePath) => {
   const expressions = [];
   nodePath.traverse({
@@ -2288,13 +2314,13 @@ var getJsxExpressions = (nodePath) => {
     },
     JSXExpressionContainer(path7) {
       const expr = path7.node.expression;
-      if (!t20.isJSXEmptyExpression(expr) && !t20.isIdentifier(expr) && !t20.isMemberExpression(expr) && !t20.isCallExpression(expr) && !(t20.isStringLiteral(expr) && expr.value === " ")) {
+      if (!t21.isJSXEmptyExpression(expr) && !t21.isIdentifier(expr) && !t21.isMemberExpression(expr) && !t21.isCallExpression(expr) && !(t21.isStringLiteral(expr) && expr.value === " ")) {
         expressions.push(expr);
       }
       path7.skip();
     }
   });
-  return t20.arrayExpression(expressions);
+  return t21.arrayExpression(expressions);
 };
 
 // src/jsx-scope-inject.ts
@@ -2316,53 +2342,53 @@ var lingoJsxScopeInjectMutation = createCodeMutation((payload) => {
       continue;
     }
     const originalAttributes = jsxScope.node.openingElement.attributes.slice();
-    const as = /^[A-Z]/.test(originalJsxElementName) ? t21.jsxExpressionContainer(t21.identifier(originalJsxElementName)) : t21.stringLiteral(originalJsxElementName);
-    originalAttributes.push(t21.jsxAttribute(t21.jsxIdentifier("$as"), as));
+    const as = /^[A-Z]/.test(originalJsxElementName) ? t22.jsxExpressionContainer(t22.identifier(originalJsxElementName)) : t22.stringLiteral(originalJsxElementName);
+    originalAttributes.push(t22.jsxAttribute(t22.jsxIdentifier("$as"), as));
     originalAttributes.push(
-      t21.jsxAttribute(
-        t21.jsxIdentifier("$fileKey"),
-        t21.stringLiteral(payload.fileKey)
+      t22.jsxAttribute(
+        t22.jsxIdentifier("$fileKey"),
+        t22.stringLiteral(payload.relativeFilePath)
       )
     );
     originalAttributes.push(
-      t21.jsxAttribute(
-        t21.jsxIdentifier("$entryKey"),
-        t21.stringLiteral(getJsxScopeAttribute(jsxScope))
+      t22.jsxAttribute(
+        t22.jsxIdentifier("$entryKey"),
+        t22.stringLiteral(getJsxScopeAttribute(jsxScope))
       )
     );
     const $variables = getJsxVariables(jsxScope);
     if ($variables.properties.length > 0) {
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$variables"),
-          t21.jsxExpressionContainer($variables)
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$variables"),
+          t22.jsxExpressionContainer($variables)
         )
       );
     }
     const $elements = getNestedJsxElements(jsxScope);
     if ($elements.elements.length > 0) {
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$elements"),
-          t21.jsxExpressionContainer($elements)
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$elements"),
+          t22.jsxExpressionContainer($elements)
         )
       );
     }
     const $functions = getJsxFunctions(jsxScope);
     if ($functions.properties.length > 0) {
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$functions"),
-          t21.jsxExpressionContainer($functions)
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$functions"),
+          t22.jsxExpressionContainer($functions)
         )
       );
     }
     const $expressions = getJsxExpressions(jsxScope);
     if ($expressions.elements.length > 0) {
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$expressions"),
-          t21.jsxExpressionContainer($expressions)
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$expressions"),
+          t22.jsxExpressionContainer($expressions)
         )
       );
     }
@@ -2372,23 +2398,23 @@ var lingoJsxScopeInjectMutation = createCodeMutation((payload) => {
         moduleName: "lingo.dev/react/rsc" /* ReactRSC */
       });
       originalAttributes.push(
-        t21.jsxAttribute(
-          t21.jsxIdentifier("$loadDictionary"),
-          t21.jsxExpressionContainer(
-            t21.arrowFunctionExpression(
-              [t21.identifier("locale")],
-              t21.callExpression(
-                t21.identifier(loadDictionaryImport.importedName),
-                [t21.identifier("locale")]
+        t22.jsxAttribute(
+          t22.jsxIdentifier("$loadDictionary"),
+          t22.jsxExpressionContainer(
+            t22.arrowFunctionExpression(
+              [t22.identifier("locale")],
+              t22.callExpression(
+                t22.identifier(loadDictionaryImport.importedName),
+                [t22.identifier("locale")]
               )
             )
           )
         )
       );
     }
-    const newNode = t21.jsxElement(
-      t21.jsxOpeningElement(
-        t21.jsxIdentifier(lingoComponentImport.importedName),
+    const newNode = t22.jsxElement(
+      t22.jsxOpeningElement(
+        t22.jsxIdentifier(lingoComponentImport.importedName),
         originalAttributes,
         true
         // selfClosing
@@ -2406,7 +2432,7 @@ var lingoJsxScopeInjectMutation = createCodeMutation((payload) => {
 });
 
 // src/jsx-remove-attributes.ts
-import * as t22 from "@babel/types";
+import * as t23 from "@babel/types";
 import traverse9 from "@babel/traverse";
 var jsxRemoveAttributesMutation = createCodeMutation(
   (payload) => {
@@ -2419,7 +2445,7 @@ var jsxRemoveAttributesMutation = createCodeMutation(
       JSXElement(path7) {
         const openingElement = path7.node.openingElement;
         openingElement.attributes = openingElement.attributes.filter((attr) => {
-          const removeAttr = t22.isJSXAttribute(attr) && t22.isJSXIdentifier(attr.name) && ATTRIBUTES_TO_REMOVE.includes(attr.name.name);
+          const removeAttr = t23.isJSXAttribute(attr) && t23.isJSXIdentifier(attr.name) && ATTRIBUTES_TO_REMOVE.includes(attr.name.name);
           return !removeAttr;
         });
       }
@@ -2431,18 +2457,8 @@ var jsxRemoveAttributesMutation = createCodeMutation(
 );
 
 // src/client-dictionary-loader.ts
-import path5 from "path";
-import * as t23 from "@babel/types";
+import * as t24 from "@babel/types";
 var clientDictionaryLoaderMutation = createCodeMutation((payload) => {
-  const lingoDir = path5.resolve(
-    process.cwd(),
-    payload.params.sourceRoot,
-    payload.params.lingoDir
-  );
-  const currentDir = path5.dirname(
-    path5.resolve(process.cwd(), payload.params.sourceRoot, payload.fileKey)
-  );
-  const relativeLingoPath = path5.relative(currentDir, lingoDir);
   const invokations = findInvokations(payload.ast, {
     moduleName: "lingo.dev/react/client" /* ReactClient */,
     functionName: "loadDictionary"
@@ -2455,24 +2471,15 @@ var clientDictionaryLoaderMutation = createCodeMutation((payload) => {
       moduleName: "lingo.dev/react/client" /* ReactClient */,
       exportedName: "loadDictionary_internal"
     });
-    if (t23.isIdentifier(invokation.callee)) {
+    if (t24.isIdentifier(invokation.callee)) {
       invokation.callee.name = internalDictionaryLoader.importedName;
     }
-    const localeImportMap = t23.objectExpression(
-      allLocales.map(
-        (locale) => t23.objectProperty(
-          t23.identifier(locale),
-          t23.arrowFunctionExpression(
-            [],
-            t23.callExpression(t23.identifier("import"), [
-              t23.stringLiteral(
-                `./${relativeLingoPath}/${LCP_DICTIONARY_FILE_NAME}?locale=${locale}`
-              )
-            ])
-          )
-        )
-      )
-    );
+    const dictionaryPath = getDictionaryPath({
+      sourceRoot: payload.params.sourceRoot,
+      lingoDir: payload.params.lingoDir,
+      relativeFilePath: payload.relativeFilePath
+    });
+    const localeImportMap = createLocaleImportMap(allLocales, dictionaryPath);
     invokation.arguments.push(localeImportMap);
   }
   return payload;
@@ -2552,7 +2559,7 @@ var unplugin = createUnplugin(
           const result = _11.chain({
             code,
             params,
-            fileKey: path6.relative(path6.resolve(process.cwd(), params.sourceRoot), id).split(path6.sep).join("/")
+            relativeFilePath: path6.relative(path6.resolve(process.cwd(), params.sourceRoot), id).split(path6.sep).join("/")
             // Always normalize for consistent dictionaries
           }).thru(createPayload).thru(
             composeMutations(