locize-cli 11.0.0 → 12.0.0

package/dist/esm/parseLocalLanguage.js

@@ -0,0 +1,194 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { mkdirp } from 'mkdirp';
+import convertToFlatFormat from './convertToFlatFormat.js';
+import { fileExtensionsMap as fileExtensionsMap$1, acceptedFileExtensions as acceptedFileExtensions$1 } from './formats.js';
+import xcstrings2locize from 'locize-xcstrings/cjs/xcstrings2locize';
+
+const fileExtensionsMap = fileExtensionsMap$1;
+const acceptedFileExtensions = acceptedFileExtensions$1;
+
+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 = 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);
+  }
+  let lngPath;
+  if (filledLngMask.lastIndexOf(path.sep) > 0) {
+    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 = [];
+  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);
+        if (splittedP.length > 2) {
+          additionalSubDirsLeft = splittedP.slice(0, foundSplittedIndex).join(path.sep);
+          additionalSubDirs = splittedP.slice(foundSplittedIndex + 1).join(path.sep);
+        }
+        let dirs = getDirectories(path.join(opt.path, additionalSubDirsLeft));
+        if (additionalSubDirs === '') {
+          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;
+            try {
+              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}`);
+
+              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}`);
+                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);
+                return a === b
+              });
+
+              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}`));
+          }
+        });
+      } else {
+        files = getFiles(path.join(opt.path, lngPath));
+      }
+    } else {
+      files = getFiles(opt.path);
+      // filter lng files...
+      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 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);
+    }
+    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));
+      if (dirPath.indexOf(restNsMask) > 0) {
+        namespace = dirPath.substring(filledNsMask.indexOf(nsMask), dirPath.indexOf(restNsMask));
+      } else {
+        namespace = dirPath.substring(filledNsMask.indexOf(nsMask));
+      }
+    } else if (!hasNamespaceInPath && startNsIndex < 0) {
+      namespace = opt.namespace;
+    }
+    let fPath = path.join(opt.path, lngPath || '', file);
+    if (dirPath && lngPath.indexOf(nsMask) > -1) {
+      fPath = path.join(opt.path, dirPath.replace(nsMask, namespace), file);
+    }
+    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.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
+      }
+    } 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
+      }
+      const stat = await fs.promises.stat(fPath);
+      return {
+        namespace,
+        path: fPath,
+        extension: fExt,
+        content,
+        language: lng,
+        mtime: stat.mtime
+      }
+    }
+  }));
+
+  // 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
+};
+
+export { parseLocalLanguage as default };

package/dist/esm/parseLocalLanguages.js

@@ -0,0 +1,16 @@
+import parseLocalLanguage from './parseLocalLanguage.js';
+import filterNamespaces from './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
+};
+
+export { parseLocalLanguages as default };

package/dist/esm/parseLocalReference.js

@@ -0,0 +1,9 @@
+import parseLocalLanguage from './parseLocalLanguage.js';
+import filterNamespaces from './filterNamespaces.js';
+
+const parseLocalReference = async (opt) => {
+  const nss = await parseLocalLanguage(opt, opt.referenceLanguage);
+  return filterNamespaces(opt, nss).filter((n) => n.language === opt.referenceLanguage)
+};
+
+export { parseLocalReference as default };

package/dist/esm/publishVersion.js

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

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

@@ -2,16 +2,16 @@
 function removeUndefinedFromArrays (obj) {
   if (!obj) return obj
 
-  const propNames = Object.keys(obj)
+  const propNames = Object.keys(obj);
   propNames.forEach((propName) => {
     if (Array.isArray(obj[propName]) && obj[propName][0] === undefined) {
-      obj[propName].shift()
+      obj[propName].shift();
     } else if (typeof obj[propName] === 'object') {
-      removeUndefinedFromArrays(obj[propName])
+      removeUndefinedFromArrays(obj[propName]);
     }
-  })
+  });
 
   return obj
 }
 
-module.exports = removeUndefinedFromArrays
+export { removeUndefinedFromArrays as default };

package/dist/esm/removeVersion.js

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

package/dist/esm/request.js

@@ -0,0 +1,64 @@
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import https from 'https';
+import CacheableLookup from '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 = new HttpsProxyAgent(httpProxy);
+    cacheable.install(httpsProxyAgent);
+    options.agent = httpsProxyAgent;
+  }
+
+  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)
+}
+
+export { request as default };

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

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

package/dist/esm/sortFlatResources.js

@@ -0,0 +1,11 @@
+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
+};
+
+export { sortFlatResources as default };