locize-cli 11.0.0 → 12.0.0

package/dist/esm/format.js

@@ -0,0 +1,154 @@
+import colors from 'colors';
+import fs from 'node:fs';
+import path from 'node:path';
+import { diffLines } from 'diff';
+import convertToFlatFormat from './convertToFlatFormat.js';
+import convertToDesiredFormat from './convertToDesiredFormat.js';
+import sortFlatResources from './sortFlatResources.js';
+import { reversedFileExtensionsMap as reversedFileExtensionsMap$1, acceptedFileExtensions as acceptedFileExtensions$1, fileExtensionsMap as fileExtensionsMap$1 } from './formats.js';
+
+const fileExtensionsMap = fileExtensionsMap$1;
+const acceptedFileExtensions = acceptedFileExtensions$1;
+const reversedFileExtensionsMap = reversedFileExtensionsMap$1;
+
+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 = 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);
+  }
+}
+
+export { format as default };

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

@@ -15,19 +15,15 @@ const fileExtensionsMap = {
   '.php': ['laravel'],
   '.properties': ['properties'],
   '.xcstrings': ['xcstrings']
-}
+};
 
-const acceptedFileExtensions = Object.keys(fileExtensionsMap)
+const acceptedFileExtensions = Object.keys(fileExtensionsMap);
 
-const reversedFileExtensionsMap = {}
+const reversedFileExtensionsMap = {};
 acceptedFileExtensions.forEach((ext) => {
   fileExtensionsMap[ext].forEach((format) => {
-    reversedFileExtensionsMap[format] = ext
-  })
-})
+    reversedFileExtensionsMap[format] = ext;
+  });
+});
 
-module.exports = {
-  fileExtensionsMap,
-  acceptedFileExtensions,
-  reversedFileExtensionsMap
-}
+export { acceptedFileExtensions, fileExtensionsMap, reversedFileExtensionsMap };

package/dist/esm/get.js

@@ -0,0 +1,64 @@
+import colors from 'colors';
+import request from './request.js';
+import flatten from '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] || ''}`);
+      });
+    }
+  }
+};
+
+export { get as default };

package/dist/esm/getBranches.js

@@ -0,0 +1,35 @@
+import colors from 'colors';
+import request from './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
+};
+
+export { getBranches as default };

package/dist/esm/getJob.js

@@ -0,0 +1,35 @@
+import colors from 'colors';
+import request from './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
+};
+
+export { getJob as default };

package/dist/esm/getProjectStats.js

@@ -0,0 +1,35 @@
+import colors from 'colors';
+import request from './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
+};
+
+export { getProjectStats as default };

package/dist/esm/getRemoteLanguages.js

@@ -0,0 +1,36 @@
+import request from './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
+};
+
+export { getRemoteLanguages as default };

package/dist/esm/getRemoteNamespace.js

@@ -0,0 +1,123 @@
+import request from './request.js';
+import flatten from 'flat';
+import sortFlatResources from './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
+  }
+};
+
+export { getRemoteNamespace as default };

package/dist/esm/index.js

@@ -0,0 +1,16 @@
+export { default as add } from './add.js';
+export { default as get } from './get.js';
+export { default as download } from './download.js';
+export { default as migrate } from './migrate.js';
+export { default as sync } from './sync.js';
+export { default as publishVersion } from './publishVersion.js';
+export { default as copyVersion } from './copyVersion.js';
+export { default as createBranch } from './createBranch.js';
+export { default as deleteBranch } from './deleteBranch.js';
+export { default as deleteNamespace } from './deleteNamespace.js';
+export { default as format } from './format.js';
+export { default as getBranches } from './getBranches.js';
+export { default as getJob } from './getJob.js';
+export { default as mergeBranch } from './mergeBranch.js';
+export { default as missing } from './missing.js';
+export { default as removeVersion } from './removeVersion.js';

package/dist/esm/isValidUuid.js

@@ -0,0 +1,4 @@
+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);
+
+export { isValidUuid as default };