@codingame/monaco-vscode-working-copy-service-override 4.0.0 → 4.1.0

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyHistoryService.js

@@ -1,618 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { Emitter, Event } from 'vscode/vscode/vs/base/common/event';
-import { assertIsDefined } from 'vscode/vscode/vs/base/common/types';
-import { Registry } from 'vscode/vscode/vs/platform/registry/common/platform';
-import { Extensions } from 'vscode/vscode/vs/workbench/common/contributions';
-import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
-import { WorkingCopyHistoryTracker } from './workingCopyHistoryTracker.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { MAX_PARALLEL_HISTORY_IO_OPS } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory';
-import { FileOperationError, IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { Limiter, DeferredPromise, RunOnceScheduler } from 'vscode/vscode/vs/base/common/async';
-import { extname, joinPath, isEqual, dirname } from 'vscode/vscode/vs/base/common/resources';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
-import { hash } from 'vscode/vscode/vs/base/common/hash';
-import { randomPath, indexOfPath } from 'vscode/vscode/vs/base/common/extpath';
-import { CancellationToken, CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
-import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
-import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
-import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
-import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration';
-import { lastOrDefault } from 'vscode/vscode/vs/base/common/arrays';
-import { escapeRegExpCharacters } from 'vscode/vscode/vs/base/common/strings';
-
-var WorkingCopyHistoryService_1, NativeWorkingCopyHistoryService_1;
-class WorkingCopyHistoryModel {
-    static { this.ENTRIES_FILE = 'entries.json'; }
-    static { this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('default.source', ( localizeWithPath(
-        'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
-        'default.source',
-        "File Saved"
-    ))); }
-    static { this.SETTINGS = {
-        MAX_ENTRIES: 'workbench.localHistory.maxFileEntries',
-        MERGE_PERIOD: 'workbench.localHistory.mergeWindow'
-    }; }
-    constructor(workingCopyResource, historyHome, entryAddedEmitter, entryChangedEmitter, entryReplacedEmitter, entryRemovedEmitter, options, fileService, labelService, logService, configurationService) {
-        this.historyHome = historyHome;
-        this.entryAddedEmitter = entryAddedEmitter;
-        this.entryChangedEmitter = entryChangedEmitter;
-        this.entryReplacedEmitter = entryReplacedEmitter;
-        this.entryRemovedEmitter = entryRemovedEmitter;
-        this.options = options;
-        this.fileService = fileService;
-        this.labelService = labelService;
-        this.logService = logService;
-        this.configurationService = configurationService;
-        this.entries = [];
-        this.whenResolved = undefined;
-        this.workingCopyResource = undefined;
-        this.workingCopyName = undefined;
-        this.historyEntriesFolder = undefined;
-        this.historyEntriesListingFile = undefined;
-        this.historyEntriesNameMatcher = undefined;
-        this.versionId = 0;
-        this.storedVersionId = this.versionId;
-        this.storeLimiter = ( new Limiter(1));
-        this.setWorkingCopy(workingCopyResource);
-    }
-    setWorkingCopy(workingCopyResource) {
-        this.workingCopyResource = workingCopyResource;
-        this.workingCopyName = this.labelService.getUriBasenameLabel(workingCopyResource);
-        this.historyEntriesNameMatcher = ( new RegExp(`[A-Za-z0-9]{4}${escapeRegExpCharacters(extname(workingCopyResource))}`));
-        this.historyEntriesFolder = this.toHistoryEntriesFolder(this.historyHome, workingCopyResource);
-        this.historyEntriesListingFile = joinPath(this.historyEntriesFolder, WorkingCopyHistoryModel.ENTRIES_FILE);
-        this.entries = [];
-        this.whenResolved = undefined;
-    }
-    toHistoryEntriesFolder(historyHome, workingCopyResource) {
-        return joinPath(historyHome, ( hash(( workingCopyResource.toString())).toString(16)));
-    }
-    async addEntry(source = WorkingCopyHistoryModel.FILE_SAVED_SOURCE, timestamp = Date.now(), token) {
-        let entryToReplace = undefined;
-        const lastEntry = lastOrDefault(this.entries);
-        if (lastEntry && lastEntry.source === source) {
-            const configuredReplaceInterval = this.configurationService.getValue(WorkingCopyHistoryModel.SETTINGS.MERGE_PERIOD, { resource: this.workingCopyResource });
-            if (timestamp - lastEntry.timestamp <= ((configuredReplaceInterval * 1000) )) {
-                entryToReplace = lastEntry;
-            }
-        }
-        let entry;
-        if (entryToReplace) {
-            entry = await this.doReplaceEntry(entryToReplace, timestamp, token);
-        }
-        else {
-            entry = await this.doAddEntry(source, timestamp, token);
-        }
-        if (this.options.flushOnChange && !token.isCancellationRequested) {
-            await this.store(token);
-        }
-        return entry;
-    }
-    async doAddEntry(source, timestamp, token) {
-        const workingCopyResource = assertIsDefined(this.workingCopyResource);
-        const workingCopyName = assertIsDefined(this.workingCopyName);
-        const historyEntriesFolder = assertIsDefined(this.historyEntriesFolder);
-        const id = `${randomPath(undefined, undefined, 4)}${extname(workingCopyResource)}`;
-        const location = joinPath(historyEntriesFolder, id);
-        await this.fileService.cloneFile(workingCopyResource, location);
-        const entry = {
-            id,
-            workingCopy: { resource: workingCopyResource, name: workingCopyName },
-            location,
-            timestamp,
-            source
-        };
-        this.entries.push(entry);
-        this.versionId++;
-        this.entryAddedEmitter.fire({ entry });
-        return entry;
-    }
-    async doReplaceEntry(entry, timestamp, token) {
-        const workingCopyResource = assertIsDefined(this.workingCopyResource);
-        await this.fileService.cloneFile(workingCopyResource, entry.location);
-        entry.timestamp = timestamp;
-        this.versionId++;
-        this.entryReplacedEmitter.fire({ entry });
-        return entry;
-    }
-    async removeEntry(entry, token) {
-        await this.resolveEntriesOnce();
-        if (token.isCancellationRequested) {
-            return false;
-        }
-        const index = this.entries.indexOf(entry);
-        if (index === -1) {
-            return false;
-        }
-        await this.deleteEntry(entry);
-        this.entries.splice(index, 1);
-        this.versionId++;
-        this.entryRemovedEmitter.fire({ entry });
-        if (this.options.flushOnChange && !token.isCancellationRequested) {
-            await this.store(token);
-        }
-        return true;
-    }
-    async updateEntry(entry, properties, token) {
-        await this.resolveEntriesOnce();
-        if (token.isCancellationRequested) {
-            return;
-        }
-        const index = this.entries.indexOf(entry);
-        if (index === -1) {
-            return;
-        }
-        entry.source = properties.source;
-        this.versionId++;
-        this.entryChangedEmitter.fire({ entry });
-        if (this.options.flushOnChange && !token.isCancellationRequested) {
-            await this.store(token);
-        }
-    }
-    async getEntries() {
-        await this.resolveEntriesOnce();
-        const configuredMaxEntries = this.configurationService.getValue(WorkingCopyHistoryModel.SETTINGS.MAX_ENTRIES, { resource: this.workingCopyResource });
-        if (this.entries.length > configuredMaxEntries) {
-            return this.entries.slice(this.entries.length - configuredMaxEntries);
-        }
-        return this.entries;
-    }
-    async hasEntries(skipResolve) {
-        if (!skipResolve) {
-            await this.resolveEntriesOnce();
-        }
-        return this.entries.length > 0;
-    }
-    resolveEntriesOnce() {
-        if (!this.whenResolved) {
-            this.whenResolved = this.doResolveEntries();
-        }
-        return this.whenResolved;
-    }
-    async doResolveEntries() {
-        const entries = await this.resolveEntriesFromDisk();
-        for (const entry of this.entries) {
-            entries.set(entry.id, entry);
-        }
-        this.entries = Array.from(( entries.values())).sort((entryA, entryB) => entryA.timestamp - entryB.timestamp);
-    }
-    async resolveEntriesFromDisk() {
-        const workingCopyResource = assertIsDefined(this.workingCopyResource);
-        const workingCopyName = assertIsDefined(this.workingCopyName);
-        const [entryListing, entryStats] = await Promise.all([
-            this.readEntriesFile(),
-            this.readEntriesFolder()
-        ]);
-        const entries = ( new Map());
-        if (entryStats) {
-            for (const entryStat of entryStats) {
-                entries.set(entryStat.name, {
-                    id: entryStat.name,
-                    workingCopy: { resource: workingCopyResource, name: workingCopyName },
-                    location: entryStat.resource,
-                    timestamp: entryStat.mtime,
-                    source: WorkingCopyHistoryModel.FILE_SAVED_SOURCE
-                });
-            }
-        }
-        if (entryListing) {
-            for (const entry of entryListing.entries) {
-                const existingEntry = entries.get(entry.id);
-                if (existingEntry) {
-                    entries.set(entry.id, {
-                        ...existingEntry,
-                        timestamp: entry.timestamp,
-                        source: entry.source ?? existingEntry.source
-                    });
-                }
-            }
-        }
-        return entries;
-    }
-    async moveEntries(targetWorkingCopyResource, source, token) {
-        await this.store(token);
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
-        const sourceHistoryEntriesFolder = assertIsDefined(this.historyEntriesFolder);
-        const targetHistoryFolder = this.toHistoryEntriesFolder(this.historyHome, targetWorkingCopyResource);
-        try {
-            await this.fileService.move(sourceHistoryEntriesFolder, targetHistoryFolder, true);
-        }
-        catch (error) {
-            if (!((error instanceof FileOperationError && error.fileOperationResult === 1) )) {
-                this.traceError(error);
-            }
-        }
-        this.setWorkingCopy(targetWorkingCopyResource);
-        await this.addEntry(source, undefined, token);
-        await this.store(token);
-    }
-    async store(token) {
-        if (!this.shouldStore()) {
-            return;
-        }
-        await this.storeLimiter.queue(async () => {
-            if (token.isCancellationRequested || !this.shouldStore()) {
-                return;
-            }
-            return this.doStore(token);
-        });
-    }
-    shouldStore() {
-        return this.storedVersionId !== this.versionId;
-    }
-    async doStore(token) {
-        const historyEntriesFolder = assertIsDefined(this.historyEntriesFolder);
-        await this.resolveEntriesOnce();
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
-        await this.cleanUpEntries();
-        const storedVersion = this.versionId;
-        if (this.entries.length === 0) {
-            try {
-                await this.fileService.del(historyEntriesFolder, { recursive: true });
-            }
-            catch (error) {
-                this.traceError(error);
-            }
-        }
-        else {
-            await this.writeEntriesFile();
-        }
-        this.storedVersionId = storedVersion;
-    }
-    async cleanUpEntries() {
-        const configuredMaxEntries = this.configurationService.getValue(WorkingCopyHistoryModel.SETTINGS.MAX_ENTRIES, { resource: this.workingCopyResource });
-        if (this.entries.length <= configuredMaxEntries) {
-            return;
-        }
-        const entriesToDelete = this.entries.slice(0, this.entries.length - configuredMaxEntries);
-        const entriesToKeep = this.entries.slice(this.entries.length - configuredMaxEntries);
-        for (const entryToDelete of entriesToDelete) {
-            await this.deleteEntry(entryToDelete);
-        }
-        this.entries = entriesToKeep;
-        for (const entry of entriesToDelete) {
-            this.entryRemovedEmitter.fire({ entry });
-        }
-    }
-    async deleteEntry(entry) {
-        try {
-            await this.fileService.del(entry.location);
-        }
-        catch (error) {
-            this.traceError(error);
-        }
-    }
-    async writeEntriesFile() {
-        const workingCopyResource = assertIsDefined(this.workingCopyResource);
-        const historyEntriesListingFile = assertIsDefined(this.historyEntriesListingFile);
-        const serializedModel = {
-            version: 1,
-            resource: ( workingCopyResource.toString()),
-            entries: ( this.entries.map(entry => {
-                return {
-                    id: entry.id,
-                    source: entry.source !== WorkingCopyHistoryModel.FILE_SAVED_SOURCE ? entry.source : undefined,
-                    timestamp: entry.timestamp
-                };
-            }))
-        };
-        await this.fileService.writeFile(historyEntriesListingFile, VSBuffer.fromString(JSON.stringify(serializedModel)));
-    }
-    async readEntriesFile() {
-        const historyEntriesListingFile = assertIsDefined(this.historyEntriesListingFile);
-        let serializedModel = undefined;
-        try {
-            serializedModel = JSON.parse(( (await this.fileService.readFile(historyEntriesListingFile)).value.toString()));
-        }
-        catch (error) {
-            if (!((error instanceof FileOperationError && error.fileOperationResult === 1) )) {
-                this.traceError(error);
-            }
-        }
-        return serializedModel;
-    }
-    async readEntriesFolder() {
-        const historyEntriesFolder = assertIsDefined(this.historyEntriesFolder);
-        const historyEntriesNameMatcher = assertIsDefined(this.historyEntriesNameMatcher);
-        let rawEntries = undefined;
-        try {
-            rawEntries = (await this.fileService.resolve(historyEntriesFolder, { resolveMetadata: true })).children;
-        }
-        catch (error) {
-            if (!((error instanceof FileOperationError && error.fileOperationResult === 1) )) {
-                this.traceError(error);
-            }
-        }
-        if (!rawEntries) {
-            return undefined;
-        }
-        return rawEntries.filter(entry => !isEqual(entry.resource, this.historyEntriesListingFile) &&
-            historyEntriesNameMatcher.test(entry.name)
-        );
-    }
-    traceError(error) {
-        this.logService.trace('[Working Copy History Service]', error);
-    }
-}
-let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposable {
-    static { WorkingCopyHistoryService_1 = this; }
-    static { this.FILE_MOVED_SOURCE = SaveSourceRegistry.registerSource('moved.source', ( localizeWithPath(
-        'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
-        'moved.source',
-        "File Moved"
-    ))); }
-    static { this.FILE_RENAMED_SOURCE = SaveSourceRegistry.registerSource('renamed.source', ( localizeWithPath(
-        'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
-        'renamed.source',
-        "File Renamed"
-    ))); }
-    constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService) {
-        super();
-        this.fileService = fileService;
-        this.remoteAgentService = remoteAgentService;
-        this.environmentService = environmentService;
-        this.uriIdentityService = uriIdentityService;
-        this.labelService = labelService;
-        this.logService = logService;
-        this.configurationService = configurationService;
-        this._onDidAddEntry = this._register(( new Emitter()));
-        this.onDidAddEntry = this._onDidAddEntry.event;
-        this._onDidChangeEntry = this._register(( new Emitter()));
-        this.onDidChangeEntry = this._onDidChangeEntry.event;
-        this._onDidReplaceEntry = this._register(( new Emitter()));
-        this.onDidReplaceEntry = this._onDidReplaceEntry.event;
-        this._onDidMoveEntries = this._register(( new Emitter()));
-        this.onDidMoveEntries = this._onDidMoveEntries.event;
-        this._onDidRemoveEntry = this._register(( new Emitter()));
-        this.onDidRemoveEntry = this._onDidRemoveEntry.event;
-        this._onDidRemoveEntries = this._register(( new Emitter()));
-        this.onDidRemoveEntries = this._onDidRemoveEntries.event;
-        this.localHistoryHome = ( new DeferredPromise());
-        this.models = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
-        this.resolveLocalHistoryHome();
-    }
-    async resolveLocalHistoryHome() {
-        let historyHome = undefined;
-        try {
-            const remoteEnv = await this.remoteAgentService.getEnvironment();
-            if (remoteEnv) {
-                historyHome = remoteEnv.localHistoryHome;
-            }
-        }
-        catch (error) {
-            this.logService.trace(error);
-        }
-        if (!historyHome) {
-            historyHome = this.environmentService.localHistoryHome;
-        }
-        this.localHistoryHome.complete(historyHome);
-    }
-    async moveEntries(source, target) {
-        const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
-        const promises = [];
-        for (const [resource, model] of this.models) {
-            if (!this.uriIdentityService.extUri.isEqualOrParent(resource, source)) {
-                continue;
-            }
-            let targetResource;
-            if (this.uriIdentityService.extUri.isEqual(source, resource)) {
-                targetResource = target;
-            }
-            else {
-                const index = indexOfPath(resource.path, source.path);
-                targetResource = joinPath(target, resource.path.substr(index + source.path.length + 1));
-            }
-            let saveSource;
-            if (this.uriIdentityService.extUri.isEqual(dirname(resource), dirname(targetResource))) {
-                saveSource = WorkingCopyHistoryService_1.FILE_RENAMED_SOURCE;
-            }
-            else {
-                saveSource = WorkingCopyHistoryService_1.FILE_MOVED_SOURCE;
-            }
-            promises.push(limiter.queue(() => this.doMoveEntries(model, saveSource, resource, targetResource)));
-        }
-        if (!promises.length) {
-            return [];
-        }
-        const resources = await Promise.all(promises);
-        this._onDidMoveEntries.fire();
-        return resources;
-    }
-    async doMoveEntries(model, source, sourceWorkingCopyResource, targetWorkingCopyResource) {
-        await model.moveEntries(targetWorkingCopyResource, source, CancellationToken.None);
-        this.models.delete(sourceWorkingCopyResource);
-        this.models.set(targetWorkingCopyResource, model);
-        return targetWorkingCopyResource;
-    }
-    async addEntry({ resource, source, timestamp }, token) {
-        if (!this.fileService.hasProvider(resource)) {
-            return undefined;
-        }
-        const model = await this.getModel(resource);
-        if (token.isCancellationRequested) {
-            return undefined;
-        }
-        return model.addEntry(source, timestamp, token);
-    }
-    async updateEntry(entry, properties, token) {
-        const model = await this.getModel(entry.workingCopy.resource);
-        if (token.isCancellationRequested) {
-            return;
-        }
-        return model.updateEntry(entry, properties, token);
-    }
-    async removeEntry(entry, token) {
-        const model = await this.getModel(entry.workingCopy.resource);
-        if (token.isCancellationRequested) {
-            return false;
-        }
-        return model.removeEntry(entry, token);
-    }
-    async removeAll(token) {
-        const historyHome = await this.localHistoryHome.p;
-        if (token.isCancellationRequested) {
-            return;
-        }
-        this.models.clear();
-        await this.fileService.del(historyHome, { recursive: true });
-        this._onDidRemoveEntries.fire();
-    }
-    async getEntries(resource, token) {
-        const model = await this.getModel(resource);
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        const entries = await model.getEntries();
-        return entries ?? [];
-    }
-    async getAll(token) {
-        const historyHome = await this.localHistoryHome.p;
-        if (token.isCancellationRequested) {
-            return [];
-        }
-        const all = ( new ResourceMap());
-        for (const [resource, model] of this.models) {
-            const hasInMemoryEntries = await model.hasEntries(true );
-            if (hasInMemoryEntries) {
-                all.set(resource, true);
-            }
-        }
-        try {
-            const resolvedHistoryHome = await this.fileService.resolve(historyHome);
-            if (resolvedHistoryHome.children) {
-                const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
-                const promises = [];
-                for (const child of resolvedHistoryHome.children) {
-                    promises.push(limiter.queue(async () => {
-                        if (token.isCancellationRequested) {
-                            return;
-                        }
-                        try {
-                            const serializedModel = JSON.parse(( (await this.fileService.readFile(joinPath(child.resource, WorkingCopyHistoryModel.ENTRIES_FILE))).value.toString()));
-                            if (serializedModel.entries.length > 0) {
-                                all.set(( URI.parse(serializedModel.resource)), true);
-                            }
-                        }
-                        catch (error) {
-                        }
-                    }));
-                }
-                await Promise.all(promises);
-            }
-        }
-        catch (error) {
-        }
-        return Array.from(( all.keys()));
-    }
-    async getModel(resource) {
-        const historyHome = await this.localHistoryHome.p;
-        let model = this.models.get(resource);
-        if (!model) {
-            model = ( new WorkingCopyHistoryModel(
-                resource,
-                historyHome,
-                this._onDidAddEntry,
-                this._onDidChangeEntry,
-                this._onDidReplaceEntry,
-                this._onDidRemoveEntry,
-                this.getModelOptions(),
-                this.fileService,
-                this.labelService,
-                this.logService,
-                this.configurationService
-            ));
-            this.models.set(resource, model);
-        }
-        return model;
-    }
-};
-WorkingCopyHistoryService = WorkingCopyHistoryService_1 = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IRemoteAgentService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IUriIdentityService)),
-    ( __param(4, ILabelService)),
-    ( __param(5, ILogService)),
-    ( __param(6, IConfigurationService))
-], WorkingCopyHistoryService));
-let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService extends WorkingCopyHistoryService {
-    static { NativeWorkingCopyHistoryService_1 = this; }
-    static { this.STORE_ALL_INTERVAL = 5 * 60 * 1000; }
-    constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, lifecycleService, logService, configurationService) {
-        super(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService);
-        this.lifecycleService = lifecycleService;
-        this.isRemotelyStored = typeof this.environmentService.remoteAuthority === 'string';
-        this.storeAllCts = this._register(( new CancellationTokenSource()));
-        this.storeAllScheduler = this._register(( new RunOnceScheduler(
-            () => this.storeAll(this.storeAllCts.token),
-            NativeWorkingCopyHistoryService_1.STORE_ALL_INTERVAL
-        )));
-        this.registerListeners();
-    }
-    registerListeners() {
-        if (!this.isRemotelyStored) {
-            this._register(this.lifecycleService.onWillShutdown(e => this.onWillShutdown(e)));
-            this._register(Event.any(this.onDidAddEntry, this.onDidChangeEntry, this.onDidReplaceEntry, this.onDidRemoveEntry)(() => this.onDidChangeModels()));
-        }
-    }
-    getModelOptions() {
-        return { flushOnChange: this.isRemotelyStored  };
-    }
-    onWillShutdown(e) {
-        this.storeAllScheduler.dispose();
-        this.storeAllCts.dispose(true);
-        e.join(this.storeAll(e.token), { id: 'join.workingCopyHistory', label: ( localizeWithPath(
-            'vs/workbench/services/workingCopy/common/workingCopyHistoryService',
-            'join.workingCopyHistory',
-            "Saving local history"
-        )) });
-    }
-    onDidChangeModels() {
-        if (!this.storeAllScheduler.isScheduled()) {
-            this.storeAllScheduler.schedule();
-        }
-    }
-    async storeAll(token) {
-        const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
-        const promises = [];
-        const models = Array.from(( this.models.values()));
-        for (const model of models) {
-            promises.push(limiter.queue(async () => {
-                if (token.isCancellationRequested) {
-                    return;
-                }
-                try {
-                    await model.store(token);
-                }
-                catch (error) {
-                    this.logService.trace(error);
-                }
-            }));
-        }
-        await Promise.all(promises);
-    }
-};
-NativeWorkingCopyHistoryService = NativeWorkingCopyHistoryService_1 = ( __decorate([
-    ( __param(0, IFileService)),
-    ( __param(1, IRemoteAgentService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IUriIdentityService)),
-    ( __param(4, ILabelService)),
-    ( __param(5, ILifecycleService)),
-    ( __param(6, ILogService)),
-    ( __param(7, IConfigurationService))
-], NativeWorkingCopyHistoryService));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(WorkingCopyHistoryTracker, 3 );
-
-export { NativeWorkingCopyHistoryService, WorkingCopyHistoryModel, WorkingCopyHistoryService };