Update ESLint-related packages
R=jacktfranklin@chromium.org
No-Presubmit: True
Bug: none
Change-Id: I52dc24b12e350787085c5e3d131cface7ea87142
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/3060705
Commit-Queue: Tim van der Lippe <tvanderlippe@chromium.org>
Reviewed-by: Paul Lewis <aerotwist@chromium.org>
diff --git a/node_modules/eslint-module-utils/resolve.js b/node_modules/eslint-module-utils/resolve.js
index 3138194..ea5bf5a 100644
--- a/node_modules/eslint-module-utils/resolve.js
+++ b/node_modules/eslint-module-utils/resolve.js
@@ -1,211 +1,211 @@
-'use strict'
-exports.__esModule = true
+'use strict';
+exports.__esModule = true;
-const pkgDir = require('pkg-dir')
+const pkgDir = require('pkg-dir');
-const fs = require('fs')
-const Module = require('module')
-const path = require('path')
+const fs = require('fs');
+const Module = require('module');
+const path = require('path');
-const hashObject = require('./hash').hashObject
- , ModuleCache = require('./ModuleCache').default
+const hashObject = require('./hash').hashObject;
+const ModuleCache = require('./ModuleCache').default;
-const CASE_SENSITIVE_FS = !fs.existsSync(path.join(__dirname, 'reSOLVE.js'))
-exports.CASE_SENSITIVE_FS = CASE_SENSITIVE_FS
+const CASE_SENSITIVE_FS = !fs.existsSync(path.join(__dirname.toUpperCase(), 'reSOLVE.js'));
+exports.CASE_SENSITIVE_FS = CASE_SENSITIVE_FS;
-const ERROR_NAME = 'EslintPluginImportResolveError'
+const ERROR_NAME = 'EslintPluginImportResolveError';
-const fileExistsCache = new ModuleCache()
+const fileExistsCache = new ModuleCache();
// Polyfill Node's `Module.createRequireFromPath` if not present (added in Node v10.12.0)
// Use `Module.createRequire` if available (added in Node v12.2.0)
const createRequire = Module.createRequire || Module.createRequireFromPath || function (filename) {
- const mod = new Module(filename, null)
- mod.filename = filename
- mod.paths = Module._nodeModulePaths(path.dirname(filename))
+ const mod = new Module(filename, null);
+ mod.filename = filename;
+ mod.paths = Module._nodeModulePaths(path.dirname(filename));
- mod._compile(`module.exports = require;`, filename)
+ mod._compile(`module.exports = require;`, filename);
- return mod.exports
-}
+ return mod.exports;
+};
function tryRequire(target, sourceFile) {
- let resolved
+ let resolved;
try {
// Check if the target exists
if (sourceFile != null) {
try {
- resolved = createRequire(path.resolve(sourceFile)).resolve(target)
+ resolved = createRequire(path.resolve(sourceFile)).resolve(target);
} catch (e) {
- resolved = require.resolve(target)
+ resolved = require.resolve(target);
}
} else {
- resolved = require.resolve(target)
+ resolved = require.resolve(target);
}
} catch(e) {
// If the target does not exist then just return undefined
- return undefined
+ return undefined;
}
// If the target exists then return the loaded module
- return require(resolved)
+ return require(resolved);
}
// http://stackoverflow.com/a/27382838
exports.fileExistsWithCaseSync = function fileExistsWithCaseSync(filepath, cacheSettings) {
// don't care if the FS is case-sensitive
- if (CASE_SENSITIVE_FS) return true
+ if (CASE_SENSITIVE_FS) return true;
// null means it resolved to a builtin
- if (filepath === null) return true
- if (filepath.toLowerCase() === process.cwd().toLowerCase()) return true
- const parsedPath = path.parse(filepath)
- , dir = parsedPath.dir
+ if (filepath === null) return true;
+ if (filepath.toLowerCase() === process.cwd().toLowerCase()) return true;
+ const parsedPath = path.parse(filepath);
+ const dir = parsedPath.dir;
- let result = fileExistsCache.get(filepath, cacheSettings)
- if (result != null) return result
+ let result = fileExistsCache.get(filepath, cacheSettings);
+ if (result != null) return result;
// base case
if (dir === '' || parsedPath.root === filepath) {
- result = true
+ result = true;
} else {
- const filenames = fs.readdirSync(dir)
+ const filenames = fs.readdirSync(dir);
if (filenames.indexOf(parsedPath.base) === -1) {
- result = false
+ result = false;
} else {
- result = fileExistsWithCaseSync(dir, cacheSettings)
+ result = fileExistsWithCaseSync(dir, cacheSettings);
}
}
- fileExistsCache.set(filepath, result)
- return result
-}
+ fileExistsCache.set(filepath, result);
+ return result;
+};
function relative(modulePath, sourceFile, settings) {
- return fullResolve(modulePath, sourceFile, settings).path
+ return fullResolve(modulePath, sourceFile, settings).path;
}
function fullResolve(modulePath, sourceFile, settings) {
// check if this is a bonus core module
- const coreSet = new Set(settings['import/core-modules'])
- if (coreSet.has(modulePath)) return { found: true, path: null }
+ const coreSet = new Set(settings['import/core-modules']);
+ if (coreSet.has(modulePath)) return { found: true, path: null };
- const sourceDir = path.dirname(sourceFile)
- , cacheKey = sourceDir + hashObject(settings).digest('hex') + modulePath
+ const sourceDir = path.dirname(sourceFile);
+ const cacheKey = sourceDir + hashObject(settings).digest('hex') + modulePath;
- const cacheSettings = ModuleCache.getSettings(settings)
+ const cacheSettings = ModuleCache.getSettings(settings);
- const cachedPath = fileExistsCache.get(cacheKey, cacheSettings)
- if (cachedPath !== undefined) return { found: true, path: cachedPath }
+ const cachedPath = fileExistsCache.get(cacheKey, cacheSettings);
+ if (cachedPath !== undefined) return { found: true, path: cachedPath };
function cache(resolvedPath) {
- fileExistsCache.set(cacheKey, resolvedPath)
+ fileExistsCache.set(cacheKey, resolvedPath);
}
function withResolver(resolver, config) {
function v1() {
try {
- const resolved = resolver.resolveImport(modulePath, sourceFile, config)
- if (resolved === undefined) return { found: false }
- return { found: true, path: resolved }
+ const resolved = resolver.resolveImport(modulePath, sourceFile, config);
+ if (resolved === undefined) return { found: false };
+ return { found: true, path: resolved };
} catch (err) {
- return { found: false }
+ return { found: false };
}
}
function v2() {
- return resolver.resolve(modulePath, sourceFile, config)
+ return resolver.resolve(modulePath, sourceFile, config);
}
switch (resolver.interfaceVersion) {
- case 2:
- return v2()
+ case 2:
+ return v2();
- default:
- case 1:
- return v1()
+ default:
+ case 1:
+ return v1();
}
}
const configResolvers = (settings['import/resolver']
- || { 'node': settings['import/resolve'] }) // backward compatibility
+ || { 'node': settings['import/resolve'] }); // backward compatibility
- const resolvers = resolverReducer(configResolvers, new Map())
+ const resolvers = resolverReducer(configResolvers, new Map());
- for (let pair of resolvers) {
- let name = pair[0]
- , config = pair[1]
- const resolver = requireResolver(name, sourceFile)
- , resolved = withResolver(resolver, config)
+ for (const pair of resolvers) {
+ const name = pair[0];
+ const config = pair[1];
+ const resolver = requireResolver(name, sourceFile);
+ const resolved = withResolver(resolver, config);
- if (!resolved.found) continue
+ if (!resolved.found) continue;
// else, counts
- cache(resolved.path)
- return resolved
+ cache(resolved.path);
+ return resolved;
}
// failed
// cache(undefined)
- return { found: false }
+ return { found: false };
}
-exports.relative = relative
+exports.relative = relative;
function resolverReducer(resolvers, map) {
- if (resolvers instanceof Array) {
- resolvers.forEach(r => resolverReducer(r, map))
- return map
+ if (Array.isArray(resolvers)) {
+ resolvers.forEach(r => resolverReducer(r, map));
+ return map;
}
if (typeof resolvers === 'string') {
- map.set(resolvers, null)
- return map
+ map.set(resolvers, null);
+ return map;
}
if (typeof resolvers === 'object') {
- for (let key in resolvers) {
- map.set(key, resolvers[key])
+ for (const key in resolvers) {
+ map.set(key, resolvers[key]);
}
- return map
+ return map;
}
- const err = new Error('invalid resolver config')
- err.name = ERROR_NAME
- throw err
+ const err = new Error('invalid resolver config');
+ err.name = ERROR_NAME;
+ throw err;
}
function getBaseDir(sourceFile) {
- return pkgDir.sync(sourceFile) || process.cwd()
+ return pkgDir.sync(sourceFile) || process.cwd();
}
function requireResolver(name, sourceFile) {
// Try to resolve package with conventional name
- let resolver = tryRequire(`eslint-import-resolver-${name}`, sourceFile) ||
+ const resolver = tryRequire(`eslint-import-resolver-${name}`, sourceFile) ||
tryRequire(name, sourceFile) ||
- tryRequire(path.resolve(getBaseDir(sourceFile), name))
+ tryRequire(path.resolve(getBaseDir(sourceFile), name));
if (!resolver) {
- const err = new Error(`unable to load resolver "${name}".`)
- err.name = ERROR_NAME
- throw err
+ const err = new Error(`unable to load resolver "${name}".`);
+ err.name = ERROR_NAME;
+ throw err;
}
if (!isResolverValid(resolver)) {
- const err = new Error(`${name} with invalid interface loaded as resolver`)
- err.name = ERROR_NAME
- throw err
+ const err = new Error(`${name} with invalid interface loaded as resolver`);
+ err.name = ERROR_NAME;
+ throw err;
}
- return resolver
+ return resolver;
}
function isResolverValid(resolver) {
if (resolver.interfaceVersion === 2) {
- return resolver.resolve && typeof resolver.resolve === 'function'
+ return resolver.resolve && typeof resolver.resolve === 'function';
} else {
- return resolver.resolveImport && typeof resolver.resolveImport === 'function'
+ return resolver.resolveImport && typeof resolver.resolveImport === 'function';
}
}
-const erroredContexts = new Set()
+const erroredContexts = new Set();
/**
* Given
@@ -218,24 +218,24 @@
function resolve(p, context) {
try {
return relative( p
- , context.getFilename()
- , context.settings
- )
+ , context.getFilename()
+ , context.settings
+ );
} catch (err) {
if (!erroredContexts.has(context)) {
// The `err.stack` string starts with `err.name` followed by colon and `err.message`.
// We're filtering out the default `err.name` because it adds little value to the message.
- let errMessage = err.message
+ let errMessage = err.message;
if (err.name !== ERROR_NAME && err.stack) {
- errMessage = err.stack.replace(/^Error: /, '')
+ errMessage = err.stack.replace(/^Error: /, '');
}
context.report({
message: `Resolve error: ${errMessage}`,
loc: { line: 1, column: 0 },
- })
- erroredContexts.add(context)
+ });
+ erroredContexts.add(context);
}
}
}
-resolve.relative = relative
-exports.default = resolve
+resolve.relative = relative;
+exports.default = resolve;