or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

application-core.mdapplication-lifecycle.mdindex.mdplugin-management.mdservice-resolution.md
tile.json

tessl/npm-lumino--application

Pluggable application framework for building extensible desktop-like web applications with plugin architecture support

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/@lumino/application@2.4.x

To install, run

npx @tessl/cli install tessl/npm-lumino--application@2.4.0

index.mddocs/

Lumino Application

Lumino Application provides a pluggable application framework for building extensible desktop-like web applications. It serves as the foundation for creating complex UI applications with plugin architecture support, enabling safe extension by third-party code via a comprehensive plugin system.

Package Information

  • Package Name: @lumino/application
  • Package Type: npm
  • Language: TypeScript
  • Installation: npm install @lumino/application

Core Imports

import { Application, type IPlugin } from "@lumino/application";
import { type Token } from "@lumino/coreutils";
import { Widget } from "@lumino/widgets";

For CommonJS:

const { Application } = require("@lumino/application");
const { Widget } = require("@lumino/widgets");

Basic Usage

import { Application } from "@lumino/application";
import { Widget } from "@lumino/widgets";

// Create a shell widget for the application
const shell = new Widget();

// Create the application
const app = new Application({ shell });

// Register a simple plugin
app.registerPlugin({
  id: 'my-plugin',
  description: 'A simple plugin',
  activate: () => {
    console.log('Plugin activated!');
  }
});

// Start the application
await app.start({
  hostID: 'app-container'
});

Architecture

Lumino Application is built around several key components:

  • Application Class: The main application orchestrator that manages plugins, commands, and the shell
  • Plugin System: Based on @lumino/coreutils PluginRegistry for registration, activation, and dependency management
  • Command Registry: Integrated command system from @lumino/commands for keyboard shortcuts and actions
  • Context Menu: Application-wide context menu system from @lumino/widgets
  • Shell Widget: The root container widget that hosts the entire application UI
  • Service Resolution: Dependency injection system for plugin services

Capabilities

Application Core

The main Application class that orchestrates the entire pluggable application framework. Provides plugin management, service resolution, and application lifecycle control.

class Application<T extends Widget = Widget> {
  constructor(options: Application.IOptions<T>);
  readonly commands: CommandRegistry;
  readonly contextMenu: ContextMenu;
  readonly shell: T;
  readonly deferredPlugins: string[];
  readonly started: Promise<void>;
}

interface Application.IOptions<T extends Widget> extends PluginRegistry.IOptions {
  shell: T;
  contextMenuRenderer?: Menu.IRenderer;
  pluginRegistry?: PluginRegistry;
}

interface PluginRegistry.IOptions {
  /** Validate that a plugin is allowed to be registered. Default is () => true. */
  validatePlugin?: (plugin: IPlugin<any, any>) => boolean;
}

Application Core

Plugin Management

Complete plugin lifecycle management including registration, activation, deactivation, and service resolution. Supports both automatic startup plugins and deferred loading.

// Plugin registration
registerPlugin(plugin: IPlugin<this, any>): void;
registerPlugins(plugins: IPlugin<this, any>[]): void;

// Plugin activation/deactivation
activatePlugin(id: string): Promise<void>;
deactivatePlugin(id: string): Promise<string[]>;
activateDeferredPlugins(): Promise<void>;

// Plugin introspection
hasPlugin(id: string): boolean;
isPluginActivated(id: string): boolean;
listPlugins(): string[];
getPluginDescription(id: string): string;

Plugin Management

Service Resolution

Dependency injection system for resolving plugin services with support for both required and optional dependencies.

resolveRequiredService<U>(token: Token<U>): Promise<U>;
resolveOptionalService<U>(token: Token<U>): Promise<U | null>;

Service Resolution

Application Lifecycle

Application startup process and event handling for managing the complete application lifecycle from initialization to shutdown.

start(options?: Application.IStartOptions): Promise<void>;
handleEvent(event: Event): void;

interface Application.IStartOptions {
  hostID?: string;
  startPlugins?: string[];
  ignorePlugins?: string[];
  bubblingKeydown?: boolean;
}

Application Lifecycle

Types

// Re-exported from @lumino/coreutils (deprecated)
interface IPlugin<T = any, U = any> {
  id: string;
  description?: string;
  activate: (application: T, ...args: any[]) => U | Promise<U>;
  deactivate?: (application: T, ...args: any[]) => void | Promise<void>;
  autoStart?: boolean | 'defer';
  provides?: Token<U>;
  requires?: Token<any>[];
  optional?: Token<any>[];
}

// From @lumino/coreutils
interface Token<T> {
  readonly name: string;
}

// From @lumino/commands
class CommandRegistry {
  processKeydownEvent(event: KeyboardEvent): void;
  processKeyupEvent(event: KeyboardEvent): void;
}

// From @lumino/widgets
class ContextMenu {
  open(event: PointerEvent): boolean;
}

class Widget {
  static attach(widget: Widget, host: Element): void;
  update(): void;
}

interface Menu.IRenderer {
  // Context menu renderer interface
}