@sussudio/platform
Version:
Internal APIs for VS Code's service injection the base services.
207 lines (205 loc) • 8.94 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 '@sussudio/base/common/cancellation.mjs';
import { IStringDictionary } from '@sussudio/base/common/collections.mjs';
import { Disposable } from '@sussudio/base/common/lifecycle.mjs';
import { URI } from '@sussudio/base/common/uri.mjs';
import { IDownloadService } from '../../download/common/download.mjs';
import { INativeEnvironmentService } from '../../environment/common/environment.mjs';
import {
AbstractExtensionManagementService,
AbstractExtensionTask,
ExtensionVerificationStatus,
IInstallExtensionTask,
InstallExtensionTaskOptions,
IUninstallExtensionTask,
UninstallExtensionTaskOptions,
} from '../common/abstractExtensionManagementService.mjs';
import {
IExtensionGalleryService,
IExtensionIdentifier,
IExtensionManagementService,
IGalleryExtension,
IGalleryMetadata,
ILocalExtension,
InstallOperation,
Metadata,
InstallOptions,
InstallVSIXOptions,
} from '../common/extensionManagement.mjs';
import { ExtensionKey } from '../common/extensionManagementUtil.mjs';
import { IExtensionsProfileScannerService } from '../common/extensionsProfileScannerService.mjs';
import { IExtensionsScannerService, IScannedExtension } from '../common/extensionsScannerService.mjs';
import { ExtensionsDownloader } from './extensionDownloader.mjs';
import { ExtensionType, IExtension, IExtensionManifest, TargetPlatform } from '../../extensions/common/extensions.mjs';
import { IFileService } from '../../files/common/files.mjs';
import { IInstantiationService } from '../../instantiation/common/instantiation.mjs';
import { ILogService } from '../../log/common/log.mjs';
import { IProductService } from '../../product/common/productService.mjs';
import { ITelemetryService } from '../../telemetry/common/telemetry.mjs';
import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.mjs';
import { IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.mjs';
interface InstallableExtension {
zipPath: string;
key: ExtensionKey;
metadata: Metadata;
}
export declare const INativeServerExtensionManagementService: import('../../instantiation/common/instantiation.mjs').ServiceIdentifier<INativeServerExtensionManagementService>;
export interface INativeServerExtensionManagementService extends IExtensionManagementService {
readonly _serviceBrand: undefined;
markAsUninstalled(...extensions: IExtension[]): Promise<void>;
removeUninstalledExtensions(): Promise<void>;
getAllUserInstalled(): Promise<ILocalExtension[]>;
}
export declare class ExtensionManagementService
extends AbstractExtensionManagementService
implements INativeServerExtensionManagementService
{
private readonly extensionsScannerService;
private readonly extensionsProfileScannerService;
private downloadService;
private readonly fileService;
private readonly uriIdentityService;
private readonly extensionsScanner;
private readonly manifestCache;
private readonly extensionsDownloader;
private readonly installGalleryExtensionsTasks;
constructor(
galleryService: IExtensionGalleryService,
telemetryService: ITelemetryService,
logService: ILogService,
environmentService: INativeEnvironmentService,
extensionsScannerService: IExtensionsScannerService,
extensionsProfileScannerService: IExtensionsProfileScannerService,
downloadService: IDownloadService,
instantiationService: IInstantiationService,
fileService: IFileService,
productService: IProductService,
uriIdentityService: IUriIdentityService,
userDataProfilesService: IUserDataProfilesService,
);
private _targetPlatformPromise;
getTargetPlatform(): Promise<TargetPlatform>;
zip(extension: ILocalExtension): Promise<URI>;
unzip(zipLocation: URI): Promise<IExtensionIdentifier>;
getManifest(vsix: URI): Promise<IExtensionManifest>;
getInstalled(type?: ExtensionType, profileLocation?: URI): Promise<ILocalExtension[]>;
getAllUserInstalled(): Promise<ILocalExtension[]>;
install(vsix: URI, options?: InstallVSIXOptions): Promise<ILocalExtension>;
installFromLocation(location: URI, profileLocation: URI): Promise<ILocalExtension>;
getMetadata(extension: ILocalExtension): Promise<Metadata | undefined>;
updateMetadata(local: ILocalExtension, metadata: IGalleryMetadata): Promise<ILocalExtension>;
updateExtensionScope(local: ILocalExtension, isMachineScoped: boolean): Promise<ILocalExtension>;
reinstallFromGallery(extension: ILocalExtension): Promise<ILocalExtension>;
markAsUninstalled(...extensions: IExtension[]): Promise<void>;
removeUninstalledExtensions(): Promise<void>;
download(extension: IGalleryExtension, operation: InstallOperation): Promise<URI>;
private downloadVsix;
protected getCurrentExtensionsManifestLocation(): URI;
protected createInstallExtensionTask(
manifest: IExtensionManifest,
extension: URI | IGalleryExtension,
options: InstallExtensionTaskOptions,
): IInstallExtensionTask;
protected createUninstallExtensionTask(
extension: ILocalExtension,
options: UninstallExtensionTaskOptions,
): IUninstallExtensionTask;
private collectFiles;
private onDidChangeExtensionsFromAnotherSource;
private readonly knownDirectories;
private watchForExtensionsNotInstalledBySystem;
private onDidFilesChange;
private addExtensionsToProfile;
}
export declare class ExtensionsScanner extends Disposable {
private readonly beforeRemovingExtension;
private readonly fileService;
private readonly extensionsScannerService;
private readonly logService;
private readonly uninstalledPath;
private readonly uninstalledFileLimiter;
private readonly _onExtract;
readonly onExtract: import('@sussudio/base/common/event.mjs').Event<URI>;
constructor(
beforeRemovingExtension: (e: ILocalExtension) => Promise<void>,
fileService: IFileService,
extensionsScannerService: IExtensionsScannerService,
logService: ILogService,
);
cleanUp(): Promise<void>;
scanExtensions(type: ExtensionType | null, profileLocation: URI | undefined): Promise<ILocalExtension[]>;
scanAllUserExtensions(excludeOutdated: boolean): Promise<ILocalExtension[]>;
scanUserExtensionAtLocation(location: URI): Promise<ILocalExtension | null>;
extractUserExtension(
extensionKey: ExtensionKey,
zipPath: string,
metadata: Metadata,
token: CancellationToken,
): Promise<ILocalExtension>;
updateMetadata(local: ILocalExtension, metadata: Partial<Metadata>): Promise<ILocalExtension>;
getUninstalledExtensions(): Promise<IStringDictionary<boolean>>;
setUninstalled(...extensions: IExtension[]): Promise<void>;
setInstalled(extensionKey: ExtensionKey): Promise<ILocalExtension | null>;
removeExtension(extension: ILocalExtension | IScannedExtension, type: string): Promise<void>;
removeUninstalledExtension(extension: ILocalExtension | IScannedExtension): Promise<void>;
private withUninstalledExtensions;
private extractAtLocation;
private rename;
private scanLocalExtension;
private toLocalExtension;
private removeUninstalledExtensions;
private joinErrors;
}
declare abstract class InstallExtensionTask
extends AbstractExtensionTask<{
local: ILocalExtension;
metadata: Metadata;
}>
implements IInstallExtensionTask
{
readonly identifier: IExtensionIdentifier;
readonly source: URI | IGalleryExtension;
protected readonly options: InstallOptions;
protected readonly extensionsScanner: ExtensionsScanner;
protected readonly logService: ILogService;
protected _verificationStatus: ExtensionVerificationStatus;
get verificationStatus(): ExtensionVerificationStatus;
protected _operation: InstallOperation;
get operation(): InstallOperation;
constructor(
identifier: IExtensionIdentifier,
source: URI | IGalleryExtension,
options: InstallOptions,
extensionsScanner: ExtensionsScanner,
logService: ILogService,
);
protected installExtension(
installableExtension: InstallableExtension,
token: CancellationToken,
): Promise<ILocalExtension>;
protected unsetUninstalledAndGetLocal(extensionKey: ExtensionKey): Promise<ILocalExtension | null>;
private isUninstalled;
private extract;
}
export declare class InstallGalleryExtensionTask extends InstallExtensionTask {
private readonly manifest;
private readonly gallery;
private readonly extensionsDownloader;
constructor(
manifest: IExtensionManifest,
gallery: IGalleryExtension,
options: InstallOptions,
extensionsDownloader: ExtensionsDownloader,
extensionsScanner: ExtensionsScanner,
logService: ILogService,
);
protected doRun(token: CancellationToken): Promise<{
local: ILocalExtension;
metadata: Metadata;
}>;
protected validateManifest(zipPath: string): Promise<void>;
}
export {};