@theia/core
Version:
Theia is a cloud & desktop IDE framework implemented in TypeScript.
322 lines • 14.1 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, __param } from "tslib";
import { inject, injectable, named } from 'inversify';
import { ContributionProvider, CommandRegistry, MenuModelRegistry, isOSX, BackendStopwatch, LogLevel, MeasurementContext, Stopwatch } from '../common/index.js';
import { KeybindingRegistry } from './keybinding.js';
import { Widget } from './widgets/index.js';
import { ApplicationShell } from './shell/application-shell.js';
import { ShellLayoutRestorer, ApplicationShellLayoutMigrationError } from './shell/shell-layout-restorer.js';
import { FrontendApplicationStateService } from './frontend-application-state.js';
import { preventNavigation, parseCssTime, animationFrame } from './browser.js';
import { CorePreferences } from '../common/core-preferences.js';
import { WindowService } from './window/window-service.js';
import { TooltipService } from './tooltip-service.js';
import { FrontendApplicationContribution } from './frontend-application-contribution.js';
import { ILogger } from '../common/logger.js';
const TIMER_WARNING_THRESHOLD = 100;
let FrontendApplication = class FrontendApplication {
constructor(commands, menus, keybindings, layoutRestorer, contributions, _shell, stateService) {
this.commands = commands;
this.menus = menus;
this.keybindings = keybindings;
this.layoutRestorer = layoutRestorer;
this.contributions = contributions;
this._shell = _shell;
this.stateService = stateService;
}
get shell() {
return this._shell;
}
/**
* Start the frontend application.
*
* Start up consists of the following steps:
* - start frontend contributions
* - attach the application shell to the host element
* - initialize the application shell layout
* - reveal the application shell if it was hidden by a startup indicator
*/
async start() {
const startup = this.backendStopwatch.start('frontend');
this.settlementContext = new MeasurementContext(this.stopwatch, 'Frontend', TIMER_WARNING_THRESHOLD);
await this.measure('startContributions', () => this.startContributions(), 'Start frontend contributions', false);
this.stateService.state = 'started_contributions';
const host = await this.getHost();
this.attachShell(host);
this.attachTooltip(host);
await animationFrame();
this.stateService.state = 'attached_shell';
await this.measure('initializeLayout', () => this.initializeLayout(), 'Initialize the workbench layout', false);
this.stateService.state = 'initialized_layout';
await this.fireOnDidInitializeLayout();
await this.measure('revealShell', () => this.revealShell(host), 'Reveal the workbench UI (start fading out the loading indicator)', false);
this.registerEventListeners();
this.stateService.state = 'ready';
this.settlementContext?.armAllSettled();
startup.then(idToken => this.backendStopwatch.stop(idToken, 'Frontend application startup sequence completed (async work may still be pending)', []));
}
/**
* Return a promise to the host element to which the application shell is attached.
*/
getHost() {
if (document.body) {
return Promise.resolve(document.body);
}
return new Promise(resolve => window.addEventListener('load', () => resolve(document.body), { once: true }));
}
/**
* Return an HTML element that indicates the startup phase, e.g. with an animation or a splash screen.
*/
getStartupIndicator(host) {
const startupElements = host.getElementsByClassName('theia-preload');
return startupElements.length === 0 ? undefined : startupElements[0];
}
/**
* Register global event listeners.
*/
registerEventListeners() {
this.windowsService.onUnload(() => {
this.stateService.state = 'closing_window';
this.layoutRestorer.storeLayout(this);
this.stopContributions();
});
window.addEventListener('resize', () => this.shell.update());
this.keybindings.registerEventListeners(window);
document.addEventListener('touchmove', event => { event.preventDefault(); }, { passive: false });
// Prevent forward/back navigation by scrolling in OS X
if (isOSX) {
document.body.addEventListener('wheel', preventNavigation, { passive: false });
}
// Prevent the default browser behavior when dragging and dropping files into the window.
document.addEventListener('dragenter', event => {
if (event.dataTransfer) {
event.dataTransfer.dropEffect = 'none';
}
event.preventDefault();
}, false);
document.addEventListener('dragover', event => {
if (event.dataTransfer) {
event.dataTransfer.dropEffect = 'none';
}
event.preventDefault();
}, false);
document.addEventListener('drop', event => {
event.preventDefault();
}, false);
}
/**
* Attach the application shell to the host element. If a startup indicator is present, the shell is
* inserted before that indicator so it is not visible yet.
*/
attachShell(host) {
const ref = this.getStartupIndicator(host);
Widget.attach(this.shell, host, ref);
}
/**
* Attach the tooltip container to the host element.
*/
attachTooltip(host) {
this.tooltipService.attachTo(host);
}
/**
* If a startup indicator is present, it is hidden with the `theia-hidden` CSS class, which starts its
* fade-out transition, and removed from the DOM once the CSS transition duration has elapsed.
*
* The returned promise resolves as soon as the fade-out has started, not when the indicator has been
* removed, so that the application reaches the `ready` state without waiting for the animation.
*/
revealShell(host) {
const startupElem = this.getStartupIndicator(host);
if (!startupElem) {
return Promise.resolve();
}
return new Promise(resolve => {
window.requestAnimationFrame(() => {
startupElem.classList.add('theia-hidden');
const preloadStyle = window.getComputedStyle(startupElem);
const transitionDuration = parseCssTime(preloadStyle.transitionDuration, 0);
window.setTimeout(() => this.removeStartupIndicator(startupElem), transitionDuration);
resolve();
});
});
}
/**
* Remove the startup indicator from the DOM once it has faded out.
*/
removeStartupIndicator(startupElem) {
startupElem.remove();
}
/**
* Initialize the shell layout either using the layout restorer service or, if no layout has
* been stored, by creating the default layout.
*/
async initializeLayout() {
if (!await this.restoreLayout()) {
// Fallback: Create the default shell layout
await this.createDefaultLayout();
}
await this.shell.pendingUpdates;
}
/**
* Try to restore the shell layout from the storage service. Resolves to `true` if successful.
*/
async restoreLayout() {
try {
return await this.layoutRestorer.restoreLayout(this);
}
catch (error) {
if (ApplicationShellLayoutMigrationError.is(error)) {
this.logger.warn(error.message);
this.logger.info('Initializing the default layout instead...');
}
else {
this.logger.error('Could not restore layout', error);
}
return false;
}
}
/**
* Let the frontend application contributions initialize the shell layout. Override this
* method in order to create an application-specific custom layout.
*/
async createDefaultLayout() {
for (const contribution of this.contributions.getContributions()) {
if (contribution.initializeLayout) {
try {
await this.measureContribution(contribution, 'initializeLayout', () => contribution.initializeLayout(this));
}
catch (error) {
this.logger.error('Could not initialize the layout of contribution', error);
}
}
}
}
async fireOnDidInitializeLayout() {
for (const contribution of this.contributions.getContributions()) {
if (contribution.onDidInitializeLayout) {
try {
await this.measureContribution(contribution, 'onDidInitializeLayout', () => contribution.onDidInitializeLayout(this));
}
catch (error) {
this.logger.error('Could not notify contribution of layout initialization', error);
}
}
}
}
/**
* Initialize and start the frontend application contributions.
*/
async startContributions() {
for (const contribution of this.contributions.getContributions()) {
if (contribution.initialize) {
try {
await this.measureContribution(contribution, 'initialize', () => contribution.initialize());
}
catch (error) {
this.logger.error('Could not initialize contribution', error);
}
}
}
for (const contribution of this.contributions.getContributions()) {
if (contribution.configure) {
try {
await this.measureContribution(contribution, 'configure', () => contribution.configure(this));
}
catch (error) {
this.logger.error('Could not configure contribution', error);
}
}
}
/**
* FIXME:
* - decouple commands & menus
* - consider treat commands, keybindings and menus as frontend application contributions
*/
await this.measure('commands.onStart', () => this.commands.onStart());
await this.measure('keybindings.onStart', () => this.keybindings.onStart());
await this.measure('menus.onStart', () => this.menus.onStart());
for (const contribution of this.contributions.getContributions()) {
if (contribution.onStart) {
try {
await this.measureContribution(contribution, 'onStart', () => contribution.onStart(this));
}
catch (error) {
this.logger.error('Could not start contribution', error);
}
}
}
}
/**
* Stop the frontend application contributions. This is called when the window is unloaded.
*/
stopContributions() {
this.logger.info('>>> Stopping frontend contributions...');
for (const contribution of this.contributions.getContributions()) {
if (contribution.onStop) {
try {
contribution.onStop(this);
}
catch (error) {
this.logger.error('Could not stop contribution', error);
}
}
}
this.logger.info('<<< All frontend contributions have been stopped.');
}
async measureContribution(contribution, hook, fn) {
let innerResult;
this.settlementContext?.ensureEntry(contribution);
const result = await this.measure(contribution.constructor.name + '.' + hook, () => (innerResult = fn()));
this.settlementContext?.trackSettlement(contribution, innerResult);
return result;
}
async measure(name, fn, message = `Frontend ${name}`, threshold = true) {
return this.stopwatch.startAsync(name, message, fn, threshold ? { thresholdMillis: TIMER_WARNING_THRESHOLD, defaultLogLevel: LogLevel.DEBUG } : {});
}
};
__decorate([
inject(CorePreferences)
], FrontendApplication.prototype, "corePreferences", void 0);
__decorate([
inject(WindowService)
], FrontendApplication.prototype, "windowsService", void 0);
__decorate([
inject(TooltipService)
], FrontendApplication.prototype, "tooltipService", void 0);
__decorate([
inject(Stopwatch)
], FrontendApplication.prototype, "stopwatch", void 0);
__decorate([
inject(BackendStopwatch)
], FrontendApplication.prototype, "backendStopwatch", void 0);
__decorate([
inject(ILogger),
named('core:FrontendApplication')
], FrontendApplication.prototype, "logger", void 0);
FrontendApplication = __decorate([
injectable(),
__param(0, inject(CommandRegistry)),
__param(1, inject(MenuModelRegistry)),
__param(2, inject(KeybindingRegistry)),
__param(3, inject(ShellLayoutRestorer)),
__param(4, inject(ContributionProvider)),
__param(4, named(FrontendApplicationContribution)),
__param(5, inject(ApplicationShell)),
__param(6, inject(FrontendApplicationStateService))
], FrontendApplication);
export { FrontendApplication };
//# sourceMappingURL=frontend-application.js.map