@theia/core
Version:
Theia is a cloud & desktop IDE framework implemented in TypeScript.
300 lines • 12.3 kB
JavaScript
// *****************************************************************************
// Copyright (C) 2017 TypeFox and others.
//
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License v. 2.0 which is available at
// http://www.eclipse.org/legal/epl-2.0.
//
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License v. 2.0 are satisfied: GNU General Public License, version 2
// with the GNU Classpath Exception which is available at
// https://www.gnu.org/software/classpath/license.html.
//
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
// *****************************************************************************
import { __decorate } from "tslib";
import { inject, injectable, named, postConstruct } from 'inversify';
// The default import returns the exported FileIcons instance itself; a namespace import would be an interop copy of its own
// properties only, and getClass/getClassWithColor live on the prototype.
import fileIcons from 'file-icons-js';
import URI from '../common/uri.js';
import { ContributionProvider } from '../common/contribution-provider.js';
import { Emitter, Disposable, isObject, Path, Prioritizeable } from '../common/index.js';
import { EnvVariablesServer } from '../common/env-variables/env-variables-protocol.js';
import { codicon } from './widgets/index.js';
/**
* @internal don't export it, use `LabelProvider.folderIcon` instead.
*/
const DEFAULT_FOLDER_ICON = `${codicon('folder')} default-folder-icon`;
/**
* @internal don't export it, use `LabelProvider.fileIcon` instead.
*/
const DEFAULT_FILE_ICON = `${codicon('file')} default-file-icon`;
export const LabelProviderContribution = Symbol('LabelProviderContribution');
export var URIIconReference;
(function (URIIconReference) {
function is(element) {
return isObject(element) && element.kind === 'uriIconReference';
}
URIIconReference.is = is;
function create(id, uri) {
return { kind: 'uriIconReference', id, uri };
}
URIIconReference.create = create;
})(URIIconReference || (URIIconReference = {}));
let DefaultUriLabelProviderContribution = class DefaultUriLabelProviderContribution {
constructor() {
this.formatters = [];
this.onDidChangeEmitter = new Emitter();
// copied and modified from https://github.com/microsoft/vscode/blob/1.44.2/src/vs/workbench/services/label/common/labelService.ts
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
this.labelMatchingRegexp = /\${(scheme|authority|path|query)}/g;
}
init() {
this.envVariablesServer.getHomeDirUri().then(result => {
this.homePath = result;
this.fireOnDidChange();
});
}
canHandle(element) {
if (element instanceof URI || URIIconReference.is(element)) {
return 1;
}
return 0;
}
getIcon(element) {
if (URIIconReference.is(element) && element.id === 'folder') {
return this.defaultFolderIcon;
}
const uri = URIIconReference.is(element) ? element.uri : element;
if (uri) {
const iconClass = uri && this.getFileIcon(uri);
return iconClass || this.defaultFileIcon;
}
return '';
}
get defaultFolderIcon() {
return DEFAULT_FOLDER_ICON;
}
get defaultFileIcon() {
return DEFAULT_FILE_ICON;
}
getFileIcon(uri) {
const fileIcon = fileIcons.getClassWithColor(uri.displayName);
if (!fileIcon) {
return undefined;
}
return fileIcon + ' theia-file-icons-js';
}
getName(element) {
const uri = this.getUri(element);
return uri && uri.displayName;
}
getLongName(element) {
const uri = this.getUri(element);
if (uri) {
const formatting = this.findFormatting(uri);
if (formatting) {
return this.formatUri(uri, formatting);
}
}
return uri && uri.path.fsPath();
}
getDetails(element) {
const uri = this.getUri(element);
if (uri) {
return this.getLongName(uri.parent);
}
return this.getLongName(element);
}
getUri(element) {
return URIIconReference.is(element) ? element.uri : element;
}
registerFormatter(formatter) {
this.formatters.push(formatter);
this.fireOnDidChange();
return Disposable.create(() => {
this.formatters = this.formatters.filter(f => f !== formatter);
this.fireOnDidChange();
});
}
get onDidChange() {
return this.onDidChangeEmitter.event;
}
fireOnDidChange() {
this.onDidChangeEmitter.fire({
affects: (element) => this.canHandle(element) > 0
});
}
formatUri(resource, formatting) {
let label = formatting.label.replace(this.labelMatchingRegexp, (match, token) => {
switch (token) {
case 'scheme': return resource.scheme;
case 'authority': return resource.authority;
case 'path': return resource.path.toString();
case 'query': return resource.query;
default: return '';
}
});
// convert \c:\something => C:\something
if (formatting.normalizeDriveLetter && this.hasDriveLetter(label)) {
label = label.charAt(1).toUpperCase() + label.substring(2);
}
if (formatting.tildify) {
label = Path.tildify(label, this.homePath ? this.homePath : '');
}
if (formatting.authorityPrefix && resource.authority) {
label = formatting.authorityPrefix + label;
}
return label.replace(/\//g, formatting.separator);
}
hasDriveLetter(path) {
return !!(path && path[2] === ':');
}
findFormatting(resource) {
let bestResult;
this.formatters.forEach(formatter => {
if (formatter.scheme === resource.scheme) {
if (!bestResult && !formatter.authority) {
bestResult = formatter;
return;
}
if (!formatter.authority) {
return;
}
if ((formatter.authority.toLowerCase() === resource.authority.toLowerCase()) &&
(!bestResult || !bestResult.authority || formatter.authority.length > bestResult.authority.length ||
((formatter.authority.length === bestResult.authority.length) && formatter.priority))) {
bestResult = formatter;
}
}
});
return bestResult ? bestResult.formatting : undefined;
}
};
__decorate([
inject(EnvVariablesServer)
], DefaultUriLabelProviderContribution.prototype, "envVariablesServer", void 0);
__decorate([
postConstruct()
], DefaultUriLabelProviderContribution.prototype, "init", null);
DefaultUriLabelProviderContribution = __decorate([
injectable()
], DefaultUriLabelProviderContribution);
export { DefaultUriLabelProviderContribution };
/**
* The {@link LabelProvider} determines how elements/nodes are displayed in the workbench. For any element, it can determine a short label, a long label
* and an icon. The {@link LabelProvider} is to be used in lists, trees and tables, but also view specific locations like headers.
* The common {@link LabelProvider} can be extended/adapted via {@link LabelProviderContribution}s. For every element, the {@links LabelProvider} will determine the
* {@link LabelProviderContribution} with the hightest priority and delegate to it. Theia registers default {@link LabelProviderContribution} for common types, e.g.
* the {@link DefaultUriLabelProviderContribution} for elements that have a URI.
* Using the {@link LabelProvider} across the workbench ensures a common look and feel for elements across multiple views. To adapt the way how specific
* elements/nodes are rendered, use a {@link LabelProviderContribution} rather than adapting or sub classing the {@link LabelProvider}. This way, your adaptation
* is applied to all views in Theia that use the {@link LabelProvider}
*/
let LabelProvider = class LabelProvider {
constructor() {
this.onDidChangeEmitter = new Emitter();
}
/**
* Start listening to contributions.
*
* Don't call this method directly!
* It's called by the frontend application during initialization.
*/
initialize() {
const contributions = this.contributionProvider.getContributions();
for (const eventContribution of contributions) {
if (eventContribution.onDidChange) {
eventContribution.onDidChange(event => {
this.onDidChangeEmitter.fire({
// TODO check eventContribution.canHandle as well
affects: element => this.affects(element, event)
});
});
}
}
}
affects(element, event) {
if (event.affects(element)) {
return true;
}
for (const contribution of this.findContribution(element)) {
if (contribution.affects && contribution.affects(element, event)) {
return true;
}
}
return false;
}
get onDidChange() {
return this.onDidChangeEmitter.event;
}
/**
* Return a default file icon for the current icon theme.
*/
get fileIcon() {
return this.getIcon(URIIconReference.create('file'));
}
/**
* Return a default folder icon for the current icon theme.
*/
get folderIcon() {
return this.getIcon(URIIconReference.create('folder'));
}
/**
* Get the icon class from the list of available {@link LabelProviderContribution} for the given element.
* @return the icon class
*/
getIcon(element) {
return this.handleRequest(element, 'getIcon') ?? '';
}
/**
* Get a short name from the list of available {@link LabelProviderContribution} for the given element.
* @return the short name
*/
getName(element) {
return this.handleRequest(element, 'getName') ?? '<unknown>';
}
/**
* Get a long name from the list of available {@link LabelProviderContribution} for the given element.
* @return the long name
*/
getLongName(element) {
return this.handleRequest(element, 'getLongName') ?? '';
}
/**
* Get details from the list of available {@link LabelProviderContribution} for the given element.
* @return the details
* Can be used to supplement {@link getName} in contexts that allow both a primary display field and extra detail.
*/
getDetails(element) {
return this.handleRequest(element, 'getDetails') ?? '';
}
handleRequest(element, method) {
for (const contribution of this.findContribution(element, method)) {
const value = contribution[method]?.(element);
if (value !== undefined) {
return value;
}
}
}
findContribution(element, method) {
const candidates = method
? this.contributionProvider.getContributions().filter(candidate => candidate[method])
: this.contributionProvider.getContributions();
return Prioritizeable.prioritizeAllSync(candidates, contrib => contrib.canHandle(element)).map(entry => entry.value);
}
};
__decorate([
inject(ContributionProvider),
named(LabelProviderContribution)
], LabelProvider.prototype, "contributionProvider", void 0);
LabelProvider = __decorate([
injectable()
], LabelProvider);
export { LabelProvider };
//# sourceMappingURL=label-provider.js.map