sussudio
Version:
An unofficial VS Code Internal API
117 lines (116 loc) • 7.07 kB
text/typescript
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import { CancellationToken } from "../../../base/common/cancellation.mjs";
import { Emitter, Event } from "../../../base/common/event.mjs";
import { Disposable } from "../../../base/common/lifecycle.mjs";
import { URI } from "../../../base/common/uri.mjs";
import { IExtensionGalleryService, IExtensionIdentifier, IExtensionManagementParticipant, IGalleryExtension, IGalleryMetadata, ILocalExtension, InstallOperation, IExtensionsControlManifest, InstallOptions, InstallVSIXOptions, UninstallOptions, Metadata, InstallExtensionEvent, DidUninstallExtensionEvent, InstallExtensionResult, UninstallExtensionEvent, IExtensionManagementService } from "./extensionManagement.mjs";
import { ExtensionType, IExtensionManifest, TargetPlatform } from "../../extensions/common/extensions.mjs";
import { ILogService } from "../../log/common/log.mjs";
import { IProductService } from "../../product/common/productService.mjs";
import { ITelemetryService } from "../../telemetry/common/telemetry.mjs";
import { IUserDataProfilesService } from "../../userDataProfile/common/userDataProfile.mjs";
export declare const enum ExtensionVerificationStatus {
'Verified' = "Verified",
'Unverified' = "Unverified",
'UnknownError' = "UnknownError"
}
export type InstallExtensionTaskOptions = InstallOptions & InstallVSIXOptions & {
readonly profileLocation: URI;
};
export interface IInstallExtensionTask {
readonly identifier: IExtensionIdentifier;
readonly source: IGalleryExtension | URI;
readonly operation: InstallOperation;
readonly verificationStatus?: ExtensionVerificationStatus;
run(): Promise<{
local: ILocalExtension;
metadata: Metadata;
}>;
waitUntilTaskIsFinished(): Promise<{
local: ILocalExtension;
metadata: Metadata;
}>;
cancel(): void;
}
export type UninstallExtensionTaskOptions = UninstallOptions & {
readonly profileLocation: URI;
};
export interface IUninstallExtensionTask {
readonly extension: ILocalExtension;
run(): Promise<void>;
waitUntilTaskIsFinished(): Promise<void>;
cancel(): void;
}
export declare abstract class AbstractExtensionManagementService extends Disposable implements IExtensionManagementService {
protected readonly galleryService: IExtensionGalleryService;
protected readonly telemetryService: ITelemetryService;
protected readonly logService: ILogService;
protected readonly productService: IProductService;
protected readonly userDataProfilesService: IUserDataProfilesService;
readonly _serviceBrand: undefined;
private extensionsControlManifest;
private lastReportTimestamp;
private readonly installingExtensions;
private readonly uninstallingExtensions;
private readonly _onInstallExtension;
get onInstallExtension(): Event<InstallExtensionEvent>;
protected readonly _onDidInstallExtensions: Emitter<InstallExtensionResult[]>;
get onDidInstallExtensions(): Event<InstallExtensionResult[]>;
protected readonly _onUninstallExtension: Emitter<UninstallExtensionEvent>;
get onUninstallExtension(): Event<UninstallExtensionEvent>;
protected _onDidUninstallExtension: Emitter<DidUninstallExtensionEvent>;
get onDidUninstallExtension(): Event<DidUninstallExtensionEvent>;
private readonly participants;
constructor(galleryService: IExtensionGalleryService, telemetryService: ITelemetryService, logService: ILogService, productService: IProductService, userDataProfilesService: IUserDataProfilesService);
canInstall(extension: IGalleryExtension): Promise<boolean>;
installFromGallery(extension: IGalleryExtension, options?: InstallOptions): Promise<ILocalExtension>;
uninstall(extension: ILocalExtension, options?: UninstallOptions): Promise<void>;
getExtensionsControlManifest(): Promise<IExtensionsControlManifest>;
registerParticipant(participant: IExtensionManagementParticipant): void;
protected installExtension(manifest: IExtensionManifest, extension: URI | IGalleryExtension, options: InstallOptions & InstallVSIXOptions): Promise<ILocalExtension>;
private canWaitForTask;
private joinAllSettled;
private getAllDepsAndPackExtensions;
private checkAndGetCompatibleVersion;
protected getCompatibleVersion(extension: IGalleryExtension, sameVersion: boolean, includePreRelease: boolean): Promise<IGalleryExtension | null>;
private uninstallExtension;
private checkForDependents;
private getDependentsErrorMessage;
private getAllPackExtensionsToUninstall;
private getDependents;
private updateControlCache;
abstract getTargetPlatform(): Promise<TargetPlatform>;
abstract zip(extension: ILocalExtension): Promise<URI>;
abstract unzip(zipLocation: URI): Promise<IExtensionIdentifier>;
abstract getManifest(vsix: URI): Promise<IExtensionManifest>;
abstract install(vsix: URI, options?: InstallVSIXOptions): Promise<ILocalExtension>;
abstract installFromLocation(location: URI, profileLocation: URI): Promise<ILocalExtension>;
abstract getInstalled(type?: ExtensionType, profileLocation?: URI): Promise<ILocalExtension[]>;
abstract download(extension: IGalleryExtension, operation: InstallOperation): Promise<URI>;
abstract reinstallFromGallery(extension: ILocalExtension): Promise<ILocalExtension>;
abstract getMetadata(extension: ILocalExtension): Promise<Metadata | undefined>;
abstract updateMetadata(local: ILocalExtension, metadata: IGalleryMetadata): Promise<ILocalExtension>;
abstract updateExtensionScope(local: ILocalExtension, isMachineScoped: boolean): Promise<ILocalExtension>;
protected abstract getCurrentExtensionsManifestLocation(): URI;
protected abstract createInstallExtensionTask(manifest: IExtensionManifest, extension: URI | IGalleryExtension, options: InstallExtensionTaskOptions): IInstallExtensionTask;
protected abstract createUninstallExtensionTask(extension: ILocalExtension, options: UninstallExtensionTaskOptions): IUninstallExtensionTask;
}
export declare function joinErrors(errorOrErrors: (Error | string) | (Array<Error | string>)): Error;
export declare function reportTelemetry(telemetryService: ITelemetryService, eventName: string, { extensionData, verificationStatus, duration, error, durationSinceUpdate }: {
extensionData: any;
verificationStatus?: ExtensionVerificationStatus;
duration?: number;
durationSinceUpdate?: number;
error?: Error;
}): void;
export declare abstract class AbstractExtensionTask<T> {
private readonly barrier;
private cancellablePromise;
waitUntilTaskIsFinished(): Promise<T>;
run(): Promise<T>;
cancel(): void;
protected abstract doRun(token: CancellationToken): Promise<T>;
}