ysjj-system/node_modules/eslint-plugin-jsdoc/dist/rules/requireDescriptionCompleteSentence.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _lodash = _interopRequireDefault(require("lodash"));

var _iterateJsdoc = _interopRequireDefault(require("../iterateJsdoc"));

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

var extractParagraphs = function extractParagraphs(text) {
  return text.split(/\n\n/);
};

var extractSentences = function extractSentences(text) {
  return text // Remove all {} tags.
  .replace(/\{[\s\S]*?\}\s*/g, '').split(/[.?!](?:\s+|$)/) // Ignore sentences with only whitespaces.
  .filter(function (sentence) {
    return !/^\s*$/.test(sentence);
  }) // Re-add the dot.
  .map(function (sentence) {
    return sentence + '.';
  });
};

var isNewLinePrecededByAPeriod = function isNewLinePrecededByAPeriod(text) {
  var lastLineEndsSentence;
  var lines = text.split('\n');
  return !_lodash.default.some(lines, function (line) {
    if (_lodash.default.isBoolean(lastLineEndsSentence) && !lastLineEndsSentence && /^[A-Z]/.test(line)) {
      return true;
    }

    lastLineEndsSentence = /[.:?!]$/.test(line);
    return false;
  });
};

var isCapitalized = function isCapitalized(str) {
  return str[0] === str[0].toUpperCase();
};

var capitalize = function capitalize(str) {
  return str.charAt(0).toUpperCase() + str.slice(1);
};

var validateDescription = function validateDescription(description, report, jsdocNode, sourceCode, tag) {
  if (!description) {
    return false;
  }

  var paragraphs = extractParagraphs(description);
  return _lodash.default.some(paragraphs, function (paragraph) {
    var sentences = extractSentences(paragraph);

    var fix = function fix(fixer) {
      var text = sourceCode.getText(jsdocNode);

      if (!/[.:?!]$/.test(paragraph)) {
        var line = _lodash.default.last(paragraph.split('\n'));

        text = text.replace(new RegExp(_lodash.default.escapeRegExp(line) + '$', 'm'), line + '.');
      }

      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        var _loop = function _loop() {
          var sentence = _step.value;
          var beginning = sentence.split('\n')[0];

          if (tag) {
            var reg = new RegExp('(@' + _lodash.default.escapeRegExp(tag) + '.*)' + _lodash.default.escapeRegExp(beginning));
            text = text.replace(reg, function ($0, $1) {
              return $1 + capitalize(beginning);
            });
          } else {
            text = text.replace(beginning, capitalize(beginning));
          }
        };

        for (var _iterator = sentences.filter(function (sentence_) {
          return !isCapitalized(sentence_);
        })[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          _loop();
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return != null) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }

      return fixer.replaceText(jsdocNode, text);
    };

    if (_lodash.default.some(sentences, function (sentence) {
      return !isCapitalized(sentence);
    })) {
      report('Sentence should start with an uppercase character.', fix);
    }

    if (!/[.!?]$/.test(paragraph)) {
      report('Sentence must end with a period.', fix);
      return true;
    }

    if (!isNewLinePrecededByAPeriod(paragraph)) {
      report('A line of text is started with an uppercase character, but preceding line does not end the sentence.');
      return true;
    }

    return false;
  });
};

var _default = (0, _iterateJsdoc.default)(function (_ref) {
  var sourceCode = _ref.sourceCode,
      jsdoc = _ref.jsdoc,
      report = _ref.report,
      jsdocNode = _ref.jsdocNode;

  if (validateDescription(jsdoc.description, report, jsdocNode, sourceCode)) {
    return;
  }

  var tags = _lodash.default.filter(jsdoc.tags, function (tag) {
    return _lodash.default.includes(['param', 'arg', 'argument', 'returns', 'return'], tag.tag);
  });

  _lodash.default.some(tags, function (tag) {
    var description = _lodash.default.trimStart(tag.description, '- ');

    return validateDescription(description, report, jsdocNode, sourceCode, tag.tag);
  });
});

exports.default = _default;
module.exports = exports.default;
//# sourceMappingURL=requireDescriptionCompleteSentence.js.map