ddcAdmin/node_modules/eslint-plugin-import/lib/rules/no-useless-path-segments.js

'use strict';

var _ignore = require('eslint-module-utils/ignore');

var _moduleVisitor = require('eslint-module-utils/moduleVisitor');

var _moduleVisitor2 = _interopRequireDefault(_moduleVisitor);

var _resolve = require('eslint-module-utils/resolve');

var _resolve2 = _interopRequireDefault(_resolve);

var _path = require('path');

var _path2 = _interopRequireDefault(_path);

var _docsUrl = require('../docsUrl');

var _docsUrl2 = _interopRequireDefault(_docsUrl);

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

/**
 * convert a potentially relative path from node utils into a true
 * relative path.
 *
 * ../ -> ..
 * ./ -> .
 * .foo/bar -> ./.foo/bar
 * ..foo/bar -> ./..foo/bar
 * foo/bar -> ./foo/bar
 *
 * @param relativePath {string} relative posix path potentially missing leading './'
 * @returns {string} relative posix path that always starts with a ./
 **/
function toRelativePath(relativePath) {
  const stripped = relativePath.replace(/\/$/g, ''); // Remove trailing /

  return (/^((\.\.)|(\.))($|\/)/.test(stripped) ? stripped : `./${stripped}`
  );
} /**
   * @fileOverview Ensures that there are no useless path segments
   * @author Thomas Grainger
   */

function normalize(fn) {
  return toRelativePath(_path2.default.posix.normalize(fn));
}

function countRelativeParents(pathSegments) {
  return pathSegments.reduce((sum, pathSegment) => pathSegment === '..' ? sum + 1 : sum, 0);
}

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      url: (0, _docsUrl2.default)('no-useless-path-segments')
    },

    fixable: 'code',

    schema: [{
      type: 'object',
      properties: {
        commonjs: { type: 'boolean' },
        noUselessIndex: { type: 'boolean' }
      },
      additionalProperties: false
    }]
  },

  create(context) {
    const currentDir = _path2.default.dirname(context.getFilename());
    const options = context.options[0];

    function checkSourceValue(source) {
      const importPath = source.value;


      function reportWithProposedPath(proposedPath) {
        context.report({
          node: source,
          // Note: Using messageIds is not possible due to the support for ESLint 2 and 3
          message: `Useless path segments for "${importPath}", should be "${proposedPath}"`,
          fix: fixer => proposedPath && fixer.replaceText(source, JSON.stringify(proposedPath))
        });
      }

      // Only relative imports are relevant for this rule --> Skip checking
      if (!importPath.startsWith('.')) {
        return;
      }

      // Report rule violation if path is not the shortest possible
      const resolvedPath = (0, _resolve2.default)(importPath, context);
      const normedPath = normalize(importPath);
      const resolvedNormedPath = (0, _resolve2.default)(normedPath, context);
      if (normedPath !== importPath && resolvedPath === resolvedNormedPath) {
        return reportWithProposedPath(normedPath);
      }

      const fileExtensions = (0, _ignore.getFileExtensions)(context.settings);
      const regexUnnecessaryIndex = new RegExp(`.*\\/index(\\${Array.from(fileExtensions).join('|\\')})?$`);

      // Check if path contains unnecessary index (including a configured extension)
      if (options && options.noUselessIndex && regexUnnecessaryIndex.test(importPath)) {
        const parentDirectory = _path2.default.dirname(importPath);

        // Try to find ambiguous imports
        if (parentDirectory !== '.' && parentDirectory !== '..') {
          for (let fileExtension of fileExtensions) {
            if ((0, _resolve2.default)(`${parentDirectory}${fileExtension}`, context)) {
              return reportWithProposedPath(`${parentDirectory}/`);
            }
          }
        }

        return reportWithProposedPath(parentDirectory);
      }

      // Path is shortest possible + starts from the current directory --> Return directly
      if (importPath.startsWith('./')) {
        return;
      }

      // Path is not existing --> Return directly (following code requires path to be defined)
      if (resolvedPath === undefined) {
        return;
      }

      const expected = _path2.default.relative(currentDir, resolvedPath); // Expected import path
      const expectedSplit = expected.split(_path2.default.sep); // Split by / or \ (depending on OS)
      const importPathSplit = importPath.replace(/^\.\//, '').split('/');
      const countImportPathRelativeParents = countRelativeParents(importPathSplit);
      const countExpectedRelativeParents = countRelativeParents(expectedSplit);
      const diff = countImportPathRelativeParents - countExpectedRelativeParents;

      // Same number of relative parents --> Paths are the same --> Return directly
      if (diff <= 0) {
        return;
      }

      // Report and propose minimal number of required relative parents
      return reportWithProposedPath(toRelativePath(importPathSplit.slice(0, countExpectedRelativeParents).concat(importPathSplit.slice(countImportPathRelativeParents + diff)).join('/')));
    }

    return (0, _moduleVisitor2.default)(checkSourceValue, options);
  }
};
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/no-useless-path-segments.js"],"names":["toRelativePath","relativePath","stripped","replace","test","normalize","fn","path","posix","countRelativeParents","pathSegments","reduce","sum","pathSegment","module","exports","meta","type","docs","url","fixable","schema","properties","commonjs","noUselessIndex","additionalProperties","create","context","currentDir","dirname","getFilename","options","checkSourceValue","source","importPath","value","reportWithProposedPath","proposedPath","report","node","message","fix","fixer","replaceText","JSON","stringify","startsWith","resolvedPath","normedPath","resolvedNormedPath","fileExtensions","settings","regexUnnecessaryIndex","RegExp","Array","from","join","parentDirectory","fileExtension","undefined","expected","relative","expectedSplit","split","sep","importPathSplit","countImportPathRelativeParents","countExpectedRelativeParents","diff","slice","concat"],"mappings":"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","file":"no-useless-path-segments.js","sourcesContent":["/**\n * @fileOverview Ensures that there are no useless path segments\n * @author Thomas Grainger\n */\n\nimport { getFileExtensions } from 'eslint-module-utils/ignore'\nimport moduleVisitor from 'eslint-module-utils/moduleVisitor'\nimport resolve from 'eslint-module-utils/resolve'\nimport path from 'path'\nimport docsUrl from '../docsUrl'\n\n/**\n * convert a potentially relative path from node utils into a true\n * relative path.\n *\n * ../ -> ..\n * ./ -> .\n * .foo/bar -> ./.foo/bar\n * ..foo/bar -> ./..foo/bar\n * foo/bar -> ./foo/bar\n *\n * @param relativePath {string} relative posix path potentially missing leading './'\n * @returns {string} relative posix path that always starts with a ./\n **/\nfunction toRelativePath(relativePath) {\n  const stripped = relativePath.replace(/\\/$/g, '') // Remove trailing /\n\n  return /^((\\.\\.)|(\\.))($|\\/)/.test(stripped) ? stripped : `./${stripped}`\n}\n\nfunction normalize(fn) {\n  return toRelativePath(path.posix.normalize(fn))\n}\n\nfunction countRelativeParents(pathSegments) {\n  return pathSegments.reduce((sum, pathSegment) => pathSegment === '..' ? sum + 1 : sum, 0)\n}\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      url: docsUrl('no-useless-path-segments'),\n    },\n\n    fixable: 'code',\n\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          commonjs: { type: 'boolean' },\n          noUselessIndex: { type: 'boolean' },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create(context) {\n    const currentDir = path.dirname(context.getFilename())\n    const options = context.options[0]\n\n    function checkSourceValue(source) {\n      const { value: importPath } = source\n\n      function reportWithProposedPath(proposedPath) {\n        context.report({\n          node: source,\n          // Note: Using messageIds is not possible due to the support for ESLint 2 and 3\n          message: `Useless path segments for \"${importPath}\", should be \"${proposedPath}\"`,\n          fix: fixer => proposedPath && fixer.replaceText(source, JSON.stringify(proposedPath)),\n        })\n      }\n\n      // Only relative imports are relevant for this rule --> Skip checking\n      if (!importPath.startsWith('.')) {\n        return\n      }\n\n      // Report rule violation if path is not the shortest possible\n      const resolvedPath = resolve(importPath, context)\n      const normedPath = normalize(importPath)\n      const resolvedNormedPath = resolve(normedPath, context)\n      if (normedPath !== importPath && resolvedPath === resolvedNormedPath) {\n        return reportWithProposedPath(normedPath)\n      }\n\n      const fileExtensions = getFileExtensions(context.settings)\n      const regexUnnecessaryIndex = new RegExp(\n        `.*\\\\/index(\\\\${Array.from(fileExtensions).join('|\\\\')})?$`\n      )\n\n      // Check if path contains unnecessary index (including a configured extension)\n      if (options && options.noUselessIndex && regexUnnecessaryIndex.test(importPath)) {\n        const parentDirectory = path.dirname(importPath)\n\n        // Try to find ambiguous imports\n        if (parentDirectory !== '.' && parentDirectory !== '..') {\n          for (let fileExtension of fileExtensions) {\n            if (resolve(`${parentDirectory}${fileExtension}`, context)) {\n              return reportWithProposedPath(`${parentDirectory}/`)\n            }\n          }\n        }\n\n        return reportWithProposedPath(parentDirectory)\n      }\n\n      // Path is shortest possible + starts from the current directory --> Return directly\n      if (importPath.startsWith('./')) {\n        return\n      }\n\n      // Path is not existing --> Return directly (following code requires path to be defined)\n      if (resolvedPath === undefined) {\n        return\n      }\n\n      const expected = path.relative(currentDir, resolvedPath) // Expected import path\n      const expectedSplit = expected.split(path.sep) // Split by / or \\ (depending on OS)\n      const importPathSplit = importPath.replace(/^\\.\\//, '').split('/')\n      const countImportPathRelativeParents = countRelativeParents(importPathSplit)\n      const countExpectedRelativeParents = countRelativeParents(expectedSplit)\n      const diff = countImportPathRelativeParents - countExpectedRelativeParents\n\n      // Same number of relative parents --> Paths are the same --> Return directly\n      if (diff <= 0) {\n        return\n      }\n\n      // Report and propose minimal number of required relative parents\n      return reportWithProposedPath(\n        toRelativePath(\n          importPathSplit\n            .slice(0, countExpectedRelativeParents)\n            .concat(importPathSplit.slice(countImportPathRelativeParents + diff))\n            .join('/')\n        )\n      )\n    }\n\n    return moduleVisitor(checkSourceValue, options)\n  },\n}\n"]}