@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.0

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

@@ -0,0 +1,188 @@
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { withNullAsUndefined } from 'monaco-editor/esm/vs/base/common/types.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 ? withNullAsUndefined(workspaceContextService.getWorkspaceFolder(activeWorkspaceRootUri)) : 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/dist/vscode/vs/workbench/contrib/searchEditor/browser/searchEditorInput.js

@@ -0,0 +1,295 @@
+import { __decorate, __param } from '../../../../../../node_modules/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 { IFileDialogService } from 'monaco-editor/esm/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';
+const SEARCH_EDITOR_EXT = '.code-search';
+let SearchEditorInput = class SearchEditorInput extends EditorInput {
+    get typeId() {
+        return SearchEditorInput.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.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) {
+            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.ID
+            }
+        };
+    }
+};
+SearchEditorInput.ID = SearchEditorInputTypeId;
+SearchEditorInput = ( __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/dist/vscode/vs/workbench/contrib/searchEditor/browser/searchEditorModel.js

@@ -0,0 +1,135 @@
+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 };