@jupyter-lsp/jupyterlab-lsp/lib/features/completion/index.js

Language Server Protocol integration for JupyterLab

import { ILSPCompletionThemeManager } from '@jupyter-lsp/completion-theme';
import { ICompletionProviderManager, ContextCompleterProvider, KernelCompleterProvider } from '@jupyterlab/completer';
import { ILSPFeatureManager, ILSPDocumentConnectionManager } from '@jupyterlab/lsp';
import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
import { ISettingRegistry } from '@jupyterlab/settingregistry';
import { LabIcon } from '@jupyterlab/ui-components';
import completionSvg from '../../../style/icons/completion.svg';
import { FeatureSettings, Feature } from '../../feature';
import { CompletionItemTag } from '../../lsp';
import { PLUGIN_ID } from '../../tokens';
import { EnhancedContextCompleterProvider, EnhancedKernelCompleterProvider } from './overrides';
import { CompletionProvider } from './provider';
import { ICompletionFeature } from './tokens';
export const completionIcon = new LabIcon({
    name: 'lsp:completion',
    svgstr: completionSvg
});
export class CompletionFeature extends Feature {
    constructor(options) {
        super(options);
        this.options = options;
        this.id = CompletionFeature.id;
        this.capabilities = {
            textDocument: {
                completion: {
                    dynamicRegistration: true,
                    completionItem: {
                        snippetSupport: false,
                        commitCharactersSupport: true,
                        documentationFormat: ['markdown', 'plaintext'],
                        deprecatedSupport: true,
                        preselectSupport: false,
                        tagSupport: {
                            valueSet: [CompletionItemTag.Deprecated]
                        }
                    },
                    contextSupport: true
                }
            }
        };
        this._configure();
        options.settings.changed.connect(() => {
            this._configure();
        });
        const provider = new CompletionProvider({ ...options });
        options.completionProviderManager.registerProvider(provider);
        options.completionProviderManager.registerProvider(new EnhancedContextCompleterProvider(options));
        options.completionProviderManager.registerProvider(new EnhancedKernelCompleterProvider(options));
    }
    _configure() {
        const settings = this.options.settings;
        const completionThemeManager = this.options.iconsThemeManager;
        if (!settings.composite.disable) {
            document.body.dataset.lspCompleterLayout = settings.composite.layout;
            completionThemeManager.setTheme(settings.composite.theme);
            completionThemeManager.setIconsOverrides(settings.composite.typesMap);
        }
        else {
            completionThemeManager.setTheme(null);
            delete document.body.dataset.lspCompleterLayout;
        }
    }
}
(function (CompletionFeature) {
    CompletionFeature.id = PLUGIN_ID + ':completion';
})(CompletionFeature || (CompletionFeature = {}));
export const COMPLETION_PLUGIN = {
    id: CompletionFeature.id,
    requires: [
        ILSPFeatureManager,
        ISettingRegistry,
        ICompletionProviderManager,
        ILSPCompletionThemeManager,
        IRenderMimeRegistry,
        ILSPDocumentConnectionManager
    ],
    provides: ICompletionFeature,
    autoStart: true,
    activate: async (app, featureManager, settingRegistry, completionProviderManager, iconsThemeManager, renderMimeRegistry, connectionManager) => {
        const settings = new FeatureSettings(settingRegistry, CompletionFeature.id);
        await settings.ready;
        if (settings.composite.disable) {
            return null;
        }
        const feature = new CompletionFeature({
            settings,
            connectionManager,
            renderMimeRegistry,
            iconsThemeManager,
            completionProviderManager
        });
        featureManager.register(feature);
        return { id: CompletionFeature.id };
    }
};
export const COMPLETION_FALLBACK_PLUGIN = {
    id: CompletionFeature.id + '-fallback',
    description: 'Plugin which restores the default completion provider when the LSP completion plugin is disabled',
    requires: [ICompletionProviderManager],
    optional: [ICompletionFeature],
    autoStart: true,
    activate: async (app, completionProviderManager, completionFeature) => {
        if (completionFeature == null) {
            completionProviderManager.registerProvider(new ContextCompleterProvider());
            completionProviderManager.registerProvider(new KernelCompleterProvider());
        }
    }
};
//# sourceMappingURL=index.js.map