locize-cli 11.0.0 → 12.0.0

package/{combineSubkeyPreprocessor.js → dist/esm/combineSubkeyPreprocessor.js}

@@ -1,65 +1,65 @@
-const yaml = require('yaml')
+import yaml from 'yaml';
 
 const delimiter = {
   i18next: '_',
   i18njs: '.'
-}
+};
 
 const detectFormat = (keys) => {
-  const i18nextMatches = keys.filter((k) => k.indexOf(delimiter.i18next) > 0).length
-  const i18njsMatches = keys.filter((k) => k.indexOf(delimiter.i18njs) > 0).length
+  const i18nextMatches = keys.filter((k) => k.indexOf(delimiter.i18next) > 0).length;
+  const i18njsMatches = keys.filter((k) => k.indexOf(delimiter.i18njs) > 0).length;
   if (i18nextMatches > i18njsMatches) {
     return 'i18next'
   }
   if (i18nextMatches < i18njsMatches) {
     return 'i18njs'
   }
-}
+};
 
 const getBaseKey = (delimiter) => (k) => {
-  const parts = k.split(delimiter)
-  parts.pop()
-  const baseKey = parts.join(delimiter)
+  const parts = k.split(delimiter);
+  parts.pop();
+  const baseKey = parts.join(delimiter);
   return baseKey
-}
+};
 
-const uniq = (value, index, self) => self.indexOf(value) === index
+const uniq = (value, index, self) => self.indexOf(value) === index;
 
 const stringify = (o) => {
-  let str = yaml.stringify(o)
-  const subKeys = Object.keys(o)
+  let str = yaml.stringify(o);
+  const subKeys = Object.keys(o);
   subKeys.forEach((sk) => {
     if (isNaN(sk)) {
-      str = str.replace(new RegExp(`^(?:${sk}: )+`, 'm'), `{${sk}}: `)
+      str = str.replace(new RegExp(`^(?:${sk}: )+`, 'm'), `{${sk}}: `);
     } else {
-      str = str.replace(new RegExp(`^(?:'${sk}': )+`, 'm'), `{${sk}}: `)
+      str = str.replace(new RegExp(`^(?:'${sk}': )+`, 'm'), `{${sk}}: `);
     }
-  })
+  });
   return str
-}
+};
 
 const transformKeys = (segments, baseKeys, toMerge, deli) => {
   baseKeys.forEach((bk) => {
     const asObj = toMerge[bk].reduce((mem, k) => {
-      const subKey = k.substring((bk + deli).length)
+      const subKey = k.substring((bk + deli).length);
       // special handling for i18next v3
       if (deli === delimiter.i18next && subKey === 'plural' && segments[bk]) {
-        mem['__'] = segments[bk]
-        delete segments[bk]
+        mem['__'] = segments[bk];
+        delete segments[bk];
       }
-      mem[subKey] = segments[k]
+      mem[subKey] = segments[k];
       return mem
-    }, {})
+    }, {});
     if (Object.keys(asObj).length > 0) {
-      const value = stringify(asObj)
-      segments[`${bk}__#locize.com/combinedSubkey`] = value
+      const value = stringify(asObj);
+      segments[`${bk}__#locize.com/combinedSubkey`] = value;
       toMerge[bk].forEach((k) => {
-        delete segments[k]
-      })
+        delete segments[k];
+      });
     }
-  })
+  });
   return segments
-}
+};
 
 // CLDR
 const pluralForms = [
@@ -69,87 +69,84 @@ const pluralForms = [
   'few',
   'many',
   'other'
-]
+];
 
-const endsWithPluralForm = (k) => !!pluralForms.find((f) => k.endsWith(`.${f}`)) || !!pluralForms.find((f) => k.endsWith(`_${f}`)) || /_\d+$/.test(k) || k.endsWith('_plural')
+const endsWithPluralForm = (k) => !!pluralForms.find((f) => k.endsWith(`.${f}`)) || !!pluralForms.find((f) => k.endsWith(`_${f}`)) || /_\d+$/.test(k) || k.endsWith('_plural');
 
 const prepareExport = (refRes, trgRes) => {
-  const refLngKeys = Object.keys(refRes)
-  const trgLngKeys = Object.keys(trgRes)
+  const refLngKeys = Object.keys(refRes);
+  const trgLngKeys = Object.keys(trgRes);
 
-  const nonMatchInRef = refLngKeys.filter((k) => trgLngKeys.indexOf(k) < 0 && endsWithPluralForm(k))
-  const nonMatchInTrg = trgLngKeys.filter((k) => refLngKeys.indexOf(k) < 0 && endsWithPluralForm(k))
+  const nonMatchInRef = refLngKeys.filter((k) => trgLngKeys.indexOf(k) < 0 && endsWithPluralForm(k));
+  const nonMatchInTrg = trgLngKeys.filter((k) => refLngKeys.indexOf(k) < 0 && endsWithPluralForm(k));
 
-  const allMatches = nonMatchInRef.concat(nonMatchInTrg)
+  const allMatches = nonMatchInRef.concat(nonMatchInTrg);
 
-  const format = detectFormat(allMatches)
+  const format = detectFormat(allMatches);
   if (!format) return { ref: refRes, trg: trgRes }
 
-  const nonMatchBaseKeysInRef = nonMatchInRef.map(getBaseKey(delimiter[format])).filter(uniq)
-  const nonMatchBaseKeysInTrg = nonMatchInTrg.map(getBaseKey(delimiter[format])).filter(uniq)
-  const nonMatchBaseKeys = nonMatchBaseKeysInRef.concat(nonMatchBaseKeysInTrg).filter(uniq)
+  const nonMatchBaseKeysInRef = nonMatchInRef.map(getBaseKey(delimiter[format])).filter(uniq);
+  const nonMatchBaseKeysInTrg = nonMatchInTrg.map(getBaseKey(delimiter[format])).filter(uniq);
+  const nonMatchBaseKeys = nonMatchBaseKeysInRef.concat(nonMatchBaseKeysInTrg).filter(uniq);
 
   const toMergeInRef = nonMatchBaseKeys.reduce((mem, bk) => {
-    mem[bk] = refLngKeys.filter((k) => k.indexOf(bk + delimiter[format]) === 0)
+    mem[bk] = refLngKeys.filter((k) => k.indexOf(bk + delimiter[format]) === 0);
     return mem
-  }, {})
+  }, {});
   const toMergeInTrg = nonMatchBaseKeys.reduce((mem, bk) => {
-    mem[bk] = trgLngKeys.filter((k) => k.indexOf(bk + delimiter[format]) === 0)
+    mem[bk] = trgLngKeys.filter((k) => k.indexOf(bk + delimiter[format]) === 0);
     return mem
-  }, {})
+  }, {});
 
-  let falseFlags = nonMatchBaseKeysInRef.filter((k) => toMergeInRef[k].length < 2 && (!toMergeInTrg[k] || toMergeInTrg[k].length < 2))
-  falseFlags = falseFlags.concat(nonMatchBaseKeysInTrg.filter((k) => toMergeInTrg[k].length < 2 && (!toMergeInRef[k] || toMergeInRef[k].length < 2)))
+  let falseFlags = nonMatchBaseKeysInRef.filter((k) => toMergeInRef[k].length < 2 && (!toMergeInTrg[k] || toMergeInTrg[k].length < 2));
+  falseFlags = falseFlags.concat(nonMatchBaseKeysInTrg.filter((k) => toMergeInTrg[k].length < 2 && (!toMergeInRef[k] || toMergeInRef[k].length < 2)));
   falseFlags.forEach((k) => {
-    delete toMergeInRef[k]
-    delete toMergeInTrg[k]
-    nonMatchBaseKeys.splice(nonMatchBaseKeys.indexOf(k), 1)
-  })
+    delete toMergeInRef[k];
+    delete toMergeInTrg[k];
+    nonMatchBaseKeys.splice(nonMatchBaseKeys.indexOf(k), 1);
+  });
 
-  const transformedRef = transformKeys(refRes, nonMatchBaseKeys, toMergeInRef, delimiter[format])
-  const transformedTrg = transformKeys(trgRes, nonMatchBaseKeys, toMergeInTrg, delimiter[format])
+  const transformedRef = transformKeys(refRes, nonMatchBaseKeys, toMergeInRef, delimiter[format]);
+  const transformedTrg = transformKeys(trgRes, nonMatchBaseKeys, toMergeInTrg, delimiter[format]);
   return { ref: transformedRef, trg: transformedTrg }
-}
+};
 
 // eslint-disable-next-line prefer-regex-literals
-const skRegex = new RegExp('^(?:{(.+)})+', 'gm')
+const skRegex = new RegExp('^(?:{(.+)})+', 'gm');
 const parse = (s) => {
-  let matchArray
+  let matchArray;
   while ((matchArray = skRegex.exec(s)) !== null) {
-    const [match, sk] = matchArray
+    const [match, sk] = matchArray;
     if (isNaN(sk)) {
-      s = s.replace(new RegExp(`^(?:${match}: )+`, 'm'), `${sk}: `)
+      s = s.replace(new RegExp(`^(?:${match}: )+`, 'm'), `${sk}: `);
     } else {
-      const escapedMatch = match.replace('{', '\\{').replace('}', '\\}')
-      s = s.replace(new RegExp(`^(?:${escapedMatch}: )+`, 'm'), `${sk}: `)
+      const escapedMatch = match.replace('{', '\\{').replace('}', '\\}');
+      s = s.replace(new RegExp(`^(?:${escapedMatch}: )+`, 'm'), `${sk}: `);
     }
   }
   return yaml.parse(s)
-}
+};
 
 const prepareImport = (resources) => {
-  const keys = Object.keys(resources)
+  const keys = Object.keys(resources);
   keys.forEach((k) => {
     if (k.indexOf('__#locize.com/combinedSubkey') > -1) {
-      const baseKey = k.substring(0, k.indexOf('__#locize.com/combinedSubkey'))
+      const baseKey = k.substring(0, k.indexOf('__#locize.com/combinedSubkey'));
       if (resources[k]) {
-        const parsed = parse(resources[k])
+        const parsed = parse(resources[k]);
         Object.keys(parsed).forEach((sk) => {
-          const skVal = parsed[sk]
-          resources[`${baseKey}_${sk}`] = skVal
+          const skVal = parsed[sk];
+          resources[`${baseKey}_${sk}`] = skVal;
           if (sk === '__') {
-            resources[baseKey] = resources[`${baseKey}_${sk}`]
-            delete resources[`${baseKey}_${sk}`]
+            resources[baseKey] = resources[`${baseKey}_${sk}`];
+            delete resources[`${baseKey}_${sk}`];
           }
-        })
-        delete resources[k]
+        });
+        delete resources[k];
       }
     }
-  })
+  });
   return resources
-}
+};
 
-module.exports = {
-  prepareExport,
-  prepareImport
-}
+export { prepareExport, prepareImport };

package/dist/esm/convertToDesiredFormat.js

@@ -0,0 +1,203 @@
+import flatten from 'flat';
+import i18next2po from 'gettext-converter/i18next2po';
+import csv from 'fast-csv';
+import xlsx from 'xlsx';
+import yaml from 'yaml';
+import js2asr from 'android-string-resource/js2asr';
+import stringsFile from 'strings-file';
+import createxliff from 'xliff/createxliff';
+import createxliff12 from 'xliff/createxliff12';
+import js2resx from 'resx/js2resx';
+import js2ftl from 'fluent_conv/js2ftl';
+import js2tmx from 'tmexchange/js2tmx';
+import js2laravel from 'laravelphp/js2laravel';
+import javaProperties from '@js.properties/properties';
+import unflatten from './unflatten.js';
+import getRemoteNamespace from './getRemoteNamespace.js';
+import removeUndefinedFromArrays from './removeUndefinedFromArrays.js';
+import shouldUnflatten from './shouldUnflatten.js';
+import { prepareExport } from './combineSubkeyPreprocessor.js';
+
+const convertToDesiredFormat = async (
+  opt,
+  namespace,
+  lng,
+  data,
+  lastModified
+) => {
+  opt.getNamespace = opt.getNamespace || getRemoteNamespace;
+  const isEmpty = !data || Object.keys(data).length === 0;
+  if (opt.format === 'json') {
+    try {
+      data = unflatten(data, true);
+    } catch (err) {}
+    return JSON.stringify(data, null, 2)
+  }
+  if (opt.format === 'nested') {
+    try {
+      data = unflatten(data);
+    } catch (err) {}
+    return JSON.stringify(data, null, 2)
+  }
+  if (opt.format === 'flat') {
+    return JSON.stringify(flatten(data), null, 2)
+  }
+  if (opt.format === 'po' || opt.format === 'gettext') {
+    const flatData = flatten(data);
+    const gettextOpt = {
+      project: 'locize',
+      language: lng,
+      potCreationDate: lastModified,
+      poRevisionDate: lastModified,
+      ctxSeparator: '_ is default but we set it to something that is never found!!!',
+      persistMsgIdPlural: true
+    };
+    return i18next2po(lng, flatData, gettextOpt)
+  }
+  if (opt.format === 'po_i18next' || opt.format === 'gettext_i18next') {
+    const flatData = flatten(data);
+    const compatibilityJSON = !!Object.keys(flatData).find((k) => /_(zero|one|two|few|many|other)/.test(k)) && 'v4';
+    const gettextOpt = {
+      project: 'locize',
+      language: lng,
+      potCreationDate: lastModified,
+      poRevisionDate: lastModified,
+      compatibilityJSON
+    };
+    return i18next2po(lng, flatData, gettextOpt)
+  }
+  if (opt.format === 'csv') {
+    const refNs = await opt.getNamespace(opt, opt.referenceLanguage, namespace);
+    const js2CsvData = Object.keys(flatten(data)).reduce((mem, k) => {
+      const value = data[k] || '';
+      const line = {
+        key: k,
+        [opt.referenceLanguage]: refNs[k] || '',
+        [lng]: value
+      };
+      mem.push(line);
+      return mem
+    }, []);
+    return `\ufeff${await csv.writeToString(js2CsvData, { headers: true, quoteColumns: true })}`
+  }
+  if (opt.format === 'xlsx') {
+    const refNs = await opt.getNamespace(opt, opt.referenceLanguage, namespace);
+    const js2XlsxData = Object.keys(flatten(data)).reduce((mem, k) => {
+      const value = data[k] || '';
+      const line = {
+        key: k,
+        [opt.referenceLanguage]: refNs[k] || '',
+        [lng]: value
+      };
+      mem.push(line);
+      return mem
+    }, []);
+    const worksheet = xlsx.utils.json_to_sheet(js2XlsxData);
+    const workbook = xlsx.utils.book_new();
+    let workSheetName = namespace;
+    if (workSheetName.length > 31) workSheetName = workSheetName.substring(0, 31);
+    workbook.SheetNames.push(workSheetName);
+    workbook.Sheets[workSheetName] = worksheet;
+    return xlsx.write(workbook, { type: 'buffer' })
+  }
+  if (
+    opt.format === 'yaml' ||
+    opt.format === 'yml'
+  ) {
+    if (isEmpty) return ''
+    return yaml.stringify(flatten(data))
+  }
+  if (
+    opt.format === 'yaml-nested' ||
+    opt.format === 'yml-nested'
+  ) {
+    if (isEmpty) return ''
+    return yaml.stringify(shouldUnflatten(data) ? unflatten(data) : data)
+  }
+  if (
+    opt.format === 'yaml-rails' ||
+    opt.format === 'yml-rails'
+  ) {
+    if (isEmpty) return ''
+    const newData = {};
+    newData[lng] = shouldUnflatten(data) ? unflatten(data) : data;
+    return yaml.stringify(removeUndefinedFromArrays(newData))
+  }
+  if (
+    opt.format === 'yaml-rails-ns' ||
+    opt.format === 'yml-rails-ns'
+  ) {
+    if (isEmpty) return ''
+    const newDataNs = {};
+    newDataNs[lng] = {};
+    newDataNs[lng][namespace] = shouldUnflatten(data) ? unflatten(data) : data;
+    return yaml.stringify(removeUndefinedFromArrays(newDataNs))
+  }
+  if (opt.format === 'android') {
+    return await js2asr(flatten(data))
+  }
+  if (opt.format === 'strings') {
+    Object.keys(data).forEach((k) => {
+      if (data[k] === null) delete data[k];
+    });
+    return stringsFile.compile(data)
+  }
+  if (
+    opt.format === 'xliff2' ||
+    opt.format === 'xliff12' ||
+    opt.format === 'xlf2' ||
+    opt.format === 'xlf12'
+  ) {
+    const fn =
+      opt.format === 'xliff12' || opt.format === 'xlf12'
+        ? createxliff12
+        : createxliff;
+    const refNs = await opt.getNamespace(opt, opt.referenceLanguage, namespace);
+    const prepared = prepareExport(refNs, flatten(data));
+    return await fn(opt.referenceLanguage, lng, prepared.ref, prepared.trg, namespace)
+  }
+  if (opt.format === 'resx') {
+    return await js2resx(flatten(data))
+  }
+  if (opt.format === 'fluent') {
+    Object.keys(data).forEach((k) => {
+      if (!data[k] || data[k] === '') delete data[k];
+      data[k] = data[k].replace(
+        new RegExp(String.fromCharCode(160), 'g'),
+        String.fromCharCode(32)
+      );
+    });
+    return js2ftl(unflatten(data))
+  }
+  if (opt.format === 'tmx') {
+    const refNs = await opt.getNamespace(opt, opt.referenceLanguage, namespace);
+    const js = flatten(data);
+    const js2TmxData = Object.keys(js).reduce(
+      (mem, k) => {
+        const refItem = refNs[k];
+        if (!refItem) return mem
+        const value = js[k] || '';
+        mem.resources[namespace][k] = {};
+        mem.resources[namespace][k][opt.referenceLanguage] = refItem;
+        mem.resources[namespace][k][lng] = value;
+        return mem
+      },
+      {
+        resources: {
+          [namespace]: {}
+        },
+        sourceLanguage: opt.referenceLanguage
+      }
+    );
+    return await js2tmx(js2TmxData)
+  }
+  if (opt.format === 'laravel') {
+    return await js2laravel(unflatten(data))
+  }
+  if (opt.format === 'properties') {
+    return javaProperties.stringifyFromProperties(data, { eol: '\n' })
+  }
+  throw new Error(`${opt.format} is not a valid format!`)
+};
+
+export { convertToDesiredFormat as default };

package/dist/esm/convertToFlatFormat.js

@@ -0,0 +1,229 @@
+import po2i18next from 'gettext-converter/po2i18next';
+import csv from 'fast-csv';
+import xlsx from 'xlsx';
+import yaml from 'yaml';
+import asr2js from 'android-string-resource/asr2js';
+import stringsFile from 'strings-file';
+import xliff2js from 'xliff/xliff2js';
+import xliff12ToJs from 'xliff/xliff12ToJs';
+import targetOfjs from 'xliff/targetOfjs';
+import sourceOfjs from 'xliff/sourceOfjs';
+import resx2js from 'resx/resx2js';
+import ftl2js from 'fluent_conv/ftl2js';
+import tmx2js from 'tmexchange/tmx2js';
+import laravel2js from 'laravelphp/laravel2js';
+import javaProperties from '@js.properties/properties';
+import xcstrings2locize from 'locize-xcstrings/xcstrings2locize';
+import flatten from 'flat';
+import { prepareImport } from './combineSubkeyPreprocessor.js';
+
+const convertToFlatFormat = async (opt, data, lng) => {
+  if (lng && typeof lng !== 'string') lng = undefined;
+  if (opt.format === 'json' || opt.format === 'nested' || opt.format === 'flat') {
+    const dataString = data.toString().trim();
+    if (dataString[0] !== '{' && dataString[0] !== '[') {
+      throw new Error(`Not a valid json file: Content starts with "${dataString[0]}" but should start with "{"`)
+    }
+    const jsonParsed = JSON.parse(dataString);
+    return flatten(jsonParsed)
+  }
+  if (opt.format === 'po' || opt.format === 'gettext') {
+    const ret = po2i18next(data.toString(), {
+      persistMsgIdPlural: true,
+      ignoreCtx: true
+    });
+    return flatten(ret)
+  }
+  if (opt.format === 'po_i18next' || opt.format === 'gettext_i18next') {
+    const potxt = data.toString();
+    const compatibilityJSON = /msgctxt "(zero|one|two|few|many|other)"/.test(potxt) && 'v4';
+    const ret = po2i18next(potxt, { compatibilityJSON });
+    return flatten(ret)
+  }
+  if (opt.format === 'csv') {
+    // CRLF => LF
+    const text = data.toString().replace(/\r\n/g, '\n');
+    const rows = await csv.parseString(text, { headers: true, ignoreEmpty: true }).promise();
+    const result = rows.reduce((mem, entry) => {
+      if (entry.key && typeof entry[opt.referenceLanguage] === 'string') {
+        mem[entry.key] = entry[opt.referenceLanguage];
+      }
+      return mem
+    }, {});
+    return result
+  }
+  if (opt.format === 'xlsx') {
+    const wb = xlsx.read(data, { type: 'buffer' });
+    const jsonData = xlsx.utils.sheet_to_json(wb.Sheets[wb.SheetNames[0]]);
+    const result = jsonData.reduce((mem, entry) => {
+      if (entry.key && typeof entry[opt.referenceLanguage] === 'string') {
+        mem[entry.key] = entry[opt.referenceLanguage];
+      }
+      return mem
+    }, {});
+    return result
+  }
+  if (
+    opt.format === 'yaml' ||
+    opt.format === 'yml'
+  ) {
+    const d = data.toString();
+    if (!d || d === '' || d === '\n') return {}
+    return flatten(yaml.parse(d))
+  }
+  if (
+    opt.format === 'yaml-nested' ||
+    opt.format === 'yml-nested'
+  ) {
+    const d = data.toString();
+    if (!d || d === '' || d === '\n') return {}
+    return flatten(yaml.parse(d))
+  }
+  if (
+    opt.format === 'yaml-rails' ||
+    opt.format === 'yml-rails'
+  ) {
+    const d = data.toString();
+    if (!d || d.trim() === '') return {}
+    const jsObj = yaml.parse(d);
+    return flatten(jsObj[Object.keys(jsObj)[0]])
+  }
+  if (
+    opt.format === 'yaml-rails-ns' ||
+    opt.format === 'yml-rails-ns'
+  ) {
+    const dn = data.toString();
+    if (!dn || dn.trim() === '') return {}
+    const jsObjn = yaml.parse(dn);
+    return flatten(jsObjn[Object.keys(jsObjn)[0]][Object.keys(jsObjn[Object.keys(jsObjn)[0]])[0]])
+  }
+  if (opt.format === 'android') {
+    const res = await asr2js(data.toString(), { comment: 'right' });
+    Object.keys(res).forEach((k) => {
+      if (res[k] !== 'string' && typeof res[k].comment === 'string') {
+        res[k] = {
+          value: res[k].value,
+          context: {
+            text: res[k].comment,
+          },
+        };
+      } else {
+        res[k] = { value: res[k].value || res[k] };
+      }
+    });
+    return res
+  }
+  if (opt.format === 'strings') {
+    // CRLF => LF
+    return stringsFile.parse(data.toString().replace(/\r\n/g, '\n'), false)
+  }
+  if (
+    opt.format === 'xliff2' ||
+    opt.format === 'xliff12' ||
+    opt.format === 'xlf2' ||
+    opt.format === 'xlf12'
+  ) {
+    const fn =
+      opt.format === 'xliff12' || opt.format === 'xlf12'
+        ? xliff12ToJs
+        : xliff2js;
+    const res = await fn(data.toString());
+    res.resources = res.resources || {};
+    const ns = Object.keys(res.resources)[0];
+    const orgRes = res.resources[ns] || res.resources;
+    function checkForPostProcessing (nsRes) {
+      Object.keys(nsRes).forEach((k) => {
+        if (orgRes[k].note && (typeof nsRes[k] === 'string' || !nsRes[k])) {
+          nsRes[k] = {
+            value: nsRes[k],
+            context: {
+              text: orgRes[k].note,
+            }
+          };
+        }
+      });
+      return prepareImport(nsRes)
+    }
+    if (!res.targetLanguage) {
+      const ret = await sourceOfjs(res);
+      return checkForPostProcessing(ret)
+    } else {
+      let ret = targetOfjs(res);
+      if (lng !== opt.referenceLanguage) return checkForPostProcessing(ret)
+      ret = ret || {};
+      const keys = Object.keys(ret);
+      if (keys.length === 0) return checkForPostProcessing(ret)
+      const allEmpty = keys.filter((k) => ret[k] !== '').length === 0;
+      if (!allEmpty) return checkForPostProcessing(ret)
+      ret = await sourceOfjs(res);
+      return checkForPostProcessing(ret)
+    }
+  }
+  if (opt.format === 'resx') {
+    let res = await resx2js(data.toString());
+    res = Object.keys(res).reduce((mem, k) => {
+      const value = res[k];
+      if (typeof value === 'string') {
+        mem[k] = value;
+      } else if (value.value) {
+        mem[k] = {
+          value: value.value,
+          context: value.comment ? { text: value.comment } : null,
+        };
+      }
+      return mem
+    }, {});
+    return res
+  }
+  if (opt.format === 'fluent') {
+    const fluentJS = ftl2js(
+      data
+        .toString()
+        .replace(
+          new RegExp(String.fromCharCode(160), 'g'),
+          String.fromCharCode(32)
+        )
+    );
+    const comments = {};
+    Object.keys(fluentJS).forEach((prop) => {
+      if (fluentJS[prop] && fluentJS[prop].comment) {
+        comments[prop] = fluentJS[prop].comment;
+        delete fluentJS[prop].comment;
+      }
+    });
+    const res = flatten(fluentJS);
+    if (res && comments) {
+      Object.keys(comments).forEach((prop) => {
+        res[`${prop}.val`] = {
+          value: res[`${prop}.val`],
+          context: comments[prop] ? { text: comments[prop] } : null,
+        };
+      });
+    }
+    return res
+  }
+  if (opt.format === 'tmx') {
+    const jsonData = await tmx2js(data.toString());
+    const tmxJsRes = jsonData.resources[Object.keys(jsonData.resources)[0]];
+    const res = {};
+    if (tmxJsRes) {
+      Object.keys(tmxJsRes).forEach((k) => {
+        res[k] = tmxJsRes[k][opt.referenceLanguage];
+      });
+    }
+    return res
+  }
+  if (opt.format === 'laravel') {
+    const res = await laravel2js(data.toString());
+    return flatten(res)
+  }
+  if (opt.format === 'properties') {
+    return javaProperties.parseToProperties(data.toString())
+  }
+  if (opt.format === 'xcstrings') {
+    return xcstrings2locize(data.toString())
+  }
+  throw new Error(`${opt.format} is not a valid format!`)
+};
+
+export { convertToFlatFormat as default };