locize-cli 11.0.0 → 12.0.0

package/dist/cjs/combineSubkeyPreprocessor.js

@@ -0,0 +1,155 @@
+'use strict';
+
+var yaml = require('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;
+  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);
+  return baseKey
+};
+
+const uniq = (value, index, self) => self.indexOf(value) === index;
+
+const stringify = (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}}: `);
+    } else {
+      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);
+      // special handling for i18next v3
+      if (deli === delimiter.i18next && subKey === 'plural' && segments[bk]) {
+        mem['__'] = segments[bk];
+        delete segments[bk];
+      }
+      mem[subKey] = segments[k];
+      return mem
+    }, {});
+    if (Object.keys(asObj).length > 0) {
+      const value = stringify(asObj);
+      segments[`${bk}__#locize.com/combinedSubkey`] = value;
+      toMerge[bk].forEach((k) => {
+        delete segments[k];
+      });
+    }
+  });
+  return segments
+};
+
+// CLDR
+const pluralForms = [
+  'zero',
+  'one',
+  'two',
+  '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 prepareExport = (refRes, 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 allMatches = nonMatchInRef.concat(nonMatchInTrg);
+
+  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 toMergeInRef = nonMatchBaseKeys.reduce((mem, bk) => {
+    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);
+    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)));
+  falseFlags.forEach((k) => {
+    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]);
+  return { ref: transformedRef, trg: transformedTrg }
+};
+
+// eslint-disable-next-line prefer-regex-literals
+const skRegex = new RegExp('^(?:{(.+)})+', 'gm');
+const parse = (s) => {
+  let matchArray;
+  while ((matchArray = skRegex.exec(s)) !== null) {
+    const [match, sk] = matchArray;
+    if (isNaN(sk)) {
+      s = s.replace(new RegExp(`^(?:${match}: )+`, 'm'), `${sk}: `);
+    } else {
+      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);
+  keys.forEach((k) => {
+    if (k.indexOf('__#locize.com/combinedSubkey') > -1) {
+      const baseKey = k.substring(0, k.indexOf('__#locize.com/combinedSubkey'));
+      if (resources[k]) {
+        const parsed = parse(resources[k]);
+        Object.keys(parsed).forEach((sk) => {
+          const skVal = parsed[sk];
+          resources[`${baseKey}_${sk}`] = skVal;
+          if (sk === '__') {
+            resources[baseKey] = resources[`${baseKey}_${sk}`];
+            delete resources[`${baseKey}_${sk}`];
+          }
+        });
+        delete resources[k];
+      }
+    }
+  });
+  return resources
+};
+
+exports.prepareExport = prepareExport;
+exports.prepareImport = prepareImport;

package/dist/cjs/convertToDesiredFormat.js

@@ -0,0 +1,205 @@
+'use strict';
+
+var flatten = require('flat');
+var i18next2po = require('gettext-converter/i18next2po');
+var csv = require('fast-csv');
+var xlsx = require('xlsx');
+var yaml = require('yaml');
+var js2asr = require('android-string-resource/js2asr');
+var stringsFile = require('strings-file');
+var createxliff = require('xliff/createxliff');
+var createxliff12 = require('xliff/createxliff12');
+var js2resx = require('resx/js2resx');
+var js2ftl = require('fluent_conv/js2ftl');
+var js2tmx = require('tmexchange/js2tmx');
+var js2laravel = require('laravelphp/js2laravel');
+var javaProperties = require('@js.properties/properties');
+var unflatten = require('./unflatten.js');
+var getRemoteNamespace = require('./getRemoteNamespace.js');
+var removeUndefinedFromArrays = require('./removeUndefinedFromArrays.js');
+var shouldUnflatten = require('./shouldUnflatten.js');
+var combineSubkeyPreprocessor = require('./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 = combineSubkeyPreprocessor.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!`)
+};
+
+module.exports = convertToDesiredFormat;

package/dist/cjs/convertToFlatFormat.js

@@ -0,0 +1,231 @@
+'use strict';
+
+var po2i18next = require('gettext-converter/po2i18next');
+var csv = require('fast-csv');
+var xlsx = require('xlsx');
+var yaml = require('yaml');
+var asr2js = require('android-string-resource/asr2js');
+var stringsFile = require('strings-file');
+var xliff2js = require('xliff/xliff2js');
+var xliff12ToJs = require('xliff/xliff12ToJs');
+var targetOfjs = require('xliff/targetOfjs');
+var sourceOfjs = require('xliff/sourceOfjs');
+var resx2js = require('resx/resx2js');
+var ftl2js = require('fluent_conv/ftl2js');
+var tmx2js = require('tmexchange/tmx2js');
+var laravel2js = require('laravelphp/laravel2js');
+var javaProperties = require('@js.properties/properties');
+var xcstrings2locize = require('locize-xcstrings/xcstrings2locize');
+var flatten = require('flat');
+var combineSubkeyPreprocessor = require('./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 combineSubkeyPreprocessor.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!`)
+};
+
+module.exports = convertToFlatFormat;

package/dist/cjs/copyVersion.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var colors = require('colors');
+var request = require('./request.js');
+var getJob = require('./getJob.js');
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const copyVersion = async (opt) => {
+  const queryParams = new URLSearchParams();
+  if (opt.ignoreIfVersionExists) {
+    queryParams.append('ignoreIfVersionExists', 'true');
+  }
+  const queryString = queryParams.size > 0 ? '?' + queryParams.toString() : '';
+  const { res, obj, err } = await request(opt.apiEndpoint + '/copy/' + opt.projectId + '/version/' + opt.fromVersion + '/' + opt.toVersion + queryString, {
+    method: 'post',
+    headers: {
+      Authorization: opt.apiKey
+    }
+  });
+
+  if (err || (obj && (obj.errorMessage || obj.message))) {
+    console.log(colors.red(`copy failed from ${opt.fromVersion} to ${opt.toVersion}...`));
+    if (err) {
+      console.error(colors.red(err.message));
+      throw err
+    }
+    if (obj && (obj.errorMessage || obj.message)) {
+      console.error(colors.red((obj.errorMessage || obj.message)));
+      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!')
+  }
+
+  let job;
+  while (true) {
+    job = await getJob(opt, obj.jobId);
+    if (job && !job.timeouted) {
+      await sleep(2000);
+      continue
+    }
+    if (job && job.timeouted) {
+      console.error(colors.red('Job timeouted!'));
+      throw new Error('Job timeouted!')
+    }
+    break
+  }
+  console.log(colors.green(`copy from ${opt.fromVersion} to ${opt.toVersion} succesfully requested`));
+  // done
+};
+
+module.exports = copyVersion;