locize-cli 11.0.0 → 12.0.0

package/dist/cjs/format.js

@@ -0,0 +1,156 @@
+'use strict';
+
+var colors = require('colors');
+var fs = require('node:fs');
+var path = require('node:path');
+var diff = require('diff');
+var convertToFlatFormat = require('./convertToFlatFormat.js');
+var convertToDesiredFormat = require('./convertToDesiredFormat.js');
+var sortFlatResources = require('./sortFlatResources.js');
+var formats = require('./formats.js');
+
+const fileExtensionsMap = formats.fileExtensionsMap;
+const acceptedFileExtensions = formats.acceptedFileExtensions;
+const reversedFileExtensionsMap = formats.reversedFileExtensionsMap;
+
+const getFiles = (srcpath) => {
+  let files = [];
+  fs.readdirSync(srcpath).forEach((file) => {
+    if (fs.statSync(path.join(srcpath, file)).isDirectory()) {
+      files = files.concat(getFiles(path.join(srcpath, file)));
+    } else if (acceptedFileExtensions.indexOf(path.extname(file)) > -1) {
+      files.push(path.join(srcpath, file));
+    }
+  });
+  return files
+};
+
+async function readLocalFile (opt, fPath) {
+  const fExt = path.extname(fPath);
+  const namespace = path.basename(fPath, fExt);
+  const splitted = fPath.split(path.sep);
+  const lng = splitted[splitted.length - 2];
+  const data = await fs.promises.readFile(fPath);
+  const stat = await fs.promises.stat(fPath);
+  return {
+    namespace,
+    path: fPath,
+    extension: fExt,
+    original: data.toString(),
+    language: lng,
+    mtime: stat.mtime
+  }
+}
+
+async function readLocalFiles (opt, filePaths) {
+  return await Promise.all(filePaths.map(f => readLocalFile(opt, f)))
+}
+
+async function convertAllFilesToFlatFormat (opt, files) {
+  return await Promise.all(files.map(async file => {
+    if (fileExtensionsMap[file.extension].indexOf(opt.format) < 0) {
+      throw new Error(`Format mismatch! Found ${fileExtensionsMap[file.extension][0]} but requested ${opt.format}!`)
+    }
+    let content;
+    try {
+      content = await convertToFlatFormat(opt, file.original);
+    } catch (err) {
+      err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '') + '\n' + file.path;
+      throw err
+    }
+    file.content = sortFlatResources(content);
+    return file
+  }))
+}
+
+async function convertAllFilesToDesiredFormat (opt, files) {
+  return await Promise.all(files.map(async file => {
+    let res;
+    try {
+      res = await convertToDesiredFormat(opt, file.namespace, file.language, file.content, file.mtime);
+    } catch (err) {
+      err.message = 'Invalid content for "' + opt.format + '" format!\n' + (err.message || '');
+      throw err
+    }
+    res = (opt.format !== 'xlsx' && !res.endsWith('\n')) ? (res + '\n') : res;
+    file.converted = res;
+    return file
+  }))
+}
+
+async function writeLocalFile (opt, file) {
+  if (file.converted === file.original) {
+    console.log(colors.grey(`${file.path} unchanged`));
+    return false
+  }
+  const d = diff.diffLines(file.original, file.converted);
+  d.forEach((part) => {
+    const color = part.added ? 'green' : part.removed ? 'red' : 'grey';
+    console.log(part.value[color]);
+  });
+  console.log(colors.yellow(`reformatting ${file.path}...`));
+  if (opt.dry) {
+    console.log(colors.yellow(`would have reformatted ${file.path}...`));
+    return true
+  }
+  const fileContent = (opt.format !== 'xlsx' && !file.converted.endsWith('\n')) ? (file.converted + '\n') : file.converted;
+  await fs.promises.writeFile(file.path, fileContent);
+  return true
+}
+
+async function writeLocalFiles (opt, files) {
+  return await Promise.all(files.map(f => writeLocalFile(opt, f)))
+}
+
+async function processFiles (opt, filePaths) {
+  const orgFiles = await readLocalFiles(opt, filePaths);
+  if (!opt.format) {
+    if (orgFiles.length === 0) {
+      throw new Error('Please provide a format!')
+    }
+    opt.format = fileExtensionsMap[orgFiles[0].extension][0];
+    console.log(colors.bgYellow(`No format argument was passed, so guessing "${opt.format}" format.`));
+  }
+  const files = await convertAllFilesToFlatFormat(opt, orgFiles);
+  opt.getNamespace = async (o, lng, ns) => {
+    const foundOrgFile = orgFiles.find((f) => f.namespace === ns && f.language === lng);
+    if (!foundOrgFile) {
+      throw new Error(`No file found for language "${lng}" and namespace "${ns}" locally!`)
+    }
+    return { content: foundOrgFile.content, mtime: foundOrgFile.mtime }
+  };
+  files.forEach((f) => {
+    if (f.content) {
+      Object.keys(f.content).forEach((k) => {
+        if (f.content[k] && typeof f.content[k] === 'object' && f.content[k].value !== undefined) {
+          f.content[k] = f.content[k].value;
+        }
+      });
+    }
+  });
+  const convertedFiles = await convertAllFilesToDesiredFormat(opt, files);
+  return await writeLocalFiles(opt, convertedFiles)
+}
+
+async function format (opt) {
+  if (opt.format && !reversedFileExtensionsMap[opt.format]) {
+    throw new Error(`${opt.format} is not a valid format!`)
+  }
+  const stat = await fs.promises.lstat(opt.fileOrDirectory);
+  const isDirectory = stat.isDirectory();
+  let filePaths = [];
+  if (isDirectory) {
+    try {
+      filePaths = getFiles(opt.fileOrDirectory);
+    } catch (err) {}
+  } else {
+    filePaths = [opt.fileOrDirectory];
+  }
+  const writeResults = await processFiles(opt, filePaths);
+  console.log(colors.green('FINISHED'));
+  if (opt.dry && writeResults.find((wr) => !!wr)) {
+    process.exit(1);
+  }
+}
+
+module.exports = format;

package/dist/cjs/formats.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const fileExtensionsMap = {
+  '.json': ['json', 'nested', 'flat'],
+  '.po': ['po', 'gettext', 'po_i18next', 'gettext_i18next'],
+  '.xml': ['android'],
+  '.strings': ['strings'],
+  '.csv': ['csv'],
+  '.resx': ['resx'],
+  '.yaml': ['yaml', 'yaml-rails', 'yaml-rails-ns', 'yaml-nested'],
+  '.yml': ['yml', 'yml-rails', 'yml-rails-ns', 'yml-nested'],
+  '.xlsx': ['xlsx'],
+  '.xliff': ['xliff2', 'xliff12'],
+  '.xlf': ['xlf2', 'xlf12'],
+  '.ftl': ['fluent'],
+  '.tmx': ['tmx'],
+  '.php': ['laravel'],
+  '.properties': ['properties'],
+  '.xcstrings': ['xcstrings']
+};
+
+const acceptedFileExtensions = Object.keys(fileExtensionsMap);
+
+const reversedFileExtensionsMap = {};
+acceptedFileExtensions.forEach((ext) => {
+  fileExtensionsMap[ext].forEach((format) => {
+    reversedFileExtensionsMap[format] = ext;
+  });
+});
+
+exports.acceptedFileExtensions = acceptedFileExtensions;
+exports.fileExtensionsMap = fileExtensionsMap;
+exports.reversedFileExtensionsMap = reversedFileExtensionsMap;

package/dist/cjs/get.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var colors = require('colors');
+var request = require('./request.js');
+var flatten = require('flat');
+
+const get = async (opt) => {
+  const url = `${opt.apiEndpoint}/{{projectId}}/{{version}}/{{lng}}/{{ns}}`
+    .replace('{{projectId}}', opt.projectId)
+    .replace('{{ver}}', opt.version)
+    .replace('{{version}}', opt.version)
+    .replace('{{language}}', opt.language)
+    .replace('{{lng}}', opt.language)
+    .replace('{{ns}}', opt.namespace)
+    .replace('{{namespace}}', opt.namespace);
+
+  if (opt.key && opt.key.indexOf(',') > 0 && opt.key.indexOf(' ') < 0) {
+    opt.keys = opt.key.split(',');
+    delete opt.key;
+  }
+
+  const { res, obj, err } = await request(`${url}${opt.cdnType === 'standard' ? '?cache=no' : ''}`, {
+    method: 'get'
+  });
+  if (err) {
+    console.log(colors.red(`get failed for ${opt.key || (opt.keys && opt.keys.join(', '))} from ${opt.version}/${opt.language}/${opt.namespace}...`));
+    throw err
+  }
+  const ignore404 = res.status === 404 && opt.cdnType === 'standard';
+  if (res.status >= 300 && !ignore404) {
+    console.error(colors.red(res.statusText + ' (' + res.status + ')'));
+    throw new Error(res.statusText + ' (' + res.status + ')')
+  }
+  const flatObj = flatten(ignore404 ? {} : obj);
+  if (opt.key) {
+    if (!flatObj[opt.key]) {
+      console.error(colors.red(`${opt.key} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`));
+      throw new Error(`${opt.key} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`)
+    }
+    console.log(flatObj[opt.key]);
+  }
+  if (opt.keys) {
+    const ret = {};
+    const retWitAllKeys = {};
+    opt.keys.forEach((k) => {
+      if (flatObj[k] !== undefined) {
+        ret[k] = flatObj[k];
+      }
+      retWitAllKeys[k] = flatObj[k];
+    });
+    const retKeys = Object.keys(ret);
+    if (retKeys.length === 0) {
+      console.error(colors.red(`${opt.keys.join(', ')} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`));
+      throw new Error(`${opt.keys.join(', ')} not found in ${opt.version}/${opt.language}/${opt.namespace} => ${JSON.stringify(obj, null, 2)}`)
+    }
+    if (console.table) {
+      console.table(retWitAllKeys);
+    } else {
+      opt.keys.forEach((k) => {
+        console.log(`${k}\t=>\t${ret[k] || ''}`);
+      });
+    }
+  }
+};
+
+module.exports = get;

package/dist/cjs/getBranches.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var colors = require('colors');
+var request = require('./request.js');
+
+const getBranches = async (opt) => {
+  const { res, obj, err } = await request(opt.apiEndpoint + '/branches/' + opt.projectId, {
+    method: 'get',
+    headers: {
+      Authorization: opt.apiKey
+    }
+  });
+
+  if (err || (obj && (obj.errorMessage || obj.message))) {
+    console.log(colors.red('getting branches failed...'));
+    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 === 404) {
+    console.error(colors.yellow(res.statusText + ' (' + res.status + ')'));
+    return null
+  }
+  if (res.status >= 300) {
+    console.error(colors.red(res.statusText + ' (' + res.status + ')'));
+    throw new Error(res.statusText + ' (' + res.status + ')')
+  }
+  console.log(colors.green('getting branches successful'));
+  return obj
+};
+
+module.exports = getBranches;

package/dist/cjs/getJob.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var colors = require('colors');
+var request = require('./request.js');
+
+const getJob = async (opt, jobId) => {
+  const { res, obj, err } = await request(opt.apiEndpoint + '/jobs/' + opt.projectId + '/' + jobId, {
+    method: 'get',
+    headers: {
+      Authorization: opt.apiKey
+    }
+  });
+
+  if (err || (obj && (obj.errorMessage || obj.message))) {
+    console.log(colors.red('getting job failed...'));
+    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 === 404) {
+    console.error(colors.yellow(res.statusText + ' (' + res.status + ')'));
+    return null
+  }
+  if (res.status >= 300) {
+    console.error(colors.red(res.statusText + ' (' + res.status + ')'));
+    throw new Error(res.statusText + ' (' + res.status + ')')
+  }
+  console.log(colors.green('getting job successful'));
+  return obj
+};
+
+module.exports = getJob;

package/dist/cjs/getProjectStats.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var colors = require('colors');
+var request = require('./request.js');
+
+const getProjectStats = async (opt) => {
+  const { res, obj, err } = await request(opt.apiEndpoint + '/stats/project/' + opt.projectId, {
+    method: 'get',
+    headers: {
+      Authorization: opt.apiKey
+    }
+  });
+
+  if (err || (obj && (obj.errorMessage || obj.message))) {
+    console.log(colors.red('getting job failed...'));
+    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 === 404) {
+    console.error(colors.yellow(res.statusText + ' (' + res.status + ')'));
+    return null
+  }
+  if (res.status >= 300) {
+    console.error(colors.red(res.statusText + ' (' + res.status + ')'));
+    throw new Error(res.statusText + ' (' + res.status + ')')
+  }
+  console.log(colors.green('getting project stats successful'));
+  return obj
+};
+
+module.exports = getProjectStats;

package/dist/cjs/getRemoteLanguages.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var request = require('./request.js');
+
+const getRemoteLanguages = async (opt) => {
+  const { res, obj } = await request(opt.apiEndpoint + '/languages/' + opt.projectId + '?ts=' + Date.now() + (opt.cdnType === 'standard' ? '&cache=no' : ''), {
+    method: 'get'
+  });
+  if ((obj && (obj.errorMessage || obj.message))) {
+    if (res && res.statusText && res.status) {
+      throw new Error(res.statusText + ' (' + res.status + ') | ' + (obj.errorMessage || obj.message))
+    }
+    throw new Error((obj.errorMessage || obj.message))
+  }
+  if (res.status >= 300) throw new Error(res.statusText + ' (' + res.status + ')')
+
+  if (Object.keys(obj).length === 0) {
+    throw new Error('Project with id "' + opt.projectId + '" not found!')
+  }
+
+  const lngs = Object.keys(obj);
+  let foundRefLng = null;
+  lngs.forEach((l) => {
+    if (obj[l].isReferenceLanguage) foundRefLng = l;
+  });
+  if (!foundRefLng) {
+    throw new Error('Reference language for project with id "' + opt.projectId + '" not found!')
+  }
+  opt.referenceLanguage = foundRefLng;
+
+  // reflng first
+  lngs.splice(lngs.indexOf(opt.referenceLanguage), 1);
+  lngs.unshift(opt.referenceLanguage);
+
+  return lngs
+};
+
+module.exports = getRemoteLanguages;

package/dist/cjs/getRemoteNamespace.js

@@ -0,0 +1,125 @@
+'use strict';
+
+var request = require('./request.js');
+var flatten = require('flat');
+var sortFlatResources = require('./sortFlatResources.js');
+
+const getRandomDelay = (delayFrom, delayTo) => Math.floor(Math.random() * delayTo) + delayFrom;
+
+function onlyKeysFlat (resources, prefix, ret) {
+  ret = ret || {};
+  if (!resources) return ret
+  Object.keys(resources).forEach((k) => {
+    if (typeof resources[k] === 'string' || !resources[k] || typeof resources[k].value === 'string') {
+      if (prefix) {
+        ret[prefix + '.' + k] = resources[k];
+      } else {
+        ret[k] = resources[k];
+      }
+    } else {
+      onlyKeysFlat(resources[k], prefix ? prefix + '.' + k : k, ret);
+    }
+  });
+  return ret
+}
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+
+const pullNamespacePaged = async (opt, lng, ns, next = '', retry = 0) => {
+  const { res, obj, err } = await request(opt.apiEndpoint + '/pull/' + opt.projectId + '/' + opt.version + '/' + lng + '/' + ns + '?' + 'next=' + next + ((opt.raw || opt.overriddenOnly) ? '&raw=true' : '') + '&ts=' + Date.now(), {
+    method: 'get',
+    headers: {
+      Authorization: opt.apiKey
+    }
+  });
+  if (err) throw err
+  if (res.status >= 300) {
+    if (retry < 3 && res.status !== 401) {
+      await sleep(getRandomDelay(3000, 10000));
+      return await pullNamespacePaged(opt, lng, ns, next, retry + 1)
+    }
+    if (obj && (obj.errorMessage || obj.message)) {
+      if (res.statusText && res.status) {
+        throw new Error(res.statusText + ' (' + res.status + ') | ' + (obj.errorMessage || obj.message))
+      }
+      throw new Error((obj.errorMessage || obj.message))
+    }
+    throw new Error(res.statusText + ' (' + res.status + ')')
+  }
+
+  let resultObj = obj;
+  if (opt.overriddenOnly && obj) {
+    const newObj = {};
+    Object.keys(obj).forEach((k) => {
+      if (obj[k].overrides !== undefined) {
+        if (opt.raw) {
+          newObj[k] = obj[k];
+        } else {
+          newObj[k] = obj[k].value;
+        }
+      }
+    });
+    resultObj = newObj;
+  }
+
+  return {
+    result: opt.raw ? sortFlatResources(onlyKeysFlat(resultObj)) : sortFlatResources(flatten(resultObj)),
+    next: res.headers.get('x-next-page'),
+    lastModified: res.headers.get('last-modified') ? new Date(res.headers.get('last-modified')) : undefined
+  }
+};
+
+const pullNamespace = async (opt, lng, ns) => {
+  const ret = {};
+  let lastModified = new Date(2000, 0, 1);
+  let next = '';
+  while (true) {
+    const info = await pullNamespacePaged(opt, lng, ns, next);
+    Object.keys(info.result).forEach((k) => {
+      ret[k] = info.result[k];
+    });
+    if (info.lastModified && info.lastModified.getTime() > (lastModified ? lastModified.getTime() : 0)) {
+      lastModified = info.lastModified;
+    }
+    if (info.next) {
+      next = info.next;
+      continue
+    }
+    break
+  }
+  return { result: ret, lastModified }
+};
+
+const getRemoteNamespace = async (opt, lng, ns) => {
+  if (opt.unpublished) {
+    const { result, lastModified } = await pullNamespace(opt, lng, ns);
+    return { result, lastModified }
+  }
+
+  const { res, obj, err } = await request(opt.apiEndpoint + (opt.isPrivate ? '/private' : '') + '/' + opt.projectId + '/' + opt.version + '/' + lng + '/' + ns + '?ts=' + Date.now() + (opt.cdnType === 'standard' ? '&cache=no' : ''), {
+    method: 'get',
+    headers: opt.isPrivate
+      ? {
+          Authorization: opt.apiKey
+        }
+      : undefined
+  });
+  if (err) throw err
+  const ignore404 = res.status === 404 && opt.cdnType === 'standard';
+  if (ignore404) return { result: {}, lastModified: undefined }
+  if (res.status >= 300) {
+    if (obj && (obj.errorMessage || obj.message)) {
+      if (res.statusText && res.status) {
+        throw new Error(res.statusText + ' (' + res.status + ') | ' + (obj.errorMessage || obj.message))
+      }
+      throw new Error((obj.errorMessage || obj.message))
+    }
+    throw new Error(res.statusText + ' (' + res.status + ')')
+  }
+  return {
+    result: sortFlatResources(flatten(obj)),
+    lastModified: res.headers.get('last-modified') ? new Date(res.headers.get('last-modified')) : undefined
+  }
+};
+
+module.exports = getRemoteNamespace;

package/dist/cjs/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+var add = require('./add.js');
+var get = require('./get.js');
+var download = require('./download.js');
+var migrate = require('./migrate.js');
+var sync = require('./sync.js');
+var publishVersion = require('./publishVersion.js');
+var copyVersion = require('./copyVersion.js');
+var createBranch = require('./createBranch.js');
+var deleteBranch = require('./deleteBranch.js');
+var deleteNamespace = require('./deleteNamespace.js');
+var format = require('./format.js');
+var getBranches = require('./getBranches.js');
+var getJob = require('./getJob.js');
+var mergeBranch = require('./mergeBranch.js');
+var missing = require('./missing.js');
+var removeVersion = require('./removeVersion.js');
+
+
+
+exports.add = add;
+exports.get = get;
+exports.download = download;
+exports.migrate = migrate;
+exports.sync = sync;
+exports.publishVersion = publishVersion;
+exports.copyVersion = copyVersion;
+exports.createBranch = createBranch;
+exports.deleteBranch = deleteBranch;
+exports.deleteNamespace = deleteNamespace;
+exports.format = format;
+exports.getBranches = getBranches;
+exports.getJob = getJob;
+exports.mergeBranch = mergeBranch;
+exports.missing = missing;
+exports.removeVersion = removeVersion;

package/dist/cjs/isValidUuid.js

@@ -0,0 +1,6 @@
+'use strict';
+
+const uuidRegex = /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i;
+const isValidUuid = (id) => uuidRegex.test(id);
+
+module.exports = isValidUuid;