@codingame/monaco-vscode-bulk-edit-service-override 11.1.2 → 12.0.0

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPreview.d.ts

@@ -0,0 +1,87 @@
+import { ITextModelContentProvider, ITextModelService } from "vscode/vscode/vs/editor/common/services/resolverService";
+import { URI } from "vscode/vscode/vs/base/common/uri";
+import { ILanguageService } from "vscode/vscode/vs/editor/common/languages/language";
+import { IModelService } from "vscode/vscode/vs/editor/common/services/model";
+import { WorkspaceEditMetadata } from "vscode/vscode/vs/editor/common/languages";
+import { ISingleEditOperation } from "vscode/vscode/vs/editor/common/core/editOperation";
+import { ServicesAccessor, IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+import { IFileService } from "vscode/vscode/vs/platform/files/common/files.service";
+import { Event } from "vscode/vscode/vs/base/common/event";
+import { ConflictDetector } from "../conflicts.js";
+import { ResourceEdit, ResourceFileEdit, ResourceTextEdit } from "vscode/vscode/vs/editor/browser/services/bulkEditService";
+export declare class CheckedStates<T extends object> {
+    private readonly _states;
+    private _checkedCount;
+    private readonly _onDidChange;
+    readonly onDidChange: Event<T>;
+    dispose(): void;
+    get checkedCount(): number;
+    isChecked(obj: T): boolean;
+    updateChecked(obj: T, value: boolean): void;
+}
+export declare class BulkTextEdit {
+    readonly parent: BulkFileOperation;
+    readonly textEdit: ResourceTextEdit;
+    constructor(parent: BulkFileOperation, textEdit: ResourceTextEdit);
+}
+export declare enum BulkFileOperationType {
+    TextEdit = 1,
+    Create = 2,
+    Delete = 4,
+    Rename = 8
+}
+export declare class BulkFileOperation {
+    readonly uri: URI;
+    readonly parent: BulkFileOperations;
+    type: number;
+    textEdits: BulkTextEdit[];
+    originalEdits: Map<number, ResourceTextEdit | ResourceFileEdit>;
+    newUri?: URI;
+    constructor(uri: URI, parent: BulkFileOperations);
+    addEdit(index: number, type: BulkFileOperationType, edit: ResourceTextEdit | ResourceFileEdit): void;
+    needsConfirmation(): boolean;
+}
+export declare class BulkCategory {
+    readonly metadata: WorkspaceEditMetadata;
+    private static readonly _defaultMetadata;
+    static keyOf(metadata?: WorkspaceEditMetadata): string;
+    readonly operationByResource: Map<string, BulkFileOperation>;
+    constructor(metadata?: WorkspaceEditMetadata);
+    get fileOperations(): IterableIterator<BulkFileOperation>;
+}
+export declare class BulkFileOperations {
+    private readonly _bulkEdit;
+    private readonly _fileService;
+    static create(accessor: ServicesAccessor, bulkEdit: ResourceEdit[]): Promise<BulkFileOperations>;
+    readonly checked: CheckedStates<ResourceEdit>;
+    readonly fileOperations: BulkFileOperation[];
+    readonly categories: BulkCategory[];
+    readonly conflicts: ConflictDetector;
+    constructor(_bulkEdit: ResourceEdit[], _fileService: IFileService, instaService: IInstantiationService);
+    dispose(): void;
+    _init(): Promise<this>;
+    getWorkspaceEdit(): ResourceEdit[];
+    private getFileEditOperation;
+    getFileEdits(uri: URI): Promise<ISingleEditOperation[]>;
+    getUriOfEdit(edit: ResourceEdit): URI;
+}
+export declare class BulkEditPreviewProvider implements ITextModelContentProvider {
+    private readonly _operations;
+    private readonly _languageService;
+    private readonly _modelService;
+    private readonly _textModelResolverService;
+    private static readonly Schema;
+    static emptyPreview: URI;
+    static fromPreviewUri(uri: URI): URI;
+    private readonly _disposables;
+    private readonly _ready;
+    private readonly _modelPreviewEdits;
+    private readonly _instanceId;
+    constructor(_operations: BulkFileOperations, _languageService: ILanguageService, _modelService: IModelService, _textModelResolverService: ITextModelService);
+    dispose(): void;
+    asPreviewUri(uri: URI): URI;
+    private _init;
+    private _applyTextEditsToPreviewModel;
+    private _getOrCreatePreviewModel;
+    provideTextContent(previewUri: URI): Promise<import("vscode/vscode/vs/editor/common/model").ITextModel | null>;
+}

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/preview/bulkEditPreview.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 { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
 import { URI } from 'vscode/vscode/vs/base/common/uri';
 import { ILanguageService } from 'vscode/vscode/vs/editor/common/languages/language';
@@ -24,9 +25,9 @@ import { MicrotaskDelay } from 'vscode/vscode/vs/base/common/symbols';
 var BulkFileOperations_1, BulkEditPreviewProvider_1;
 class CheckedStates {
     constructor() {
-        this._states = ( (new WeakMap()));
+        this._states = ( new WeakMap());
         this._checkedCount = 0;
-        this._onDidChange = ( (new Emitter()));
+        this._onDidChange = ( new Emitter());
         this.onDidChange = this._onDidChange.event;
     }
     dispose() {
@@ -66,21 +67,28 @@ class BulkTextEdit {
         this.textEdit = textEdit;
     }
 }
+var BulkFileOperationType;
+(function (BulkFileOperationType) {
+    BulkFileOperationType[BulkFileOperationType["TextEdit"] = 1] = "TextEdit";
+    BulkFileOperationType[BulkFileOperationType["Create"] = 2] = "Create";
+    BulkFileOperationType[BulkFileOperationType["Delete"] = 4] = "Delete";
+    BulkFileOperationType[BulkFileOperationType["Rename"] = 8] = "Rename";
+})(BulkFileOperationType || (BulkFileOperationType = {}));
 class BulkFileOperation {
     constructor(uri, parent) {
         this.uri = uri;
         this.parent = parent;
         this.type = 0;
         this.textEdits = [];
-        this.originalEdits = ( (new Map()));
+        this.originalEdits = ( new Map());
     }
     addEdit(index, type, edit) {
         this.type |= type;
         this.originalEdits.set(index, edit);
         if (edit instanceof ResourceTextEdit) {
-            this.textEdits.push(( (new BulkTextEdit(this, edit))));
+            this.textEdits.push(( new BulkTextEdit(this, edit)));
         }
-        else if (type === 8 ) {
+        else if (type === BulkFileOperationType.Rename) {
             this.newUri = edit.newResource;
         }
     }
@@ -94,22 +102,20 @@ class BulkFileOperation {
     }
 }
 class BulkCategory {
-    static { this._defaultMetadata = ( (Object.freeze({
-        label: ( localize(10173, "Other")),
+    static { this._defaultMetadata = ( Object.freeze({
+        label: ( localize(4094, "Other")),
         icon: Codicon.symbolFile,
         needsConfirmation: false
-    }))); }
+    })); }
     static keyOf(metadata) {
         return metadata?.label || '<default>';
     }
     constructor(metadata = BulkCategory._defaultMetadata) {
         this.metadata = metadata;
-        this.operationByResource = ( (new Map()));
+        this.operationByResource = ( new Map());
     }
     get fileOperations() {
-        return (
-             (this.operationByResource.values())
-        );
+        return ( this.operationByResource.values());
     }
 }
 let BulkFileOperations = BulkFileOperations_1 = class BulkFileOperations {
@@ -120,7 +126,7 @@ let BulkFileOperations = BulkFileOperations_1 = class BulkFileOperations {
     constructor(_bulkEdit, _fileService, instaService) {
         this._bulkEdit = _bulkEdit;
         this._fileService = _fileService;
-        this.checked = ( (new CheckedStates()));
+        this.checked = ( new CheckedStates());
         this.fileOperations = [];
         this.categories = [];
         this.conflicts = instaService.createInstance(ConflictDetector, _bulkEdit);
@@ -130,21 +136,21 @@ let BulkFileOperations = BulkFileOperations_1 = class BulkFileOperations {
         this.conflicts.dispose();
     }
     async _init() {
-        const operationByResource = ( (new Map()));
-        const operationByCategory = ( (new Map()));
-        const newToOldUri = ( (new ResourceMap()));
+        const operationByResource = ( new Map());
+        const operationByCategory = ( new Map());
+        const newToOldUri = ( new ResourceMap());
         for (let idx = 0; idx < this._bulkEdit.length; idx++) {
             const edit = this._bulkEdit[idx];
             let uri;
             let type;
             this.checked.updateChecked(edit, !edit.metadata?.needsConfirmation);
             if (edit instanceof ResourceTextEdit) {
-                type = 1 ;
+                type = BulkFileOperationType.TextEdit;
                 uri = edit.resource;
             }
             else if (edit instanceof ResourceFileEdit) {
                 if (edit.newResource && edit.oldResource) {
-                    type = 8 ;
+                    type = BulkFileOperationType.Rename;
                     uri = edit.oldResource;
                     if (edit.options?.overwrite === undefined && edit.options?.ignoreIfExists && (await this._fileService.exists(uri))) {
                         continue;
@@ -152,14 +158,14 @@ let BulkFileOperations = BulkFileOperations_1 = class BulkFileOperations {
                     newToOldUri.set(edit.newResource, uri);
                 }
                 else if (edit.oldResource) {
-                    type = 4 ;
+                    type = BulkFileOperationType.Delete;
                     uri = edit.oldResource;
                     if (edit.options?.ignoreIfNotExists && !(await this._fileService.exists(uri))) {
                         continue;
                     }
                 }
                 else if (edit.newResource) {
-                    type = 2 ;
+                    type = BulkFileOperationType.Create;
                     uri = edit.newResource;
                     if (edit.options?.overwrite === undefined && edit.options?.ignoreIfExists && (await this._fileService.exists(uri))) {
                         continue;
@@ -175,13 +181,13 @@ let BulkFileOperations = BulkFileOperations_1 = class BulkFileOperations {
             const insert = (uri, map) => {
                 let key = extUri.getComparisonKey(uri, true);
                 let operation = map.get(key);
-                if (!operation && ( (newToOldUri.has(uri)))) {
+                if (!operation && ( newToOldUri.has(uri))) {
                     uri = newToOldUri.get(uri);
                     key = extUri.getComparisonKey(uri, true);
                     operation = map.get(key);
                 }
                 if (!operation) {
-                    operation = ( (new BulkFileOperation(uri, this)));
+                    operation = ( new BulkFileOperation(uri, this));
                     map.set(key, operation);
                 }
                 operation.addEdit(idx, type, edit);
@@ -190,7 +196,7 @@ let BulkFileOperations = BulkFileOperations_1 = class BulkFileOperations {
             const key = BulkCategory.keyOf(edit.metadata);
             let category = operationByCategory.get(key);
             if (!category) {
-                category = ( (new BulkCategory(edit.metadata)));
+                category = ( new BulkCategory(edit.metadata));
                 operationByCategory.set(key, category);
             }
             insert(uri, category.operationByResource);
@@ -198,15 +204,15 @@ let BulkFileOperations = BulkFileOperations_1 = class BulkFileOperations {
         operationByResource.forEach(value => this.fileOperations.push(value));
         operationByCategory.forEach(value => this.categories.push(value));
         for (const file of this.fileOperations) {
-            if (file.type !== 1 ) {
+            if (file.type !== BulkFileOperationType.TextEdit) {
                 let checked = true;
-                for (const edit of ( (file.originalEdits.values()))) {
+                for (const edit of ( file.originalEdits.values())) {
                     if (edit instanceof ResourceFileEdit) {
                         checked = checked && this.checked.isChecked(edit);
                     }
                 }
                 if (!checked) {
-                    for (const edit of ( (file.originalEdits.values()))) {
+                    for (const edit of ( file.originalEdits.values())) {
                         this.checked.updateChecked(edit, checked);
                     }
                 }
@@ -247,14 +253,14 @@ let BulkFileOperations = BulkFileOperations_1 = class BulkFileOperations {
         if (!content) {
             return undefined;
         }
-        return EditOperation.replaceMove(Range.lift({ startLineNumber: 0, startColumn: 0, endLineNumber: Number.MAX_VALUE, endColumn: 0 }), ( (content.toString())));
+        return EditOperation.replaceMove(Range.lift({ startLineNumber: 0, startColumn: 0, endLineNumber: Number.MAX_VALUE, endColumn: 0 }), ( content.toString()));
     }
     async getFileEdits(uri) {
         for (const file of this.fileOperations) {
-            if (( (file.uri.toString())) === ( (uri.toString()))) {
+            if (( file.uri.toString()) === ( uri.toString())) {
                 const result = [];
                 let ignoreAll = false;
-                for (const edit of ( (file.originalEdits.values()))) {
+                for (const edit of ( file.originalEdits.values())) {
                     if (edit instanceof ResourceFileEdit) {
                         result.push(this.getFileEditOperation(edit));
                     }
@@ -277,35 +283,33 @@ let BulkFileOperations = BulkFileOperations_1 = class BulkFileOperations {
     }
     getUriOfEdit(edit) {
         for (const file of this.fileOperations) {
-            for (const value of ( (file.originalEdits.values()))) {
+            for (const value of ( file.originalEdits.values())) {
                 if (value === edit) {
                     return file.uri;
                 }
             }
         }
-        throw ( (new Error('invalid edit')));
+        throw ( new Error('invalid edit'));
     }
 };
-BulkFileOperations = BulkFileOperations_1 = ( (__decorate([
-    ( (__param(1, IFileService))),
-    ( (__param(2, IInstantiationService)))
-], BulkFileOperations)));
+BulkFileOperations = BulkFileOperations_1 = ( __decorate([
+    ( __param(1, IFileService)),
+    ( __param(2, IInstantiationService))
+], BulkFileOperations));
 let BulkEditPreviewProvider = class BulkEditPreviewProvider {
     static { BulkEditPreviewProvider_1 = this; }
     static { this.Schema = 'vscode-bulkeditpreview-editor'; }
-    static { this.emptyPreview = ( (URI.from({ scheme: this.Schema, fragment: 'empty' }))); }
+    static { this.emptyPreview = ( URI.from({ scheme: this.Schema, fragment: 'empty' })); }
     static fromPreviewUri(uri) {
-        return (
-             (URI.parse(uri.query))
-        );
+        return ( URI.parse(uri.query));
     }
     constructor(_operations, _languageService, _modelService, _textModelResolverService) {
         this._operations = _operations;
         this._languageService = _languageService;
         this._modelService = _modelService;
         this._textModelResolverService = _textModelResolverService;
-        this._disposables = ( (new DisposableStore()));
-        this._modelPreviewEdits = ( (new Map()));
+        this._disposables = ( new DisposableStore());
+        this._modelPreviewEdits = ( new Map());
         this._instanceId = generateUuid();
         this._disposables.add(this._textModelResolverService.registerTextModelContentProvider(BulkEditPreviewProvider_1.Schema, this));
         this._ready = this._init();
@@ -314,11 +318,9 @@ let BulkEditPreviewProvider = class BulkEditPreviewProvider {
         this._disposables.dispose();
     }
     asPreviewUri(uri) {
-        return (
-             (URI.from(
-                { scheme: BulkEditPreviewProvider_1.Schema, authority: this._instanceId, path: uri.path, query: ( (uri.toString())) }
-            ))
-        );
+        return ( URI.from(
+            { scheme: BulkEditPreviewProvider_1.Schema, authority: this._instanceId, path: uri.path, query: ( uri.toString()) }
+        ));
     }
     async _init() {
         for (const operation of this._operations.fileOperations) {
@@ -359,17 +361,17 @@ let BulkEditPreviewProvider = class BulkEditPreviewProvider {
         return model;
     }
     async provideTextContent(previewUri) {
-        if (( (previewUri.toString())) === ( (BulkEditPreviewProvider_1.emptyPreview.toString()))) {
+        if (( previewUri.toString()) === ( BulkEditPreviewProvider_1.emptyPreview.toString())) {
             return this._modelService.createModel('', null, previewUri);
         }
         await this._ready;
         return this._modelService.getModel(previewUri);
     }
 };
-BulkEditPreviewProvider = BulkEditPreviewProvider_1 = ( (__decorate([
-    ( (__param(1, ILanguageService))),
-    ( (__param(2, IModelService))),
-    ( (__param(3, ITextModelService)))
-], BulkEditPreviewProvider)));
+BulkEditPreviewProvider = BulkEditPreviewProvider_1 = ( __decorate([
+    ( __param(1, ILanguageService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ITextModelService))
+], BulkEditPreviewProvider));
 
-export { BulkCategory, BulkEditPreviewProvider, BulkFileOperation, BulkFileOperations, BulkTextEdit, CheckedStates };
+export { BulkCategory, BulkEditPreviewProvider, BulkFileOperation, BulkFileOperationType, BulkFileOperations, BulkTextEdit, CheckedStates };

package/vscode/src/vs/workbench/contrib/bulkEdit/browser/preview/bulkEditTree.d.ts

@@ -0,0 +1,132 @@
+import { IAsyncDataSource, ITreeRenderer, ITreeNode, ITreeSorter } from "vscode/vscode/vs/base/browser/ui/tree/tree";
+import { ITextModelService } from "vscode/vscode/vs/editor/common/services/resolverService";
+import { FuzzyScore } from "vscode/vscode/vs/base/common/filters";
+import { ResourceLabels } from "@codingame/monaco-vscode-9e888134-1a6f-58d9-b0e6-0fc047448366-common/vscode/vs/workbench/browser/labels";
+import { IIdentityProvider, IListVirtualDelegate, IKeyboardNavigationLabelProvider } from "vscode/vscode/vs/base/browser/ui/list/list";
+import { BulkFileOperations, BulkFileOperation, BulkTextEdit, BulkCategory } from "./bulkEditPreview.js";
+import { ILabelService } from "vscode/vscode/vs/platform/label/common/label.service";
+import type { IListAccessibilityProvider } from "vscode/vscode/vs/base/browser/ui/list/listWidget";
+import { IconLabel } from "vscode/vscode/vs/base/browser/ui/iconLabel/iconLabel";
+import { IThemeService } from "vscode/vscode/vs/platform/theme/common/themeService.service";
+import { AriaRole } from "vscode/vscode/vs/base/browser/ui/aria/aria";
+import { IInstantiationService } from "vscode/vscode/vs/platform/instantiation/common/instantiation";
+export interface ICheckable {
+    isChecked(): boolean;
+    setChecked(value: boolean): void;
+}
+export declare class CategoryElement implements ICheckable {
+    readonly parent: BulkFileOperations;
+    readonly category: BulkCategory;
+    constructor(parent: BulkFileOperations, category: BulkCategory);
+    isChecked(): boolean;
+    setChecked(value: boolean): void;
+}
+export declare class FileElement implements ICheckable {
+    readonly parent: CategoryElement | BulkFileOperations;
+    readonly edit: BulkFileOperation;
+    constructor(parent: CategoryElement | BulkFileOperations, edit: BulkFileOperation);
+    isChecked(): boolean;
+    setChecked(value: boolean): void;
+    isDisabled(): boolean;
+}
+export declare class TextEditElement implements ICheckable {
+    readonly parent: FileElement;
+    readonly idx: number;
+    readonly edit: BulkTextEdit;
+    readonly prefix: string;
+    readonly selecting: string;
+    readonly inserting: string;
+    readonly suffix: string;
+    constructor(parent: FileElement, idx: number, edit: BulkTextEdit, prefix: string, selecting: string, inserting: string, suffix: string);
+    isChecked(): boolean;
+    setChecked(value: boolean): void;
+    isDisabled(): boolean;
+}
+export type BulkEditElement = CategoryElement | FileElement | TextEditElement;
+export declare class BulkEditDataSource implements IAsyncDataSource<BulkFileOperations, BulkEditElement> {
+    private readonly _textModelService;
+    private readonly _instantiationService;
+    groupByFile: boolean;
+    constructor(_textModelService: ITextModelService, _instantiationService: IInstantiationService);
+    hasChildren(element: BulkFileOperations | BulkEditElement): boolean;
+    getChildren(element: BulkFileOperations | BulkEditElement): Promise<BulkEditElement[]>;
+}
+export declare class BulkEditSorter implements ITreeSorter<BulkEditElement> {
+    compare(a: BulkEditElement, b: BulkEditElement): number;
+}
+export declare function compareBulkFileOperations(a: BulkFileOperation, b: BulkFileOperation): number;
+export declare class BulkEditAccessibilityProvider implements IListAccessibilityProvider<BulkEditElement> {
+    private readonly _labelService;
+    constructor(_labelService: ILabelService);
+    getWidgetAriaLabel(): string;
+    getRole(_element: BulkEditElement): AriaRole;
+    getAriaLabel(element: BulkEditElement): string | null;
+}
+export declare class BulkEditIdentityProvider implements IIdentityProvider<BulkEditElement> {
+    getId(element: BulkEditElement): {
+        toString(): string;
+    };
+}
+declare class CategoryElementTemplate {
+    readonly icon: HTMLDivElement;
+    readonly label: IconLabel;
+    constructor(container: HTMLElement);
+}
+export declare class CategoryElementRenderer implements ITreeRenderer<CategoryElement, FuzzyScore, CategoryElementTemplate> {
+    private readonly _themeService;
+    static readonly id: string;
+    readonly templateId: string;
+    constructor(_themeService: IThemeService);
+    renderTemplate(container: HTMLElement): CategoryElementTemplate;
+    renderElement(node: ITreeNode<CategoryElement, FuzzyScore>, _index: number, template: CategoryElementTemplate): void;
+    disposeTemplate(template: CategoryElementTemplate): void;
+}
+declare class FileElementTemplate {
+    private readonly _labelService;
+    private readonly _disposables;
+    private readonly _localDisposables;
+    private readonly _checkbox;
+    private readonly _label;
+    private readonly _details;
+    constructor(container: HTMLElement, resourceLabels: ResourceLabels, _labelService: ILabelService);
+    dispose(): void;
+    set(element: FileElement, score: FuzzyScore | undefined): void;
+}
+export declare class FileElementRenderer implements ITreeRenderer<FileElement, FuzzyScore, FileElementTemplate> {
+    private readonly _resourceLabels;
+    private readonly _labelService;
+    static readonly id: string;
+    readonly templateId: string;
+    constructor(_resourceLabels: ResourceLabels, _labelService: ILabelService);
+    renderTemplate(container: HTMLElement): FileElementTemplate;
+    renderElement(node: ITreeNode<FileElement, FuzzyScore>, _index: number, template: FileElementTemplate): void;
+    disposeTemplate(template: FileElementTemplate): void;
+}
+declare class TextEditElementTemplate {
+    private readonly _themeService;
+    private readonly _disposables;
+    private readonly _localDisposables;
+    private readonly _checkbox;
+    private readonly _icon;
+    private readonly _label;
+    constructor(container: HTMLElement, _themeService: IThemeService);
+    dispose(): void;
+    set(element: TextEditElement): void;
+}
+export declare class TextEditElementRenderer implements ITreeRenderer<TextEditElement, FuzzyScore, TextEditElementTemplate> {
+    private readonly _themeService;
+    static readonly id = "TextEditElementRenderer";
+    readonly templateId: string;
+    constructor(_themeService: IThemeService);
+    renderTemplate(container: HTMLElement): TextEditElementTemplate;
+    renderElement({ element }: ITreeNode<TextEditElement, FuzzyScore>, _index: number, template: TextEditElementTemplate): void;
+    disposeTemplate(_template: TextEditElementTemplate): void;
+}
+export declare class BulkEditDelegate implements IListVirtualDelegate<BulkEditElement> {
+    getHeight(): number;
+    getTemplateId(element: BulkEditElement): string;
+}
+export declare class BulkEditNaviLabelProvider implements IKeyboardNavigationLabelProvider<BulkEditElement> {
+    getKeyboardNavigationLabel(element: BulkEditElement): string | undefined;
+}
+export {};