handlebars-i18n-cli 1.0.5 → 2.0.1

package/src/i18n-collect.js

@@ -1,151 +1,43 @@
-/*********************************************************************
+/****************************************
  * i18n-collect.js
- *
  * @author: Florian Walzel
- * @date: 2022-10
- *
- * Usage:
- * $ i18n-collect <source> <target> <options...>
- *
- * valid options:
- * --alphabetical || -a
- * --dryRun || -dr
- * --empty || -e
- * --lng=de,fr,es,etc…
- * --log || -l
- * --separateLngFiles || -sf
- * --translFunc=yourCustomFunctionName
- * --update || -u*
- *
- * Copyright (c) 2020 Florian Walzel, MIT LICENSE
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaininga copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
- * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
- * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
- * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * THE SOFTWARE.
  *
- *********************************************************************/
-
+ ****************************************/
 
-'use strict';
 
 /****************************************
- * REQUIRE & DEFINE
+ * IMPORT
  ****************************************/
 
-const fs = require('fs')
-const { promisify } = require('util')
-const readFileAsync = promisify(fs.readFile)
-const writeFileAsync = promisify(fs.writeFile)
-
+import fst from 'async-file-tried';
+import {glob} from 'glob';
 
 /****************************************
- * FUNCTIONS
+ * PRIVATE FUNCTIONS
  ****************************************/
 
 /**
- * Asynchronously read file
- *
- * @param file
- * @returns {Promise<*>}
- */
-async function readFile (file) {
-  try {
-    const data = await readFileAsync(file, 'utf8')
-    return data
-  }
-  catch (e) {
-    console.log('\x1b[31m%s\x1b[0m', `Error. Could not read ${file}`)
-    console.error(e)
-    return false
-  }
-}
-
-/**
- * Asynchronously write file in utf8 encoding
- *
- * @param file
- * @param data
- * @returns {Promise<boolean>}
- */
-async function writeFile(file, data) {
-  try {
-    await writeFileAsync(file, data, 'utf8')
-    return true
-  }
-  catch (e) {
-    console.log('\x1b[31m%s\x1b[0m', `Error. Could not write ${file}`)
-    console.error(e)
-    return false
-  }
-}
-
-/**
- * Simple object check.
+ * Simple object check
  *
  * @param item
  * @returns {boolean}
  */
 function isObject(item) {
-  return (item && typeof item === 'object' && ! Array.isArray(item))
+  return (item && typeof item === 'object' && !Array.isArray(item))
 }
 
 /**
  * Conditionally removes a substring (file extension)
- * from end of given string.
+ * from end of given string
  *
  * @param str
  * @param ending
  * @returns {*|string[]}
  */
-function sanitizeFileExt(str, ending='.json') {
+function sanitizeFileExt(str, ending = '.json') {
   return str.toLowerCase().endsWith(ending) ? str.slice(0, ending.length * (-1)) : str
 }
 
-/**
- * Log the help information to console
- * @returns {boolean}
- */
-function logHelp() {
-  console.log('\x1b[2m%s', 'Usage:')
-  console.log('i18n-collect <source> <target> <options...>')
-  console.log('')
-  console.log('<source>                 path to handlebars.js template file(s), glob pattern allowed')
-  console.log('<target>                 json file(s) to write result to')
-  console.log('')
-  console.log('<options>')
-  console.log('--alphabetical or -a     will order the keys to the translation strings alphabetically in the json')
-  console.log('                         default: keys in order of appearance as within the template(s)')
-  console.log('--dryRun or -dr          will log the result(s) but not write out json file(s)')
-  console.log('--empty or -e            will create empty value strings for the translations in the json')
-  console.log('                         default: value strings contain current language and key name')
-  console.log('--lng=en,fr,es,…         the languages you want to be generated')
-  console.log('                         default: en')
-  console.log('--log or -l              log final results to console')
-  console.log('--separateLngFiles       write each language in a separate json file')
-  console.log('  or -sf                 default: all languages are written as arrays in one json file')
-  console.log('--translFunc=customName  a custom name of the translation function used in the templates')
-  console.log('                         default: __ like handlebars-i18n notation: {{__ keyToTranslate}}')
-  console.log('--update or -u           updates existing json files(s) after changes made in template file(s)')
-  console.log('\x1b[0m')
-  return true
-}
-
 /**
  * A collection of functions to extract and handle the
  * strings between mustaches {{ ... }}
@@ -157,8 +49,8 @@ function logHelp() {
  * getAllResults: mustacheBetweens.getAllResults}}
  */
 const mustacheBetweens = {
-  results : [ ],
-  str : '',
+  results: [],
+  str: '',
   /**
    * Returns a substring between an opening and
    * a closing string sequence in a given string
@@ -167,51 +59,49 @@ const mustacheBetweens = {
    * @param sub2
    * @returns {string|boolean}
    */
-  getFromBetween : function(sub1, sub2) {
-    if (this.str.indexOf(sub1) < 0 || this.str.indexOf(sub2) < 0)
-      return false
+  getFromBetween: function (sub1, sub2) {
     let SP = this.str.indexOf(sub1) + sub1.length,
-        string1 = this.str.substr(0, SP),
-        string2 = this.str.substr(SP),
-        TP = string1.length + string2.indexOf(sub2)
+      string1 = this.str.slice(0, SP),
+      string2 = this.str.slice(SP),
+      TP = string1.length + string2.indexOf(sub2);
+
     return this.str.substring(SP, TP)
   },
 
   /**
    * Removes a found sequence between an opening and
-   * a closing string from a a given string
+   * a closing string from a given string
    *
    * @param sub1
    * @param sub2
    * @returns {boolean}
    */
-  removeFromBetween : function(sub1, sub2) {
-    if (this.str.indexOf(sub1) < 0 || this.str.indexOf(sub2) < 0)
-      return false
-    let removal = sub1 + this.getFromBetween(sub1, sub2) + sub2
-    this.str = this.str.replace(removal,'')
+  removeFromBetween: function (sub1, sub2) {
+    let removal = sub1 + this.getFromBetween(sub1, sub2) + sub2;
+    this.str = this.str.replace(removal, '');
+    return true
   },
 
   /**
    * gets all substrings of a string that are between an opening character sequence (sub1)
-   * and a closing sequence (sub2). The Result is stored in parent results array.
+   * and a closing sequence (sub2). The Result is stored in parent results array
    *
    * @param sub1
    * @param sub2
    */
-  getAllResults : function(sub1, sub2) {
+  getAllResults: function (sub1, sub2) {
     //  first check to see if we do have both substrings
     if (this.str.indexOf(sub1) < 0 || this.str.indexOf(sub2) < 0)
-      return false
+      return false;
     //  find first result
-    let result = this.getFromBetween(sub1, sub2)
+    let result = this.getFromBetween(sub1, sub2);
     //  replace multiple spaces by a single one, then trim and push it to the results array
-    this.results.push(result.replace(/ +(?= )/g,'').trim())
+    this.results.push(result.replace(/ +(?= )/g, '').trim());
     //  remove the most recently found one from the string
-    this.removeFromBetween(sub1, sub2)
+    this.removeFromBetween(sub1, sub2);
     //  recursion in case there are more substrings
     if (this.str.indexOf(sub1) > -1 && this.str.indexOf(sub2) > -1)
-      this.getAllResults(sub1, sub2)
+      this.getAllResults(sub1, sub2);
   },
 
   /**
@@ -221,34 +111,34 @@ const mustacheBetweens = {
    * @param sub2
    * @returns {*}
    */
-  getSorted : function(string, translFuncName, sub1='{{', sub2='}}') {
-    this.str = string
-    this.getAllResults(sub1, sub2)
+  getSorted: function (string, translFuncName, sub1 = '{{', sub2 = '}}') {
+    this.str = string;
+    this.getAllResults(sub1, sub2);
     this.results =
       this.results.filter(
-      (el) => {
-        return typeof el === 'string' && el.startsWith(`${translFuncName} `)
-      })
-      .map(
         (el) => {
-          //  remove leading translation function and explode string by space
-          let splited = el.replace(`${translFuncName} `, '').split(' ')
-          //  remove quotation marks around key name in element 0 of array
-          splited[0] = splited[0]
-            .replace(/"/g, '')
-            .replace(/'/g, '')
-          //  split remaining string in first element of array by dot (.) to get separate keys of a dot-notated object
-          let keys = splited[0].split('.')
-          //  transformed is a container object for key
-          let transformed = { }
-          transformed.keys = keys
-          transformed.replacementVars = [ ]
-          //  split following elements by '=' and preserve first element of split
-          for (let i = 1; i < splited.length; i++)
-            transformed.replacementVars[i-1] = splited[i].split('=')[0]
-
-          return transformed
-      })
+          return typeof el === 'string' && el.startsWith(`${translFuncName} `)
+        })
+        .map(
+          (el) => {
+            //  remove leading translation function and explode string by space
+            let splited = el.replace(`${translFuncName} `, '').split(' ');
+            //  remove quotation marks around key name in element 0 of array
+            splited[0] = splited[0]
+              .replace(/"/g, '')
+              .replace(/'/g, '');
+            //  split remaining string in first element of array by dot (.) to get separate keys of a dot-notated object
+            let keys = splited[0].split('.');
+            //  transformed is a container object for key
+            let transformed = {};
+            transformed.keys = keys;
+            transformed.replacementVars = [];
+            //  split following elements by '=' and preserve first element of split
+            for (let i = 1; i < splited.length; i++)
+              transformed.replacementVars[i - 1] = splited[i].split('=')[0];
+
+            return transformed
+          });
     return this.results
   }
 };
@@ -266,22 +156,22 @@ const mustacheBetweens = {
  * @returns {*}
  */
 const arrRmvDuplicateValues = (arr) => {
-  let seen = { }
+  let seen = {};
   return arr.filter((item) => {
     return seen.hasOwnProperty(item.keys) ? false : seen[item.keys] = true
   })
-}
+};
 
 
 /**
- * Builds a nested object with key-value-pairs from a three-dimensional array.
+ * Builds a nested object with key-value-pairs from a three-dimensional array
  *
  * @param arr
  * @param lang
  * @param empty
  * @returns {{}}
  */
-function objectify (arr, lang='en', empty = false) {
+function objectify(arr, lang = 'en', empty = false) {
 
   /**
    *
@@ -290,16 +180,14 @@ function objectify (arr, lang='en', empty = false) {
    * @param arr
    * @param pos
    */
-  function __iterateArr (obj, val, arr, pos) {
-    if (! obj.hasOwnProperty(arr[pos])) {
+  function __iterateArr(obj, val, arr, pos) {
+    if (!obj.hasOwnProperty(arr[pos])) {
       if (pos + 1 < arr.length) {
-        obj[arr[pos]] = { }
-        __iterateArr(obj[arr[pos]], val, arr, pos + 1)
-      }
-      else
+        obj[arr[pos]] = {};
+        __iterateArr(obj[arr[pos]], val, arr, pos + 1);
+      } else
         obj[arr[pos]] = val;
-    }
-    else if (pos+1 < arr.length)
+    } else if (pos + 1 < arr.length)
       __iterateArr(obj[arr[pos]], val, arr, pos + 1);
   }
 
@@ -311,22 +199,22 @@ function objectify (arr, lang='en', empty = false) {
    * @param textBefore
    * @returns {string}
    */
-  function __listTranslVariables(arr, textBefore= '')  {
+  function __listTranslVariables(arr, textBefore = '') {
     let str = '';
     if (arr.length === 0)
       return str;
     for (let elem of arr)
       str += `{{${elem}}} `;
-    return textBefore + str.slice(0, -1);
+    return textBefore + str.slice(0, -1)
   }
 
-  let obj = { }
+  let obj = {}
   arr.forEach((el) => {
     let prop;
     if (empty)
       prop = __listTranslVariables(el.replacementVars);
     else
-      prop = `${lang} of ${el.keys.join('.') + __listTranslVariables(el.replacementVars, ' with variables ')}`
+      prop = `${lang} of ${el.keys.join('.') + __listTranslVariables(el.replacementVars, ' with variables ')}`;
     __iterateArr(obj, prop, el.keys, 0)
   })
 
@@ -335,27 +223,29 @@ function objectify (arr, lang='en', empty = false) {
 
 /**
  * Deep merge two objects whereby all properties of
- * sources are kept and the target properties are added.
+ * sources are kept and the target properties are added
  *
  * @param target
  * @param ...sources
  */
 function mergeDeep(target, ...sources) {
-  if (! sources.length) return target;
+  if (!sources.length)
+    return target;
+
   const source = sources.shift();
 
   if (isObject(target) && isObject(source)) {
     for (const key in source) {
       if (isObject(source[key])) {
-        if (! target[key])
-          Object.assign(target, {[key]: { }});
+        if (!target[key])
+          Object.assign(target, {[key]: {}});
         mergeDeep(target[key], source[key]);
       } else
         Object.assign(target, {[key]: source[key]});
     }
   }
 
-  return mergeDeep(target, ...sources);
+  return mergeDeep(target, ...sources)
 }
 
 /**
@@ -370,23 +260,23 @@ function mergeDeep(target, ...sources) {
  * @returns arr
  */
 function deepSort(arr) {
-  //  determine the longest array in keys properties
   let depth = 0;
+  //  determine the longest array in keys properties
   for (let inst of arr)
     if (inst.keys.length > depth)
       depth = inst.keys.length;
 
   //  iterate from longest to shortest and sort
-  for (let i = depth-1; i>=0; i--) {
+  for (let i = depth - 1; i >= 0; i--) {
     arr = arr.sort((a, b) => {
-      if ( a.keys[i] !== undefined && b.keys[i] !== undefined )
+      if (a.keys[i] !== undefined && b.keys[i] !== undefined)
         return a.keys[i] > b.keys[i] ? -1 : 1;
       else
-        return a.keys[i] !== undefined ? -1 : 1
+        return a.keys[i] !== undefined ? -1 : 1;
     });
   }
   //  we get a descending array, so we invert it
-  return arr.reverse();
+  return arr.reverse()
 }
 
 
@@ -394,130 +284,106 @@ function deepSort(arr) {
  * EXPORT PUBLIC INTERFACE
  ****************************************/
 
-exports.cli = async (argv) => {
+async function i18nCollect(source, target, options) {
 
-  //  take in cli arguments from process argv
-  let args = [ ]
-  for (let i = 2; i < argv.length; i++)
-    args.push(argv[i])
+  if (typeof source !== 'string')
+    throw new Error(`First argument SOURCE must be of type string. Please specify a valid SOURCE.`);
 
-  //  validation: error when no argument was given
-  if (args.length === 0)
-    throw new Error(`No arguments given. Please specify SOURCE and TARGET. 
-      Call argument --help for further Information.`)
+  if (typeof target !== 'string')
+    throw new Error(`Second argument TARGET must be of type string. Please specify a valid TARGET.`);
 
-  //  only one argument was given
-  if (args.length === 1) {
-    //  answer to argument 'help'
-    if (['help', '--help', '-h'].includes(args[0]))
-      return logHelp()
-    //  error the missing second argument
-    else
-      throw new Error(`Missing second argument for TARGET. 
-        Call argument --help for further Information.`)
-  }
+  options = options || {};
+
+  if (typeof options !== 'object' && !Array.isArray(options) && Object.prototype.toString.call(options))
+    throw new Error(`Third argument OPTIONS must be of type object. Please specify a valid OPTION.`);
 
   //  register vars
-  let hndlbrKeys = [ ],
-    sources,
-    targetFileName,
-    targetFileNameSeparated,
-    translationFuncName,
-    pos = -1,
-    languages,
+  let hndlbrKeys = [],
     translObj,
     outputObj;
 
-  //  create an array "sources" by filtering out all options from args
-  sources = args.filter(
-    (el) => ! (el === 'help' || el.startsWith('--') || el.startsWith('-'))
-  )
+  // get glob from source
+  const templateFiles = await glob(source, {ignore: 'node_modules/**'})
 
-  //  then removing last element as being the <target>
-  targetFileName = sources.pop()
-
-  //  check for argument '--translFunc=someName' => a custom function name was given
-  args.forEach((el, key) => {
-    if (el.startsWith('--translFunc=')) return pos = key
-  })
-  translationFuncName = (pos >= 0) ? args[pos].split('=')[1] : '__'
-
-  //  read in file(s) and join contents keeping only unique key names
-  for (let file of sources) {
-    console.log(`Now processing ${file}`)
-    let content = await readFile(file)
+  // extract translations keys from file(s) in array hndlbrKeys
+  for (let file of templateFiles) {
+    console.log(`Now processing ${file}`);
+    let [content, err] = await fst.readFile(file, 'utf8');
+    if (err)
+      throw (err);
+    //console.log(content)
     hndlbrKeys = hndlbrKeys.concat(
-      mustacheBetweens.getSorted(content, translationFuncName)
-    )
+      mustacheBetweens.getSorted(content, options.translFunc || '__')
+    );
   }
 
   //  break if no strings for translation where found
   if (hndlbrKeys.length === 0)
-    return console.log('No strings for translation found, no files written.')
+    return console.log('No strings for translation found, no files written.');
 
   //  remove all duplicate value entries in position 'keys' of array hndlbrKeys
-  hndlbrKeys = arrRmvDuplicateValues(hndlbrKeys)
+  hndlbrKeys = arrRmvDuplicateValues(hndlbrKeys);
 
-  //  evaluate argument '--alphabetical' for sorting
-  if (args.includes('--alphabetical') || args.includes('-a'))
+  //  evaluate argument 'alphabetical' for sorting
+  if (options.alphabetical)
     hndlbrKeys = deepSort(hndlbrKeys)
 
-  //  form an array of languages from argument '--lng='
-  languages = args.filter((el) => {
-    return el.startsWith('--lng=')
-  }).map((el) => {
-    return el.split('=')[1].split(',')
-  })[0]
-
-  //  if no language parameter is passed set 'en' as default language
-  if (typeof languages === 'undefined') languages = ['en']
+  //  form an array of languages from argument 'lng
+  const languages = (Array.isArray(options.lng) && options.lng.length > 0)
+    ? options.lng
+    : ['en'];
 
 
   //  WRITE TO ONE FILE PER LANGUAGE
   //  ------------------------------------------------
 
-  //  evaluate argument '--separateLngFiles' to output each language in a separate file
-  if (args.includes('--separateLngFiles') || args.includes('-sf')) {
+  //  evaluate argument 'separateLngFiles' to output each language in a separate file
+  if (options.separateLngFiles) {
 
     //  if user entered argument for target ending with .json, remove it
-    targetFileName = sanitizeFileExt(targetFileName)
+    let targetFileName = sanitizeFileExt(target)
 
     for (let lng of languages) {
+
       //  join file name per language such as myfile.de.json, myfile.en.json, ...
-      targetFileNameSeparated =
-        (targetFileName.startsWith('/') ? targetFileName.substring(1) : targetFileName) + '.' + lng + '.json'
+      let targetFileNameSeparated = (targetFileName.startsWith('/')
+          ? targetFileName.substring(1)
+          : targetFileName)
+        + '.' + lng + '.json';
 
       //  create output object per language and add keys in nested object form
-      outputObj = { }
-      outputObj[lng] = objectify(hndlbrKeys, lng, args.includes('--empty') || args.includes('-e'))
+      outputObj = {}
+      outputObj[lng] = objectify(hndlbrKeys, lng, options.empty)
 
-      //  if argument '--update' was given, existing files per language are read in, parsed,
+      //  if option 'update' was given, existing files per language are read in, parsed,
       //  and the new translation Object is merged onto the existing translation
-      if (args.includes('--update') || args.includes('-u')) {
-        let existingTransl = await readFile(targetFileNameSeparated)
-        existingTransl = JSON.parse(existingTransl)
-        outputObj = mergeDeep(outputObj[lng], existingTransl)
+      if (options.update) {
+        let [res, err] = await fst.readJson(targetFileNameSeparated);
+        if (err)
+          throw (err);
+        outputObj = mergeDeep(outputObj[lng], res)
       }
 
       //  convert output object to json with linebreaks and indenting of 2 spaces
       const fileOutputJson = JSON.stringify(outputObj, null, 2)
 
       //  log output per language
-      if (args.includes('--log') || args.includes('-l')
-        || args.includes('--dryRun') || args.includes('-dr'))
+      if (options.log || options.dryRun)
         console.log(fileOutputJson)
 
+      let [write, e] = [undefined, undefined];
+
       //  write files only if no --dryRun option was set
-      if (! args.includes('--dryRun') && ! args.includes('-dr'))
+      if (!options.dryRun)
         //  write out the json to target file per language
-        if (await writeFile(targetFileNameSeparated, fileOutputJson))
-          console.log('\x1b[34m%s\x1b[0m', `Wrote language keys for '${lng}' to ${targetFileNameSeparated}`)
+        [write, e] = await fst.writeFile(targetFileNameSeparated, fileOutputJson);
+      if (e)
+        throw (e);
+      console.log('\x1b[34m%s\x1b[0m', `Wrote language keys for '${lng}' to ${targetFileNameSeparated}`)
     }
 
-    return (args.includes('--dryRun') || args.includes('-dr')) ?
-      console.log('\x1b[36m%s\x1b[0m', 'This was a dry run. No files witten.')
-      :
-      console.log('\x1b[32m%s\x1b[0m', `You’re good. All Done.`)
+    if (options.dryRun)
+      console.log('\x1b[36m%s\x1b[0m', 'This was a dry run. No files witten.');
   }
 
   //  WRITE SINGLE FILE CONTAINING ALL LANGUAGES
@@ -525,37 +391,44 @@ exports.cli = async (argv) => {
   else {
     //  create object to hold the translations and create a key for every language
     //  add all handlebars translation keys to each language key as nested objects
-    translObj = {translations: { }}
+    translObj = {translations: {}}
+
     languages.forEach((lng) => {
-      translObj.translations[lng] = objectify(hndlbrKeys, lng, args.includes('--empty') || args.includes('-e'))
+      translObj.translations[lng] = objectify(hndlbrKeys, lng, options.empty)
     })
 
-    //  if argument '--update' was given, an existing file is read in, parsed,
+    //  if argument 'update' was given, an existing file is read in, parsed,
     //  and the new translation Object is merged onto the existing translations
-    if (args.includes('--update') || args.includes('-u')) {
-      let existingTransl = await readFile(targetFileName)
-      existingTransl = JSON.parse(existingTransl)
-      outputObj = mergeDeep(translObj, existingTransl)
-    }
-    else
-      outputObj = translObj
+    if (options.update) {
+      let [res, err] = await fst.readJson(target);
+      if (err)
+        throw (err);
+      outputObj = mergeDeep(translObj, res)
+    } else
+      outputObj = translObj;
 
     //  convert output object to json with linebreaks and indenting of 2 spaces
-    const fileOutputJson = JSON.stringify(outputObj,null, 2)
+    const fileOutputJson = JSON.stringify(outputObj, null, 2)
 
-    //  log the final object to console if option '--log' or '--dryRun' was set
-    if (args.includes('--log') || args.includes('-l')
-      || args.includes('--dryRun') || args.includes('-dr'))
-      console.log(fileOutputJson)
+    //  log the final object to console if option 'log' or 'dryRun' was set
+    if (options.log || options.dryRun)
+      console.log(fileOutputJson);
 
-    //  exit if option '--dryRun' was set
-    if (args.includes('--dryRun') || args.includes('-dr')) {
+    //  exit if option 'dryRun' was set
+    if (options.dryRun) {
       console.log('\x1b[36m%s\x1b[0m', 'This was a dry run. No file witten.')
       process.exit(0)
     }
 
     //  write out the json to target file
-    if (await writeFile(targetFileName, fileOutputJson))
-      return console.log('\x1b[32m%s\x1b[0m', `Done and Ready! Your output was written to ${targetFileName}`)
+    let [res, err] = await fst.writeFile(target, fileOutputJson);
+    if (err)
+      throw (err);
   }
-}
+  return true;
+}
+
+// Export the function
+export {
+  i18nCollect
+}