ae-biu/bin/ae-pack-i18n.js

Born For AE, Born To Do

#!/usr/bin/env node
'use strict';

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _stringify = require('babel-runtime/core-js/json/stringify');

var _stringify2 = _interopRequireDefault(_stringify);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _promise = require('babel-runtime/core-js/promise');

var _promise2 = _interopRequireDefault(_promise);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var extractI18NFiles = function () {
  var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(dir, language, destDir) {
    return _regenerator2.default.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            return _context.abrupt('return', _promise2.default.all(readI18NFilesSync(dir, language).map(function (file) {
              var relativePath = file.replace(dir, '');
              var targetFile = ('' + destDir + relativePath).replace(language + '.json', 'module.json');

              return (0, _executor.executeUnsafe)(copyFile, 'Got an error when copy file from ' + file + ' to ' + targetFile)(file, targetFile);
            })));

          case 1:
          case 'end':
            return _context.stop();
        }
      }
    }, _callee, this);
  }));

  return function extractI18NFiles(_x, _x2, _x3) {
    return _ref.apply(this, arguments);
  };
}();

var readI18NFileContent = function () {
  var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3(dir, language) {
    var _this = this;

    var all;
    return _regenerator2.default.wrap(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            all = {};
            _context3.next = 3;
            return _promise2.default.all(readI18NFilesSync(dir, language).map(function () {
              var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(file) {
                var content, dirname;
                return _regenerator2.default.wrap(function _callee2$(_context2) {
                  while (1) {
                    switch (_context2.prev = _context2.next) {
                      case 0:
                        _context2.next = 2;
                        return (0, _util.promisify)(_fs2.default.readFile)(file, 'utf8');

                      case 2:
                        content = _context2.sent;
                        dirname = _path2.default.dirname(file).replace(dir, '').replace(_path2.default.sep, '');


                        if (process.platform === 'win32') {
                          dirname = dirname.replace(/\\/g, '/');
                        }

                        if (!dirname) {
                          dirname = 'ae';
                        }
                        all[dirname] = JSON.parse(content);

                      case 7:
                      case 'end':
                        return _context2.stop();
                    }
                  }
                }, _callee2, _this);
              }));

              return function (_x6) {
                return _ref3.apply(this, arguments);
              };
            }()));

          case 3:
            return _context3.abrupt('return', all);

          case 4:
          case 'end':
            return _context3.stop();
        }
      }
    }, _callee3, this);
  }));

  return function readI18NFileContent(_x4, _x5) {
    return _ref2.apply(this, arguments);
  };
}();

var copyFile = function () {
  var _ref4 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4(src, dest) {
    var content;
    return _regenerator2.default.wrap(function _callee4$(_context4) {
      while (1) {
        switch (_context4.prev = _context4.next) {
          case 0:
            _context4.next = 2;
            return (0, _util.promisify)(_fs2.default.readFile)(src, 'utf8');

          case 2:
            content = _context4.sent;
            return _context4.abrupt('return', (0, _util.promisify)(writeFile)(dest, content));

          case 4:
          case 'end':
            return _context4.stop();
        }
      }
    }, _callee4, this);
  }));

  return function copyFile(_x7, _x8) {
    return _ref4.apply(this, arguments);
  };
}();

var zipDirectory = function () {
  var _ref5 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee5(dir, zipFileName, callback) {
    var output, archive;
    return _regenerator2.default.wrap(function _callee5$(_context5) {
      while (1) {
        switch (_context5.prev = _context5.next) {
          case 0:
            output = _fs2.default.createWriteStream(dir + '/' + zipFileName + '.zip');
            archive = (0, _archiver2.default)('zip');


            output.on('close', callback);
            archive.on('error', callback);
            _logger2.default.info('archiving...');
            archive.pipe(output);
            archive.glob('!(*.zip)', {
              cwd: dir
            });

            archive.finalize();

          case 8:
          case 'end':
            return _context5.stop();
        }
      }
    }, _callee5, this);
  }));

  return function zipDirectory(_x9, _x10, _x11) {
    return _ref5.apply(this, arguments);
  };
}();

var run = function () {
  var _ref6 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee7() {
    var _this2 = this;

    var start, srcDir, staticDir, pkgConfig, language, targetDir, version, time;
    return _regenerator2.default.wrap(function _callee7$(_context7) {
      while (1) {
        switch (_context7.prev = _context7.next) {
          case 0:
            start = Date.now();
            srcDir = _path2.default.resolve(process.cwd(), 'src/modules');
            staticDir = _path2.default.resolve(process.cwd(), 'src/static/locale');
            pkgConfig = getPackageConfig();
            language = _commander2.default.lang || pkgConfig.language;


            console.log();
            _logger2.default.info('Start extracting ' + _chalk2.default.red(language) + '.json files...');

            targetDir = _commander2.default.args[0] || './i18n-data';

            targetDir = _path2.default.isAbsolute(targetDir) ? targetDir : _path2.default.resolve(process.cwd(), targetDir);
            (0, _executor.executeSafe)(_rimraf2.default.sync, 'Got an error when rmdir ' + targetDir)(targetDir);

            if (!_commander2.default.keep) {
              _context7.next = 15;
              break;
            }

            _context7.next = 13;
            return _promise2.default.all([extractI18NFiles(srcDir, language, targetDir), extractI18NFiles(staticDir, language, targetDir)]);

          case 13:
            _context7.next = 17;
            break;

          case 15:
            _context7.next = 17;
            return (0, _executor.executeUnsafe)((0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee6() {
              var modules, common;
              return _regenerator2.default.wrap(function _callee6$(_context6) {
                while (1) {
                  switch (_context6.prev = _context6.next) {
                    case 0:
                      _context6.next = 2;
                      return readI18NFileContent(srcDir, language);

                    case 2:
                      modules = _context6.sent;
                      _context6.next = 5;
                      return readI18NFileContent(staticDir, language);

                    case 5:
                      common = _context6.sent;

                      (0, _util.promisify)(writeFile)('' + targetDir + _path2.default.sep + 'module.json', (0, _stringify2.default)((0, _extends3.default)({}, modules, common), null, 2));

                    case 7:
                    case 'end':
                      return _context6.stop();
                  }
                }
              }, _callee6, _this2);
            })), 'Got an error in reading I18N file content')();

          case 17:
            version = _commander2.default.data_version || pkgConfig.version;

            if (version[0] !== 'v') {
              version = 'v' + version;
            }
            _context7.next = 21;
            return (0, _executor.executeUnsafe)((0, _util.promisify)(writeFile), 'Got an error in writing version ' + version + ' to version.txt')('' + targetDir + _path2.default.sep + 'version.txt', version);

          case 21:
            if (!_commander2.default.zip) {
              _context7.next = 24;
              break;
            }

            _context7.next = 24;
            return (0, _executor.executeSafe)((0, _util.promisify)(zipDirectory), 'Got an error in zipping files.')(targetDir, language + '_' + version);

          case 24:
            time = Date.now() - start;

            console.log();
            _logger2.default.success('Done in ' + _chalk2.default.blue(time + 'ms') + ' !!!');

          case 27:
          case 'end':
            return _context7.stop();
        }
      }
    }, _callee7, this);
  }));

  return function run() {
    return _ref6.apply(this, arguments);
  };
}();

var _commander = require('commander');

var _commander2 = _interopRequireDefault(_commander);

var _chalk = require('chalk');

var _chalk2 = _interopRequireDefault(_chalk);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _fs = require('fs');

var _fs2 = _interopRequireDefault(_fs);

var _util = require('util');

var _rimraf = require('rimraf');

var _rimraf2 = _interopRequireDefault(_rimraf);

var _mkdirp = require('mkdirp');

var _mkdirp2 = _interopRequireDefault(_mkdirp);

var _archiver = require('archiver');

var _archiver2 = _interopRequireDefault(_archiver);

var _readDirRecursive = require('./utils/read-dir-recursive');

var _logger = require('./utils/logger');

var _logger2 = _interopRequireDefault(_logger);

var _executor = require('./utils/executor');

var _readJson = require('./utils/read-json');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

_commander2.default.on('--help', function () {
  console.log();
  console.log('  Usage:');
  console.log();
  console.log('     $ ae pack-i18n [-l | --language] [-k | --keep] [-z | --zip]');
  console.log('                    [-v|--data_version] [<version>] [<target folder>]');
  console.log();
  console.log('  Run $ ae pack-i18n -h for more information.');
  console.log();
});

_commander2.default.usage('[--options] <directory>').option('-l, --lang <language>', 'Pack I18N json file for specific language.').option('-k, --keep', 'Keep file structure, otherwise all of the json data will merge into module.json.').option('-z, --zip', 'Zip the I18N json files and version.txt.').option('-v, --data_version <data_version>', 'The version of I18N json files to write into version.txt. Use package.json version as default.').parse(process.argv);

function getPackageConfig() {
  var pkg = (0, _readJson.readJSONFileSync)(_path2.default.resolve(process.cwd(), 'package.json'));
  var config = {
    language: 'zh-CN',
    version: '0.0.1'
  };
  try {
    config.language = pkg.ae.languages[0].trim();
  } catch (error) {
    _logger2.default.warning('Cannot find languages in packages.json, use "zh-CN" as default.');
  }

  config.version = pkg.version;
  return config;
}

function readI18NFilesSync(dir, language) {
  (0, _executor.executeUnsafe)((0, _util.promisify)(_fs2.default.accessSync), 'Cannot find source directory, make sure you are in an AE project.')(dir);

  return (0, _executor.executeUnsafe)(_readDirRecursive.readDirRecursiveSync, 'Got an error when reading ' + dir)(dir, language + '.json');
}

function writeFile(file, contents, cb) {
  (0, _mkdirp2.default)(_path2.default.dirname(file), function (err) {
    if (err) {
      return cb(err);
    }
    _fs2.default.writeFile(file, contents, cb);
  });
}

run();