@codingame/monaco-vscode-api 2.1.4 → 2.2.0-next.1

package/vscode/src/vs/base/browser/ui/sash/sash.js

@@ -18,8 +18,16 @@ var OrthogonalEdge;
 })(OrthogonalEdge || (OrthogonalEdge = {})));
 let globalSize = 4;
 const onDidChangeGlobalSize = ( new Emitter());
+function setGlobalSashSize(size) {
+    globalSize = size;
+    onDidChangeGlobalSize.fire(size);
+}
 let globalHoverDelay = 300;
 const onDidChangeHoverDelay = ( new Emitter());
+function setGlobalHoverDelay(size) {
+    globalHoverDelay = size;
+    onDidChangeHoverDelay.fire(size);
+}
 class MouseEventFactory {
     constructor(el) {
         this.el = el;
@@ -370,4 +378,4 @@ class Sash extends Disposable {
         this.el.remove();
     }
 }
-export { OrthogonalEdge, Sash };
+export { OrthogonalEdge, Sash, setGlobalHoverDelay, setGlobalSashSize };

package/vscode/src/vs/base/browser/ui/splitview/splitview.d.ts

@@ -1,5 +1,12 @@
+import { Orientation, Sash } from '../sash/sash.js';
+import { Color } from '../../../common/color.js';
 import { Event } from '../../../common/event.js';
+import { Disposable, IDisposable } from '../../../common/lifecycle.js';
+import { ScrollEvent, ScrollbarVisibility } from '../../../common/scrollable.js';
 
+interface ISplitViewStyles {
+    readonly separatorBorder: Color;
+}
 declare const enum LayoutPriority {
     Normal = 0,
     Low = 1,
@@ -80,5 +87,345 @@ interface IView<TLayoutContext = undefined> {
      */
     setVisible?(visible: boolean): void;
 }
+/**
+ * A descriptor for a {@link SplitView} instance.
+ */
+interface ISplitViewDescriptor<TLayoutContext = undefined, TView extends IView<TLayoutContext> = IView<TLayoutContext>> {
+    /**
+     * The layout size of the {@link SplitView}.
+     */
+    readonly size: number;
+    /**
+     * Descriptors for each {@link IView view}.
+     */
+    readonly views: {
+        /**
+         * Whether the {@link IView view} is visible.
+         *
+         * @defaultValue `true`
+         */
+        readonly visible?: boolean;
+        /**
+         * The size of the {@link IView view}.
+         *
+         * @defaultValue `true`
+         */
+        readonly size: number;
+        /**
+         * The size of the {@link IView view}.
+         *
+         * @defaultValue `true`
+         */
+        readonly view: TView;
+    }[];
+}
+interface ISplitViewOptions<TLayoutContext = undefined, TView extends IView<TLayoutContext> = IView<TLayoutContext>> {
+    /**
+     * Which axis the views align on.
+     *
+     * @defaultValue `Orientation.VERTICAL`
+     */
+    readonly orientation?: Orientation;
+    /**
+     * Styles overriding the {@link defaultStyles default ones}.
+     */
+    readonly styles?: ISplitViewStyles;
+    /**
+     * Make Alt-drag the default drag operation.
+     */
+    readonly inverseAltBehavior?: boolean;
+    /**
+     * Resize each view proportionally when resizing the SplitView.
+     *
+     * @defaultValue `true`
+     */
+    readonly proportionalLayout?: boolean;
+    /**
+     * An initial description of this {@link SplitView} instance, allowing
+     * to initialze all views within the ctor.
+     */
+    readonly descriptor?: ISplitViewDescriptor<TLayoutContext, TView>;
+    /**
+     * The scrollbar visibility setting for whenever the views within
+     * the {@link SplitView} overflow.
+     */
+    readonly scrollbarVisibility?: ScrollbarVisibility;
+    /**
+     * Override the orthogonal size of sashes.
+     */
+    readonly getSashOrthogonalSize?: () => number;
+}
+interface ISashItem {
+    sash: Sash;
+    disposable: IDisposable;
+}
+/**
+ * When adding or removing views, uniformly distribute the entire split view space among
+ * all views.
+ */
+type DistributeSizing = {
+    type: 'distribute';
+};
+/**
+ * When adding a view, make space for it by reducing the size of another view,
+ * indexed by the provided `index`.
+ */
+type SplitSizing = {
+    type: 'split';
+    index: number;
+};
+/**
+ * When adding a view, use DistributeSizing when all pre-existing views are
+ * distributed evenly, otherwise use SplitSizing.
+ */
+type AutoSizing = {
+    type: 'auto';
+    index: number;
+};
+/**
+ * When adding or removing views, assume the view is invisible.
+ */
+type InvisibleSizing = {
+    type: 'invisible';
+    cachedVisibleSize: number;
+};
+/**
+ * When adding or removing views, the sizing provides fine grained
+ * control over how other views get resized.
+ */
+type Sizing = DistributeSizing | SplitSizing | AutoSizing | InvisibleSizing;
+declare namespace Sizing {
+    /**
+     * When adding or removing views, distribute the delta space among
+     * all other views.
+     */
+    const Distribute: DistributeSizing;
+    /**
+     * When adding or removing views, split the delta space with another
+     * specific view, indexed by the provided `index`.
+     */
+    function Split(index: number): SplitSizing;
+    /**
+     * When adding a view, use DistributeSizing when all pre-existing views are
+     * distributed evenly, otherwise use SplitSizing.
+     */
+    function Auto(index: number): AutoSizing;
+    /**
+     * When adding or removing views, assume the view is invisible.
+     */
+    function Invisible(cachedVisibleSize: number): InvisibleSizing;
+}
+/**
+ * The {@link SplitView} is the UI component which implements a one dimensional
+ * flex-like layout algorithm for a collection of {@link IView} instances, which
+ * are essentially HTMLElement instances with the following size constraints:
+ *
+ * - {@link IView.minimumSize}
+ * - {@link IView.maximumSize}
+ * - {@link IView.priority}
+ * - {@link IView.snap}
+ *
+ * In case the SplitView doesn't have enough size to fit all views, it will overflow
+ * its content with a scrollbar.
+ *
+ * In between each pair of views there will be a {@link Sash} allowing the user
+ * to resize the views, making sure the constraints are respected.
+ *
+ * An optional {@link TLayoutContext layout context type} may be used in order to
+ * pass along layout contextual data from the {@link SplitView.layout} method down
+ * to each view's {@link IView.layout} calls.
+ *
+ * Features:
+ * - Flex-like layout algorithm
+ * - Snap support
+ * - Orthogonal sash support, for corner sashes
+ * - View hide/show support
+ * - View swap/move support
+ * - Alt key modifier behavior, macOS style
+ */
+declare class SplitView<TLayoutContext = undefined, TView extends IView<TLayoutContext> = IView<TLayoutContext>> extends Disposable {
+    /**
+     * This {@link SplitView}'s orientation.
+     */
+    readonly orientation: Orientation;
+    /**
+     * The DOM element representing this {@link SplitView}.
+     */
+    readonly el: HTMLElement;
+    private sashContainer;
+    private viewContainer;
+    private scrollable;
+    private scrollableElement;
+    private size;
+    private layoutContext;
+    private _contentSize;
+    private proportions;
+    private viewItems;
+    sashItems: ISashItem[];
+    private sashDragState;
+    private state;
+    private inverseAltBehavior;
+    private proportionalLayout;
+    private readonly getSashOrthogonalSize;
+    private _onDidSashChange;
+    private _onDidSashReset;
+    private _orthogonalStartSash;
+    private _orthogonalEndSash;
+    private _startSnappingEnabled;
+    private _endSnappingEnabled;
+    /**
+     * The sum of all views' sizes.
+     */
+    get contentSize(): number;
+    /**
+     * Fires whenever the user resizes a {@link Sash sash}.
+     */
+    readonly onDidSashChange: Event<number>;
+    /**
+     * Fires whenever the user double clicks a {@link Sash sash}.
+     */
+    readonly onDidSashReset: Event<number>;
+    /**
+     * Fires whenever the split view is scrolled.
+     */
+    readonly onDidScroll: Event<ScrollEvent>;
+    /**
+     * The amount of views in this {@link SplitView}.
+     */
+    get length(): number;
+    /**
+     * The minimum size of this {@link SplitView}.
+     */
+    get minimumSize(): number;
+    /**
+     * The maximum size of this {@link SplitView}.
+     */
+    get maximumSize(): number;
+    get orthogonalStartSash(): Sash | undefined;
+    get orthogonalEndSash(): Sash | undefined;
+    get startSnappingEnabled(): boolean;
+    get endSnappingEnabled(): boolean;
+    /**
+     * A reference to a sash, perpendicular to all sashes in this {@link SplitView},
+     * located at the left- or top-most side of the SplitView.
+     * Corner sashes will be created automatically at the intersections.
+     */
+    set orthogonalStartSash(sash: Sash | undefined);
+    /**
+     * A reference to a sash, perpendicular to all sashes in this {@link SplitView},
+     * located at the right- or bottom-most side of the SplitView.
+     * Corner sashes will be created automatically at the intersections.
+     */
+    set orthogonalEndSash(sash: Sash | undefined);
+    /**
+     * The internal sashes within this {@link SplitView}.
+     */
+    get sashes(): readonly Sash[];
+    /**
+     * Enable/disable snapping at the beginning of this {@link SplitView}.
+     */
+    set startSnappingEnabled(startSnappingEnabled: boolean);
+    /**
+     * Enable/disable snapping at the end of this {@link SplitView}.
+     */
+    set endSnappingEnabled(endSnappingEnabled: boolean);
+    /**
+     * Create a new {@link SplitView} instance.
+     */
+    constructor(container: HTMLElement, options?: ISplitViewOptions<TLayoutContext, TView>);
+    style(styles: ISplitViewStyles): void;
+    /**
+     * Add a {@link IView view} to this {@link SplitView}.
+     *
+     * @param view The view to add.
+     * @param size Either a fixed size, or a dynamic {@link Sizing} strategy.
+     * @param index The index to insert the view on.
+     * @param skipLayout Whether layout should be skipped.
+     */
+    addView(view: TView, size: number | Sizing, index?: number, skipLayout?: boolean): void;
+    /**
+     * Remove a {@link IView view} from this {@link SplitView}.
+     *
+     * @param index The index where the {@link IView view} is located.
+     * @param sizing Whether to distribute other {@link IView view}'s sizes.
+     */
+    removeView(index: number, sizing?: Sizing): TView;
+    removeAllViews(): TView[];
+    /**
+     * Move a {@link IView view} to a different index.
+     *
+     * @param from The source index.
+     * @param to The target index.
+     */
+    moveView(from: number, to: number): void;
+    /**
+     * Swap two {@link IView views}.
+     *
+     * @param from The source index.
+     * @param to The target index.
+     */
+    swapViews(from: number, to: number): void;
+    /**
+     * Returns whether the {@link IView view} is visible.
+     *
+     * @param index The {@link IView view} index.
+     */
+    isViewVisible(index: number): boolean;
+    /**
+     * Set a {@link IView view}'s visibility.
+     *
+     * @param index The {@link IView view} index.
+     * @param visible Whether the {@link IView view} should be visible.
+     */
+    setViewVisible(index: number, visible: boolean): void;
+    /**
+     * Returns the {@link IView view}'s size previously to being hidden.
+     *
+     * @param index The {@link IView view} index.
+     */
+    getViewCachedVisibleSize(index: number): number | undefined;
+    /**
+     * Layout the {@link SplitView}.
+     *
+     * @param size The entire size of the {@link SplitView}.
+     * @param layoutContext An optional layout context to pass along to {@link IView views}.
+     */
+    layout(size: number, layoutContext?: TLayoutContext): void;
+    private saveProportions;
+    private onSashStart;
+    private onSashChange;
+    private onSashEnd;
+    private onViewChange;
+    /**
+     * Resize a {@link IView view} within the {@link SplitView}.
+     *
+     * @param index The {@link IView view} index.
+     * @param size The {@link IView view} size.
+     */
+    resizeView(index: number, size: number): void;
+    /**
+     * Returns whether all other {@link IView views} are at their minimum size.
+     */
+    isViewExpanded(index: number): boolean;
+    /**
+     * Distribute the entire {@link SplitView} size among all {@link IView views}.
+     */
+    distributeViewSizes(): void;
+    /**
+     * Returns the size of a {@link IView view}.
+     */
+    getViewSize(index: number): number;
+    private doAddView;
+    private relayout;
+    private resize;
+    private distributeEmptySpace;
+    private layoutViews;
+    private updateScrollableElement;
+    private updateSashEnablement;
+    private getSashPosition;
+    private findFirstSnapIndex;
+    private areViewsDistributed;
+    dispose(): void;
+}
 
-export { type IView, LayoutPriority };
+export { type AutoSizing, type DistributeSizing, type ISplitViewDescriptor, type ISplitViewOptions, type ISplitViewStyles, type IView, type InvisibleSizing, LayoutPriority, Orientation, Sizing, type SplitSizing, SplitView };

package/vscode/src/vs/base/common/async.js

@@ -1,10 +1,11 @@
 import { CancellationTokenSource } from './cancellation.js';
-import { CancellationError } from './errors.js';
+import { CancellationError, BugIndicatingError } from './errors.js';
 import { Emitter, Event } from './event.js';
 import { toDisposable, DisposableMap } from './lifecycle.js';
 import { extUri } from './resources.js';
 import { setTimeout0 } from './platform.js';
 import { MicrotaskDelay } from './symbols.js';
+import { Lazy } from './lazy.js';
 function isThenable(obj) {
     return !!obj && typeof obj.then === 'function';
 }
@@ -865,6 +866,49 @@ var Promises;
     }
     Promises.withAsyncBody = withAsyncBody;
 })(Promises || (Promises = {})));
+class StatefulPromise {
+    get value() { return this._value; }
+    get error() { return this._error; }
+    get isResolved() { return this._isResolved; }
+    constructor(promise) {
+        this._value = undefined;
+        this._error = undefined;
+        this._isResolved = false;
+        this.promise = promise.then(value => {
+            this._value = value;
+            this._isResolved = true;
+            return value;
+        }, error => {
+            this._error = error;
+            this._isResolved = true;
+            throw error;
+        });
+    }
+    requireValue() {
+        if (!this._isResolved) {
+            throw new BugIndicatingError('Promise is not resolved yet');
+        }
+        if (this._error) {
+            throw this._error;
+        }
+        return this._value;
+    }
+}
+class LazyStatefulPromise {
+    constructor(_compute) {
+        this._compute = _compute;
+        this._promise = ( new Lazy(() => ( new StatefulPromise(this._compute()))));
+    }
+    requireValue() {
+        return this._promise.value.requireValue();
+    }
+    getPromise() {
+        return this._promise.value.promise;
+    }
+    get currentValue() {
+        return this._promise.rawValue?.value;
+    }
+}
 class AsyncIterableObject {
     static fromArray(items) {
         return ( new AsyncIterableObject((writer) => {
@@ -1081,4 +1125,4 @@ class AsyncIterableSource {
         this._emitFn(item);
     }
 }
-export { AbstractIdleValue, AsyncIterableObject, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableObject, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterable, createCancelablePromise, disposableTimeout, first, isThenable, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, retry, runWhenGlobalIdle, sequence, timeout };
+export { AbstractIdleValue, AsyncIterableObject, AsyncIterableSource, AutoOpenBarrier, Barrier, CancelableAsyncIterableObject, DeferredPromise, Delayer, GlobalIdleValue, IntervalCounter, IntervalTimer, LazyStatefulPromise, Limiter, Promises, Queue, ResourceQueue, RunOnceScheduler, RunOnceWorker, Sequencer, SequencerByKey, StatefulPromise, TaskSequentializer, ThrottledDelayer, Throttler, TimeoutTimer, _runWhenIdle, asPromise, createCancelableAsyncIterable, createCancelablePromise, disposableTimeout, first, isThenable, raceCancellablePromises, raceCancellation, raceCancellationError, raceTimeout, retry, runWhenGlobalIdle, sequence, timeout };