@theia/core 1.70.0-next.26 → 1.70.0-next.34

package/src/common/fuzzy-match-utils.ts

@@ -0,0 +1,78 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource 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
+// *****************************************************************************
+
+/**
+ * Returns the index of the first case-insensitive substring match of `pattern` in `text`,
+ * or `-1` if `pattern` is not a substring. Returns `0` for an empty pattern.
+ */
+export function findSubstringIndex(text: string, pattern: string): number {
+    if (!pattern) { return 0; }
+    return text.toLowerCase().indexOf(pattern.toLowerCase());
+}
+
+export function hasSubstringMatch(text: string, pattern: string): boolean {
+    return findSubstringIndex(text, pattern) !== -1;
+}
+
+const SEGMENT_SEPARATOR = /[\p{P}\s]+/u;
+
+/**
+ * Tests whether `pattern` is a "prefix match" for `text`, accounting for punctuation-separated segments.
+ *
+ * The pattern is split on punctuation into query parts. The text is split on punctuation into segments.
+ * It is a prefix match when the first query part matches the start of segment 0, and each subsequent
+ * query part matches the start of a later segment, in order.
+ *
+ * Examples:
+ * - `hasPrefixMatch("workspace-server", "works-ser")` → true
+ * - `hasPrefixMatch("backend-workspace-service", "works-ser")` → false (first segment doesn't match)
+ * - `hasPrefixMatch("fontSize", "font")` → true (single-part prefix)
+ */
+export function hasPrefixMatch(text: string, pattern: string): boolean {
+    if (!pattern) { return true; }
+    const queryParts = pattern.toLowerCase().split(SEGMENT_SEPARATOR).filter(Boolean);
+    if (queryParts.length === 0) { return true; }
+    const textSegments = text.toLowerCase().split(SEGMENT_SEPARATOR).filter(Boolean);
+    if (textSegments.length === 0) { return false; }
+    // First query part must match the start of the first text segment.
+    if (!textSegments[0].startsWith(queryParts[0])) { return false; }
+    let segIdx = 1;
+    for (let qIdx = 1; qIdx < queryParts.length; qIdx++) {
+        let found = false;
+        while (segIdx < textSegments.length) {
+            if (textSegments[segIdx].startsWith(queryParts[qIdx])) {
+                segIdx++;
+                found = true;
+                break;
+            }
+            segIdx++;
+        }
+        if (!found) { return false; }
+    }
+    return true;
+}
+
+/**
+ * Returns a numeric rank for how well `pattern` matches `text`:
+ * - 0: prefix match (best)
+ * - 1: substring match
+ * - 2: fuzzy-only match (worst)
+ */
+export function matchRank(text: string, pattern: string): number {
+    if (hasPrefixMatch(text, pattern)) { return 0; }
+    if (hasSubstringMatch(text, pattern)) { return 1; }
+    return 2;
+}

package/src/{browser/tree → common}/fuzzy-search.spec.ts

@@ -71,7 +71,9 @@ describe('fuzzy-search', () => {
     });
 
     ([
-        ['con', ['configs', 'base.tsconfig.json', 'tsconfig.json', 'base.nyc.json', 'CONTRIBUTING.MD']],
+        // "con" prefix matches (configs, CONTRIBUTING.MD) first, then substring matches (base.tsconfig.json, tsconfig.json), then fuzzy-only (base.nyc.json)
+        ['con', ['configs', 'base.tsconfig.json', 'tsconfig.json', 'base.nyc.json', 'CONTRIBUTING.MD'],
+            ['configs', 'CONTRIBUTING.MD', 'base.tsconfig.json', 'tsconfig.json', 'base.nyc.json']],
         ['bcn', ['baconing', 'narwhal', 'a mighty bear canoe'], ['baconing', 'a mighty bear canoe']]
     ] as ([string, string[], string[]])[]).forEach(test => {
         const [pattern, items, expected] = test;
@@ -80,6 +82,26 @@ describe('fuzzy-search', () => {
         });
     });
 
+    it('should rank substring matches before fuzzy-only matches', async () => {
+        const results = await search('font', ['reformatting', 'fontSize', 'fontFamily']);
+        // "reformatting" contains f-o-n-t scattered but not as substring; fontSize/fontFamily do
+        expectOrder(results, ['fontSize', 'fontFamily']);
+    });
+
+    it('should preserve original order for equal-score fuzzy-only matches', async () => {
+        // Both are fuzzy-only matches for "bcn" with different scores from the fuzzy library;
+        // when scores are equal, original array order (index) should be preserved.
+        const results = await search('ab', ['xab', 'yab']);
+        expectOrder(results, ['xab', 'yab']);
+    });
+
+    it('should highlight contiguous substring range instead of scattered fuzzy ranges', async () => {
+        const results = await search('works', ['browser-only-workspace-server.ts']);
+        expect(results).to.have.length(1);
+        // "works" appears at index 13 in "browser-only-workspace-server.ts"
+        expect(results[0].ranges).to.deep.equal([{ offset: 13, length: 5 }]);
+    });
+
     function expectOrder(actual: FuzzySearch.Match<string>[], expected: string[]): void {
         expect(actual.map(result => result.item)).to.be.deep.equal(expected);
     }

package/src/common/fuzzy-search.ts

@@ -0,0 +1,158 @@
+// *****************************************************************************
+// Copyright (C) 2018 TypeFox 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 * as fuzzy from 'fuzzy';
+import { injectable } from 'inversify';
+import { findSubstringIndex, matchRank } from './fuzzy-match-utils';
+
+@injectable()
+export class FuzzySearch {
+
+    private static readonly PRE = '\x01';
+    private static readonly POST = '\x02';
+
+    /**
+     * Filters the input and returns with an array that contains all items that match the pattern.
+     */
+    async filter<T>(input: FuzzySearch.Input<T>): Promise<FuzzySearch.Match<T>[]> {
+        return fuzzy.filter(input.pattern, input.items.slice(), {
+            pre: FuzzySearch.PRE,
+            post: FuzzySearch.POST,
+            extract: input.transform
+        }).sort((left, right) => this.sortResultsForInput(left, right, input))
+            .map(result => this.mapResultForInput(result, input));
+    }
+
+    protected sortResultsForInput<T>(left: fuzzy.FilterResult<T>, right: fuzzy.FilterResult<T>, input: FuzzySearch.Input<T>): number {
+        const leftRank = matchRank(input.transform(left.original), input.pattern);
+        const rightRank = matchRank(input.transform(right.original), input.pattern);
+        if (leftRank !== rightRank) { return leftRank - rightRank; }
+        return this.sortResults(left, right);
+    }
+
+    protected sortResults<T>(left: fuzzy.FilterResult<T>, right: fuzzy.FilterResult<T>): number {
+        if (right.score !== left.score) { return right.score - left.score; }
+        return left.index - right.index;
+    }
+
+    protected mapResultForInput<T>(result: fuzzy.FilterResult<T>, input: FuzzySearch.Input<T>): FuzzySearch.Match<T> {
+        const text = input.transform(result.original);
+        const substringIndex = input.pattern ? findSubstringIndex(text, input.pattern) : -1;
+        if (substringIndex !== -1) {
+            return {
+                item: result.original,
+                ranges: [{ offset: substringIndex, length: input.pattern.length }]
+            };
+        }
+        return this.mapResult(result);
+    }
+
+    protected mapResult<T>(result: fuzzy.FilterResult<T>): FuzzySearch.Match<T> {
+        return {
+            item: result.original,
+            ranges: this.mapRanges(result.string)
+        };
+    }
+
+    protected mapRanges(input: string): ReadonlyArray<FuzzySearch.Range> {
+        const copy = input.split('').filter(s => s !== '');
+        const ranges: FuzzySearch.Range[] = [];
+        const validate = (pre: number, post: number) => {
+            if (preIndex > postIndex || (preIndex === -1) !== (postIndex === -1)) {
+                throw new Error(`Error when trying to map ranges. Escaped string was: '${input}. [${[...input].join('|')}]'`);
+            }
+        };
+        let preIndex = copy.indexOf(FuzzySearch.PRE);
+        let postIndex = copy.indexOf(FuzzySearch.POST);
+        validate(preIndex, postIndex);
+        while (preIndex !== -1 && postIndex !== -1) {
+            ranges.push({
+                offset: preIndex,
+                length: postIndex - preIndex - 1
+            });
+            copy.splice(postIndex, 1);
+            copy.splice(preIndex, 1);
+            preIndex = copy.indexOf(FuzzySearch.PRE);
+            postIndex = copy.indexOf(FuzzySearch.POST);
+        }
+        if (ranges.length === 0) {
+            throw new Error(`Unexpected zero ranges for match-string: ${input}.`);
+        }
+        return ranges;
+    }
+
+}
+
+/**
+ * Fuzzy searcher.
+ */
+export namespace FuzzySearch {
+
+    /**
+     * A range representing the match region.
+     */
+    export interface Range {
+
+        /**
+         * The zero based offset of the match region.
+         */
+        readonly offset: number;
+
+        /**
+         * The length of the match region.
+         */
+        readonly length: number;
+    }
+
+    /**
+     * A fuzzy search match.
+     */
+    export interface Match<T> {
+
+        /**
+         * The original item.
+         */
+        readonly item: T;
+
+        /**
+         * An array of ranges representing the match regions.
+         */
+        readonly ranges: ReadonlyArray<Range>;
+    }
+
+    /**
+     * The fuzzy search input.
+     */
+    export interface Input<T> {
+
+        /**
+         * The pattern to match.
+         */
+        readonly pattern: string;
+
+        /**
+         * The items to filter based on the `pattern`.
+         */
+        readonly items: ReadonlyArray<T>;
+
+        /**
+         * Function that extracts the string from the inputs which will be used to evaluate the fuzzy matching filter.
+         */
+        readonly transform: (item: T) => string;
+
+    }
+
+}

package/src/common/quick-pick-service.ts

@@ -19,6 +19,7 @@ import { Event } from './event';
 import { KeySequence } from './keys';
 import { CancellationToken } from './cancellation';
 import { Severity } from './severity';
+import { findSubstringIndex, matchRank } from './fuzzy-match-utils';
 
 export const quickPickServicePath = '/services/quickPick';
 export const QuickPickService = Symbol('QuickPickService');
@@ -303,24 +304,52 @@ export function filterItems(items: QuickPickItemOrSeparator[], filter: string):
         return items;
     }
 
-    const filteredItems: QuickPickItemOrSeparator[] = [];
+    function matchesFilter(item: QuickPickItem): boolean {
+        return fuzzy.test(filter, item.label) ||
+            (!!item.description && fuzzy.test(filter, item.description)) ||
+            (!!item.detail && fuzzy.test(filter, item.detail));
+    }
+
+    function itemMatchRank(item: QuickPickItem): number {
+        return Math.min(
+            matchRank(item.label, filter),
+            item.description ? matchRank(item.description, filter) : 2,
+            item.detail ? matchRank(item.detail, filter) : 2
+        );
+    }
+
+    // Process items in separator groups, sorted by match rank within each group.
+    const result: QuickPickItemOrSeparator[] = [];
+    let currentSeparator: QuickPickSeparator | undefined;
+    let groupMatches: { item: QuickPickItem; rank: number }[] = [];
+
+    const flushGroup = (): void => {
+        if (groupMatches.length > 0) {
+            if (currentSeparator) {
+                result.push(currentSeparator);
+            }
+            groupMatches.sort((a, b) => a.rank - b.rank);
+            result.push(...groupMatches.map(m => m.item));
+        }
+        groupMatches = [];
+    };
+
     for (const item of items) {
         if (item.type === 'separator') {
-            filteredItems.push(item);
-        } else if (
-            fuzzy.test(filter, item.label) ||
-            (item.description && fuzzy.test(filter, item.description)) ||
-            (item.detail && fuzzy.test(filter, item.detail))
-        ) {
+            flushGroup();
+            currentSeparator = item;
+        } else if (matchesFilter(item)) {
             item.highlights = {
                 label: findMatches(item.label, filter),
                 description: item.description ? findMatches(item.description, filter) : undefined,
                 detail: item.detail ? findMatches(item.detail, filter) : undefined
             };
-            filteredItems.push(item);
+            groupMatches.push({ item, rank: itemMatchRank(item) });
         }
     }
-    return filteredItems;
+    flushGroup();
+
+    return result;
 }
 
 /**
@@ -337,6 +366,12 @@ export function findMatches(word: string, pattern: string): Array<{ start: numbe
         return undefined;
     }
 
+    // Prefer a contiguous substring highlight over scattered fuzzy character highlights.
+    const substringIndex = findSubstringIndex(word, pattern);
+    if (substringIndex !== -1) {
+        return [{ start: substringIndex, end: substringIndex + pattern.length }];
+    }
+
     const delimiter = '\u0000'; // null byte that shouldn't appear in the input and is used to denote matches.
     const matchResult = fuzzy.match(pattern.replace(/\u0000/gu, ''), word, { pre: delimiter, post: delimiter });
     if (!matchResult) {

package/src/electron-browser/window/electron-window-service.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { injectable, inject, postConstruct } from 'inversify';
-import { NewWindowOptions, WindowSearchParams } from '../../common/window';
+import { NewWindowOptions } from '../../common/window';
 import { DefaultWindowService } from '../../browser/window/default-window-service';
 import { ElectronMainWindowService } from '../../electron-common/electron-main-window-service';
 import { ElectronWindowPreferences } from '../../electron-common/electron-window-preferences';
@@ -57,8 +57,12 @@ export class ElectronWindowService extends DefaultWindowService {
         return undefined;
     }
 
-    override openNewDefaultWindow(params?: WindowSearchParams): void {
-        this.delegate.openNewDefaultWindow(params);
+    override async openNewDefaultWindow(params?: WindowReloadOptions): Promise<number> {
+        return this.delegate.openNewDefaultWindow(params?.search);
+    }
+
+    override closeWindow(windowId: number): void {
+        this.delegate.closeWindow(windowId);
     }
 
     override focus(): void {
@@ -116,4 +120,3 @@ export class ElectronWindowService extends DefaultWindowService {
         }
     }
 }
-

package/src/electron-common/electron-main-window-service.ts

@@ -20,5 +20,6 @@ export const electronMainWindowServicePath = '/services/electron-window';
 export const ElectronMainWindowService = Symbol('ElectronMainWindowService');
 export interface ElectronMainWindowService {
     openNewWindow(url: string, options?: NewWindowOptions): undefined;
-    openNewDefaultWindow(params?: WindowSearchParams): void;
+    openNewDefaultWindow(params?: WindowSearchParams): Promise<number>;
+    closeWindow(windowId: number): void;
 }

package/src/electron-main/electron-main-application.ts

@@ -502,6 +502,13 @@ export class ElectronMainApplication {
         };
     }
 
+    closeWindowById(webContentsId: number): void {
+        const window = this.windows.get(webContentsId);
+        if (window) {
+            window.close(StopReason.Close);
+        }
+    }
+
     async openDefaultWindow(params?: WindowSearchParams): Promise<BrowserWindow> {
         const options = this.getDefaultTheiaWindowOptions();
         const [uri, electronWindow] = await Promise.all([this.createWindowUri(params), this.reuseOrCreateWindow(options)]);

package/src/electron-main/electron-main-window-service-impl.ts

@@ -37,8 +37,13 @@ export class ElectronMainWindowServiceImpl implements ElectronMainWindowService
         return undefined;
     }
 
-    openNewDefaultWindow(params?: WindowSearchParams): void {
-        this.app.openDefaultWindow(params);
+    async openNewDefaultWindow(params?: WindowSearchParams): Promise<number> {
+        const electronWindow = await this.app.openDefaultWindow(params);
+        return electronWindow.webContents.id;
+    }
+
+    closeWindow(windowId: number): void {
+        this.app.closeWindowById(windowId);
     }
 
 }

package/lib/browser/tree/fuzzy-search.spec.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fuzzy-search.spec.d.ts","sourceRoot":"","sources":["../../../src/browser/tree/fuzzy-search.spec.ts"],"names":[],"mappings":""}

package/lib/browser/tree/fuzzy-search.spec.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fuzzy-search.spec.js","sourceRoot":"","sources":["../../../src/browser/tree/fuzzy-search.spec.ts"],"names":[],"mappings":"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"}