@codingame/monaco-vscode-notebook-service-override 1.85.1 → 1.85.2

package/notebook.js

@@ -22,6 +22,8 @@ import { INotebookExecutionStateService } from 'vscode/vscode/vs/workbench/contr
 import { NotebookKernelHistoryService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookKernelHistoryServiceImpl.js';
 import { INotebookLoggingService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookLoggingService';
 import { NotebookLoggingService } from './vscode/src/vs/workbench/contrib/notebook/browser/services/notebookLoggingServiceImpl.js';
+import { INotebookSearchService } from 'vscode/vscode/vs/workbench/contrib/search/common/notebookSearch';
+import { NotebookSearchService } from './vscode/src/vs/workbench/contrib/search/browser/notebookSearch/notebookSearchService.js';
 import './vscode/src/vs/workbench/contrib/notebook/browser/notebook.contribution.js';
 
 function getServiceOverride() {
@@ -37,7 +39,8 @@ function getServiceOverride() {
         [( INotebookExecutionStateService.toString())]: new SyncDescriptor(NotebookExecutionStateService, [], true),
         [( INotebookRendererMessagingService.toString())]: new SyncDescriptor(NotebookRendererMessagingService, [], true),
         [( INotebookKeymapService.toString())]: new SyncDescriptor(NotebookKeymapService, [], true),
-        [( INotebookLoggingService.toString())]: new SyncDescriptor(NotebookLoggingService, [], true)
+        [( INotebookLoggingService.toString())]: new SyncDescriptor(NotebookLoggingService, [], true),
+        [( INotebookSearchService.toString())]: new SyncDescriptor(NotebookSearchService, [], true)
     };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-notebook-service-override",
-  "version": "1.85.1",
+  "version": "1.85.2",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.85.1",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.85.2",
     "monaco-editor": "0.45.0"
   },
   "exports": {

package/vscode/src/vs/workbench/contrib/search/browser/notebookSearch/notebookSearchService.js

@@ -0,0 +1,197 @@
+import { __decorate, __param } from '../../../../../../../../external/tslib/tslib.es6.js';
+import { CancellationToken } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { ResourceSet, ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { INotebookService } from 'vscode/vscode/vs/workbench/contrib/notebook/common/notebookService';
+import { contentMatchesToTextSearchMatches, webviewMatchesToTextSearchMatches } from 'vscode/vscode/vs/workbench/contrib/search/browser/notebookSearch/searchNotebookHelpers';
+import * as arrays from 'monaco-editor/esm/vs/base/common/arrays.js';
+import { isNumber } from 'monaco-editor/esm/vs/base/common/types.js';
+import { IEditorResolverService } from 'vscode/vscode/vs/workbench/services/editor/common/editorResolverService';
+import { INotebookEditorService } from 'vscode/vscode/vs/workbench/contrib/notebook/browser/services/notebookEditorService';
+
+let NotebookSearchService = class NotebookSearchService {
+    constructor(uriIdentityService, notebookEditorService, logService, notebookService, configurationService, editorResolverService) {
+        this.uriIdentityService = uriIdentityService;
+        this.notebookEditorService = notebookEditorService;
+        this.logService = logService;
+        this.notebookService = notebookService;
+        this.configurationService = configurationService;
+        this.editorResolverService = editorResolverService;
+    }
+    notebookSearch(query, token, searchInstanceID, onProgress) {
+        if (query.type !== 2 ) {
+            return {
+                openFilesToScan: ( new ResourceSet()),
+                completeData: Promise.resolve({
+                    messages: [],
+                    limitHit: false,
+                    results: [],
+                }),
+                allScannedFiles: Promise.resolve(( new ResourceSet())),
+            };
+        }
+        const localNotebookWidgets = this.getLocalNotebookWidgets();
+        const localNotebookFiles = ( localNotebookWidgets.map(widget => widget.viewModel.uri));
+        const getAllResults = () => {
+            const searchStart = Date.now();
+            const localResultPromise = this.getLocalNotebookResults(query, token ?? CancellationToken.None, localNotebookWidgets, searchInstanceID);
+            const searchLocalEnd = Date.now();
+            const experimentalNotebooksEnabled = this.configurationService.getValue('search').experimental?.closedNotebookRichContentResults ?? false;
+            let closedResultsPromise = Promise.resolve(undefined);
+            if (experimentalNotebooksEnabled) {
+                closedResultsPromise = this.getClosedNotebookResults(query, ( new ResourceSet(
+                    localNotebookFiles,
+                    uri => this.uriIdentityService.extUri.getComparisonKey(uri)
+                )), token ?? CancellationToken.None);
+            }
+            const promise = Promise.all([localResultPromise, closedResultsPromise]);
+            return {
+                completeData: promise.then((resolvedPromise) => {
+                    const openNotebookResult = resolvedPromise[0];
+                    const closedNotebookResult = resolvedPromise[1];
+                    const resolved = resolvedPromise.filter((e) => !!e);
+                    const resultArray = [...( openNotebookResult.results.values()), ...(closedNotebookResult?.results.values() ?? [])];
+                    const results = arrays.coalesce(resultArray);
+                    if (onProgress) {
+                        results.forEach(onProgress);
+                    }
+                    this.logService.trace(`local notebook search time | ${searchLocalEnd - searchStart}ms`);
+                    return {
+                        messages: [],
+                        limitHit: resolved.reduce((prev, cur) => prev || cur.limitHit, false),
+                        results,
+                    };
+                }),
+                allScannedFiles: promise.then(resolvedPromise => {
+                    const openNotebookResults = resolvedPromise[0];
+                    const closedNotebookResults = resolvedPromise[1];
+                    const results = arrays.coalesce([...( openNotebookResults.results.keys()), ...(closedNotebookResults?.results.keys() ?? [])]);
+                    return ( new ResourceSet(results, uri => this.uriIdentityService.extUri.getComparisonKey(uri)));
+                })
+            };
+        };
+        const promiseResults = getAllResults();
+        return {
+            openFilesToScan: ( new ResourceSet(localNotebookFiles)),
+            completeData: promiseResults.completeData,
+            allScannedFiles: promiseResults.allScannedFiles
+        };
+    }
+    async getClosedNotebookResults(textQuery, scannedFiles, token) {
+        const userAssociations = this.editorResolverService.getAllUserAssociations();
+        const allPriorityInfo = ( new Map());
+        const contributedNotebookTypes = this.notebookService.getContributedNotebookTypes();
+        userAssociations.forEach(association => {
+            if (!association.filenamePattern) {
+                return;
+            }
+            const info = {
+                isFromSettings: true,
+                filenamePatterns: [association.filenamePattern]
+            };
+            const existingEntry = allPriorityInfo.get(association.viewType);
+            if (existingEntry) {
+                allPriorityInfo.set(association.viewType, existingEntry.concat(info));
+            }
+            else {
+                allPriorityInfo.set(association.viewType, [info]);
+            }
+        });
+        const promises = [];
+        contributedNotebookTypes.forEach((notebook) => {
+            promises.push((async () => {
+                const serializer = (await this.notebookService.withNotebookDataProvider(notebook.id)).serializer;
+                return await serializer.searchInNotebooks(textQuery, token, allPriorityInfo);
+            })());
+        });
+        const start = Date.now();
+        const searchComplete = (await Promise.all(promises));
+        const results = searchComplete.flatMap(e => e.results);
+        let limitHit = ( searchComplete.some(e => e.limitHit));
+        const uniqueResults = ( new ResourceMap(uri => this.uriIdentityService.extUri.getComparisonKey(uri)));
+        let numResults = 0;
+        for (const result of results) {
+            if (textQuery.maxResults && numResults >= textQuery.maxResults) {
+                limitHit = true;
+                break;
+            }
+            if (!( scannedFiles.has(result.resource)) && !( uniqueResults.has(result.resource))) {
+                uniqueResults.set(result.resource, result.cellResults.length > 0 ? result : null);
+                numResults++;
+            }
+        }
+        const end = Date.now();
+        this.logService.trace(`query: ${textQuery.contentPattern.pattern}`);
+        this.logService.trace(`closed notebook search time | ${end - start}ms`);
+        return {
+            results: uniqueResults,
+            limitHit
+        };
+    }
+    async getLocalNotebookResults(query, token, widgets, searchID) {
+        const localResults = ( new ResourceMap(uri => this.uriIdentityService.extUri.getComparisonKey(uri)));
+        let limitHit = false;
+        for (const widget of widgets) {
+            if (!widget.hasModel()) {
+                continue;
+            }
+            const askMax = isNumber(query.maxResults) ? query.maxResults + 1 : Number.MAX_SAFE_INTEGER;
+            let matches = await widget
+                .find(query.contentPattern.pattern, {
+                regex: query.contentPattern.isRegExp,
+                wholeWord: query.contentPattern.isWordMatch,
+                caseSensitive: query.contentPattern.isCaseSensitive,
+                includeMarkupInput: query.contentPattern.notebookInfo?.isInNotebookMarkdownInput ?? true,
+                includeMarkupPreview: query.contentPattern.notebookInfo?.isInNotebookMarkdownPreview ?? true,
+                includeCodeInput: query.contentPattern.notebookInfo?.isInNotebookCellInput ?? true,
+                includeOutput: query.contentPattern.notebookInfo?.isInNotebookCellOutput ?? true,
+            }, token, false, true, searchID);
+            const uri = widget.viewModel.uri;
+            if (matches.length) {
+                if (askMax && matches.length >= askMax) {
+                    limitHit = true;
+                    matches = matches.slice(0, askMax - 1);
+                }
+                const cellResults = ( matches.map(match => {
+                    const contentResults = contentMatchesToTextSearchMatches(match.contentMatches, match.cell);
+                    const webviewResults = webviewMatchesToTextSearchMatches(match.webviewMatches);
+                    return {
+                        cell: match.cell,
+                        index: match.index,
+                        contentResults: contentResults,
+                        webviewResults: webviewResults,
+                    };
+                }));
+                const fileMatch = {
+                    resource: uri, cellResults: cellResults
+                };
+                localResults.set(uri, fileMatch);
+            }
+            else {
+                localResults.set(uri, null);
+            }
+        }
+        return {
+            results: localResults,
+            limitHit
+        };
+    }
+    getLocalNotebookWidgets() {
+        const notebookWidgets = this.notebookEditorService.retrieveAllExistingWidgets();
+        return ( notebookWidgets
+            .map(widget => widget.value))
+            .filter((val) => !!val && val.hasModel());
+    }
+};
+NotebookSearchService = ( __decorate([
+    ( __param(0, IUriIdentityService)),
+    ( __param(1, INotebookEditorService)),
+    ( __param(2, ILogService)),
+    ( __param(3, INotebookService)),
+    ( __param(4, IConfigurationService)),
+    ( __param(5, IEditorResolverService))
+], NotebookSearchService));
+
+export { NotebookSearchService };