babel-plugin-react-intl-messages-generator/lib/index.js

Extracts explicit texts from react components and generate a componentNameMessages.js files

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _set = require('babel-runtime/core-js/set');

var _set2 = _interopRequireDefault(_set);

var _symbol = require('babel-runtime/core-js/symbol');

var _symbol2 = _interopRequireDefault(_symbol);

exports.default = function (_ref) {
  var t = _ref.types;
  // eslint-disable-line no-unused-vars

  function isTextIgnorable(text) {
    var hasWords = /^\w+/.test(text); // covers empty string
    var isNumber = /^\d+$/.test(text);
    return text.length === 1 || isNumber || !hasWords;
  }

  function generateDescriptorFromText(defaultMessage, path, state) {
    var file = state.file,
        _state$reactIntlMessa = state.reactIntlMessages,
        generatedDescriptors = _state$reactIntlMessa.generatedDescriptors,
        proxyTexts = _state$reactIntlMessa.proxyTexts;


    defaultMessage = defaultMessage.trim();

    if (isTextIgnorable(defaultMessage) || proxyTexts.has(defaultMessage)) return;

    proxyTexts.add(defaultMessage);

    var prefixId = p.relative(process.cwd(), file.opts.filename).split('/').join('.').replace(/jsx?/, '..');

    generatedDescriptors.push({ id: prefixId, defaultMessage: defaultMessage });
  }

  function tagAsExtracted(path) {
    path.node[EXTRACTED_TAG] = true;
  }

  function wasExtracted(path) {
    return !!path.node[EXTRACTED_TAG];
  }

  return {
    visitor: {
      Program: {
        enter: function enter(path, state) {
          state.reactIntlMessages = {
            generatedDescriptors: [],
            proxyTexts: new _set2.default()
          };
        },
        exit: function exit(path, state) {
          var file = state.file,
              opts = state.opts,
              reactIntlMessages = state.reactIntlMessages;
          var _file$opts = file.opts,
              basename = _file$opts.basename,
              filename = _file$opts.filename;


          var generatedDescriptors = reactIntlMessages.generatedDescriptors;
          file.metadata['react-intl-defineMessages'] = { generatedDescriptors: generatedDescriptors };

          if (opts.messagesDir && generatedDescriptors.length > 0) {
            (function () {
              var relativePath = p.join(p.sep, p.relative(process.cwd(), filename));

              var generatedMessagesFilename = p.join(opts.messagesDir, p.dirname(relativePath), basename + 'Messages.js');

              var existingContent = void 0;
              if ((0, _fs.existsSync)(generatedMessagesFilename)) {
                existingContent = (0, _fs.readFileSync)(generatedMessagesFilename, 'utf-8');
              }

              var namedDesriptors = generatedDescriptors.reduce(function (descriptorsWithKey, descriptor) {

                if (existingContent) {
                  var defaultMessage = descriptor.defaultMessage;

                  var messageExist = new RegExp('defaultMessage: \'' + defaultMessage + '\'');

                  if (messageExist.test(existingContent)) {
                    return descriptorsWithKey;
                  }
                }

                descriptorsWithKey += (0, _utils.createDescriptorsWithKey)(descriptor);
                return descriptorsWithKey;
              }, '');

              (0, _mkdirp.sync)(p.dirname(generatedMessagesFilename));

              // updating existing file
              if (existingContent && namedDesriptors) {
                var oldDescriptors = (0, _utils.removeDefindeMessageFormat)(existingContent);

                var updatedNamedDescriptors = oldDescriptors + namedDesriptors;
                var updatedDescriptorFile = (0, _utils.defineMessageFormat)(updatedNamedDescriptors);

                (0, _fs.writeFileSync)(generatedMessagesFilename, updatedDescriptorFile);
              }

              // new file
              if (!existingContent && namedDesriptors) {
                var generatedDescriptorFile = (0, _utils.defineMessageFormat)(namedDesriptors);
                (0, _fs.writeFileSync)(generatedMessagesFilename, generatedDescriptorFile);
              }
              // else keep the file untouched
            })();
          }
        }
      }, // Program ends

      JSXText: function JSXText(path, state) {
        if (wasExtracted(path)) {
          return;
        }

        generateDescriptorFromText(path.node.value, path, state);

        // Tag the AST node so we don't try to extract it twice.
        tagAsExtracted(path);
      }
    } };
};

var _path = require('path');

var p = _interopRequireWildcard(_path);

var _fs = require('fs');

var _mkdirp = require('mkdirp');

var _utils = require('./utils');

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

/*
 * Copyright 2017-Present, Peramanathan Sathyamoorthy.
 * Copyrights licensed under the New BSD License.
 * See the accompanying LICENSE file for terms.
 */

var EXTRACTED_TAG = (0, _symbol2.default)('DescriptorGenerated');