@codingame/monaco-vscode-working-copy-service-override 11.1.1 → 12.0.0

package/index.d.ts

@@ -1 +1,6 @@
-export { default } from 'vscode/service-override/workingCopy';
+import type { IEditorOverrideServices } from "vscode/vscode/vs/editor/standalone/browser/standaloneServices";
+interface WorkingCopyServiceOptions {
+    storage?: "memory" | "userData" | null;
+}
+export default function getServiceOverride({ storage }?: WorkingCopyServiceOptions): IEditorOverrideServices;
+export {};

package/index.js

@@ -1 +1,46 @@
-export { default } from './workingCopy.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
+import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
+import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service';
+import { WorkingCopyService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyService.js';
+import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
+import { WorkingCopyEditorService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyEditorService.js';
+import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service';
+import { IWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory.service';
+import { BrowserWorkingCopyHistoryService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyHistoryService.js';
+import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
+import { joinPath } from 'vscode/vscode/vs/base/common/resources';
+import { WorkingCopyBackupService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyBackupService.js';
+import getServiceOverride$1 from '@codingame/monaco-vscode-files-service-override';
+
+let BrowserWorkingCopyBackupService = class BrowserWorkingCopyBackupService extends WorkingCopyBackupService {
+    constructor(memory, contextService, environmentService, fileService, logService) {
+        super(memory
+            ? undefined
+            : joinPath(environmentService.userRoamingDataHome, 'Backups', contextService.getWorkspace().id), fileService, logService);
+    }
+};
+BrowserWorkingCopyBackupService = __decorate([
+    __param(1, IWorkspaceContextService),
+    __param(2, IWorkbenchEnvironmentService),
+    __param(3, IFileService),
+    __param(4, ILogService)
+], BrowserWorkingCopyBackupService);
+function getServiceOverride({ storage = 'userData' } = {}) {
+    return {
+        ...getServiceOverride$1(),
+        ...(storage != null
+            ? {
+                [IWorkingCopyBackupService.toString()]: new SyncDescriptor(BrowserWorkingCopyBackupService, [storage === 'memory'], false)
+            }
+            : {}),
+        [IWorkingCopyService.toString()]: new SyncDescriptor(WorkingCopyService, [], false),
+        [IWorkingCopyEditorService.toString()]: new SyncDescriptor(WorkingCopyEditorService, [], false),
+        [IWorkingCopyHistoryService.toString()]: new SyncDescriptor(BrowserWorkingCopyHistoryService, [], false)
+    };
+}
+
+export { getServiceOverride as default };

package/package.json

@@ -1,6 +1,8 @@
 {
   "name": "@codingame/monaco-vscode-working-copy-service-override",
-  "version": "11.1.1",
+  "version": "12.0.0",
+  "private": false,
+  "description": "VSCode public API plugged on the monaco editor - working-copy service-override",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -12,8 +14,14 @@
     "url": "git+ssh://git@github.com/CodinGame/monaco-vscode-api.git"
   },
   "type": "module",
-  "private": false,
-  "description": "VSCode public API plugged on the monaco editor - working-copy service-override",
+  "dependencies": {
+    "@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common": "12.0.0",
+    "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common": "12.0.0",
+    "@codingame/monaco-vscode-files-service-override": "12.0.0",
+    "vscode": "npm:@codingame/monaco-vscode-api@12.0.0"
+  },
+  "peerDependencies": {},
+  "peerDependenciesMeta": {},
   "main": "index.js",
   "module": "index.js",
   "types": "index.d.ts",
@@ -22,11 +30,12 @@
       "default": "./index.js"
     },
     "./vscode/*": {
-      "default": "./vscode/src/*.js"
+      "default": "./vscode/src/*.js",
+      "types": "./vscode/src/*.d.ts"
+    },
+    "./*": {
+      "default": "./*.js",
+      "types": "./*.d.ts"
     }
-  },
-  "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@11.1.1",
-    "@codingame/monaco-vscode-files-service-override": "11.1.1"
   }
 }

package/vscode/src/vs/workbench/services/workingCopy/browser/workingCopyHistoryService.d.ts

@@ -0,0 +1,12 @@
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IRemoteAgentService } from "vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { ILabelService } from "vscode/vscode/vs/platform/label/common/label.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IWorkingCopyHistoryModelOptions, WorkingCopyHistoryService } from "../common/workingCopyHistoryService.js";
+export declare class BrowserWorkingCopyHistoryService extends WorkingCopyHistoryService {
+    constructor(fileService: IFileService, remoteAgentService: IRemoteAgentService, environmentService: IWorkbenchEnvironmentService, uriIdentityService: IUriIdentityService, labelService: ILabelService, logService: ILogService, configurationService: IConfigurationService);
+    protected getModelOptions(): IWorkingCopyHistoryModelOptions;
+}

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
@@ -7,6 +8,7 @@ import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label.serv
 import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { IConfigurationService } from 'vscode/vscode/vs/platform/configuration/common/configuration.service';
 import { WorkingCopyHistoryService } from '../common/workingCopyHistoryService.js';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
 
 let BrowserWorkingCopyHistoryService = class BrowserWorkingCopyHistoryService extends WorkingCopyHistoryService {

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyBackupService.d.ts

@@ -0,0 +1,61 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IResolvedWorkingCopyBackup } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup";
+import { IWorkingCopyBackupService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { VSBufferReadable, VSBufferReadableStream } from "vscode/vscode/vs/base/common/buffer";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { CancellationToken } from "vscode/vscode/vs/base/common/cancellation";
+import { IWorkingCopyBackupMeta, IWorkingCopyIdentifier } from "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
+export declare class WorkingCopyBackupsModel {
+    private backupRoot;
+    private fileService;
+    private readonly cache;
+    static create(backupRoot: URI, fileService: IFileService): Promise<WorkingCopyBackupsModel>;
+    private constructor();
+    private resolve;
+    add(resource: URI, versionId?: number, meta?: IWorkingCopyBackupMeta): void;
+    update(resource: URI, meta?: IWorkingCopyBackupMeta): void;
+    count(): number;
+    has(resource: URI, versionId?: number, meta?: IWorkingCopyBackupMeta): boolean;
+    get(): URI[];
+    remove(resource: URI): void;
+    clear(): void;
+}
+export declare abstract class WorkingCopyBackupService extends Disposable implements IWorkingCopyBackupService {
+    protected fileService: IFileService;
+    private readonly logService;
+    readonly _serviceBrand: undefined;
+    private impl;
+    constructor(backupWorkspaceHome: URI | undefined, fileService: IFileService, logService: ILogService);
+    private initialize;
+    reinitialize(backupWorkspaceHome: URI | undefined): void;
+    hasBackups(): Promise<boolean>;
+    hasBackupSync(identifier: IWorkingCopyIdentifier, versionId?: number, meta?: IWorkingCopyBackupMeta): boolean;
+    backup(identifier: IWorkingCopyIdentifier, content?: VSBufferReadableStream | VSBufferReadable, versionId?: number, meta?: IWorkingCopyBackupMeta, token?: CancellationToken): Promise<void>;
+    discardBackup(identifier: IWorkingCopyIdentifier, token?: CancellationToken): Promise<void>;
+    discardBackups(filter?: {
+        except: IWorkingCopyIdentifier[];
+    }): Promise<void>;
+    getBackups(): Promise<IWorkingCopyIdentifier[]>;
+    resolve<T extends IWorkingCopyBackupMeta>(identifier: IWorkingCopyIdentifier): Promise<IResolvedWorkingCopyBackup<T> | undefined>;
+    toBackupResource(identifier: IWorkingCopyIdentifier): URI;
+    joinBackups(): Promise<void>;
+}
+export declare class InMemoryWorkingCopyBackupService extends Disposable implements IWorkingCopyBackupService {
+    readonly _serviceBrand: undefined;
+    private backups;
+    constructor();
+    hasBackups(): Promise<boolean>;
+    hasBackupSync(identifier: IWorkingCopyIdentifier, versionId?: number): boolean;
+    backup(identifier: IWorkingCopyIdentifier, content?: VSBufferReadable | VSBufferReadableStream, versionId?: number, meta?: IWorkingCopyBackupMeta, token?: CancellationToken): Promise<void>;
+    resolve<T extends IWorkingCopyBackupMeta>(identifier: IWorkingCopyIdentifier): Promise<IResolvedWorkingCopyBackup<T> | undefined>;
+    getBackups(): Promise<IWorkingCopyIdentifier[]>;
+    discardBackup(identifier: IWorkingCopyIdentifier): Promise<void>;
+    discardBackups(filter?: {
+        except: IWorkingCopyIdentifier[];
+    }): Promise<void>;
+    toBackupResource(identifier: IWorkingCopyIdentifier): URI;
+    joinBackups(): Promise<void>;
+}
+export declare function hashIdentifier(identifier: IWorkingCopyIdentifier): string;

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

@@ -1,9 +1,11 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { joinPath } from 'vscode/vscode/vs/base/common/resources';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
 import { deepClone, equals } from 'vscode/vscode/vs/base/common/objects';
 import { Promises, ResourceQueue } from 'vscode/vscode/vs/base/common/async';
+import { FileOperationResult } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { ResourceMap } from 'vscode/vscode/vs/base/common/map';
 import { isReadableStream, peekStream } from 'vscode/vscode/vs/base/common/stream';
@@ -13,7 +15,7 @@ import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
 import { hash } from 'vscode/vscode/vs/base/common/hash';
 import { isEmptyObject } from 'vscode/vscode/vs/base/common/types';
-import { NO_TYPE_ID } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopy';
+import { NO_TYPE_ID } from '@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy';
 
 var WorkingCopyBackupServiceImpl_1;
 class WorkingCopyBackupsModel {
@@ -255,7 +257,7 @@ let WorkingCopyBackupServiceImpl = class WorkingCopyBackupServiceImpl extends Di
             await this.fileService.del(backupResource, { recursive: true });
         }
         catch (error) {
-            if (error.fileOperationResult !== 1 ) {
+            if (error.fileOperationResult !== FileOperationResult.FILE_NOT_FOUND) {
                 throw error;
             }
         }

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyEditorService.d.ts

@@ -0,0 +1,22 @@
+import { IEditorIdentifier } from "vscode/vscode/vs/workbench/common/editor";
+import { EditorInput } from "vscode/vscode/vs/workbench/common/editor/editorInput";
+import { IWorkingCopy, IWorkingCopyIdentifier } from "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IEditorService } from "vscode/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IWorkingCopyEditorService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service";
+export interface IWorkingCopyEditorHandler {
+    handles(workingCopy: IWorkingCopyIdentifier): boolean | Promise<boolean>;
+    isOpen(workingCopy: IWorkingCopyIdentifier, editor: EditorInput): boolean;
+    createEditor(workingCopy: IWorkingCopyIdentifier): EditorInput | Promise<EditorInput>;
+}
+export declare class WorkingCopyEditorService extends Disposable implements IWorkingCopyEditorService {
+    private readonly editorService;
+    readonly _serviceBrand: undefined;
+    private readonly _onDidRegisterHandler;
+    readonly onDidRegisterHandler: import("vscode/vscode/vs/base/common/event").Event<IWorkingCopyEditorHandler>;
+    private readonly handlers;
+    constructor(editorService: IEditorService);
+    registerHandler(handler: IWorkingCopyEditorHandler): IDisposable;
+    findEditor(workingCopy: IWorkingCopy): IEditorIdentifier | undefined;
+    private isOpen;
+}

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

@@ -1,5 +1,8 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
+import { EditorsOrder } from 'vscode/vscode/vs/workbench/common/editor';
 import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService.service';
 import 'vscode/vscode/vs/platform/instantiation/common/instantiation';
@@ -18,7 +21,7 @@ let WorkingCopyEditorService = class WorkingCopyEditorService extends Disposable
         return toDisposable(() => this.handlers.delete(handler));
     }
     findEditor(workingCopy) {
-        for (const editorIdentifier of this.editorService.getEditors(0 )) {
+        for (const editorIdentifier of this.editorService.getEditors(EditorsOrder.MOST_RECENTLY_ACTIVE)) {
             if (this.isOpen(workingCopy, editorIdentifier.editor)) {
                 return editorIdentifier;
             }

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyHistory.d.ts

@@ -0,0 +1,22 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { SaveSource } from "vscode/vscode/vs/workbench/common/editor";
+export interface IWorkingCopyHistoryEvent {
+    readonly entry: IWorkingCopyHistoryEntry;
+}
+export interface IWorkingCopyHistoryEntry {
+    readonly id: string;
+    readonly workingCopy: {
+        readonly resource: URI;
+        readonly name: string;
+    };
+    readonly location: URI;
+    timestamp: number;
+    source: SaveSource;
+    sourceDescription: string | undefined;
+}
+export interface IWorkingCopyHistoryEntryDescriptor {
+    readonly resource: URI;
+    readonly timestamp?: number;
+    readonly source?: SaveSource;
+}
+export declare const MAX_PARALLEL_HISTORY_IO_OPS = 20;

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

@@ -1,3 +1,5 @@
+
+
 const MAX_PARALLEL_HISTORY_IO_OPS = 20;
 
 export { MAX_PARALLEL_HISTORY_IO_OPS };

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyHistoryService.d.ts

@@ -0,0 +1,123 @@
+import { Event, Emitter } from "vscode/vscode/vs/base/common/event";
+import { ILifecycleService } from "vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service";
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IWorkingCopyHistoryEntry, IWorkingCopyHistoryEntryDescriptor, IWorkingCopyHistoryEvent } from "./workingCopyHistory.js";
+import { IWorkingCopyHistoryService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { IRemoteAgentService } from "vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { IWorkbenchEnvironmentService } from "vscode/vscode/vs/workbench/services/environment/common/environmentService.service";
+import { CancellationToken } 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.service";
+import { ILabelService } from "vscode/vscode/vs/platform/label/common/label.service";
+import { ILogService } from "vscode/vscode/vs/platform/log/common/log.service";
+import { SaveSource } from "vscode/vscode/vs/workbench/common/editor";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+export interface IWorkingCopyHistoryModelOptions {
+    flushOnChange: boolean;
+}
+export declare class WorkingCopyHistoryModel {
+    private readonly historyHome;
+    private readonly entryAddedEmitter;
+    private readonly entryChangedEmitter;
+    private readonly entryReplacedEmitter;
+    private readonly entryRemovedEmitter;
+    private readonly options;
+    private readonly fileService;
+    private readonly labelService;
+    private readonly logService;
+    private readonly configurationService;
+    static readonly ENTRIES_FILE = "entries.json";
+    private static readonly FILE_SAVED_SOURCE;
+    private static readonly SETTINGS;
+    private entries;
+    private whenResolved;
+    private workingCopyResource;
+    private workingCopyName;
+    private historyEntriesFolder;
+    private historyEntriesListingFile;
+    private historyEntriesNameMatcher;
+    private versionId;
+    private storedVersionId;
+    private readonly storeLimiter;
+    constructor(workingCopyResource: URI, historyHome: URI, entryAddedEmitter: Emitter<IWorkingCopyHistoryEvent>, entryChangedEmitter: Emitter<IWorkingCopyHistoryEvent>, entryReplacedEmitter: Emitter<IWorkingCopyHistoryEvent>, entryRemovedEmitter: Emitter<IWorkingCopyHistoryEvent>, options: IWorkingCopyHistoryModelOptions, fileService: IFileService, labelService: ILabelService, logService: ILogService, configurationService: IConfigurationService);
+    private setWorkingCopy;
+    private toHistoryEntriesFolder;
+    addEntry(source: string | undefined, sourceDescription: string | undefined, timestamp: number | undefined, token: CancellationToken): Promise<IWorkingCopyHistoryEntry>;
+    private doAddEntry;
+    private doReplaceEntry;
+    removeEntry(entry: IWorkingCopyHistoryEntry, token: CancellationToken): Promise<boolean>;
+    updateEntry(entry: IWorkingCopyHistoryEntry, properties: {
+        source: SaveSource;
+    }, token: CancellationToken): Promise<void>;
+    getEntries(): Promise<readonly IWorkingCopyHistoryEntry[]>;
+    hasEntries(skipResolve: boolean): Promise<boolean>;
+    private resolveEntriesOnce;
+    private doResolveEntries;
+    private resolveEntriesFromDisk;
+    moveEntries(target: WorkingCopyHistoryModel, source: SaveSource, token: CancellationToken): Promise<void>;
+    store(token: CancellationToken): Promise<void>;
+    private shouldStore;
+    private doStore;
+    private cleanUpEntries;
+    private deleteEntry;
+    private writeEntriesFile;
+    private readEntriesFile;
+    private readEntriesFolder;
+    private isFileNotFound;
+    private traceError;
+}
+export declare abstract class WorkingCopyHistoryService extends Disposable implements IWorkingCopyHistoryService {
+    protected readonly fileService: IFileService;
+    protected readonly remoteAgentService: IRemoteAgentService;
+    protected readonly environmentService: IWorkbenchEnvironmentService;
+    protected readonly uriIdentityService: IUriIdentityService;
+    protected readonly labelService: ILabelService;
+    protected readonly logService: ILogService;
+    protected readonly configurationService: IConfigurationService;
+    private static readonly FILE_MOVED_SOURCE;
+    private static readonly FILE_RENAMED_SOURCE;
+    readonly _serviceBrand: undefined;
+    protected readonly _onDidAddEntry: Emitter<IWorkingCopyHistoryEvent>;
+    readonly onDidAddEntry: Event<IWorkingCopyHistoryEvent>;
+    protected readonly _onDidChangeEntry: Emitter<IWorkingCopyHistoryEvent>;
+    readonly onDidChangeEntry: Event<IWorkingCopyHistoryEvent>;
+    protected readonly _onDidReplaceEntry: Emitter<IWorkingCopyHistoryEvent>;
+    readonly onDidReplaceEntry: Event<IWorkingCopyHistoryEvent>;
+    private readonly _onDidMoveEntries;
+    readonly onDidMoveEntries: Event<void>;
+    protected readonly _onDidRemoveEntry: Emitter<IWorkingCopyHistoryEvent>;
+    readonly onDidRemoveEntry: Event<IWorkingCopyHistoryEvent>;
+    private readonly _onDidRemoveEntries;
+    readonly onDidRemoveEntries: Event<void>;
+    private readonly localHistoryHome;
+    protected readonly models: ResourceMap<WorkingCopyHistoryModel>;
+    constructor(fileService: IFileService, remoteAgentService: IRemoteAgentService, environmentService: IWorkbenchEnvironmentService, uriIdentityService: IUriIdentityService, labelService: ILabelService, logService: ILogService, configurationService: IConfigurationService);
+    private resolveLocalHistoryHome;
+    moveEntries(source: URI, target: URI): Promise<URI[]>;
+    private doMoveEntries;
+    addEntry({ resource, source, timestamp }: IWorkingCopyHistoryEntryDescriptor, token: CancellationToken): Promise<IWorkingCopyHistoryEntry | undefined>;
+    updateEntry(entry: IWorkingCopyHistoryEntry, properties: {
+        source: SaveSource;
+    }, token: CancellationToken): Promise<void>;
+    removeEntry(entry: IWorkingCopyHistoryEntry, token: CancellationToken): Promise<boolean>;
+    removeAll(token: CancellationToken): Promise<void>;
+    getEntries(resource: URI, token: CancellationToken): Promise<readonly IWorkingCopyHistoryEntry[]>;
+    getAll(token: CancellationToken): Promise<readonly URI[]>;
+    private getModel;
+    protected abstract getModelOptions(): IWorkingCopyHistoryModelOptions;
+}
+export declare class NativeWorkingCopyHistoryService extends WorkingCopyHistoryService {
+    private readonly lifecycleService;
+    private static readonly STORE_ALL_INTERVAL;
+    private readonly isRemotelyStored;
+    private readonly storeAllCts;
+    private readonly storeAllScheduler;
+    constructor(fileService: IFileService, remoteAgentService: IRemoteAgentService, environmentService: IWorkbenchEnvironmentService, uriIdentityService: IUriIdentityService, labelService: ILabelService, lifecycleService: ILifecycleService, logService: ILogService, configurationService: IConfigurationService);
+    private registerListeners;
+    protected getModelOptions(): IWorkingCopyHistoryModelOptions;
+    private onWillShutdown;
+    private onDidChangeModels;
+    private storeAll;
+}

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

@@ -1,14 +1,16 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } 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 { LifecyclePhase } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle';
 import { ILifecycleService } from 'vscode/vscode/vs/workbench/services/lifecycle/common/lifecycle.service';
 import { WorkingCopyHistoryTracker } from './workingCopyHistoryTracker.js';
 import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
 import { MAX_PARALLEL_HISTORY_IO_OPS } from './workingCopyHistory.js';
-import { FileOperationError } from 'vscode/vscode/vs/platform/files/common/files';
+import { FileOperationError, FileOperationResult } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService.service';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
@@ -31,7 +33,7 @@ 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', ( localize(8701, "File Saved"))); }
+    static { this.FILE_SAVED_SOURCE = SaveSourceRegistry.registerSource('default.source', ( localize(12110, "File Saved"))); }
     static { this.SETTINGS = {
         MAX_ENTRIES: 'workbench.localHistory.maxFileEntries',
         MERGE_PERIOD: 'workbench.localHistory.mergeWindow'
@@ -56,20 +58,20 @@ class WorkingCopyHistoryModel {
         this.historyEntriesNameMatcher = undefined;
         this.versionId = 0;
         this.storedVersionId = this.versionId;
-        this.storeLimiter = ( (new Limiter(1)));
+        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.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))));
+        return joinPath(historyHome, ( hash(( workingCopyResource.toString())).toString(16)));
     }
     async addEntry(source = WorkingCopyHistoryModel.FILE_SAVED_SOURCE, sourceDescription = undefined, timestamp = Date.now(), token) {
         let entryToReplace = undefined;
@@ -181,7 +183,7 @@ class WorkingCopyHistoryModel {
         for (const entry of this.entries) {
             entries.set(entry.id, entry);
         }
-        this.entries = Array.from(( (entries.values()))).sort((entryA, entryB) => entryA.timestamp - entryB.timestamp);
+        this.entries = Array.from(( entries.values())).sort((entryA, entryB) => entryA.timestamp - entryB.timestamp);
     }
     async resolveEntriesFromDisk() {
         const workingCopyResource = assertIsDefined(this.workingCopyResource);
@@ -190,7 +192,7 @@ class WorkingCopyHistoryModel {
             this.readEntriesFile(),
             this.readEntriesFolder()
         ]);
-        const entries = ( (new Map()));
+        const entries = ( new Map());
         if (entryStats) {
             for (const entryStat of entryStats) {
                 entries.set(entryStat.name, {
@@ -324,15 +326,15 @@ class WorkingCopyHistoryModel {
         const historyEntriesListingFile = assertIsDefined(this.historyEntriesListingFile);
         const serializedModel = {
             version: 1,
-            resource: ( (workingCopyResource.toString())),
-            entries: ( (this.entries.map(entry => {
+            resource: ( workingCopyResource.toString()),
+            entries: ( this.entries.map(entry => {
                 return {
                     id: entry.id,
                     source: entry.source !== WorkingCopyHistoryModel.FILE_SAVED_SOURCE ? entry.source : undefined,
                     sourceDescription: entry.sourceDescription,
                     timestamp: entry.timestamp
                 };
-            })))
+            }))
         };
         await this.fileService.writeFile(historyEntriesListingFile, VSBuffer.fromString(JSON.stringify(serializedModel)));
     }
@@ -340,7 +342,7 @@ class WorkingCopyHistoryModel {
         const historyEntriesListingFile = assertIsDefined(this.historyEntriesListingFile);
         let serializedModel = undefined;
         try {
-            serializedModel = JSON.parse(( ((await this.fileService.readFile(historyEntriesListingFile)).value.toString())));
+            serializedModel = JSON.parse(( (await this.fileService.readFile(historyEntriesListingFile)).value.toString()));
         }
         catch (error) {
             if (!this.isFileNotFound(error)) {
@@ -369,7 +371,7 @@ class WorkingCopyHistoryModel {
         );
     }
     isFileNotFound(error) {
-        return error instanceof FileOperationError && error.fileOperationResult === 1 ;
+        return error instanceof FileOperationError && error.fileOperationResult === FileOperationResult.FILE_NOT_FOUND;
     }
     traceError(error) {
         this.logService.trace('[Working Copy History Service]', error);
@@ -377,8 +379,8 @@ class WorkingCopyHistoryModel {
 }
 let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposable {
     static { WorkingCopyHistoryService_1 = this; }
-    static { this.FILE_MOVED_SOURCE = SaveSourceRegistry.registerSource('moved.source', ( localize(8702, "File Moved"))); }
-    static { this.FILE_RENAMED_SOURCE = SaveSourceRegistry.registerSource('renamed.source', ( localize(8703, "File Renamed"))); }
+    static { this.FILE_MOVED_SOURCE = SaveSourceRegistry.registerSource('moved.source', ( localize(12111, "File Moved"))); }
+    static { this.FILE_RENAMED_SOURCE = SaveSourceRegistry.registerSource('renamed.source', ( localize(12112, "File Renamed"))); }
     constructor(fileService, remoteAgentService, environmentService, uriIdentityService, labelService, logService, configurationService) {
         super();
         this.fileService = fileService;
@@ -388,20 +390,20 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         this.labelService = labelService;
         this.logService = logService;
         this.configurationService = configurationService;
-        this._onDidAddEntry = this._register(( (new Emitter())));
+        this._onDidAddEntry = this._register(( new Emitter()));
         this.onDidAddEntry = this._onDidAddEntry.event;
-        this._onDidChangeEntry = this._register(( (new Emitter())));
+        this._onDidChangeEntry = this._register(( new Emitter()));
         this.onDidChangeEntry = this._onDidChangeEntry.event;
-        this._onDidReplaceEntry = this._register(( (new Emitter())));
+        this._onDidReplaceEntry = this._register(( new Emitter()));
         this.onDidReplaceEntry = this._onDidReplaceEntry.event;
-        this._onDidMoveEntries = this._register(( (new Emitter())));
+        this._onDidMoveEntries = this._register(( new Emitter()));
         this.onDidMoveEntries = this._onDidMoveEntries.event;
-        this._onDidRemoveEntry = this._register(( (new Emitter())));
+        this._onDidRemoveEntry = this._register(( new Emitter()));
         this.onDidRemoveEntry = this._onDidRemoveEntry.event;
-        this._onDidRemoveEntries = this._register(( (new Emitter())));
+        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.localHistoryHome = ( new DeferredPromise());
+        this.models = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
         this.resolveLocalHistoryHome();
     }
     async resolveLocalHistoryHome() {
@@ -421,7 +423,7 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         this.localHistoryHome.complete(historyHome);
     }
     async moveEntries(source, target) {
-        const limiter = ( (new Limiter(MAX_PARALLEL_HISTORY_IO_OPS)));
+        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)) {
@@ -504,7 +506,7 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         if (token.isCancellationRequested) {
             return [];
         }
-        const all = ( (new ResourceMap()));
+        const all = ( new ResourceMap());
         for (const [resource, model] of this.models) {
             const hasInMemoryEntries = await model.hasEntries(true );
             if (hasInMemoryEntries) {
@@ -514,7 +516,7 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         try {
             const resolvedHistoryHome = await this.fileService.resolve(historyHome);
             if (resolvedHistoryHome.children) {
-                const limiter = ( (new Limiter(MAX_PARALLEL_HISTORY_IO_OPS)));
+                const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
                 const promises = [];
                 for (const child of resolvedHistoryHome.children) {
                     promises.push(limiter.queue(async () => {
@@ -522,9 +524,9 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
                             return;
                         }
                         try {
-                            const serializedModel = JSON.parse(( ((await this.fileService.readFile(joinPath(child.resource, WorkingCopyHistoryModel.ENTRIES_FILE))).value.toString())));
+                            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);
+                                all.set(( URI.parse(serializedModel.resource)), true);
                             }
                         }
                         catch (error) {
@@ -536,13 +538,13 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
         }
         catch (error) {
         }
-        return Array.from(( (all.keys())));
+        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(
+            model = ( new WorkingCopyHistoryModel(
                 resource,
                 historyHome,
                 this._onDidAddEntry,
@@ -554,21 +556,21 @@ let WorkingCopyHistoryService = class WorkingCopyHistoryService extends Disposab
                 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)));
+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; }
@@ -576,11 +578,11 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
         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.storeAllCts = this._register(( new CancellationTokenSource()));
+        this.storeAllScheduler = this._register(( new RunOnceScheduler(
             () => this.storeAll(this.storeAllCts.token),
             NativeWorkingCopyHistoryService_1.STORE_ALL_INTERVAL
-        ))));
+        )));
         this.registerListeners();
     }
     registerListeners() {
@@ -595,7 +597,7 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
     onWillShutdown(e) {
         this.storeAllScheduler.dispose();
         this.storeAllCts.dispose(true);
-        e.join(this.storeAll(e.token), { id: 'join.workingCopyHistory', label: ( localize(8704, "Saving local history")) });
+        e.join(this.storeAll(e.token), { id: 'join.workingCopyHistory', label: ( localize(12113, "Saving local history")) });
     }
     onDidChangeModels() {
         if (!this.storeAllScheduler.isScheduled()) {
@@ -603,9 +605,9 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
         }
     }
     async storeAll(token) {
-        const limiter = ( (new Limiter(MAX_PARALLEL_HISTORY_IO_OPS)));
+        const limiter = ( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS));
         const promises = [];
-        const models = Array.from(( (this.models.values())));
+        const models = Array.from(( this.models.values()));
         for (const model of models) {
             promises.push(limiter.queue(async () => {
                 if (token.isCancellationRequested) {
@@ -622,16 +624,16 @@ let NativeWorkingCopyHistoryService = class NativeWorkingCopyHistoryService exte
         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 );
+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, LifecyclePhase.Restored);
 
 export { NativeWorkingCopyHistoryService, WorkingCopyHistoryModel, WorkingCopyHistoryService };

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyHistoryTracker.d.ts

@@ -0,0 +1,37 @@
+import { Disposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IConfigurationService } from "vscode/vscode/vs/platform/configuration/common/configuration.service";
+import { IUndoRedoService } from "vscode/vscode/vs/platform/undoRedo/common/undoRedo.service";
+import { IUriIdentityService } from "vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service";
+import { IWorkbenchContribution } from "vscode/vscode/vs/workbench/common/contributions";
+import { IPathService } from "vscode/vscode/vs/workbench/services/path/common/pathService.service";
+import { IWorkingCopyHistoryService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory.service";
+import { IWorkingCopyService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service";
+import { IWorkspaceContextService } from "vscode/vscode/vs/platform/workspace/common/workspace.service";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+export declare class WorkingCopyHistoryTracker extends Disposable implements IWorkbenchContribution {
+    private readonly workingCopyService;
+    private readonly workingCopyHistoryService;
+    private readonly uriIdentityService;
+    private readonly pathService;
+    private readonly configurationService;
+    private readonly undoRedoService;
+    private readonly contextService;
+    private readonly fileService;
+    private static readonly SETTINGS;
+    private static readonly UNDO_REDO_SAVE_SOURCE;
+    private readonly limiter;
+    private readonly resourceExcludeMatcher;
+    private readonly pendingAddHistoryEntryOperations;
+    private readonly workingCopyContentVersion;
+    private readonly historyEntryContentVersion;
+    constructor(workingCopyService: IWorkingCopyService, workingCopyHistoryService: IWorkingCopyHistoryService, uriIdentityService: IUriIdentityService, pathService: IPathService, configurationService: IConfigurationService, undoRedoService: IUndoRedoService, contextService: IWorkspaceContextService, fileService: IFileService);
+    private registerListeners;
+    private onDidRunFileOperation;
+    private onDidChangeContent;
+    private getContentVersion;
+    private onDidSave;
+    private resolveSourceFromUndoRedo;
+    private shouldTrackHistoryFromSaveEvent;
+    private shouldTrackHistoryFromFileOperationEvent;
+    private shouldTrackHistory;
+}

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

@@ -1,4 +1,5 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
+
+import { __decorate, __param } from 'vscode/external/tslib/tslib.es6';
 import { localize } from 'vscode/vscode/vs/nls';
 import { Limiter, GlobalIdleValue } from 'vscode/vscode/vs/base/common/async';
 import { CancellationTokenSource } from 'vscode/vscode/vs/base/common/cancellation';
@@ -9,13 +10,14 @@ import { IUndoRedoService } from 'vscode/vscode/vs/platform/undoRedo/common/undo
 import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity.service';
 import { SaveSourceRegistry } from 'vscode/vscode/vs/workbench/common/editor';
 import { IPathService } from 'vscode/vscode/vs/workbench/services/path/common/pathService.service';
-import { isStoredFileWorkingCopySaveEvent } from 'vscode/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
+import { isStoredFileWorkingCopySaveEvent } from '@codingame/monaco-vscode-99f24462-c56d-5407-83fb-2ea9dd33cc8c-common/vscode/vs/workbench/services/workingCopy/common/storedFileWorkingCopy';
 import { MAX_PARALLEL_HISTORY_IO_OPS } from './workingCopyHistory.js';
 import { IWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory.service';
 import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
 import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { ResourceGlobMatcher } from 'vscode/vscode/vs/workbench/common/resources';
+import { ResourceGlobMatcher } from '@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/common/resources';
 import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
+import { FileOperation } from 'vscode/vscode/vs/platform/files/common/files';
 import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
 
 var WorkingCopyHistoryTracker_1;
@@ -26,7 +28,7 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
         SIZE_LIMIT: 'workbench.localHistory.maxFileSize',
         EXCLUDES: 'workbench.localHistory.exclude'
     }; }
-    static { this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource('undoRedo.source', ( localize(11096, "Undo / Redo"))); }
+    static { this.UNDO_REDO_SAVE_SOURCE = SaveSourceRegistry.registerSource('undoRedo.source', ( localize(12114, "Undo / Redo"))); }
     constructor(workingCopyService, workingCopyHistoryService, uriIdentityService, pathService, configurationService, undoRedoService, contextService, fileService) {
         super();
         this.workingCopyService = workingCopyService;
@@ -37,19 +39,19 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
         this.undoRedoService = undoRedoService;
         this.contextService = contextService;
         this.fileService = fileService;
-        this.limiter = this._register(( (new Limiter(MAX_PARALLEL_HISTORY_IO_OPS))));
-        this.resourceExcludeMatcher = this._register(( (new GlobalIdleValue(() => {
-            const matcher = this._register(( (new ResourceGlobMatcher(
+        this.limiter = this._register(( new Limiter(MAX_PARALLEL_HISTORY_IO_OPS)));
+        this.resourceExcludeMatcher = this._register(( new GlobalIdleValue(() => {
+            const matcher = this._register(( new ResourceGlobMatcher(
                 root => this.configurationService.getValue(WorkingCopyHistoryTracker_1.SETTINGS.EXCLUDES, { resource: root }),
                 event => event.affectsConfiguration(WorkingCopyHistoryTracker_1.SETTINGS.EXCLUDES),
                 this.contextService,
                 this.configurationService
-            ))));
+            )));
             return matcher;
-        }))));
-        this.pendingAddHistoryEntryOperations = ( (new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource))));
-        this.workingCopyContentVersion = ( (new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource))));
-        this.historyEntryContentVersion = ( (new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource))));
+        })));
+        this.pendingAddHistoryEntryOperations = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
+        this.workingCopyContentVersion = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
+        this.historyEntryContentVersion = ( new ResourceMap(resource => this.uriIdentityService.extUri.getComparisonKey(resource)));
         this.registerListeners();
     }
     registerListeners() {
@@ -85,7 +87,7 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
             return;
         }
         this.pendingAddHistoryEntryOperations.get(e.workingCopy.resource)?.dispose(true);
-        const cts = ( (new CancellationTokenSource()));
+        const cts = ( new CancellationTokenSource());
         this.pendingAddHistoryEntryOperations.set(e.workingCopy.resource, cts);
         this.limiter.queue(async () => {
             if (cts.token.isCancellationRequested) {
@@ -125,7 +127,7 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
         return this.shouldTrackHistory(e.workingCopy.resource, e.stat);
     }
     shouldTrackHistoryFromFileOperationEvent(e) {
-        if (!e.isOperation(2 )) {
+        if (!e.isOperation(FileOperation.MOVE)) {
             return false;
         }
         return this.shouldTrackHistory(e.target.resource, e.target);
@@ -147,15 +149,15 @@ let WorkingCopyHistoryTracker = class WorkingCopyHistoryTracker extends Disposab
         return !this.resourceExcludeMatcher.value.matches(resource);
     }
 };
-WorkingCopyHistoryTracker = WorkingCopyHistoryTracker_1 = ( (__decorate([
-    ( (__param(0, IWorkingCopyService))),
-    ( (__param(1, IWorkingCopyHistoryService))),
-    ( (__param(2, IUriIdentityService))),
-    ( (__param(3, IPathService))),
-    ( (__param(4, IConfigurationService))),
-    ( (__param(5, IUndoRedoService))),
-    ( (__param(6, IWorkspaceContextService))),
-    ( (__param(7, IFileService)))
-], WorkingCopyHistoryTracker)));
+WorkingCopyHistoryTracker = WorkingCopyHistoryTracker_1 = ( __decorate([
+    ( __param(0, IWorkingCopyService)),
+    ( __param(1, IWorkingCopyHistoryService)),
+    ( __param(2, IUriIdentityService)),
+    ( __param(3, IPathService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IUndoRedoService)),
+    ( __param(6, IWorkspaceContextService)),
+    ( __param(7, IFileService))
+], WorkingCopyHistoryTracker));
 
 export { WorkingCopyHistoryTracker };

package/vscode/src/vs/workbench/services/workingCopy/common/workingCopyService.d.ts

@@ -0,0 +1,36 @@
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { Disposable, IDisposable } from "vscode/vscode/vs/base/common/lifecycle";
+import { IWorkingCopy, IWorkingCopyIdentifier, IWorkingCopySaveEvent as IBaseWorkingCopySaveEvent } from "@codingame/monaco-vscode-a4683c2b-a0d2-5112-96ba-eedc605346d2-common/vscode/vs/workbench/services/workingCopy/common/workingCopy";
+import { IWorkingCopyService } from "vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service";
+export interface IWorkingCopySaveEvent extends IBaseWorkingCopySaveEvent {
+    readonly workingCopy: IWorkingCopy;
+}
+export declare class WorkingCopyService extends Disposable implements IWorkingCopyService {
+    readonly _serviceBrand: undefined;
+    private readonly _onDidRegister;
+    readonly onDidRegister: import("vscode/vscode/vs/base/common/event").Event<IWorkingCopy>;
+    private readonly _onDidUnregister;
+    readonly onDidUnregister: import("vscode/vscode/vs/base/common/event").Event<IWorkingCopy>;
+    private readonly _onDidChangeDirty;
+    readonly onDidChangeDirty: import("vscode/vscode/vs/base/common/event").Event<IWorkingCopy>;
+    private readonly _onDidChangeContent;
+    readonly onDidChangeContent: import("vscode/vscode/vs/base/common/event").Event<IWorkingCopy>;
+    private readonly _onDidSave;
+    readonly onDidSave: import("vscode/vscode/vs/base/common/event").Event<IWorkingCopySaveEvent>;
+    get workingCopies(): IWorkingCopy[];
+    private _workingCopies;
+    private readonly mapResourceToWorkingCopies;
+    private readonly mapWorkingCopyToListeners;
+    registerWorkingCopy(workingCopy: IWorkingCopy): IDisposable;
+    protected unregisterWorkingCopy(workingCopy: IWorkingCopy): void;
+    has(identifier: IWorkingCopyIdentifier): boolean;
+    has(resource: URI): boolean;
+    get(identifier: IWorkingCopyIdentifier): IWorkingCopy | undefined;
+    getAll(resource: URI): readonly IWorkingCopy[] | undefined;
+    get hasDirty(): boolean;
+    get dirtyCount(): number;
+    get dirtyWorkingCopies(): IWorkingCopy[];
+    get modifiedCount(): number;
+    get modifiedWorkingCopies(): IWorkingCopy[];
+    isDirty(resource: URI, typeId?: string): boolean;
+}

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

@@ -1,3 +1,5 @@
+
+import 'vscode/vscode/vs/platform/instantiation/common/extensions';
 import { Emitter } from 'vscode/vscode/vs/base/common/event';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { Disposable, DisposableMap, DisposableStore, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';

package/workingCopy.js

@@ -1,45 +0,0 @@
-import { __decorate, __param } from 'vscode/external/tslib/tslib.es6.js';
-import { SyncDescriptor } from 'vscode/vscode/vs/platform/instantiation/common/descriptors';
-import { IWorkingCopyBackupService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyBackup.service';
-import { WorkingCopyService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyService.js';
-import { IWorkingCopyService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyService.service';
-import { WorkingCopyEditorService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyEditorService.js';
-import { IWorkingCopyEditorService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.service';
-import { IWorkingCopyHistoryService } from 'vscode/vscode/vs/workbench/services/workingCopy/common/workingCopyHistory.service';
-import { BrowserWorkingCopyHistoryService } from './vscode/src/vs/workbench/services/workingCopy/browser/workingCopyHistoryService.js';
-import { IWorkspaceContextService } from 'vscode/vscode/vs/platform/workspace/common/workspace.service';
-import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService.service';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files.service';
-import { ILogService } from 'vscode/vscode/vs/platform/log/common/log.service';
-import { joinPath } from 'vscode/vscode/vs/base/common/resources';
-import { WorkingCopyBackupService } from './vscode/src/vs/workbench/services/workingCopy/common/workingCopyBackupService.js';
-import getServiceOverride$1 from '@codingame/monaco-vscode-files-service-override';
-
-let BrowserWorkingCopyBackupService = class BrowserWorkingCopyBackupService extends WorkingCopyBackupService {
-    constructor(memory, contextService, environmentService, fileService, logService) {
-        super(memory
-            ? undefined
-            : joinPath(environmentService.userRoamingDataHome, 'Backups', contextService.getWorkspace().id), fileService, logService);
-    }
-};
-BrowserWorkingCopyBackupService = __decorate([
-    ( __param(1, IWorkspaceContextService)),
-    ( __param(2, IWorkbenchEnvironmentService)),
-    ( __param(3, IFileService)),
-    ( __param(4, ILogService))
-], BrowserWorkingCopyBackupService);
-function getServiceOverride({ storage = 'userData' } = {}) {
-    return {
-        ...getServiceOverride$1(),
-        ...(storage != null
-            ? {
-                [( IWorkingCopyBackupService.toString())]: new SyncDescriptor(BrowserWorkingCopyBackupService, [storage === 'memory'], false)
-            }
-            : {}),
-        [( IWorkingCopyService.toString())]: new SyncDescriptor(WorkingCopyService, [], false),
-        [( IWorkingCopyEditorService.toString())]: new SyncDescriptor(WorkingCopyEditorService, [], false),
-        [( IWorkingCopyHistoryService.toString())]: new SyncDescriptor(BrowserWorkingCopyHistoryService, [], false)
-    };
-}
-
-export { getServiceOverride as default };