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

package/dist/vscode/vs/workbench/services/preferences/common/preferencesModels.js

@@ -223,9 +223,15 @@ let Settings2EditorModel = class Settings2EditorModel extends AbstractSettingsMo
     }
     get settingsGroups() {
         const groups = this._defaultSettings.getSettingsGroups(this.dirty);
+        if (this.additionalGroups?.length) {
+            groups.push(...this.additionalGroups);
+        }
         this.dirty = false;
         return groups;
     }
+    setAdditionalGroups(groups) {
+        this.additionalGroups = groups;
+    }
     findValueMatches(filter, setting) {
         return [];
     }

package/dist/vscode/vs/workbench/services/preferences/common/preferencesValidation.js

@@ -63,6 +63,42 @@ function createValidator(prop) {
         return '';
     };
 }
+function getInvalidTypeError(value, type) {
+    if (typeof type === 'undefined') {
+        return;
+    }
+    const typeArr = Array.isArray(type) ? type : [type];
+    if (!( typeArr.some(_type => valueValidatesAsType(value, _type)))) {
+        return ( nls.localize(
+            'invalidTypeError',
+            "Setting has an invalid type, expected {0}. Fix in JSON.",
+            JSON.stringify(type)
+        ));
+    }
+    return;
+}
+function valueValidatesAsType(value, type) {
+    const valueType = typeof value;
+    if (type === 'boolean') {
+        return valueType === 'boolean';
+    }
+    else if (type === 'object') {
+        return value && !Array.isArray(value) && valueType === 'object';
+    }
+    else if (type === 'null') {
+        return value === null;
+    }
+    else if (type === 'array') {
+        return Array.isArray(value);
+    }
+    else if (type === 'string') {
+        return valueType === 'string';
+    }
+    else if (type === 'number' || type === 'integer') {
+        return valueType === 'number';
+    }
+    return true;
+}
 function getStringValidators(prop) {
     const uriRegex = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
     let patternRegex;
@@ -354,4 +390,4 @@ function getErrorsForSchema(propertySchema, data) {
     const errorMessage = validator(data);
     return errorMessage;
 }
-export { createValidator };
+export { createValidator, getInvalidTypeError };

package/dist/vscode/vs/workbench/services/remote/common/remoteAgentService.js

@@ -1,3 +1,72 @@
+import { __classPrivateFieldGet, __classPrivateFieldSet } from '../../../../../../node_modules/tslib/tslib.es6.js';
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { timeout } from 'monaco-editor/esm/vs/base/common/async.js';
+var _maxSampleCount, _sampleDelay, _initial, _maxInitialCount, _average, _maxAverageCount, _highLatencyMultiple, _highLatencyMinThreshold, _highLatencyMaxThreshold, _lastMeasurement, _a;
 const IRemoteAgentService = ( createDecorator('remoteAgentService'));
+new (_a = class {
+        constructor() {
+            _maxSampleCount.set(this, 5);
+            _sampleDelay.set(this, 2000);
+            _initial.set(this, []);
+            _maxInitialCount.set(this, 3);
+            _average.set(this, []);
+            _maxAverageCount.set(this, 100);
+            _highLatencyMultiple.set(this, 2);
+            _highLatencyMinThreshold.set(this, 500);
+            _highLatencyMaxThreshold.set(this, 1500);
+            _lastMeasurement.set(this, undefined);
+        }
+        get latency() { return __classPrivateFieldGet(this, _lastMeasurement, "f"); }
+        async measure(remoteAgentService) {
+            let currentLatency = Infinity;
+            for (let i = 0; i < __classPrivateFieldGet(this, _maxSampleCount, "f"); i++) {
+                const rtt = await remoteAgentService.getRoundTripTime();
+                if (rtt === undefined) {
+                    return undefined;
+                }
+                currentLatency = Math.min(currentLatency, rtt / 2 );
+                await timeout(__classPrivateFieldGet(this, _sampleDelay, "f"));
+            }
+            __classPrivateFieldGet(this, _average, "f").push(currentLatency);
+            if (__classPrivateFieldGet(this, _average, "f").length > __classPrivateFieldGet(this, _maxAverageCount, "f")) {
+                __classPrivateFieldGet(this, _average, "f").shift();
+            }
+            let initialLatency = undefined;
+            if (__classPrivateFieldGet(this, _initial, "f").length < __classPrivateFieldGet(this, _maxInitialCount, "f")) {
+                __classPrivateFieldGet(this, _initial, "f").push(currentLatency);
+            }
+            else {
+                initialLatency = __classPrivateFieldGet(this, _initial, "f").reduce((sum, value) => sum + value, 0) / __classPrivateFieldGet(this, _initial, "f").length;
+            }
+            __classPrivateFieldSet(this, _lastMeasurement, {
+                initial: initialLatency,
+                current: currentLatency,
+                average: __classPrivateFieldGet(this, _average, "f").reduce((sum, value) => sum + value, 0) / __classPrivateFieldGet(this, _average, "f").length,
+                high: (() => {
+                    if (typeof initialLatency === 'undefined') {
+                        return false;
+                    }
+                    if (currentLatency > __classPrivateFieldGet(this, _highLatencyMaxThreshold, "f")) {
+                        return true;
+                    }
+                    if (currentLatency > __classPrivateFieldGet(this, _highLatencyMinThreshold, "f") && currentLatency > initialLatency * __classPrivateFieldGet(this, _highLatencyMultiple, "f")) {
+                        return true;
+                    }
+                    return false;
+                })()
+            }, "f");
+            return __classPrivateFieldGet(this, _lastMeasurement, "f");
+        }
+    },
+    _maxSampleCount = ( new WeakMap()),
+    _sampleDelay = ( new WeakMap()),
+    _initial = ( new WeakMap()),
+    _maxInitialCount = ( new WeakMap()),
+    _average = ( new WeakMap()),
+    _maxAverageCount = ( new WeakMap()),
+    _highLatencyMultiple = ( new WeakMap()),
+    _highLatencyMinThreshold = ( new WeakMap()),
+    _highLatencyMaxThreshold = ( new WeakMap()),
+    _lastMeasurement = ( new WeakMap()),
+    _a);
 export { IRemoteAgentService };

package/dist/vscode/vs/workbench/services/remote/common/remoteExplorerService.js

@@ -28,6 +28,12 @@ var TunnelType;
     TunnelType["Forwarded"] = "Forwarded";
     TunnelType["Add"] = "Add";
 })(TunnelType || (TunnelType = {}))));
+var TunnelCloseReason;
+( ((function(TunnelCloseReason) {
+    TunnelCloseReason["Other"] = "Other";
+    TunnelCloseReason["User"] = "User";
+    TunnelCloseReason["AutoForwardEnd"] = "AutoForwardEnd";
+})(TunnelCloseReason || (TunnelCloseReason = {}))));
 var TunnelEditId;
 ( ((function(TunnelEditId) {
     TunnelEditId[TunnelEditId["None"] = 0] = "None";
@@ -324,6 +330,7 @@ let TunnelModel = class TunnelModel extends Disposable {
         this.onEnvironmentTunnelsSet = this._onEnvironmentTunnelsSet.event;
         this._environmentTunnelsSet = false;
         this.unrestoredExtensionTunnels = ( (new Map()));
+        this.sessionCachedProperties = ( (new Map()));
         this.portAttributesProviders = [];
         this.mismatchCooldown = ( (new Date()));
         this.configPortsAttributes = ( (new PortsAttributes(configurationService)));
@@ -385,10 +392,10 @@ let TunnelModel = class TunnelModel extends Disposable {
             this._onForwardPort.fire(this.forwarded.get(key));
         }));
         this._register(this.tunnelService.onTunnelClosed(address => {
-            return this.onTunnelClosed(address);
+            return this.onTunnelClosed(address, TunnelCloseReason.Other);
         }));
     }
-    async onTunnelClosed(address) {
+    async onTunnelClosed(address, reason) {
         const key = makeAddress(address.host, address.port);
         if (( (this.forwarded.has(key)))) {
             this.forwarded.delete(key);
@@ -509,7 +516,8 @@ let TunnelModel = class TunnelModel extends Disposable {
             } : undefined;
             const key = makeAddress(tunnelProperties.remote.host, tunnelProperties.remote.port);
             this.inProgress.set(key, true);
-            let tunnel = await this.tunnelService.openTunnel(addressProvider, tunnelProperties.remote.host, tunnelProperties.remote.port, undefined, localPort, (!tunnelProperties.elevateIfNeeded) ? attributes?.elevateIfNeeded : tunnelProperties.elevateIfNeeded, tunnelProperties.privacy, attributes?.protocol);
+            tunnelProperties = this.mergeCachedAndUnrestoredProperties(key, tunnelProperties);
+            const tunnel = await this.tunnelService.openTunnel(addressProvider, tunnelProperties.remote.host, tunnelProperties.remote.port, undefined, localPort, (!tunnelProperties.elevateIfNeeded) ? attributes?.elevateIfNeeded : tunnelProperties.elevateIfNeeded, tunnelProperties.privacy, attributes?.protocol);
             if (tunnel && tunnel.localAddress) {
                 const matchingCandidate = mapHasAddressLocalhostOrAllInterfaces(this._candidates ?? ( (new Map())), tunnelProperties.remote.host, tunnelProperties.remote.port);
                 const protocol = (tunnel.protocol ?
@@ -536,37 +544,59 @@ let TunnelModel = class TunnelModel extends Disposable {
                 await this.storeForwarded();
                 await this.showPortMismatchModalIfNeeded(tunnel, localPort, attributes);
                 this._onForwardPort.fire(newForward);
-                if (( (this.unrestoredExtensionTunnels.has(key)))) {
-                    const updateProps = this.unrestoredExtensionTunnels.get(key);
-                    this.unrestoredExtensionTunnels.delete(key);
-                    if (updateProps) {
-                        tunnel = await this.forward({
-                            remote: { host: newForward.remoteHost, port: newForward.remotePort },
-                            local: newForward.localPort,
-                            name: newForward.name,
-                            privacy: updateProps.privacy,
-                            elevateIfNeeded: true,
-                        });
-                    }
-                }
                 return tunnel;
             }
             this.inProgress.delete(key);
         }
         else {
-            const newName = attributes?.label ?? tunnelProperties.name;
-            if (newName !== existingTunnel.name) {
-                existingTunnel.name = newName;
+            return this.mergeAttributesIntoExistingTunnel(existingTunnel, tunnelProperties, attributes);
+        }
+        return undefined;
+    }
+    mergeCachedAndUnrestoredProperties(key, tunnelProperties) {
+        const map = ( (this.unrestoredExtensionTunnels.has(key))) ? this.unrestoredExtensionTunnels : (( (this.sessionCachedProperties.has(key))) ? this.sessionCachedProperties : undefined);
+        if (map) {
+            const updateProps = map.get(key);
+            map.delete(key);
+            if (updateProps) {
+                tunnelProperties.name = updateProps.name ?? tunnelProperties.name;
+                tunnelProperties.local = (('local' in updateProps) ? updateProps.local : (('localPort' in updateProps) ? updateProps.localPort : undefined)) ?? tunnelProperties.local;
+                tunnelProperties.privacy = updateProps.privacy ?? tunnelProperties.privacy;
+            }
+        }
+        return tunnelProperties;
+    }
+    async mergeAttributesIntoExistingTunnel(existingTunnel, tunnelProperties, attributes) {
+        const newName = attributes?.label ?? tunnelProperties.name;
+        let MergedAttributeAction;
+        ( ((function(MergedAttributeAction) {
+            MergedAttributeAction[MergedAttributeAction["None"] = 0] = "None";
+            MergedAttributeAction[MergedAttributeAction["Fire"] = 1] = "Fire";
+            MergedAttributeAction[MergedAttributeAction["Reopen"] = 2] = "Reopen";
+        })(MergedAttributeAction || (MergedAttributeAction = {}))));
+        let mergedAction = MergedAttributeAction.None;
+        if (newName !== existingTunnel.name) {
+            existingTunnel.name = newName;
+            mergedAction = MergedAttributeAction.Fire;
+        }
+        if ((attributes?.protocol || (existingTunnel.protocol !== TunnelProtocol.Http)) && (attributes?.protocol !== existingTunnel.protocol)) {
+            tunnelProperties.source = existingTunnel.source;
+            mergedAction = MergedAttributeAction.Reopen;
+        }
+        if (tunnelProperties.privacy && (existingTunnel.privacy !== tunnelProperties.privacy)) {
+            mergedAction = MergedAttributeAction.Reopen;
+        }
+        switch (mergedAction) {
+            case MergedAttributeAction.Fire: {
                 this._onForwardPort.fire();
+                break;
             }
-            if ((attributes?.protocol || (existingTunnel.protocol !== TunnelProtocol.Http)) && (attributes?.protocol !== existingTunnel.protocol)) {
-                await this.close(existingTunnel.remoteHost, existingTunnel.remotePort);
-                tunnelProperties.source = existingTunnel.source;
+            case MergedAttributeAction.Reopen: {
+                await this.close(existingTunnel.remoteHost, existingTunnel.remotePort, TunnelCloseReason.User);
                 await this.forward(tunnelProperties, attributes);
             }
-            return mapHasAddressLocalhostOrAllInterfaces(this.remoteTunnels, tunnelProperties.remote.host, tunnelProperties.remote.port);
         }
-        return undefined;
+        return mapHasAddressLocalhostOrAllInterfaces(this.remoteTunnels, tunnelProperties.remote.host, tunnelProperties.remote.port);
     }
     async name(host, port, name) {
         const existingForwarded = mapHasAddressLocalhostOrAllInterfaces(this.forwarded, host, port);
@@ -582,9 +612,18 @@ let TunnelModel = class TunnelModel extends Disposable {
             this._onPortName.fire({ host, port });
         }
     }
-    async close(host, port) {
+    async close(host, port, reason) {
+        const key = makeAddress(host, port);
+        const oldTunnel = this.forwarded.get(key);
+        if (reason === TunnelCloseReason.AutoForwardEnd) {
+            this.sessionCachedProperties.set(key, {
+                local: oldTunnel.localPort,
+                name: oldTunnel.name,
+                privacy: oldTunnel.privacy,
+            });
+        }
         await this.tunnelService.closeTunnel(host, port);
-        return this.onTunnelClosed({ host, port });
+        return this.onTunnelClosed({ host, port }, reason);
     }
     address(host, port) {
         const key = makeAddress(host, port);
@@ -779,4 +818,4 @@ TunnelModel = ( (__decorate([
     ( (__param(6, ILogService))),
     ( (__param(7, IDialogService)))
 ], TunnelModel)));
-export { AutoTunnelSource, IRemoteExplorerService, OnPortForward, PortsAttributes, TUNNEL_VIEW_ID, TunnelEditId, TunnelModel, TunnelSource, TunnelType, UserTunnelSource, makeAddress, mapHasAddress, mapHasAddressLocalhostOrAllInterfaces, parseAddress };
+export { AutoTunnelSource, IRemoteExplorerService, OnPortForward, PortsAttributes, TUNNEL_VIEW_ID, TunnelCloseReason, TunnelEditId, TunnelModel, TunnelSource, TunnelType, UserTunnelSource, makeAddress, mapHasAddress, mapHasAddressLocalhostOrAllInterfaces, parseAddress };

package/dist/vscode/vs/workbench/services/search/common/fileSearchManager.js

@@ -0,0 +1,265 @@
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { CancellationTokenSource } from 'monaco-editor/esm/vs/base/common/cancellation.js';
+import { toErrorMessage } from 'monaco-editor/esm/vs/base/common/errorMessage.js';
+import * as glob from 'monaco-editor/esm/vs/base/common/glob.js';
+import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
+import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
+import { resolvePatternsForProvider, QueryGlobTester, hasSiblingFn } from './search.js';
+class FileSearchEngine {
+    constructor(config, provider, sessionToken) {
+        this.config = config;
+        this.provider = provider;
+        this.sessionToken = sessionToken;
+        this.isLimitHit = false;
+        this.resultCount = 0;
+        this.isCanceled = false;
+        this.filePattern = config.filePattern;
+        this.includePattern = config.includePattern && glob.parse(config.includePattern);
+        this.maxResults = config.maxResults || undefined;
+        this.exists = config.exists;
+        this.activeCancellationTokens = ( new Set());
+        this.globalExcludePattern = config.excludePattern && glob.parse(config.excludePattern);
+    }
+    cancel() {
+        this.isCanceled = true;
+        this.activeCancellationTokens.forEach(t => t.cancel());
+        this.activeCancellationTokens = ( new Set());
+    }
+    search(_onResult) {
+        const folderQueries = this.config.folderQueries || [];
+        return ( new Promise((resolve, reject) => {
+            const onResult = (match) => {
+                this.resultCount++;
+                _onResult(match);
+            };
+            if (this.isCanceled) {
+                return resolve({ limitHit: this.isLimitHit });
+            }
+            if (this.config.extraFileResources) {
+                this.config.extraFileResources
+                    .forEach(extraFile => {
+                    const extraFileStr = ( extraFile.toString());
+                    const basename = path.basename(extraFileStr);
+                    if (this.globalExcludePattern && this.globalExcludePattern(extraFileStr, basename)) {
+                        return;
+                    }
+                    this.matchFile(onResult, { base: extraFile, basename });
+                });
+            }
+            Promise.all(( folderQueries.map(fq => {
+                return this.searchInFolder(fq, onResult);
+            }))).then(stats => {
+                resolve({
+                    limitHit: this.isLimitHit,
+                    stats: stats[0] || undefined
+                });
+            }, (err) => {
+                reject(( new Error(toErrorMessage(err))));
+            });
+        }));
+    }
+    async searchInFolder(fq, onResult) {
+        const cancellation = ( new CancellationTokenSource());
+        const options = this.getSearchOptionsForFolder(fq);
+        const tree = this.initDirectoryTree();
+        const queryTester = ( new QueryGlobTester(this.config, fq));
+        const noSiblingsClauses = !queryTester.hasSiblingExcludeClauses();
+        let providerSW;
+        try {
+            this.activeCancellationTokens.add(cancellation);
+            providerSW = StopWatch.create();
+            const results = await this.provider.provideFileSearchResults({
+                pattern: this.config.filePattern || ''
+            }, options, cancellation.token);
+            const providerTime = providerSW.elapsed();
+            const postProcessSW = StopWatch.create();
+            if (this.isCanceled && !this.isLimitHit) {
+                return null;
+            }
+            if (results) {
+                results.forEach(result => {
+                    const relativePath = path.posix.relative(fq.folder.path, result.path);
+                    if (noSiblingsClauses) {
+                        const basename = path.basename(result.path);
+                        this.matchFile(onResult, { base: fq.folder, relativePath, basename });
+                        return;
+                    }
+                    this.addDirectoryEntries(tree, fq.folder, relativePath, onResult);
+                });
+            }
+            if (this.isCanceled && !this.isLimitHit) {
+                return null;
+            }
+            this.matchDirectoryTree(tree, queryTester, onResult);
+            return {
+                providerTime,
+                postProcessTime: postProcessSW.elapsed()
+            };
+        }
+        finally {
+            cancellation.dispose();
+            this.activeCancellationTokens.delete(cancellation);
+        }
+    }
+    getSearchOptionsForFolder(fq) {
+        const includes = resolvePatternsForProvider(this.config.includePattern, fq.includePattern);
+        const excludes = resolvePatternsForProvider(this.config.excludePattern, fq.excludePattern);
+        return {
+            folder: fq.folder,
+            excludes,
+            includes,
+            useIgnoreFiles: !fq.disregardIgnoreFiles,
+            useGlobalIgnoreFiles: !fq.disregardGlobalIgnoreFiles,
+            useParentIgnoreFiles: !fq.disregardParentIgnoreFiles,
+            followSymlinks: !fq.ignoreSymlinks,
+            maxResults: this.config.maxResults,
+            session: this.sessionToken
+        };
+    }
+    initDirectoryTree() {
+        const tree = {
+            rootEntries: [],
+            pathToEntries: Object.create(null)
+        };
+        tree.pathToEntries['.'] = tree.rootEntries;
+        return tree;
+    }
+    addDirectoryEntries({ pathToEntries }, base, relativeFile, onResult) {
+        if (relativeFile === this.filePattern) {
+            const basename = path.basename(this.filePattern);
+            this.matchFile(onResult, { base: base, relativePath: this.filePattern, basename });
+        }
+        function add(relativePath) {
+            const basename = path.basename(relativePath);
+            const dirname = path.dirname(relativePath);
+            let entries = pathToEntries[dirname];
+            if (!entries) {
+                entries = pathToEntries[dirname] = [];
+                add(dirname);
+            }
+            entries.push({
+                base,
+                relativePath,
+                basename
+            });
+        }
+        add(relativeFile);
+    }
+    matchDirectoryTree({ rootEntries, pathToEntries }, queryTester, onResult) {
+        const self = this;
+        const filePattern = this.filePattern;
+        function matchDirectory(entries) {
+            const hasSibling = hasSiblingFn(() => ( entries.map(entry => entry.basename)));
+            for (let i = 0, n = entries.length; i < n; i++) {
+                const entry = entries[i];
+                const { relativePath, basename } = entry;
+                if (queryTester.matchesExcludesSync(relativePath, basename, filePattern !== basename ? hasSibling : undefined)) {
+                    continue;
+                }
+                const sub = pathToEntries[relativePath];
+                if (sub) {
+                    matchDirectory(sub);
+                }
+                else {
+                    if (relativePath === filePattern) {
+                        continue;
+                    }
+                    self.matchFile(onResult, entry);
+                }
+                if (self.isLimitHit) {
+                    break;
+                }
+            }
+        }
+        matchDirectory(rootEntries);
+    }
+    matchFile(onResult, candidate) {
+        if (!this.includePattern || (candidate.relativePath && this.includePattern(candidate.relativePath, candidate.basename))) {
+            if (this.exists || (this.maxResults && this.resultCount >= this.maxResults)) {
+                this.isLimitHit = true;
+                this.cancel();
+            }
+            if (!this.isLimitHit) {
+                onResult(candidate);
+            }
+        }
+    }
+}
+class FileSearchManager {
+    constructor() {
+        this.sessions = ( new Map());
+    }
+    fileSearch(config, provider, onBatch, token) {
+        const sessionTokenSource = this.getSessionTokenSource(config.cacheKey);
+        const engine = ( new FileSearchEngine(config, provider, sessionTokenSource && sessionTokenSource.token));
+        let resultCount = 0;
+        const onInternalResult = (batch) => {
+            resultCount += batch.length;
+            onBatch(( batch.map(m => this.rawMatchToSearchItem(m))));
+        };
+        return this.doSearch(engine, FileSearchManager.BATCH_SIZE, onInternalResult, token).then(result => {
+            return {
+                limitHit: result.limitHit,
+                stats: {
+                    fromCache: false,
+                    type: 'fileSearchProvider',
+                    resultCount,
+                    detailStats: result.stats
+                }
+            };
+        });
+    }
+    clearCache(cacheKey) {
+        const sessionTokenSource = this.getSessionTokenSource(cacheKey);
+        sessionTokenSource?.cancel();
+    }
+    getSessionTokenSource(cacheKey) {
+        if (!cacheKey) {
+            return undefined;
+        }
+        if (!( this.sessions.has(cacheKey))) {
+            this.sessions.set(cacheKey, ( new CancellationTokenSource()));
+        }
+        return this.sessions.get(cacheKey);
+    }
+    rawMatchToSearchItem(match) {
+        if (match.relativePath) {
+            return {
+                resource: resources.joinPath(match.base, match.relativePath)
+            };
+        }
+        else {
+            return {
+                resource: match.base
+            };
+        }
+    }
+    doSearch(engine, batchSize, onResultBatch, token) {
+        token.onCancellationRequested(() => {
+            engine.cancel();
+        });
+        const _onResult = (match) => {
+            if (match) {
+                batch.push(match);
+                if (batchSize > 0 && batch.length >= batchSize) {
+                    onResultBatch(batch);
+                    batch = [];
+                }
+            }
+        };
+        let batch = [];
+        return engine.search(_onResult).then(result => {
+            if (batch.length) {
+                onResultBatch(batch);
+            }
+            return result;
+        }, error => {
+            if (batch.length) {
+                onResultBatch(batch);
+            }
+            return Promise.reject(error);
+        });
+    }
+}
+FileSearchManager.BATCH_SIZE = 512;
+export { FileSearchManager };

package/dist/vscode/vs/workbench/services/search/common/queryBuilder.js

@@ -67,6 +67,12 @@ let QueryBuilder = class QueryBuilder {
             }
             newPattern.notebookInfo.isInNotebookMarkdownInput = options.notebookSearchConfig.includeMarkupInput;
         }
+        if (options.notebookSearchConfig?.includeMarkupPreview) {
+            if (!newPattern.notebookInfo) {
+                newPattern.notebookInfo = {};
+            }
+            newPattern.notebookInfo.isInNotebookMarkdownPreview = options.notebookSearchConfig.includeMarkupPreview;
+        }
         if (options.notebookSearchConfig?.includeCodeInput) {
             if (!newPattern.notebookInfo) {
                 newPattern.notebookInfo = {};