Class LanguageMiddlewareFeature

src/omnisharp/languageMiddlewareFeature.ts:33–87

type RemapParameterType<M extends keyof RemapApi> = GetRemapType<NonNullable<RemapApi[M]>>;

export class LanguageMiddlewareFeature implements IDisposable {
    private readonly _middlewares: LanguageMiddleware[];
    private _registration: IDisposable | undefined;

    constructor() {
        this._middlewares = [];
    }

    public dispose(): void {
        // this._registration should always be defined, but just in case we never register...
        this._registration?.dispose();
    }

    public register(): void {
        this._registration = vscode.commands.registerCommand(
            'omnisharp.registerLanguageMiddleware',
            (middleware: LanguageMiddleware) => {
                this._middlewares.push(middleware);
            }
        );
    }

    public getLanguageMiddlewares(): LanguageMiddleware[] {
        return this._middlewares;
    }

    public async remap<M extends keyof RemapApi, P extends RemapParameterType<M>>(
        remapType: M,
        original: P,
        token: vscode.CancellationToken
    ): Promise<P> {
        try {
            const languageMiddlewares = this.getLanguageMiddlewares();
            let remapped = original;

            for (const middleware of languageMiddlewares) {
                // Commit a type crime because we know better than the compiler
                const method = <(p: P, c: vscode.CancellationToken) => vscode.ProviderResult<P>>middleware[remapType];
                if (!method) {
                    continue;
                }

                const result = await method.call(middleware, remapped, token);
                if (result) {
                    remapped = result;
                }
            }

            return remapped;
        } catch (_) {
            // Something happened while remapping. Return the original.
            return original;
        }
    }
}