@codingame/monaco-vscode-api 9.0.3 → 10.0.1

package/vscode/src/vs/base/browser/ui/tree/abstractTree.js

@@ -1,33 +1,32 @@
-import { createStyleSheet, isActiveElement, asCssValueWithDefault, isKeyboardEvent, append, $, clearNode, addDisposableListener, hasParentWithClass, h, getWindow } from '../../dom.js';
+import { isEditableElement, createStyleSheet, isActiveElement, asCssValueWithDefault, isKeyboardEvent, append, $, clearNode, addDisposableListener, hasParentWithClass, h, getWindow } from '../../dom.js';
 import { DomEmitter } from '../../event.js';
 import { StandardKeyboardEvent } from '../../keyboardEvent.js';
 import { ActionBar } from '../actionbar/actionbar.js';
 import { FindInput } from '../findinput/findInput.js';
-import { MessageType, unthemedInboxStyles } from '../inputbox/inputBox.js';
+import { unthemedInboxStyles } from '../inputbox/inputBox.js';
 import { ElementsDragAndDropData } from '../list/listView.js';
-import { isInputElement, isStickyScrollContainer, isStickyScrollElement, List, MouseController, isButton, isMonacoEditor, isMonacoCustomToggle, isActionItem } from '../list/listWidget.js';
+import { isStickyScrollContainer, isStickyScrollElement, List, MouseController, isButton, isMonacoEditor, isMonacoCustomToggle, isActionItem } from '../list/listWidget.js';
 import { Toggle, unthemedToggleStyles } from '../toggle/toggle.js';
 import { isFilterResult, getVisibleState } from './indexTreeModel.js';
-import { TreeMouseEventTarget, TreeError, TreeDragOverBubble, TreeVisibility } from './tree.js';
+import { TreeMouseEventTarget, TreeError } from './tree.js';
 import { Action } from '../../../common/actions.js';
-import { firstOrDefault, equals, distinct, range } from '../../../common/arrays.js';
+import { equals, distinct, range } from '../../../common/arrays.js';
 import { Delayer, disposableTimeout, timeout } from '../../../common/async.js';
 import { Codicon } from '../../../common/codicons.js';
 import { ThemeIcon } from '../../../common/themables.js';
 import { SetMap } from '../../../common/map.js';
 import { Event, EventBufferer, Emitter, Relay } from '../../../common/event.js';
 import { FuzzyScore, fuzzyScore } from '../../../common/filters.js';
-import { KeyCode } from '../../../common/keyCodes.js';
 import { DisposableStore, dispose, Disposable, toDisposable } from '../../../common/lifecycle.js';
 import { clamp } from '../../../common/numbers.js';
 import { isNumber } from '../../../common/types.js';
 import './media/tree.css.js';
 import { localize } from '../../../../nls.js';
-import { createInstantHoverDelegate, getDefaultHoverDelegate } from '../hover/hoverDelegateFactory.js';
-import '../../../common/observableInternal/derived.js';
+import { createInstantHoverDelegate } from '../hover/hoverDelegateFactory.js';
 import { autorun } from '../../../common/observableInternal/autorun.js';
-import { constObservable } from '../../../common/observableInternal/utils.js';
+import '../../../common/observableInternal/derived.js';
 import '../../../common/cancellation.js';
+import { constObservable } from '../../../common/observableInternal/utils.js';
 import { alert } from '../aria/aria.js';
 class TreeElementsDragAndDropData extends ElementsDragAndDropData {
     set context(context) {
@@ -96,7 +95,7 @@ class TreeNodeListDragAndDrop {
             }
             return result;
         }
-        if (result.bubble === TreeDragOverBubble.Up) {
+        if (result.bubble === 1 ) {
             const model = this.modelProvider();
             const ref = model.getNodeLocation(targetNode);
             const parentRef = model.getParentNodeLocation(ref);
@@ -256,9 +255,9 @@ class EventCollection {
 }
 class TreeRenderer {
     static { this.DefaultIndent = 8; }
-    constructor(renderer, modelProvider, onDidChangeCollapseState, activeNodes, renderedIndentGuides, options = {}) {
+    constructor(renderer, model, onDidChangeCollapseState, activeNodes, renderedIndentGuides, options = {}) {
         this.renderer = renderer;
-        this.modelProvider = modelProvider;
+        this.model = model;
         this.activeNodes = activeNodes;
         this.renderedIndentGuides = renderedIndentGuides;
         this.renderedElements = ( (new Map()));
@@ -378,14 +377,13 @@ class TreeRenderer {
             return;
         }
         const disposableStore = ( (new DisposableStore()));
-        const model = this.modelProvider();
         while (true) {
-            const ref = model.getNodeLocation(node);
-            const parentRef = model.getParentNodeLocation(ref);
+            const ref = this.model.getNodeLocation(node);
+            const parentRef = this.model.getParentNodeLocation(ref);
             if (!parentRef) {
                 break;
             }
-            const parent = model.getNode(parentRef);
+            const parent = this.model.getNode(parentRef);
             const guide = $('.indent-guide', { style: `width: ${this.indent}px` });
             if (( (this.activeIndentNodes.has(parent)))) {
                 guide.classList.add('active');
@@ -407,16 +405,15 @@ class TreeRenderer {
             return;
         }
         const set = ( (new Set()));
-        const model = this.modelProvider();
         nodes.forEach(node => {
-            const ref = model.getNodeLocation(node);
+            const ref = this.model.getNodeLocation(node);
             try {
-                const parentRef = model.getParentNodeLocation(ref);
+                const parentRef = this.model.getParentNodeLocation(ref);
                 if (node.collapsible && node.children.length > 0 && !node.collapsed) {
                     set.add(node);
                 }
                 else if (parentRef) {
-                    set.add(model.getNode(parentRef));
+                    set.add(this.model.getNode(parentRef));
                 }
             }
             catch {
@@ -434,6 +431,9 @@ class TreeRenderer {
         });
         this.activeIndentNodes = set;
     }
+    setModel(model) {
+        this.model = model;
+    }
     dispose() {
         this.renderedNodes.clear();
         this.renderedElements.clear();
@@ -460,11 +460,11 @@ class FindFilter {
         tree.onWillRefilter(this.reset, this, this.disposables);
     }
     filter(element, parentVisibility) {
-        let visibility = TreeVisibility.Visible;
+        let visibility = 1 ;
         if (this._filter) {
             const result = this._filter.filter(element, parentVisibility);
             if (typeof result === 'boolean') {
-                visibility = result ? TreeVisibility.Visible : TreeVisibility.Hidden;
+                visibility = result ? 1  : 0 ;
             }
             else if (isFilterResult(result)) {
                 visibility = getVisibleState(result.visibility);
@@ -472,7 +472,7 @@ class FindFilter {
             else {
                 visibility = result;
             }
-            if (visibility === TreeVisibility.Hidden) {
+            if (visibility === 0 ) {
                 return false;
             }
         }
@@ -516,7 +516,7 @@ class FindFilter {
                 return this.tree.options.defaultFindVisibility(element);
             }
             else {
-                return TreeVisibility.Recurse;
+                return 2 ;
             }
         }
         else {
@@ -531,30 +531,44 @@ class FindFilter {
         dispose(this.disposables);
     }
 }
-class ModeToggle extends Toggle {
-    constructor(opts) {
+class TreeFindToggle extends Toggle {
+    constructor(contribution, opts, hoverDelegate) {
         super({
-            icon: Codicon.listFilter,
-            title: ( localize(4939, "Filter")),
-            isChecked: opts.isChecked ?? false,
-            hoverDelegate: opts.hoverDelegate ?? getDefaultHoverDelegate('element'),
+            icon: contribution.icon,
+            title: contribution.title,
+            isChecked: contribution.isChecked,
             inputActiveOptionBorder: opts.inputActiveOptionBorder,
             inputActiveOptionForeground: opts.inputActiveOptionForeground,
-            inputActiveOptionBackground: opts.inputActiveOptionBackground
+            inputActiveOptionBackground: opts.inputActiveOptionBackground,
+            hoverDelegate,
         });
+        this.id = contribution.id;
     }
 }
-class FuzzyToggle extends Toggle {
-    constructor(opts) {
-        super({
-            icon: Codicon.searchFuzzy,
-            title: ( localize(4940, "Fuzzy Match")),
-            isChecked: opts.isChecked ?? false,
-            hoverDelegate: opts.hoverDelegate ?? getDefaultHoverDelegate('element'),
-            inputActiveOptionBorder: opts.inputActiveOptionBorder,
-            inputActiveOptionForeground: opts.inputActiveOptionForeground,
-            inputActiveOptionBackground: opts.inputActiveOptionBackground
-        });
+class FindToggles {
+    constructor(startStates) {
+        this.stateMap = ( (new Map( (startStates.map(state => [state.id, { ...state }])))));
+    }
+    states() {
+        return Array.from(( (this.stateMap.values())));
+    }
+    get(id) {
+        const state = this.stateMap.get(id);
+        if (state === undefined) {
+            throw ( (new Error(`No state found for toggle id ${id}`)));
+        }
+        return state.isChecked;
+    }
+    set(id, value) {
+        const state = this.stateMap.get(id);
+        if (state === undefined) {
+            throw ( (new Error(`No state found for toggle id ${id}`)));
+        }
+        if (state.isChecked === value) {
+            return false;
+        }
+        state.isChecked = value;
+        return true;
     }
 }
 const unthemedFindWidgetStyles = {
@@ -576,20 +590,13 @@ var TreeFindMatchType;
     TreeFindMatchType[TreeFindMatchType["Contiguous"] = 1] = "Contiguous";
 })(TreeFindMatchType || (TreeFindMatchType = {}))));
 class FindWidget extends Disposable {
-    set mode(mode) {
-        this.modeToggle.checked = mode === TreeFindMode.Filter;
-        this.findInput.inputBox.setPlaceHolder(mode === TreeFindMode.Filter ? ( localize(4941, "Type to filter")) : ( localize(4942, "Type to search")));
-    }
-    set matchType(matchType) {
-        this.matchTypeToggle.checked = matchType === TreeFindMatchType.Fuzzy;
-    }
     get value() {
         return this.findInput.inputBox.value;
     }
     set value(value) {
         this.findInput.inputBox.value = value;
     }
-    constructor(container, tree, contextViewProvider, mode, matchType, options) {
+    constructor(container, tree, contextViewProvider, placeholder, toggleContributions = [], options) {
         super();
         this.tree = tree;
         this.elements = h('.monaco-tree-type-filter', [
@@ -597,6 +604,7 @@ class FindWidget extends Disposable {
             h('.monaco-tree-type-filter-input@findInput'),
             h('.monaco-tree-type-filter-actionbar@actionbar'),
         ]);
+        this.toggles = [];
         this.width = 0;
         this.right = 0;
         this.top = 0;
@@ -612,43 +620,33 @@ class FindWidget extends Disposable {
             this.elements.root.style.boxShadow = `0 0 8px 2px ${styles.listFilterWidgetShadow}`;
         }
         const toggleHoverDelegate = this._register(createInstantHoverDelegate());
-        this.modeToggle = this._register(( (new ModeToggle(
-            { ...styles.toggleStyles, isChecked: mode === TreeFindMode.Filter, hoverDelegate: toggleHoverDelegate }
-        ))));
-        this.matchTypeToggle = this._register(( (new FuzzyToggle(
-            { ...styles.toggleStyles, isChecked: matchType === TreeFindMatchType.Fuzzy, hoverDelegate: toggleHoverDelegate }
-        ))));
-        this.onDidChangeMode = ( (Event.map(
-            this.modeToggle.onChange,
-            () => this.modeToggle.checked ? TreeFindMode.Filter : TreeFindMode.Highlight,
-            this._store
-        )));
-        this.onDidChangeMatchType = ( (Event.map(
-            this.matchTypeToggle.onChange,
-            () => this.matchTypeToggle.checked ? TreeFindMatchType.Fuzzy : TreeFindMatchType.Contiguous,
-            this._store
+        this.toggles = ( (toggleContributions.map(
+            contribution => this._register(( (new TreeFindToggle(contribution, styles.toggleStyles, toggleHoverDelegate))))
         )));
+        this.onDidToggleChange = Event.any(...( (this.toggles.map(
+            toggle => ( (Event.map(toggle.onChange, () => ({ id: toggle.id, isChecked: toggle.checked }))))
+        ))));
         this.findInput = this._register(( (new FindInput(this.elements.findInput, contextViewProvider, {
-            label: ( localize(4942, "Type to search")),
-            additionalToggles: [this.modeToggle, this.matchTypeToggle],
+            label: ( localize(4970, "Type to search")),
+            placeholder,
+            additionalToggles: this.toggles,
             showCommonFindToggles: false,
             inputBoxStyles: styles.inputBoxStyles,
             toggleStyles: styles.toggleStyles,
             history: options?.history
         }))));
         this.actionbar = this._register(( (new ActionBar(this.elements.actionbar))));
-        this.mode = mode;
         const emitter = this._register(( (new DomEmitter(this.findInput.inputBox.inputElement, 'keydown'))));
         const onKeyDown = Event.chain(emitter.event, $ => ( ($.map(e => ( (new StandardKeyboardEvent(e)))))));
         this._register(onKeyDown((e) => {
-            if (e.equals(KeyCode.Enter)) {
+            if (e.equals(3 )) {
                 e.preventDefault();
                 e.stopPropagation();
                 this.findInput.inputBox.addToHistory();
                 this.tree.domFocus();
                 return;
             }
-            if (e.equals(KeyCode.DownArrow)) {
+            if (e.equals(18 )) {
                 e.preventDefault();
                 e.stopPropagation();
                 if (this.findInput.inputBox.isAtLastInHistory() || this.findInput.inputBox.isNowhereInHistory()) {
@@ -660,14 +658,14 @@ class FindWidget extends Disposable {
                 }
                 return;
             }
-            if (e.equals(KeyCode.UpArrow)) {
+            if (e.equals(16 )) {
                 e.preventDefault();
                 e.stopPropagation();
                 this.findInput.inputBox.showPreviousValue();
                 return;
             }
         }));
-        const closeAction = this._register(( (new Action('close', ( localize(4943, "Close")), 'codicon codicon-close', true, () => this.dispose()))));
+        const closeAction = this._register(( (new Action('close', ( localize(4971, "Close")), 'codicon codicon-close', true, () => this.dispose()))));
         this.actionbar.push(closeAction, { icon: true, label: false });
         const onGrabMouseDown = this._register(( (new DomEmitter(this.elements.grab, 'mousedown'))));
         this._register(onGrabMouseDown.event(e => {
@@ -700,19 +698,19 @@ class FindWidget extends Disposable {
         this._register(onGrabKeyDown((e) => {
             let right;
             let top;
-            if (e.keyCode === KeyCode.LeftArrow) {
+            if (e.keyCode === 15 ) {
                 right = Number.POSITIVE_INFINITY;
             }
-            else if (e.keyCode === KeyCode.RightArrow) {
+            else if (e.keyCode === 17 ) {
                 right = 0;
             }
-            else if (e.keyCode === KeyCode.Space) {
+            else if (e.keyCode === 10 ) {
                 right = this.right === 0 ? Number.POSITIVE_INFINITY : 0;
             }
-            if (e.keyCode === KeyCode.UpArrow) {
+            if (e.keyCode === 16 ) {
                 top = 0;
             }
-            else if (e.keyCode === KeyCode.DownArrow) {
+            else if (e.keyCode === 18 ) {
                 top = Number.POSITIVE_INFINITY;
             }
             if (right !== undefined) {
@@ -735,6 +733,15 @@ class FindWidget extends Disposable {
         }));
         this.onDidChangeValue = this.findInput.onDidChange;
     }
+    setToggleState(id, checked) {
+        const toggle = this.toggles.find(toggle => toggle.id === id);
+        if (toggle) {
+            toggle.checked = checked;
+        }
+    }
+    setPlaceHolder(placeHolder) {
+        this.findInput.inputBox.setPlaceHolder(placeHolder);
+    }
     getHistory() {
         return this.findInput.inputBox.getHistory();
     }
@@ -765,64 +772,37 @@ class FindWidget extends Disposable {
         super.dispose();
     }
 }
-class FindController {
+var DefaultTreeToggles;
+( ((function(DefaultTreeToggles) {
+    DefaultTreeToggles["Mode"] = "mode";
+    DefaultTreeToggles["MatchType"] = "matchType";
+})(DefaultTreeToggles || (DefaultTreeToggles = {}))));
+class AbstractFindController {
     get pattern() { return this._pattern; }
-    get mode() { return this._mode; }
-    set mode(mode) {
-        if (mode === this._mode) {
-            return;
-        }
-        this._mode = mode;
-        if (this.widget) {
-            this.widget.mode = this._mode;
-        }
-        this.tree.refilter();
-        this.render();
-        this._onDidChangeMode.fire(mode);
+    get placeholder() { return this._placeholder; }
+    set placeholder(value) {
+        this._placeholder = value;
+        this.widget?.setPlaceHolder(value);
     }
-    get matchType() { return this._matchType; }
-    set matchType(matchType) {
-        if (matchType === this._matchType) {
-            return;
-        }
-        this._matchType = matchType;
-        if (this.widget) {
-            this.widget.matchType = this._matchType;
-        }
-        this.tree.refilter();
-        this.render();
-        this._onDidChangeMatchType.fire(matchType);
-    }
-    constructor(tree, model, view, filter, contextViewProvider, options = {}) {
+    constructor(tree, filter, contextViewProvider, options = {}) {
         this.tree = tree;
-        this.view = view;
         this.filter = filter;
         this.contextViewProvider = contextViewProvider;
         this.options = options;
         this._pattern = '';
         this.previousPattern = '';
         this.width = 0;
-        this._onDidChangeMode = ( (new Emitter()));
-        this.onDidChangeMode = this._onDidChangeMode.event;
-        this._onDidChangeMatchType = ( (new Emitter()));
-        this.onDidChangeMatchType = this._onDidChangeMatchType.event;
         this._onDidChangePattern = ( (new Emitter()));
         this.onDidChangePattern = this._onDidChangePattern.event;
         this._onDidChangeOpenState = ( (new Emitter()));
         this.onDidChangeOpenState = this._onDidChangeOpenState.event;
         this.enabledDisposables = ( (new DisposableStore()));
         this.disposables = ( (new DisposableStore()));
-        this._mode = tree.options.defaultFindMode ?? TreeFindMode.Highlight;
-        this._matchType = tree.options.defaultFindMatchType ?? TreeFindMatchType.Fuzzy;
-        model.onDidSplice(this.onDidSpliceModel, this, this.disposables);
+        this.toggles = ( (new FindToggles(options.toggles ?? [])));
+        this._placeholder = options.placeholder ?? ( localize(4970, "Type to search"));
     }
-    updateOptions(optionsUpdate = {}) {
-        if (optionsUpdate.defaultFindMode !== undefined) {
-            this.mode = optionsUpdate.defaultFindMode;
-        }
-        if (optionsUpdate.defaultFindMatchType !== undefined) {
-            this.matchType = optionsUpdate.defaultFindMatchType;
-        }
+    isOpened() {
+        return !!this.widget;
     }
     open() {
         if (this.widget) {
@@ -831,18 +811,17 @@ class FindController {
             return;
         }
         this.widget = ( (new FindWidget(
-            this.view.getHTMLElement(),
+            this.tree.getHTMLElement(),
             this.tree,
             this.contextViewProvider,
-            this.mode,
-            this.matchType,
+            this.placeholder,
+            this.toggles.states(),
             { ...this.options, history: this._history }
         )));
         this.enabledDisposables.add(this.widget);
         this.widget.onDidChangeValue(this.onDidChangeValue, this, this.enabledDisposables);
-        this.widget.onDidChangeMode(mode => this.mode = mode, undefined, this.enabledDisposables);
-        this.widget.onDidChangeMatchType(matchType => this.matchType = matchType, undefined, this.enabledDisposables);
         this.widget.onDidDisable(this.close, this, this.enabledDisposables);
+        this.widget.onDidToggleChange(this.onDidToggleChange, this, this.enabledDisposables);
         this.widget.layout(this.width);
         this.widget.focus();
         this.widget.value = this.previousPattern;
@@ -865,46 +844,124 @@ class FindController {
         this._pattern = pattern;
         this._onDidChangePattern.fire(pattern);
         this.filter.pattern = pattern;
-        this.tree.refilter();
-        if (pattern) {
-            this.tree.focusNext(0, true, undefined, node => !FuzzyScore.isDefault(node.filterData));
-        }
-        const focus = this.tree.getFocus();
-        if (focus.length > 0) {
-            const element = focus[0];
-            if (this.tree.getRelativeTop(element) === null) {
-                this.tree.reveal(element, 0.5);
+        this.applyPattern(pattern);
+    }
+    onDidToggleChange(e) {
+        this.toggles.set(e.id, e.isChecked);
+    }
+    updateToggleState(id, checked) {
+        this.toggles.set(id, checked);
+        this.widget?.setToggleState(id, checked);
+    }
+    renderMessage(showNotFound) {
+        if (showNotFound) {
+            if (this.tree.options.showNotFoundMessage ?? true) {
+                this.widget?.showMessage({ type: 2 , content: ( localize(4972, "No results found.")) });
             }
+            else {
+                this.widget?.showMessage({ type: 2  });
+            }
+        }
+        else {
+            this.widget?.clearMessage();
         }
+    }
+    alertResults(results) {
+        if (!results) {
+            alert(( localize(4973, "No results")));
+        }
+        else {
+            alert(( localize(4974, "{0} results", results)));
+        }
+    }
+    layout(width) {
+        this.width = width;
+        this.widget?.layout(width);
+    }
+    dispose() {
+        this._history = undefined;
+        this._onDidChangePattern.dispose();
+        this.enabledDisposables.dispose();
+        this.disposables.dispose();
+    }
+}
+class FindController extends AbstractFindController {
+    get mode() { return this.toggles.get(DefaultTreeToggles.Mode) ? TreeFindMode.Filter : TreeFindMode.Highlight; }
+    set mode(mode) {
+        if (mode === this.mode) {
+            return;
+        }
+        const isFilterMode = mode === TreeFindMode.Filter;
+        this.updateToggleState(DefaultTreeToggles.Mode, isFilterMode);
+        this.placeholder = isFilterMode ? ( localize(4975, "Type to filter")) : ( localize(4970, "Type to search"));
+        this.tree.refilter();
         this.render();
+        this._onDidChangeMode.fire(mode);
     }
-    onDidSpliceModel() {
-        if (!this.widget || this.pattern.length === 0) {
+    get matchType() { return this.toggles.get(DefaultTreeToggles.MatchType) ? TreeFindMatchType.Fuzzy : TreeFindMatchType.Contiguous; }
+    set matchType(matchType) {
+        if (matchType === this.matchType) {
             return;
         }
+        this.updateToggleState(DefaultTreeToggles.MatchType, matchType === TreeFindMatchType.Fuzzy);
         this.tree.refilter();
         this.render();
+        this._onDidChangeMatchType.fire(matchType);
     }
-    render() {
-        const noMatches = this.filter.totalCount > 0 && this.filter.matchCount === 0;
-        if (this.pattern && noMatches) {
-            alert(( localize(4944, "No results")));
-            if (this.tree.options.showNotFoundMessage ?? true) {
-                this.widget?.showMessage({ type: MessageType.WARNING, content: ( localize(4945, "No elements found.")) });
+    constructor(tree, filter, contextViewProvider, options = {}) {
+        const defaultFindMode = options.defaultFindMode ?? TreeFindMode.Highlight;
+        const defaultFindMatchType = options.defaultFindMatchType ?? TreeFindMatchType.Fuzzy;
+        const toggleContributions = [{
+                id: DefaultTreeToggles.Mode,
+                icon: Codicon.listFilter,
+                title: ( localize(4976, "Filter")),
+                isChecked: defaultFindMode === TreeFindMode.Filter,
+            }, {
+                id: DefaultTreeToggles.MatchType,
+                icon: Codicon.searchFuzzy,
+                title: ( localize(4977, "Fuzzy Match")),
+                isChecked: defaultFindMatchType === TreeFindMatchType.Fuzzy,
+            }];
+        super(tree, filter, contextViewProvider, { ...options, toggles: toggleContributions });
+        this.filter = filter;
+        this._onDidChangeMode = ( (new Emitter()));
+        this.onDidChangeMode = this._onDidChangeMode.event;
+        this._onDidChangeMatchType = ( (new Emitter()));
+        this.onDidChangeMatchType = this._onDidChangeMatchType.event;
+        this.disposables.add(this.tree.onDidChangeModel(() => {
+            if (!this.isOpened()) {
+                return;
             }
-            else {
-                this.widget?.showMessage({ type: MessageType.WARNING });
+            if (this.pattern.length !== 0) {
+                this.tree.refilter();
             }
+            this.render();
+        }));
+    }
+    updateOptions(optionsUpdate = {}) {
+        if (optionsUpdate.defaultFindMode !== undefined) {
+            this.mode = optionsUpdate.defaultFindMode;
         }
-        else {
-            this.widget?.clearMessage();
-            if (this.pattern) {
-                alert(( localize(4946, "{0} results", this.filter.matchCount)));
+        if (optionsUpdate.defaultFindMatchType !== undefined) {
+            this.matchType = optionsUpdate.defaultFindMatchType;
+        }
+    }
+    applyPattern(pattern) {
+        this.tree.refilter();
+        if (pattern) {
+            this.tree.focusNext(0, true, undefined, node => !FuzzyScore.isDefault(node.filterData));
+        }
+        const focus = this.tree.getFocus();
+        if (focus.length > 0) {
+            const element = focus[0];
+            if (this.tree.getRelativeTop(element) === null) {
+                this.tree.reveal(element, 0.5);
             }
         }
+        this.render();
     }
     shouldAllowFocus(node) {
-        if (!this.widget || !this.pattern) {
+        if (!this.isOpened() || !this.pattern) {
             return true;
         }
         if (this.filter.totalCount > 0 && this.filter.matchCount <= 1) {
@@ -912,15 +969,21 @@ class FindController {
         }
         return !FuzzyScore.isDefault(node.filterData);
     }
-    layout(width) {
-        this.width = width;
-        this.widget?.layout(width);
+    onDidToggleChange(e) {
+        if (e.id === DefaultTreeToggles.Mode) {
+            this.mode = e.isChecked ? TreeFindMode.Filter : TreeFindMode.Highlight;
+        }
+        else if (e.id === DefaultTreeToggles.MatchType) {
+            this.matchType = e.isChecked ? TreeFindMatchType.Fuzzy : TreeFindMatchType.Contiguous;
+        }
     }
-    dispose() {
-        this._history = undefined;
-        this._onDidChangePattern.dispose();
-        this.enabledDisposables.dispose();
-        this.disposables.dispose();
+    render() {
+        const noMatches = this.filter.matchCount === 0 && this.filter.totalCount > 0;
+        const showNotFound = noMatches && this.pattern.length > 0;
+        this.renderMessage(showNotFound);
+        if (this.pattern.length) {
+            this.alertResults(this.filter.matchCount);
+        }
     }
 }
 function stickyScrollNodeStateEquals(node1, node2) {
@@ -1197,6 +1260,9 @@ class StickyScrollController extends Disposable {
         }
         return { stickyScrollMaxItemCount };
     }
+    setModel(model) {
+        this.model = model;
+    }
 }
 class StickyScrollWidget {
     constructor(container, view, tree, treeRenderers, treeDelegate, accessibilityProvider) {
@@ -1694,7 +1760,7 @@ class TreeNodeListMouseController extends MouseController {
     }
     onViewPointer(e) {
         if (isButton(e.browserEvent.target) ||
-            isInputElement(e.browserEvent.target) ||
+            isEditableElement(e.browserEvent.target) ||
             isMonacoEditor(e.browserEvent.target)) {
             return;
         }
@@ -1853,11 +1919,6 @@ class TreeNodeList extends List {
         }
     }
 }
-var AbstractTreePart;
-( ((function(AbstractTreePart) {
-    AbstractTreePart[AbstractTreePart["Tree"] = 0] = "Tree";
-    AbstractTreePart[AbstractTreePart["StickyScroll"] = 1] = "StickyScroll";
-})(AbstractTreePart || (AbstractTreePart = {}))));
 class AbstractTree {
     get onDidScroll() { return this.view.onDidScroll; }
     get onDidChangeFocus() { return this.eventBufferer.wrapEvent(this.focus.onDidChange); }
@@ -1884,9 +1945,9 @@ class AbstractTree {
     get onKeyPress() { return this.view.onKeyPress; }
     get onDidFocus() { return this.view.onDidFocus; }
     get onDidBlur() { return this.view.onDidBlur; }
-    get onDidChangeModel() { return Event.signal(this.model.onDidSplice); }
-    get onDidChangeCollapseState() { return this.model.onDidChangeCollapseState; }
-    get onDidChangeRenderNodeCount() { return this.model.onDidChangeRenderNodeCount; }
+    get onDidChangeModel() { return Event.any(this.onDidChangeModelRelay.event, this.onDidSwapModel.event); }
+    get onDidChangeCollapseState() { return this.onDidChangeCollapseStateRelay.event; }
+    get onDidChangeRenderNodeCount() { return this.onDidChangeRenderNodeCountRelay.event; }
     get findMode() { return this.findController?.mode ?? TreeFindMode.Highlight; }
     set findMode(findMode) { if (this.findController) {
         this.findController.mode = findMode;
@@ -1906,19 +1967,30 @@ class AbstractTree {
         this.onDidChangeFindOpenState = Event.None;
         this.onDidChangeStickyScrollFocused = Event.None;
         this.disposables = ( (new DisposableStore()));
+        this.onDidSwapModel = this.disposables.add(( (new Emitter())));
+        this.onDidChangeModelRelay = this.disposables.add(( (new Relay())));
+        this.onDidSpliceModelRelay = this.disposables.add(( (new Relay())));
+        this.onDidChangeCollapseStateRelay = this.disposables.add(( (new Relay())));
+        this.onDidChangeRenderNodeCountRelay = this.disposables.add(( (new Relay())));
+        this.onDidChangeActiveNodesRelay = this.disposables.add(( (new Relay())));
         this._onWillRefilter = ( (new Emitter()));
         this.onWillRefilter = this._onWillRefilter.event;
         this._onDidUpdateOptions = ( (new Emitter()));
         this.onDidUpdateOptions = this._onDidUpdateOptions.event;
+        this.modelDisposables = ( (new DisposableStore()));
+        if (_options.keyboardNavigationLabelProvider) {
+            this.findFilter = ( (new FindFilter(this, _options.keyboardNavigationLabelProvider, _options.filter)));
+            _options = { ..._options, filter: this.findFilter };
+            this.disposables.add(this.findFilter);
+        }
+        this.model = this.createModel(_user, _options);
         this.treeDelegate = ( (new ComposedTreeDelegate(delegate)));
-        const onDidChangeCollapseStateRelay = ( (new Relay()));
-        const onDidChangeActiveNodes = ( (new Relay()));
-        const activeNodes = this.disposables.add(( (new EventCollection(onDidChangeActiveNodes.event))));
+        const activeNodes = this.disposables.add(( (new EventCollection(this.onDidChangeActiveNodesRelay.event))));
         const renderedIndentGuides = ( (new SetMap()));
         this.renderers = ( (renderers.map(r => ( (new TreeRenderer(
             r,
-            () => this.model,
-            onDidChangeCollapseStateRelay.event,
+            this.model,
+            this.onDidChangeCollapseStateRelay.event,
             activeNodes,
             renderedIndentGuides,
             _options
@@ -1926,12 +1998,6 @@ class AbstractTree {
         for (const r of this.renderers) {
             this.disposables.add(r);
         }
-        let filter;
-        if (_options.keyboardNavigationLabelProvider) {
-            filter = ( (new FindFilter(this, _options.keyboardNavigationLabelProvider, _options.filter)));
-            _options = { ..._options, filter: filter };
-            this.disposables.add(filter);
-        }
         this.focus = ( (new Trait(() => this.view.getFocusedElements()[0], _options.identityProvider)));
         this.selection = ( (new Trait(() => this.view.getSelectedElements()[0], _options.identityProvider)));
         this.anchor = ( (new Trait(() => this.view.getAnchorElement(), _options.identityProvider)));
@@ -1945,43 +2011,24 @@ class AbstractTree {
             this.anchor,
             { ...asListOptions(() => this.model, _options), tree: this, stickyScrollProvider: () => this.stickyScrollController }
         )));
-        this.model = this.createModel(_user, this.view, _options);
-        onDidChangeCollapseStateRelay.input = this.model.onDidChangeCollapseState;
-        const onDidModelSplice = Event.forEach(this.model.onDidSplice, e => {
-            this.eventBufferer.bufferEvents(() => {
-                this.focus.onDidModelSplice(e);
-                this.selection.onDidModelSplice(e);
-            });
-        }, this.disposables);
-        onDidModelSplice(() => null, null, this.disposables);
-        const activeNodesEmitter = this.disposables.add(( (new Emitter())));
-        const activeNodesDebounce = this.disposables.add(( (new Delayer(0))));
-        this.disposables.add(Event.any(onDidModelSplice, this.focus.onDidChange, this.selection.onDidChange)(() => {
-            activeNodesDebounce.trigger(() => {
-                const set = ( (new Set()));
-                for (const node of this.focus.getNodes()) {
-                    set.add(node);
-                }
-                for (const node of this.selection.getNodes()) {
-                    set.add(node);
-                }
-                activeNodesEmitter.fire([...( (set.values()))]);
-            });
-        }));
-        onDidChangeActiveNodes.input = activeNodesEmitter.event;
+        this.setupModel(this.model);
         if (_options.keyboardSupport !== false) {
-            const onKeyDown = Event.chain(this.view.onKeyDown, $ => ( ($.filter(e => !isInputElement(e.target))
+            const onKeyDown = Event.chain(this.view.onKeyDown, $ => ( ($.filter(e => !isEditableElement(e.target))
                 .map(e => ( (new StandardKeyboardEvent(e)))))));
-            Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === KeyCode.LeftArrow))(this.onLeftArrow, this, this.disposables);
-            Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === KeyCode.RightArrow))(this.onRightArrow, this, this.disposables);
-            Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === KeyCode.Space))(this.onSpace, this, this.disposables);
+            Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === 15 ))(this.onLeftArrow, this, this.disposables);
+            Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === 17 ))(this.onRightArrow, this, this.disposables);
+            Event.chain(onKeyDown, $ => $.filter(e => e.keyCode === 10 ))(this.onSpace, this, this.disposables);
         }
         if ((_options.findWidgetEnabled ?? true) && _options.keyboardNavigationLabelProvider && _options.contextViewProvider) {
-            const opts = this.options.findWidgetStyles ? { styles: this.options.findWidgetStyles } : undefined;
-            this.findController = ( (new FindController(this, this.model, this.view, filter, _options.contextViewProvider, opts)));
+            const findOptions = {
+                styles: _options.findWidgetStyles,
+                defaultFindMode: _options.defaultFindMode,
+                defaultFindMatchType: _options.defaultFindMatchType,
+                showNotFoundMessage: _options.showNotFoundMessage,
+            };
+            this.findController = this.disposables.add(( (new FindController(this, this.findFilter, _options.contextViewProvider, findOptions))));
             this.focusNavigationFilter = node => this.findController.shouldAllowFocus(node);
             this.onDidChangeFindOpenState = this.findController.onDidChangeOpenState;
-            this.disposables.add(this.findController);
             this.onDidChangeFindMode = this.findController.onDidChangeMode;
             this.onDidChangeFindMatchType = this.findController.onDidChangeMatchType;
         }
@@ -2216,7 +2263,7 @@ class AbstractTree {
         });
     }
     getAnchor() {
-        return firstOrDefault(this.anchor.get(), undefined);
+        return this.anchor.get().at(0);
     }
     setSelection(elements, browserEvent) {
         this.eventBufferer.bufferEvents(() => {
@@ -2263,7 +2310,7 @@ class AbstractTree {
         return focus !== undefined ? [focus] : [];
     }
     getFocusedPart() {
-        return this.stickyScrollController?.focusedLast() ? AbstractTreePart.StickyScroll : AbstractTreePart.Tree;
+        return this.stickyScrollController?.focusedLast() ? 1  : 0 ;
     }
     reveal(location, relativeTop) {
         this.model.expandTo(location);
@@ -2362,6 +2409,55 @@ class AbstractTree {
         const recursive = e.browserEvent.altKey;
         this.model.setCollapsed(location, undefined, recursive);
     }
+    createNewModel(options = {}) {
+        return this.createModel(this._user, { ...this._options, filter: this.findFilter, ...options });
+    }
+    setupModel(model) {
+        this.modelDisposables.clear();
+        this.modelDisposables.add(model.onDidSpliceRenderedNodes(({ start, deleteCount, elements }) => this.view.splice(start, deleteCount, elements)));
+        const onDidModelSplice = Event.forEach(model.onDidSpliceModel, e => {
+            this.eventBufferer.bufferEvents(() => {
+                this.focus.onDidModelSplice(e);
+                this.selection.onDidModelSplice(e);
+            });
+        }, this.modelDisposables);
+        onDidModelSplice(() => null, null, this.modelDisposables);
+        const activeNodesEmitter = this.modelDisposables.add(( (new Emitter())));
+        const activeNodesDebounce = this.modelDisposables.add(( (new Delayer(0))));
+        this.modelDisposables.add(Event.any(onDidModelSplice, this.focus.onDidChange, this.selection.onDidChange)(() => {
+            activeNodesDebounce.trigger(() => {
+                const set = ( (new Set()));
+                for (const node of this.focus.getNodes()) {
+                    set.add(node);
+                }
+                for (const node of this.selection.getNodes()) {
+                    set.add(node);
+                }
+                activeNodesEmitter.fire([...( (set.values()))]);
+            });
+        }));
+        this.onDidChangeActiveNodesRelay.input = activeNodesEmitter.event;
+        this.onDidChangeModelRelay.input = Event.signal(model.onDidSpliceModel);
+        this.onDidChangeCollapseStateRelay.input = model.onDidChangeCollapseState;
+        this.onDidChangeRenderNodeCountRelay.input = model.onDidChangeRenderNodeCount;
+        this.onDidSpliceModelRelay.input = model.onDidSpliceModel;
+    }
+    setModel(newModel) {
+        const oldModel = this.model;
+        this.model = newModel;
+        this.setupModel(newModel);
+        this.renderers.forEach(r => r.setModel(newModel));
+        this.stickyScrollController?.setModel(newModel);
+        this.focus.set([]);
+        this.selection.set([]);
+        this.anchor.set([]);
+        this.view.splice(0, oldModel.getListRenderCount(oldModel.rootRef));
+        newModel.refilter();
+        this.onDidSwapModel.fire();
+    }
+    getModel() {
+        return this.model;
+    }
     navigate(start) {
         return (
              (new TreeNavigator(this.view, this.model, start))
@@ -2371,6 +2467,7 @@ class AbstractTree {
         dispose(this.disposables);
         this.stickyScrollController?.dispose();
         this.view.dispose();
+        this.modelDisposables.dispose();
     }
 }
 class TreeNavigator {
@@ -2407,4 +2504,4 @@ class TreeNavigator {
         return this.current();
     }
 }
-export { AbstractTree, AbstractTreePart, AbstractTreeViewState, ComposedTreeDelegate, FuzzyToggle, ModeToggle, RenderIndentGuides, TreeFindMatchType, TreeFindMode, TreeRenderer };
+export { AbstractFindController, AbstractTree, AbstractTreeViewState, ComposedTreeDelegate, FindToggles, RenderIndentGuides, TreeFindMatchType, TreeFindMode, TreeRenderer };