UNPKG

@theia/core

Version:

Theia is a cloud & desktop IDE framework implemented in TypeScript.

322 lines • 14.1 kB
// ***************************************************************************** // 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