@yolkai/nx-workspace
Version:
147 lines (146 loc) • 6.16 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const project_graph_1 = require("../core/project-graph");
const core_1 = require("@angular-devkit/core");
const file_utils_1 = require("../core/file-utils");
function hasNoneOfTheseTags(proj, tags) {
return tags.filter(allowedTag => hasTag(proj, allowedTag)).length === 0;
}
exports.hasNoneOfTheseTags = hasNoneOfTheseTags;
function hasTag(proj, tag) {
return (proj.data.tags || []).indexOf(tag) > -1 || tag === '*';
}
function containsFile(files, targetFileWithoutExtension) {
return !!files.filter(f => removeExt(f.file) === targetFileWithoutExtension)[0];
}
function removeExt(file) {
return file.replace(/\.[^/.]+$/, '');
}
function removeWindowsDriveLetter(osSpecificPath) {
return osSpecificPath.replace(/^[A-Z]:/, '');
}
function normalizePath(osSpecificPath) {
return removeWindowsDriveLetter(osSpecificPath)
.split(path.sep)
.join('/');
}
function matchImportWithWildcard(
// This may or may not contain wildcards ("*")
allowableImport, extractedImport) {
if (allowableImport.endsWith('/**')) {
const prefix = allowableImport.substring(0, allowableImport.length - 2);
return extractedImport.startsWith(prefix);
}
else if (allowableImport.endsWith('/*')) {
const prefix = allowableImport.substring(0, allowableImport.length - 1);
if (!extractedImport.startsWith(prefix))
return false;
return extractedImport.substring(prefix.length).indexOf('/') === -1;
}
else if (allowableImport.indexOf('/**/') > -1) {
const [prefix, suffix] = allowableImport.split('/**/');
return (extractedImport.startsWith(prefix) && extractedImport.endsWith(suffix));
}
else {
return new RegExp(allowableImport).test(extractedImport);
}
}
exports.matchImportWithWildcard = matchImportWithWildcard;
function isRelative(s) {
return s.startsWith('.');
}
exports.isRelative = isRelative;
function isRelativeImportIntoAnotherProject(imp, projectPath, projectGraph, sourceFilePath) {
if (!isRelative(imp))
return false;
const targetFile = normalizePath(path.resolve(path.join(projectPath, path.dirname(sourceFilePath)), imp)).substring(projectPath.length + 1);
const sourceProject = findSourceProject(projectGraph, sourceFilePath);
const targetProject = findTargetProject(projectGraph, targetFile);
return sourceProject && targetProject && sourceProject !== targetProject;
}
exports.isRelativeImportIntoAnotherProject = isRelativeImportIntoAnotherProject;
function findProjectUsingFile(projectGraph, file) {
return Object.values(projectGraph.nodes).filter(n => containsFile(n.data.files, file))[0];
}
exports.findProjectUsingFile = findProjectUsingFile;
function findSourceProject(projectGraph, sourceFilePath) {
const targetFile = removeExt(sourceFilePath);
return findProjectUsingFile(projectGraph, targetFile);
}
exports.findSourceProject = findSourceProject;
function findTargetProject(projectGraph, targetFile) {
let targetProject = findProjectUsingFile(projectGraph, targetFile);
if (!targetProject) {
targetProject = findProjectUsingFile(projectGraph, normalizePath(path.join(targetFile, 'index')));
}
if (!targetProject) {
targetProject = findProjectUsingFile(projectGraph, normalizePath(path.join(targetFile, 'src', 'index')));
}
return targetProject;
}
exports.findTargetProject = findTargetProject;
function isAbsoluteImportIntoAnotherProject(imp) {
return (imp.startsWith('libs/') ||
imp.startsWith('/libs/') ||
imp.startsWith('apps/') ||
imp.startsWith('/apps/'));
}
exports.isAbsoluteImportIntoAnotherProject = isAbsoluteImportIntoAnotherProject;
function findProjectUsingImport(projectGraph, npmScope, imp) {
const unscopedImport = imp.substring(npmScope.length + 2);
let bestMatchedRoot = '';
let bestMatch = undefined;
Object.values(projectGraph.nodes).forEach(n => {
const normalizedRoot = file_utils_1.normalizedProjectRoot(n);
if (unscopedImport === normalizedRoot ||
unscopedImport.startsWith(`${normalizedRoot}/`)) {
if (normalizedRoot.length > bestMatchedRoot.length) {
bestMatchedRoot = normalizedRoot;
bestMatch = n;
}
}
});
return bestMatch;
}
exports.findProjectUsingImport = findProjectUsingImport;
function isCircular(graph, sourceProject, targetProject) {
if (!graph.nodes[targetProject.name])
return false;
return isDependingOn(graph, targetProject.name, sourceProject.name);
}
exports.isCircular = isCircular;
function isDependingOn(graph, sourceProjectName, targetProjectName, done = {}) {
if (done[sourceProjectName])
return false;
if (!graph.dependencies[sourceProjectName])
return false;
return graph.dependencies[sourceProjectName]
.map(dep => dep.target === targetProjectName
? true
: isDependingOn(graph, dep.target, targetProjectName, Object.assign({}, done, { [`${sourceProjectName}`]: true })))
.some(result => result);
}
function findConstraintsFor(depConstraints, sourceProject) {
return depConstraints.filter(f => hasTag(sourceProject, f.sourceTag));
}
exports.findConstraintsFor = findConstraintsFor;
function onlyLoadChildren(graph, sourceProjectName, targetProjectName, visited) {
if (visited.indexOf(sourceProjectName) > -1)
return false;
return ((graph.dependencies[sourceProjectName] || []).filter(d => {
if (d.type !== project_graph_1.DependencyType.dynamic)
return false;
if (d.target === targetProjectName)
return true;
return onlyLoadChildren(graph, d.target, targetProjectName, [
...visited,
sourceProjectName
]);
}).length > 0);
}
exports.onlyLoadChildren = onlyLoadChildren;
function getSourceFilePath(sourceFileName, projectPath) {
return core_1.normalize(sourceFileName).substring(projectPath.length + 1);
}
exports.getSourceFilePath = getSourceFilePath;