@codingame/monaco-vscode-api 1.76.8 → 1.78.0-next.0

package/dist/textmate.d.ts

@@ -1,5 +1,4 @@
 import * as monaco from 'monaco-editor';
-import * as vscode from 'vscode';
 import { IGrammar } from 'vscode-textmate';
 
 /**
@@ -10,274 +9,11 @@ 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 readonly _toDispose;
-    private _isDisposed;
-    constructor();
-    /**
-     * Dispose of all registered disposables and mark this object as disposed.
-     *
-     * Any future disposables added to this object will be disposed of on `add`.
-     */
-    dispose(): void;
-    /**
-     * @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;
-}
-
-interface IObservable<T, TChange = void> {
-    readonly TChange: TChange;
-    /**
-     * Reads the current value.
-     *
-     * Must not be called from {@link IObserver.handleChange}.
-     */
-    get(): T;
-    /**
-     * Adds an observer.
-     */
-    addObserver(observer: IObserver): void;
-    removeObserver(observer: IObserver): void;
-    /**
-     * Subscribes the reader to this observable and returns the current value of this observable.
-     */
-    read(reader: IReader): T;
-    map<TNew>(fn: (value: T) => TNew): IObservable<TNew>;
-    readonly debugName: string;
-}
-interface IReader {
-    /**
-     * Reports an observable that was read.
-     *
-     * Is called by {@link IObservable.read}.
-     */
-    subscribeTo<T>(observable: IObservable<T, any>): void;
-}
-interface IObserver {
-    /**
-     * Indicates that an update operation is about to begin.
-     *
-     * During an update, invariants might not hold for subscribed observables and
-     * change events might be delayed.
-     * However, all changes must be reported before all update operations are over.
-     */
-    beginUpdate<T>(observable: IObservable<T>): void;
-    /**
-     * Is called by a subscribed observable immediately after it notices a change.
-     *
-     * When {@link IObservable.get} returns and no change has been reported,
-     * there has been no change for that observable.
-     *
-     * Implementations must not call into other observables!
-     * The change should be processed when {@link IObserver.endUpdate} is called.
-     */
-    handleChange<T, TChange>(observable: IObservable<T, TChange>, change: TChange): void;
-    /**
-     * Indicates that an update operation has completed.
-     */
-    endUpdate<T>(observable: IObservable<T>): void;
-}
-
-/**
- * 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>;
-    /**
-     * *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 forEach<I>(event: Event<I>, each: (i: I) => void, disposable?: DisposableStore): Event<I>;
-    /**
-     * *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 filter<T, U>(event: Event<T | U>, filter: (e: T | U) => e is T, disposable?: DisposableStore): Event<T>;
-    function filter<T>(event: Event<T>, filter: (e: T) => boolean, disposable?: DisposableStore): Event<T>;
-    function filter<T, R>(event: Event<T | R>, filter: (e: T | R) => e is R, disposable?: DisposableStore): Event<R>;
-    /**
-     * Given an event, returns the same event but typed as `Event<void>`.
-     */
-    function signal<T>(event: Event<T>): Event<void>;
-    /**
-     * Given a collection of events, returns a single event which emits
-     * whenever any of the provided events emit.
-     */
-    function any<T>(...events: Event<T>[]): Event<T>;
-    function any(...events: Event<any>[]): Event<void>;
-    /**
-     * *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 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.
-     *
-     * @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 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
-     * returned event causes this utility to leak a listener on the original 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>];
-    /**
-     * *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 buffer<T>(event: Event<T>, flushAfterTimeout?: boolean, _buffer?: T[]): Event<T>;
-    interface IChainableEvent<T> extends IDisposable {
-        event: Event<T>;
-        map<O>(fn: (i: T) => O): IChainableEvent<O>;
-        forEach(fn: (i: T) => void): IChainableEvent<T>;
-        filter(fn: (e: T) => boolean): IChainableEvent<T>;
-        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, 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;
-    }
-    function chain<T>(event: Event<T>): IChainableEvent<T>;
-    interface NodeEventEmitter {
-        on(event: string | symbol, listener: Function): unknown;
-        removeListener(event: string | symbol, listener: Function): unknown;
-    }
-    function fromNodeEventEmitter<T>(emitter: NodeEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
-    interface DOMEventEmitter {
-        addEventListener(event: string | symbol, listener: Function): void;
-        removeEventListener(event: string | symbol, listener: Function): void;
-    }
-    function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
-    function toPromise<T>(event: Event<T>): Promise<T>;
-    function runAndSubscribe<T>(event: Event<T>, handler: (e: T | undefined) => any): IDisposable;
-    function runAndSubscribeWithStore<T>(event: Event<T>, handler: (e: T | undefined, disposableStore: DisposableStore) => any): IDisposable;
-    function fromObservable<T>(obs: IObservable<T, any>, store?: DisposableStore): Event<T>;
-}
-
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 
 declare const ITextMateTokenizationService: ServiceIdentifier<ITextMateTokenizationService>;
 interface ITextMateTokenizationService {
     readonly _serviceBrand: undefined;
-    onDidEncounterLanguage: Event<string>;
     createGrammar(languageId: string): Promise<IGrammar | null>;
     startDebugMode(printFn: (str: string) => void, onStop: () => void): void;
 }