"use strict";
/* ---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.newCommands = exports.ApiCommand = exports.ApiCommandResult = exports.ApiCommandArgument = void 0;
const tslib_1 = require("tslib");
const ide_core_common_1 = require("@opensumi/ide-core-common");
const typeConverters = tslib_1.__importStar(require("../../../common/vscode/converter"));
const types = tslib_1.__importStar(require("../../../common/vscode/ext-types"));
const modes = tslib_1.__importStar(require("../../../common/vscode/model.api"));
const { isFalsyOrEmpty } = ide_core_common_1.arrays;
class ApiCommandArgument {
    constructor(name, description, validate, convert) {
        this.name = name;
        this.description = description;
        this.validate = validate;
        this.convert = convert;
    }
    optional() {
        return new ApiCommandArgument(this.name, `(optional) ${this.description}`, (value) => value === undefined || value === null || this.validate(value), (value) => (value === undefined ? undefined : value === null ? null : this.convert(value)));
    }
    with(name, description) {
        return new ApiCommandArgument(name !== null && name !== void 0 ? name : this.name, description !== null && description !== void 0 ? description : this.description, this.validate, this.convert);
    }
}
exports.ApiCommandArgument = ApiCommandArgument;
ApiCommandArgument.Uri = new ApiCommandArgument('uri', 'Uri of a text document', (v) => ide_core_common_1.Uri.isUri(v), (v) => v);
ApiCommandArgument.Position = new ApiCommandArgument('position', 'A position in a text document', (v) => types.Position.isPosition(v), typeConverters.fromPosition);
ApiCommandArgument.Range = new ApiCommandArgument('range', 'A range in a text document', (v) => types.Range.isRange(v), typeConverters.fromRange);
ApiCommandArgument.Selection = new ApiCommandArgument('selection', 'A selection in a text document', (v) => types.Selection.isSelection(v), typeConverters.fromSelection);
ApiCommandArgument.Number = new ApiCommandArgument('number', '', (v) => typeof v === 'number', (v) => v);
ApiCommandArgument.String = new ApiCommandArgument('string', '', (v) => typeof v === 'string', (v) => v);
ApiCommandArgument.CallHierarchyItem = new ApiCommandArgument('item', 'A call hierarchy item', (v) => v instanceof types.CallHierarchyItem, typeConverters.CallHierarchyItem.to);
ApiCommandArgument.TypeHierarchyItem = new ApiCommandArgument('item', 'A type hierarchy item', (v) => v instanceof types.TypeHierarchyItem, typeConverters.TypeHierarchyItem.to);
class ApiCommandResult {
    constructor(description, convert) {
        this.description = description;
        this.convert = convert;
    }
}
exports.ApiCommandResult = ApiCommandResult;
ApiCommandResult.Void = new ApiCommandResult('no result', (v) => v);
class ApiCommand {
    constructor(id, internalId, description, args, result) {
        this.id = id;
        this.internalId = internalId;
        this.description = description;
        this.args = args;
        this.result = result;
    }
}
exports.ApiCommand = ApiCommand;
// some code copied and modified from https://github.com/microsoft/vscode/blob/main/src/vs/workbench/api/common/extHostApiCommands.ts#L25-L475
exports.newCommands = [
    // -- document highlights
    new ApiCommand('vscode.executeDocumentHighlights', '_executeDocumentHighlights', 'Execute document highlight provider.', [ApiCommandArgument.Uri, ApiCommandArgument.Position], new ApiCommandResult('A promise that resolves to an array of SymbolInformation and DocumentSymbol instances.', tryMapWith(typeConverters.DocumentHighlight.to))),
    // -- document symbols
    new ApiCommand('vscode.executeDocumentSymbolProvider', '_executeDocumentSymbolProvider', 'Execute document symbol provider.', [ApiCommandArgument.Uri], new ApiCommandResult('A promise that resolves to an array of DocumentHighlight-instances.', (value, apiArgs) => {
        if (isFalsyOrEmpty(value)) {
            return undefined;
        }
        class MergedInfo extends types.SymbolInformation {
            static to(symbol) {
                const res = new MergedInfo(symbol.name, typeConverters.SymbolKind.toSymbolKind(symbol.kind), symbol.containerName || '', new types.Location(apiArgs[0], typeConverters.toRange(symbol.range)));
                res.detail = symbol.detail;
                res.range = res.location.range;
                res.selectionRange = typeConverters.toRange(symbol.selectionRange);
                res.children = symbol.children ? symbol.children.map(MergedInfo.to) : [];
                return res;
            }
        }
        return value.map(MergedInfo.to);
    })),
    // -- formatting
    new ApiCommand('vscode.executeFormatDocumentProvider', '_executeFormatDocumentProvider', 'Execute document format provider.', [
        ApiCommandArgument.Uri,
        new ApiCommandArgument('options', 'Formatting options', (_) => true, (v) => v),
    ], new ApiCommandResult('A promise that resolves to an array of TextEdits.', tryMapWith(typeConverters.TextEdit.to))),
    new ApiCommand('vscode.executeFormatRangeProvider', '_executeFormatRangeProvider', 'Execute range format provider.', [
        ApiCommandArgument.Uri,
        ApiCommandArgument.Range,
        new ApiCommandArgument('options', 'Formatting options', (_) => true, (v) => v),
    ], new ApiCommandResult('A promise that resolves to an array of TextEdits.', tryMapWith(typeConverters.TextEdit.to))),
    new ApiCommand('vscode.executeFormatOnTypeProvider', '_executeFormatOnTypeProvider', 'Execute format on type provider.', [
        ApiCommandArgument.Uri,
        ApiCommandArgument.Position,
        new ApiCommandArgument('ch', 'Trigger character', (v) => typeof v === 'string', (v) => v),
        new ApiCommandArgument('options', 'Formatting options', (_) => true, (v) => v),
    ], new ApiCommandResult('A promise that resolves to an array of TextEdits.', tryMapWith(typeConverters.TextEdit.to))),
    // -- go to symbol (definition, type definition, declaration, impl, references)
    new ApiCommand('vscode.executeDefinitionProvider', '_executeDefinitionProvider', 'Execute all definition providers.', [ApiCommandArgument.Uri, ApiCommandArgument.Position], new ApiCommandResult('A promise that resolves to an array of Location or LocationLink instances.', mapLocationOrLocationLink)),
    new ApiCommand('vscode.executeTypeDefinitionProvider', '_executeTypeDefinitionProvider', 'Execute all type definition providers.', [ApiCommandArgument.Uri, ApiCommandArgument.Position], new ApiCommandResult('A promise that resolves to an array of Location or LocationLink instances.', mapLocationOrLocationLink)),
    new ApiCommand('vscode.executeDeclarationProvider', '_executeDeclarationProvider', 'Execute all declaration providers.', [ApiCommandArgument.Uri, ApiCommandArgument.Position], new ApiCommandResult('A promise that resolves to an array of Location or LocationLink instances.', mapLocationOrLocationLink)),
    new ApiCommand('vscode.executeImplementationProvider', '_executeImplementationProvider', 'Execute all implementation providers.', [ApiCommandArgument.Uri, ApiCommandArgument.Position], new ApiCommandResult('A promise that resolves to an array of Location or LocationLink instances.', mapLocationOrLocationLink)),
    new ApiCommand('vscode.executeReferenceProvider', '_executeReferenceProvider', 'Execute all reference providers.', [ApiCommandArgument.Uri, ApiCommandArgument.Position], new ApiCommandResult('A promise that resolves to an array of Location-instances.', tryMapWith(typeConverters.location.to))),
    // -- hover
    new ApiCommand('vscode.executeHoverProvider', '_executeHoverProvider', 'Execute all hover providers.', [ApiCommandArgument.Uri, ApiCommandArgument.Position], new ApiCommandResult('A promise that resolves to an array of Hover-instances.', tryMapWith(typeConverters.Hover.to))),
    // -- selection range
    new ApiCommand('vscode.executeSelectionRangeProvider', '_executeSelectionRangeProvider', 'Execute selection range provider.', [
        ApiCommandArgument.Uri,
        new ApiCommandArgument('position', 'A positions in a text document', (v) => Array.isArray(v) && v.every((v) => types.Position.isPosition(v)), (v) => v.map(typeConverters.Position.from)),
    ], new ApiCommandResult('A promise that resolves to an array of ranges.', (result) => result.map((ranges) => {
        let node;
        for (const range of ranges.reverse()) {
            node = new types.SelectionRange(typeConverters.Range.to(range), node);
        }
        return node;
    }))),
    // -- symbol search
    new ApiCommand('vscode.executeWorkspaceSymbolProvider', '_executeWorkspaceSymbolProvider', 'Execute all workspace symbol providers.', [ApiCommandArgument.String.with('query', 'Search string')], new ApiCommandResult('A promise that resolves to an array of SymbolInformation-instances.', (value) => {
        const result = [];
        if (Array.isArray(value)) {
            for (const tuple of value) {
                result.push(...tuple[1].map(typeConverters.WorkspaceSymbol.to));
            }
        }
        return result;
    })),
    // --- call hierarchy
    new ApiCommand('vscode.prepareCallHierarchy', '_executePrepareCallHierarchy', 'Prepare call hierarchy at a position inside a document', [ApiCommandArgument.Uri, ApiCommandArgument.Position], new ApiCommandResult('A CallHierarchyItem or undefined', (v) => v.map(typeConverters.CallHierarchyItem.to))),
    new ApiCommand('vscode.provideIncomingCalls', '_executeProvideIncomingCalls', 'Compute incoming calls for an item', [ApiCommandArgument.CallHierarchyItem], new ApiCommandResult('A CallHierarchyItem or undefined', (v) => v.map(typeConverters.CallHierarchyIncomingCall.to))),
    new ApiCommand('vscode.provideOutgoingCalls', '_executeProvideOutgoingCalls', 'Compute outgoing calls for an item', [ApiCommandArgument.CallHierarchyItem], new ApiCommandResult('A CallHierarchyItem or undefined', (v) => v.map(typeConverters.CallHierarchyOutgoingCall.to))),
    // --- type hierarchy
    new ApiCommand('vscode.prepareTypeHierarchy', '_executePrepareTypeHierarchy', 'Prepare type hierarchy at a position inside a document', [ApiCommandArgument.Uri, ApiCommandArgument.Position], new ApiCommandResult('A TypeHierarchyItem or undefined', (v) => v.map(typeConverters.TypeHierarchyItem.to))),
    new ApiCommand('vscode.provideSupertypes', '_executeProvideSupertypes', 'Compute supertypes for an item', [ApiCommandArgument.TypeHierarchyItem], new ApiCommandResult('A TypeHierarchyItem or undefined', (v) => v.map(typeConverters.TypeHierarchyItem.to))),
    new ApiCommand('vscode.provideSubtypes', '_executeProvideSubtypes', 'Compute subtypes for an item', [ApiCommandArgument.TypeHierarchyItem], new ApiCommandResult('A TypeHierarchyItem or undefined', (v) => v.map(typeConverters.TypeHierarchyItem.to))),
    // --- rename
    new ApiCommand('vscode.executeDocumentRenameProvider', '_executeDocumentRenameProvider', 'Execute rename provider.', [
        ApiCommandArgument.Uri,
        ApiCommandArgument.Position,
        ApiCommandArgument.String.with('newName', 'The new symbol name'),
    ], new ApiCommandResult('A promise that resolves to a WorkspaceEdit.', (value) => {
        if (!value) {
            return undefined;
        }
        if (value.rejectReason) {
            throw new Error(value.rejectReason);
        }
        return typeConverters.WorkspaceEdit.to(value);
    })),
    // --- links
    new ApiCommand('vscode.executeLinkProvider', '_executeLinkProvider', 'Execute document link provider.', [
        ApiCommandArgument.Uri,
        ApiCommandArgument.Number.with('linkResolveCount', 'Number of links that should be resolved, only when links are unresolved.').optional(),
    ], new ApiCommandResult('A promise that resolves to an array of DocumentLink-instances.', (value) => value.map(typeConverters.DocumentLink.to))),
    // --- completions
    new ApiCommand('vscode.executeCompletionItemProvider', '_executeCompletionItemProvider', 'Execute completion item provider.', [
        ApiCommandArgument.Uri,
        ApiCommandArgument.Position,
        ApiCommandArgument.String.with('triggerCharacter', 'Trigger completion when the user types the character, like `,` or `(`').optional(),
        ApiCommandArgument.Number.with('itemResolveCount', 'Number of completions to resolve (too large numbers slow down completions)').optional(),
    ], new ApiCommandResult('A promise that resolves to a CompletionList-instance.', (value, _args, converter) => {
        if (!value) {
            return new types.CompletionList([]);
        }
        const items = value.suggestions.map((suggestion) => typeConverters.CompletionItem.to(suggestion, converter));
        return new types.CompletionList(items, value.incomplete);
    })),
    // --- signature help
    new ApiCommand('vscode.executeSignatureHelpProvider', '_executeSignatureHelpProvider', 'Execute signature help provider.', [
        ApiCommandArgument.Uri,
        ApiCommandArgument.Position,
        ApiCommandArgument.String.with('triggerCharacter', 'Trigger signature help when the user types the character, like `,` or `(`').optional(),
    ], new ApiCommandResult('A promise that resolves to SignatureHelp.', (value) => {
        if (value) {
            return typeConverters.SignatureHelp.to(value);
        }
        return undefined;
    })),
    // --- code lens
    new ApiCommand('vscode.executeCodeLensProvider', '_executeCodeLensProvider', 'Execute code lens provider.', [
        ApiCommandArgument.Uri,
        ApiCommandArgument.Number.with('itemResolveCount', 'Number of lenses that should be resolved and returned. Will only return resolved lenses, will impact performance)').optional(),
    ], new ApiCommandResult('A promise that resolves to an array of CodeLens-instances.', (value, _args, converter) => tryMapWith((item) => new types.CodeLens(typeConverters.Range.to(item.range), item.command && converter.fromInternal(item.command)))(value))),
    // --- code actions
    new ApiCommand('vscode.executeCodeActionProvider', '_executeCodeActionProvider', 'Execute code action provider.', [
        ApiCommandArgument.Uri,
        new ApiCommandArgument('rangeOrSelection', 'Range in a text document. Some refactoring provider requires Selection object.', (v) => types.Range.isRange(v), (v) => (types.Selection.isSelection(v) ? typeConverters.Selection.from(v) : typeConverters.Range.from(v))),
        ApiCommandArgument.String.with('kind', 'Code action kind to return code actions for').optional(),
        ApiCommandArgument.Number.with('itemResolveCount', 'Number of code actions to resolve (too large numbers slow down code actions)').optional(),
    ], new ApiCommandResult('A promise that resolves to an array of Command-instances.', (value, _args, converter) => tryMapWith((codeAction) => {
        if (codeAction._isSynthetic) {
            if (!codeAction.command) {
                throw new Error('Synthetic code actions must have a command');
            }
            return converter.fromInternal(codeAction.command);
        }
        else {
            const ret = new types.CodeAction(codeAction.title, codeAction.kind ? new types.CodeActionKind(codeAction.kind) : undefined);
            if (codeAction.edit) {
                ret.edit = typeConverters.WorkspaceEdit.to(codeAction.edit);
            }
            if (codeAction.command) {
                ret.command = converter.fromInternal(codeAction.command);
            }
            ret.isPreferred = codeAction.isPreferred;
            return ret;
        }
    })(value))),
    // --- colors
    new ApiCommand('vscode.executeDocumentColorProvider', '_executeDocumentColorProvider', 'Execute document color provider.', [ApiCommandArgument.Uri], new ApiCommandResult('A promise that resolves to an array of ColorInformation objects.', (result) => {
        if (result) {
            return result.map((ci) => new types.ColorInformation(typeConverters.Range.to(ci.range), typeConverters.Color.to(ci.color)));
        }
        return [];
    })),
    new ApiCommand('vscode.executeColorPresentationProvider', '_executeColorPresentationProvider', 'Execute color presentation provider.', [
        new ApiCommandArgument('color', 'The color to show and insert', (v) => v instanceof types.Color, typeConverters.Color.from),
        new ApiCommandArgument('context', 'Context object with uri and range', (_v) => true, (v) => ({ uri: v.uri, range: typeConverters.Range.from(v.range) })),
    ], new ApiCommandResult('A promise that resolves to an array of ColorPresentation objects.', (result) => {
        if (result) {
            return result.map(typeConverters.ColorPresentation.to);
        }
        return [];
    })),
    // --- open'ish commands
    new ApiCommand('vscode.open', '_workbench.open', 'Opens the provided resource in the editor. Can be a text or binary file, or a http(s) url. If you need more control over the options for opening a text file, use vscode.window.showTextDocument instead.', [
        ApiCommandArgument.Uri,
        new ApiCommandArgument('columnOrOptions', 'Either the column in which to open or editor options, see vscode.TextDocumentShowOptions', (v) => v === undefined || typeof v === 'number' || typeof v === 'object', (v) => !v
            ? v
            : typeof v === 'number'
                ? [v, undefined]
                : [typeConverters.ViewColumn.from(v.viewColumn), typeConverters.TextEditorOpenOptions.from(v)]).optional(),
        ApiCommandArgument.String.with('label', '').optional(),
    ], ApiCommandResult.Void),
    new ApiCommand('vscode.openWith', '_workbench.openWith', 'Opens the provided resource with a specific editor.', [
        ApiCommandArgument.Uri.with('resource', 'Resource to open'),
        ApiCommandArgument.String.with('viewId', "Custom editor view id or 'default' to use VS Code's default editor"),
        new ApiCommandArgument('columnOrOptions', 'Either the column in which to open or editor options, see vscode.TextDocumentShowOptions', (v) => v === undefined || typeof v === 'number' || typeof v === 'object', (v) => !v
            ? v
            : typeof v === 'number'
                ? [v, undefined]
                : [typeConverters.ViewColumn.from(v.viewColumn), typeConverters.TextEditorOpenOptions.from(v)]).optional(),
    ], ApiCommandResult.Void),
    new ApiCommand('vscode.diff', '_workbench.diff', 'Opens the provided resources in the diff editor to compare their contents.', [
        ApiCommandArgument.Uri.with('left', 'Left-hand side resource of the diff editor'),
        ApiCommandArgument.Uri.with('right', 'Right-hand side resource of the diff editor'),
        ApiCommandArgument.String.with('title', 'Human readable title for the diff editor').optional(),
        new ApiCommandArgument('columnOrOptions', 'Either the column in which to open or editor options, see vscode.TextDocumentShowOptions', (v) => v === undefined || typeof v === 'object', (v) => v && [typeConverters.ViewColumn.from(v.viewColumn), typeConverters.TextEditorOpenOptions.from(v)]).optional(),
    ], ApiCommandResult.Void),
];
function tryMapWith(f) {
    return (value) => {
        if (Array.isArray(value)) {
            return value.map(f);
        }
        return undefined;
    };
}
function mapLocationOrLocationLink(values) {
    if (!Array.isArray(values)) {
        return undefined;
    }
    const result = [];
    for (const item of values) {
        if (modes.isLocationLink(item)) {
            result.push(typeConverters.DefinitionLink.to(item));
        }
        else {
            result.push(typeConverters.location.to(item));
        }
    }
    return result;
}
//# sourceMappingURL=ext.host.api.command.js.map