lingo.dev 0.113.3 → 0.113.4

package/build/cli.mjs

@@ -1874,9 +1874,9 @@ function createJsoncLoader() {
 import { flatten, unflatten } from "flat";
 import _6 from "lodash";
 var OBJECT_NUMERIC_KEY_PREFIX = "__lingodotdev__obj__";
-function createFlatLoader() {
+function createFlatLoader(options) {
   const composedLoader = composeLoaders(
-    createDenormalizeLoader(),
+    createDenormalizeLoader(options),
     createNormalizeLoader()
   );
   return {
@@ -1889,16 +1889,29 @@ function createFlatLoader() {
     }
   };
 }
-function createDenormalizeLoader() {
+function createDenormalizeLoader(options) {
   return createLoader({
     pull: async (locale, input2) => {
       const inputDenormalized = denormalizeObjectKeys(input2 || {});
-      const denormalized = flatten(inputDenormalized, {
+      const preservedObjects = {};
+      const nonPreservedInput = {};
+      for (const [key, value] of Object.entries(inputDenormalized)) {
+        if (options?.shouldPreserveObject?.(value)) {
+          preservedObjects[key] = value;
+        } else {
+          nonPreservedInput[key] = value;
+        }
+      }
+      const flattened = flatten(nonPreservedInput, {
         delimiter: "/",
         transformKey(key) {
           return encodeURIComponent(String(key));
         }
       });
+      const denormalized = {
+        ...flattened,
+        ...preservedObjects
+      };
       const keysMap = buildDenormalizedKeysMap(denormalized);
       return { denormalized, keysMap };
     },
@@ -2941,6 +2954,380 @@ function _removeLocale(input2, locale) {
   return { ...input2, strings: newStrings };
 }
 
+// src/cli/loaders/xcode-xcstrings-icu.ts
+var ICU_TYPE_MARKER = Symbol.for("@lingo.dev/icu-plural-object");
+var CLDR_PLURAL_CATEGORIES = /* @__PURE__ */ new Set([
+  "zero",
+  "one",
+  "two",
+  "few",
+  "many",
+  "other"
+]);
+function isICUPluralObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  if (ICU_TYPE_MARKER in value) {
+    return true;
+  }
+  if (!("icu" in value) || typeof value.icu !== "string") {
+    return false;
+  }
+  const icuPluralPattern = /^\{[\w]+,\s*plural,\s*.+\}$/;
+  if (!icuPluralPattern.test(value.icu)) {
+    return false;
+  }
+  if (value._meta !== void 0) {
+    if (typeof value._meta !== "object" || !value._meta.variables || typeof value._meta.variables !== "object") {
+      return false;
+    }
+    for (const [varName, varMeta] of Object.entries(value._meta.variables)) {
+      if (!varMeta || typeof varMeta !== "object" || typeof varMeta.format !== "string" || varMeta.role !== "plural" && varMeta.role !== "other") {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isPluralFormsObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const keys = Object.keys(value);
+  if (keys.length === 0) {
+    return false;
+  }
+  const allKeysAreCldr = keys.every((key) => CLDR_PLURAL_CATEGORIES.has(key));
+  if (!allKeysAreCldr) {
+    return false;
+  }
+  const allValuesAreStrings = keys.every(
+    (key) => typeof value[key] === "string"
+  );
+  if (!allValuesAreStrings) {
+    return false;
+  }
+  if (!("other" in value)) {
+    return false;
+  }
+  return true;
+}
+function getRequiredPluralCategories(locale) {
+  try {
+    const pluralRules = new Intl.PluralRules(locale);
+    const categories = pluralRules.resolvedOptions().pluralCategories;
+    if (!categories || categories.length === 0) {
+      throw new Error(`No plural categories found for locale: ${locale}`);
+    }
+    return categories;
+  } catch (error) {
+    console.warn(
+      `[xcode-xcstrings-icu] Failed to resolve plural categories for locale "${locale}". Using fallback ["one", "other"]. Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return ["one", "other"];
+  }
+}
+var CLDR_CATEGORY_TO_NUMBER = {
+  zero: 0,
+  one: 1,
+  two: 2
+};
+var NUMBER_TO_CLDR_CATEGORY = {
+  0: "zero",
+  1: "one",
+  2: "two"
+};
+function xcstringsToPluralWithMeta(pluralForms, sourceLocale = "en") {
+  if (!pluralForms || Object.keys(pluralForms).length === 0) {
+    throw new Error("pluralForms cannot be empty");
+  }
+  const requiredCategories = getRequiredPluralCategories(sourceLocale);
+  const variables = {};
+  const formatRegex = /(%(?:(\d+)\$)?(?:[+-])?(?:\d+)?(?:\.(\d+))?([lhqLzjt]*)([diuoxXfFeEgGaAcspn@]))/g;
+  let maxMatches = [];
+  let maxMatchText = "";
+  for (const [form, text] of Object.entries(pluralForms)) {
+    if (typeof text !== "string") {
+      console.warn(
+        `Warning: Plural form "${form}" has non-string value:`,
+        text
+      );
+      continue;
+    }
+    const matches = [...text.matchAll(formatRegex)];
+    if (matches.length > maxMatches.length) {
+      maxMatches = matches;
+      maxMatchText = text;
+    }
+  }
+  let lastNumericIndex = -1;
+  maxMatches.forEach((match2, idx) => {
+    const specifier = match2[5];
+    if (/[diuoxXfFeE]/.test(specifier)) {
+      lastNumericIndex = idx;
+    }
+  });
+  let nonPluralCounter = 0;
+  maxMatches.forEach((match2, idx) => {
+    const fullFormat = match2[1];
+    const position = match2[2];
+    const precision = match2[3];
+    const lengthMod = match2[4];
+    const specifier = match2[5];
+    const isPluralVar = idx === lastNumericIndex;
+    const varName = isPluralVar ? "count" : `var${nonPluralCounter++}`;
+    variables[varName] = {
+      format: fullFormat,
+      role: isPluralVar ? "plural" : "other"
+    };
+  });
+  const variableKeys = Object.keys(variables);
+  const icuForms = Object.entries(pluralForms).filter(([form, text]) => {
+    if (typeof text !== "string") {
+      return false;
+    }
+    return true;
+  }).map(([form, text]) => {
+    let processed = text;
+    let vIdx = 0;
+    processed = processed.replace(formatRegex, () => {
+      if (vIdx >= variableKeys.length) {
+        vIdx++;
+        return "#";
+      }
+      const varName = variableKeys[vIdx];
+      const varMeta = variables[varName];
+      vIdx++;
+      if (varMeta.role === "plural") {
+        return "#";
+      } else {
+        return `{${varName}}`;
+      }
+    });
+    const isRequired = requiredCategories.includes(form);
+    const formKey = !isRequired && form in CLDR_CATEGORY_TO_NUMBER ? `=${CLDR_CATEGORY_TO_NUMBER[form]}` : form;
+    return `${formKey} {${processed}}`;
+  }).join(" ");
+  const pluralVarName = Object.keys(variables).find((name) => variables[name].role === "plural") || "count";
+  const icu = `{${pluralVarName}, plural, ${icuForms}}`;
+  const result = {
+    icu,
+    _meta: Object.keys(variables).length > 0 ? { variables } : void 0,
+    [ICU_TYPE_MARKER]: true
+    // Add type marker for robust detection
+  };
+  return result;
+}
+function pluralWithMetaToXcstrings(data) {
+  if (!data.icu) {
+    throw new Error("ICU string is required");
+  }
+  const ast = parseICU(data.icu);
+  if (!ast || ast.length === 0) {
+    throw new Error("Invalid ICU format");
+  }
+  const pluralNode = ast.find((node) => node.type === "plural");
+  if (!pluralNode) {
+    throw new Error("No plural found in ICU format");
+  }
+  const forms = {};
+  for (const [form, option] of Object.entries(pluralNode.options)) {
+    let text = "";
+    const optionValue = option.value;
+    for (const element of optionValue) {
+      if (element.type === "literal") {
+        text += element.value;
+      } else if (element.type === "pound") {
+        const pluralVar = Object.entries(data._meta?.variables || {}).find(
+          ([_36, meta]) => meta.role === "plural"
+        );
+        text += pluralVar?.[1].format || "%lld";
+      } else if (element.type === "argument") {
+        const varName = element.value;
+        const varMeta = data._meta?.variables?.[varName];
+        text += varMeta?.format || "%@";
+      }
+    }
+    let xcstringsFormName = form;
+    if (form.startsWith("=")) {
+      const numValue = parseInt(form.substring(1), 10);
+      xcstringsFormName = NUMBER_TO_CLDR_CATEGORY[numValue] || form;
+    }
+    forms[xcstringsFormName] = text;
+  }
+  return forms;
+}
+function parseICU(icu) {
+  const match2 = icu.match(/\{(\w+),\s*plural,\s*(.+)\}$/);
+  if (!match2) {
+    throw new Error("Invalid ICU plural format");
+  }
+  const varName = match2[1];
+  const formsText = match2[2];
+  const options = {};
+  let i = 0;
+  while (i < formsText.length) {
+    while (i < formsText.length && /\s/.test(formsText[i])) {
+      i++;
+    }
+    if (i >= formsText.length) break;
+    let formName = "";
+    if (formsText[i] === "=") {
+      formName += formsText[i];
+      i++;
+      while (i < formsText.length && /\d/.test(formsText[i])) {
+        formName += formsText[i];
+        i++;
+      }
+    } else {
+      while (i < formsText.length && /\w/.test(formsText[i])) {
+        formName += formsText[i];
+        i++;
+      }
+    }
+    if (!formName) break;
+    while (i < formsText.length && /\s/.test(formsText[i])) {
+      i++;
+    }
+    if (i >= formsText.length || formsText[i] !== "{") {
+      throw new Error(`Expected '{' after form name '${formName}'`);
+    }
+    i++;
+    let braceCount = 1;
+    let formText = "";
+    while (i < formsText.length && braceCount > 0) {
+      if (formsText[i] === "{") {
+        braceCount++;
+        formText += formsText[i];
+      } else if (formsText[i] === "}") {
+        braceCount--;
+        if (braceCount > 0) {
+          formText += formsText[i];
+        }
+      } else {
+        formText += formsText[i];
+      }
+      i++;
+    }
+    if (braceCount !== 0) {
+      const preview = formsText.substring(
+        Math.max(0, i - 50),
+        Math.min(formsText.length, i + 50)
+      );
+      throw new Error(
+        `Unclosed brace for form '${formName}' in ICU MessageFormat.
+Expected ${braceCount} more closing brace(s).
+Context: ...${preview}...
+Full ICU: {${varName}, plural, ${formsText}}`
+      );
+    }
+    const elements = parseFormText(formText);
+    options[formName] = {
+      value: elements
+    };
+  }
+  return [
+    {
+      type: "plural",
+      value: varName,
+      options
+    }
+  ];
+}
+function parseFormText(text) {
+  const elements = [];
+  let currentText = "";
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === "#") {
+      if (currentText) {
+        elements.push({ type: "literal", value: currentText });
+        currentText = "";
+      }
+      elements.push({ type: "pound" });
+      i++;
+    } else if (text[i] === "{") {
+      if (currentText) {
+        elements.push({ type: "literal", value: currentText });
+        currentText = "";
+      }
+      let braceCount = 1;
+      let j = i + 1;
+      while (j < text.length && braceCount > 0) {
+        if (text[j] === "{") {
+          braceCount++;
+        } else if (text[j] === "}") {
+          braceCount--;
+        }
+        j++;
+      }
+      if (braceCount !== 0) {
+        throw new Error("Unclosed variable reference");
+      }
+      const varName = text.slice(i + 1, j - 1);
+      elements.push({ type: "argument", value: varName });
+      i = j;
+    } else {
+      currentText += text[i];
+      i++;
+    }
+  }
+  if (currentText) {
+    elements.push({ type: "literal", value: currentText });
+  }
+  return elements;
+}
+
+// src/cli/loaders/xcode-xcstrings-v2-loader.ts
+function createXcodeXcstringsV2Loader(defaultLocale = "en") {
+  return createLoader({
+    async pull(locale, input2) {
+      const result = {};
+      for (const [key, value] of Object.entries(input2)) {
+        if (isPluralFormsObject(value)) {
+          try {
+            result[key] = xcstringsToPluralWithMeta(value, locale);
+          } catch (error) {
+            console.error(
+              `
+[xcode-xcstrings-icu] Failed to convert plural forms for key "${key}":`,
+              `
+Error: ${error instanceof Error ? error.message : String(error)}`,
+              `
+Locale: ${locale}
+`
+            );
+            result[key] = value;
+          }
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    },
+    async push(locale, payload) {
+      const result = {};
+      for (const [key, value] of Object.entries(payload)) {
+        if (isICUPluralObject(value)) {
+          try {
+            const pluralForms = pluralWithMetaToXcstrings(value);
+            result[key] = pluralForms;
+          } catch (error) {
+            throw new Error(
+              `Failed to write plural translation for key "${key}" (locale: ${locale}).
+${error instanceof Error ? error.message : String(error)}`
+            );
+          }
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    }
+  });
+}
+
 // src/cli/loaders/unlocalizable.ts
 import _10 from "lodash";
 import _isUrl from "is-url";
@@ -4544,6 +4931,15 @@ function variableExtractLoader(params) {
       const inputValues = _16.omitBy(input2, _16.isEmpty);
       for (const [key, value] of Object.entries(inputValues)) {
         const originalValue = originalInput[key];
+        if (isICUPluralObject(originalValue)) {
+          const icuValue = isICUPluralObject(value) ? { icu: value.icu } : value;
+          result[key] = {
+            value: icuValue,
+            variables: []
+            // Metadata stored separately, not in variables
+          };
+          continue;
+        }
         const matches = originalValue.match(specifierPattern) || [];
         result[key] = result[key] || {
           value,
@@ -4563,11 +4959,21 @@ function variableExtractLoader(params) {
       const result = {};
       for (const [key, valueObj] of Object.entries(data)) {
         result[key] = valueObj.value;
+        const resultValue = result[key];
+        if (isICUPluralObject(resultValue)) {
+          const originalValue = originalInput?.[key];
+          if (isICUPluralObject(originalValue) && originalValue._meta) {
+            resultValue._meta = originalValue._meta;
+            resultValue[Symbol.for("@lingo.dev/icu-plural-object")] = true;
+          }
+        }
         for (let i = 0; i < valueObj.variables.length; i++) {
           const variable = valueObj.variables[i];
           const currentValue = result[key];
-          const newValue = currentValue?.replace(`{variable:${i}}`, variable);
-          result[key] = newValue;
+          if (typeof currentValue === "string") {
+            const newValue = currentValue?.replace(`{variable:${i}}`, variable);
+            result[key] = newValue;
+          }
         }
       }
       return result;
@@ -7358,6 +7764,20 @@ function createBucketLoader(bucketType, bucketPathPattern, options, lockedKeys,
         createVariableLoader({ type: "ieee" }),
         createUnlocalizableLoader(options.returnUnlocalizedKeys)
       );
+    case "xcode-xcstrings-v2":
+      return composeLoaders(
+        createTextFileLoader(bucketPathPattern),
+        createPlutilJsonTextLoader(),
+        createJsonLoader(),
+        createXcodeXcstringsLoader(options.defaultLocale),
+        createXcodeXcstringsV2Loader(options.defaultLocale),
+        createFlatLoader({ shouldPreserveObject: isICUPluralObject }),
+        createEnsureKeyOrderLoader(),
+        createLockedKeysLoader(lockedKeys || []),
+        createSyncLoader(),
+        createVariableLoader({ type: "ieee" }),
+        createUnlocalizableLoader(options.returnUnlocalizedKeys)
+      );
     case "yaml":
       return composeLoaders(
         createTextFileLoader(bucketPathPattern),
@@ -11783,7 +12203,7 @@ async function renderHero2() {
 // package.json
 var package_default = {
   name: "lingo.dev",
-  version: "0.113.3",
+  version: "0.113.4",
   description: "Lingo.dev CLI",
   private: false,
   publishConfig: {