Class FastFinder

Extension/src/Utility/Filesystem/ripgrep.ts:26–95

}

export class FastFinder implements AsyncIterable<string> {
    private keepOnlyExecutables: boolean;
    private executableExtensions = new Array<string>();
    private processes = new Array<Instance<Process>>();
    private pending = 0;
    private readyToComplete = false;
    private distinct = new Set<string>();

    #files = accumulator<string>().autoComplete(false);

    [Symbol.asyncIterator](): AsyncIterator<string> {
        this.readyToComplete = true;
        if (this.pending === 0) {
            this.#files.complete();
        }

        return this.#files[Symbol.asyncIterator]();
    }

    constructor(private fileGlobs: string[], options?: { executable?: boolean; executableExtensions?: string[] }) {
        strict(ripgrep, 'initRipGrep must be called before using FastFinder');

        this.keepOnlyExecutables = options?.executable ?? false;
        if (this.keepOnlyExecutables && process.platform === 'win32') {
            this.executableExtensions = options?.executableExtensions ?? ['.exe', '.bat', '.cmd', '.ps1'];
        }
    }

    /**
     * Add one or more locations to scan, with an optionally specified depth.
     *
     * The scanning of those locations begins immediately and is done asynchronously.
     *
     */
    scan(...location: string[]): FastFinder;
    scan(depth: number, ...location: string[]): FastFinder;
    scan(...location: (string | number)[]): FastFinder {
        const depth = (typeof location[0] === 'number' ? location.shift() as number : 0) + 1;
        const globs = this.executableExtensions.length ?
            this.fileGlobs.map(glob => this.executableExtensions.map(ext => glob.includes('**') ? glob : `**/${glob}${ext}`)).flat() :
            this.fileGlobs.map(glob => glob.includes('**') ? glob : `**/${glob}`);

        // only search locations that exist
        location = location.filter(each => existsSync(each.toString()));

        // only search if there are globs and locations to search
        if (globs.length && location.length) {
            this.pending++;
            void ripgrep!(...globs.map(each => ['--glob', each]).flat(), '--max-depth', depth, '--null-data', '--no-messages', '-L', '--files', ...location.map(each => each.toString())).then(async proc => {
                const process = proc as unknown as Instance<Process>;
                this.processes.push(process);
                for await (const line of process.stdio) {
                    if (this.distinct.has(line)) {
                        continue;
                    }
                    this.distinct.add(line);
                    if (!this.keepOnlyExecutables || await filepath.isExecutable(line)) {
                        this.#files.add(line);