@theia/search-in-workspace 1.40.1 → 1.42.0

package/src/browser/components/search-in-workspace-textarea.tsx

@@ -0,0 +1,153 @@
+// *****************************************************************************
+// Copyright (C) 2021 Ericsson and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Key, KeyCode } from '@theia/core/lib/browser';
+import * as React from '@theia/core/shared/react';
+import TextareaAutosize from 'react-autosize-textarea';
+import debounce = require('@theia/core/shared/lodash.debounce');
+
+interface HistoryState {
+    history: string[];
+    index: number;
+};
+type TextareaAttributes = React.TextareaHTMLAttributes<HTMLTextAreaElement>;
+
+export class SearchInWorkspaceTextArea extends React.Component<TextareaAttributes, HistoryState> {
+    static LIMIT = 100;
+
+    private textarea = React.createRef<HTMLTextAreaElement>();
+
+    constructor(props: TextareaAttributes) {
+        super(props);
+        this.state = {
+            history: [],
+            index: 0,
+        };
+    }
+
+    updateState(index: number, history?: string[]): void {
+        this.value = history ? history[index] : this.state.history[index];
+        this.setState(prevState => {
+            const newState = {
+                ...prevState,
+                index,
+            };
+            if (history) {
+                newState.history = history;
+            }
+            return newState;
+        });
+    }
+
+    get value(): string {
+        return this.textarea.current?.value ?? '';
+    }
+
+    set value(value: string) {
+        if (this.textarea.current) {
+            this.textarea.current.value = value;
+        }
+    }
+
+    /**
+     * Handle history navigation without overriding the parent's onKeyDown handler, if any.
+     */
+    protected readonly onKeyDown = (e: React.KeyboardEvent<HTMLTextAreaElement>): void => {
+        // Navigate history only when cursor is at first or last position of the textarea
+        if (Key.ARROW_UP.keyCode === KeyCode.createKeyCode(e.nativeEvent).key?.keyCode && e.currentTarget.selectionStart === 0) {
+            e.preventDefault();
+            this.previousValue();
+        } else if (Key.ARROW_DOWN.keyCode === KeyCode.createKeyCode(e.nativeEvent).key?.keyCode && e.currentTarget.selectionEnd === e.currentTarget.value.length) {
+            e.preventDefault();
+            this.nextValue();
+        }
+
+        // Prevent newline on enter
+        if (Key.ENTER.keyCode === KeyCode.createKeyCode(e.nativeEvent).key?.keyCode && !e.nativeEvent.shiftKey) {
+            e.preventDefault();
+        }
+
+        this.props.onKeyDown?.(e);
+    };
+
+    /**
+     * Switch the textarea's text to the previous value, if any.
+     */
+    previousValue(): void {
+        const { history, index } = this.state;
+        if (!this.value) {
+            this.value = history[index];
+        } else if (index > 0 && index < history.length) {
+            this.updateState(index - 1);
+        }
+    }
+
+    /**
+     * Switch the textarea's text to the next value, if any.
+     */
+    nextValue(): void {
+        const { history, index } = this.state;
+        if (index === history.length - 1) {
+            this.value = '';
+        } else if (!this.value) {
+            this.value = history[index];
+        } else if (index >= 0 && index < history.length - 1) {
+            this.updateState(index + 1);
+        }
+    }
+
+    /**
+     * Handle history collection and textarea resizing without overriding the parent's onChange handler, if any.
+     */
+    protected readonly onChange = (e: React.ChangeEvent<HTMLTextAreaElement>): void => {
+        this.addToHistory();
+        this.props.onChange?.(e);
+    };
+
+    /**
+     * Add a nonempty current value to the history, if not already present. (Debounced, 1 second delay.)
+     */
+    readonly addToHistory = debounce(this.doAddToHistory, 1000);
+
+    private doAddToHistory(): void {
+        if (!this.value) {
+            return;
+        }
+        const history = this.state.history
+            .filter(term => term !== this.value)
+            .concat(this.value)
+            .slice(-SearchInWorkspaceTextArea.LIMIT);
+        this.updateState(history.length - 1, history);
+    }
+
+    override render(): React.ReactNode {
+        const { onResize, ...filteredProps } = this.props;
+        return (
+            <TextareaAutosize
+                {...filteredProps}
+                autoCapitalize="off"
+                autoCorrect="off"
+                maxRows={7} /* from VS Code */
+                onChange={this.onChange}
+                onKeyDown={this.onKeyDown}
+                ref={this.textarea}
+                rows={1}
+                spellCheck={false}
+            >
+            </TextareaAutosize>
+        );
+    }
+}

package/src/browser/search-in-workspace-result-tree-widget.tsx

@@ -36,7 +36,7 @@ import {
 import { CancellationTokenSource, Emitter, EOL, Event, ProgressService } from '@theia/core';
 import {
     EditorManager, EditorDecoration, TrackedRangeStickiness, OverviewRulerLane,
-    EditorWidget, EditorOpenerOptions, FindMatch
+    EditorWidget, EditorOpenerOptions, FindMatch, Position
 } from '@theia/editor/lib/browser';
 import { WorkspaceService } from '@theia/workspace/lib/browser';
 import { FileResourceResolver, FileSystemPreferences } from '@theia/filesystem/lib/browser';
@@ -303,12 +303,16 @@ export class SearchInWorkspaceResultTreeWidget extends TreeWidget {
 
         const matches: SearchMatch[] = [];
         results.forEach(r => {
-            const lineText: string = widget.editor.document.getLineContent(r.range.start.line);
+            const numberOfLines = searchTerm.split('\n').length;
+            const lineTexts = [];
+            for (let i = 0; i < numberOfLines; i++) {
+                lineTexts.push(widget.editor.document.getLineContent(r.range.start.line + i));
+            }
             matches.push({
                 line: r.range.start.line,
                 character: r.range.start.character,
-                length: r.range.end.character - r.range.start.character,
-                lineText
+                length: searchTerm.length,
+                lineText: lineTexts.join('\n')
             });
         });
 
@@ -873,6 +877,7 @@ export class SearchInWorkspaceResultTreeWidget extends TreeWidget {
             // Open the file only if the function is called to replace all matches under a specific node.
             const widget: EditorWidget = replaceOne ? await this.doOpen(toReplace[0]) : await this.doGetWidget(toReplace[0]);
             const source: string = widget.editor.document.getText();
+
             const replaceOperations = toReplace.map(resultLineNode => ({
                 text: replacementText,
                 range: {
@@ -880,12 +885,10 @@ export class SearchInWorkspaceResultTreeWidget extends TreeWidget {
                         line: resultLineNode.line - 1,
                         character: resultLineNode.character - 1
                     },
-                    end: {
-                        line: resultLineNode.line - 1,
-                        character: resultLineNode.character - 1 + resultLineNode.length
-                    }
+                    end: this.findEndCharacterPosition(resultLineNode),
                 }
             }));
+
             // Replace the text.
             await widget.editor.replaceText({
                 source,
@@ -955,6 +958,23 @@ export class SearchInWorkspaceResultTreeWidget extends TreeWidget {
         }
     }
 
+    private findEndCharacterPosition(node: SearchInWorkspaceResultLineNode): Position {
+        const lineText = typeof node.lineText === 'string' ? node.lineText : node.lineText.text;
+        const lines = lineText.split('\n');
+        const line = node.line + lines.length - 2;
+        let character = node.character - 1 + node.length;
+        if (lines.length > 1) {
+            character = node.length - lines[0].length + node.character - lines.length;
+            if (lines.length > 2) {
+                for (const lineNum of Array(lines.length - 2).keys()) {
+                    character -= lines[lineNum + 1].length;
+                }
+            }
+        }
+
+        return { line, character };
+    }
+
     protected renderRootFolderNode(node: SearchInWorkspaceRootFolderNode): React.ReactNode {
         return <div className='result'>
             <div className='result-head'>
@@ -1017,28 +1037,33 @@ export class SearchInWorkspaceResultTreeWidget extends TreeWidget {
             wordBreak.lastIndex++;
         }
 
-        const before = lineText.slice(start, character - 1).trimLeft();
-
-        return <div className={`resultLine noWrapInfo noselect ${node.selected ? 'selected' : ''}`} title={lineText.trim()}>
-            {this.searchInWorkspacePreferences['search.lineNumbers'] && <span className='theia-siw-lineNumber'>{node.line}</span>}
-            <span>
-                {before}
-            </span>
-            {this.renderMatchLinePart(node)}
-            <span>
-                {lineText.slice(node.character + node.length - 1, 250 - before.length + node.length)}
-            </span>
-        </div>;
+        const before = lineText.slice(start, character - 1).trimStart();
+        const lineCount = lineText.split('\n').length;
+
+        return <>
+            <div className={`resultLine noWrapInfo noselect ${node.selected ? 'selected' : ''}`} title={lineText.trim()}>
+                {this.searchInWorkspacePreferences['search.lineNumbers'] && <span className='theia-siw-lineNumber'>{node.line}</span>}
+                <span>
+                    {before}
+                </span>
+                {this.renderMatchLinePart(node)}
+                {lineCount > 1 || <span>
+                    {lineText.slice(node.character + node.length - 1, 250 - before.length + node.length)}
+                </span>}
+            </div>
+            {lineCount > 1 && <div className='match-line-num'>+{lineCount - 1}</div>}
+        </>;
     }
 
     protected renderMatchLinePart(node: SearchInWorkspaceResultLineNode): React.ReactNode {
-        const replaceTerm = this.isReplacing ? <span className='replace-term'>{this._replaceTerm}</span> : '';
+        const replaceTermLines = this._replaceTerm.split('\n');
+        const replaceTerm = this.isReplacing ? <span className='replace-term'>{replaceTermLines[0]}</span> : '';
         const className = `match${this.isReplacing ? ' strike-through' : ''}`;
-        const match = typeof node.lineText === 'string' ?
-            node.lineText.substring(node.character - 1, node.length + node.character - 1)
-            : node.lineText.text.substring(node.lineText.character - 1, node.length + node.lineText.character - 1);
+        const text = typeof node.lineText === 'string' ? node.lineText : node.lineText.text;
+        const match = text.substring(node.character - 1, node.character + node.length - 1);
+        const matchLines = match.split('\n');
         return <React.Fragment>
-            <span className={className}>{match}</span>
+            <span className={className}>{matchLines[0]}</span>
             {replaceTerm}
         </React.Fragment>;
     }
@@ -1071,10 +1096,7 @@ export class SearchInWorkspaceResultTreeWidget extends TreeWidget {
                     line: node.line - 1,
                     character: node.character - 1
                 },
-                end: {
-                    line: node.line - 1,
-                    character: node.character - 1 + node.length
-                }
+                end: this.findEndCharacterPosition(node),
             },
             mode: preview ? 'reveal' : 'activate',
             preview,
@@ -1100,16 +1122,8 @@ export class SearchInWorkspaceResultTreeWidget extends TreeWidget {
             content = await resource.readContents();
         }
 
-        const lines = content.split('\n');
-        node.children.forEach(l => {
-            const leftPositionedNodes = node.children.filter(rl => rl.line === l.line && rl.character < l.character);
-            const diff = (this._replaceTerm.length - this.searchTerm.length) * leftPositionedNodes.length;
-            const start = lines[l.line - 1].substring(0, l.character - 1 + diff);
-            const end = lines[l.line - 1].substring(l.character - 1 + diff + l.length);
-            lines[l.line - 1] = start + this._replaceTerm + end;
-        });
-
-        return fileUri.withScheme(MEMORY_TEXT).withQuery(lines.join('\n'));
+        const searchTermRegExp = new RegExp(this.searchTerm, 'g');
+        return fileUri.withScheme(MEMORY_TEXT).withQuery(content.replace(searchTermRegExp, this._replaceTerm));
     }
 
     protected decorateEditor(node: SearchInWorkspaceFileNode | undefined, editorWidget: EditorWidget): void {

package/src/browser/search-in-workspace-widget.tsx

@@ -28,6 +28,7 @@ import { ProgressBarFactory } from '@theia/core/lib/browser/progress-bar-factory
 import { EditorManager } from '@theia/editor/lib/browser';
 import { SearchInWorkspacePreferences } from './search-in-workspace-preferences';
 import { SearchInWorkspaceInput } from './components/search-in-workspace-input';
+import { SearchInWorkspaceTextArea } from './components/search-in-workspace-textarea';
 import { nls } from '@theia/core/lib/common/nls';
 
 export interface SearchFieldState {
@@ -65,8 +66,8 @@ export class SearchInWorkspaceWidget extends BaseWidget implements StatefulWidge
     protected searchTerm = '';
     protected replaceTerm = '';
 
-    private searchRef = React.createRef<SearchInWorkspaceInput>();
-    private replaceRef = React.createRef<SearchInWorkspaceInput>();
+    private searchRef = React.createRef<SearchInWorkspaceTextArea>();
+    private replaceRef = React.createRef<SearchInWorkspaceTextArea>();
     private includeRef = React.createRef<SearchInWorkspaceInput>();
     private excludeRef = React.createRef<SearchInWorkspaceInput>();
 
@@ -142,6 +143,7 @@ export class SearchInWorkspaceWidget extends BaseWidget implements StatefulWidge
             matchCase: false,
             matchWholeWord: false,
             useRegExp: false,
+            multiline: false,
             includeIgnored: false,
             include: [],
             exclude: [],
@@ -323,6 +325,8 @@ export class SearchInWorkspaceWidget extends BaseWidget implements StatefulWidge
 
     protected override onResize(msg: Widget.ResizeMessage): void {
         super.onResize(msg);
+        this.searchRef.current?.forceUpdate();
+        this.replaceRef.current?.forceUpdate();
         MessageLoop.sendMessage(this.resultTreeWidget, Widget.ResizeMessage.UnknownSize);
     }
 
@@ -447,7 +451,8 @@ export class SearchInWorkspaceWidget extends BaseWidget implements StatefulWidge
         const searchOptions: SearchInWorkspaceOptions = {
             ...this.searchInWorkspaceOptions,
             followSymlinks: this.shouldFollowSymlinks(),
-            matchCase: this.shouldMatchCase()
+            matchCase: this.shouldMatchCase(),
+            multiline: this.searchTerm.includes('\n')
         };
         this.resultTreeWidget.search(this.searchTerm, searchOptions);
     }
@@ -471,12 +476,10 @@ export class SearchInWorkspaceWidget extends BaseWidget implements StatefulWidge
     }
 
     protected renderSearchField(): React.ReactNode {
-        const input = <SearchInWorkspaceInput
+        const input = <SearchInWorkspaceTextArea
             id='search-input-field'
             className='theia-input'
             title={SearchInWorkspaceWidget.LABEL}
-            type='text'
-            size={1}
             placeholder={SearchInWorkspaceWidget.LABEL}
             defaultValue={this.searchTerm}
             autoComplete='off'
@@ -516,12 +519,10 @@ export class SearchInWorkspaceWidget extends BaseWidget implements StatefulWidge
         const replaceAllButtonContainer = this.renderReplaceAllButtonContainer();
         const replace = nls.localizeByDefault('Replace');
         return <div className={`replace-field${this.showReplaceField ? '' : ' hidden'}`}>
-            <SearchInWorkspaceInput
+            <SearchInWorkspaceTextArea
                 id='replace-input-field'
                 className='theia-input'
                 title={replace}
-                type='text'
-                size={1}
                 placeholder={replace}
                 defaultValue={this.replaceTerm}
                 autoComplete='off'

package/src/browser/styles/index.css

@@ -36,9 +36,14 @@
 }
 
 .t-siw-search-container .theia-input {
+  box-sizing: border-box;
   flex: 1;
   line-height: var(--theia-content-line-height);
+  max-height: calc(2 * 3px + 7 * var(--theia-content-line-height));
+  min-width: 16px;
   padding: 3px 0 3px 4px;
+  resize: none;
+  width: 100%;
 }
 
 .t-siw-search-container #search-input-field:focus {
@@ -99,16 +104,17 @@
 }
 
 .t-siw-search-container .searchHeader .search-field .option-buttons {
-  height: 23px;
-  display: flex;
-  align-items: center;
-  background-color: none;
+    height: 23px;
+    display: flex;
+    align-items: center;
+    align-self: flex-start;
+    background-color: none;
+    margin: 2px;
 }
 
 .t-siw-search-container .searchHeader .search-field-container.tooManyResults {
   border-style: solid;
   border-width: var(--theia-border-width);
-  margin: -1px;
   border-color: var(--theia-inputValidation-warningBorder);
 }
 
@@ -234,7 +240,6 @@
 }
 
 .t-siw-search-container .resultLine .match {
-  line-height: normal;
   white-space: pre;
   background: var(--theia-editor-findMatchHighlightBackground);
   border: 1px solid var(--theia-editor-findMatchHighlightBorder);
@@ -257,13 +262,17 @@
   border-style: dashed;
 }
 
-.t-siw-search-container .noWrapInfo {
-  width: 100%;
+.t-siw-search-container .match-line-num {
+    font-size: .9em;
+    margin-left: 7px;
+    margin-right: 4px;
+    opacity: .7;
 }
 
 .t-siw-search-container .result-head-info {
-  display: inline-flex;
   align-items: center;
+  display: inline-flex;
+  flex-grow: 1;
 }
 
 .search-in-workspace-editor-match {
@@ -294,13 +303,18 @@
 }
 
 .result-node-buttons > span {
-  width: 15px;
-  height: 15px;
+  width: 16px;
+  height: 16px;
   margin-left: 2.5px;
   margin-right: 0.5px;
   background-repeat: no-repeat;
   background-position: center;
   background-size: contain;
+  border-radius: 5px;
+}
+
+.result-node-buttons > span:hover {
+  background-color: var(--theia-toolbar-hoverBackground);
 }
 
 .search-and-replace-container {
@@ -346,10 +360,11 @@
 }
 
 .replace-all-button-container {
-  width: 25px;
-  display: flex;
-  align-items: center;
-  justify-content: center;
+    width: 25px;
+    display: flex;
+    align-items: start;
+    justify-content: center;
+    padding-top: 3px;
 }
 
 .result-node-buttons .replace-result {

package/src/common/search-in-workspace-interface.ts

@@ -41,6 +41,10 @@ export interface SearchInWorkspaceOptions {
      * Use regular expressions for search if true.
      */
     useRegExp?: boolean;
+    /**
+     * Use multiline search if true.
+     */
+    multiline?: boolean;
     /**
      * Include all .gitignored and hidden files.
      */

package/src/node/ripgrep-search-in-workspace-server.slow-spec.ts

@@ -957,10 +957,10 @@ describe('ripgrep-search-in-workspace-server', function (): void {
 
 describe('#extractSearchPathsFromIncludes', function (): void {
     this.timeout(10000);
-    it('should not resolve paths from a not absolute / relative pattern', function (): void {
+    it('should not resolve paths from a not absolute / relative pattern', async () => {
         const pattern = 'carrots';
         const options = { include: [pattern] };
-        const searchPaths = ripgrepServer['extractSearchPathsFromIncludes']([rootDirA], options);
+        const searchPaths = await ripgrepServer['extractSearchPathsFromIncludes']([rootDirA], options);
         // Same root directory
         expect(searchPaths.length).equal(1);
         expect(searchPaths[0]).equal(rootDirA);
@@ -970,21 +970,21 @@ describe('#extractSearchPathsFromIncludes', function (): void {
         expect(options.include[0]).equals(pattern);
     });
 
-    it('should resolve pattern to path for relative filename', function (): void {
+    it('should resolve pattern to path for relative filename', async () => {
         const filename = 'carrots';
         const pattern = `./${filename}`;
-        checkResolvedPathForPattern(pattern, path.join(rootDirA, filename));
+        await checkResolvedPathForPattern(pattern, path.join(rootDirA, filename));
     });
 
-    it('should resolve relative pattern with sub-folders glob', function (): void {
+    it('should resolve relative pattern with sub-folders glob', async () => {
         const filename = 'carrots';
         const pattern = `./${filename}/**`;
-        checkResolvedPathForPattern(pattern, path.join(rootDirA, filename));
+        await checkResolvedPathForPattern(pattern, path.join(rootDirA, filename));
     });
 
-    it('should resolve absolute path pattern', function (): void {
+    it('should resolve absolute path pattern', async () => {
         const pattern = `${rootDirA}/carrots`;
-        checkResolvedPathForPattern(pattern, pattern);
+        await checkResolvedPathForPattern(pattern, pattern);
     });
 });
 
@@ -1064,9 +1064,9 @@ describe('#addGlobArgs', function (): void {
     });
 });
 
-function checkResolvedPathForPattern(pattern: string, expectedPath: string): void {
+async function checkResolvedPathForPattern(pattern: string, expectedPath: string): Promise<void> {
     const options = { include: [pattern] };
-    const searchPaths = ripgrepServer['extractSearchPathsFromIncludes']([rootDirA], options);
+    const searchPaths = await ripgrepServer['extractSearchPathsFromIncludes']([rootDirA], options);
     expect(searchPaths.length).equal(1, 'searchPath result should contain exactly one element');
     expect(options.include.length).equals(0, 'options.include should be empty');
     expect(searchPaths[0]).equal(path.normalize(expectedPath));

package/src/node/ripgrep-search-in-workspace-server.ts

@@ -101,6 +101,10 @@ export class RipgrepSearchInWorkspaceServer implements SearchInWorkspaceServer {
         args.add('--hidden');
         args.add('--json');
 
+        if (options?.multiline) {
+            args.add('--multiline');
+        }
+
         if (options?.matchCase) {
             args.add('--case-sensitive');
         } else {
@@ -216,7 +220,7 @@ export class RipgrepSearchInWorkspaceServer implements SearchInWorkspaceServer {
         const rootPaths = rootUris.map(root => FileUri.fsPath(root));
         // If there are absolute paths in `include` we will remove them and use
         // those as paths to search from.
-        const searchPaths = this.extractSearchPathsFromIncludes(rootPaths, options);
+        const searchPaths = await this.extractSearchPathsFromIncludes(rootPaths, options);
         options.include = this.replaceRelativeToAbsolute(searchPaths, options.include);
         options.exclude = this.replaceRelativeToAbsolute(searchPaths, options.exclude);
         const rgArgs = this.getArgs(options);
@@ -388,23 +392,27 @@ export class RipgrepSearchInWorkspaceServer implements SearchInWorkspaceServer {
      * Any pattern that resulted in a valid search path will be removed from the 'include' list as it is
      * provided as an equivalent search path instead.
      */
-    protected extractSearchPathsFromIncludes(rootPaths: string[], options: SearchInWorkspaceOptions): string[] {
+    protected async extractSearchPathsFromIncludes(rootPaths: string[], options: SearchInWorkspaceOptions): Promise<string[]> {
         if (!options.include) {
             return rootPaths;
         }
         const resolvedPaths = new Set<string>();
-        options.include = options.include.filter(pattern => {
+        const include: string[] = [];
+        for (const pattern of options.include) {
             let keep = true;
             for (const root of rootPaths) {
-                const absolutePath = this.getAbsolutePathFromPattern(root, pattern);
+                const absolutePath = await this.getAbsolutePathFromPattern(root, pattern);
                 // undefined means the pattern cannot be converted into an absolute path
                 if (absolutePath) {
                     resolvedPaths.add(absolutePath);
                     keep = false;
                 }
             }
-            return keep;
-        });
+            if (keep) {
+                include.push(pattern);
+            }
+        }
+        options.include = include;
         return resolvedPaths.size > 0
             ? Array.from(resolvedPaths)
             : rootPaths;
@@ -417,7 +425,7 @@ export class RipgrepSearchInWorkspaceServer implements SearchInWorkspaceServer {
      *
      * @returns undefined if the pattern cannot be converted into an absolute path.
      */
-    protected getAbsolutePathFromPattern(root: string, pattern: string): string | undefined {
+    protected async getAbsolutePathFromPattern(root: string, pattern: string): Promise<string | undefined> {
         pattern = pattern.replace(/\\/g, '/');
         // The pattern is not referring to a single file or folder, i.e. not to be converted
         if (!path.isAbsolute(pattern) && !pattern.startsWith('./')) {
@@ -429,7 +437,7 @@ export class RipgrepSearchInWorkspaceServer implements SearchInWorkspaceServer {
         }
         // if `pattern` is absolute then `root` will be ignored by `path.resolve()`
         const targetPath = path.resolve(root, pattern);
-        if (fs.existsSync(targetPath)) {
+        if (await fs.pathExists(targetPath)) {
             return targetPath;
         }
         return undefined;