ui5plugin-parser
Version:
192 lines (191 loc) • 10.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.MessageState = void 0;
const path_1 = require("path");
const PackageParserConfigHandler_1 = require("../../classes/config/PackageParserConfigHandler");
const AbstractFileReader_1 = require("../../classes/parsing/util/filereader/AbstractFileReader");
const WorkspaceFolder_1 = require("../../classes/parsing/util/textdocument/WorkspaceFolder");
const UI5JSNodeParser_1 = require("../UI5JSNodeParser");
const UI5JSParser_1 = require("../UI5JSParser");
const UI5TSParser_1 = require("../UI5TSParser");
const AbstractUI5Parser_1 = require("../abstraction/AbstractUI5Parser");
const ParserPool_1 = require("../pool/ParserPool");
const path = require("path");
var MessageState;
(function (MessageState) {
MessageState[MessageState["Error"] = 0] = "Error";
MessageState[MessageState["Warning"] = 1] = "Warning";
MessageState[MessageState["Information"] = 2] = "Information";
})(MessageState || (exports.MessageState = MessageState = {}));
class ParserFactory {
static getInitializationMessages() {
return this._initializationMessages;
}
static async createInstances(wsFolders, globalStoragePath = path.join(__dirname, "./node_modules/.cache/ui5plugin"), clearCache = false, globalConfigPath) {
if (globalConfigPath) {
PackageParserConfigHandler_1.PackageParserConfigHandler.setGlobalConfigPath(globalConfigPath);
}
this._initializationMessages = [];
const wsFoldersAndConfigHandlers = this._extractAllWSFoldersAndConfigHandlers(wsFolders);
await this._loadVersionInfo(wsFoldersAndConfigHandlers);
const manifestInfos = wsFoldersAndConfigHandlers.flatMap(({ wsFolder, configHandler, isNodeProject }) => {
const manifestPaths = AbstractFileReader_1.AbstractFileReader.readFilesInWorkspace(wsFolder, "**/manifest.json", isNodeProject ? undefined : configHandler);
return manifestPaths.map(manifestPath => ({
path: manifestPath,
wsFolder: wsFolder,
configHandler: configHandler,
isNodeProject
}));
});
const parsers = manifestInfos.map(manifestInfo => this._createParser(manifestInfo));
if (clearCache) {
parsers.forEach(parser => {
parser.fileReader.clearCache();
});
}
const initializations = parsers.map(parser => parser.initializeLibsAndManifest(globalStoragePath));
await Promise.all(initializations);
parsers.forEach(parser => parser.initializeFragments());
parsers.forEach(parser => parser.fileReader.reloadFragmentReferences());
parsers.forEach(parser => parser.initializeViews());
parsers.forEach(parser => parser.initializeI18n());
parsers.forEach(parser => parser.initializeCustomClasses());
parsers.forEach(parser => parser.fileReader.reEnrichAllCustomClasses());
this._addInitializationMessages(parsers);
return ParserPool_1.default.getAllParsers();
}
static async _loadVersionInfo(wsFoldersAndConfigHandlers) {
const sources = [
...new Set(wsFoldersAndConfigHandlers.map(wsFoldersAndConfigHandler => wsFoldersAndConfigHandler.configHandler.getDataSource()))
];
if (sources.length > 1) {
this._initializationMessages.push({
state: MessageState.Information,
message: `Multiple sources found for UI5 Library metadata preload. "${sources[0]}" is used to fetch UI5 version info.`
});
}
const source = sources[0];
await PackageParserConfigHandler_1.PackageParserConfigHandler.loadVersionInfo(source);
}
static _addInitializationMessages(parsers) {
this._addDuplicateManifestMessages(parsers);
parsers.forEach(parser => {
this._addManifestQuantityMessages(parser);
});
}
static _addManifestQuantityMessages(parser) {
const manifests = parser.fileReader.getAllManifests();
if (manifests.length > 1) {
this._initializationMessages.push({
state: MessageState.Warning,
message: `Project in workspace "${parser.workspaceFolder.fsPath}" has ${manifests.length} manifests. Nested manifest projects are not supported and might work inconsistently.`
});
}
else if (manifests.length === 0) {
this._initializationMessages.push({
state: MessageState.Warning,
message: `No manifests found for project in "${parser.workspaceFolder.fsPath}" workspace.`
});
ParserPool_1.default.deregister(parser);
}
}
static _addDuplicateManifestMessages(parsers) {
const manifests = parsers.flatMap(parser => parser.fileReader.getAllManifests());
const checkedManifests = [];
manifests.forEach(currentManifest => {
const manifestAlreadyChecked = checkedManifests.includes(currentManifest.componentName);
if (manifestAlreadyChecked) {
return;
}
const sameManifests = manifests.filter(manifest => manifest.componentName === currentManifest.componentName);
const manifestAlreadyExists = sameManifests.length > 1;
if (manifestAlreadyExists) {
const manifestPaths = sameManifests.map(sameManifest => sameManifest.fsPath).join(",\n");
this._initializationMessages.push({
state: MessageState.Error,
message: `Multiple manifests with same app id found: "${currentManifest.componentName}", paths: \n${manifestPaths}`
});
}
checkedManifests.push(currentManifest.componentName);
});
}
static _extractAllWSFoldersAndConfigHandlers(wsFolders) {
if (wsFolders.length === 0) {
return [];
}
const wsFoldersAndConfigHandlers = wsFolders.map(wsFolder => {
return {
wsFolder: wsFolder,
configHandler: this._getConfigHandlerForWorkspaceFolder(wsFolder),
isNodeProject: false
};
});
const proxyWorkspaces = wsFoldersAndConfigHandlers.filter(({ configHandler }) => {
return !!configHandler.getProxyWorkspaces();
});
const nonProxyWorkspaces = wsFoldersAndConfigHandlers.filter(workspace => !proxyWorkspaces.includes(workspace));
const additionalWorkspaces = nonProxyWorkspaces.flatMap(({ configHandler, wsFolder }) => {
const proxyWorkspaces = configHandler.getProxyWorkspaces();
if (proxyWorkspaces) {
return [];
}
const additionalWorkspacePaths = configHandler.getAdditionalWorkspaces();
const nodeProjects = configHandler.getNodeProjects();
return additionalWorkspacePaths
.map(additionalWorkspacePath => {
const isPathAbsolute = path.isAbsolute(additionalWorkspacePath);
const workspaceFsPath = isPathAbsolute
? additionalWorkspacePath
: path.join(wsFolder.fsPath, additionalWorkspacePath);
return this._createWorkspaceFolderAndConfigHandler(workspaceFsPath);
})
.concat(nodeProjects.map(nodeProject => {
return this._createWorkspaceFolderAndConfigHandler(path.join(wsFolder.fsPath, "/node_modules", `/${nodeProject}`), true, path.join(wsFolder.fsPath, "/package.json"));
}));
});
nonProxyWorkspaces.push(...additionalWorkspaces);
const proxyWorkspaceFolders = proxyWorkspaces.flatMap(({ wsFolder, configHandler }) => {
const proxyWorkspacePaths = configHandler.getProxyWorkspaces() ?? [];
return proxyWorkspacePaths.map(proxyWorkspacePath => {
const resolvedProxyWorkspacePath = path.join(wsFolder.fsPath, proxyWorkspacePath);
return new WorkspaceFolder_1.WorkspaceFolder(resolvedProxyWorkspacePath);
});
});
const resolvedProxyWorkspaces = this._extractAllWSFoldersAndConfigHandlers(proxyWorkspaceFolders);
const allWorkspaces = nonProxyWorkspaces.concat(resolvedProxyWorkspaces);
const uniqueWorkspaces = allWorkspaces.reduce((uniqueWorkspaces, workspace) => {
const workspaceExists = uniqueWorkspaces.some(nonUniqueWorkspace => nonUniqueWorkspace.wsFolder.fsPath === workspace.wsFolder.fsPath);
if (!workspaceExists) {
uniqueWorkspaces.push(workspace);
}
return uniqueWorkspaces;
}, []);
return uniqueWorkspaces;
}
static _createWorkspaceFolderAndConfigHandler(workspaceFolderPath, isNodeProject = false, configPath) {
return {
wsFolder: new WorkspaceFolder_1.WorkspaceFolder(workspaceFolderPath),
configHandler: new PackageParserConfigHandler_1.PackageParserConfigHandler(configPath ?? path.join(workspaceFolderPath, "/package.json")),
isNodeProject
};
}
static _getConfigHandlerForWorkspaceFolder(wsFolder) {
return new PackageParserConfigHandler_1.PackageParserConfigHandler(path.join(wsFolder.fsPath, "/package.json"));
}
static _createParser(manifestInfo) {
const isTypescriptProject = AbstractUI5Parser_1.AbstractUI5Parser.getIsTypescriptProject(manifestInfo.wsFolder, manifestInfo.configHandler);
const packagePath = (0, path_1.join)(manifestInfo.wsFolder.fsPath, "/package.json");
const manifestFolderPath = (0, path_1.dirname)(manifestInfo.path);
if (manifestInfo.isNodeProject) {
return new UI5JSNodeParser_1.UI5JSNodeParser({ workspaceFolder: new WorkspaceFolder_1.WorkspaceFolder(manifestFolderPath), configHandler: manifestInfo.configHandler }, packagePath);
}
else if (isTypescriptProject) {
return new UI5TSParser_1.UI5TSParser({ workspaceFolder: new WorkspaceFolder_1.WorkspaceFolder(manifestFolderPath), configHandler: manifestInfo.configHandler }, packagePath);
}
else {
return new UI5JSParser_1.UI5JSParser({ workspaceFolder: new WorkspaceFolder_1.WorkspaceFolder(manifestFolderPath), configHandler: manifestInfo.configHandler }, packagePath);
}
}
}
ParserFactory._initializationMessages = [];
exports.default = ParserFactory;