@theia/core 1.70.0-next.7 → 1.70.0-next.71

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

@@ -39,8 +39,16 @@ export interface WindowService {
     /**
      * Opens a new default window.
      * - In electron and in the browser it will open the default window without a pre-defined content.
+     * @returns a window identifier that can be passed to {@link closeWindow}, or -1 if not supported.
      */
-    openNewDefaultWindow(params?: WindowReloadOptions): void;
+    openNewDefaultWindow(params?: WindowReloadOptions): Promise<number>;
+
+    /**
+     * Closes a window previously opened by {@link openNewDefaultWindow}.
+     * @param windowId the identifier returned by {@link openNewDefaultWindow}.
+     * No-op if the window does not exist or the platform does not support it.
+     */
+    closeWindow(windowId: number): void;
 
     /**
      * Reveal and focuses the current window

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

@@ -0,0 +1,141 @@
+// *****************************************************************************
+// 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
+// *****************************************************************************
+
+import { expect } from 'chai';
+import { findSubstringIndex, hasPrefixMatch, hasSubstringMatch, matchRank } from './fuzzy-match-utils';
+
+describe('fuzzy-match-utils', () => {
+
+    describe('#findSubstringIndex', () => {
+
+        it('should return the index of a case-insensitive substring match', () => {
+            expect(findSubstringIndex('fontSize', 'font')).to.equal(0);
+            expect(findSubstringIndex('setFont', 'font')).to.equal(3);
+        });
+
+        it('should be case-insensitive', () => {
+            expect(findSubstringIndex('FontSize', 'font')).to.equal(0);
+            expect(findSubstringIndex('fontSize', 'Font')).to.equal(0);
+        });
+
+        it('should return -1 when pattern is not a substring', () => {
+            expect(findSubstringIndex('reformatting', 'font')).to.equal(-1);
+        });
+
+        it('should return 0 for empty pattern', () => {
+            expect(findSubstringIndex('anything', '')).to.equal(0);
+        });
+
+    });
+
+    describe('#hasSubstringMatch', () => {
+
+        it('should return true for exact substring match', () => {
+            expect(hasSubstringMatch('fontSize', 'font')).to.be.true;
+        });
+
+        it('should be case-insensitive', () => {
+            expect(hasSubstringMatch('FontSize', 'font')).to.be.true;
+            expect(hasSubstringMatch('fontSize', 'Font')).to.be.true;
+        });
+
+        it('should return false when pattern is not a substring', () => {
+            expect(hasSubstringMatch('reformatting', 'font')).to.be.false;
+        });
+
+        it('should return true for empty pattern', () => {
+            expect(hasSubstringMatch('anything', '')).to.be.true;
+        });
+
+        it('should return true when text equals pattern', () => {
+            expect(hasSubstringMatch('font', 'font')).to.be.true;
+        });
+
+    });
+
+    describe('#hasPrefixMatch', () => {
+
+        it('should match simple prefix', () => {
+            expect(hasPrefixMatch('fontSize', 'font')).to.be.true;
+        });
+
+        it('should match segmented prefix across punctuation', () => {
+            expect(hasPrefixMatch('workspace-server', 'works-ser')).to.be.true;
+        });
+
+        it('should match when query parts skip segments', () => {
+            expect(hasPrefixMatch('workspace-backend-service', 'works-ser')).to.be.true;
+        });
+
+        it('should not match when first segment does not match', () => {
+            expect(hasPrefixMatch('backend-workspace-service', 'works-ser')).to.be.false;
+        });
+
+        it('should be case-insensitive', () => {
+            expect(hasPrefixMatch('WorkspaceServer', 'work')).to.be.true;
+        });
+
+        it('should return true for empty pattern', () => {
+            expect(hasPrefixMatch('anything', '')).to.be.true;
+        });
+
+        it('should handle various separators', () => {
+            expect(hasPrefixMatch('workspace_server', 'works_ser')).to.be.true;
+            expect(hasPrefixMatch('workspace.server.ts', 'works.ser')).to.be.true;
+            expect(hasPrefixMatch('workspace/server', 'works/ser')).to.be.true;
+        });
+
+        it('should not match when query parts are out of order', () => {
+            expect(hasPrefixMatch('service-workspace', 'works-ser')).to.be.false;
+        });
+
+        it('should return true when pattern is only separators', () => {
+            expect(hasPrefixMatch('anything', '---')).to.be.true;
+        });
+
+        it('should return false when text is only separators', () => {
+            expect(hasPrefixMatch('---', 'abc')).to.be.false;
+        });
+
+        it('should not match when a later query part has no matching segment', () => {
+            expect(hasPrefixMatch('workspace-server', 'works-zzz')).to.be.false;
+        });
+
+    });
+
+    describe('#matchRank', () => {
+
+        it('should return 0 for prefix matches', () => {
+            expect(matchRank('fontSize', 'font')).to.equal(0);
+            expect(matchRank('workspace-server', 'works-ser')).to.equal(0);
+        });
+
+        it('should return 1 for substring (non-prefix) matches', () => {
+            expect(matchRank('setFont', 'font')).to.equal(1);
+            expect(matchRank('base.tsconfig.json', 'con')).to.equal(1);
+        });
+
+        it('should return 2 for fuzzy-only matches', () => {
+            expect(matchRank('baconing', 'bcn')).to.equal(2);
+        });
+
+        it('should return 0 for empty pattern', () => {
+            expect(matchRank('anything', '')).to.equal(0);
+        });
+
+    });
+
+});

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;
+
+    }
+
+}