feat: new extension API in sourcegraph.d.ts, remove old code

BREAKING CHANGE: The extension API changed significantly for the alpha release. See `sourcegraph.d.ts`.

Author: sqs

src/client/api/codeEditor.ts

@@ -0,0 +1,63 @@
+import { BehaviorSubject, Observable, Subscription } from 'rxjs'
+import { handleRequests } from '../../common/proxy'
+import { Connection } from '../../protocol/jsonrpc2/connection'
+import { TextDocumentDecoration } from '../../protocol/plainTypes'
+import { ProvideTextDocumentDecorationSignature } from '../providers/decoration'
+import { FeatureProviderRegistry } from '../providers/registry'
+import { TextDocumentIdentifier } from '../types/textDocument'
+
+/** @internal */
+export interface ClientCodeEditorAPI {
+    $setDecorations(resource: string, decorations: TextDocumentDecoration[]): void
+}
+
+/** @internal */
+export class ClientCodeEditor implements ClientCodeEditorAPI {
+    private subscriptions = new Subscription()
+
+    /** Map of document URI to its decorations (last published by the server). */
+    private decorations = new Map<string, BehaviorSubject<TextDocumentDecoration[] | null>>()
+
+    constructor(
+        connection: Connection,
+        private registry: FeatureProviderRegistry<undefined, ProvideTextDocumentDecorationSignature>
+    ) {
+        this.subscriptions.add(
+            this.registry.registerProvider(
+                undefined,
+                (textDocument: TextDocumentIdentifier): Observable<TextDocumentDecoration[] | null> =>
+                    this.getDecorationsSubject(textDocument.uri)
+            )
+        )
+
+        handleRequests(connection, 'codeEditor', this)
+    }
+
+    public $setDecorations(resource: string, decorations: TextDocumentDecoration[]): void {
+        this.getDecorationsSubject(resource, decorations)
+    }
+
+    private getDecorationsSubject(
+        resource: string,
+        value?: TextDocumentDecoration[] | null
+    ): BehaviorSubject<TextDocumentDecoration[] | null> {
+        let subject = this.decorations.get(resource)
+        if (!subject) {
+            subject = new BehaviorSubject<TextDocumentDecoration[] | null>(value || null)
+            this.decorations.set(resource, subject)
+        }
+        if (value !== undefined) {
+            subject.next(value)
+        }
+        return subject
+    }
+
+    public unsubscribe(): void {
+        // Clear decorations.
+        for (const subject of this.decorations.values()) {
+            subject.next(null)
+        }
+
+        this.subscriptions.unsubscribe()
+    }
+}

src/client/api/commands.ts

@@ -0,0 +1,48 @@
+import { Subscription } from 'rxjs'
+import { createProxyAndHandleRequests } from '../../common/proxy'
+import { ExtCommandsAPI } from '../../extension/api/commands'
+import { Connection } from '../../protocol/jsonrpc2/connection'
+import { CommandRegistry } from '../providers/command'
+import { SubscriptionMap } from './common'
+
+/** @internal */
+export interface ClientCommandsAPI {
+    $unregister(id: number): void
+    $registerCommand(id: number, command: string): void
+    $executeCommand(command: string, args: any[]): Promise<any>
+}
+
+/** @internal */
+export class ClientCommands implements ClientCommandsAPI {
+    private subscriptions = new Subscription()
+    private registrations = new SubscriptionMap()
+    private proxy: ExtCommandsAPI
+
+    constructor(connection: Connection, private registry: CommandRegistry) {
+        this.subscriptions.add(this.registrations)
+
+        this.proxy = createProxyAndHandleRequests('commands', connection, this)
+    }
+
+    public $unregister(id: number): void {
+        this.registrations.remove(id)
+    }
+
+    public $registerCommand(id: number, command: string): void {
+        this.registrations.add(
+            id,
+            this.registry.registerCommand({
+                command,
+                run: (...args: any[]): any => this.proxy.$executeCommand(id, args),
+            })
+        )
+    }
+
+    public $executeCommand(command: string, args: any[]): Promise<any> {
+        return this.registry.executeCommand({ command, arguments: args })
+    }
+
+    public unsubscribe(): void {
+        this.subscriptions.unsubscribe()
+    }
+}

src/client/api/common.ts

@@ -0,0 +1,53 @@
+import { Unsubscribable } from 'sourcegraph'
+
+/**
+ * Manages a map of subscriptions keyed on a numeric ID.
+ *
+ * @internal
+ */
+export class SubscriptionMap {
+    private map = new Map<number, Unsubscribable>()
+
+    /**
+     * Adds a new subscription with the given {@link id}.
+     *
+     * @param id - A unique identifier for this subscription among all other entries in this map.
+     * @param subscription - The subscription, unsubscribed when {@link SubscriptionMap#remove} is called.
+     * @throws If there already exists an entry with the given {@link id}.
+     */
+    public add(id: number, subscription: Unsubscribable): void {
+        if (this.map.has(id)) {
+            throw new Error(`subscription already exists with ID ${id}`)
+        }
+        this.map.set(id, subscription)
+    }
+
+    /**
+     * Unsubscribes the subscription that was previously added with the given {@link id}, and removes it from the
+     * map.
+     */
+    public remove(id: number): void {
+        const subscription = this.map.get(id)
+        if (!subscription) {
+            throw new Error(`no subscription with ID ${id}`)
+        }
+        try {
+            subscription.unsubscribe()
+        } finally {
+            this.map.delete(id)
+        }
+    }
+
+    /**
+     * Unsubscribes all subscriptions in this map and clears it.
+     */
+    public unsubscribe(): void {
+        try {
+            for (const subscription of this.map.values()) {
+                subscription.unsubscribe()
+            }
+        } finally {
+            this.map.clear()
+        }
+    }
+}

src/client/api/configuration.ts

@@ -0,0 +1,41 @@
+import { Observable, Subscription } from 'rxjs'
+import { createProxyAndHandleRequests } from '../../common/proxy'
+import { ExtConfigurationAPI } from '../../extension/api/configuration'
+import { ConfigurationUpdateParams } from '../../protocol'
+import { Connection } from '../../protocol/jsonrpc2/connection'
+
+/** @internal */
+export interface ClientConfigurationAPI {
+    $acceptConfigurationUpdate(params: ConfigurationUpdateParams): Promise<void>
+}
+
+/**
+ * @internal
+ * @template C - The configuration schema.
+ */
+export class ClientConfiguration<C> implements ClientConfigurationAPI {
+    private subscriptions = new Subscription()
+    private proxy: ExtConfigurationAPI<C>
+
+    constructor(
+        connection: Connection,
+        environmentConfiguration: Observable<C>,
+        private updateConfiguration: (params: ConfigurationUpdateParams) => Promise<void>
+    ) {
+        this.proxy = createProxyAndHandleRequests('configuration', connection, this)
+
+        this.subscriptions.add(
+            environmentConfiguration.subscribe(config => {
+                this.proxy.$acceptConfigurationData(config)
+            })
+        )
+    }
+
+    public async $acceptConfigurationUpdate(params: ConfigurationUpdateParams): Promise<void> {
+        await this.updateConfiguration(params)
+    }
+
+    public unsubscribe(): void {
+        this.subscriptions.unsubscribe()
+    }
+}

src/client/api/context.ts

@@ -0,0 +1,47 @@
+import { Subscription } from 'rxjs'
+import { ContextValues } from 'sourcegraph'
+import { handleRequests } from '../../common/proxy'
+import { Connection } from '../../protocol/jsonrpc2/connection'
+
+/** @internal */
+export interface ClientContextAPI {
+    $acceptContextUpdates(updates: ContextValues): void
+}
+
+/** @internal */
+export class ClientContext implements ClientContextAPI {
+    private subscriptions = new Subscription()
+
+    /**
+     * Context keys set by this server. To ensure that context values are cleaned up, all context properties that
+     * the server set are cleared upon deinitialization. This errs on the side of clearing too much (if another
+     * server set the same context keys after this server, then those keys would also be cleared when this server's
+     * client deinitializes).
+     */
+    private keys = new Set<string>()
+
+    constructor(connection: Connection, private updateContext: (updates: ContextValues) => void) {
+        handleRequests(connection, 'context', this)
+    }
+
+    public $acceptContextUpdates(updates: ContextValues): void {
+        for (const key of Object.keys(updates)) {
+            this.keys.add(key)
+        }
+        this.updateContext(updates)
+    }
+
+    public unsubscribe(): void {
+        /**
+         * Clear all context properties whose keys were ever set by the server. See {@link ClientContext#keys}.
+         */
+        const updates: ContextValues = {}
+        for (const key of this.keys) {
+            updates[key] = null
+        }
+        this.keys.clear()
+        this.updateContext(updates)
+
+        this.subscriptions.unsubscribe()
+    }
+}

src/client/api/documents.ts

@@ -0,0 +1,34 @@
+import { Observable, Subscription } from 'rxjs'
+import { filter } from 'rxjs/operators'
+import { TextDocument } from 'sourcegraph'
+import { createProxyAndHandleRequests } from '../../common/proxy'
+import { ExtDocumentsAPI } from '../../extension/api/documents'
+import { Connection } from '../../protocol/jsonrpc2/connection'
+import { TextDocumentItem } from '../types/textDocument'
+import { SubscriptionMap } from './common'
+
+/** @internal */
+export class ClientDocuments {
+    private subscriptions = new Subscription()
+    private registrations = new SubscriptionMap()
+    private proxy: ExtDocumentsAPI
+
+    constructor(
+        connection: Connection,
+        environmentTextDocument: Observable<Pick<TextDocument, 'uri' | 'languageId'> | null>
+    ) {
+        this.proxy = createProxyAndHandleRequests('documents', connection, this)
+
+        this.subscriptions.add(
+            environmentTextDocument.pipe(filter((v): v is TextDocumentItem => v !== null)).subscribe(doc => {
+                this.proxy.$acceptDocumentData(doc)
+            })
+        )
+
+        this.subscriptions.add(this.registrations)
+    }
+
+    public unsubscribe(): void {
+        this.subscriptions.unsubscribe()
+    }
+}