@codingame/monaco-vscode-api 1.83.15 → 1.85.0-next.0

package/vscode/src/vs/base/common/event.d.ts

@@ -196,8 +196,8 @@ declare namespace Event {
     interface IChainableSythensis<T> {
         map<O>(fn: (i: T) => O): IChainableSythensis<O>;
         forEach(fn: (i: T) => void): IChainableSythensis<T>;
+        filter<R extends T>(fn: (e: T) => e is R): IChainableSythensis<R>;
         filter(fn: (e: T) => boolean): IChainableSythensis<T>;
-        filter<R>(fn: (e: T | R) => e is R): IChainableSythensis<R>;
         reduce<R>(merge: (last: R, event: T) => R, initial: R): IChainableSythensis<R>;
         reduce<R>(merge: (last: R | undefined, event: T) => R): IChainableSythensis<R>;
         latch(equals?: (a: T, b: T) => boolean): IChainableSythensis<T>;
@@ -236,6 +236,7 @@ declare namespace Event {
      * runAndSubscribe(dataChangeEvent, () => this._updateUI());
      * ```
      */
+    function runAndSubscribe<T>(event: Event<T>, handler: (e: T) => any, initial: T): IDisposable;
     function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable;
     /**
      * Adds a listener to an event and calls the listener immediately with undefined as the event object. A new

package/vscode/src/vs/base/common/observableInternal/base.d.ts

@@ -1,8 +1,13 @@
+import { DisposableStore } from '../lifecycle.js';
+
 /**
  * Represents an observable value.
  *
- * @template T The type of the value.
- * @template TChange The type of delta information (usually `void` and only used in advanced scenarios).
+ * @template T The type of the values the observable can hold.
+ * @template TChange The type used to describe value changes
+ * (usually `void` and only used in advanced scenarios).
+ * While observers can miss temporary values of an observable,
+ * they will receive all change values (as long as they are subscribed)!
  */
 interface IObservable<T, TChange = unknown> {
     /**
@@ -13,7 +18,7 @@ interface IObservable<T, TChange = unknown> {
      */
     get(): T;
     /**
-     * Forces the observable to check for and report changes.
+     * Forces the observable to check for changes and report them.
      *
      * Has the same effect as calling {@link IObservable.get}, but does not force the observable
      * to actually construct the value, e.g. if change deltas are used.
@@ -32,19 +37,23 @@ interface IObservable<T, TChange = unknown> {
      */
     removeObserver(observer: IObserver): void;
     /**
-     * Reads the current value and subscribes to this observable.
+     * Reads the current value and subscribes the reader to this observable.
      *
-     * Just calls {@link IReader.readObservable} if a reader is given, otherwise {@link IObservable.get}
-     * (see {@link ConvenientObservable.read}).
+     * Calls {@link IReader.readObservable} if a reader is given, otherwise {@link IObservable.get}
+     * (see {@link ConvenientObservable.read} for the implementation).
      */
     read(reader: IReader | undefined): T;
     /**
      * Creates a derived observable that depends on this observable.
      * Use the reader to read other observables
-     * (see {@link ConvenientObservable.map}).
+     * (see {@link ConvenientObservable.map} for the implementation).
      */
     map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
     map<TNew>(owner: object, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
+    /**
+     * Makes sure this value is computed eagerly.
+     */
+    recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
     /**
      * A human-readable name for debugging purposes.
      */
@@ -74,26 +83,30 @@ interface IObserver {
      * Signals that the given observable might have changed and a transaction potentially modifying that observable started.
      * Before the given observable can call this method again, is must call {@link IObserver.endUpdate}.
      *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
      * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
      */
     beginUpdate<T>(observable: IObservable<T>): void;
     /**
      * Signals that the transaction that potentially modified the given observable ended.
+     * This is a good place to react to (potential) changes.
      */
     endUpdate<T>(observable: IObservable<T>): void;
     /**
      * Signals that the given observable might have changed.
      * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
      *
-     * Implementations must not call into other observables, as they might not have received this event yet!
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
      * The change should be processed lazily or in {@link IObserver.endUpdate}.
      */
     handlePossibleChange<T>(observable: IObservable<T>): void;
     /**
-     * Signals that the given observable changed.
+     * Signals that the given {@link observable} changed.
      *
-     * Implementations must not call into other observables, as they might not have received this event yet!
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
      * The change should be processed lazily or in {@link IObserver.endUpdate}.
+     *
+     * @param change Indicates how or why the value changed.
      */
     handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
 }

package/vscode/src/vs/base/common/prefixTree.js

@@ -0,0 +1,140 @@
+import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
+const unset = Symbol('unset');
+class WellDefinedPrefixTree {
+    constructor() {
+        this.root = ( new Node());
+        this._size = 0;
+    }
+    get size() {
+        return this._size;
+    }
+    get nodes() {
+        return this.root.children?.values() || Iterable.empty();
+    }
+    insert(key, value) {
+        this.opNode(key, n => n._value = value);
+    }
+    mutate(key, mutate) {
+        this.opNode(key, n => n._value = mutate(n._value === unset ? undefined : n._value));
+    }
+    delete(key) {
+        const path = [{ part: '', node: this.root }];
+        let i = 0;
+        for (const part of key) {
+            const node = path[i].node.children?.get(part);
+            if (!node) {
+                return undefined;
+            }
+            path.push({ part, node });
+            i++;
+        }
+        const value = path[i].node._value;
+        if (value === unset) {
+            return;
+        }
+        this._size--;
+        for (; i > 0; i--) {
+            const parent = path[i - 1];
+            parent.node.children.delete(path[i].part);
+            if (parent.node.children.size > 0 || parent.node._value !== unset) {
+                break;
+            }
+        }
+        return value;
+    }
+    find(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return undefined;
+            }
+            node = next;
+        }
+        return node._value === unset ? undefined : node._value;
+    }
+    hasKeyOrParent(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            if (next._value !== unset) {
+                return true;
+            }
+            node = next;
+        }
+        return false;
+    }
+    hasKeyOrChildren(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            node = next;
+        }
+        return true;
+    }
+    hasKey(key) {
+        let node = this.root;
+        for (const segment of key) {
+            const next = node.children?.get(segment);
+            if (!next) {
+                return false;
+            }
+            node = next;
+        }
+        return node._value !== unset;
+    }
+    opNode(key, fn) {
+        let node = this.root;
+        for (const part of key) {
+            if (!node.children) {
+                const next = ( new Node());
+                node.children = ( new Map([[part, next]]));
+                node = next;
+            }
+            else if (!( node.children.has(part))) {
+                const next = ( new Node());
+                node.children.set(part, next);
+                node = next;
+            }
+            else {
+                node = node.children.get(part);
+            }
+        }
+        if (node._value === unset) {
+            this._size++;
+        }
+        fn(node);
+    }
+    *values() {
+        const stack = [this.root];
+        while (stack.length > 0) {
+            const node = stack.pop();
+            if (node._value !== unset) {
+                yield node._value;
+            }
+            if (node.children) {
+                for (const child of ( node.children.values())) {
+                    stack.push(child);
+                }
+            }
+        }
+    }
+}
+class Node {
+    constructor() {
+        this._value = unset;
+    }
+    get value() {
+        return this._value === unset ? undefined : this._value;
+    }
+    set value(value) {
+        this._value = value === undefined ? unset : value;
+    }
+}
+export { WellDefinedPrefixTree };

package/vscode/src/vs/base/common/product.d.ts

@@ -183,6 +183,7 @@ interface IProductConfiguration {
     readonly profileTemplatesUrl?: string;
     readonly commonlyUsedSettings?: string[];
     readonly aiGeneratedWorkspaceTrust?: IAiGeneratedWorkspaceTrust;
+    readonly gitHubEntitlement?: IGitHubEntitlement;
 }
 interface ITunnelApplicationConfig {
     authenticationProviders: IStringDictionary<{
@@ -214,7 +215,6 @@ type IFileContentCondition = (IFileLanguageCondition | IFilePathCondition) & {
     readonly contentPattern: string;
 };
 interface IAppCenterConfiguration {
-    readonly 'win32-ia32': string;
     readonly 'win32-x64': string;
     readonly 'linux-x64': string;
     readonly 'darwin': string;
@@ -278,5 +278,19 @@ interface IAiGeneratedWorkspaceTrust {
     readonly dontTrustOption: string;
     readonly startupTrustRequestLearnMore: string;
 }
+interface IGitHubEntitlement {
+    providerId: string;
+    command: {
+        title: string;
+        titleWithoutPlaceHolder: string;
+        action: string;
+        when: string;
+    };
+    entitlementUrl: string;
+    extensionId: string;
+    enablementKey: string;
+    confirmationMessage: string;
+    confirmationAction: string;
+}
 
-export type { ConfigurationSyncStore, ExtensionUntrustedWorkspaceSupport, ExtensionVirtualWorkspaceSupport, IAiGeneratedWorkspaceTrust, IAppCenterConfiguration, IBuiltInExtension, IConfigBasedExtensionTip, IExeBasedExtensionTip, IExtensionRecommendationCondition, IExtensionRecommendations, IFeaturedExtension, IFileContentCondition, IFileLanguageCondition, IFileOpenCondition, IFilePathCondition, IProductConfiguration, IProductWalkthrough, IProductWalkthroughStep, IRemoteExtensionTip, ISettingsEditorOpenCondition, ISurveyData, ITunnelApplicationConfig, IVirtualWorkspaceExtensionTip };
+export type { ConfigurationSyncStore, ExtensionUntrustedWorkspaceSupport, ExtensionVirtualWorkspaceSupport, IAiGeneratedWorkspaceTrust, IAppCenterConfiguration, IBuiltInExtension, IConfigBasedExtensionTip, IExeBasedExtensionTip, IExtensionRecommendationCondition, IExtensionRecommendations, IFeaturedExtension, IFileContentCondition, IFileLanguageCondition, IFileOpenCondition, IFilePathCondition, IGitHubEntitlement, IProductConfiguration, IProductWalkthrough, IProductWalkthroughStep, IRemoteExtensionTip, ISettingsEditorOpenCondition, ISurveyData, ITunnelApplicationConfig, IVirtualWorkspaceExtensionTip };

package/vscode/src/vs/base/common/resourceTree.js

@@ -0,0 +1,135 @@
+import { __decorate } from '../../../../../external/tslib/tslib.es6.js';
+import { memoize } from 'monaco-editor/esm/vs/base/common/decorators.js';
+import { PathIterator } from 'monaco-editor/esm/vs/base/common/ternarySearchTree.js';
+import * as path from 'monaco-editor/esm/vs/base/common/path.js';
+import { extUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+class Node {
+    get childrenCount() {
+        return this._children.size;
+    }
+    get children() {
+        return ( this._children.values());
+    }
+    get name() {
+        return path.posix.basename(this.relativePath);
+    }
+    constructor(uri, relativePath, context, element = undefined, parent = undefined) {
+        this.uri = uri;
+        this.relativePath = relativePath;
+        this.context = context;
+        this.element = element;
+        this.parent = parent;
+        this._children = ( new Map());
+    }
+    get(path) {
+        return this._children.get(path);
+    }
+    set(path, child) {
+        this._children.set(path, child);
+    }
+    delete(path) {
+        this._children.delete(path);
+    }
+    clear() {
+        this._children.clear();
+    }
+}
+Node.__decorator = ( __decorate([
+    memoize
+], Node.prototype, "name", null));
+function collect(node, result) {
+    if (typeof node.element !== 'undefined') {
+        result.push(node.element);
+    }
+    for (const child of node.children) {
+        collect(child, result);
+    }
+    return result;
+}
+class ResourceTree {
+    static getRoot(node) {
+        while (node.parent) {
+            node = node.parent;
+        }
+        return node;
+    }
+    static collect(node) {
+        return collect(node, []);
+    }
+    static isResourceNode(obj) {
+        return obj instanceof Node;
+    }
+    constructor(context, rootURI = URI.file('/'), extUri$1 = extUri) {
+        this.extUri = extUri$1;
+        this.root = ( new Node(rootURI, '', context));
+    }
+    add(uri, element) {
+        const key = this.extUri.relativePath(this.root.uri, uri) || uri.path;
+        const iterator = ( new PathIterator(false)).reset(key);
+        let node = this.root;
+        let path = '';
+        while (true) {
+            const name = iterator.value();
+            path = path + '/' + name;
+            let child = node.get(name);
+            if (!child) {
+                child = ( new Node(
+                    this.extUri.joinPath(this.root.uri, path),
+                    path,
+                    this.root.context,
+                    iterator.hasNext() ? undefined : element,
+                    node
+                ));
+                node.set(name, child);
+            }
+            else if (!iterator.hasNext()) {
+                child.element = element;
+            }
+            node = child;
+            if (!iterator.hasNext()) {
+                return;
+            }
+            iterator.next();
+        }
+    }
+    delete(uri) {
+        const key = this.extUri.relativePath(this.root.uri, uri) || uri.path;
+        const iterator = ( new PathIterator(false)).reset(key);
+        return this._delete(this.root, iterator);
+    }
+    _delete(node, iterator) {
+        const name = iterator.value();
+        const child = node.get(name);
+        if (!child) {
+            return undefined;
+        }
+        if (iterator.hasNext()) {
+            const result = this._delete(child, iterator.next());
+            if (typeof result !== 'undefined' && child.childrenCount === 0) {
+                node.delete(name);
+            }
+            return result;
+        }
+        node.delete(name);
+        return child.element;
+    }
+    clear() {
+        this.root.clear();
+    }
+    getNode(uri) {
+        const key = this.extUri.relativePath(this.root.uri, uri) || uri.path;
+        const iterator = ( new PathIterator(false)).reset(key);
+        let node = this.root;
+        while (true) {
+            const name = iterator.value();
+            const child = node.get(name);
+            if (!child || !iterator.hasNext()) {
+                return child;
+            }
+            node = child;
+            iterator.next();
+        }
+    }
+}
+export { ResourceTree };

package/vscode/src/vs/base/common/skipList.js

@@ -22,6 +22,7 @@ class SkipList {
     }
     clear() {
         this._header = ( new Node(this._maxLevel, NIL, NIL));
+        this._size = 0;
     }
     has(key) {
         return Boolean(SkipList._search(this, key, this.comparator));

package/vscode/src/vs/base/common/tfIdf.js

@@ -0,0 +1,137 @@
+function countMapFrom(values) {
+    const map = ( new Map());
+    for (const value of values) {
+        map.set(value, (map.get(value) ?? 0) + 1);
+    }
+    return map;
+}
+class TfIdfCalculator {
+    constructor() {
+        this.chunkCount = 0;
+        this.chunkOccurrences = ( new Map());
+        this.documents = ( new Map());
+    }
+    calculateScores(query, token) {
+        const embedding = this.computeEmbedding(query);
+        const idfCache = ( new Map());
+        const scores = [];
+        for (const [key, doc] of this.documents) {
+            if (token.isCancellationRequested) {
+                return [];
+            }
+            for (const chunk of doc.chunks) {
+                const score = this.computeSimilarityScore(chunk, embedding, idfCache);
+                if (score > 0) {
+                    scores.push({ key, score });
+                }
+            }
+        }
+        return scores;
+    }
+    static termFrequencies(input) {
+        return countMapFrom(TfIdfCalculator.splitTerms(input));
+    }
+    static *splitTerms(input) {
+        const normalize = (word) => word.toLowerCase();
+        for (const [word] of input.matchAll(/\b\p{Letter}[\p{Letter}\d]{2,}\b/gu)) {
+            yield normalize(word);
+            const camelParts = word.replace(/([a-z])([A-Z])/g, '$1 $2').split(/\s+/g);
+            if (camelParts.length > 1) {
+                for (const part of camelParts) {
+                    if (part.length > 2 && /\p{Letter}{3,}/gu.test(part)) {
+                        yield normalize(part);
+                    }
+                }
+            }
+        }
+    }
+    updateDocuments(documents) {
+        for (const { key } of documents) {
+            this.deleteDocument(key);
+        }
+        for (const doc of documents) {
+            const chunks = [];
+            for (const text of doc.textChunks) {
+                const tf = TfIdfCalculator.termFrequencies(text);
+                for (const term of ( tf.keys())) {
+                    this.chunkOccurrences.set(term, (this.chunkOccurrences.get(term) ?? 0) + 1);
+                }
+                chunks.push({ text, tf });
+            }
+            this.chunkCount += chunks.length;
+            this.documents.set(doc.key, { chunks });
+        }
+        return this;
+    }
+    deleteDocument(key) {
+        const doc = this.documents.get(key);
+        if (!doc) {
+            return;
+        }
+        this.documents.delete(key);
+        this.chunkCount -= doc.chunks.length;
+        for (const chunk of doc.chunks) {
+            for (const term of ( chunk.tf.keys())) {
+                const currentOccurrences = this.chunkOccurrences.get(term);
+                if (typeof currentOccurrences === 'number') {
+                    const newOccurrences = currentOccurrences - 1;
+                    if (newOccurrences <= 0) {
+                        this.chunkOccurrences.delete(term);
+                    }
+                    else {
+                        this.chunkOccurrences.set(term, newOccurrences);
+                    }
+                }
+            }
+        }
+    }
+    computeSimilarityScore(chunk, queryEmbedding, idfCache) {
+        let sum = 0;
+        for (const [term, termTfidf] of Object.entries(queryEmbedding)) {
+            const chunkTf = chunk.tf.get(term);
+            if (!chunkTf) {
+                continue;
+            }
+            let chunkIdf = idfCache.get(term);
+            if (typeof chunkIdf !== 'number') {
+                chunkIdf = this.computeIdf(term);
+                idfCache.set(term, chunkIdf);
+            }
+            const chunkTfidf = chunkTf * chunkIdf;
+            sum += chunkTfidf * termTfidf;
+        }
+        return sum;
+    }
+    computeEmbedding(input) {
+        const tf = TfIdfCalculator.termFrequencies(input);
+        return this.computeTfidf(tf);
+    }
+    computeIdf(term) {
+        const chunkOccurrences = this.chunkOccurrences.get(term) ?? 0;
+        return chunkOccurrences > 0
+            ? Math.log((this.chunkCount + 1) / chunkOccurrences)
+            : 0;
+    }
+    computeTfidf(termFrequencies) {
+        const embedding = Object.create(null);
+        for (const [word, occurrences] of termFrequencies) {
+            const idf = this.computeIdf(word);
+            if (idf > 0) {
+                embedding[word] = occurrences * idf;
+            }
+        }
+        return embedding;
+    }
+}
+function normalizeTfIdfScores(scores) {
+    const result = scores.slice(0);
+    result.sort((a, b) => b.score - a.score);
+    const max = result[0]?.score ?? 0;
+    if (max > 0) {
+        for (const score of result) {
+            score.score /= max;
+        }
+    }
+    return result;
+}
+export { TfIdfCalculator, normalizeTfIdfScores };

package/vscode/src/vs/base/common/types.d.ts

@@ -12,5 +12,17 @@ type AtLeastOne<T, U = {
 type OmitOptional<T> = {
     [K in keyof T as T[K] extends Required<T>[K] ? K : never]: T[K];
 };
+/**
+ * A type that recursively makes all properties of `T` required
+ */
+type DeepRequiredNonNullable<T> = {
+    [P in keyof T]-?: T[P] extends object ? DeepRequiredNonNullable<T[P]> : Required<NonNullable<T[P]>>;
+};
+/**
+ * Represents a type that is a partial version of a given type `T`, where all properties are optional and can be deeply nested.
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : Partial<T[P]>;
+};
 
-export type { AtLeastOne, OmitOptional, TypeConstraint };
+export type { AtLeastOne, DeepPartial, DeepRequiredNonNullable, OmitOptional, TypeConstraint };

package/vscode/src/vs/base/common/verifier.js

@@ -0,0 +1,62 @@
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+class Verifier {
+    constructor(defaultValue) {
+        this.defaultValue = defaultValue;
+    }
+    verify(value) {
+        if (!this.isType(value)) {
+            return this.defaultValue;
+        }
+        return value;
+    }
+}
+class BooleanVerifier extends Verifier {
+    isType(value) {
+        return typeof value === 'boolean';
+    }
+}
+class NumberVerifier extends Verifier {
+    isType(value) {
+        return typeof value === 'number';
+    }
+}
+class SetVerifier extends Verifier {
+    isType(value) {
+        return value instanceof Set;
+    }
+}
+class EnumVerifier extends Verifier {
+    constructor(defaultValue, allowedValues) {
+        super(defaultValue);
+        this.allowedValues = allowedValues;
+    }
+    isType(value) {
+        return this.allowedValues.includes(value);
+    }
+}
+class ObjectVerifier extends Verifier {
+    constructor(defaultValue, verifier) {
+        super(defaultValue);
+        this.verifier = verifier;
+    }
+    verify(value) {
+        if (!this.isType(value)) {
+            return this.defaultValue;
+        }
+        return verifyObject(this.verifier, value);
+    }
+    isType(value) {
+        return isObject(value);
+    }
+}
+function verifyObject(verifiers, value) {
+    const result = Object.create(null);
+    for (const key in verifiers) {
+        if (Object.hasOwnProperty.call(verifiers, key)) {
+            const verifier = verifiers[key];
+            result[key] = verifier.verify(value[key]);
+        }
+    }
+    return result;
+}
+export { BooleanVerifier, EnumVerifier, NumberVerifier, ObjectVerifier, SetVerifier, verifyObject };

package/vscode/src/vs/editor/browser/editorBrowser.d.ts

@@ -90,15 +90,17 @@ interface IDiffEditor extends IEditor {
      */
     setBoundarySashes(sashes: IBoundarySashes): void;
     /**
-     * @internal
+     * Jumps to the next or previous diff.
      */
     goToDiff(target: 'next' | 'previous'): void;
     /**
-     * @internal
+     * Scrolls to the first diff.
+     * (Waits until the diff computation finished.)
      */
     revealFirstDiff(): unknown;
     accessibleDiffViewerNext(): void;
     accessibleDiffViewerPrev(): void;
+    handleInitialized(): void;
 }
 
 export type { ICodeEditor, IDiffEditor };