locize-cli 11.0.0 → 12.0.0

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "locize-cli",
+  "version": "12.0.0",
+  "type": "commonjs"
+}

package/{parseLocalLanguage.js → dist/cjs/parseLocalLanguage.js}

@@ -1,203 +1,196 @@
-const fs = require('fs')
-const path = require('path')
-const async = require('async')
-const { mkdirp } = require('mkdirp')
-const convertToFlatFormat = require('./convertToFlatFormat')
-const formats = require('./formats')
-const fileExtensionsMap = formats.fileExtensionsMap
-const acceptedFileExtensions = formats.acceptedFileExtensions
-const xcstrings2locize = require('locize-xcstrings/cjs/xcstrings2locize')
+'use strict';
+
+var fs = require('node:fs');
+var path = require('node:path');
+var mkdirp = require('mkdirp');
+var convertToFlatFormat = require('./convertToFlatFormat.js');
+var formats = require('./formats.js');
+var xcstrings2locize = require('locize-xcstrings/cjs/xcstrings2locize');
+
+const fileExtensionsMap = formats.fileExtensionsMap;
+const acceptedFileExtensions = formats.acceptedFileExtensions;
 
 const getFiles = (srcpath) => {
   return fs.readdirSync(srcpath).filter((file) => {
     return !fs.statSync(path.join(srcpath, file)).isDirectory()
   }).filter((file) => acceptedFileExtensions.indexOf(path.extname(file)) > -1)
-}
+};
 
 const getDirectories = (srcpath) => {
   return fs.readdirSync(srcpath).filter((file) => {
     return fs.statSync(path.join(srcpath, file)).isDirectory()
   })
-}
+};
 
-const parseLocalLanguage = (opt, lng, cb) => {
-  const hasNamespaceInPath = opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1
-  const filledLngMask = opt.pathMask.replace(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`, opt.format === 'xcstrings' ? '' : lng)
-  let firstPartLngMask, lastPartLngMask
+const parseLocalLanguage = async (opt, lng) => {
+  const hasNamespaceInPath = opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1;
+  const filledLngMask = opt.pathMask.replace(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`, opt.format === 'xcstrings' ? '' : lng);
+  let firstPartLngMask, lastPartLngMask;
   if (opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`) > opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`)) {
-    const secondPartMask = opt.pathMask.substring(opt.pathMask.lastIndexOf(path.sep) + 1)
-    firstPartLngMask = secondPartMask.substring(0, secondPartMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`))
-    lastPartLngMask = secondPartMask.substring(secondPartMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`) + `${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`.length)
+    const secondPartMask = opt.pathMask.substring(opt.pathMask.lastIndexOf(path.sep) + 1);
+    firstPartLngMask = secondPartMask.substring(0, secondPartMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`));
+    lastPartLngMask = secondPartMask.substring(secondPartMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`) + `${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`.length);
   }
-  let lngPath
+  let lngPath;
   if (filledLngMask.lastIndexOf(path.sep) > 0) {
-    lngPath = filledLngMask.substring(0, filledLngMask.lastIndexOf(path.sep))
+    lngPath = filledLngMask.substring(0, filledLngMask.lastIndexOf(path.sep));
   }
-  if (!opt.dry && lngPath && lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) < 0) mkdirp.sync(path.join(opt.path, lngPath))
-  let files = []
+  if (!opt.dry && lngPath && lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) < 0) mkdirp.mkdirp.sync(path.join(opt.path, lngPath));
+
+  let files = [];
   try {
     if (lngPath) {
       if (lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1) {
-        const firstPart = lngPath.substring(0, lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`))
-        const lastPart = lngPath.substring(lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) + `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`.length)
-        let additionalSubDirsLeft = ''
-        let additionalSubDirs = ''
-        const splittedP = lngPath.split(path.sep)
-        const foundSplitted = splittedP.find((s) => s.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1)
-        const foundSplittedIndex = splittedP.indexOf(foundSplitted)
+        const firstPart = lngPath.substring(0, lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`));
+        const lastPart = lngPath.substring(lngPath.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) + `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`.length);
+        let additionalSubDirsLeft = '';
+        let additionalSubDirs = '';
+        const splittedP = lngPath.split(path.sep);
+        const foundSplitted = splittedP.find((s) => s.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1);
+        const foundSplittedIndex = splittedP.indexOf(foundSplitted);
         if (splittedP.length > 2) {
-          additionalSubDirsLeft = splittedP.slice(0, foundSplittedIndex).join(path.sep)
-          additionalSubDirs = splittedP.slice(foundSplittedIndex + 1).join(path.sep)
+          additionalSubDirsLeft = splittedP.slice(0, foundSplittedIndex).join(path.sep);
+          additionalSubDirs = splittedP.slice(foundSplittedIndex + 1).join(path.sep);
         }
-        let dirs = getDirectories(path.join(opt.path, additionalSubDirsLeft))
+        let dirs = getDirectories(path.join(opt.path, additionalSubDirsLeft));
         if (additionalSubDirs === '') {
-          dirs = dirs.filter((d) => d.startsWith(firstPart) && d.endsWith(lastPart))
+          dirs = dirs.filter((d) => d.startsWith(firstPart) && d.endsWith(lastPart));
         }
         dirs.forEach((d) => {
           if (additionalSubDirs && fs.statSync(path.join(opt.path, additionalSubDirsLeft, d)).isDirectory()) {
-            let directoryExists = false
+            let directoryExists = false;
             try {
-              directoryExists = fs.statSync(path.join(opt.path, additionalSubDirsLeft, d, additionalSubDirs)).isDirectory()
+              directoryExists = fs.statSync(path.join(opt.path, additionalSubDirsLeft, d, additionalSubDirs)).isDirectory();
             } catch (e) {}
             if (directoryExists) {
-              let subFls = getFiles(path.join(opt.path, additionalSubDirsLeft, d, additionalSubDirs))
-              if (firstPartLngMask || lastPartLngMask) subFls = subFls.filter((f) => path.basename(f, path.extname(f)) === `${firstPartLngMask}${lng}${lastPartLngMask}`)
+              let subFls = getFiles(path.join(opt.path, additionalSubDirsLeft, d, additionalSubDirs));
+              if (firstPartLngMask || lastPartLngMask) subFls = subFls.filter((f) => path.basename(f, path.extname(f)) === `${firstPartLngMask}${lng}${lastPartLngMask}`);
 
               subFls = subFls.filter((f) => {
-                const a = path.join(additionalSubDirsLeft, d, additionalSubDirs, path.basename(f, path.extname(f)))
-                const startIndexOfNs = filledLngMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`)
+                const a = path.join(additionalSubDirsLeft, d, additionalSubDirs, path.basename(f, path.extname(f)));
+                const startIndexOfNs = filledLngMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`);
                 if (startIndexOfNs === -1) return true
-                const afterNs = filledLngMask.substring(startIndexOfNs + `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`.length)
-                const nsName = a.substring(startIndexOfNs, a.indexOf(afterNs))
-                const b = filledLngMask.replace(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`, nsName)
+                const afterNs = filledLngMask.substring(startIndexOfNs + `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`.length);
+                const nsName = a.substring(startIndexOfNs, a.indexOf(afterNs));
+                const b = filledLngMask.replace(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`, nsName);
                 return a === b
-              })
+              });
 
-              files = files.concat(subFls.map((f) => `${additionalSubDirsLeft ? additionalSubDirsLeft + path.sep : ''}${d}${path.sep}${additionalSubDirs}${path.sep}${f}`))
+              files = files.concat(subFls.map((f) => `${additionalSubDirsLeft ? additionalSubDirsLeft + path.sep : ''}${d}${path.sep}${additionalSubDirs}${path.sep}${f}`));
             }
           } else {
-            const fls = getFiles(path.join(opt.path, additionalSubDirsLeft, d)).filter((f) => path.basename(f, path.extname(f)) === `${firstPartLngMask}${lng}${lastPartLngMask}`)
-            files = files.concat(fls.map((f) => `${additionalSubDirsLeft ? additionalSubDirsLeft + path.sep : ''}${d}${path.sep}${f}`))
+            const fls = getFiles(path.join(opt.path, additionalSubDirsLeft, d)).filter((f) => path.basename(f, path.extname(f)) === `${firstPartLngMask}${lng}${lastPartLngMask}`);
+            files = files.concat(fls.map((f) => `${additionalSubDirsLeft ? additionalSubDirsLeft + path.sep : ''}${d}${path.sep}${f}`));
           }
-        })
+        });
       } else {
-        files = getFiles(path.join(opt.path, lngPath))
+        files = getFiles(path.join(opt.path, lngPath));
       }
     } else {
-      files = getFiles(opt.path)
+      files = getFiles(opt.path);
       // filter lng files...
-      const lngIndex = filledLngMask.indexOf(lng)
-      const lngLeftLength = filledLngMask.length - lngIndex
+      const lngIndex = filledLngMask.indexOf(lng);
+      const lngLeftLength = filledLngMask.length - lngIndex;
       files = files.filter((f) => { // {{language}} can be left or right of {{namespace}}
         if (opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}language${opt.pathMaskInterpolationSuffix}`) < opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`)) {
           return f.indexOf(lng) === lngIndex
         }
         return (path.basename(f, path.extname(f)).length - f.indexOf(lng)) === lngLeftLength
-      })
+      });
     }
   } catch (err) {}
-  async.map(files, (file, clb) => {
-    let dirPath
+
+  // Async map logic using Promise.all
+  const results = await Promise.all(files.map(async (fileOrig) => {
+    let file = fileOrig;
+    let dirPath;
     if (file.lastIndexOf(path.sep) > 0) {
-      dirPath = file.substring(0, file.lastIndexOf(path.sep))
-      file = file.substring(file.lastIndexOf(path.sep) + 1)
+      dirPath = file.substring(0, file.lastIndexOf(path.sep));
+      file = file.substring(file.lastIndexOf(path.sep) + 1);
     }
-    const fExt = path.extname(file)
-    let namespace = path.basename(file, fExt)
-    const nsMask = `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`
-    const filledNsMask = lngPath && lngPath.indexOf(nsMask) > -1 ? filledLngMask : filledLngMask.substring(filledLngMask.lastIndexOf(path.sep) + 1)
-    const startNsIndex = filledNsMask.indexOf(nsMask)
-    let restNsMask = filledNsMask.substring((startNsIndex || 0) + nsMask.length)
-    namespace = namespace.substring(startNsIndex || 0, namespace.lastIndexOf(restNsMask))
+    const fExt = path.extname(file);
+    let namespace = path.basename(file, fExt);
+    const nsMask = `${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`;
+    const filledNsMask = lngPath && lngPath.indexOf(nsMask) > -1 ? filledLngMask : filledLngMask.substring(filledLngMask.lastIndexOf(path.sep) + 1);
+    const startNsIndex = filledNsMask.indexOf(nsMask);
+    let restNsMask = filledNsMask.substring((startNsIndex || 0) + nsMask.length);
+    namespace = namespace.substring(startNsIndex || 0, namespace.lastIndexOf(restNsMask));
     if (lngPath && lngPath.indexOf(nsMask) > -1) {
-      restNsMask = restNsMask.substring(0, restNsMask.lastIndexOf(path.sep))
+      restNsMask = restNsMask.substring(0, restNsMask.lastIndexOf(path.sep));
       if (dirPath.indexOf(restNsMask) > 0) {
-        namespace = dirPath.substring(filledNsMask.indexOf(nsMask), dirPath.indexOf(restNsMask))
+        namespace = dirPath.substring(filledNsMask.indexOf(nsMask), dirPath.indexOf(restNsMask));
       } else {
-        namespace = dirPath.substring(filledNsMask.indexOf(nsMask))
+        namespace = dirPath.substring(filledNsMask.indexOf(nsMask));
       }
     } else if (!hasNamespaceInPath && startNsIndex < 0) {
-      namespace = opt.namespace
+      namespace = opt.namespace;
     }
-    let fPath = path.join(opt.path, lngPath || '', file)
+    let fPath = path.join(opt.path, lngPath || '', file);
     if (dirPath && lngPath.indexOf(nsMask) > -1) {
-      fPath = path.join(opt.path, dirPath.replace(nsMask, namespace), file)
+      fPath = path.join(opt.path, dirPath.replace(nsMask, namespace), file);
     }
-    if (!namespace) return clb(new Error(`namespace could not be found in ${fPath}`))
-    if (opt.namespaces && opt.namespaces.indexOf(namespace) < 0) return clb(null)
-    if (opt.namespace && opt.namespace !== namespace) return clb(null)
-    fs.readFile(fPath, (err, data) => {
-      if (err) return clb(err)
-
-      if (fileExtensionsMap[fExt].indexOf(opt.format) < 0) {
-        return clb(new Error(`Format mismatch! Found ${fileExtensionsMap[fExt][0]} but requested ${opt.format}!`))
+    if (!namespace) throw new Error(`namespace could not be found in ${fPath}`)
+    if (opt.namespaces && opt.namespaces.indexOf(namespace) < 0) return undefined
+    if (opt.namespace && opt.namespace !== namespace) return undefined
+    const data = await fs.promises.readFile(fPath);
+    if (fileExtensionsMap[fExt].indexOf(opt.format) < 0) {
+      throw new Error(`Format mismatch! Found ${fileExtensionsMap[fExt][0]} but requested ${opt.format}!`)
+    }
+    if (opt.namespace) {
+      let hasNamespaceInPathPask = !opt.pathMask || !opt.pathMaskInterpolationPrefix || !opt.pathMaskInterpolationSuffix;
+      hasNamespaceInPathPask = !hasNamespaceInPathPask && opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1;
+      if (!hasNamespaceInPathPask && namespace === lng) {
+        namespace = opt.namespace;
       }
-
-      if (opt.namespace) {
-        let hasNamespaceInPathPask = !opt.pathMask || !opt.pathMaskInterpolationPrefix || !opt.pathMaskInterpolationSuffix
-        hasNamespaceInPathPask = !hasNamespaceInPathPask && opt.pathMask.indexOf(`${opt.pathMaskInterpolationPrefix}namespace${opt.pathMaskInterpolationSuffix}`) > -1
-        if (!hasNamespaceInPathPask && namespace === lng) {
-          namespace = opt.namespace
-        }
+    }
+    if (opt.format === 'xcstrings') {
+      try {
+        const content = xcstrings2locize(data);
+        const stat = await fs.promises.stat(fPath);
+        return Object.keys(content.resources).map((l) => ({
+          namespace,
+          path: fPath,
+          extension: fExt,
+          content: content.resources[l],
+          language: l,
+          mtime: stat.mtime
+        }))
+      } catch (err) {
+        err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '');
+        err.message += '\n' + fPath;
+        throw err
       }
-
-      if (opt.format === 'xcstrings') { // 1 file per namespace including all languages
-        try {
-          const content = xcstrings2locize(data)
-
-          fs.stat(fPath, (err, stat) => {
-            if (err) return clb(err)
-
-            clb(null, Object.keys(content.resources).map((l) => ({
-              namespace,
-              path: fPath,
-              extension: fExt,
-              content: content.resources[l],
-              language: l,
-              mtime: stat.mtime
-            })))
-          })
-        } catch (e) {
-          err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '')
-          err.message += '\n' + fPath
-          return clb(err)
-        }
-      } else { // 1 file per namespace/lng
-        convertToFlatFormat(opt, data, lng, (err, content) => {
-          if (err) {
-            err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '')
-            err.message += '\n' + fPath
-            return clb(err)
-          }
-
-          fs.stat(fPath, (err, stat) => {
-            if (err) return clb(err)
-
-            clb(null, {
-              namespace,
-              path: fPath,
-              extension: fExt,
-              content,
-              language: lng,
-              mtime: stat.mtime
-            })
-          })
-        })
+    } else {
+      let content;
+      try {
+        content = await convertToFlatFormat(opt, data, lng);
+      } catch (err) {
+        err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '');
+        err.message += '\n' + fPath;
+        throw err
       }
-    })
-  }, (err, ret) => {
-    if (err) return cb(err)
-    // xcstrings, returns array in array
-    const r = ret.filter((r) => r !== undefined).reduce((prev, cur) => {
-      if (Array.isArray(cur)) {
-        prev = prev.concat(cur)
-      } else {
-        prev.push(cur)
+      const stat = await fs.promises.stat(fPath);
+      return {
+        namespace,
+        path: fPath,
+        extension: fExt,
+        content,
+        language: lng,
+        mtime: stat.mtime
       }
-      return prev
-    }, [])
-    cb(null, r)
-  })
-}
+    }
+  }));
+
+  // xcstrings, returns array in array
+  const r = results.filter((r) => r !== undefined).reduce((prev, cur) => {
+    if (Array.isArray(cur)) {
+      prev = prev.concat(cur);
+    } else {
+      prev.push(cur);
+    }
+    return prev
+  }, []);
+  return r
+};
 
-module.exports = parseLocalLanguage
+module.exports = parseLocalLanguage;

package/dist/cjs/parseLocalLanguages.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var parseLocalLanguage = require('./parseLocalLanguage.js');
+var filterNamespaces = require('./filterNamespaces.js');
+
+const parseLocalLanguages = async (opt, lngs) => {
+  let res = [];
+  for (const lng of lngs) {
+    if (opt.language && (lng !== opt.language && lng !== opt.referenceLanguage)) {
+      continue
+    }
+    const nss = await parseLocalLanguage(opt, lng);
+    res = res.concat(filterNamespaces(opt, nss));
+  }
+  return res
+};
+
+module.exports = parseLocalLanguages;

package/dist/cjs/parseLocalReference.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var parseLocalLanguage = require('./parseLocalLanguage.js');
+var filterNamespaces = require('./filterNamespaces.js');
+
+const parseLocalReference = async (opt) => {
+  const nss = await parseLocalLanguage(opt, opt.referenceLanguage);
+  return filterNamespaces(opt, nss).filter((n) => n.language === opt.referenceLanguage)
+};
+
+module.exports = parseLocalReference;

package/dist/cjs/publishVersion.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var colors = require('colors');
+var request = require('./request.js');
+var getJob = require('./getJob.js');
+
+const publishVersion = async (opt) => {
+  const { res, obj } = await request(opt.apiEndpoint + '/publish/' + opt.projectId + '/' + opt.version + (opt.tenants ? '?tenants=true' : ''), {
+    method: 'post',
+    headers: {
+      Authorization: opt.apiKey
+    }
+  });
+  if (obj && (obj.errorMessage || obj.message)) {
+    console.log(colors.red(`publishing failed for ${opt.version}...`));
+    throw new Error(obj.errorMessage || obj.message)
+  }
+  if (res.status >= 300) {
+    console.error(colors.red(res.statusText + ' (' + res.status + ')'));
+    throw new Error(res.statusText + ' (' + res.status + ')')
+  }
+  if (!obj || !obj.jobId) {
+    console.error(colors.red('No jobId! Something went wrong!'));
+    throw new Error('No jobId! Something went wrong!')
+  }
+  // Poll for job completion
+  while (true) {
+    const job = await getJob(opt, obj.jobId);
+    if (job && !job.timeouted) {
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      continue
+    }
+    if (job && job.timeouted) {
+      console.error(colors.red('Job timeouted!'));
+      throw new Error('Job timeouted!')
+    }
+    break
+  }
+  console.log(colors.green(`publishing for ${opt.version} succesfully requested`));
+};
+
+module.exports = publishVersion;

package/dist/cjs/removeUndefinedFromArrays.js

@@ -0,0 +1,19 @@
+'use strict';
+
+// rails seems to start date relevant information in an array with 1 instead of 0
+function removeUndefinedFromArrays (obj) {
+  if (!obj) return obj
+
+  const propNames = Object.keys(obj);
+  propNames.forEach((propName) => {
+    if (Array.isArray(obj[propName]) && obj[propName][0] === undefined) {
+      obj[propName].shift();
+    } else if (typeof obj[propName] === 'object') {
+      removeUndefinedFromArrays(obj[propName]);
+    }
+  });
+
+  return obj
+}
+
+module.exports = removeUndefinedFromArrays;

package/dist/cjs/removeVersion.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var colors = require('colors');
+var request = require('./request.js');
+var getJob = require('./getJob.js');
+
+const removeVersion = async (opt) => {
+  const { res, obj } = await request(opt.apiEndpoint + '/version/' + opt.projectId + '/' + opt.version, {
+    method: 'delete',
+    headers: {
+      Authorization: opt.apiKey
+    }
+  });
+  if (obj && (obj.errorMessage || obj.message)) {
+    console.log(colors.red(`remove failed for version ${opt.version}...`));
+    throw new Error(obj.errorMessage || obj.message)
+  }
+  if (res.status >= 300) {
+    console.error(colors.red(res.statusText + ' (' + res.status + ')'));
+    throw new Error(res.statusText + ' (' + res.status + ')')
+  }
+  if (!obj || !obj.jobId) {
+    console.error(colors.red('No jobId! Something went wrong!'));
+    throw new Error('No jobId! Something went wrong!')
+  }
+  // Poll for job completion
+  while (true) {
+    const job = await getJob(opt, obj.jobId);
+    if (job && !job.timeouted) {
+      await new Promise(resolve => setTimeout(resolve, 2000));
+      continue
+    }
+    if (job && job.timeouted) {
+      console.error(colors.red('Job timeouted!'));
+      throw new Error('Job timeouted!')
+    }
+    break
+  }
+  console.log(colors.green(`remove version ${opt.version} succesfully requested`));
+};
+
+module.exports = removeVersion;

package/dist/cjs/request.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var httpsProxyAgent = require('https-proxy-agent');
+var https = require('https');
+var CacheableLookup = require('cacheable-lookup');
+
+const cacheable = new CacheableLookup();
+cacheable.install(https.globalAgent);
+
+const httpProxy = process.env.http_proxy || process.env.HTTP_PROXY || process.env.https_proxy || process.env.HTTPS_PROXY;
+const isRetriableError = (err) => {
+  return err && err.message && (
+    err.message.indexOf('ETIMEDOUT') > -1 || // on timeout retry
+    err.message.indexOf('FetchError') > -1 ||
+    err.code === 'ETIMEDOUT' ||
+    // on dns errors
+    err.message.indexOf('ENOTFOUND') > -1 ||
+    err.message.indexOf('ENODATA') > -1 ||
+    err.message.indexOf('ENOENT') > -1 // Windows: name exists, but not this record type
+  )
+};
+
+const isJSONResponse = (res) => res.headers.get('content-type') && res.headers.get('content-type').indexOf('json') > 0;
+
+const handleResponse = (res) => {
+  if (isJSONResponse(res)) {
+    return new Promise((resolve, reject) => res.json().then((obj) => resolve({ res, obj })).catch(reject))
+  } else {
+    return { res }
+  }
+};
+
+async function request (url, options) {
+  if (httpProxy) {
+    const httpsProxyAgent$1 = new httpsProxyAgent.HttpsProxyAgent(httpProxy);
+    cacheable.install(httpsProxyAgent$1);
+    options.agent = httpsProxyAgent$1;
+  }
+
+  options.headers = options.headers || {};
+  options.headers['User-Agent'] = `__packageName__/v__packageVersion__ (node/${process.version}; ${process.platform} ${process.arch})`; // This string is replaced with the actual version at build time by rollup
+  options.headers['X-User-Agent'] = options.headers['User-Agent'];
+  if (options.body || options.method !== 'get') options.headers['Content-Type'] = 'application/json';
+  if (options.body) {
+    if (typeof options.body !== 'string') {
+      options.body = JSON.stringify(options.body);
+    }
+  }
+  if (options.headers['Authorization'] === undefined) delete options.headers['Authorization'];
+
+  async function retriableFetch (maxRetries) {
+    try {
+      const response = await fetch(url, options);
+      const result = await handleResponse(response);
+      return result
+    } catch (err) {
+      if (maxRetries < 1) throw err
+      if (!isRetriableError(err)) throw err
+      await new Promise(resolve => setTimeout(resolve, 5000));
+      return retriableFetch(--maxRetries)
+    }
+  }
+  return retriableFetch(3)
+}
+
+module.exports = request;

package/dist/cjs/shouldUnflatten.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const shouldUnflatten = (json) => {
+  const keys = Object.keys(json);
+  let shouldUnflatten = true;
+  for (let i = 0, len = keys.length; i < len; i++) {
+    const key = keys[i];
+
+    if (shouldUnflatten && /( |,|\?)/.test(key)) {
+      shouldUnflatten = false;
+      return shouldUnflatten
+    } else if (shouldUnflatten && key.indexOf('.') > -1 && keys.indexOf(key.substring(0, key.lastIndexOf('.'))) > -1) {
+      shouldUnflatten = false;
+      return shouldUnflatten
+    }
+  }
+
+  return shouldUnflatten
+};
+
+module.exports = shouldUnflatten;

package/dist/cjs/sortFlatResources.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const sortFlatResources = (resources) => {
+  const keys = Object.keys(resources).sort();
+  const cleaned = {};
+  for (let i = 0, len = keys.length; i < len; i++) {
+    const key = keys[i];
+    cleaned[key] = resources[key];
+  }
+  return cleaned
+};
+
+module.exports = sortFlatResources;