@codingame/monaco-vscode-api 1.82.4-next.1 → 1.82.5-next.0

package/vscode/src/vs/workbench/contrib/searchEditor/browser/searchEditorActions.js

@@ -1,187 +0,0 @@
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import './media/searchEditor.css.js';
-import { isDiffEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
-import { IViewsService } from '../../../common/views.js';
-import { getSearchView } from '../../search/browser/searchActionsBase.js';
-import { SearchEditorInput, getOrMakeSearchEditorInput } from './searchEditorInput.js';
-import { serializeSearchResultForEditor } from './searchEditorSerialization.js';
-import { IConfigurationResolverService } from '../../../services/configurationResolver/common/configurationResolver.js';
-import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
-import { IEditorService, SIDE_GROUP, ACTIVE_GROUP } from '../../../services/editor/common/editorService.js';
-import { IHistoryService } from '../../../services/history/common/history.js';
-const toggleSearchEditorCaseSensitiveCommand = (accessor) => {
-    const editorService = accessor.get(IEditorService);
-    const input = editorService.activeEditor;
-    if (input instanceof SearchEditorInput) {
-        editorService.activeEditorPane.toggleCaseSensitive();
-    }
-};
-const toggleSearchEditorWholeWordCommand = (accessor) => {
-    const editorService = accessor.get(IEditorService);
-    const input = editorService.activeEditor;
-    if (input instanceof SearchEditorInput) {
-        editorService.activeEditorPane.toggleWholeWords();
-    }
-};
-const toggleSearchEditorRegexCommand = (accessor) => {
-    const editorService = accessor.get(IEditorService);
-    const input = editorService.activeEditor;
-    if (input instanceof SearchEditorInput) {
-        editorService.activeEditorPane.toggleRegex();
-    }
-};
-const toggleSearchEditorContextLinesCommand = (accessor) => {
-    const editorService = accessor.get(IEditorService);
-    const input = editorService.activeEditor;
-    if (input instanceof SearchEditorInput) {
-        editorService.activeEditorPane.toggleContextLines();
-    }
-};
-const modifySearchEditorContextLinesCommand = (accessor, increase) => {
-    const editorService = accessor.get(IEditorService);
-    const input = editorService.activeEditor;
-    if (input instanceof SearchEditorInput) {
-        editorService.activeEditorPane.modifyContextLines(increase);
-    }
-};
-const selectAllSearchEditorMatchesCommand = (accessor) => {
-    const editorService = accessor.get(IEditorService);
-    const input = editorService.activeEditor;
-    if (input instanceof SearchEditorInput) {
-        editorService.activeEditorPane.focusAllResults();
-    }
-};
-async function openSearchEditor(accessor) {
-    const viewsService = accessor.get(IViewsService);
-    const instantiationService = accessor.get(IInstantiationService);
-    const searchView = getSearchView(viewsService);
-    if (searchView) {
-        await instantiationService.invokeFunction(openNewSearchEditor, {
-            filesToInclude: searchView.searchIncludePattern.getValue(),
-            onlyOpenEditors: searchView.searchIncludePattern.onlySearchInOpenEditors(),
-            filesToExclude: searchView.searchExcludePattern.getValue(),
-            isRegexp: searchView.searchAndReplaceWidget.searchInput?.getRegex(),
-            isCaseSensitive: searchView.searchAndReplaceWidget.searchInput?.getCaseSensitive(),
-            matchWholeWord: searchView.searchAndReplaceWidget.searchInput?.getWholeWords(),
-            useExcludeSettingsAndIgnoreFiles: searchView.searchExcludePattern.useExcludesAndIgnoreFiles(),
-            showIncludesExcludes: !!(searchView.searchIncludePattern.getValue() || searchView.searchExcludePattern.getValue() || !searchView.searchExcludePattern.useExcludesAndIgnoreFiles())
-        });
-    }
-    else {
-        await instantiationService.invokeFunction(openNewSearchEditor);
-    }
-}
-const openNewSearchEditor = async (accessor, _args = {}, toSide = false) => {
-    const editorService = accessor.get(IEditorService);
-    const editorGroupsService = accessor.get(IEditorGroupsService);
-    const telemetryService = accessor.get(ITelemetryService);
-    const instantiationService = accessor.get(IInstantiationService);
-    const configurationService = accessor.get(IConfigurationService);
-    const configurationResolverService = accessor.get(IConfigurationResolverService);
-    const workspaceContextService = accessor.get(IWorkspaceContextService);
-    const historyService = accessor.get(IHistoryService);
-    const activeWorkspaceRootUri = historyService.getLastActiveWorkspaceRoot(Schemas.file);
-    const lastActiveWorkspaceRoot = activeWorkspaceRootUri ? workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri) ?? undefined : undefined;
-    const activeEditorControl = editorService.activeTextEditorControl;
-    let activeModel;
-    let selected = '';
-    if (activeEditorControl) {
-        if (isDiffEditor(activeEditorControl)) {
-            if (activeEditorControl.getOriginalEditor().hasTextFocus()) {
-                activeModel = activeEditorControl.getOriginalEditor();
-            }
-            else {
-                activeModel = activeEditorControl.getModifiedEditor();
-            }
-        }
-        else {
-            activeModel = activeEditorControl;
-        }
-        const selection = activeModel?.getSelection();
-        selected = (selection && activeModel?.getModel()?.getValueInRange(selection)) ?? '';
-        if (selection?.isEmpty() && configurationService.getValue('search').seedWithNearestWord) {
-            const wordAtPosition = activeModel.getModel()?.getWordAtPosition(selection.getStartPosition());
-            if (wordAtPosition) {
-                selected = wordAtPosition.word;
-            }
-        }
-    }
-    else {
-        if (editorService.activeEditor instanceof SearchEditorInput) {
-            const active = editorService.activeEditorPane;
-            selected = active.getSelected();
-        }
-    }
-    telemetryService.publicLog2('searchEditor/openNewSearchEditor');
-    const seedSearchStringFromSelection = _args.location === 'new' || configurationService.getValue('editor').find.seedSearchStringFromSelection;
-    const args = { query: seedSearchStringFromSelection ? selected : undefined };
-    for (const entry of Object.entries(_args)) {
-        const name = entry[0];
-        const value = entry[1];
-        if (value !== undefined) {
-            args[name] = (typeof value === 'string') ? await configurationResolverService.resolveAsync(lastActiveWorkspaceRoot, value) : value;
-        }
-    }
-    const existing = editorService.getEditors(0 ).find(id => id.editor.typeId === SearchEditorInput.ID);
-    let editor;
-    if (existing && args.location === 'reuse') {
-        const group = editorGroupsService.getGroup(existing.groupId);
-        if (!group) {
-            throw new Error('Invalid group id for search editor');
-        }
-        const input = existing.editor;
-        editor = (await group.openEditor(input));
-        if (selected) {
-            editor.setQuery(selected);
-        }
-        else {
-            editor.selectQuery();
-        }
-        editor.setSearchConfig(args);
-    }
-    else {
-        const input = instantiationService.invokeFunction(getOrMakeSearchEditorInput, { config: args, resultsContents: '', from: 'rawData' });
-        editor = await editorService.openEditor(input, { pinned: true }, toSide ? SIDE_GROUP : ACTIVE_GROUP);
-    }
-    const searchOnType = configurationService.getValue('search').searchOnType;
-    if (args.triggerSearch === true ||
-        args.triggerSearch !== false && searchOnType && args.query) {
-        editor.triggerSearch({ focusResults: args.focusResults });
-    }
-    if (!args.focusResults) {
-        editor.focusSearchInput();
-    }
-};
-const createEditorFromSearchResult = async (accessor, searchResult, rawIncludePattern, rawExcludePattern, onlySearchInOpenEditors) => {
-    if (!searchResult.query) {
-        console.error('Expected searchResult.query to be defined. Got', searchResult);
-        return;
-    }
-    const editorService = accessor.get(IEditorService);
-    const telemetryService = accessor.get(ITelemetryService);
-    const instantiationService = accessor.get(IInstantiationService);
-    const labelService = accessor.get(ILabelService);
-    const configurationService = accessor.get(IConfigurationService);
-    const sortOrder = configurationService.getValue('search').sortOrder;
-    telemetryService.publicLog2('searchEditor/createEditorFromSearchResult');
-    const labelFormatter = (uri) => labelService.getUriLabel(uri, { relative: true });
-    const { text, matchRanges, config } = serializeSearchResultForEditor(searchResult, rawIncludePattern, rawExcludePattern, 0, labelFormatter, sortOrder);
-    config.onlyOpenEditors = onlySearchInOpenEditors;
-    const contextLines = configurationService.getValue('search').searchEditor.defaultNumberOfContextLines;
-    if (searchResult.isDirty || contextLines === 0 || contextLines === null) {
-        const input = instantiationService.invokeFunction(getOrMakeSearchEditorInput, { resultsContents: text, config, from: 'rawData' });
-        await editorService.openEditor(input, { pinned: true });
-        input.setMatchRanges(matchRanges);
-    }
-    else {
-        const input = instantiationService.invokeFunction(getOrMakeSearchEditorInput, { from: 'rawData', resultsContents: '', config: { ...config, contextLines } });
-        const editor = await editorService.openEditor(input, { pinned: true });
-        editor.triggerSearch({ focusResults: true });
-    }
-};
-export { createEditorFromSearchResult, modifySearchEditorContextLinesCommand, openNewSearchEditor, openSearchEditor, selectAllSearchEditorMatchesCommand, toggleSearchEditorCaseSensitiveCommand, toggleSearchEditorContextLinesCommand, toggleSearchEditorRegexCommand, toggleSearchEditorWholeWordCommand };

package/vscode/src/vs/workbench/contrib/searchEditor/browser/searchEditorInput.js

@@ -1,298 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import './media/searchEditor.css.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
-import { isEqual, extname, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
-import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
-import { EditorResourceAccessor } from '../../../common/editor.js';
-import { Memento } from '../../../common/memento.js';
-import { SearchEditorInputTypeId, SearchEditorScheme, SearchEditorWorkingCopyTypeId, SearchEditorFindMatchClass } from './constants.js';
-import { SearchEditorModel, searchEditorModelFactory } from './searchEditorModel.js';
-import { serializeSearchConfiguration, parseSavedSearchEditor, defaultSearchConfig } from './searchEditorSerialization.js';
-import { IPathService } from '../../../services/path/common/pathService.js';
-import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
-import { IWorkingCopyService } from '../../../services/workingCopy/common/workingCopyService.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-import { bufferToReadable, VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
-import { EditorInput } from '../../../common/editor/editorInput.js';
-import { IFileDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-var SearchEditorInput_1;
-const SEARCH_EDITOR_EXT = '.code-search';
-let SearchEditorInput = class SearchEditorInput extends EditorInput {
-    static { SearchEditorInput_1 = this; }
-    static { this.ID = SearchEditorInputTypeId; }
-    get typeId() {
-        return SearchEditorInput_1.ID;
-    }
-    get editorId() {
-        return this.typeId;
-    }
-    get capabilities() {
-        let capabilities = 8 ;
-        if (!this.backingUri) {
-            capabilities |= 4 ;
-        }
-        return capabilities;
-    }
-    get resource() {
-        return this.backingUri || this.modelUri;
-    }
-    constructor(modelUri, backingUri, modelService, textFileService, fileDialogService, instantiationService, workingCopyService, telemetryService, pathService, storageService) {
-        super();
-        this.modelUri = modelUri;
-        this.backingUri = backingUri;
-        this.modelService = modelService;
-        this.textFileService = textFileService;
-        this.fileDialogService = fileDialogService;
-        this.instantiationService = instantiationService;
-        this.workingCopyService = workingCopyService;
-        this.telemetryService = telemetryService;
-        this.pathService = pathService;
-        this.dirty = false;
-        this._onDidChangeContent = this._register(( new Emitter()));
-        this.onDidChangeContent = this._onDidChangeContent.event;
-        this._onDidSave = this._register(( new Emitter()));
-        this.onDidSave = this._onDidSave.event;
-        this.oldDecorationsIDs = [];
-        this.model = instantiationService.createInstance(SearchEditorModel, modelUri);
-        if (this.modelUri.scheme !== SearchEditorScheme) {
-            throw Error('SearchEditorInput must be invoked with a SearchEditorScheme uri');
-        }
-        this.memento = ( new Memento(SearchEditorInput_1.ID, storageService));
-        storageService.onWillSaveState(() => this.memento.saveMemento());
-        const input = this;
-        const workingCopyAdapter = new (class {
-            constructor() {
-                this.typeId = SearchEditorWorkingCopyTypeId;
-                this.resource = input.modelUri;
-                this.capabilities = input.hasCapability(4 ) ? 2  : 0 ;
-                this.onDidChangeDirty = input.onDidChangeDirty;
-                this.onDidChangeContent = input.onDidChangeContent;
-                this.onDidSave = input.onDidSave;
-            }
-            get name() { return input.getName(); }
-            isDirty() { return input.isDirty(); }
-            isModified() { return input.isDirty(); }
-            backup(token) { return input.backup(token); }
-            save(options) { return input.save(0, options).then(editor => !!editor); }
-            revert(options) { return input.revert(0, options); }
-        });
-        this._register(this.workingCopyService.registerWorkingCopy(workingCopyAdapter));
-    }
-    async save(group, options) {
-        if (((await this.resolveModels()).resultsModel).isDisposed()) {
-            return;
-        }
-        if (this.backingUri) {
-            await this.textFileService.write(this.backingUri, await this.serializeForDisk(), options);
-            this.setDirty(false);
-            this._onDidSave.fire({ reason: options?.reason, source: options?.source });
-            return this;
-        }
-        else {
-            return this.saveAs(group, options);
-        }
-    }
-    tryReadConfigSync() {
-        return this._cachedConfigurationModel?.config;
-    }
-    async serializeForDisk() {
-        const { configurationModel, resultsModel } = await this.resolveModels();
-        return serializeSearchConfiguration(configurationModel.config) + '\n' + resultsModel.getValue();
-    }
-    registerConfigChangeListeners(model) {
-        this.configChangeListenerDisposable?.dispose();
-        if (!this.isDisposed()) {
-            this.configChangeListenerDisposable = model.onConfigDidUpdate(() => {
-                if (this.lastLabel !== this.getName()) {
-                    this._onDidChangeLabel.fire();
-                    this.lastLabel = this.getName();
-                }
-                this.memento.getMemento(1 , 1 ).searchConfig = model.config;
-            });
-            this._register(this.configChangeListenerDisposable);
-        }
-    }
-    async resolveModels() {
-        return this.model.resolve().then(data => {
-            this._cachedResultsModel = data.resultsModel;
-            this._cachedConfigurationModel = data.configurationModel;
-            if (this.lastLabel !== this.getName()) {
-                this._onDidChangeLabel.fire();
-                this.lastLabel = this.getName();
-            }
-            this.registerConfigChangeListeners(data.configurationModel);
-            return data;
-        });
-    }
-    async saveAs(group, options) {
-        const path = await this.fileDialogService.pickFileToSave(await this.suggestFileName(), options?.availableFileSystems);
-        if (path) {
-            this.telemetryService.publicLog2('searchEditor/saveSearchResults');
-            const toWrite = await this.serializeForDisk();
-            if (await this.textFileService.create([{ resource: path, value: toWrite, options: { overwrite: true } }])) {
-                this.setDirty(false);
-                if (!isEqual(path, this.modelUri)) {
-                    const input = this.instantiationService.invokeFunction(getOrMakeSearchEditorInput, { fileUri: path, from: 'existingFile' });
-                    input.setMatchRanges(this.getMatchRanges());
-                    return input;
-                }
-                return this;
-            }
-        }
-        return undefined;
-    }
-    getName(maxLength = 12) {
-        const trimToMax = (label) => (label.length < maxLength ? label : `${label.slice(0, maxLength - 3)}...`);
-        if (this.backingUri) {
-            const originalURI = EditorResourceAccessor.getOriginalUri(this);
-            return ( localize(
-                'searchTitle.withQuery',
-                "Search: {0}",
-                basename((originalURI ?? this.backingUri).path, SEARCH_EDITOR_EXT)
-            ));
-        }
-        const query = this._cachedConfigurationModel?.config?.query?.trim();
-        if (query) {
-            return ( localize('searchTitle.withQuery', "Search: {0}", trimToMax(query)));
-        }
-        return ( localize('searchTitle', "Search"));
-    }
-    setDirty(dirty) {
-        const wasDirty = this.dirty;
-        this.dirty = dirty;
-        if (wasDirty !== dirty) {
-            this._onDidChangeDirty.fire();
-        }
-    }
-    isDirty() {
-        return this.dirty;
-    }
-    async rename(group, target) {
-        if (extname(target) === SEARCH_EDITOR_EXT) {
-            return {
-                editor: this.instantiationService.invokeFunction(getOrMakeSearchEditorInput, { from: 'existingFile', fileUri: target })
-            };
-        }
-        return undefined;
-    }
-    dispose() {
-        this.modelService.destroyModel(this.modelUri);
-        super.dispose();
-    }
-    matches(other) {
-        if (super.matches(other)) {
-            return true;
-        }
-        if (other instanceof SearchEditorInput_1) {
-            return !!(other.modelUri.fragment && other.modelUri.fragment === this.modelUri.fragment) || !!(other.backingUri && isEqual(other.backingUri, this.backingUri));
-        }
-        return false;
-    }
-    getMatchRanges() {
-        return ( (this._cachedResultsModel?.getAllDecorations() ?? [])
-            .filter(decoration => decoration.options.className === SearchEditorFindMatchClass)
-            .filter(({ range }) => !(range.startColumn === 1 && range.endColumn === 1))
-            .map(({ range }) => range));
-    }
-    async setMatchRanges(ranges) {
-        this.oldDecorationsIDs = (await this.resolveModels()).resultsModel.deltaDecorations(this.oldDecorationsIDs, ( ranges.map(
-            range => ({ range, options: { description: 'search-editor-find-match', className: SearchEditorFindMatchClass, stickiness: 1  } })
-        )));
-    }
-    async revert(group, options) {
-        if (options?.soft) {
-            this.setDirty(false);
-            return;
-        }
-        if (this.backingUri) {
-            const { config, text } = await this.instantiationService.invokeFunction(parseSavedSearchEditor, this.backingUri);
-            const { resultsModel, configurationModel } = await this.resolveModels();
-            resultsModel.setValue(text);
-            configurationModel.updateConfig(config);
-        }
-        else {
-            (await this.resolveModels()).resultsModel.setValue('');
-        }
-        super.revert(group, options);
-        this.setDirty(false);
-    }
-    async backup(token) {
-        const contents = await this.serializeForDisk();
-        if (token.isCancellationRequested) {
-            return {};
-        }
-        return {
-            content: bufferToReadable(VSBuffer.fromString(contents))
-        };
-    }
-    async suggestFileName() {
-        const query = (await this.resolveModels()).configurationModel.config.query;
-        const searchFileName = (query.replace(/[^\w \-_]+/g, '_') || 'Search') + SEARCH_EDITOR_EXT;
-        return joinPath(await this.fileDialogService.defaultFilePath(this.pathService.defaultUriScheme), searchFileName);
-    }
-    toUntyped() {
-        if (this.hasCapability(4 )) {
-            return undefined;
-        }
-        return {
-            resource: this.resource,
-            options: {
-                override: SearchEditorInput_1.ID
-            }
-        };
-    }
-};
-SearchEditorInput = SearchEditorInput_1 = ( __decorate([
-    ( __param(2, IModelService)),
-    ( __param(3, ITextFileService)),
-    ( __param(4, IFileDialogService)),
-    ( __param(5, IInstantiationService)),
-    ( __param(6, IWorkingCopyService)),
-    ( __param(7, ITelemetryService)),
-    ( __param(8, IPathService)),
-    ( __param(9, IStorageService))
-], SearchEditorInput));
-const getOrMakeSearchEditorInput = (accessor, existingData) => {
-    const storageService = accessor.get(IStorageService);
-    const configurationService = accessor.get(IConfigurationService);
-    const instantiationService = accessor.get(IInstantiationService);
-    const modelUri = existingData.from === 'model' ? existingData.modelUri : ( URI.from({ scheme: SearchEditorScheme, fragment: `${Math.random()}` }));
-    if (!( searchEditorModelFactory.models.has(modelUri))) {
-        if (existingData.from === 'existingFile') {
-            instantiationService.invokeFunction(accessor => searchEditorModelFactory.initializeModelFromExistingFile(accessor, modelUri, existingData.fileUri));
-        }
-        else {
-            const searchEditorSettings = configurationService.getValue('search').searchEditor;
-            const reuseOldSettings = searchEditorSettings.reusePriorSearchConfiguration;
-            const defaultNumberOfContextLines = searchEditorSettings.defaultNumberOfContextLines;
-            const priorConfig = reuseOldSettings ? ( new Memento(SearchEditorInput.ID, storageService)).getMemento(1 , 1 ).searchConfig : {};
-            const defaultConfig = defaultSearchConfig();
-            const config = { ...defaultConfig, ...priorConfig, ...existingData.config };
-            if (defaultNumberOfContextLines !== null && defaultNumberOfContextLines !== undefined) {
-                config.contextLines = existingData?.config?.contextLines ?? defaultNumberOfContextLines;
-            }
-            if (existingData.from === 'rawData') {
-                if (existingData.resultsContents) {
-                    config.contextLines = 0;
-                }
-                instantiationService.invokeFunction(accessor => searchEditorModelFactory.initializeModelFromRawData(accessor, modelUri, config, existingData.resultsContents));
-            }
-            else {
-                instantiationService.invokeFunction(accessor => searchEditorModelFactory.initializeModelFromExistingModel(accessor, modelUri, config));
-            }
-        }
-    }
-    return instantiationService.createInstance(SearchEditorInput, modelUri, existingData.from === 'existingFile'
-        ? existingData.fileUri
-        : existingData.from === 'model'
-            ? existingData.backupOf
-            : undefined);
-};
-export { SEARCH_EDITOR_EXT, SearchEditorInput, getOrMakeSearchEditorInput };

package/vscode/src/vs/workbench/contrib/searchEditor/browser/searchEditorModel.js

@@ -1,135 +0,0 @@
-import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-import { parseSavedSearchEditor, parseSerializedSearchEditor } from './searchEditorSerialization.js';
-import { IWorkingCopyBackupService } from '../../../services/workingCopy/common/workingCopyBackup.js';
-import { assertIsDefined } from 'monaco-editor/esm/vs/base/common/types.js';
-import { createTextBufferFactoryFromStream } from 'monaco-editor/esm/vs/editor/common/model/textModel.js';
-import { SearchEditorWorkingCopyTypeId } from './constants.js';
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
-class SearchConfigurationModel {
-    constructor(config) {
-        this.config = config;
-        this._onConfigDidUpdate = ( new Emitter());
-        this.onConfigDidUpdate = this._onConfigDidUpdate.event;
-    }
-    updateConfig(config) { this.config = config; this._onConfigDidUpdate.fire(config); }
-}
-class SearchEditorModel {
-    constructor(resource) {
-        this.resource = resource;
-    }
-    async resolve() {
-        return assertIsDefined(searchEditorModelFactory.models.get(this.resource)).resolve();
-    }
-}
-class SearchEditorModelFactory {
-    constructor() {
-        this.models = ( new ResourceMap());
-    }
-    initializeModelFromExistingModel(accessor, resource, config) {
-        if (( this.models.has(resource))) {
-            throw Error('Unable to contruct model for resource that already exists');
-        }
-        const languageService = accessor.get(ILanguageService);
-        const modelService = accessor.get(IModelService);
-        const instantiationService = accessor.get(IInstantiationService);
-        const workingCopyBackupService = accessor.get(IWorkingCopyBackupService);
-        let ongoingResolve;
-        this.models.set(resource, {
-            resolve: () => {
-                if (!ongoingResolve) {
-                    ongoingResolve = (async () => {
-                        const backup = await this.tryFetchModelFromBackupService(resource, languageService, modelService, workingCopyBackupService, instantiationService);
-                        if (backup) {
-                            return backup;
-                        }
-                        return Promise.resolve({
-                            resultsModel: modelService.getModel(resource) ?? modelService.createModel('', languageService.createById('search-result'), resource),
-                            configurationModel: ( new SearchConfigurationModel(config))
-                        });
-                    })();
-                }
-                return ongoingResolve;
-            }
-        });
-    }
-    initializeModelFromRawData(accessor, resource, config, contents) {
-        if (( this.models.has(resource))) {
-            throw Error('Unable to contruct model for resource that already exists');
-        }
-        const languageService = accessor.get(ILanguageService);
-        const modelService = accessor.get(IModelService);
-        const instantiationService = accessor.get(IInstantiationService);
-        const workingCopyBackupService = accessor.get(IWorkingCopyBackupService);
-        let ongoingResolve;
-        this.models.set(resource, {
-            resolve: () => {
-                if (!ongoingResolve) {
-                    ongoingResolve = (async () => {
-                        const backup = await this.tryFetchModelFromBackupService(resource, languageService, modelService, workingCopyBackupService, instantiationService);
-                        if (backup) {
-                            return backup;
-                        }
-                        return Promise.resolve({
-                            resultsModel: modelService.createModel(contents ?? '', languageService.createById('search-result'), resource),
-                            configurationModel: ( new SearchConfigurationModel(config))
-                        });
-                    })();
-                }
-                return ongoingResolve;
-            }
-        });
-    }
-    initializeModelFromExistingFile(accessor, resource, existingFile) {
-        if (( this.models.has(resource))) {
-            throw Error('Unable to contruct model for resource that already exists');
-        }
-        const languageService = accessor.get(ILanguageService);
-        const modelService = accessor.get(IModelService);
-        const instantiationService = accessor.get(IInstantiationService);
-        const workingCopyBackupService = accessor.get(IWorkingCopyBackupService);
-        let ongoingResolve;
-        this.models.set(resource, {
-            resolve: async () => {
-                if (!ongoingResolve) {
-                    ongoingResolve = (async () => {
-                        const backup = await this.tryFetchModelFromBackupService(resource, languageService, modelService, workingCopyBackupService, instantiationService);
-                        if (backup) {
-                            return backup;
-                        }
-                        const { text, config } = await instantiationService.invokeFunction(parseSavedSearchEditor, existingFile);
-                        return ({
-                            resultsModel: modelService.createModel(text ?? '', languageService.createById('search-result'), resource),
-                            configurationModel: ( new SearchConfigurationModel(config))
-                        });
-                    })();
-                }
-                return ongoingResolve;
-            }
-        });
-    }
-    async tryFetchModelFromBackupService(resource, languageService, modelService, workingCopyBackupService, instantiationService) {
-        const backup = await workingCopyBackupService.resolve({ resource, typeId: SearchEditorWorkingCopyTypeId });
-        let model = modelService.getModel(resource);
-        if (!model && backup) {
-            const factory = await createTextBufferFactoryFromStream(backup.value);
-            model = modelService.createModel(factory, languageService.createById('search-result'), resource);
-        }
-        if (model) {
-            const existingFile = model.getValue();
-            const { text, config } = parseSerializedSearchEditor(existingFile);
-            modelService.destroyModel(resource);
-            return ({
-                resultsModel: modelService.createModel(text ?? '', languageService.createById('search-result'), resource),
-                configurationModel: ( new SearchConfigurationModel(config))
-            });
-        }
-        else {
-            return undefined;
-        }
-    }
-}
-const searchEditorModelFactory = ( new SearchEditorModelFactory());
-export { SearchConfigurationModel, SearchEditorModel, searchEditorModelFactory };