@codingame/monaco-vscode-api 1.67.13 → 1.67.16

package/dist/async-f842d13c.js

@@ -0,0 +1,212 @@
+import { E as Emitter } from './missing-services-8687ea11.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { extUri } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { CancellationError } from 'monaco-editor/esm/vs/base/common/errors.js';
+function isThenable(obj) {
+    return !!obj && typeof obj.then === 'function';
+}
+function raceCancellationError(promise, token) {
+    return (
+         new Promise((resolve, reject) => {
+            const ref = token.onCancellationRequested(() => {
+                ref.dispose();
+                reject( new CancellationError());
+            });
+            promise.then(resolve, reject).finally(() => ref.dispose());
+        })
+    );
+}
+function asPromise(callback) {
+    return (
+         new Promise((resolve, reject) => {
+            const item = callback();
+            if (isThenable(item)) {
+                item.then(resolve, reject);
+            }
+            else {
+                resolve(item);
+            }
+        })
+    );
+}
+class Barrier {
+    constructor() {
+        this._isOpen = false;
+        this._promise =  new Promise((c, e) => {
+            this._completePromise = c;
+        });
+    }
+    isOpen() {
+        return this._isOpen;
+    }
+    open() {
+        this._isOpen = true;
+        this._completePromise(true);
+    }
+    wait() {
+        return this._promise;
+    }
+}
+class Limiter {
+    constructor(maxDegreeOfParalellism) {
+        this._size = 0;
+        this.maxDegreeOfParalellism = maxDegreeOfParalellism;
+        this.outstandingPromises = [];
+        this.runningPromises = 0;
+        this._onFinished =  new Emitter();
+    }
+    get onFinished() {
+        return this._onFinished.event;
+    }
+    get size() {
+        return this._size;
+    }
+    queue(factory) {
+        this._size++;
+        return (
+             new Promise((c, e) => {
+                this.outstandingPromises.push({ factory, c, e });
+                this.consume();
+            })
+        );
+    }
+    consume() {
+        while (this.outstandingPromises.length && this.runningPromises < this.maxDegreeOfParalellism) {
+            const iLimitedTask = this.outstandingPromises.shift();
+            this.runningPromises++;
+            const promise = iLimitedTask.factory();
+            promise.then(iLimitedTask.c, iLimitedTask.e);
+            promise.then(() => this.consumed(), () => this.consumed());
+        }
+    }
+    consumed() {
+        this._size--;
+        this.runningPromises--;
+        if (this.outstandingPromises.length > 0) {
+            this.consume();
+        }
+        else {
+            this._onFinished.fire();
+        }
+    }
+    dispose() {
+        this._onFinished.dispose();
+    }
+}
+class Queue extends Limiter {
+    constructor() {
+        super(1);
+    }
+}
+class ResourceQueue {
+    constructor() {
+        this.queues =  new Map();
+        this.drainers =  new Set();
+    }
+    async whenDrained() {
+        if (this.isDrained()) {
+            return;
+        }
+        const promise =  new DeferredPromise();
+        this.drainers.add(promise);
+        return promise.p;
+    }
+    isDrained() {
+        for (const [, queue] of this.queues) {
+            if (queue.size > 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    queueFor(resource, extUri$1 = extUri) {
+        const key = extUri$1.getComparisonKey(resource);
+        let queue = this.queues.get(key);
+        if (!queue) {
+            queue =  new Queue();
+            Event.once(queue.onFinished)(() => {
+                queue?.dispose();
+                this.queues.delete(key);
+                this.onDidQueueFinish();
+            });
+            this.queues.set(key, queue);
+        }
+        return queue;
+    }
+    onDidQueueFinish() {
+        if (!this.isDrained()) {
+            return;
+        }
+        this.releaseDrainers();
+    }
+    releaseDrainers() {
+        for (const drainer of this.drainers) {
+            drainer.complete();
+        }
+        this.drainers.clear();
+    }
+    dispose() {
+        for (const [, queue] of this.queues) {
+            queue.dispose();
+        }
+        this.queues.clear();
+        this.releaseDrainers();
+    }
+}
+class IntervalCounter {
+    constructor(interval, nowFn = () => Date.now()) {
+        this.interval = interval;
+        this.nowFn = nowFn;
+        this.lastIncrementTime = 0;
+        this.value = 0;
+    }
+    increment() {
+        const now = this.nowFn();
+        if (now - this.lastIncrementTime > this.interval) {
+            this.lastIncrementTime = now;
+            this.value = 0;
+        }
+        this.value++;
+        return this.value;
+    }
+}
+class DeferredPromise {
+    constructor() {
+        this.rejected = false;
+        this.resolved = false;
+        this.p =  new Promise((c, e) => {
+            this.completeCallback = c;
+            this.errorCallback = e;
+        });
+    }
+    get isRejected() {
+        return this.rejected;
+    }
+    get isResolved() {
+        return this.resolved;
+    }
+    get isSettled() {
+        return this.rejected || this.resolved;
+    }
+    complete(value) {
+        return (
+             new Promise(resolve => {
+                this.completeCallback(value);
+                this.resolved = true;
+                resolve();
+            })
+        );
+    }
+    error(err) {
+        return (
+             new Promise(resolve => {
+                this.errorCallback(err);
+                this.rejected = true;
+                resolve();
+            })
+        );
+    }
+    cancel() {
+    }
+}
+export { Barrier as B, IntervalCounter as I, ResourceQueue as R, asPromise as a, raceCancellationError as r };

package/dist/configuration.d.ts

@@ -0,0 +1,292 @@
+import * as monaco from 'monaco-editor';
+import * as vscode from 'vscode';
+
+interface IDisposable {
+    dispose(): void;
+}
+declare class DisposableStore implements IDisposable {
+    static DISABLE_DISPOSED_WARNING: boolean;
+    private _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;
+    /**
+     * Returns `true` if this object has been disposed
+     */
+    get isDisposed(): boolean;
+    /**
+     * Dispose of all registered disposables but do not mark this object as disposed.
+     */
+    clear(): void;
+    add<T extends IDisposable>(o: T): T;
+}
+
+/**
+ * To an event a function with one or zero parameters
+ * can be subscribed. The event is the subscriber function itself.
+ */
+type Event<T> = vscode.Event<T>
+declare namespace Event {
+    const None: Event<any>;
+    /**
+     * Given an event, returns another event which only fires once.
+     */
+    function once<T>(event: Event<T>): 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 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>;
+    /**
+     * *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>;
+    /**
+     * *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>;
+    /**
+     * *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>;
+    /**
+     * *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 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> {
+        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, leakWarningThreshold?: number): IChainableEvent<T>;
+        debounce<R>(merge: (last: R | undefined, event: T) => R, delay?: number, leading?: 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;
+    }
+    /**
+     * @deprecated DO NOT use, this leaks memory
+     */
+    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;
+}
+
+/**
+ * Uniform Resource Identifier (URI) http://tools.ietf.org/html/rfc3986.
+ * This class is a simple parser which creates the basic component parts
+ * (http://tools.ietf.org/html/rfc3986#section-3) with minimal validation
+ * and encoding.
+ *
+ * ```txt
+ *       foo://example.com:8042/over/there?name=ferret#nose
+ *       \_/   \______________/\_________/ \_________/ \__/
+ *        |           |            |            |        |
+ *     scheme     authority       path        query   fragment
+ *        |   _____________________|__
+ *       / \ /                        \
+ *       urn:example:animal:ferret:nose
+ * ```
+ */
+declare class URI implements UriComponents {
+    static isUri(thing: any): thing is URI;
+    /**
+     * scheme is the 'http' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part before the first colon.
+     */
+    readonly scheme: string;
+    /**
+     * authority is the 'www.example.com' part of 'http://www.example.com/some/path?query#fragment'.
+     * The part between the first double slashes and the next slash.
+     */
+    readonly authority: string;
+    /**
+     * path is the '/some/path' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly path: string;
+    /**
+     * query is the 'query' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly query: string;
+    /**
+     * fragment is the 'fragment' part of 'http://www.example.com/some/path?query#fragment'.
+     */
+    readonly fragment: string;
+    /**
+     * @internal
+     */
+    protected constructor(scheme: string, authority?: string, path?: string, query?: string, fragment?: string, _strict?: boolean);
+    /**
+     * @internal
+     */
+    protected constructor(components: UriComponents);
+    /**
+     * Returns a string representing the corresponding file system path of this URI.
+     * Will handle UNC paths, normalizes windows drive letters to lower-case, and uses the
+     * platform specific path separator.
+     *
+     * * Will *not* validate the path for invalid characters and semantics.
+     * * Will *not* look at the scheme of this URI.
+     * * The result shall *not* be used for display purposes but for accessing a file on disk.
+     *
+     *
+     * The *difference* to `URI#path` is the use of the platform specific separator and the handling
+     * of UNC paths. See the below sample of a file-uri with an authority (UNC path).
+     *
+     * ```ts
+        const u = URI.parse('file://server/c$/folder/file.txt')
+        u.authority === 'server'
+        u.path === '/shares/c$/file.txt'
+        u.fsPath === '\\server\c$\folder\file.txt'
+    ```
+     *
+     * Using `URI#path` to read a file (using fs-apis) would not be enough because parts of the path,
+     * namely the server name, would be missing. Therefore `URI#fsPath` exists - it's sugar to ease working
+     * with URIs that represent files on disk (`file` scheme).
+     */
+    get fsPath(): string;
+    with(change: {
+        scheme?: string;
+        authority?: string | null;
+        path?: string | null;
+        query?: string | null;
+        fragment?: string | null;
+    }): URI;
+    /**
+     * Creates a new URI from a string, e.g. `http://www.example.com/some/path`,
+     * `file:///usr/home`, or `scheme:with/path`.
+     *
+     * @param value A string which represents an URI (see `URI#toString`).
+     */
+    static parse(value: string, _strict?: boolean): URI;
+    /**
+     * Creates a new URI from a file system path, e.g. `c:\my\files`,
+     * `/usr/home`, or `\\server\share\some\path`.
+     *
+     * The *difference* between `URI#parse` and `URI#file` is that the latter treats the argument
+     * as path, not as stringified-uri. E.g. `URI.file(path)` is **not the same as**
+     * `URI.parse('file://' + path)` because the path might contain characters that are
+     * interpreted (# and ?). See the following sample:
+     * ```ts
+    const good = URI.file('/coding/c#/project1');
+    good.scheme === 'file';
+    good.path === '/coding/c#/project1';
+    good.fragment === '';
+    const bad = URI.parse('file://' + '/coding/c#/project1');
+    bad.scheme === 'file';
+    bad.path === '/coding/c'; // path is now broken
+    bad.fragment === '/project1';
+    ```
+     *
+     * @param path A file system path (see `URI#fsPath`)
+     */
+    static file(path: string): URI;
+    static from(components: {
+        scheme: string;
+        authority?: string;
+        path?: string;
+        query?: string;
+        fragment?: string;
+    }): URI;
+    /**
+     * Join a URI path with path fragments and normalizes the resulting path.
+     *
+     * @param uri The input URI.
+     * @param pathFragment The path fragment to add to the URI path.
+     * @returns The resulting URI.
+     */
+    static joinPath(uri: URI, ...pathFragment: string[]): URI;
+    /**
+     * Creates a string representation for this URI. It's guaranteed that calling
+     * `URI.parse` with the result of this function creates an URI which is equal
+     * to this URI.
+     *
+     * * The result shall *not* be used for display purposes but for externalization or transport.
+     * * The result will be encoded using the percentage encoding and encoding happens mostly
+     * ignore the scheme-specific encoding rules.
+     *
+     * @param skipEncoding Do not encode the result, default is `false`
+     */
+    toString(skipEncoding?: boolean): string;
+    toJSON(): UriComponents;
+    static revive(data: UriComponents | URI): URI;
+    static revive(data: UriComponents | URI | undefined): URI | undefined;
+    static revive(data: UriComponents | URI | null): URI | null;
+    static revive(data: UriComponents | URI | undefined | null): URI | undefined | null;
+}
+interface UriComponents {
+    scheme: string;
+    authority: string;
+    path: string;
+    query: string;
+    fragment: string;
+}
+
+type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
+
+declare function getServiceOverride(readConfiguration: () => string, onChange: Event<void>, settingsResource?: URI): IEditorOverrideServices;
+
+export { getServiceOverride as default };