In order to make the license that applies to each file as clear as possible, and to be consistent with elasticsearch, we are adding Apache 2.0 license headers to the top of each file. Existence of this header is enforced by eslint and tslint and missing headers were automatically added in the last commit by running: ``` node scripts/eslint --fix && node scripts/tslint --fix ```
132 lines
4.2 KiB
JavaScript
Executable file
132 lines
4.2 KiB
JavaScript
Executable file
/*
|
|
* Licensed to Elasticsearch B.V. under one or more contributor
|
|
* license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright
|
|
* ownership. Elasticsearch B.V. licenses this file to you under
|
|
* the Apache License, Version 2.0 (the "License"); you may
|
|
* not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing,
|
|
* software distributed under the License is distributed on an
|
|
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
* KIND, either express or implied. See the License for the
|
|
* specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
|
|
const { join, dirname, extname } = require('path');
|
|
|
|
const webpackResolver = require('eslint-import-resolver-webpack');
|
|
const nodeResolver = require('eslint-import-resolver-node');
|
|
|
|
const {
|
|
getKibanaPath,
|
|
getProjectRoot,
|
|
getWebpackConfig,
|
|
isFile,
|
|
isProbablyWebpackShim,
|
|
getIsPathRequest,
|
|
resolveWebpackAlias,
|
|
} = require('./lib');
|
|
|
|
// cache context, it shouldn't change
|
|
let context;
|
|
function initContext(file, config) {
|
|
if (context) {
|
|
return context;
|
|
}
|
|
|
|
const projectRoot = getProjectRoot(file, config);
|
|
const kibanaPath = getKibanaPath(config, projectRoot);
|
|
const webpackConfig = getWebpackConfig(kibanaPath, projectRoot, config);
|
|
const aliasEntries = Object.entries(webpackConfig.resolve.alias || {});
|
|
|
|
context = {
|
|
webpackConfig,
|
|
aliasEntries,
|
|
};
|
|
|
|
return context;
|
|
}
|
|
|
|
function tryNodeResolver(importRequest, file, config) {
|
|
return nodeResolver.resolve(
|
|
importRequest,
|
|
file,
|
|
// we use Object.assign so that this file is compatible with slightly older
|
|
// versions of node.js used by IDEs (eg. resolvers are run in the Electron
|
|
// process in Atom)
|
|
Object.assign({}, config, {
|
|
extensions: ['.js', '.json', '.ts', '.tsx'],
|
|
isFile,
|
|
})
|
|
);
|
|
}
|
|
|
|
exports.resolve = function resolveKibanaPath(importRequest, file, config) {
|
|
config = config || {};
|
|
|
|
if (config.forceNode) {
|
|
return tryNodeResolver(importRequest, file, config);
|
|
}
|
|
|
|
// these modules are simulated by webpack, so there is no
|
|
// path to resolve to and no reason to do any more work
|
|
if (importRequest.startsWith('uiExports/')) {
|
|
return {
|
|
found: true,
|
|
path: null,
|
|
};
|
|
}
|
|
|
|
const { webpackConfig, aliasEntries } = initContext(file, config);
|
|
let isPathRequest = getIsPathRequest(importRequest);
|
|
|
|
// if the importRequest is not a path we might be able to map it to a path
|
|
// by comparing it to the webpack aliases. If we can convert it to a path
|
|
// without actually invoking the webpack resolver we can save a lot of time
|
|
if (!isPathRequest) {
|
|
const resolvedAlias = resolveWebpackAlias(importRequest, aliasEntries);
|
|
if (resolvedAlias) {
|
|
importRequest = resolvedAlias;
|
|
isPathRequest = true;
|
|
}
|
|
}
|
|
|
|
// if the importRequest is a path, and it has a file extension, then
|
|
// we just resolve it. This is most helpful with relative imports for
|
|
// .css and .html files because those don't work with the node resolver
|
|
// and we can resolve them much quicker than webpack
|
|
if (isPathRequest && extname(importRequest)) {
|
|
const abs = join(dirname(file), importRequest);
|
|
if (isFile(abs)) {
|
|
return {
|
|
found: true,
|
|
path: abs,
|
|
};
|
|
}
|
|
}
|
|
|
|
// only use the node resolver if the importRequest is a path, or is
|
|
// a module request but not one that's probably a webpackShim. This
|
|
// prevents false positives as webpackShims are likely to be resolved
|
|
// to the node_modules directory by the node resolver, but we want
|
|
// them to resolve to the actual shim
|
|
if (isPathRequest || !isProbablyWebpackShim(importRequest, file)) {
|
|
const nodeResult = tryNodeResolver(importRequest, file, config);
|
|
if (nodeResult && nodeResult.found) {
|
|
return nodeResult;
|
|
}
|
|
}
|
|
|
|
return webpackResolver.resolve(importRequest, file, {
|
|
config: webpackConfig,
|
|
});
|
|
};
|
|
|
|
// use version 2 of the resolver interface, https://github.com/benmosher/eslint-plugin-import/blob/master/resolvers/README.md#interfaceversion--number
|
|
exports.interfaceVersion = 2;
|