webhook/node_modules/eslint-plugin-import/lib/rules/no-restricted-paths.js

'use strict';var _path = require('path');var _path2 = _interopRequireDefault(_path);

var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);
var _moduleVisitor = require('eslint-module-utils/moduleVisitor');var _moduleVisitor2 = _interopRequireDefault(_moduleVisitor);
var _isGlob = require('is-glob');var _isGlob2 = _interopRequireDefault(_isGlob);
var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch);
var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);
var _importType = require('../core/importType');var _importType2 = _interopRequireDefault(_importType);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}

var containsPath = function containsPath(filepath, target) {
  var relative = _path2['default'].relative(target, filepath);
  return relative === '' || !relative.startsWith('..');
};

module.exports = {
  meta: {
    type: 'problem',
    docs: {
      url: (0, _docsUrl2['default'])('no-restricted-paths') },


    schema: [
    {
      type: 'object',
      properties: {
        zones: {
          type: 'array',
          minItems: 1,
          items: {
            type: 'object',
            properties: {
              target: { type: 'string' },
              from: { type: 'string' },
              except: {
                type: 'array',
                items: {
                  type: 'string' },

                uniqueItems: true },

              message: { type: 'string' } },

            additionalProperties: false } },


        basePath: { type: 'string' } },

      additionalProperties: false }] },




  create: function () {function noRestrictedPaths(context) {
      var options = context.options[0] || {};
      var restrictedPaths = options.zones || [];
      var basePath = options.basePath || process.cwd();
      var currentFilename = context.getPhysicalFilename ? context.getPhysicalFilename() : context.getFilename();
      var matchingZones = restrictedPaths.filter(function (zone) {
        var targetPath = _path2['default'].resolve(basePath, zone.target);

        if ((0, _isGlob2['default'])(targetPath)) {
          return (0, _minimatch2['default'])(currentFilename, targetPath);
        }

        return containsPath(currentFilename, targetPath);
      });

      function isValidExceptionPath(absoluteFromPath, absoluteExceptionPath) {
        var relativeExceptionPath = _path2['default'].relative(absoluteFromPath, absoluteExceptionPath);

        return (0, _importType2['default'])(relativeExceptionPath, context) !== 'parent';
      }

      function reportInvalidExceptionPath(node) {
        context.report({
          node: node,
          message: 'Restricted path exceptions must be descendants of the configured `from` path for that zone.' });

      }

      function reportInvalidExceptionGlob(node) {
        context.report({
          node: node,
          message: 'Restricted path exceptions must be glob patterns when`from` is a glob pattern' });

      }

      var makePathValidator = function () {function makePathValidator(zoneFrom) {var zoneExcept = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
          var absoluteFrom = _path2['default'].resolve(basePath, zoneFrom);
          var isGlobPattern = (0, _isGlob2['default'])(zoneFrom);
          var isPathRestricted = void 0;
          var hasValidExceptions = void 0;
          var isPathException = void 0;
          var reportInvalidException = void 0;

          if (isGlobPattern) {
            var mm = new _minimatch.Minimatch(absoluteFrom);
            isPathRestricted = function () {function isPathRestricted(absoluteImportPath) {return mm.match(absoluteImportPath);}return isPathRestricted;}();

            hasValidExceptions = zoneExcept.every(_isGlob2['default']);

            if (hasValidExceptions) {
              var exceptionsMm = zoneExcept.map(function (except) {return new _minimatch.Minimatch(except);});
              isPathException = function () {function isPathException(absoluteImportPath) {return exceptionsMm.some(function (mm) {return mm.match(absoluteImportPath);});}return isPathException;}();
            }

            reportInvalidException = reportInvalidExceptionGlob;
          } else {
            isPathRestricted = function () {function isPathRestricted(absoluteImportPath) {return containsPath(absoluteImportPath, absoluteFrom);}return isPathRestricted;}();

            var absoluteExceptionPaths = zoneExcept.
            map(function (exceptionPath) {return _path2['default'].resolve(absoluteFrom, exceptionPath);});
            hasValidExceptions = absoluteExceptionPaths.
            every(function (absoluteExceptionPath) {return isValidExceptionPath(absoluteFrom, absoluteExceptionPath);});

            if (hasValidExceptions) {
              isPathException = function () {function isPathException(absoluteImportPath) {return absoluteExceptionPaths.some(
                  function (absoluteExceptionPath) {return containsPath(absoluteImportPath, absoluteExceptionPath);});}return isPathException;}();

            }

            reportInvalidException = reportInvalidExceptionPath;
          }

          return {
            isPathRestricted: isPathRestricted,
            hasValidExceptions: hasValidExceptions,
            isPathException: isPathException,
            reportInvalidException: reportInvalidException };

        }return makePathValidator;}();

      var validators = [];

      function checkForRestrictedImportPath(importPath, node) {
        var absoluteImportPath = (0, _resolve2['default'])(importPath, context);

        if (!absoluteImportPath) {
          return;
        }

        matchingZones.forEach(function (zone, index) {
          if (!validators[index]) {
            validators[index] = makePathValidator(zone.from, zone.except);
          }var _validators$index =






          validators[index],isPathRestricted = _validators$index.isPathRestricted,hasValidExceptions = _validators$index.hasValidExceptions,isPathException = _validators$index.isPathException,reportInvalidException = _validators$index.reportInvalidException;

          if (!isPathRestricted(absoluteImportPath)) {
            return;
          }

          if (!hasValidExceptions) {
            reportInvalidException(node);
            return;
          }

          var pathIsExcepted = isPathException(absoluteImportPath);
          if (pathIsExcepted) {
            return;
          }

          context.report({
            node: node,
            message: 'Unexpected path "{{importPath}}" imported in restricted zone.' + (zone.message ? ' ' + String(zone.message) : ''),
            data: { importPath: importPath } });

        });
      }

      return (0, _moduleVisitor2['default'])(function (source) {
        checkForRestrictedImportPath(source.value, source);
      }, { commonjs: true });
    }return noRestrictedPaths;}() };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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