@theia/plugin-ext 1.26.0-next.3 → 1.26.0-next.30

package/src/plugin/languages.ts

@@ -19,20 +19,18 @@ import {
     PLUGIN_RPC_CONTEXT,
     LanguagesMain,
     SerializedLanguageConfiguration,
-    SerializedRegExp,
-    SerializedOnEnterRule,
-    SerializedIndentationRule,
     Position,
     Selection,
     RawColorInfo,
     WorkspaceEditDto,
-    PluginInfo
+    PluginInfo,
+    Plugin,
 } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import * as theia from '@theia/plugin';
 import { DocumentsExtImpl } from './documents';
 import { PluginModel } from '../common/plugin-protocol';
-import { Disposable, URI } from './types-impl';
+import { Disposable, URI, LanguageStatusSeverity } from './types-impl';
 import { UriComponents } from '../common/uri-components';
 import {
     CodeActionProviderDocumentation,
@@ -63,6 +61,7 @@ import {
     CallHierarchyItem,
     CallHierarchyIncomingCall,
     CallHierarchyOutgoingCall,
+    LinkedEditingRanges,
 } from '../common/plugin-api-rpc-model';
 import { CompletionAdapter } from './languages/completion';
 import { Diagnostics } from './languages/diagnostics';
@@ -93,7 +92,10 @@ import { CallHierarchyAdapter } from './languages/call-hierarchy';
 import { BinaryBuffer } from '@theia/core/lib/common/buffer';
 import { DocumentSemanticTokensAdapter, DocumentRangeSemanticTokensAdapter } from './languages/semantic-highlighting';
 import { isReadonlyArray } from '../common/arrays';
-import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { DisposableCollection, disposableTimeout, Disposable as TheiaDisposable } from '@theia/core/lib/common/disposable';
+import { Severity } from '@theia/core/lib/common/severity';
+import { LinkedEditingRangeAdapter } from './languages/linked-editing-range';
+import { serializeEnterRules, serializeIndentation, serializeRegExp } from './languages-utils';
 
 type Adapter = CompletionAdapter |
     SignatureHelpAdapter |
@@ -118,7 +120,8 @@ type Adapter = CompletionAdapter |
     RenameAdapter |
     CallHierarchyAdapter |
     DocumentRangeSemanticTokensAdapter |
-    DocumentSemanticTokensAdapter;
+    DocumentSemanticTokensAdapter |
+    LinkedEditingRangeAdapter;
 
 export class LanguagesExtImpl implements LanguagesExt {
 
@@ -630,6 +633,19 @@ export class LanguagesExtImpl implements LanguagesExt {
     }
     // ### Call Hierarchy Provider end
 
+    // ### Linked Editing Range Provider begin
+    registerLinkedEditingRangeProvider(selector: theia.DocumentSelector, provider: theia.LinkedEditingRangeProvider): theia.Disposable {
+        const handle = this.addNewAdapter(new LinkedEditingRangeAdapter(this.documents, provider));
+        this.proxy.$registerLinkedEditingRangeProvider(handle, this.transformDocumentSelector(selector));
+        return this.createDisposable(handle);
+    }
+
+    $provideLinkedEditingRanges(handle: number, resource: UriComponents, position: Position, token: theia.CancellationToken): Promise<LinkedEditingRanges | undefined> {
+        return this.withAdapter(handle, LinkedEditingRangeAdapter, async adapter => adapter.provideRanges(URI.revive(resource), position, token), undefined);
+    }
+
+    // ### Linked Editing Range Provider end
+
     // #region semantic coloring
 
     registerDocumentSemanticTokensProvider(selector: theia.DocumentSelector, provider: theia.DocumentSemanticTokensProvider, legend: theia.SemanticTokensLegend,
@@ -668,46 +684,129 @@ export class LanguagesExtImpl implements LanguagesExt {
         return this.withAdapter(handle, DocumentRangeSemanticTokensAdapter, adapter => adapter.provideDocumentRangeSemanticTokens(URI.revive(resource), range, token), null);
     }
 
-    // #endregion
-}
-
-function serializeEnterRules(rules?: theia.OnEnterRule[]): SerializedOnEnterRule[] | undefined {
-    if (typeof rules === 'undefined' || rules === null) {
-        return undefined;
-    }
+    // Copied from https://github.com/microsoft/vscode/blob/7d9b1c37f8e5ae3772782ba3b09d827eb3fdd833/src/vs/workbench/api/common/extHostLanguages.ts
+    protected statusItemHandlePool = 0;
+    protected readonly statusItemIds = new Set<string>();
+    createLanguageStatusItem(extension: Plugin, id: string, selector: theia.DocumentSelector): theia.LanguageStatusItem {
 
-    return rules.map(r =>
-    ({
-        action: r.action,
-        beforeText: serializeRegExp(r.beforeText),
-        afterText: serializeRegExp(r.afterText)
-    } as SerializedOnEnterRule));
-}
+        const handle = this.statusItemHandlePool++;
+        const proxy = this.proxy;
+        const ids = this.statusItemIds;
 
-function serializeRegExp(regexp?: RegExp): SerializedRegExp | undefined {
-    if (typeof regexp === 'undefined' || regexp === null) {
-        return undefined;
-    }
+        // enforce extension unique identifier
+        const fullyQualifiedId = `${extension.model.id}/${id}`;
+        if (ids.has(fullyQualifiedId)) {
+            throw new Error(`LanguageStatusItem with id '${id}' ALREADY exists`);
+        }
+        ids.add(fullyQualifiedId);
+
+        const data: Omit<theia.LanguageStatusItem, 'dispose'> = {
+            selector,
+            id,
+            name: extension.model.displayName ?? extension.model.name,
+            severity: LanguageStatusSeverity.Information,
+            command: undefined,
+            text: '',
+            detail: '',
+            busy: false
+        };
 
-    return {
-        pattern: regexp.source,
-        flags: (regexp.global ? 'g' : '') + (regexp.ignoreCase ? 'i' : '') + (regexp.multiline ? 'm' : '')
-    };
-}
+        let soonHandle: TheiaDisposable | undefined;
+        const commandDisposables = new DisposableCollection();
+        const updateAsync = () => {
+            soonHandle?.dispose();
+            soonHandle = disposableTimeout(() => {
+                commandDisposables.dispose();
+                commandDisposables.push({ dispose: () => { } }); // Mark disposable as undisposed.
+                this.proxy.$setLanguageStatus(handle, {
+                    id: fullyQualifiedId,
+                    name: data.name ?? extension.model.displayName ?? extension.model.name,
+                    source: extension.model.displayName ?? extension.model.name,
+                    selector: this.transformDocumentSelector(data.selector),
+                    label: data.text,
+                    detail: data.detail ?? '',
+                    severity: data.severity === LanguageStatusSeverity.Error ? Severity.Error : data.severity === LanguageStatusSeverity.Warning ? Severity.Warning : Severity.Info,
+                    command: data.command && this.commands.converter.toSafeCommand(data.command, commandDisposables),
+                    accessibilityInfo: data.accessibilityInformation,
+                    busy: data.busy
+                });
+            }, 0);
+        };
 
-function serializeIndentation(indentationRules?: theia.IndentationRule): SerializedIndentationRule | undefined {
-    if (typeof indentationRules === 'undefined' || indentationRules === null) {
-        return undefined;
+        const result: theia.LanguageStatusItem = {
+            dispose(): void {
+                commandDisposables.dispose();
+                soonHandle?.dispose();
+                proxy.$removeLanguageStatus(handle);
+                ids.delete(fullyQualifiedId);
+            },
+            get id(): string {
+                return data.id;
+            },
+            get name(): string | undefined {
+                return data.name;
+            },
+            set name(value) {
+                data.name = value;
+                updateAsync();
+            },
+            get selector(): theia.DocumentSelector {
+                return data.selector;
+            },
+            set selector(value) {
+                data.selector = value;
+                updateAsync();
+            },
+            get text(): string {
+                return data.text;
+            },
+            set text(value) {
+                data.text = value;
+                updateAsync();
+            },
+            get detail(): string | undefined {
+                return data.detail;
+            },
+            set detail(value) {
+                data.detail = value;
+                updateAsync();
+            },
+            get severity(): theia.LanguageStatusSeverity {
+                return data.severity;
+            },
+            set severity(value) {
+                data.severity = value;
+                updateAsync();
+            },
+            get accessibilityInformation(): theia.AccessibilityInformation | undefined {
+                return data.accessibilityInformation;
+            },
+            set accessibilityInformation(value) {
+                data.accessibilityInformation = value;
+                updateAsync();
+            },
+            get command(): theia.Command | undefined {
+                return data.command;
+            },
+            set command(value) {
+                data.command = value;
+                updateAsync();
+            },
+            get busy(): boolean {
+                return data.busy;
+            },
+            set busy(value: boolean) {
+                data.busy = value;
+                updateAsync();
+            }
+        };
+        updateAsync();
+        return result;
     }
-
-    return {
-        increaseIndentPattern: serializeRegExp(indentationRules.increaseIndentPattern),
-        decreaseIndentPattern: serializeRegExp(indentationRules.decreaseIndentPattern),
-        indentNextLinePattern: serializeRegExp(indentationRules.indentNextLinePattern),
-        unIndentedLinePattern: serializeRegExp(indentationRules.unIndentedLinePattern)
-    };
+    // #endregion
 }
 
 function getPluginLabel(pluginInfo: PluginInfo): string {
     return pluginInfo.displayName || pluginInfo.name;
 }
+

package/src/plugin/markdown-string.ts

@@ -14,45 +14,102 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { MarkdownString as IMarkdownString } from '../common/plugin-api-rpc-model';
+import { Mutable } from '@theia/core';
+import { MarkdownStringImpl as BaseMarkdownString, MarkdownString as MarkdownStringInterface } from '@theia/core/lib/common/markdown-rendering';
+import * as pluginAPI from '@theia/plugin';
+import { es5ClassCompat } from '../common/types';
+import { URI } from './types-impl';
 
-export class MarkdownString {
+// Copied from https://github.com/microsoft/vscode/blob/7d9b1c37f8e5ae3772782ba3b09d827eb3fdd833/src/vs/workbench/api/common/extHostTypes.ts
 
-    value: string;
-    isTrusted?: boolean;
+@es5ClassCompat
+export class MarkdownString implements pluginAPI.MarkdownString {
 
-    constructor(value?: string) {
-        this.value = value || '';
+    readonly #delegate: BaseMarkdownString;
+
+    /**
+     * @returns whether the thing is a markdown string implementation with helper methods.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static isMarkdownString(thing: any): thing is pluginAPI.MarkdownString {
+        if (thing instanceof MarkdownString) {
+            return true;
+        }
+        return thing && thing.appendCodeblock && thing.appendMarkdown && thing.appendText && (thing.value !== undefined);
+    }
+
+    constructor(value?: string, supportThemeIcons: boolean = false) {
+        this.#delegate = new BaseMarkdownString(value, { supportThemeIcons });
+    }
+
+    get value(): string {
+        return this.#delegate.value;
+    }
+    set value(value: string) {
+        this.#delegate.value = value;
+    }
+
+    get isTrusted(): boolean | undefined {
+        return this.#delegate.isTrusted;
+    }
+
+    set isTrusted(value: boolean | undefined) {
+        this.#delegate.isTrusted = value;
+    }
+
+    get supportThemeIcons(): boolean | undefined {
+        return this.#delegate.supportThemeIcons;
     }
 
-    appendText(value: string): MarkdownString {
-        // escape markdown syntax tokens: http://daringfireball.net/projects/markdown/syntax#backslash
-        this.value += value.replace(/[\\`*_{}[\]()#+\-.!]/g, '\\$&');
+    set supportThemeIcons(value: boolean | undefined) {
+        this.#delegate.supportThemeIcons = value;
+    }
+
+    get supportHtml(): boolean | undefined {
+        return this.#delegate.supportHtml;
+    }
+
+    set supportHtml(value: boolean | undefined) {
+        this.#delegate.supportHtml = value;
+    }
+
+    get baseUri(): pluginAPI.Uri | undefined {
+        return URI.revive(this.#delegate.baseUri);
+    }
+
+    set baseUri(value: pluginAPI.Uri | undefined) {
+        this.#delegate.baseUri = value;
+    }
+
+    appendText(value: string): pluginAPI.MarkdownString {
+        this.#delegate.appendText(value);
         return this;
     }
 
-    appendMarkdown(value: string): MarkdownString {
-        this.value += value;
+    appendMarkdown(value: string): pluginAPI.MarkdownString {
+        this.#delegate.appendMarkdown(value);
         return this;
     }
 
-    appendCodeblock(code: string, language: string = ''): MarkdownString {
-        this.value += '\n```';
-        this.value += language;
-        this.value += '\n';
-        this.value += code;
-        this.value += '\n```\n';
+    appendCodeblock(value: string, language?: string): pluginAPI.MarkdownString {
+        this.#delegate.appendCodeblock(language ?? '', value);
         return this;
     }
-}
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function isMarkdownString(thing: any): thing is IMarkdownString {
-    if (thing instanceof MarkdownString) {
-        return true;
-    } else if (thing && typeof thing === 'object') {
-        return typeof (<MarkdownString>thing).value === 'string'
-            && (typeof (<MarkdownString>thing).isTrusted === 'boolean' || (<MarkdownString>thing).isTrusted === undefined);
+    toJSON(): MarkdownStringInterface {
+        const plainObject: Mutable<MarkdownStringInterface> = { value: this.value };
+        if (this.isTrusted !== undefined) {
+            plainObject.isTrusted = this.isTrusted;
+        }
+        if (this.supportThemeIcons !== undefined) {
+            plainObject.supportThemeIcons = this.supportThemeIcons;
+        }
+        if (this.supportHtml !== undefined) {
+            plainObject.supportHtml = this.supportHtml;
+        }
+        if (this.baseUri !== undefined) {
+            plainObject.baseUri = this.baseUri.toJSON();
+        }
+        return plainObject;
     }
-    return false;
 }

package/src/plugin/node/debug/debug.ts

@@ -290,13 +290,14 @@ export class DebugExtImpl implements DebugExt {
         return undefined;
     }
 
-    async $createDebugSession(debugConfiguration: theia.DebugConfiguration): Promise<string> {
+    async $createDebugSession(debugConfiguration: theia.DebugConfiguration, workspaceFolderUri: string | undefined): Promise<string> {
         const sessionId = uuid.v4();
 
         const theiaSession: theia.DebugSession = {
             id: sessionId,
             type: debugConfiguration.type,
             name: debugConfiguration.name,
+            workspaceFolder: this.toWorkspaceFolder(workspaceFolderUri),
             configuration: debugConfiguration,
             customRequest: async (command: string, args?: any) => {
                 const response = await this.proxy.$customRequest(sessionId, command, args);

package/src/plugin/node/debug/plugin-debug-adapter-session.ts

@@ -27,6 +27,7 @@ import { Channel } from '@theia/debug/lib/common/debug-service';
 export class PluginDebugAdapterSession extends DebugAdapterSessionImpl {
     readonly type: string;
     readonly name: string;
+    readonly workspaceFolder: theia.WorkspaceFolder | undefined;
     readonly configuration: theia.DebugConfiguration;
 
     constructor(
@@ -38,6 +39,7 @@ export class PluginDebugAdapterSession extends DebugAdapterSessionImpl {
 
         this.type = theiaSession.type;
         this.name = theiaSession.name;
+        this.workspaceFolder = theiaSession.workspaceFolder;
         this.configuration = theiaSession.configuration;
     }
 

package/src/plugin/plugin-context.ts

@@ -140,7 +140,10 @@ import {
     SourceControlInputBoxValidationType,
     URI,
     FileDecoration,
-    ExtensionMode
+    ExtensionMode,
+    LinkedEditingRanges,
+    LanguageStatusSeverity,
+    TextDocumentChangeReason
 } from './types-impl';
 import { AuthenticationExtImpl } from './authentication-ext';
 import { SymbolKind } from '../common/plugin-api-rpc-model';
@@ -155,7 +158,7 @@ import { LanguagesExtImpl } from './languages';
 import { fromDocumentSelector, pluginToPluginInfo, fromGlobPattern } from './type-converters';
 import { DialogsExtImpl } from './dialogs';
 import { NotificationExtImpl } from './notification';
-import { score } from '@theia/callhierarchy/lib/common/language-selector';
+import { score } from '@theia/editor/lib/common/language-selector';
 import { MarkdownString } from './markdown-string';
 import { TreeViewsExtImpl } from './tree/tree-views';
 import { ConnectionImpl } from '../common/connection';
@@ -779,6 +782,12 @@ export function createAPIFactory(
             },
             registerCallHierarchyProvider(selector: theia.DocumentSelector, provider: theia.CallHierarchyProvider): theia.Disposable {
                 return languagesExt.registerCallHierarchyProvider(selector, provider);
+            },
+            registerLinkedEditingRangeProvider(selector: theia.DocumentSelector, provider: theia.LinkedEditingRangeProvider): theia.Disposable {
+                return languagesExt.registerLinkedEditingRangeProvider(selector, provider);
+            },
+            createLanguageStatusItem(id: string, selector: theia.DocumentSelector): theia.LanguageStatusItem {
+                return languagesExt.createLanguageStatusItem(plugin, id, selector);
             }
         };
 
@@ -955,6 +964,7 @@ export function createAPIFactory(
             DebugConsoleMode,
             DiagnosticSeverity,
             DiagnosticRelatedInformation,
+            LanguageStatusSeverity,
             Location,
             LogLevel,
             DiagnosticTag,
@@ -1031,11 +1041,13 @@ export function createAPIFactory(
             SemanticTokens,
             SemanticTokensEdits,
             SemanticTokensEdit,
+            TextDocumentChangeReason,
             ColorThemeKind,
             SourceControlInputBoxValidationType,
             FileDecoration,
             CancellationError,
-            ExtensionMode
+            ExtensionMode,
+            LinkedEditingRanges
         };
     };
 }

package/src/plugin/scm.ts

@@ -37,7 +37,7 @@ import { Command } from '../common/plugin-api-rpc-model';
 import { RPCProtocol } from '../common/rpc-protocol';
 import { URI } from './types-impl';
 import { ScmCommandArg } from '../common/plugin-api-rpc';
-import { sep } from '@theia/callhierarchy/lib/common/paths';
+import { sep } from '@theia/core/lib/common/paths';
 type ProviderHandle = number;
 type GroupHandle = number;
 type ResourceStateHandle = number;

package/src/plugin/status-bar/status-bar-item.ts

@@ -33,7 +33,7 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
 
     private _name: string | undefined;
     private _text: string;
-    private _tooltip: string;
+    private _tooltip: string | theia.MarkdownString | undefined;
     private _color: string | ThemeColor | undefined;
     private _backgroundColor: ThemeColor | undefined;
     private _command: string | theia.Command;
@@ -74,7 +74,7 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
         return this._text;
     }
 
-    public get tooltip(): string {
+    public get tooltip(): string | theia.MarkdownString | undefined {
         return this._tooltip;
     }
 
@@ -104,7 +104,7 @@ export class StatusBarItemImpl implements theia.StatusBarItem {
         this.update();
     }
 
-    public set tooltip(tooltip: string) {
+    public set tooltip(tooltip: string | theia.MarkdownString | undefined) {
         this._tooltip = tooltip;
         this.update();
     }

package/src/plugin/type-converters.spec.ts

@@ -19,7 +19,8 @@ import * as Converter from './type-converters';
 import * as theia from '@theia/plugin';
 import * as types from './types-impl';
 import * as model from '../common/plugin-api-rpc-model';
-import { MarkdownString, isMarkdownString } from './markdown-string';
+import { MarkdownString } from './markdown-string';
+import { MarkdownString as MarkdownStringInterface } from '@theia/core/lib/common/markdown-rendering';
 import { TaskDto } from '../common/plugin-api-rpc';
 import { TaskGroup } from './types-impl';
 
@@ -63,7 +64,7 @@ describe('Type converters:', () => {
                 const markdownString = new MarkdownString('**test**');
 
                 // when
-                const result = isMarkdownString(markdownString);
+                const result = MarkdownStringInterface.is(markdownString);
 
                 // then
                 assert.deepStrictEqual(result !== false, true);
@@ -74,7 +75,7 @@ describe('Type converters:', () => {
                 const markdownObject = { value: '*test*' };
 
                 // when
-                const result = isMarkdownString(markdownObject);
+                const result = MarkdownStringInterface.is(markdownObject);
 
                 // then
                 assert.deepStrictEqual(result !== false, true);
@@ -85,7 +86,7 @@ describe('Type converters:', () => {
                 const markdownObject = { field1: 5, value: '*test*', field2: 'test' };
 
                 // when
-                const result = isMarkdownString(markdownObject);
+                const result = MarkdownStringInterface.is(markdownObject);
 
                 // then
                 assert.deepStrictEqual(result !== false, true);
@@ -96,7 +97,7 @@ describe('Type converters:', () => {
                 const nonMarkdownObject = { field1: 5, field2: 'test' };
 
                 // when
-                const result = isMarkdownString(nonMarkdownObject);
+                const result = MarkdownStringInterface.is(nonMarkdownObject);
 
                 // then
                 assert.deepStrictEqual(result === false, true);
@@ -107,7 +108,7 @@ describe('Type converters:', () => {
                 const nonMarkdownObject = { isTrusted: true, field1: 5, field2: 'test' };
 
                 // when
-                const result = isMarkdownString(nonMarkdownObject);
+                const result = MarkdownStringInterface.is(nonMarkdownObject);
 
                 // then
                 assert.deepStrictEqual(result === false, true);
@@ -125,10 +126,11 @@ describe('Type converters:', () => {
 
             it('should convert plugin markdown to model markdown', () => {
                 // when
-                const result = { ...Converter.fromMarkdown(pluginMarkdown) };
+                const result = Converter.fromMarkdown(pluginMarkdown);
 
                 // then
-                assert.deepStrictEqual(result, modelMarkdown);
+                assert.deepStrictEqual(result, { ...modelMarkdown, supportThemeIcons: false, supportHtml: false },
+                    'The implementation includes an explicit default `false` for `supportThemeIcons` and `supportHtml`');
             });
 
             it('should convert string to model markdown', () => {
@@ -153,20 +155,21 @@ describe('Type converters:', () => {
                 const markups: (theia.MarkdownString | theia.MarkedString)[] = [
                     pluginMarkdown,
                     aStringWithMarkdown,
-                    codeblock
+                    codeblock,
+                    new MarkdownString('hello', true),
                 ];
 
                 // when
-                const result: model.MarkdownString[] = Converter.fromManyMarkdown(markups)
-                    // convert to vanilla JS Object for deepStrictEqual comparison:
-                    .map(md => ({ ...md }));
-
+                const result: model.MarkdownString[] = Converter.fromManyMarkdown(markups);
                 // then
                 assert.deepStrictEqual(Array.isArray(result), true);
-                assert.deepStrictEqual(result.length, 3);
-                assert.deepStrictEqual(result[0], modelMarkdown);
-                assert.deepStrictEqual(result[1], modelMarkdown);
-                assert.deepStrictEqual(result[2], modelMarkdownWithCode);
+                assert.deepStrictEqual(result.length, 4);
+                assert.deepStrictEqual(result[0], { ...modelMarkdown, supportThemeIcons: false, supportHtml: false, },
+                    'MarkdownString implementation includes default value for `supportThemeIcons` and `supportHtml`');
+                assert.deepStrictEqual(result[1], modelMarkdown, 'Strings should be converted to Markdown.');
+                assert.deepStrictEqual(result[2], modelMarkdownWithCode, 'Objects matching the interface should be unchanged');
+                assert.deepStrictEqual(result[3], { value: 'hello', supportThemeIcons: true, supportHtml: false },
+                    'The constructor argument to MarkdownString for theme icons is respected.');
             });
         });
 

package/src/plugin/type-converters.ts

@@ -22,11 +22,12 @@ import {
     DecorationOptions, EditorPosition, Plugin, Position, WorkspaceTextEditDto, WorkspaceFileEditDto, Selection, TaskDto, WorkspaceEditDto
 } from '../common/plugin-api-rpc';
 import * as model from '../common/plugin-api-rpc-model';
-import { LanguageFilter, LanguageSelector, RelativePattern } from '@theia/callhierarchy/lib/common/language-selector';
-import { isMarkdownString, MarkdownString } from './markdown-string';
+import { LanguageFilter, LanguageSelector, RelativePattern } from '@theia/editor/lib/common/language-selector';
+import { MarkdownString as PluginMarkdownStringImpl } from './markdown-string';
 import * as types from './types-impl';
 import { UriComponents } from '../common/uri-components';
 import { isReadonlyArray } from '../common/arrays';
+import { MarkdownString as MarkdownStringDTO } from '@theia/core/lib/common/markdown-rendering';
 
 const SIDE_GROUP = -2;
 const ACTIVE_GROUP = -1;
@@ -172,7 +173,7 @@ export function fromRangeOrRangeWithMessage(ranges: theia.Range[] | theia.Decora
     }
 }
 
-export function fromManyMarkdown(markup: (theia.MarkdownString | theia.MarkedString)[]): model.MarkdownString[] {
+export function fromManyMarkdown(markup: (theia.MarkdownString | theia.MarkedString)[]): MarkdownStringDTO[] {
     return markup.map(fromMarkdown);
 }
 
@@ -188,23 +189,27 @@ function isCodeblock(thing: any): thing is Codeblock {
         && typeof (<Codeblock>thing).value === 'string';
 }
 
-export function fromMarkdown(markup: theia.MarkdownString | theia.MarkedString): model.MarkdownString {
+export function fromMarkdown(markup: theia.MarkdownString | theia.MarkedString): MarkdownStringDTO {
     if (isCodeblock(markup)) {
         const { language, value } = markup;
         return { value: '```' + language + '\n' + value + '\n```\n' };
-    } else if (isMarkdownString(markup)) {
+    } else if (markup instanceof PluginMarkdownStringImpl) {
+        return markup.toJSON();
+    } else if (MarkdownStringDTO.is(markup)) {
         return markup;
     } else if (typeof markup === 'string') {
-        return { value: <string>markup };
+        return { value: markup };
     } else {
         return { value: '' };
     }
 }
 
-export function toMarkdown(value: model.MarkdownString): MarkdownString {
-    const ret = new MarkdownString(value.value);
-    ret.isTrusted = value.isTrusted;
-    return ret;
+export function toMarkdown(value: MarkdownStringDTO): PluginMarkdownStringImpl {
+    const implemented = new PluginMarkdownStringImpl(value.value, value.supportThemeIcons);
+    implemented.isTrusted = value.isTrusted;
+    implemented.supportHtml = value.supportHtml;
+    implemented.baseUri = value.baseUri && URI.revive(implemented.baseUri);
+    return implemented;
 }
 
 export function fromDocumentSelector(selector: theia.DocumentSelector | undefined): LanguageSelector | undefined {
@@ -466,7 +471,7 @@ export namespace ParameterInformation {
     export function to(info: model.ParameterInformation): types.ParameterInformation {
         return {
             label: info.label,
-            documentation: isMarkdownString(info.documentation) ? toMarkdown(info.documentation) : info.documentation
+            documentation: MarkdownStringDTO.is(info.documentation) ? toMarkdown(info.documentation) : info.documentation
         };
     }
 }
@@ -484,7 +489,7 @@ export namespace SignatureInformation {
     export function to(info: model.SignatureInformation): types.SignatureInformation {
         return {
             label: info.label,
-            documentation: isMarkdownString(info.documentation) ? toMarkdown(info.documentation) : info.documentation,
+            documentation: MarkdownStringDTO.is(info.documentation) ? toMarkdown(info.documentation) : info.documentation,
             parameters: info.parameters && info.parameters.map(ParameterInformation.to)
         };
     }