Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2025-12-24 04:09:28 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add /~ as a layer template, adopt it, simplify and align code import rules (#140857)

Browse Source
This commit is contained in:
Alex Dima
2022-01-18 18:26:43 +01:00
parent aa86df2561
commit 62b0d5cb81
12 changed files with 451 additions and 902 deletions
Download Patch File Download Diff File Expand all files Collapse all files

116
build/lib/eslint/code-import-patterns.js
View File

@@ -29,16 +29,8 @@ module.exports = new class {
}
create(context) {
const options = context.options;
const { configs, warnings } = this._processOptions(options);
const configs = this._processOptions(options);
const relativeFilename = getRelativeFilename(context);
if (warnings.length > 0) {
// configuration warnings
context.report({
loc: { line: 1, column: 0 },
message: warnings.join('\n')
});
return {};
}
for (const config of configs) {
if (minimatch(relativeFilename, config.target)) {
return (0, utils_1.createImportRuleListener)((node, value) => this._checkImport(context, config, node, value));
@@ -54,24 +46,104 @@ module.exports = new class {
if (this._optionsCache.has(options)) {
return this._optionsCache.get(options);
}
function orSegment(variants) {
return (variants.length === 1 ? variants[0] : `{${variants.join(',')}}`);
}
const layerRules = [
{ layer: 'common', deps: orSegment(['common']) },
{ layer: 'worker', deps: orSegment(['common', 'worker']) },
{ layer: 'browser', deps: orSegment(['common', 'browser']), isBrowser: true },
{ layer: 'electron-sandbox', deps: orSegment(['common', 'browser', 'electron-sandbox']), isBrowser: true },
{ layer: 'node', deps: orSegment(['common', 'node']), isNode: true },
{ layer: 'electron-browser', deps: orSegment(['common', 'browser', 'node', 'electron-sandbox', 'electron-browser']), isBrowser: true, isNode: true },
{ layer: 'electron-main', deps: orSegment(['common', 'node', 'electron-main']), isNode: true },
];
function findLayer(layer) {
for (const layerRule of layerRules) {
if (layerRule.layer === layer) {
return layerRule;
}
}
return null;
}
function generateConfig(layerRule, target, rawRestrictions) {
const restrictions = [];
const testRestrictions = ['assert', 'sinon', 'sinon-test'];
if (layerRule.isBrowser) {
restrictions.push('vs/css!./**/*');
}
if (layerRule.isNode) {
restrictions.push('@microsoft/*', '@vscode/*', '@parcel/*', '*');
}
for (const rawRestriction of rawRestrictions) {
let importPattern;
let when = undefined;
if (typeof rawRestriction === 'string') {
importPattern = rawRestriction;
}
else {
importPattern = rawRestriction.pattern;
when = rawRestriction.when;
}
if (typeof when === 'undefined'
|| (when === 'hasBrowser' && layerRule.isBrowser)
|| (when === 'hasNode' && layerRule.isNode)) {
restrictions.push(importPattern.replace(/\/\~$/, `/${layerRule.deps}/**`));
testRestrictions.push(importPattern.replace(/\/\~$/, `/test/${layerRule.deps}/**`));
}
else if (when === 'test') {
testRestrictions.push(importPattern.replace(/\/\~$/, `/${layerRule.deps}/**`));
testRestrictions.push(importPattern.replace(/\/\~$/, `/test/${layerRule.deps}/**`));
}
}
testRestrictions.push(...restrictions);
return [
{
target: target.replace(/\/\~$/, `/${layerRule.layer}/**`),
restrictions: restrictions
},
{
target: target.replace(/\/\~$/, `/test/${layerRule.layer}/**`),
restrictions: testRestrictions
}
];
}
const configs = [];
const warnings = [];
for (const option of options) {
const target = option.target;
const restrictions = (typeof option.restrictions === 'string' ? [option.restrictions] : option.restrictions.slice(0));
if (/^src\/vs\/.*\/\*\*/.test(target)) {
const amdTarget = target.substring('src/'.length);
// Allow importing itself
if (restrictions.includes(amdTarget)) {
warnings.push(`target ${target}: '${amdTarget}' is automatically included in restrictions.`);
}
restrictions.push(amdTarget);
const targetIsVS = /^src\/vs\//.test(target);
const restrictions = (typeof option.restrictions === 'string' ? [option.restrictions] : option.restrictions).slice(0);
if (targetIsVS) {
// Always add "vs/nls"
restrictions.push('vs/nls');
}
if (targetIsVS && option.layer) {
// single layer => simple substitution for /~
const layerRule = findLayer(option.layer);
if (layerRule) {
const [config, testConfig] = generateConfig(layerRule, target, restrictions);
if (option.test) {
configs.push(testConfig);
}
else {
configs.push(config);
}
}
}
else if (targetIsVS && /\/\~$/.test(target)) {
// generate all layers
for (const layerRule of layerRules) {
const [config, testConfig] = generateConfig(layerRule, target, restrictions);
configs.push(config);
configs.push(testConfig);
}
}
else {
configs.push({ target, restrictions: restrictions.filter(r => typeof r === 'string') });
}
configs.push({ target, restrictions });
}
const result = { configs, warnings };
this._optionsCache.set(options, result);
return result;
this._optionsCache.set(options, configs);
return configs;
}
_checkImport(context, config, node, importPath) {
// resolve relative paths