monaco-editor-wrapper/dist/editorApp.d.ts

Wrapper for monaco-vscode-editor-api and monaco-languageclient

import * as monaco from '@codingame/monaco-vscode-editor-api';
import { type ITextFileEditorModel } from '@codingame/monaco-vscode-api/monaco';
import type { IReference } from '@codingame/monaco-vscode-editor-service-override';
import type { Logger } from 'monaco-languageclient/tools';
import type { OverallConfigType } from './vscode/services.js';
export interface ModelRefs {
    modified: IReference<ITextFileEditorModel>;
    original?: IReference<ITextFileEditorModel>;
}
export interface TextModels {
    modified?: monaco.editor.ITextModel | null;
    original?: monaco.editor.ITextModel | null;
}
export interface TextContents {
    modified?: string;
    original?: string;
}
export interface CodeContent {
    text: string;
    uri: string;
    enforceLanguageId?: string;
}
export interface CodeResources {
    modified?: CodeContent;
    original?: CodeContent;
}
export interface CallbackDisposeable {
    modified?: monaco.IDisposable;
    original?: monaco.IDisposable;
}
export interface DisposableModelRefs {
    modified?: IReference<ITextFileEditorModel>;
    original?: IReference<ITextFileEditorModel>;
}
export interface EditorAppConfig {
    codeResources?: CodeResources;
    useDiffEditor?: boolean;
    domReadOnly?: boolean;
    readOnly?: boolean;
    overrideAutomaticLayout?: boolean;
    editorOptions?: monaco.editor.IStandaloneEditorConstructionOptions;
    diffEditorOptions?: monaco.editor.IStandaloneDiffEditorConstructionOptions;
    monacoWorkerFactory?: (logger?: Logger) => void;
    languageDef?: {
        languageExtensionConfig: monaco.languages.ILanguageExtensionPoint;
        monarchLanguage?: monaco.languages.IMonarchLanguage;
        theme?: {
            name: monaco.editor.BuiltinTheme | string;
            data: monaco.editor.IStandaloneThemeData;
        };
    };
}
/**
 * This is the base class for both Monaco Ediotor Apps:
 * - EditorAppClassic
 * - EditorAppExtended
 *
 * It provides the generic functionality for both implementations.
 */
export declare class EditorApp {
    private $type;
    private id;
    private config;
    protected logger: Logger | undefined;
    private editor;
    private diffEditor;
    private modelRefs;
    private onTextChanged?;
    private textChangedDiposeables;
    private modelDisposables;
    private modelRefDisposeTimeout;
    constructor($type: OverallConfigType, id: string, userAppConfig?: EditorAppConfig, logger?: Logger);
    getConfig(): EditorAppConfig;
    haveEditor(): boolean;
    getEditor(): monaco.editor.IStandaloneCodeEditor | undefined;
    getDiffEditor(): monaco.editor.IStandaloneDiffEditor | undefined;
    getTextModels(): TextModels;
    registerOnTextChangedCallbacks(onTextChanged?: (textChanges: TextContents) => void): void;
    setModelRefDisposeTimeout(modelRefDisposeTimeout: number): void;
    init(): Promise<void>;
    createEditors(htmlContainer: HTMLElement): Promise<void>;
    updateCodeResources(codeResources?: CodeResources): Promise<void>;
    buildModelReference(codeContent: CodeContent, logger?: Logger): Promise<IReference<ITextFileEditorModel>>;
    private announceModelUpdate;
    dispose(): Promise<void>;
    disposeModelRefs(): Promise<void>;
    updateLayout(): void;
}
export declare const verifyUrlOrCreateDataUrl: (input: string | URL) => string;
export declare const didModelContentChange: (textModels: TextModels, onTextChanged?: (textChanges: TextContents) => void) => void;
//# sourceMappingURL=editorApp.d.ts.map