move RemoteSourceProvider to git api

extensions/git/src/api/api1.ts

@@ -5,7 +5,7 @@
 
 import { Model } from '../model';
 import { Repository as BaseRepository, Resource } from '../repository';
-import { InputBox, Git, API, Repository, Remote, RepositoryState, Branch, Ref, Submodule, Commit, Change, RepositoryUIState, Status, LogOptions, APIState, CommitOptions, GitExtension, RefType } from './git';
+import { InputBox, Git, API, Repository, Remote, RepositoryState, Branch, Ref, Submodule, Commit, Change, RepositoryUIState, Status, LogOptions, APIState, CommitOptions, GitExtension, RefType, RemoteSourceProvider } from './git';
 import { Event, SourceControlInputBox, Uri, SourceControl, Disposable, commands } from 'vscode';
 import { mapEvent } from '../util';
 import { toGitUri } from '../uri';
@@ -248,6 +248,10 @@ export class ApiImpl implements API {
 		return result ? new ApiRepository(result) : null;
 	}
 
+	registerRemoteSourceProvider(provider: RemoteSourceProvider): Disposable {
+		return this._model.registerRemoteSourceProvider(provider);
+	}
+
 	constructor(private _model: Model) { }
 }
 

extensions/git/src/api/git.d.ts

@@ -3,7 +3,8 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { Uri, SourceControlInputBox, Event, CancellationToken } from 'vscode';
+import { Uri, Event, Disposable, ProviderResult } from 'vscode';
+export { ProviderResult } from 'vscode';
 
 export interface Git {
 	readonly path: string;
@@ -189,6 +190,17 @@ export interface Repository {
 	commit(message: string, opts?: CommitOptions): Promise<void>;
 }
 
+export interface RemoteSource {
+	readonly name: string;
+	readonly url: string;
+}
+
+export interface RemoteSourceProvider {
+	readonly name: string;
+	readonly supportsQuery?: boolean;
+	getRemoteSources(query?: string): ProviderResult<RemoteSource[]>;
+}
+
 export type APIState = 'uninitialized' | 'initialized';
 
 export interface API {
@@ -201,6 +213,7 @@ export interface API {
 
 	toGitUri(uri: Uri, ref: string): Uri;
 	getRepository(uri: Uri): Repository | null;
+	registerRemoteSourceProvider(provider: RemoteSourceProvider): Disposable;
 }
 
 export interface GitExtension {

extensions/git/src/commands.ts

@@ -9,9 +9,9 @@ import * as path from 'path';
 import { commands, Disposable, LineChange, MessageOptions, OutputChannel, Position, ProgressLocation, QuickPickItem, Range, SourceControlResourceState, TextDocumentShowOptions, TextEditor, Uri, ViewColumn, window, workspace, WorkspaceEdit, WorkspaceFolder, TimelineItem, env, QuickPick } from 'vscode';
 import TelemetryReporter from 'vscode-extension-telemetry';
 import * as nls from 'vscode-nls';
-import { Branch, GitErrorCodes, Ref, RefType, Status, CommitOptions } from './api/git';
+import { Branch, GitErrorCodes, Ref, RefType, Status, CommitOptions, RemoteSourceProvider, RemoteSource } from './api/git';
 import { ForcePushMode, Git, Stash } from './git';
-import { Model, RemoteProvider, Remote } from './model';
+import { Model } from './model';
 import { Repository, Resource, ResourceGroupType } from './repository';
 import { applyLineChanges, getModifiedRange, intersectDiffWithRange, invertLineChange, toLineRanges } from './staging';
 import { fromGitUri, toGitUri, isGitUri } from './uri';
@@ -245,11 +245,11 @@ async function getQuickPickResult<T extends QuickPickItem>(quickpick: QuickPick<
 	return result;
 }
 
-class RemoteProviderQuickPick {
+class RemoteSourceProviderQuickPick {
 
-	private quickpick: QuickPick<QuickPickItem & { remote?: Remote }>;
+	private quickpick: QuickPick<QuickPickItem & { remoteSource?: RemoteSource }>;
 
-	constructor(private provider: RemoteProvider) {
+	constructor(private provider: RemoteSourceProvider) {
 		this.quickpick = window.createQuickPick();
 		this.quickpick.ignoreFocusOut = true;
 
@@ -269,27 +269,27 @@ class RemoteProviderQuickPick {
 	@throttle
 	async query(): Promise<void> {
 		this.quickpick.busy = true;
-		const remotes = await this.provider.getRemotes(this.quickpick.value);
+		const remoteSources = await this.provider.getRemoteSources(this.quickpick.value) || [];
 		this.quickpick.busy = false;
 
-		if (remotes.length === 0) {
+		if (remoteSources.length === 0) {
 			this.quickpick.items = [{
 				label: localize('none found', "No remote repositories found."),
 				alwaysShow: true
 			}];
 		} else {
-			this.quickpick.items = remotes.map(remote => ({
-				label: remote.name,
-				description: remote.url,
-				remote
+			this.quickpick.items = remoteSources.map(remoteSource => ({
+				label: remoteSource.name,
+				description: remoteSource.url,
+				remote: remoteSource
 			}));
 		}
 	}
 
-	async pick(): Promise<Remote | undefined> {
+	async pick(): Promise<RemoteSource | undefined> {
 		this.query();
 		const result = await getQuickPickResult(this.quickpick);
-		return result?.remote;
+		return result?.remoteSource;
 	}
 }
 
@@ -514,7 +514,7 @@ export class CommandCenter {
 	@command('git.clone')
 	async clone(url?: string, parentPath?: string): Promise<void> {
 		if (!url) {
-			const quickpick = window.createQuickPick<(QuickPickItem & { provider?: RemoteProvider })>();
+			const quickpick = window.createQuickPick<(QuickPickItem & { provider?: RemoteSourceProvider })>();
 			quickpick.ignoreFocusOut = true;
 
 			const providers = this.model.getRemoteProviders()
@@ -544,7 +544,7 @@ export class CommandCenter {
 
 			if (result) {
 				if (result.provider) {
-					const quickpick = new RemoteProviderQuickPick(result.provider);
+					const quickpick = new RemoteSourceProviderQuickPick(result.provider);
 					const remote = await quickpick.pick();
 					url = remote?.url;
 				} else {

extensions/git/src/model.ts

@@ -12,7 +12,7 @@ import * as path from 'path';
 import * as fs from 'fs';
 import * as nls from 'vscode-nls';
 import { fromGitUri } from './uri';
-import { GitErrorCodes, APIState as State } from './api/git';
+import { GitErrorCodes, APIState as State, RemoteSourceProvider } from './api/git';
 
 const localize = nls.loadMessageBundle();
 
@@ -44,17 +44,6 @@ interface OpenRepository extends Disposable {
 	repository: Repository;
 }
 
-export interface Remote {
-	readonly name: string;
-	readonly url: string;
-}
-
-export interface RemoteProvider {
-	readonly name: string;
-	readonly supportsQuery?: boolean;
-	getRemotes(query?: string): Remote[] | Promise<Remote[]>;
-}
-
 export class Model {
 
 	private _onDidOpenRepository = new EventEmitter<Repository>();
@@ -85,7 +74,7 @@ export class Model {
 		this._onDidChangeState.fire(state);
 	}
 
-	private remoteProviders = new Set<RemoteProvider>();
+	private remoteProviders = new Set<RemoteSourceProvider>();
 
 	private disposables: Disposable[] = [];
 
@@ -460,12 +449,12 @@ export class Model {
 		return undefined;
 	}
 
-	registerRemoteProvider(provider: RemoteProvider): Disposable {
+	registerRemoteSourceProvider(provider: RemoteSourceProvider): Disposable {
 		this.remoteProviders.add(provider);
 		return toDisposable(() => this.remoteProviders.delete(provider));
 	}
 
-	getRemoteProviders(): RemoteProvider[] {
+	getRemoteProviders(): RemoteSourceProvider[] {
 		return [...this.remoteProviders.values()];
 	}