@codingame/monaco-vscode-api 1.69.24 → 1.76.0-next.2

package/dist/snippets.d.ts

@@ -150,17 +150,28 @@ interface UriComponents {
     fragment: string;
 }
 
+interface ILocalizedString {
+    /**
+     * The localized value of the string.
+     */
+    value: string;
+    /**
+     * The original (non localized value of the string)
+     */
+    original: string;
+}
+
 /**
  * Type of extension.
  *
  * **NOTE**: This is defined in `platform/environment` because it can appear as a CLI argument.
  */
-declare type ExtensionKind = 'ui' | 'workspace' | 'web';
+type ExtensionKind = 'ui' | 'workspace' | 'web';
 
 interface ICommand {
     command: string;
-    title: string;
-    category?: string;
+    title: string | ILocalizedString;
+    category?: string | ILocalizedString;
 }
 interface IConfigurationProperty {
     description: string;
@@ -282,6 +293,7 @@ interface IWalkthroughStep {
 interface IWalkthrough {
     readonly id: string;
     readonly title: string;
+    readonly icon?: string;
     readonly description: string;
     readonly steps: IWalkthroughStep[];
     readonly featuredFor: string[] | undefined;
@@ -351,8 +363,8 @@ interface IExtensionCapabilities {
     readonly virtualWorkspaces?: ExtensionVirtualWorkspaceSupport;
     readonly untrustedWorkspaces?: ExtensionUntrustedWorkspaceSupport;
 }
-declare type LimitedWorkspaceSupportType = 'limited';
-declare type ExtensionUntrustedWorkspaceSupport = {
+type LimitedWorkspaceSupportType = 'limited';
+type ExtensionUntrustedWorkspaceSupport = {
     supported: true;
 } | {
     supported: false;
@@ -362,7 +374,7 @@ declare type ExtensionUntrustedWorkspaceSupport = {
     description: string;
     restrictedConfigurations?: string[];
 };
-declare type ExtensionVirtualWorkspaceSupport = boolean | {
+type ExtensionVirtualWorkspaceSupport = boolean | {
     supported: true;
 } | {
     supported: false | LimitedWorkspaceSupportType;
@@ -379,6 +391,8 @@ interface IRelaxedExtensionManifest {
     description?: string;
     main?: string;
     browser?: string;
+    preview?: boolean;
+    l10n?: string;
     icon?: string;
     categories?: string[];
     keywords?: string[];
@@ -451,8 +465,11 @@ interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest {
     isUserBuiltin: boolean;
     isUnderDevelopment: boolean;
     extensionLocation: URI;
+    browserNlsBundleUris?: {
+        [language: string]: URI;
+    };
 }
-declare type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
+type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
 
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 

package/dist/snippets.js

@@ -1,7 +1,7 @@
-import { b as parse, g as getNodeType } from './polyfill.js';
-import { f as IUserDataProfileService, I as ILifecycleService } from './missing-services.js';
+import { h as isStringArray, p as parse, g as getNodeType } from './polyfill.js';
+import { e as IUserDataProfileService, I as ILifecycleService } from './missing-services.js';
 import { i as ISnippetsService, S as Services, c as IFileService, j as ITextFileService } from './services2.js';
-import { _ as __decorate, a as __param } from './workspace.js';
+import { _ as __decorate, a as __param } from './contextkey.js';
 import * as monacoSuggest from 'monaco-editor/esm/vs/editor/contrib/suggest/browser/suggest.js';
 import { extname as extname$1, basename as basename$1 } from 'monaco-editor/esm/vs/base/common/path.js';
 import { Iterable } from 'monaco-editor/esm/vs/base/common/iterator.js';
@@ -14,17 +14,16 @@ import { tail, insertInto } from 'monaco-editor/esm/vs/base/common/arrays.js';
 import { KnownSnippetVariableNames } from 'monaco-editor/esm/vs/editor/contrib/snippet/browser/snippetVariables.js';
 import { g as getExtensionPoint, a as ExtensionMessageCollector, c as consoleExtensionMessageHandler, o as onServicesInitialized, E as ExtensionsRegistry } from './tools.js';
 import { l as languagesExtPoint } from './languageService.js';
-import { be as DEFAULT_EXTENSION, bk as Range$2 } from './extHost.js';
+import { bj as DEFAULT_EXTENSION, bs as Range$2 } from './extHost.js';
 import { CommandsRegistry } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { getWordAtText } from 'monaco-editor/esm/vs/editor/common/core/wordHelper.js';
 import { isPatternInWord } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { compareSubstring, isFalsyOrWhitespace, compare } from 'monaco-editor/esm/vs/base/common/strings.js';
+import { firstNonWhitespaceIndex, compareSubstring, isFalsyOrWhitespace, compare } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
 import { ILanguageConfigurationService } from 'monaco-editor/esm/vs/editor/common/languages/languageConfigurationRegistry.js';
 import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
 import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
 import { r as registerExtensionFile, I as IExtensionResourceLoaderService } from './files.js';
-import { b as isStringArray } from './types.js';
 import { DisposableStore, combinedDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ResourceMap } from 'monaco-editor/esm/vs/base/common/map.js';
 import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
@@ -255,7 +254,7 @@ class SnippetFile {
                 source = ( (localize('source.userSnippet', "User Snippet")));
             }
         }
-        for (const _prefix of Array.isArray(prefix) ? prefix : Iterable.single(prefix)) {
+        for (const _prefix of Iterable.wrap(prefix)) {
             bucket.push(( (new Snippet(
                 Boolean(isFileTemplate),
                 scopes,
@@ -298,7 +297,7 @@ class SnippetCompletion {
         this.command = { id: markSnippetAsUsed, title: '', arguments: [snippet] };
     }
     resolve() {
-        this.documentation = ( (new MarkdownString())).appendCodeblock('', ( (new SnippetParser())).text(this.snippet.codeSnippet));
+        this.documentation = ( (new MarkdownString())).appendCodeblock('', SnippetParser.asInsertText(this.snippet.codeSnippet));
         return this;
     }
     static compareByLabel(a, b) {
@@ -330,7 +329,10 @@ let SnippetCompletionProvider = class SnippetCompletionProvider {
             if (wordUntil && word && !isPatternInWord(wordUntil, 0, wordUntil.length, snippet.prefixLow, 0, snippet.prefixLow.length)) {
                 continue snippet;
             }
-            column: for (let pos = Math.max(0, columnOffset - snippet.prefixLow.length); pos < lineContentLow.length; pos++) {
+            const minPos = firstNonWhitespaceIndex(snippet.prefixLow) === 0
+                ? Math.max(0, model.getLineFirstNonWhitespaceColumn(position.lineNumber) - 1)
+                : 0;
+            column: for (let pos = Math.max(minPos, columnOffset - snippet.prefixLow.length); pos < lineContentLow.length; pos++) {
                 if (!isPatternInWord(lineContentLow, pos, columnOffset, snippet.prefixLow, 0, snippet.prefixLow.length)) {
                     continue column;
                 }

package/dist/textmate.d.ts

@@ -10,12 +10,28 @@ interface ServiceIdentifier<T> {
     type: T;
 }
 
+/**
+ * An object that performs a cleanup operation when `.dispose()` is called.
+ *
+ * Some examples of how disposables are used:
+ *
+ * - An event listener that removes itself when `.dispose()` is called.
+ * - A resource such as a file system watcher that cleans up the resource when `.dispose()` is called.
+ * - The return value from registering a provider. When `.dispose()` is called, the provider is unregistered.
+ */
 interface IDisposable {
     dispose(): void;
 }
+/**
+ * Manages a collection of disposable values.
+ *
+ * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
+ * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
+ * store that has already been disposed of.
+ */
 declare class DisposableStore implements IDisposable {
     static DISABLE_DISPOSED_WARNING: boolean;
-    private _toDispose;
+    private readonly _toDispose;
     private _isDisposed;
     constructor();
     /**
@@ -25,13 +41,16 @@ declare class DisposableStore implements IDisposable {
      */
     dispose(): void;
     /**
-     * Returns `true` if this object has been disposed
+     * @return `true` if this object has been disposed of.
      */
     get isDisposed(): boolean;
     /**
      * Dispose of all registered disposables but do not mark this object as disposed.
      */
     clear(): void;
+    /**
+     * Add a new {@link IDisposable disposable} to the collection.
+     */
     add<T extends IDisposable>(o: T): T;
 }
 
@@ -89,20 +108,50 @@ interface IObserver {
 }
 
 /**
- * To an event a function with one or zero parameters
- * can be subscribed. The event is the subscriber function itself.
+ * Can be passed into the Delayed to defer using a microtask
+ * */
+declare const MicrotaskDelay: unique symbol;
+
+/**
+ * An event with zero or one parameters that can be subscribed to. The event is a function itself.
  */
 type Event<T> = vscode.Event<T>
 declare namespace Event {
     const None: Event<any>;
+    /**
+     * Given an event, returns another event which debounces calls and defers the listeners to a later task via a shared
+     * `setTimeout`. The event is converted into a signal (`Event<void>`) to avoid additional object creation as a
+     * result of merging events and to try prevent race conditions that could arise when using related deferred and
+     * non-deferred events.
+     *
+     * This is useful for deferring non-critical work (eg. general UI updates) to ensure it does not block critical work
+     * (eg. latency of keypress to text rendered).
+     *
+     * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
+     * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
+     * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param disposable A disposable store to add the new EventEmitter to.
+     */
+    function defer(event: Event<unknown>, disposable?: DisposableStore): Event<void>;
     /**
      * Given an event, returns another event which only fires once.
+     *
+     * @param event The event source for the new event.
      */
     function once<T>(event: Event<T>): Event<T>;
     /**
+     * Maps an event of one type into an event of another type using a mapping function, similar to how
+     * `Array.prototype.map` works.
+     *
      * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
      * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
      * returned event causes this utility to leak a listener on the original event.
+     *
+     * @param event The event source for the new event.
+     * @param map The mapping function.
+     * @param disposable A disposable store to add the new EventEmitter to.
      */
     function map<I, O>(event: Event<I>, map: (i: I) => O, disposable?: DisposableStore): Event<O>;
     /**
@@ -136,17 +185,33 @@ declare namespace Event {
      */
     function reduce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, initial?: O, disposable?: DisposableStore): Event<O>;
     /**
+     * Given an event, creates a new emitter that event that will debounce events based on {@link delay} and give an
+     * array event object of all events that fired.
+     *
      * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
      * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
      * returned event causes this utility to leak a listener on the original event.
-     */
-    function debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;
-    /**
+     *
+     * @param event The original event to debounce.
+     * @param merge A function that reduces all events into a single event.
+     * @param delay The number of milliseconds to debounce.
+     * @param leading Whether to fire a leading event without debouncing.
+     * @param flushOnListenerRemove Whether to fire all debounced events when a listener is removed. If this is not
+     * specified, some events could go missing. Use this if it's important that all events are processed, even if the
+     * listener gets disposed before the debounced event fires.
+     * @param leakWarningThreshold See {@link EmitterOptions.leakWarningThreshold}.
+     * @param disposable A disposable store to register the debounce emitter to.
+     */
+    function debounce<T>(event: Event<T>, merge: (last: T | undefined, event: T) => T, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<T>;
+    function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number | typeof MicrotaskDelay, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;
+    /**
+     * Debounces an event, firing after some delay (default=0) with an array of all event original objects.
+     *
      * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
      * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
      * returned event causes this utility to leak a listener on the original event.
      */
-    function debounce<I, O>(event: Event<I>, merge: (last: O | undefined, event: I) => O, delay?: number, leading?: boolean, leakWarningThreshold?: number, disposable?: DisposableStore): Event<O>;
+    function accumulate<T>(event: Event<T>, delay?: number, disposable?: DisposableStore): Event<T[]>;
     /**
      * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
      * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
@@ -154,9 +219,21 @@ declare namespace Event {
      */
     function latch<T>(event: Event<T>, equals?: (a: T, b: T) => boolean, disposable?: DisposableStore): Event<T>;
     /**
+     * Splits an event whose parameter is a union type into 2 separate events for each type in the union.
+     *
      * *NOTE* that this function returns an `Event` and it MUST be called with a `DisposableStore` whenever the returned
      * event is accessible to "third parties", e.g the event is a public property. Otherwise a leaked listener on the
      * returned event causes this utility to leak a listener on the original event.
+     *
+     * @example
+     * ```
+     * const event = new EventEmitter<number | undefined>().event;
+     * const [numberEvent, undefinedEvent] = Event.split(event, isUndefined);
+     * ```
+     *
+     * @param event The event source for the new event.
+     * @param isT A function that determines what event is of the first type.
+     * @param disposable A disposable store to add the new EventEmitter to.
      */
     function split<T, U>(event: Event<T | U>, isT: (e: T | U) => e is T, disposable?: DisposableStore): [Event<T>, Event<U>];
     /**
@@ -173,8 +250,8 @@ declare namespace Event {
         filter<R>(fn: (e: T | R) => e is R): IChainableEvent<R>;
         reduce<R>(merge: (last: R | undefined, event: T) => R, initial?: R): IChainableEvent<R>;
         latch(): IChainableEvent<T>;
-        debounce(merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, leakWarningThreshold?: number): IChainableEvent<T>;
-        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: boolean, leakWarningThreshold?: number): IChainableEvent<R>;
+        debounce(merge: (last: T | undefined, event: T) => T, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<T>;
+        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: boolean, flushOnListenerRemove?: boolean, leakWarningThreshold?: number): IChainableEvent<R>;
         on(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
         once(listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[]): IDisposable;
     }
@@ -345,17 +422,28 @@ interface UriComponents {
     fragment: string;
 }
 
+interface ILocalizedString {
+    /**
+     * The localized value of the string.
+     */
+    value: string;
+    /**
+     * The original (non localized value of the string)
+     */
+    original: string;
+}
+
 /**
  * Type of extension.
  *
  * **NOTE**: This is defined in `platform/environment` because it can appear as a CLI argument.
  */
-declare type ExtensionKind = 'ui' | 'workspace' | 'web';
+type ExtensionKind = 'ui' | 'workspace' | 'web';
 
 interface ICommand {
     command: string;
-    title: string;
-    category?: string;
+    title: string | ILocalizedString;
+    category?: string | ILocalizedString;
 }
 interface IConfigurationProperty {
     description: string;
@@ -477,6 +565,7 @@ interface IWalkthroughStep {
 interface IWalkthrough {
     readonly id: string;
     readonly title: string;
+    readonly icon?: string;
     readonly description: string;
     readonly steps: IWalkthroughStep[];
     readonly featuredFor: string[] | undefined;
@@ -546,8 +635,8 @@ interface IExtensionCapabilities {
     readonly virtualWorkspaces?: ExtensionVirtualWorkspaceSupport;
     readonly untrustedWorkspaces?: ExtensionUntrustedWorkspaceSupport;
 }
-declare type LimitedWorkspaceSupportType = 'limited';
-declare type ExtensionUntrustedWorkspaceSupport = {
+type LimitedWorkspaceSupportType = 'limited';
+type ExtensionUntrustedWorkspaceSupport = {
     supported: true;
 } | {
     supported: false;
@@ -557,7 +646,7 @@ declare type ExtensionUntrustedWorkspaceSupport = {
     description: string;
     restrictedConfigurations?: string[];
 };
-declare type ExtensionVirtualWorkspaceSupport = boolean | {
+type ExtensionVirtualWorkspaceSupport = boolean | {
     supported: true;
 } | {
     supported: false | LimitedWorkspaceSupportType;
@@ -574,6 +663,8 @@ interface IRelaxedExtensionManifest {
     description?: string;
     main?: string;
     browser?: string;
+    preview?: boolean;
+    l10n?: string;
     icon?: string;
     categories?: string[];
     keywords?: string[];
@@ -646,13 +737,16 @@ interface IRelaxedExtensionDescription extends IRelaxedExtensionManifest {
     isUserBuiltin: boolean;
     isUnderDevelopment: boolean;
     extensionLocation: URI;
+    browserNlsBundleUris?: {
+        [language: string]: URI;
+    };
 }
-declare type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
+type IExtensionDescription = Readonly<IRelaxedExtensionDescription>;
 
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 
-declare const ITextMateService: ServiceIdentifier<ITextMateService>;
-interface ITextMateService {
+declare const ITextMateTokenizationService: ServiceIdentifier<ITextMateTokenizationService>;
+interface ITextMateTokenizationService {
     readonly _serviceBrand: undefined;
     onDidEncounterLanguage: Event<string>;
     createGrammar(languageId: string): Promise<IGrammar$1 | null>;
@@ -680,4 +774,4 @@ type PartialITMSyntaxExtensionPoint = Partial<ITMSyntaxExtensionPoint> & Pick<IT
 declare function setGrammars<T extends PartialITMSyntaxExtensionPoint>(grammars: T[], getContent: (grammar: T) => Promise<string>, extension?: IExtensionDescription): void;
 declare function getServiceOverride(getOnigLib: () => Promise<Response | ArrayBuffer>): IEditorOverrideServices;
 
-export { PartialITMSyntaxExtensionPoint as ITMSyntaxExtensionPoint, ITextMateService, getServiceOverride as default, setGrammars };
+export { PartialITMSyntaxExtensionPoint as ITMSyntaxExtensionPoint, ITextMateTokenizationService, getServiceOverride as default, setGrammars };