lingo.dev 0.111.10 → 0.111.12

package/build/cli.mjs

@@ -1060,9 +1060,9 @@ function makeGitlabInitializer(spinner) {
 
 // src/cli/cmd/init.ts
 import open2 from "open";
-var openUrl = (path18) => {
+var openUrl = (path19) => {
   const settings = getSettings(void 0);
-  open2(`${settings.auth.webUrl}${path18}`, { wait: false });
+  open2(`${settings.auth.webUrl}${path19}`, { wait: false });
 };
 var throwHelpError = (option, value) => {
   if (value === "help") {
@@ -1499,8 +1499,8 @@ var files_default = new Command6().command("files").description(
           } else if (type.target) {
             result.push(...targetPaths);
           }
-          result.forEach((path18) => {
-            console.log(path18);
+          result.forEach((path19) => {
+            console.log(path19);
           });
         }
       }
@@ -1829,8 +1829,8 @@ function extractCommentsFromJsonc(jsoncString) {
         const keyMatch = line.match(/^\s*["']?([^"':,\s]+)["']?\s*:/);
         if (keyMatch) {
           const key = keyMatch[1];
-          const path18 = contextStack.map((ctx) => ctx.key).filter(Boolean);
-          keyInfo = { key, path: path18 };
+          const path19 = contextStack.map((ctx) => ctx.key).filter(Boolean);
+          keyInfo = { key, path: path19 };
         }
       } else {
         keyInfo = findAssociatedKey(lines, commentData.lineIndex, contextStack);
@@ -1914,8 +1914,8 @@ function findAssociatedKey(lines, commentLineIndex, contextStack) {
     const keyMatch = line.match(/^\s*["']?([^"':,\s]+)["']?\s*:/);
     if (keyMatch) {
       const key = keyMatch[1];
-      const path18 = contextStack.map((ctx) => ctx.key).filter(Boolean);
-      return { key, path: path18 };
+      const path19 = contextStack.map((ctx) => ctx.key).filter(Boolean);
+      return { key, path: path19 };
     }
   }
   return { key: null, path: [] };
@@ -1934,9 +1934,9 @@ function updateContext(contextStack, line, parsedJson) {
     }
   }
 }
-function setCommentAtPath(comments, path18, key, hint) {
+function setCommentAtPath(comments, path19, key, hint) {
   let current = comments;
-  for (const pathKey of path18) {
+  for (const pathKey of path19) {
     if (!current[pathKey]) {
       current[pathKey] = {};
     }
@@ -2597,9 +2597,9 @@ function createHtmlLoader() {
         const bDepth = b.split("/").length;
         return aDepth - bDepth;
       });
-      paths.forEach((path18) => {
-        const value = data[path18];
-        const [nodePath, attribute] = path18.split("#");
+      paths.forEach((path19) => {
+        const value = data[path19];
+        const [nodePath, attribute] = path19.split("#");
         const [rootTag, ...indices] = nodePath.split("/");
         let parent = rootTag === "head" ? document.head : document.body;
         let current = parent;
@@ -2928,36 +2928,99 @@ function _removeLocale(input2, locale) {
   return { ...input2, strings: newStrings };
 }
 
-// src/cli/loaders/prettier.ts
-import path11 from "path";
+// src/cli/loaders/unlocalizable.ts
+import _13 from "lodash";
+import _isUrl from "is-url";
+import { isValid, parseISO } from "date-fns";
+function createUnlocalizableLoader(returnUnlocalizedKeys = false) {
+  return createLoader({
+    async pull(locale, input2) {
+      const unlocalizableKeys = _getUnlocalizableKeys(input2);
+      const result = _13.omitBy(
+        input2,
+        (_35, key) => unlocalizableKeys.includes(key)
+      );
+      if (returnUnlocalizedKeys) {
+        result.unlocalizable = _13.omitBy(
+          input2,
+          (_35, key) => !unlocalizableKeys.includes(key)
+        );
+      }
+      return result;
+    },
+    async push(locale, data, originalInput) {
+      const unlocalizableKeys = _getUnlocalizableKeys(originalInput);
+      const result = _13.merge(
+        {},
+        data,
+        _13.omitBy(originalInput, (_35, key) => !unlocalizableKeys.includes(key))
+      );
+      return result;
+    }
+  });
+}
+function _isSystemId(v) {
+  return /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)[A-Za-z0-9]{22}$/.test(v);
+}
+function _isIsoDate(v) {
+  return isValid(parseISO(v));
+}
+function _getUnlocalizableKeys(input2) {
+  const rules = {
+    isEmpty: (v) => _13.isEmpty(v),
+    isNumber: (v) => typeof v === "number" || /^[0-9]+$/.test(v),
+    isBoolean: (v) => _13.isBoolean(v),
+    isIsoDate: (v) => _13.isString(v) && _isIsoDate(v),
+    isSystemId: (v) => _13.isString(v) && _isSystemId(v),
+    isUrl: (v) => _13.isString(v) && _isUrl(v)
+  };
+  if (!input2) {
+    return [];
+  }
+  return Object.entries(input2).filter(([key, value]) => {
+    for (const [ruleName, rule] of Object.entries(rules)) {
+      if (rule(value)) {
+        return true;
+      }
+    }
+    return false;
+  }).map(([key, _35]) => key);
+}
+
+// src/cli/loaders/formatters/prettier.ts
 import prettier from "prettier";
-function createPrettierLoader(options) {
+
+// src/cli/loaders/formatters/_base.ts
+import path11 from "path";
+function createBaseFormatterLoader(options, formatFn) {
   const stage = options.stage || "both";
+  const formatData = async (locale, data) => {
+    const draftPath = options.bucketPathPattern.replaceAll("[locale]", locale);
+    const finalPath = path11.resolve(draftPath);
+    return await formatFn(data, finalPath);
+  };
   return createLoader({
     async pull(locale, data) {
       if (!["pull", "both"].includes(stage)) {
         return data;
       }
-      const draftPath = options.bucketPathPattern.replaceAll(
-        "[locale]",
-        locale
-      );
-      const finalPath = path11.resolve(draftPath);
-      return await formatDataWithPrettier(data, finalPath, options);
+      return await formatData(locale, data);
     },
     async push(locale, data) {
       if (!["push", "both"].includes(stage)) {
         return data;
       }
-      const draftPath = options.bucketPathPattern.replaceAll(
-        "[locale]",
-        locale
-      );
-      const finalPath = path11.resolve(draftPath);
-      return await formatDataWithPrettier(data, finalPath, options);
+      return await formatData(locale, data);
     }
   });
 }
+
+// src/cli/loaders/formatters/prettier.ts
+function createPrettierLoader(options) {
+  return createBaseFormatterLoader(options, async (data, filePath) => {
+    return await formatDataWithPrettier(data, filePath, options);
+  });
+}
 async function loadPrettierConfig(filePath) {
   try {
     const config = await prettier.resolveConfig(filePath);
@@ -3000,63 +3063,89 @@ async function formatDataWithPrettier(data, filePath, options) {
   }
 }
 
-// src/cli/loaders/unlocalizable.ts
-import _13 from "lodash";
-import _isUrl from "is-url";
-import { isValid, parseISO } from "date-fns";
-function createUnlocalizableLoader(returnUnlocalizedKeys = false) {
-  return createLoader({
-    async pull(locale, input2) {
-      const unlocalizableKeys = _getUnlocalizableKeys(input2);
-      const result = _13.omitBy(
-        input2,
-        (_35, key) => unlocalizableKeys.includes(key)
-      );
-      if (returnUnlocalizedKeys) {
-        result.unlocalizable = _13.omitBy(
-          input2,
-          (_35, key) => !unlocalizableKeys.includes(key)
+// src/cli/loaders/formatters/biome.ts
+import path12 from "path";
+import fs9 from "fs/promises";
+import { Biome, Distribution } from "@biomejs/js-api";
+var shownWarnings = /* @__PURE__ */ new Set();
+function createBiomeLoader(options) {
+  return createBaseFormatterLoader(options, async (data, filePath) => {
+    return await formatDataWithBiome(data, filePath, options);
+  });
+}
+async function findBiomeConfig(startPath) {
+  let currentDir = path12.dirname(startPath);
+  const root = path12.parse(currentDir).root;
+  while (currentDir !== root) {
+    for (const configName of ["biome.json", "biome.jsonc"]) {
+      const configPath = path12.join(currentDir, configName);
+      try {
+        await fs9.access(configPath);
+        return configPath;
+      } catch {
+      }
+    }
+    const parentDir = path12.dirname(currentDir);
+    if (parentDir === currentDir) break;
+    currentDir = parentDir;
+  }
+  return null;
+}
+async function formatDataWithBiome(data, filePath, options) {
+  let configPath = null;
+  try {
+    const biome = await Biome.create({
+      distribution: Distribution.NODE
+    });
+    const openResult = biome.openProject(".");
+    const projectKey = openResult.projectKey;
+    configPath = await findBiomeConfig(filePath);
+    if (!configPath && !options.alwaysFormat) {
+      return data;
+    }
+    if (configPath) {
+      const configContent = await fs9.readFile(configPath, "utf-8");
+      try {
+        const config = JSON.parse(configContent);
+        biome.applyConfiguration(projectKey, config);
+      } catch (parseError) {
+        throw new Error(
+          `Invalid Biome configuration in ${configPath}: ${parseError instanceof Error ? parseError.message : "JSON parse error"}`
         );
       }
-      return result;
-    },
-    async push(locale, data, originalInput) {
-      const unlocalizableKeys = _getUnlocalizableKeys(originalInput);
-      const result = _13.merge(
-        {},
-        data,
-        _13.omitBy(originalInput, (_35, key) => !unlocalizableKeys.includes(key))
+    }
+    const formatted = biome.formatContent(projectKey, data, {
+      filePath
+    });
+    return formatted.content;
+  } catch (error) {
+    const ext2 = path12.extname(filePath);
+    if (!shownWarnings.has(ext2)) {
+      shownWarnings.add(ext2);
+      console.log();
+      console.log(
+        `\u26A0\uFE0F  Biome does not support ${ext2} files - skipping formatting`
       );
-      return result;
+      if (error instanceof Error && error.message) {
+        console.log(`   ${error.message}`);
+      }
     }
-  });
-}
-function _isSystemId(v) {
-  return /^(?=.*[A-Z])(?=.*[a-z])(?=.*\d)[A-Za-z0-9]{22}$/.test(v);
-}
-function _isIsoDate(v) {
-  return isValid(parseISO(v));
+    return data;
+  }
 }
-function _getUnlocalizableKeys(input2) {
-  const rules = {
-    isEmpty: (v) => _13.isEmpty(v),
-    isNumber: (v) => typeof v === "number" || /^[0-9]+$/.test(v),
-    isBoolean: (v) => _13.isBoolean(v),
-    isIsoDate: (v) => _13.isString(v) && _isIsoDate(v),
-    isSystemId: (v) => _13.isString(v) && _isSystemId(v),
-    isUrl: (v) => _13.isString(v) && _isUrl(v)
-  };
-  if (!input2) {
-    return [];
+
+// src/cli/loaders/formatters/index.ts
+function createFormatterLoader(formatterType, parser, bucketPathPattern) {
+  if (formatterType === void 0) {
+    return createPrettierLoader({ parser, bucketPathPattern });
   }
-  return Object.entries(input2).filter(([key, value]) => {
-    for (const [ruleName, rule] of Object.entries(rules)) {
-      if (rule(value)) {
-        return true;
-      }
-    }
-    return false;
-  }).map(([key, _35]) => key);
+  if (formatterType === "prettier") {
+    return createPrettierLoader({ parser, bucketPathPattern });
+  }
+  if (formatterType === "biome") {
+    return createBiomeLoader({ bucketPathPattern });
+  }
+  throw new Error(`Unknown formatter: ${formatterType}`);
 }
 
 // src/cli/loaders/po/index.ts
@@ -3677,7 +3766,7 @@ function createSrtLoader() {
 }
 
 // src/cli/loaders/dato/index.ts
-import fs9 from "fs";
+import fs10 from "fs";
 import JSON52 from "json5";
 
 // src/cli/loaders/dato/_base.ts
@@ -4242,24 +4331,24 @@ function createRawDatoValue(parsedDatoValue, originalRawDatoValue, isClean = fal
 }
 function serializeStructuredText(rawStructuredText) {
   return serializeStructuredTextNode(rawStructuredText);
-  function serializeStructuredTextNode(node, path18 = [], acc = {}) {
+  function serializeStructuredTextNode(node, path19 = [], acc = {}) {
     if ("document" in node) {
       return serializeStructuredTextNode(
         node.document,
-        [...path18, "document"],
+        [...path19, "document"],
         acc
       );
     }
     if (!_18.isNil(node.value)) {
-      acc[[...path18, "value"].join(".")] = node.value;
+      acc[[...path19, "value"].join(".")] = node.value;
     } else if (_18.get(node, "type") === "block") {
-      acc[[...path18, "item"].join(".")] = serializeBlock(node.item);
+      acc[[...path19, "item"].join(".")] = serializeBlock(node.item);
     }
     if (node.children) {
       for (let i = 0; i < node.children.length; i++) {
         serializeStructuredTextNode(
           node.children[i],
-          [...path18, i.toString()],
+          [...path19, i.toString()],
           acc
         );
       }
@@ -4326,8 +4415,8 @@ function deserializeBlockList(parsedBlockList, originalRawBlockList, isClean = f
 }
 function deserializeStructuredText(parsedStructuredText, originalRawStructuredText) {
   const result = _18.cloneDeep(originalRawStructuredText);
-  for (const [path18, value] of _18.entries(parsedStructuredText)) {
-    const realPath = _18.chain(path18.split(".")).flatMap((s) => !_18.isNaN(_18.toNumber(s)) ? ["children", s] : s).value();
+  for (const [path19, value] of _18.entries(parsedStructuredText)) {
+    const realPath = _18.chain(path19.split(".")).flatMap((s) => !_18.isNaN(_18.toNumber(s)) ? ["children", s] : s).value();
     const deserializedValue = createRawDatoValue(
       value,
       _18.get(originalRawStructuredText, realPath),
@@ -4364,12 +4453,12 @@ function _isVideo(rawDatoValue) {
 // src/cli/loaders/dato/index.ts
 function createDatoLoader(configFilePath) {
   try {
-    const configContent = fs9.readFileSync(configFilePath, "utf-8");
+    const configContent = fs10.readFileSync(configFilePath, "utf-8");
     const datoConfig = datoConfigSchema.parse(JSON52.parse(configContent));
     return composeLoaders(
       createDatoApiLoader(
         datoConfig,
-        (updatedConfig) => fs9.writeFileSync(
+        (updatedConfig) => fs10.writeFileSync(
           configFilePath,
           JSON52.stringify(updatedConfig, null, 2)
         )
@@ -4753,15 +4842,15 @@ function parseTypeScript(input2) {
 function extractStringsFromDefaultExport(ast) {
   let extracted = {};
   traverse(ast, {
-    ExportDefaultDeclaration(path18) {
-      const { declaration } = path18.node;
+    ExportDefaultDeclaration(path19) {
+      const { declaration } = path19.node;
       const decl = unwrapTSAsExpression(declaration);
       if (t.isObjectExpression(decl)) {
         extracted = objectExpressionToObject(decl);
       } else if (t.isArrayExpression(decl)) {
         extracted = arrayExpressionToArray(decl);
       } else if (t.isIdentifier(decl)) {
-        const binding = path18.scope.bindings[decl.name];
+        const binding = path19.scope.bindings[decl.name];
         if (binding && t.isVariableDeclarator(binding.path.node) && binding.path.node.init) {
           const initRaw = binding.path.node.init;
           const init = initRaw ? unwrapTSAsExpression(initRaw) : initRaw;
@@ -4826,8 +4915,8 @@ function arrayExpressionToArray(arrayExpression) {
 function updateStringsInDefaultExport(ast, data) {
   let modified = false;
   traverse(ast, {
-    ExportDefaultDeclaration(path18) {
-      const { declaration } = path18.node;
+    ExportDefaultDeclaration(path19) {
+      const { declaration } = path19.node;
       const decl = unwrapTSAsExpression(declaration);
       if (t.isObjectExpression(decl)) {
         modified = updateStringsInObjectExpression(decl, data) || modified;
@@ -4836,7 +4925,7 @@ function updateStringsInDefaultExport(ast, data) {
           modified = updateStringsInArrayExpression(decl, data) || modified;
         }
       } else if (t.isIdentifier(decl)) {
-        modified = updateStringsInExportedIdentifier(path18, data) || modified;
+        modified = updateStringsInExportedIdentifier(path19, data) || modified;
       }
     }
   });
@@ -4907,9 +4996,9 @@ function updateStringsInArrayExpression(arrayExpression, incoming) {
   });
   return modified;
 }
-function updateStringsInExportedIdentifier(path18, data) {
-  const exportName = path18.node.declaration.name;
-  const binding = path18.scope.bindings[exportName];
+function updateStringsInExportedIdentifier(path19, data) {
+  const exportName = path19.node.declaration.name;
+  const binding = path19.scope.bindings[exportName];
   if (!binding || !binding.path.node) return false;
   if (t.isVariableDeclarator(binding.path.node) && binding.path.node.init) {
     const initRaw = binding.path.node.init;
@@ -5815,11 +5904,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path12 = {
+var path13 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path12.win32.sep : path12.posix.sep;
+var sep = defaultPlatform === "win32" ? path13.win32.sep : path13.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -6511,11 +6600,11 @@ function _getAllKeys(obj, prefix = "") {
   let keys = [];
   for (const key in obj) {
     if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
-    const path18 = prefix ? `${prefix}.${key}` : key;
+    const path19 = prefix ? `${prefix}.${key}` : key;
     if (typeof obj[key] === "object" && obj[key] !== null && !Array.isArray(obj[key])) {
-      keys = keys.concat(_getAllKeys(obj[key], path18));
+      keys = keys.concat(_getAllKeys(obj[key], path19));
     } else {
-      keys.push(path18);
+      keys.push(path19);
     }
   }
   return keys;
@@ -7028,19 +7117,19 @@ function createJsonDictionaryLoader() {
         );
         return input2;
       }
-      function walk(obj, dataNode, path18 = []) {
+      function walk(obj, dataNode, path19 = []) {
         if (Array.isArray(obj) && Array.isArray(dataNode)) {
           obj.forEach(
-            (item, idx) => walk(item, dataNode[idx], [...path18, String(idx)])
+            (item, idx) => walk(item, dataNode[idx], [...path19, String(idx)])
           );
         } else if (obj && typeof obj === "object" && dataNode && typeof dataNode === "object" && !Array.isArray(dataNode)) {
           for (const key of Object.keys(obj)) {
             if (dataNode.hasOwnProperty(key)) {
-              walk(obj[key], dataNode[key], [...path18, key]);
+              walk(obj[key], dataNode[key], [...path19, key]);
             }
           }
         } else if (obj && typeof obj === "object" && !Array.isArray(obj) && typeof dataNode === "string") {
-          setNestedLocale(input2, path18, locale, dataNode, originalLocale);
+          setNestedLocale(input2, path19, locale, dataNode, originalLocale);
         }
       }
       walk(input2, data);
@@ -7068,14 +7157,14 @@ function extractTranslatables(obj, locale) {
 function isTranslatableObject(obj, locale) {
   return obj && typeof obj === "object" && !Array.isArray(obj) && Object.prototype.hasOwnProperty.call(obj, locale);
 }
-function setNestedLocale(obj, path18, locale, value, originalLocale) {
+function setNestedLocale(obj, path19, locale, value, originalLocale) {
   let curr = obj;
-  for (let i = 0; i < path18.length - 1; i++) {
-    const key = path18[i];
+  for (let i = 0; i < path19.length - 1; i++) {
+    const key = path19[i];
     if (!(key in curr)) curr[key] = {};
     curr = curr[key];
   }
-  const last = path18[path18.length - 1];
+  const last = path19[path19.length - 1];
   if (curr[last] && typeof curr[last] === "object") {
     curr[last][locale] = value;
     if (originalLocale && curr[last][originalLocale]) {
@@ -7118,7 +7207,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
     case "html":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({ parser: "html", bucketPathPattern }),
+        createFormatterLoader(options.formatter, "html", bucketPathPattern),
         createHtmlLoader(),
         createSyncLoader(),
         createUnlocalizableLoader(options.returnUnlocalizedKeys)
@@ -7133,7 +7222,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
     case "json":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({ parser: "json", bucketPathPattern }),
+        createFormatterLoader(options.formatter, "json", bucketPathPattern),
         createJsonLoader(),
         createEnsureKeyOrderLoader(),
         createFlatLoader(),
@@ -7167,7 +7256,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
     case "markdown":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({ parser: "markdown", bucketPathPattern }),
+        createFormatterLoader(options.formatter, "markdown", bucketPathPattern),
         createMarkdownLoader(),
         createSyncLoader(),
         createUnlocalizableLoader(options.returnUnlocalizedKeys)
@@ -7175,10 +7264,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
     case "mdx":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({
-          parser: "mdx",
-          bucketPathPattern
-        }),
+        createFormatterLoader(options.formatter, "mdx", bucketPathPattern),
         createMdxCodePlaceholderLoader(),
         createMdxLockedPatternsLoader(lockedPatterns),
         createMdxFrontmatterSplitLoader(),
@@ -7239,7 +7325,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
     case "yaml":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({ parser: "yaml", bucketPathPattern }),
+        createFormatterLoader(options.formatter, "yaml", bucketPathPattern),
         createYamlLoader(),
         createFlatLoader(),
         createEnsureKeyOrderLoader(),
@@ -7250,7 +7336,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
     case "yaml-root-key":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({ parser: "yaml", bucketPathPattern }),
+        createFormatterLoader(options.formatter, "yaml", bucketPathPattern),
         createYamlLoader(),
         createRootKeyLoader(true),
         createFlatLoader(),
@@ -7261,7 +7347,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
     case "flutter":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({ parser: "json", bucketPathPattern }),
+        createFormatterLoader(options.formatter, "json", bucketPathPattern),
         createJsonLoader(),
         createEnsureKeyOrderLoader(),
         createFlutterLoader(),
@@ -7330,7 +7416,11 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
     case "typescript":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({ parser: "typescript", bucketPathPattern }),
+        createFormatterLoader(
+          options.formatter,
+          "typescript",
+          bucketPathPattern
+        ),
         createTypescriptLoader(),
         createFlatLoader(),
         createEnsureKeyOrderLoader(),
@@ -7349,7 +7439,7 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
     case "json-dictionary":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
-        createPrettierLoader({ parser: "json", bucketPathPattern }),
+        createFormatterLoader(options.formatter, "json", bucketPathPattern),
         createJsonLoader(),
         createJsonDictionaryLoader(),
         createEnsureKeyOrderLoader(),
@@ -7694,29 +7784,29 @@ import _30 from "lodash";
 import z from "zod";
 
 // src/cli/utils/fs.ts
-import * as fs10 from "fs";
-import * as path13 from "path";
+import * as fs11 from "fs";
+import * as path14 from "path";
 function tryReadFile(filePath, defaultValue = null) {
   try {
-    const content = fs10.readFileSync(filePath, "utf-8");
+    const content = fs11.readFileSync(filePath, "utf-8");
     return content;
   } catch (error) {
     return defaultValue;
   }
 }
 function writeFile(filePath, content) {
-  const dir = path13.dirname(filePath);
-  if (!fs10.existsSync(dir)) {
-    fs10.mkdirSync(dir, { recursive: true });
+  const dir = path14.dirname(filePath);
+  if (!fs11.existsSync(dir)) {
+    fs11.mkdirSync(dir, { recursive: true });
   }
-  fs10.writeFileSync(filePath, content);
+  fs11.writeFileSync(filePath, content);
 }
 function checkIfFileExists(filePath) {
-  return fs10.existsSync(filePath);
+  return fs11.existsSync(filePath);
 }
 
 // src/cli/utils/delta.ts
-import * as path14 from "path";
+import * as path15 from "path";
 import YAML4 from "yaml";
 var LockSchema = z.object({
   version: z.literal(1).default(1),
@@ -7733,7 +7823,7 @@ var LockSchema = z.object({
   ).default({})
 });
 function createDeltaProcessor(fileKey) {
-  const lockfilePath = path14.join(process.cwd(), "i18n.lock");
+  const lockfilePath = path15.join(process.cwd(), "i18n.lock");
   return {
     async checkIfLockExists() {
       return checkIfFileExists(lockfilePath);
@@ -7911,7 +8001,7 @@ var i18n_default = new Command12().command("i18n").description(
     if (flags.file?.length) {
       buckets = buckets.map((bucket) => {
         const paths = bucket.paths.filter(
-          (path18) => flags.file.find((file) => path18.pathPattern?.includes(file))
+          (path19) => flags.file.find((file) => path19.pathPattern?.includes(file))
         );
         return { ...bucket, paths };
       }).filter((bucket) => bucket.paths.length > 0);
@@ -7926,8 +8016,8 @@ var i18n_default = new Command12().command("i18n").description(
         ora.info(`\x1B[36mProcessing only filtered buckets:\x1B[0m`);
         buckets.map((bucket) => {
           ora.info(`  ${bucket.type}:`);
-          bucket.paths.forEach((path18) => {
-            ora.info(`    - ${path18.pathPattern}`);
+          bucket.paths.forEach((path19) => {
+            ora.info(`    - ${path19.pathPattern}`);
           });
         });
       }
@@ -7949,7 +8039,8 @@ var i18n_default = new Command12().command("i18n").description(
             bucketPath.pathPattern,
             {
               defaultLocale: sourceLocale,
-              injectLocale: bucket.injectLocale
+              injectLocale: bucket.injectLocale,
+              formatter: i18nConfig.formatter
             },
             bucket.lockedKeys,
             bucket.lockedPatterns,
@@ -8070,7 +8161,8 @@ var i18n_default = new Command12().command("i18n").description(
             bucketPath.pathPattern,
             {
               defaultLocale: sourceLocale,
-              injectLocale: bucket.injectLocale
+              injectLocale: bucket.injectLocale,
+              formatter: i18nConfig.formatter
             },
             bucket.lockedKeys,
             bucket.lockedPatterns,
@@ -8467,8 +8559,8 @@ import Z5 from "zod";
 import Ora8 from "ora";
 
 // src/cli/utils/lockfile.ts
-import fs11 from "fs";
-import path15 from "path";
+import fs12 from "fs";
+import path16 from "path";
 import Z4 from "zod";
 import YAML5 from "yaml";
 import { MD5 as MD52 } from "object-hash";
@@ -8477,7 +8569,7 @@ function createLockfileHelper() {
   return {
     isLockfileExists: () => {
       const lockfilePath = _getLockfilePath();
-      return fs11.existsSync(lockfilePath);
+      return fs12.existsSync(lockfilePath);
     },
     registerSourceData: (pathPattern, sourceData) => {
       const lockfile = _loadLockfile();
@@ -8514,20 +8606,20 @@ function createLockfileHelper() {
   };
   function _loadLockfile() {
     const lockfilePath = _getLockfilePath();
-    if (!fs11.existsSync(lockfilePath)) {
+    if (!fs12.existsSync(lockfilePath)) {
       return LockfileSchema.parse({});
     }
-    const content = fs11.readFileSync(lockfilePath, "utf-8");
+    const content = fs12.readFileSync(lockfilePath, "utf-8");
     const result = LockfileSchema.parse(YAML5.parse(content));
     return result;
   }
   function _saveLockfile(lockfile) {
     const lockfilePath = _getLockfilePath();
     const content = YAML5.stringify(lockfile);
-    fs11.writeFileSync(lockfilePath, content);
+    fs12.writeFileSync(lockfilePath, content);
   }
   function _getLockfilePath() {
-    return path15.join(process.cwd(), "i18n.lock");
+    return path16.join(process.cwd(), "i18n.lock");
   }
 }
 var LockfileSchema = Z4.object({
@@ -8573,7 +8665,8 @@ var lockfile_default = new Command13().command("lockfile").description(
           bucket.type,
           bucketConfig.pathPattern,
           {
-            defaultLocale: sourceLocale
+            defaultLocale: sourceLocale,
+            formatter: i18nConfig.formatter
           }
         );
         bucketLoader.setDefaultLocale(sourceLocale);
@@ -8640,7 +8733,8 @@ var cleanup_default = new Command14().command("cleanup").description(
           bucket.type,
           bucketConfig.pathPattern,
           {
-            defaultLocale: sourceLocale
+            defaultLocale: sourceLocale,
+            formatter: i18nConfig.formatter
           }
         );
         bucketLoader.setDefaultLocale(sourceLocale);
@@ -8788,7 +8882,7 @@ import { execSync as execSync2 } from "child_process";
 
 // src/cli/cmd/ci/flows/in-branch.ts
 import { execSync } from "child_process";
-import path17 from "path";
+import path18 from "path";
 
 // src/cli/cmd/ci/flows/_base.ts
 var IntegrationFlow = class {
@@ -8809,7 +8903,7 @@ function escapeShellArg(arg) {
 // src/cli/cmd/run/index.ts
 import { Command as Command16 } from "interactive-commander";
 import { exec } from "child_process";
-import path16 from "path";
+import path17 from "path";
 import { fileURLToPath } from "url";
 import os2 from "os";
 
@@ -9266,7 +9360,8 @@ async function plan(input2) {
                   injectLocale: bucket.injectLocale || [],
                   lockedKeys: bucket.lockedKeys || [],
                   lockedPatterns: bucket.lockedPatterns || [],
-                  onlyKeys: input2.flags.key || []
+                  onlyKeys: input2.flags.key || [],
+                  formatter: input2.config.formatter
                 });
               }
             }
@@ -9387,7 +9482,8 @@ function createLoaderForTask(assignedTask) {
     assignedTask.bucketPathPattern,
     {
       defaultLocale: assignedTask.sourceLocale,
-      injectLocale: assignedTask.injectLocale
+      injectLocale: assignedTask.injectLocale,
+      formatter: assignedTask.formatter
     },
     assignedTask.lockedKeys,
     assignedTask.lockedPatterns
@@ -9555,14 +9651,14 @@ async function watch2(ctx) {
       pollInterval: 100
     }
   });
-  watcher.on("change", (path18) => {
-    handleFileChange(path18, state, ctx);
+  watcher.on("change", (path19) => {
+    handleFileChange(path19, state, ctx);
   });
-  watcher.on("add", (path18) => {
-    handleFileChange(path18, state, ctx);
+  watcher.on("add", (path19) => {
+    handleFileChange(path19, state, ctx);
   });
-  watcher.on("unlink", (path18) => {
-    handleFileChange(path18, state, ctx);
+  watcher.on("unlink", (path19) => {
+    handleFileChange(path19, state, ctx);
   });
   watcher.on("error", (error) => {
     console.error(
@@ -9694,12 +9790,12 @@ async function determineAuthId(ctx) {
 }
 
 // src/cli/cmd/run/index.ts
-var __dirname = path16.dirname(fileURLToPath(import.meta.url));
+var __dirname = path17.dirname(fileURLToPath(import.meta.url));
 function playSound(type) {
   const platform = os2.platform();
   return new Promise((resolve) => {
-    const assetDir = path16.join(__dirname, "../assets");
-    const soundFiles = [path16.join(assetDir, `${type}.mp3`)];
+    const assetDir = path17.join(__dirname, "../assets");
+    const soundFiles = [path17.join(assetDir, `${type}.mp3`)];
     let command = "";
     if (platform === "linux") {
       command = soundFiles.map(
@@ -9893,7 +9989,7 @@ var InBranchFlow = class extends IntegrationFlow {
         return false;
       }
     }
-    const workingDir = path17.resolve(
+    const workingDir = path18.resolve(
       process.cwd(),
       this.platformKit.config.workingDir
     );
@@ -10651,8 +10747,8 @@ var status_default = new Command18().command("status").description("Show the sta
     if (flags.file?.length) {
       buckets = buckets.map((bucket) => {
         const paths = bucket.paths.filter(
-          (path18) => flags.file.find(
-            (file) => path18.pathPattern?.includes(file) || path18.pathPattern?.match(file) || minimatch(path18.pathPattern, file)
+          (path19) => flags.file.find(
+            (file) => path19.pathPattern?.includes(file) || path19.pathPattern?.match(file) || minimatch(path19.pathPattern, file)
           )
         );
         return { ...bucket, paths };
@@ -10666,8 +10762,8 @@ var status_default = new Command18().command("status").description("Show the sta
         ora.info(`\x1B[36mProcessing only filtered buckets:\x1B[0m`);
         buckets.map((bucket) => {
           ora.info(`  ${bucket.type}:`);
-          bucket.paths.forEach((path18) => {
-            ora.info(`    - ${path18.pathPattern}`);
+          bucket.paths.forEach((path19) => {
+            ora.info(`    - ${path19.pathPattern}`);
           });
         });
       }
@@ -10705,7 +10801,8 @@ var status_default = new Command18().command("status").description("Show the sta
             bucketPath.pathPattern,
             {
               defaultLocale: sourceLocale,
-              injectLocale: bucket.injectLocale
+              injectLocale: bucket.injectLocale,
+              formatter: i18nConfig.formatter
             },
             bucket.lockedKeys
           );
@@ -10951,10 +11048,10 @@ var status_default = new Command18().command("status").description("Show the sta
     if (flags.confirm && Object.keys(fileStats).length > 0) {
       console.log(chalk14.bold(`
 \u{1F4D1} BREAKDOWN BY FILE:`));
-      Object.entries(fileStats).sort((a, b) => b[1].wordCount - a[1].wordCount).forEach(([path18, stats]) => {
+      Object.entries(fileStats).sort((a, b) => b[1].wordCount - a[1].wordCount).forEach(([path19, stats]) => {
         if (stats.sourceKeys === 0) return;
         console.log(chalk14.bold(`
-\u2022 ${path18}:`));
+\u2022 ${path19}:`));
         console.log(
           `  ${stats.sourceKeys} source keys, ~${stats.wordCount.toLocaleString()} source words`
         );
@@ -11174,7 +11271,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.111.10",
+  version: "0.111.12",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {
@@ -11304,6 +11401,8 @@ var package_default = {
     "@babel/parser": "^7.27.1",
     "@babel/traverse": "^7.27.4",
     "@babel/types": "^7.27.1",
+    "@biomejs/js-api": "^3.0.0",
+    "@biomejs/wasm-nodejs": "^2.2.4",
     "@datocms/cma-client-node": "^4.0.1",
     "@gitbeaker/rest": "^39.34.3",
     "@inkjs/ui": "^2.0.0",
@@ -11491,7 +11590,8 @@ var purge_default = new Command20().command("purge").description(
               bucketPath.pathPattern,
               {
                 defaultLocale: sourceLocale,
-                injectLocale: bucket.injectLocale
+                injectLocale: bucket.injectLocale,
+                formatter: i18nConfig.formatter
               },
               bucket.lockedKeys,
               bucket.lockedPatterns,