@krassowski/jupyterlab-lsp/lib/editor_integration/testutils.d.ts

Language Server Protocol integration for JupyterLab

import { JupyterFrontEnd } from '@jupyterlab/application';
import { CodeEditor } from '@jupyterlab/codeeditor';
import { CodeMirrorEditor } from '@jupyterlab/codemirror';
import { IDocumentWidget } from '@jupyterlab/docregistry';
import { FileEditor } from '@jupyterlab/fileeditor';
import { ILoggerRegistry } from '@jupyterlab/logconsole';
import * as nbformat from '@jupyterlab/nbformat';
import { Notebook, NotebookPanel } from '@jupyterlab/notebook';
import { ITranslator } from '@jupyterlab/translation';
import { Signal } from '@lumino/signaling';
import { WidgetAdapter } from '../adapters/adapter';
import { FileEditorAdapter } from '../adapters/file_editor/file_editor';
import { NotebookAdapter } from '../adapters/notebook/notebook';
import { LSPConnection } from '../connection';
import { DocumentConnectionManager } from '../connection_manager';
import { IForeignCodeExtractorsRegistry } from '../extractors/types';
import { IFeatureSettings } from '../feature';
import { ILSPExtension } from '../index';
import { LanguageServerManager } from '../manager';
import { ICodeOverridesRegistry } from '../overrides/tokens';
import { ILSPFeatureManager, ILSPLogConsole, ILSPVirtualEditorManager, WidgetAdapterConstructor } from '../tokens';
import { CodeMirrorVirtualEditor } from '../virtual/codemirror_editor';
import { VirtualDocument } from '../virtual/document';
import { IVirtualEditor } from '../virtual/editor';
import { CodeMirrorIntegration, CodeMirrorIntegrationConstructor } from './codemirror';
import { EditorAdapter } from './editor_adapter';
import IEditor = CodeEditor.IEditor;
export interface ITestEnvironment {
    document_options: VirtualDocument.IOptions;
    virtual_editor: CodeMirrorVirtualEditor;
    adapter: WidgetAdapter<any>;
    /**
     * Has to be called after construction!
     */
    init(): void;
    dispose(): void;
}
export declare class MockLanguageServerManager extends LanguageServerManager {
    fetchSessions(): Promise<void>;
}
export declare class MockSettings<T> implements IFeatureSettings<T> {
    private settings;
    changed: Signal<IFeatureSettings<T>, void>;
    constructor(settings: T);
    get composite(): Required<T>;
    set(setting: keyof T, value: any): void;
}
export declare class MockExtension implements ILSPExtension {
    app: JupyterFrontEnd;
    connection_manager: DocumentConnectionManager;
    language_server_manager: LanguageServerManager;
    feature_manager: ILSPFeatureManager;
    editor_type_manager: ILSPVirtualEditorManager;
    foreign_code_extractors: IForeignCodeExtractorsRegistry;
    code_overrides: ICodeOverridesRegistry;
    console: ILSPLogConsole;
    user_console: ILoggerRegistry;
    translator: ITranslator;
    constructor();
}
export declare abstract class TestEnvironment implements ITestEnvironment {
    virtual_editor: CodeMirrorVirtualEditor;
    protected abstract get_adapter_type(): WidgetAdapterConstructor<any>;
    adapter: WidgetAdapter<any>;
    abstract widget: IDocumentWidget;
    protected extension: ILSPExtension;
    protected abstract get_defaults(): VirtualDocument.IOptions;
    document_options: VirtualDocument.IOptions;
    constructor(options?: Partial<VirtualDocument.IOptions>);
    protected abstract create_widget(): IDocumentWidget;
    init(): void;
    create_virtual_editor(): CodeMirrorVirtualEditor;
    dispose(): void;
}
export interface IFeatureTestEnvironment extends ITestEnvironment {
    init_integration<T extends CodeMirrorIntegration>(options: IFeatureTestEnvironment.IInitOptions): T;
    dispose_feature(feature: CodeMirrorIntegration): void;
}
export declare namespace IFeatureTestEnvironment {
    interface IInitOptions {
        constructor: CodeMirrorIntegrationConstructor;
        id: string;
        register?: boolean;
        document?: VirtualDocument;
        settings?: IFeatureSettings<any>;
    }
}
export declare class FileEditorTestEnvironment extends TestEnvironment {
    protected get_adapter_type(): typeof FileEditorAdapter;
    widget: IDocumentWidget<FileEditor>;
    protected get_defaults(): VirtualDocument.IOptions;
    get ce_editor(): CodeMirrorEditor;
    create_widget(): IDocumentWidget;
    dispose(): void;
}
export declare class NotebookTestEnvironment extends TestEnvironment {
    widget: NotebookPanel;
    protected get_adapter_type(): typeof NotebookAdapter;
    get notebook(): Notebook;
    protected get_defaults(): VirtualDocument.IOptions;
    create_widget(): IDocumentWidget;
}
declare const FileEditorFeatureTestEnvironment_base: {
    new (...args: any[]): {
        _connections: Map<CodeMirrorIntegration, LSPConnection>;
        init(): void;
        readonly status_message: import("../adapters/adapter").StatusMessage;
        init_integration<T extends CodeMirrorIntegration>(options: IFeatureTestEnvironment.IInitOptions): T;
        dispose_feature(feature: CodeMirrorIntegration): void;
        create_dummy_connection(): LSPConnection;
        dispose(): void;
        document_options: VirtualDocument.IOptions;
        virtual_editor: CodeMirrorVirtualEditor;
        adapter: WidgetAdapter<any>;
    };
} & typeof FileEditorTestEnvironment;
export declare class FileEditorFeatureTestEnvironment extends FileEditorFeatureTestEnvironment_base {
}
declare const NotebookFeatureTestEnvironment_base: {
    new (...args: any[]): {
        _connections: Map<CodeMirrorIntegration, LSPConnection>;
        init(): void;
        readonly status_message: import("../adapters/adapter").StatusMessage;
        init_integration<T extends CodeMirrorIntegration>(options: IFeatureTestEnvironment.IInitOptions): T;
        dispose_feature(feature: CodeMirrorIntegration): void;
        create_dummy_connection(): LSPConnection;
        dispose(): void;
        document_options: VirtualDocument.IOptions;
        virtual_editor: CodeMirrorVirtualEditor;
        adapter: WidgetAdapter<any>;
    };
} & typeof NotebookTestEnvironment;
export declare class NotebookFeatureTestEnvironment extends NotebookFeatureTestEnvironment_base {
}
export declare function code_cell(source: string[] | string, metadata?: Partial<nbformat.ICodeCellMetadata>): nbformat.ICodeCell;
export declare function set_notebook_content(notebook: Notebook, cells: nbformat.ICodeCell[], metadata?: nbformat.INotebookMetadata): void;
export declare const python_notebook_metadata: nbformat.INotebookMetadata;
export declare function showAllCells(notebook: Notebook): void;
export declare function getCellsJSON(notebook: Notebook): Array<nbformat.ICell>;
export declare function synchronize_content(environment: IFeatureTestEnvironment, adapter: EditorAdapter<IVirtualEditor<IEditor>>): Promise<void>;
export {};