@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/services.js

@@ -48,6 +48,9 @@ export { IDebugService } from './vscode/vs/workbench/contrib/debug/common/debug.
 export { ILogService, ILoggerService, LogLevel } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 export { IViewsService } from './vscode/vs/workbench/common/views.js';
 export { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+export { IPreferencesService } from './vscode/vs/workbench/services/preferences/common/preferences.js';
+export { IPreferencesSearchService } from './vscode/vs/workbench/contrib/preferences/common/preferences.js';
+export { IKeybindingEditingService } from './vscode/vs/workbench/services/keybinding/common/keybindingEditing.js';
 const serviceInitializeParticipants = [];
 function registerServiceInitializeParticipant(participant) {
     serviceInitializeParticipants.push(participant);

package/dist/severity.d.ts

@@ -0,0 +1,16 @@
+declare enum Severity {
+    Ignore = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3
+}
+declare namespace Severity {
+    /**
+     * Parses 'error', 'warning', 'warn', 'info' in call casings
+     * and falls back to ignore.
+     */
+    function fromValue(value: string): Severity;
+    function toString(severity: Severity): string;
+}
+
+export { Severity as S };

package/dist/uri.d.ts

@@ -107,13 +107,14 @@ declare class URI implements UriComponents {
      * @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;
+    /**
+     * Creates new URI from uri components.
+     *
+     * Unless `strict` is `true` the scheme is defaults to be `file`. This function performs
+     * validation and should be used for untrusted uri components retrieved from storage,
+     * user input, command arguments etc
+     */
+    static from(components: UriComponents, strict?: boolean): URI;
     /**
      * Join a URI path with path fragments and normalizes the resulting path.
      *
@@ -135,6 +136,16 @@ declare class URI implements UriComponents {
      */
     toString(skipEncoding?: boolean): string;
     toJSON(): UriComponents;
+    /**
+     * A helper function to revive URIs.
+     *
+     * **Note** that this function should only be used when receiving URI#toJSON generated data
+     * and that it doesn't do any validation. Use {@link URI.from} when received "untrusted"
+     * uri components such as command arguments or data from storage.
+     *
+     * @param data The URI components or URI to revive.
+     * @returns The revived URI or undefined or null.
+     */
     static revive(data: UriComponents | URI): URI;
     static revive(data: UriComponents | URI | undefined): URI | undefined;
     static revive(data: UriComponents | URI | null): URI | null;
@@ -142,10 +153,10 @@ declare class URI implements UriComponents {
 }
 interface UriComponents {
     scheme: string;
-    authority: string;
-    path: string;
-    query: string;
-    fragment: string;
+    authority?: string;
+    path?: string;
+    query?: string;
+    fragment?: string;
 }
 
 export { URI as U, UriComponents as a };

package/dist/views.d.ts

@@ -0,0 +1,270 @@
+import { S as ServiceIdentifier, b as SyncDescriptor } from './instantiation.js';
+import { U as URI } from './uri.js';
+import { E as Event } from './event.js';
+import { T as ThemeIcon } from './themables.js';
+import { C as ContextKeyExpression } from './contextkey.js';
+import { I as ILocalizedString, E as ExtensionIdentifier } from './extensions.d2.ts';
+import { I as IComposite, a as IProgressIndicator } from './composite.js';
+
+interface IKeybindings {
+    primary?: number;
+    secondary?: number[];
+    win?: {
+        primary: number;
+        secondary?: number[];
+    };
+    linux?: {
+        primary: number;
+        secondary?: number[];
+    };
+    mac?: {
+        primary: number;
+        secondary?: number[];
+    };
+}
+
+interface IPaneComposite extends IComposite {
+    /**
+     * Returns the minimal width needed to avoid any content horizontal truncation
+     */
+    getOptimalWidth(): number | undefined;
+    openView<T extends IView>(id: string, focus?: boolean): T | undefined;
+    getViewPaneContainer(): IViewPaneContainer | undefined;
+}
+
+declare const enum ViewContainerLocation {
+    Sidebar = 0,
+    Panel = 1,
+    AuxiliaryBar = 2
+}
+type OpenCommandActionDescriptor = {
+    readonly id: string;
+    readonly title?: ILocalizedString | string;
+    readonly mnemonicTitle?: string;
+    readonly order?: number;
+    readonly keybindings?: IKeybindings & {
+        when?: ContextKeyExpression;
+    };
+};
+/**
+ * View Container Contexts
+ */
+interface IViewContainerDescriptor {
+    /**
+     * The id of the view container
+     */
+    readonly id: string;
+    /**
+     * The title of the view container
+     */
+    readonly title: ILocalizedString | string;
+    /**
+     * Icon representation of the View container
+     */
+    readonly icon?: ThemeIcon | URI;
+    /**
+     * Order of the view container.
+     */
+    readonly order?: number;
+    /**
+     * IViewPaneContainer Ctor to instantiate
+     */
+    readonly ctorDescriptor: SyncDescriptor<IViewPaneContainer>;
+    /**
+     * Descriptor for open view container command
+     * If not provided, view container info (id, title) is used.
+     *
+     * Note: To prevent registering open command, use `doNotRegisterOpenCommand` flag while registering the view container
+     */
+    readonly openCommandActionDescriptor?: OpenCommandActionDescriptor;
+    /**
+     * Storage id to use to store the view container state.
+     * If not provided, it will be derived.
+     */
+    readonly storageId?: string;
+    /**
+     * If enabled, view container is not shown if it has no active views.
+     */
+    readonly hideIfEmpty?: boolean;
+    /**
+     * Id of the extension that contributed the view container
+     */
+    readonly extensionId?: ExtensionIdentifier;
+    readonly alwaysUseContainerInfo?: boolean;
+    readonly viewOrderDelegate?: ViewOrderDelegate;
+    readonly rejectAddedViews?: boolean;
+    requestedIndex?: number;
+}
+interface ViewOrderDelegate {
+    getOrder(group?: string): number | undefined;
+}
+interface ViewContainer extends IViewContainerDescriptor {
+}
+interface IViewDescriptor {
+    readonly type?: string;
+    readonly id: string;
+    readonly name: string;
+    readonly ctorDescriptor: SyncDescriptor<IView>;
+    readonly when?: ContextKeyExpression;
+    readonly order?: number;
+    readonly weight?: number;
+    readonly collapsed?: boolean;
+    readonly canToggleVisibility?: boolean;
+    readonly canMoveView?: boolean;
+    readonly containerIcon?: ThemeIcon | URI;
+    readonly containerTitle?: string;
+    readonly hideByDefault?: boolean;
+    readonly workspace?: boolean;
+    readonly focusCommand?: {
+        id: string;
+        keybindings?: IKeybindings;
+    };
+    readonly group?: string;
+    readonly remoteAuthority?: string | string[];
+    readonly virtualWorkspace?: string;
+    readonly openCommandActionDescriptor?: OpenCommandActionDescriptor;
+}
+interface IViewDescriptorRef {
+    viewDescriptor: IViewDescriptor;
+    index: number;
+}
+interface IAddedViewDescriptorRef extends IViewDescriptorRef {
+    collapsed: boolean;
+    size?: number;
+}
+interface IViewContainerModel {
+    readonly viewContainer: ViewContainer;
+    readonly title: string;
+    readonly icon: ThemeIcon | URI | undefined;
+    readonly keybindingId: string | undefined;
+    readonly onDidChangeContainerInfo: Event<{
+        title?: boolean;
+        icon?: boolean;
+        keybindingId?: boolean;
+        badgeEnablement?: boolean;
+    }>;
+    readonly allViewDescriptors: ReadonlyArray<IViewDescriptor>;
+    readonly onDidChangeAllViewDescriptors: Event<{
+        added: ReadonlyArray<IViewDescriptor>;
+        removed: ReadonlyArray<IViewDescriptor>;
+    }>;
+    readonly activeViewDescriptors: ReadonlyArray<IViewDescriptor>;
+    readonly onDidChangeActiveViewDescriptors: Event<{
+        added: ReadonlyArray<IViewDescriptor>;
+        removed: ReadonlyArray<IViewDescriptor>;
+    }>;
+    readonly visibleViewDescriptors: ReadonlyArray<IViewDescriptor>;
+    readonly onDidAddVisibleViewDescriptors: Event<IAddedViewDescriptorRef[]>;
+    readonly onDidRemoveVisibleViewDescriptors: Event<IViewDescriptorRef[]>;
+    readonly onDidMoveVisibleViewDescriptors: Event<{
+        from: IViewDescriptorRef;
+        to: IViewDescriptorRef;
+    }>;
+    isVisible(id: string): boolean;
+    setVisible(id: string, visible: boolean): void;
+    isCollapsed(id: string): boolean;
+    setCollapsed(id: string, collapsed: boolean): void;
+    getSize(id: string): number | undefined;
+    setSizes(newSizes: readonly {
+        id: string;
+        size: number;
+    }[]): void;
+    move(from: string, to: string): void;
+}
+interface IView {
+    readonly id: string;
+    focus(): void;
+    isVisible(): boolean;
+    isBodyVisible(): boolean;
+    setExpanded(expanded: boolean): boolean;
+    getProgressIndicator(): IProgressIndicator | undefined;
+}
+declare const IViewsService: ServiceIdentifier<IViewsService>;
+interface IViewsService {
+    readonly _serviceBrand: undefined;
+    readonly onDidChangeViewContainerVisibility: Event<{
+        id: string;
+        visible: boolean;
+        location: ViewContainerLocation;
+    }>;
+    isViewContainerVisible(id: string): boolean;
+    openViewContainer(id: string, focus?: boolean): Promise<IPaneComposite | null>;
+    closeViewContainer(id: string): void;
+    getVisibleViewContainer(location: ViewContainerLocation): ViewContainer | null;
+    getActiveViewPaneContainerWithId(viewContainerId: string): IViewPaneContainer | null;
+    readonly onDidChangeViewVisibility: Event<{
+        id: string;
+        visible: boolean;
+    }>;
+    isViewVisible(id: string): boolean;
+    openView<T extends IView>(id: string, focus?: boolean): Promise<T | null>;
+    closeView(id: string): void;
+    getActiveViewWithId<T extends IView>(id: string): T | null;
+    getViewWithId<T extends IView>(id: string): T | null;
+    getViewProgressIndicator(id: string): IProgressIndicator | undefined;
+}
+declare enum ViewVisibilityState {
+    Default = 0,
+    Expand = 1
+}
+declare const IViewDescriptorService: ServiceIdentifier<IViewDescriptorService>;
+interface IViewDescriptorService {
+    readonly _serviceBrand: undefined;
+    readonly viewContainers: ReadonlyArray<ViewContainer>;
+    readonly onDidChangeViewContainers: Event<{
+        added: ReadonlyArray<{
+            container: ViewContainer;
+            location: ViewContainerLocation;
+        }>;
+        removed: ReadonlyArray<{
+            container: ViewContainer;
+            location: ViewContainerLocation;
+        }>;
+    }>;
+    getDefaultViewContainer(location: ViewContainerLocation): ViewContainer | undefined;
+    getViewContainerById(id: string): ViewContainer | null;
+    isViewContainerRemovedPermanently(id: string): boolean;
+    getDefaultViewContainerLocation(viewContainer: ViewContainer): ViewContainerLocation | null;
+    getViewContainerLocation(viewContainer: ViewContainer): ViewContainerLocation | null;
+    getViewContainersByLocation(location: ViewContainerLocation): ViewContainer[];
+    getViewContainerModel(viewContainer: ViewContainer): IViewContainerModel;
+    readonly onDidChangeContainerLocation: Event<{
+        viewContainer: ViewContainer;
+        from: ViewContainerLocation;
+        to: ViewContainerLocation;
+    }>;
+    moveViewContainerToLocation(viewContainer: ViewContainer, location: ViewContainerLocation, requestedIndex?: number): void;
+    getViewContainerBadgeEnablementState(id: string): boolean;
+    setViewContainerBadgeEnablementState(id: string, badgesEnabled: boolean): void;
+    getViewDescriptorById(id: string): IViewDescriptor | null;
+    getViewContainerByViewId(id: string): ViewContainer | null;
+    getDefaultContainerById(id: string): ViewContainer | null;
+    getViewLocationById(id: string): ViewContainerLocation | null;
+    readonly onDidChangeContainer: Event<{
+        views: IViewDescriptor[];
+        from: ViewContainer;
+        to: ViewContainer;
+    }>;
+    moveViewsToContainer(views: IViewDescriptor[], viewContainer: ViewContainer, visibilityState?: ViewVisibilityState): void;
+    readonly onDidChangeLocation: Event<{
+        views: IViewDescriptor[];
+        from: ViewContainerLocation;
+        to: ViewContainerLocation;
+    }>;
+    moveViewToLocation(view: IViewDescriptor, location: ViewContainerLocation): void;
+    reset(): void;
+}
+interface IViewPaneContainer {
+    onDidAddViews: Event<IView[]>;
+    onDidRemoveViews: Event<IView[]>;
+    onDidChangeViewVisibility: Event<IView>;
+    readonly views: IView[];
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    focus(): void;
+    getActionsContext(): unknown;
+    getView(viewId: string): IView | undefined;
+    toggleViewVisibility(viewId: string): void;
+}
+
+export { IView as I, ViewContainerLocation as V, IViewDescriptorService as a, IViewPaneContainer as b, ViewContainer as c, IViewContainerModel as d, IViewDescriptor as e, IAddedViewDescriptorRef as f, IPaneComposite as g, IViewsService as h };

package/dist/vscode/vs/base/browser/ui/centered/centeredViewLayout.js

@@ -0,0 +1,178 @@
+import { $ } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { SplitView } from 'monaco-editor/esm/vs/base/browser/ui/splitview/splitview.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+const defaultState = {
+    targetWidth: 900,
+    leftMarginRatio: 0.1909,
+    rightMarginRatio: 0.1909,
+};
+const distributeSizing = { type: 'distribute' };
+function createEmptyView(background) {
+    const element = $('.centered-layout-margin');
+    element.style.height = '100%';
+    if (background) {
+        element.style.backgroundColor = ( background.toString());
+    }
+    return {
+        element,
+        layout: () => undefined,
+        minimumSize: 60,
+        maximumSize: Number.POSITIVE_INFINITY,
+        onDidChange: Event.None
+    };
+}
+function toSplitViewView(view, getHeight) {
+    return {
+        element: view.element,
+        get maximumSize() { return view.maximumWidth; },
+        get minimumSize() { return view.minimumWidth; },
+        onDidChange: ( Event.map(view.onDidChange, e => e && e.width)),
+        layout: (size, offset, ctx) => view.layout(size, getHeight(), ctx?.top ?? 0, (ctx?.left ?? 0) + offset)
+    };
+}
+class CenteredViewLayout {
+    constructor(container, view, state = { ...defaultState }) {
+        this.container = container;
+        this.view = view;
+        this.state = state;
+        this.lastLayoutPosition = { width: 0, height: 0, left: 0, top: 0 };
+        this.didLayout = false;
+        this.splitViewDisposables = ( new DisposableStore());
+        this.centeredLayoutFixedWidth = true;
+        this._boundarySashes = {};
+        this.container.appendChild(this.view.element);
+        this.container.style.overflow = 'hidden';
+    }
+    get minimumWidth() { return this.splitView ? this.splitView.minimumSize : this.view.minimumWidth; }
+    get maximumWidth() { return this.splitView ? this.splitView.maximumSize : this.view.maximumWidth; }
+    get minimumHeight() { return this.view.minimumHeight; }
+    get maximumHeight() { return this.view.maximumHeight; }
+    get onDidChange() { return this.view.onDidChange; }
+    get boundarySashes() { return this._boundarySashes; }
+    set boundarySashes(boundarySashes) {
+        this._boundarySashes = boundarySashes;
+        if (!this.splitView) {
+            return;
+        }
+        this.splitView.orthogonalStartSash = boundarySashes.top;
+        this.splitView.orthogonalEndSash = boundarySashes.bottom;
+    }
+    layout(width, height, top, left) {
+        this.lastLayoutPosition = { width, height, top, left };
+        if (this.splitView) {
+            this.splitView.layout(width, this.lastLayoutPosition);
+            if (!this.didLayout || this.centeredLayoutFixedWidth) {
+                this.resizeSplitViews();
+            }
+        }
+        else {
+            this.view.layout(width, height, top, left);
+        }
+        this.didLayout = true;
+    }
+    resizeSplitViews() {
+        if (!this.splitView) {
+            return;
+        }
+        if (this.centeredLayoutFixedWidth) {
+            const centerViewWidth = Math.min(this.lastLayoutPosition.width, this.state.targetWidth);
+            const marginWidthFloat = (this.lastLayoutPosition.width - centerViewWidth) / 2;
+            this.splitView.resizeView(0, Math.floor(marginWidthFloat));
+            this.splitView.resizeView(1, centerViewWidth);
+            this.splitView.resizeView(2, Math.ceil(marginWidthFloat));
+        }
+        else {
+            const leftMargin = this.state.leftMarginRatio * this.lastLayoutPosition.width;
+            const rightMargin = this.state.rightMarginRatio * this.lastLayoutPosition.width;
+            const center = this.lastLayoutPosition.width - leftMargin - rightMargin;
+            this.splitView.resizeView(0, leftMargin);
+            this.splitView.resizeView(1, center);
+            this.splitView.resizeView(2, rightMargin);
+        }
+    }
+    setFixedWidth(option) {
+        this.centeredLayoutFixedWidth = option;
+        if (!!this.splitView) {
+            this.updateState();
+            this.resizeSplitViews();
+        }
+    }
+    updateState() {
+        if (!!this.splitView) {
+            this.state.targetWidth = this.splitView.getViewSize(1);
+            this.state.leftMarginRatio = this.splitView.getViewSize(0) / this.lastLayoutPosition.width;
+            this.state.rightMarginRatio = this.splitView.getViewSize(2) / this.lastLayoutPosition.width;
+        }
+    }
+    isActive() {
+        return !!this.splitView;
+    }
+    styles(style) {
+        this.style = style;
+        if (this.splitView && this.emptyViews) {
+            this.splitView.style(this.style);
+            this.emptyViews[0].element.style.backgroundColor = ( this.style.background.toString());
+            this.emptyViews[1].element.style.backgroundColor = ( this.style.background.toString());
+        }
+    }
+    activate(active) {
+        if (active === this.isActive()) {
+            return;
+        }
+        if (active) {
+            this.container.removeChild(this.view.element);
+            this.splitView = ( new SplitView(this.container, {
+                inverseAltBehavior: true,
+                orientation: 1 ,
+                styles: this.style
+            }));
+            this.splitView.orthogonalStartSash = this.boundarySashes.top;
+            this.splitView.orthogonalEndSash = this.boundarySashes.bottom;
+            this.splitViewDisposables.add(this.splitView.onDidSashChange(() => {
+                if (!!this.splitView) {
+                    this.updateState();
+                }
+            }));
+            this.splitViewDisposables.add(this.splitView.onDidSashReset(() => {
+                this.state = { ...defaultState };
+                this.resizeSplitViews();
+            }));
+            this.splitView.layout(this.lastLayoutPosition.width, this.lastLayoutPosition);
+            const backgroundColor = this.style ? this.style.background : undefined;
+            this.emptyViews = [createEmptyView(backgroundColor), createEmptyView(backgroundColor)];
+            this.splitView.addView(this.emptyViews[0], distributeSizing, 0);
+            this.splitView.addView(toSplitViewView(this.view, () => this.lastLayoutPosition.height), distributeSizing, 1);
+            this.splitView.addView(this.emptyViews[1], distributeSizing, 2);
+            this.resizeSplitViews();
+        }
+        else {
+            if (this.splitView) {
+                this.container.removeChild(this.splitView.el);
+            }
+            this.splitViewDisposables.clear();
+            this.splitView?.dispose();
+            this.splitView = undefined;
+            this.emptyViews = undefined;
+            this.container.appendChild(this.view.element);
+            this.view.layout(this.lastLayoutPosition.width, this.lastLayoutPosition.height, this.lastLayoutPosition.top, this.lastLayoutPosition.left);
+        }
+    }
+    isDefault(state) {
+        if (this.centeredLayoutFixedWidth) {
+            return state.targetWidth === defaultState.targetWidth;
+        }
+        else {
+            return state.leftMarginRatio === defaultState.leftMarginRatio
+                && state.rightMarginRatio === defaultState.rightMarginRatio;
+        }
+    }
+    dispose() {
+        this.splitViewDisposables.dispose();
+        if (this.splitView) {
+            this.splitView.dispose();
+            this.splitView = undefined;
+        }
+    }
+}
+export { CenteredViewLayout };