ter-localization-cli/dist/helpers/io.js

Quick and powerful library for localization for react / react native application

"use strict";

function _toArray(arr) { return _arrayWithHoles(arr) || _iterableToArray(arr) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }

function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }

function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }

function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }

var fs = require('fs');

var write = function write(config, languages) {
  var path = config.storage_path;
  var languagesCode = config.languages;

  if (!fs.existsSync("".concat(process.cwd(), "/").concat(path))) {
    fs.mkdirSync("".concat(process.cwd(), "/").concat(path));
  }

  languagesCode.map(function (code) {
    var filePath = "".concat(process.cwd(), "/").concat(path, "/").concat(code, ".json");
    var groups = languages[code];
    var orderedGroups = Object.keys(groups).sort().reduce(function (result, current) {
      var words = groups[current];
      var orderedWords = Object.keys(words).sort().reduce(function (resultWord, currentWord) {
        resultWord[currentWord] = words[currentWord];
        return resultWord;
      }, {});
      result[current] = orderedWords;
      return result;
    }, {});
    fs.writeFileSync(filePath, JSON.stringify(orderedGroups, null, 2));
  });
};

var read = function read(config) {
  var path = config.storage_path;
  var languagesCode = config.languages;
  var result = {};
  languagesCode.map(function (code) {
    var filePath = "".concat(process.cwd(), "/").concat(path, "/").concat(code, ".json");

    if (fs.existsSync(filePath)) {
      result[code] = JSON.parse(fs.readFileSync(filePath));
    } else {
      result[code] = {};
    }
  });
  return result;
};

var toArray = function toArray(data) {
  var languages = Object.keys(data);
  var groups = languages.reduce(function (result, language) {
    return result.concat(Object.keys(data[language]));
  }, []).filter(distinct);
  var headers = ['Group', 'Keyword'].concat(_toConsumableArray(languages));
  var values = groups.reduce(function (group_result, group) {
    var keys = languages.reduce(function (result, language) {
      return result.concat(Object.keys(data[language][group]));
    }, []).filter(distinct);
    var rows = keys.map(function (key) {
      var words = languages.map(function (language) {
        return data[language][group][key];
      });
      return [group, key].concat(_toConsumableArray(words));
    });
    return group_result.concat(rows);
  }, [headers]);
  return values;
};

var fromArray = function fromArray(data) {
  var base = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};

  var _data = _toArray(data),
      header = _data[0],
      lines = _data.slice(1);

  var _header = _toArray(header),
      groupHeader = _header[0],
      keywordHeader = _header[1],
      languageKeys = _header.slice(2);

  var result = base;

  for (var i = 0; i < lines.length; i++) {
    var _lines$i = _toArray(lines[i]),
        group = _lines$i[0],
        key = _lines$i[1],
        words = _lines$i.slice(2);

    if (group.length == 0 || key.length == 0) {
      break;
    }

    for (var j = 0; j < languageKeys.length; j++) {
      var languageKey = languageKeys[j];

      if (!result[languageKey]) {
        result[languageKey] = {};
      }

      if (!result[languageKey][group]) {
        result[languageKey][group] = {};
      }

      result[languageKey][group][key] = words[j];
    }
  }

  return result;
};

var distinct = function distinct(value, index, self) {
  return self.indexOf(value) === index;
};

var IOHelper = {
  write: write,
  read: read,
  toArray: toArray,
  fromArray: fromArray
};
module.exports = IOHelper;