@theia/core 1.67.0-next.56 → 1.67.0-next.59

package/lib/common/encodings.d.ts

@@ -0,0 +1,8 @@
+export declare const UTF8 = "utf8";
+export declare const UTF8_with_bom = "utf8bom";
+export declare const UTF16be = "utf16be";
+export declare const UTF16le = "utf16le";
+export declare const UTF16be_BOM: number[];
+export declare const UTF16le_BOM: number[];
+export declare const UTF8_BOM: number[];
+//# sourceMappingURL=encodings.d.ts.map

package/lib/common/encodings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodings.d.ts","sourceRoot":"","sources":["../../src/common/encodings.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,IAAI,SAAS,CAAC;AAC3B,eAAO,MAAM,aAAa,YAAY,CAAC;AACvC,eAAO,MAAM,OAAO,YAAY,CAAC;AACjC,eAAO,MAAM,OAAO,YAAY,CAAC;AAEjC,eAAO,MAAM,WAAW,UAAe,CAAC;AACxC,eAAO,MAAM,WAAW,UAAe,CAAC;AACxC,eAAO,MAAM,QAAQ,UAAqB,CAAC"}

package/lib/common/encodings.js

@@ -0,0 +1,26 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2020 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
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UTF8_BOM = exports.UTF16le_BOM = exports.UTF16be_BOM = exports.UTF16le = exports.UTF16be = exports.UTF8_with_bom = exports.UTF8 = void 0;
+exports.UTF8 = 'utf8';
+exports.UTF8_with_bom = 'utf8bom';
+exports.UTF16be = 'utf16be';
+exports.UTF16le = 'utf16le';
+exports.UTF16be_BOM = [0xFE, 0xFF];
+exports.UTF16le_BOM = [0xFF, 0xFE];
+exports.UTF8_BOM = [0xEF, 0xBB, 0xBF];
+//# sourceMappingURL=encodings.js.map

package/lib/common/encodings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encodings.js","sourceRoot":"","sources":["../../src/common/encodings.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,yCAAyC;AACzC,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;;;AAEnE,QAAA,IAAI,GAAG,MAAM,CAAC;AACd,QAAA,aAAa,GAAG,SAAS,CAAC;AAC1B,QAAA,OAAO,GAAG,SAAS,CAAC;AACpB,QAAA,OAAO,GAAG,SAAS,CAAC;AAEpB,QAAA,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC3B,QAAA,WAAW,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;AAC3B,QAAA,QAAQ,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC"}

package/lib/common/env-variables/env-variables-protocol.d.ts

@@ -0,0 +1,21 @@
+export declare const envVariablesPath = "/services/envs";
+export declare const EnvVariablesServer: unique symbol;
+export interface EnvVariablesServer {
+    getExecPath(): Promise<string>;
+    getVariables(): Promise<EnvVariable[]>;
+    getValue(key: string): Promise<EnvVariable | undefined>;
+    getConfigDirUri(): Promise<string>;
+    /**
+     * Resolves to a URI representing the current user's home directory.
+     */
+    getHomeDirUri(): Promise<string>;
+    /**
+     * Resolves to an array of URIs pointing to the available drives on the filesystem.
+     */
+    getDrives(): Promise<string[]>;
+}
+export interface EnvVariable {
+    readonly name: string;
+    readonly value: string | undefined;
+}
+//# sourceMappingURL=env-variables-protocol.d.ts.map

package/lib/common/env-variables/env-variables-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-variables-protocol.d.ts","sourceRoot":"","sources":["../../../src/common/env-variables/env-variables-protocol.ts"],"names":[],"mappings":"AAgBA,eAAO,MAAM,gBAAgB,mBAAmB,CAAC;AAEjD,eAAO,MAAM,kBAAkB,eAA+B,CAAC;AAC/D,MAAM,WAAW,kBAAkB;IAC/B,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC,CAAA;IAC9B,YAAY,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAAA;IACtC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAAA;IACvD,eAAe,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACnC;;OAEG;IACH,aAAa,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;IACjC;;OAEG;IACH,SAAS,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;CAClC;AAED,MAAM,WAAW,WAAW;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CACrC"}

package/lib/common/env-variables/env-variables-protocol.js

@@ -0,0 +1,21 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2018 Red Hat, Inc. 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
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnvVariablesServer = exports.envVariablesPath = void 0;
+exports.envVariablesPath = '/services/envs';
+exports.EnvVariablesServer = Symbol('EnvVariablesServer');
+//# sourceMappingURL=env-variables-protocol.js.map

package/lib/common/env-variables/env-variables-protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-variables-protocol.js","sourceRoot":"","sources":["../../../src/common/env-variables/env-variables-protocol.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,+CAA+C;AAC/C,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;;;AAEnE,QAAA,gBAAgB,GAAG,gBAAgB,CAAC;AAEpC,QAAA,kBAAkB,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAAC"}

package/lib/common/env-variables/index.d.ts

@@ -0,0 +1,2 @@
+export * from './env-variables-protocol';
+//# sourceMappingURL=index.d.ts.map

package/lib/common/env-variables/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/common/env-variables/index.ts"],"names":[],"mappings":"AAgBA,cAAc,0BAA0B,CAAC"}

package/lib/common/env-variables/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2018 Red Hat, Inc. 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
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./env-variables-protocol"), exports);
+//# sourceMappingURL=index.js.map

package/lib/common/env-variables/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/common/env-variables/index.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,+CAA+C;AAC/C,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;;;AAEhF,mEAAyC"}

package/lib/common/event.d.ts

@@ -0,0 +1,123 @@
+import { Disposable, DisposableGroup } from './disposable';
+import { MaybePromise } from './types';
+/**
+ * Represents a typed event.
+ */
+export interface Event<T> {
+    /**
+     *
+     * @param listener The listener function will be call when the event happens.
+     * @param thisArgs The 'this' which will be used when calling the event listener.
+     * @param disposables An array to which a {{IDisposable}} will be added.
+     * @return a disposable to remove the listener again.
+     */
+    (listener: (e: T) => any, thisArgs?: any, disposables?: DisposableGroup): Disposable;
+}
+export declare namespace Event {
+    function getMaxListeners(event: Event<unknown>): number;
+    function setMaxListeners<N extends number>(event: Event<unknown>, maxListeners: N): N;
+    function addMaxListeners(event: Event<unknown>, add: number): number;
+    const None: Event<any>;
+    /**
+     * Given an event, returns another event which only fires once.
+     */
+    function once<T>(event: Event<T>): Event<T>;
+    function toPromise<T>(event: Event<T>): Promise<T>;
+    function filter<T>(event: Event<T>, predicate: (e: T) => unknown): Event<T>;
+    function filter<T, S extends T>(event: Event<T>, predicate: (e: T) => e is S): Event<S>;
+    /**
+     * Given an event and a `map` function, returns another event which maps each element
+     * through the mapping function.
+     */
+    function map<I, O>(event: Event<I>, mapFunc: (i: I) => O): Event<O>;
+    /**
+     * 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>;
+}
+type Callback = (...args: any[]) => any;
+declare class CallbackList implements Iterable<Callback> {
+    private _callbacks;
+    private _contexts;
+    get length(): number;
+    add(callback: Function, context?: any, bucket?: Disposable[]): void;
+    remove(callback: Function, context?: any): void;
+    [Symbol.iterator](): IterableIterator<(...args: any[]) => any>;
+    invoke(...args: any[]): any[];
+    isEmpty(): boolean;
+    dispose(): void;
+}
+export interface EmitterOptions {
+    onFirstListenerAdd?: Function;
+    onLastListenerRemove?: Function;
+}
+export declare class Emitter<T = any> {
+    private _options?;
+    private static LEAK_WARNING_THRESHHOLD;
+    private static _noop;
+    private _event;
+    protected _callbacks: CallbackList | undefined;
+    private _disposed;
+    private _leakingStacks;
+    private _leakWarnCountdown;
+    constructor(_options?: EmitterOptions | undefined);
+    /**
+     * For the public to allow to subscribe
+     * to events from this Emitter
+     */
+    get event(): Event<T>;
+    protected checkMaxListeners(maxListeners: number): (() => void) | undefined;
+    protected pushLeakingStack(): () => void;
+    protected popLeakingStack(stack: string): void;
+    /**
+     * To be kept private to fire an event to
+     * subscribers
+     */
+    fire(event: T): any;
+    /**
+     * Process each listener one by one.
+     * Return `false` to stop iterating over the listeners, `true` to continue.
+     */
+    sequence(processor: (listener: (e: T) => any) => MaybePromise<boolean>): Promise<void>;
+    dispose(): void;
+}
+export type WaitUntilData<T> = Omit<T, 'waitUntil' | 'token'>;
+export interface WaitUntilEvent {
+    /**
+     * A cancellation token.
+     */
+    token: CancellationToken;
+    /**
+     * Allows to pause the event loop until the provided thenable resolved.
+     *
+     * *Note:* It can only be called during event dispatch and not in an asynchronous manner
+     *
+     * @param thenable A thenable that delays execution.
+     */
+    waitUntil(thenable: Promise<any>): void;
+}
+export declare namespace WaitUntilEvent {
+    /**
+     * Fire all listeners in the same tick.
+     *
+     * Use `AsyncEmitter.fire` to fire listeners async one after another.
+     */
+    function fire<T extends WaitUntilEvent>(emitter: Emitter<T>, event: WaitUntilData<T>, timeout?: number, token?: CancellationToken): Promise<void>;
+}
+import { CancellationToken } from './cancellation';
+export declare class AsyncEmitter<T extends WaitUntilEvent> extends Emitter<T> {
+    protected deliveryQueue: Promise<void> | undefined;
+    /**
+     * Fire listeners async one after another.
+     */
+    fire(event: WaitUntilData<T>, token?: CancellationToken, promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void>;
+    protected deliver(listeners: Callback[], event: WaitUntilData<T>, token: CancellationToken, promiseJoin?: (p: Promise<any>, listener: Function) => Promise<any>): Promise<void>;
+}
+export declare class QueueableEmitter<T> extends Emitter<T[]> {
+    currentQueue?: T[];
+    queue(...arg: T[]): void;
+    fire(): void;
+}
+export {};
+//# sourceMappingURL=event.d.ts.map

package/lib/common/event.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event.d.ts","sourceRoot":"","sources":["../../src/common/event.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,UAAU,EAAE,eAAe,EAAwB,MAAM,cAAc,CAAC;AACjF,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC;;GAEG;AACH,MAAM,WAAW,KAAK,CAAC,CAAC;IAEpB;;;;;;OAMG;IACH,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,GAAG,EAAE,QAAQ,CAAC,EAAE,GAAG,EAAE,WAAW,CAAC,EAAE,eAAe,GAAG,UAAU,CAAC;CACxF;AAED,yBAAiB,KAAK,CAAC;IAEnB,SAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,MAAM,CAG7D;IACD,SAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC,GAAG,CAAC,CAK3F;IACD,SAAgB,eAAe,CAAC,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAK1E;IACM,MAAM,IAAI,EAAE,KAAK,CAAC,GAAG,CAG1B,CAAC;IAEH;;OAEG;IACH,SAAgB,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAuBjD;IAED,SAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAExD;IAED,SAAgB,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACnF,SAAgB,MAAM,CAAC,CAAC,EAAE,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IAK/F;;;OAGG;IACH,SAAgB,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,CAKzE;IAED;;OAEG;IACH,SAAgB,GAAG,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC;IACxD,SAAgB,GAAG,CAAC,GAAG,MAAM,EAAE,KAAK,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;CAK7D;AAED,KAAK,QAAQ,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,CAAC;AACxC,cAAM,YAAa,YAAW,QAAQ,CAAC,QAAQ,CAAC;IAE5C,OAAO,CAAC,UAAU,CAAyB;IAC3C,OAAO,CAAC,SAAS,CAAoB;IAErC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAEM,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,GAAE,GAAe,EAAE,MAAM,CAAC,EAAE,UAAU,EAAE,GAAG,IAAI;IAa9E,MAAM,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,GAAE,GAAe,GAAG,IAAI;IAyB1D,CAAC,MAAM,CAAC,QAAQ,CAAC,+BAQN,GAAG,EAAE;IAIhB,MAAM,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,GAAG,EAAE;IAY7B,OAAO,IAAI,OAAO;IAIlB,OAAO,IAAI,IAAI;CAIzB;AAED,MAAM,WAAW,cAAc;IAC3B,kBAAkB,CAAC,EAAE,QAAQ,CAAC;IAC9B,oBAAoB,CAAC,EAAE,QAAQ,CAAC;CACnC;AAED,qBAAa,OAAO,CAAC,CAAC,GAAG,GAAG;IAcpB,OAAO,CAAC,QAAQ,CAAC;IAZrB,OAAO,CAAC,MAAM,CAAC,uBAAuB,CAAO;IAE7C,OAAO,CAAC,MAAM,CAAC,KAAK,CAAyB;IAE7C,OAAO,CAAC,MAAM,CAAW;IACzB,SAAS,CAAC,UAAU,EAAE,YAAY,GAAG,SAAS,CAAC;IAC/C,OAAO,CAAC,SAAS,CAAS;IAE1B,OAAO,CAAC,cAAc,CAAkC;IACxD,OAAO,CAAC,kBAAkB,CAAK;gBAGnB,QAAQ,CAAC,4BAAgB;IAGrC;;;OAGG;IACH,IAAI,KAAK,IAAI,KAAK,CAAC,CAAC,CAAC,CAuCpB;IAED,SAAS,CAAC,iBAAiB,CAAC,YAAY,EAAE,MAAM,GAAG,CAAC,MAAM,IAAI,CAAC,GAAG,SAAS;IAkC3E,SAAS,CAAC,gBAAgB,IAAI,MAAM,IAAI;IAUxC,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQ9C;;;OAGG;IACH,IAAI,CAAC,KAAK,EAAE,CAAC,GAAG,GAAG;IAMnB;;;OAGG;IACG,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,GAAG,KAAK,YAAY,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAU5F,OAAO,IAAI,IAAI;CAWlB;AAED,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,CAAC;AAE9D,MAAM,WAAW,cAAc;IAC3B;;OAEG;IACH,KAAK,EAAE,iBAAiB,CAAC;IACzB;;;;;;OAMG;IACH,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC;CAC3C;AACD,yBAAiB,cAAc,CAAC;IAC5B;;;;OAIG;IACH,SAAsB,IAAI,CAAC,CAAC,SAAS,cAAc,EAC/C,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EACnB,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,OAAO,CAAC,EAAE,MAAM,EAChB,KAAK,oBAAyB,GAC/B,OAAO,CAAC,IAAI,CAAC,CA0Bf;CACJ;AAED,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,qBAAa,YAAY,CAAC,CAAC,SAAS,cAAc,CAAE,SAAQ,OAAO,CAAC,CAAC,CAAC;IAElE,SAAS,CAAC,aAAa,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC;IAEnD;;OAEG;IACM,IAAI,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,GAAE,iBAA0C,EACpF,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;cAYvE,OAAO,CAAC,SAAS,EAAE,QAAQ,EAAE,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,iBAAiB,EAC5F,WAAW,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,GAAG,CAAC,EAAE,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;CAsC1F;AAED,qBAAa,gBAAgB,CAAC,CAAC,CAAE,SAAQ,OAAO,CAAC,CAAC,EAAE,CAAC;IAEjD,YAAY,CAAC,EAAE,CAAC,EAAE,CAAC;IAEnB,KAAK,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,GAAG,IAAI;IAOf,IAAI,IAAI,IAAI;CAKxB"}

package/lib/common/event.js

@@ -0,0 +1,403 @@
+"use strict";
+// *****************************************************************************
+// Copyright (C) 2017 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
+// *****************************************************************************
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueueableEmitter = exports.AsyncEmitter = exports.WaitUntilEvent = exports.Emitter = exports.Event = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const disposable_1 = require("./disposable");
+var Event;
+(function (Event) {
+    const _disposable = { dispose() { } };
+    function getMaxListeners(event) {
+        const { maxListeners } = event;
+        return typeof maxListeners === 'number' ? maxListeners : 0;
+    }
+    Event.getMaxListeners = getMaxListeners;
+    function setMaxListeners(event, maxListeners) {
+        if (typeof event.maxListeners === 'number') {
+            return event.maxListeners = maxListeners;
+        }
+        return maxListeners;
+    }
+    Event.setMaxListeners = setMaxListeners;
+    function addMaxListeners(event, add) {
+        if (typeof event.maxListeners === 'number') {
+            return event.maxListeners += add;
+        }
+        return add;
+    }
+    Event.addMaxListeners = addMaxListeners;
+    Event.None = Object.assign(function () { return _disposable; }, {
+        get maxListeners() { return 0; },
+        set maxListeners(maxListeners) { }
+    });
+    /**
+     * Given an event, returns another event which only fires once.
+     */
+    function once(event) {
+        return (listener, thisArgs = undefined, disposables) => {
+            // we need this, in case the event fires during the listener call
+            let didFire = false;
+            let result = undefined;
+            result = event(e => {
+                if (didFire) {
+                    return;
+                }
+                else if (result) {
+                    result.dispose();
+                }
+                else {
+                    didFire = true;
+                }
+                return listener.call(thisArgs, e);
+            }, undefined, disposables);
+            if (didFire) {
+                result.dispose();
+            }
+            return result;
+        };
+    }
+    Event.once = once;
+    function toPromise(event) {
+        return new Promise(resolve => once(event)(resolve));
+    }
+    Event.toPromise = toPromise;
+    function filter(event, predicate) {
+        return (listener, thisArg, disposables) => event(e => predicate(e) && listener.call(thisArg, e), undefined, disposables);
+    }
+    Event.filter = filter;
+    /**
+     * Given an event and a `map` function, returns another event which maps each element
+     * through the mapping function.
+     */
+    function map(event, mapFunc) {
+        return Object.assign((listener, thisArgs, disposables) => event(i => listener.call(thisArgs, mapFunc(i)), undefined, disposables), {
+            get maxListeners() { return 0; },
+            set maxListeners(maxListeners) { }
+        });
+    }
+    Event.map = map;
+    function any(...events) {
+        return (listener, thisArgs = undefined, disposables) => new disposable_1.DisposableCollection(...events.map(event => event(e => listener.call(thisArgs, e), undefined, disposables)));
+    }
+    Event.any = any;
+})(Event || (exports.Event = Event = {}));
+class CallbackList {
+    get length() {
+        return this._callbacks && this._callbacks.length || 0;
+    }
+    add(callback, context = undefined, bucket) {
+        if (!this._callbacks) {
+            this._callbacks = [];
+            this._contexts = [];
+        }
+        this._callbacks.push(callback);
+        this._contexts.push(context);
+        if (Array.isArray(bucket)) {
+            bucket.push({ dispose: () => this.remove(callback, context) });
+        }
+    }
+    remove(callback, context = undefined) {
+        if (!this._callbacks) {
+            return;
+        }
+        let foundCallbackWithDifferentContext = false;
+        for (let i = 0; i < this._callbacks.length; i++) {
+            if (this._callbacks[i] === callback) {
+                if (this._contexts[i] === context) {
+                    // callback & context match => remove it
+                    this._callbacks.splice(i, 1);
+                    this._contexts.splice(i, 1);
+                    return;
+                }
+                else {
+                    foundCallbackWithDifferentContext = true;
+                }
+            }
+        }
+        if (foundCallbackWithDifferentContext) {
+            throw new Error('When adding a listener with a context, you should remove it with the same context');
+        }
+    }
+    // tslint:disable-next-line:typedef
+    [Symbol.iterator]() {
+        if (!this._callbacks) {
+            return [][Symbol.iterator]();
+        }
+        const callbacks = this._callbacks.slice(0);
+        const contexts = this._contexts.slice(0);
+        return callbacks.map((callback, i) => (...args) => callback.apply(contexts[i], args))[Symbol.iterator]();
+    }
+    invoke(...args) {
+        const ret = [];
+        for (const callback of this) {
+            try {
+                ret.push(callback(...args));
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+        return ret;
+    }
+    isEmpty() {
+        return !this._callbacks || this._callbacks.length === 0;
+    }
+    dispose() {
+        this._callbacks = undefined;
+        this._contexts = undefined;
+    }
+}
+class Emitter {
+    constructor(_options) {
+        this._options = _options;
+        this._disposed = false;
+        this._leakWarnCountdown = 0;
+    }
+    /**
+     * For the public to allow to subscribe
+     * to events from this Emitter
+     */
+    get event() {
+        if (!this._event) {
+            this._event = Object.assign((listener, thisArgs, disposables) => {
+                if (!this._callbacks) {
+                    this._callbacks = new CallbackList();
+                }
+                if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
+                    this._options.onFirstListenerAdd(this);
+                }
+                this._callbacks.add(listener, thisArgs);
+                const removeMaxListenersCheck = this.checkMaxListeners(Event.getMaxListeners(this._event));
+                const result = {
+                    dispose: () => {
+                        if (removeMaxListenersCheck) {
+                            removeMaxListenersCheck();
+                        }
+                        result.dispose = Emitter._noop;
+                        if (!this._disposed) {
+                            this._callbacks.remove(listener, thisArgs);
+                            result.dispose = Emitter._noop;
+                            if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
+                                this._options.onLastListenerRemove(this);
+                            }
+                        }
+                    }
+                };
+                if (disposable_1.DisposableGroup.canPush(disposables)) {
+                    disposables.push(result);
+                }
+                else if (disposable_1.DisposableGroup.canAdd(disposables)) {
+                    disposables.add(result);
+                }
+                return result;
+            }, {
+                maxListeners: Emitter.LEAK_WARNING_THRESHHOLD
+            });
+        }
+        return this._event;
+    }
+    checkMaxListeners(maxListeners) {
+        if (maxListeners === 0 || !this._callbacks) {
+            return undefined;
+        }
+        const listenerCount = this._callbacks.length;
+        if (listenerCount <= maxListeners) {
+            return undefined;
+        }
+        const popStack = this.pushLeakingStack();
+        this._leakWarnCountdown -= 1;
+        if (this._leakWarnCountdown <= 0) {
+            // only warn on first exceed and then every time the limit
+            // is exceeded by 50% again
+            this._leakWarnCountdown = maxListeners * 0.5;
+            let topStack;
+            let topCount = 0;
+            this._leakingStacks.forEach((stackCount, stack) => {
+                if (!topStack || topCount < stackCount) {
+                    topStack = stack;
+                    topCount = stackCount;
+                }
+            });
+            // eslint-disable-next-line max-len
+            console.warn(`Possible Emitter memory leak detected. ${listenerCount} listeners added. Use event.maxListeners to increase the limit (${maxListeners}). MOST frequent listener (${topCount}):`);
+            console.warn(topStack);
+        }
+        return popStack;
+    }
+    pushLeakingStack() {
+        if (!this._leakingStacks) {
+            this._leakingStacks = new Map();
+        }
+        const stack = new Error().stack.split('\n').slice(3).join('\n');
+        const count = (this._leakingStacks.get(stack) || 0);
+        this._leakingStacks.set(stack, count + 1);
+        return () => this.popLeakingStack(stack);
+    }
+    popLeakingStack(stack) {
+        if (!this._leakingStacks) {
+            return;
+        }
+        const count = (this._leakingStacks.get(stack) || 0);
+        this._leakingStacks.set(stack, count - 1);
+    }
+    /**
+     * To be kept private to fire an event to
+     * subscribers
+     */
+    fire(event) {
+        if (this._callbacks) {
+            return this._callbacks.invoke(event);
+        }
+    }
+    /**
+     * Process each listener one by one.
+     * Return `false` to stop iterating over the listeners, `true` to continue.
+     */
+    async sequence(processor) {
+        if (this._callbacks) {
+            for (const listener of this._callbacks) {
+                if (!await processor(listener)) {
+                    break;
+                }
+            }
+        }
+    }
+    dispose() {
+        if (this._leakingStacks) {
+            this._leakingStacks.clear();
+            this._leakingStacks = undefined;
+        }
+        if (this._callbacks) {
+            this._callbacks.dispose();
+            this._callbacks = undefined;
+        }
+        this._disposed = true;
+    }
+}
+exports.Emitter = Emitter;
+Emitter.LEAK_WARNING_THRESHHOLD = 175;
+Emitter._noop = function () { };
+var WaitUntilEvent;
+(function (WaitUntilEvent) {
+    /**
+     * Fire all listeners in the same tick.
+     *
+     * Use `AsyncEmitter.fire` to fire listeners async one after another.
+     */
+    async function fire(emitter, event, timeout, token = cancellation_1.CancellationToken.None) {
+        const waitables = [];
+        const asyncEvent = Object.assign(event, {
+            token,
+            waitUntil: (thenable) => {
+                if (Object.isFrozen(waitables)) {
+                    throw new Error('waitUntil cannot be called asynchronously.');
+                }
+                waitables.push(thenable);
+            }
+        });
+        try {
+            emitter.fire(asyncEvent);
+            // Asynchronous calls to `waitUntil` should fail.
+            Object.freeze(waitables);
+        }
+        finally {
+            delete asyncEvent['waitUntil'];
+        }
+        if (!waitables.length) {
+            return;
+        }
+        if (timeout !== undefined) {
+            await Promise.race([Promise.all(waitables), new Promise(resolve => setTimeout(resolve, timeout))]);
+        }
+        else {
+            await Promise.all(waitables);
+        }
+    }
+    WaitUntilEvent.fire = fire;
+})(WaitUntilEvent || (exports.WaitUntilEvent = WaitUntilEvent = {}));
+const cancellation_1 = require("./cancellation");
+class AsyncEmitter extends Emitter {
+    /**
+     * Fire listeners async one after another.
+     */
+    fire(event, token = cancellation_1.CancellationToken.None, promiseJoin) {
+        const callbacks = this._callbacks;
+        if (!callbacks) {
+            return Promise.resolve();
+        }
+        const listeners = [...callbacks];
+        if (this.deliveryQueue) {
+            return this.deliveryQueue = this.deliveryQueue.then(() => this.deliver(listeners, event, token, promiseJoin));
+        }
+        return this.deliveryQueue = this.deliver(listeners, event, token, promiseJoin);
+    }
+    async deliver(listeners, event, token, promiseJoin) {
+        for (const listener of listeners) {
+            if (token.isCancellationRequested) {
+                return;
+            }
+            const waitables = [];
+            const asyncEvent = Object.assign(event, {
+                token,
+                waitUntil: (thenable) => {
+                    if (Object.isFrozen(waitables)) {
+                        throw new Error('waitUntil cannot be called asynchronously.');
+                    }
+                    if (promiseJoin) {
+                        thenable = promiseJoin(thenable, listener);
+                    }
+                    waitables.push(thenable);
+                }
+            });
+            try {
+                listener(event);
+                // Asynchronous calls to `waitUntil` should fail.
+                Object.freeze(waitables);
+            }
+            catch (e) {
+                console.error(e);
+            }
+            finally {
+                delete asyncEvent['waitUntil'];
+            }
+            if (!waitables.length) {
+                continue;
+            }
+            try {
+                await Promise.all(waitables);
+            }
+            catch (e) {
+                console.error(e);
+            }
+        }
+    }
+}
+exports.AsyncEmitter = AsyncEmitter;
+class QueueableEmitter extends Emitter {
+    queue(...arg) {
+        if (!this.currentQueue) {
+            this.currentQueue = [];
+        }
+        this.currentQueue.push(...arg);
+    }
+    fire() {
+        super.fire(this.currentQueue || []);
+        this.currentQueue = undefined;
+    }
+}
+exports.QueueableEmitter = QueueableEmitter;
+//# sourceMappingURL=event.js.map