custom-electron-titlebar 4.2.0-alpha.2 → 4.2.0

package/dist/vs/base/common/event.d.ts

@@ -1,274 +0,0 @@
-import { CancellationToken } from 'vs/base/common/cancellation';
-import { DisposableStore, IDisposable, SafeDisposable } from 'vs/base/common/lifecycle';
-import { LinkedList } from 'vs/base/common/linkedList';
-/**
- * To an event a function with one or zero parameters
- * can be subscribed. The event is the subscriber function itself.
- */
-export interface Event<T> {
-    (listener: (e: T) => any, thisArgs?: any, disposables?: IDisposable[] | DisposableStore): IDisposable;
-}
-export 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;
-}
-export interface EmitterOptions {
-    onFirstListenerAdd?: Function;
-    onFirstListenerDidAdd?: Function;
-    onListenerDidAdd?: Function;
-    onLastListenerRemove?: Function;
-    leakWarningThreshold?: number;
-    /** ONLY enable this during development */
-    _profName?: string;
-}
-export declare function setGlobalLeakWarningThreshold(n: number): IDisposable;
-declare class Stacktrace {
-    readonly value: string;
-    static create(): Stacktrace;
-    private constructor();
-    print(): void;
-}
-declare class Listener<T> {
-    readonly callback: (e: T) => void;
-    readonly callbackThis: any | undefined;
-    readonly stack: Stacktrace | undefined;
-    readonly subscription: SafeDisposable;
-    constructor(callback: (e: T) => void, callbackThis: any | undefined, stack: Stacktrace | undefined);
-    invoke(e: T): void;
-}
-/**
- * The Emitter can be used to expose an Event to the public
- * to fire it from the insides.
- * Sample:
-    class Document {
-
-        private readonly _onDidChange = new Emitter<(value:string)=>any>();
-
-        public onDidChange = this._onDidChange.event;
-
-        // getter-style
-        // get onDidChange(): Event<(value:string)=>any> {
-        // 	return this._onDidChange.event;
-        // }
-
-        private _doIt() {
-            //...
-            this._onDidChange.fire(value);
-        }
-    }
- */
-export declare class Emitter<T> {
-    private readonly _options?;
-    private readonly _leakageMon?;
-    private _disposed;
-    private _event?;
-    private _deliveryQueue?;
-    protected _listeners?: LinkedList<Listener<T>>;
-    constructor(options?: EmitterOptions);
-    dispose(): void;
-    /**
-     * For the public to allow to subscribe
-     * to events from this Emitter
-     */
-    get event(): Event<T>;
-    /**
-     * To be kept private to fire an event to
-     * subscribers
-     */
-    fire(event: T): void;
-    hasListeners(): boolean;
-}
-export interface IWaitUntil {
-    token: CancellationToken;
-    waitUntil(thenable: Promise<unknown>): void;
-}
-export declare type IWaitUntilData<T> = Omit<Omit<T, 'waitUntil'>, 'token'>;
-export declare class AsyncEmitter<T extends IWaitUntil> extends Emitter<T> {
-    private _asyncDeliveryQueue?;
-    fireAsync(data: IWaitUntilData<T>, token: CancellationToken, promiseJoin?: (p: Promise<unknown>, listener: Function) => Promise<unknown>): Promise<void>;
-}
-export declare class PauseableEmitter<T> extends Emitter<T> {
-    private _isPaused;
-    protected _eventQueue: LinkedList<T>;
-    private _mergeFn?;
-    constructor(options?: EmitterOptions & {
-        merge?: (input: T[]) => T;
-    });
-    pause(): void;
-    resume(): void;
-    fire(event: T): void;
-}
-export declare class DebounceEmitter<T> extends PauseableEmitter<T> {
-    private readonly _delay;
-    private _handle;
-    constructor(options: EmitterOptions & {
-        merge: (input: T[]) => T;
-        delay?: number;
-    });
-    fire(event: T): void;
-}
-/**
- * An emitter which queue all events and then process them at the
- * end of the event loop.
- */
-export declare class MicrotaskEmitter<T> extends Emitter<T> {
-    private _queuedEvents;
-    private _mergeFn?;
-    constructor(options?: EmitterOptions & {
-        merge?: (input: T[]) => T;
-    });
-    fire(event: T): void;
-}
-export declare class EventMultiplexer<T> implements IDisposable {
-    private readonly emitter;
-    private hasListeners;
-    private events;
-    constructor();
-    get event(): Event<T>;
-    add(event: Event<T>): IDisposable;
-    private onFirstListenerAdd;
-    private onLastListenerRemove;
-    private hook;
-    private unhook;
-    dispose(): void;
-}
-/**
- * The EventBufferer is useful in situations in which you want
- * to delay firing your events during some code.
- * You can wrap that code and be sure that the event will not
- * be fired during that wrap.
- *
- * ```
- * const emitter: Emitter;
- * const delayer = new EventDelayer();
- * const delayedEvent = delayer.wrapEvent(emitter.event);
- *
- * delayedEvent(console.log);
- *
- * delayer.bufferEvents(() => {
- *   emitter.fire(); // event will not be fired yet
- * });
- *
- * // event will only be fired at this point
- * ```
- */
-export declare class EventBufferer {
-    private buffers;
-    wrapEvent<T>(event: Event<T>): Event<T>;
-    bufferEvents<R = void>(fn: () => R): R;
-}
-/**
- * A Relay is an event forwarder which functions as a replugabble event pipe.
- * Once created, you can connect an input event to it and it will simply forward
- * events from that input event through its own `event` property. The `input`
- * can be changed at any point in time.
- */
-export declare class Relay<T> implements IDisposable {
-    private listening;
-    private inputEvent;
-    private inputEventListener;
-    private readonly emitter;
-    readonly event: Event<T>;
-    set input(event: Event<T>);
-    dispose(): void;
-}
-export {};

package/dist/vs/base/common/functional.d.ts

@@ -1 +0,0 @@
-export declare function once<T extends Function>(this: unknown, fn: T): T;

package/dist/vs/base/common/iterator.d.ts

@@ -1,31 +0,0 @@
-export declare namespace Iterable {
-    function is<T = any>(thing: any): thing is IterableIterator<T>;
-    function empty<T = any>(): Iterable<T>;
-    function single<T>(element: T): Iterable<T>;
-    function from<T>(iterable: Iterable<T> | undefined | null): Iterable<T>;
-    function isEmpty<T>(iterable: Iterable<T> | undefined | null): boolean;
-    function first<T>(iterable: Iterable<T>): T | undefined;
-    function some<T>(iterable: Iterable<T>, predicate: (t: T) => unknown): boolean;
-    function find<T, R extends T>(iterable: Iterable<T>, predicate: (t: T) => t is R): T | undefined;
-    function find<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): T | undefined;
-    function filter<T, R extends T>(iterable: Iterable<T>, predicate: (t: T) => t is R): Iterable<R>;
-    function filter<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): Iterable<T>;
-    function map<T, R>(iterable: Iterable<T>, fn: (t: T, index: number) => R): Iterable<R>;
-    function concat<T>(...iterables: Iterable<T>[]): Iterable<T>;
-    function concatNested<T>(iterables: Iterable<Iterable<T>>): Iterable<T>;
-    function reduce<T, R>(iterable: Iterable<T>, reducer: (previousValue: R, currentValue: T) => R, initialValue: R): R;
-    /**
-     * Returns an iterable slice of the array, with the same semantics as `array.slice()`.
-     */
-    function slice<T>(arr: ReadonlyArray<T>, from: number, to?: number): Iterable<T>;
-    /**
-     * Consumes `atMost` elements from iterable and returns the consumed elements,
-     * and an iterable for the rest of the elements.
-     */
-    function consume<T>(iterable: Iterable<T>, atMost?: number): [T[], Iterable<T>];
-    /**
-     * Returns whether the iterables are the same length and all items are
-     * equal using the comparator function.
-     */
-    function equals<T>(a: Iterable<T>, b: Iterable<T>, comparator?: (at: T, bt: T) => boolean): boolean;
-}