function depcheck(rootDir, options, callback) {
var getOption = function getOption(key) {
return _lodash2.default.isUndefined(options[key]) ? _constants.defaultOptions[key] : options[key];
};
var withoutDev = getOption('withoutDev');
var ignoreBinPackage = getOption('ignoreBinPackage');
var ignoreMatches = getOption('ignoreMatches');
var ignoreDirs = _lodash2.default.union(_constants.defaultOptions.ignoreDirs, options.ignoreDirs);
var detectors = getOption('detectors');
var parsers = (0, _lodash2.default)(getOption('parsers')).mapValues(function (value) {
return _lodash2.default.isArray(value) ? value : [value];
}).merge({ '*': getOption('specials') }).value();
var metadata = options.package || (0, _utils.readJSON)(_path2.default.join(rootDir, 'package.json'));
var dependencies = metadata.dependencies || {};
var devDependencies = !withoutDev && metadata.devDependencies ? metadata.devDependencies : {};
var peerDeps = Object.keys(metadata.peerDependencies || {});
var optionalDeps = Object.keys(metadata.optionalDependencies || {});
var deps = filterDependencies(rootDir, ignoreBinPackage, ignoreMatches, dependencies);
var devDeps = filterDependencies(rootDir, ignoreBinPackage, ignoreMatches, devDependencies);
return (0, _check2.default)({
rootDir: rootDir,
ignoreDirs: ignoreDirs,
deps: deps,
devDeps: devDeps,
peerDeps: peerDeps,
optionalDeps: optionalDeps,
parsers: parsers,
detectors: detectors
}).then(function (results) {
return _extends(results, {
missing: _lodash2.default.pick(results.missing, filterDependencies(rootDir, ignoreBinPackage, ignoreMatches, results.missing
))
});
}).then(callback);
}n/a
function detectGruntLoadTaskCallExpression(node) {
return node.type === 'CallExpression' && node.callee && node.callee.property && node.callee.property.name === 'loadNpmTasks' &&
node.arguments[0] ? [node.arguments[0].value] : [];
}n/a
function detectImportDeclaration(node) {
return node.type === 'ImportDeclaration' && node.source && node.source.value ? [node.source.value] : [];
}n/a
function detectRequireCallExpression(node) {
return node.type === 'CallExpression' && node.callee && node.callee.type === 'Identifier' && node.callee.name === 'require' &&
node.arguments[0] && _lodash2.default.isString(node.arguments[0].value) ? [node.arguments[0].value] : [];
}n/a
function parseCoffeeScript(content) {
return re.getDependencies(content);
}n/a
function parseES6(content) {
return (0, _babylon.parse)(content, {
sourceType: 'module'
});
}n/a
function parseES7(content) {
return (0, _babylon.parse)(content, {
sourceType: 'module',
// Enable all possible babylon plugins.
// Because we only parse them, not evaluate any code, it is safe to do so.
plugins: ['*']
});
}n/a
function parseJSX(content) {
return (0, _babylon.parse)(content, {
sourceType: 'module',
// Enable all possible babylon plugins.
// Because the guys using React always want the newest syntax.
plugins: ['*', 'jsx']
});
}n/a
function parseSASS(content, filePath, deps, rootDir) {
var _sass$renderSync = sass.renderSync({
data: content,
includePaths: [_path2.default.dirname(filePath)]
}),
stats = _sass$renderSync.stats;
var result = (0, _lodash2.default)(stats.includedFiles).map(function (file) {
return _path2.default.relative(rootDir, file);
}).filter(function (file) {
return file.indexOf('node_modules') === 0;
}) // refer to node_modules
.map(function (file) {
return file.replace(/\\/g, '/');
}) // normalize paths in Windows
.map(function (file) {
return file.substring('node_modules/'.length);
}) // avoid heading slash
.map(_requirePackageName2.default).uniq().value();
return result;
}n/a
function parseTypescript(content, filePath) {
if (!typescript) {
return [];
}
var compileOptions = {
module: typescript.ModuleKind.CommonJS,
target: typescript.ScriptTarget.Latest
};
var result = typescript.transpile(content, compileOptions, filePath);
// TODO avoid parse source file twice, use Typescript native traverser to find out dependencies.
// Reference: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#traversing-the-ast-with-a-little-linter
return (0, _babylon.parse)(result, {
sourceType: 'module'
});
}n/a
function parseBabel(content, filePath, deps) {
var filename = _path2.default.basename(filePath);
if (filename === '.babelrc') {
var options = parse(content);
return checkOptions(deps, options);
}
if (filename === 'package.json') {
var metadata = parse(content);
return checkOptions(deps, metadata.babel);
}
return [];
}n/a
function parseBinary(content, filepath, deps, dir) {
var scripts = (0, _utils.getScripts)(filepath, content);
return deps.filter(function (dep) {
return isBinaryInUse(dep, scripts, dir);
});
}n/a
function parseCommitizen(content, filePath, deps, rootDir) {
var packageJsonPath = _path2.default.resolve(rootDir, 'package.json');
var resolvedFilePath = _path2.default.resolve(filePath);
if (resolvedFilePath === packageJsonPath) {
var metadata = JSON.parse(content);
if (metadata.config && metadata.config.commitizen && metadata.config.commitizen.path) {
var commitizenPath = metadata.config.commitizen.path;
if (!commitizenPath.startsWith('.')) {
return [(0, _requirePackageName2.default)(commitizenPath)];
}
var normalizedPath = _path2.default.normalize(commitizenPath).replace(/\\/g, '/');
if (!normalizedPath.startsWith('node_modules')) {
// The path is not refering to a file in another module
return [];
}
var packagePath = normalizedPath.substring('node_modules/'.length);
return [(0, _requirePackageName2.default)(packagePath)];
}
}
return [];
}n/a
function parseESLint(content, filename, deps, rootDir) {
var basename = _path2.default.basename(filename);
if (/^\.eslintrc(\.json|\.js|\.yml|\.yaml)?$/.test(basename)) {
var config = parse(content);
return checkConfig(config, rootDir);
}
return [];
}n/a
function parseFerossStandard(content, filePath, deps, rootDir) {
var packageJsonPath = _path2.default.resolve(rootDir, 'package.json');
var resolvedFilePath = _path2.default.resolve(filePath);
if (resolvedFilePath === packageJsonPath && deps.indexOf('standard') !== -1) {
var metadata = JSON.parse(content);
var config = metadata.standard || {};
var parser = config.parser;
return parser ? [parser] : [];
}
return [];
}n/a
function parseGulpPlugins(content, filePath, deps, rootDir) {
var resolvedPath = (0, _path.resolve)(filePath);
if (resolvedPath !== (0, _path.resolve)(rootDir, 'gulpfile.js') && resolvedPath !== (0, _path.resolve)(rootDir, 'gulpfile.babel
.js')) {
return [];
}
var pluginLookup = getPluginLookup(deps);
var ast = (0, _es2.default)(content);
var results = [];
(0, _babelTraverse2.default)(ast, {
enter: function enter(path) {
results.push.apply(results, _toConsumableArray(check(content, pluginLookup, path)));
}
});
return (0, _lodash2.default)(results).filter().uniq().value();
}n/a
function parseMocha(content, filepath, deps, rootDir) {
var defaultOptPath = _path2.default.resolve(rootDir, 'test/mocha.opts');
if (filepath === defaultOptPath) {
return getRequires(content, deps);
}
// get mocha.opts from scripts
var requires = (0, _lodash2.default)((0, _utils.getScripts)(filepath, content)).filter(function (script) {
return script.indexOf('mocha') !== -1;
}).map(function (script) {
return getOpts(script);
}).filter(function (opts) {
return opts;
}).map(function (opts) {
return _path2.default.resolve(filepath, '..', opts);
}).map(function (optPath) {
return _fs2.default.readFileSync(optPath, 'utf-8');
}) // TODO async read file
.map(function (optContent) {
return getRequires(optContent, deps);
}).flatten().value();
return requires;
}n/a
function parseWebpack(content, filepath, deps) {
var filename = _path2.default.basename(filepath);
if (webpackConfigRegex.test(filename)) {
var module = require(filepath).module || {}; // eslint-disable-line global-require
var loaders = getLoaders(deps, module.loaders);
var preLoaders = getLoaders(deps, module.preLoaders);
var postLoaders = getLoaders(deps, module.postLoaders);
return loaders.concat(preLoaders).concat(postLoaders);
}
return [];
}n/a