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

'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();var _containsPath = require('contains-path');var _containsPath2 = _interopRequireDefault(_containsPath);
var _path = require('path');var _path2 = _interopRequireDefault(_path);

var _resolve = require('eslint-module-utils/resolve');var _resolve2 = _interopRequireDefault(_resolve);
var _staticRequire = require('../core/staticRequire');var _staticRequire2 = _interopRequireDefault(_staticRequire);
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 };}

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 noRestrictedPaths(context) {
    const options = context.options[0] || {};
    const restrictedPaths = options.zones || [];
    const basePath = options.basePath || process.cwd();
    const currentFilename = context.getFilename();
    const matchingZones = restrictedPaths.filter(zone => {
      const targetPath = _path2.default.resolve(basePath, zone.target);

      return (0, _containsPath2.default)(currentFilename, targetPath);
    });

    function isValidExceptionPath(absoluteFromPath, absoluteExceptionPath) {
      const relativeExceptionPath = _path2.default.relative(absoluteFromPath, absoluteExceptionPath);

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

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

    }

    function checkForRestrictedImportPath(importPath, node) {
      const absoluteImportPath = (0, _resolve2.default)(importPath, context);

      if (!absoluteImportPath) {
        return;
      }

      matchingZones.forEach(zone => {
        const exceptionPaths = zone.except || [];
        const absoluteFrom = _path2.default.resolve(basePath, zone.from);

        if (!(0, _containsPath2.default)(absoluteImportPath, absoluteFrom)) {
          return;
        }

        const absoluteExceptionPaths = exceptionPaths.map(exceptionPath =>
        _path2.default.resolve(absoluteFrom, exceptionPath));

        const hasValidExceptionPaths = absoluteExceptionPaths.
        every(absoluteExceptionPath => isValidExceptionPath(absoluteFrom, absoluteExceptionPath));

        if (!hasValidExceptionPaths) {
          reportInvalidExceptionPath(node);
          return;
        }

        const pathIsExcepted = absoluteExceptionPaths.
        some(absoluteExceptionPath => (0, _containsPath2.default)(absoluteImportPath, absoluteExceptionPath));

        if (pathIsExcepted) {
          return;
        }

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

      });
    }

    return {
      ImportDeclaration(node) {
        checkForRestrictedImportPath(node.source.value, node.source);
      },
      CallExpression(node) {
        if ((0, _staticRequire2.default)(node)) {var _node$arguments = _slicedToArray(
          node.arguments, 1);const firstArgument = _node$arguments[0];

          checkForRestrictedImportPath(firstArgument.value, firstArgument);
        }
      } };

  } };
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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