@sussudio/platform/userDataSync/common/extensionsSync.d.mts

Internal APIs for VS Code's service injection the base services.

/*---------------------------------------------------------------------------------------------
 *  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 { URI } from '@sussudio/base/common/uri.mjs';
import { IConfigurationService } from '../../configuration/common/configuration.mjs';
import { IEnvironmentService } from '../../environment/common/environment.mjs';
import {
	IExtensionGalleryService,
	IExtensionManagementService,
	ILocalExtension,
} from '../../extensionManagement/common/extensionManagement.mjs';
import { IExtensionStorageService } from '../../extensionManagement/common/extensionStorage.mjs';
import { IExtensionIdentifier } 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 { IStorageService } from '../../storage/common/storage.mjs';
import { ITelemetryService } from '../../telemetry/common/telemetry.mjs';
import { IUriIdentityService } from '../../uriIdentity/common/uriIdentity.mjs';
import { IUserDataProfile, IUserDataProfilesService } from '../../userDataProfile/common/userDataProfile.mjs';
import {
	AbstractInitializer,
	AbstractSynchroniser,
	IAcceptResult,
	IMergeResult,
	IResourcePreview,
} from './abstractSynchronizer.mjs';
import { IMergeResult as IExtensionMergeResult } from './extensionsMerge.mjs';
import { IIgnoredExtensionsManagementService } from './ignoredExtensions.mjs';
import {
	IRemoteUserData,
	ISyncData,
	ISyncExtension,
	ISyncExtensionWithVersion,
	IUserDataSyncBackupStoreService,
	IUserDataSynchroniser,
	IUserDataSyncLogService,
	IUserDataSyncEnablementService,
	IUserDataSyncStoreService,
} from './userDataSync.mjs';
import { IUserDataProfileStorageService } from '../../userDataProfile/common/userDataProfileStorageService.mjs';
type IExtensionResourceMergeResult = IAcceptResult & IExtensionMergeResult;
interface IExtensionResourcePreview extends IResourcePreview {
	readonly localExtensions: ISyncExtensionWithVersion[];
	readonly remoteExtensions: ISyncExtension[] | null;
	readonly skippedExtensions: ISyncExtension[];
	readonly builtinExtensions: IExtensionIdentifier[];
	readonly previewResult: IExtensionResourceMergeResult;
}
interface ILastSyncUserData extends IRemoteUserData {
	skippedExtensions: ISyncExtension[] | undefined;
	builtinExtensions: IExtensionIdentifier[] | undefined;
}
export declare function parseExtensions(syncData: ISyncData): ISyncExtension[];
export declare function stringify(extensions: ISyncExtension[], format: boolean): string;
export declare class ExtensionsSynchroniser extends AbstractSynchroniser implements IUserDataSynchroniser {
	private readonly extensionManagementService;
	private readonly ignoredExtensionsManagementService;
	private readonly instantiationService;
	protected readonly version: number;
	private readonly previewResource;
	private readonly baseResource;
	private readonly localResource;
	private readonly remoteResource;
	private readonly acceptedResource;
	private readonly localExtensionsProvider;
	constructor(
		profile: IUserDataProfile,
		collection: string | undefined,
		environmentService: IEnvironmentService,
		fileService: IFileService,
		storageService: IStorageService,
		userDataSyncStoreService: IUserDataSyncStoreService,
		userDataSyncBackupStoreService: IUserDataSyncBackupStoreService,
		extensionManagementService: IExtensionManagementService,
		ignoredExtensionsManagementService: IIgnoredExtensionsManagementService,
		logService: IUserDataSyncLogService,
		configurationService: IConfigurationService,
		userDataSyncEnablementService: IUserDataSyncEnablementService,
		telemetryService: ITelemetryService,
		extensionStorageService: IExtensionStorageService,
		uriIdentityService: IUriIdentityService,
		userDataProfileStorageService: IUserDataProfileStorageService,
		instantiationService: IInstantiationService,
	);
	protected generateSyncPreview(
		remoteUserData: IRemoteUserData,
		lastSyncUserData: ILastSyncUserData | null,
	): Promise<IExtensionResourcePreview[]>;
	protected hasRemoteChanged(lastSyncUserData: ILastSyncUserData): Promise<boolean>;
	private getPreviewContent;
	protected getMergeResult(resourcePreview: IExtensionResourcePreview, token: CancellationToken): Promise<IMergeResult>;
	protected getAcceptResult(
		resourcePreview: IExtensionResourcePreview,
		resource: URI,
		content: string | null | undefined,
		token: CancellationToken,
	): Promise<IExtensionResourceMergeResult>;
	private acceptLocal;
	private acceptRemote;
	protected applyResult(
		remoteUserData: IRemoteUserData,
		lastSyncUserData: IRemoteUserData | null,
		resourcePreviews: [IExtensionResourcePreview, IExtensionResourceMergeResult][],
		force: boolean,
	): Promise<void>;
	resolveContent(uri: URI): Promise<string | null>;
	private stringify;
	hasLocalData(): Promise<boolean>;
}
export declare class LocalExtensionsProvider {
	private readonly extensionManagementService;
	private readonly userDataProfileStorageService;
	private readonly extensionGalleryService;
	private readonly ignoredExtensionsManagementService;
	private readonly instantiationService;
	private readonly logService;
	constructor(
		extensionManagementService: IExtensionManagementService,
		userDataProfileStorageService: IUserDataProfileStorageService,
		extensionGalleryService: IExtensionGalleryService,
		ignoredExtensionsManagementService: IIgnoredExtensionsManagementService,
		instantiationService: IInstantiationService,
		logService: IUserDataSyncLogService,
	);
	getLocalExtensions(profile: IUserDataProfile): Promise<{
		localExtensions: ISyncExtensionWithVersion[];
		ignoredExtensions: string[];
	}>;
	updateLocalExtensions(
		added: ISyncExtension[],
		removed: IExtensionIdentifier[],
		updated: ISyncExtension[],
		skippedExtensions: ISyncExtension[],
		profile: IUserDataProfile,
	): Promise<ISyncExtension[]>;
	private updateExtensionState;
	private withProfileScopedServices;
}
export interface IExtensionsInitializerPreviewResult {
	readonly installedExtensions: ILocalExtension[];
	readonly disabledExtensions: IExtensionIdentifier[];
	readonly newExtensions: (IExtensionIdentifier & {
		preRelease: boolean;
	})[];
	readonly remoteExtensions: ISyncExtension[];
}
export declare abstract class AbstractExtensionsInitializer extends AbstractInitializer {
	protected readonly extensionManagementService: IExtensionManagementService;
	private readonly ignoredExtensionsManagementService;
	constructor(
		extensionManagementService: IExtensionManagementService,
		ignoredExtensionsManagementService: IIgnoredExtensionsManagementService,
		fileService: IFileService,
		userDataProfilesService: IUserDataProfilesService,
		environmentService: IEnvironmentService,
		logService: ILogService,
		storageService: IStorageService,
		uriIdentityService: IUriIdentityService,
	);
	protected parseExtensions(remoteUserData: IRemoteUserData): Promise<ISyncExtension[] | null>;
	protected generatePreview(
		remoteExtensions: ISyncExtension[],
		localExtensions: ILocalExtension[],
	): IExtensionsInitializerPreviewResult;
}
export {};