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

package/service-override/tools/views.js

@@ -0,0 +1,249 @@
+import { __decorate, __param } from '../../external/tslib/tslib.es6.js';
+import { SyncDescriptor } from '../../vscode/src/vs/platform/instantiation/common/descriptors.js';
+import { Extensions } from '../../vscode/src/vs/workbench/common/views.js';
+export { ViewContainerLocation } from '../../vscode/src/vs/workbench/common/views.js';
+import { MutableDisposable, DisposableStore } from '../../vscode/src/vs/base/common/lifecycle.js';
+import { size, $, append } from '../../vscode/src/vs/base/browser/dom.js';
+import { ViewPane } from '../../vscode/src/vs/workbench/browser/parts/views/viewPane.js';
+import { Registry } from '../../vscode/src/vs/platform/registry/common/platform.js';
+import { ViewPaneContainer } from '../../vscode/src/vs/workbench/browser/parts/views/viewPaneContainer.js';
+import { URI } from '../../vscode/src/vs/base/common/uri.js';
+import { Codicon } from '../../vscode/src/vs/base/common/codicons.js';
+import { IEditorResolverService } from '../../vscode/src/vs/workbench/services/editor/common/editorResolverService.js';
+export { RegisteredEditorPriority } from '../../vscode/src/vs/workbench/services/editor/common/editorResolverService.js';
+import { EditorInput } from '../../vscode/src/vs/workbench/common/editor/editorInput.js';
+import { EditorExtensions } from '../../vscode/src/vs/workbench/common/editor.js';
+export { EditorInputCapabilities } from '../../vscode/src/vs/workbench/common/editor.js';
+import { registerAction2, Action2, MenuId } from '../../vscode/src/vs/platform/actions/common/actions.js';
+import { Categories } from '../../vscode/src/vs/platform/action/common/actionCommonCategories.js';
+import { ContextKeyExpr } from '../../vscode/src/vs/platform/contextkey/common/contextkey.js';
+import { BaseActionViewItem } from '../../vscode/src/vs/base/browser/ui/actionbar/actionViewItems.js';
+import { EditorPaneDescriptor } from '../../vscode/src/vs/workbench/browser/editor.js';
+import { EditorPane } from '../../vscode/src/vs/workbench/browser/parts/editor/editorPane.js';
+import { ITelemetryService } from '../../vscode/src/vs/platform/telemetry/common/telemetry.js';
+import { IStorageService } from '../../vscode/src/vs/platform/storage/common/storage.js';
+import { IThemeService } from '../../vscode/src/vs/platform/theme/common/themeService.js';
+import { DomScrollableElement } from '../../vscode/src/vs/base/browser/ui/scrollbar/scrollableElement.js';
+import { assertAllDefined, assertIsDefined } from '../../vscode/src/vs/base/common/types.js';
+export { ConfirmResult } from '../../override/vs/platform/dialogs/common/dialogs.js';
+import { IWorkbenchLayoutService } from '../../vscode/src/vs/workbench/services/layout/browser/layoutService.js';
+export { Parts } from '../../vscode/src/vs/workbench/services/layout/browser/layoutService.js';
+import { StandaloneServices } from '../../vscode/src/vs/editor/standalone/browser/standaloneServices.js';
+import { withReadyServices } from '../../services.js';
+let SimpleEditorPane = class SimpleEditorPane extends EditorPane {
+    constructor(id, telemetryService, themeService, storageService) {
+        super(id, telemetryService, themeService, storageService);
+        this.inputDisposable = this._register(new MutableDisposable());
+    }
+    createEditor(parent) {
+        this.container = this.initialize();
+        this.scrollbar = this._register(new DomScrollableElement(this.container, { horizontal: 1 , vertical: 1  }));
+        parent.appendChild(this.scrollbar.getDomNode());
+    }
+    async setInput(input, editorOptions, context, token) {
+        await super.setInput(input, editorOptions, context, token);
+        if (token.isCancellationRequested) {
+            return;
+        }
+        this.inputDisposable.value = await this.renderInput?.(input, editorOptions, context, token);
+    }
+    layout(dimension) {
+        const [container, scrollbar] = assertAllDefined(this.container, this.scrollbar);
+        size(container, dimension.width, dimension.height);
+        scrollbar.scanDomNode();
+    }
+    focus() {
+        const container = assertIsDefined(this.container);
+        container.focus();
+    }
+    clearInput() {
+        this.inputDisposable.clear();
+        super.clearInput();
+    }
+};
+SimpleEditorPane = __decorate([
+    ( __param(1, ITelemetryService)),
+    ( __param(2, IThemeService)),
+    ( __param(3, IStorageService))
+], SimpleEditorPane);
+class SimpleEditorInput extends EditorInput {
+    constructor(resource, closeHandler) {
+        super();
+        this.closeHandler = closeHandler;
+        this.dirty = false;
+        this._capabilities = 0;
+        this.resource = resource;
+    }
+    get capabilities() {
+        return this._capabilities;
+    }
+    addCapability(capability) {
+        this._capabilities |= capability;
+        this._onDidChangeCapabilities.fire();
+    }
+    removeCapability(capability) {
+        this._capabilities &= ~capability;
+        this._onDidChangeCapabilities.fire();
+    }
+    get editorId() {
+        return this.typeId;
+    }
+    setName(name) {
+        this.name = name;
+        this._onDidChangeLabel.fire();
+    }
+    setTitle(title) {
+        this.title = title;
+        this._onDidChangeLabel.fire();
+    }
+    setDescription(description) {
+        this.description = description;
+        this._onDidChangeLabel.fire();
+    }
+    getLabelValue(label, verbosity) {
+        if (typeof label === 'string') {
+            return label;
+        }
+        switch (verbosity) {
+            case 0 :
+                return label.short;
+            case 2 :
+                return label.long;
+            case 1 :
+            default:
+                return label.medium;
+        }
+    }
+    getName() {
+        return this.name ?? 'Unnamed';
+    }
+    getTitle(verbosity) {
+        return this.getLabelValue(this.title ?? this.getName(), verbosity);
+    }
+    getDescription(verbosity) {
+        return this.getLabelValue(this.description ?? this.getName(), verbosity);
+    }
+    isDirty() {
+        return this.dirty;
+    }
+    setDirty(dirty) {
+        this.dirty = dirty;
+        this._onDidChangeDirty.fire();
+    }
+}
+function registerEditorPane(typeId, name, ctor, inputCtors) {
+    return ( Registry.as(EditorExtensions.EditorPane)).registerEditorPane(EditorPaneDescriptor.create(ctor, typeId, name), ( inputCtors.map(ctor => new SyncDescriptor(ctor))));
+}
+function registerEditor(globPattern, editorInfo, editorOptions, factory) {
+    return withReadyServices((servicesAccessor) => {
+        const resolverService = servicesAccessor.get(IEditorResolverService);
+        return resolverService.registerEditor(globPattern, editorInfo, editorOptions, factory);
+    });
+}
+function registerEditorSerializer(editorTypeId, ctor) {
+    return ( Registry.as(EditorExtensions.EditorFactory)).registerEditorSerializer(editorTypeId, ctor);
+}
+function registerCustomView(options) {
+    const iconUrl = options.icon != null ? ( URI.parse(options.icon)) : undefined;
+    const viewContainer = options.viewContainer ?? ( Registry.as(Extensions.ViewContainersRegistry)).registerViewContainer({
+        id: options.id,
+        title: { value: options.name, original: options.name },
+        order: options.order,
+        ctorDescriptor: new SyncDescriptor(ViewPaneContainer, [options.id, { mergeViewWithContainerWhenSingleView: true }]),
+        hideIfEmpty: true,
+        icon: iconUrl
+    }, options.location, {
+        isDefault: options.default
+    });
+    const views = [{
+            id: options.id,
+            name: {
+                value: options.name,
+                original: options.name
+            },
+            ctorDescriptor: new SyncDescriptor(class extends ViewPane {
+                renderBody(container) {
+                    super.renderBody(container);
+                    this.content = $('.view-pane-content');
+                    this.content.style.display = 'flex';
+                    this.content.style.alignItems = 'stretch';
+                    append(container, this.content);
+                    this._register(options.renderBody(this.content));
+                }
+                getActionViewItem(action, actionOptions) {
+                    const customAction = (options.actions ?? []).find(customAction => customAction.id === action.id);
+                    if (customAction?.render != null) {
+                        return new (class extends BaseActionViewItem {
+                            constructor() {
+                                super(null, action);
+                                this.render = customAction.render;
+                            }
+                        })();
+                    }
+                    return super.getActionViewItem(action, actionOptions);
+                }
+                layoutBody(height, width) {
+                    this.content.style.height = `${height}px`;
+                    this.content.style.width = `${width}px`;
+                }
+            }),
+            canMoveView: options.canMoveView ?? true,
+            canToggleVisibility: options.canToggleVisibility ?? false,
+            hideByDefault: options.hideByDefault ?? false,
+            collapsed: options.collapsed ?? false,
+            order: options.order,
+            containerIcon: iconUrl
+        }];
+    ( Registry.as(Extensions.ViewsRegistry)).registerViews(views, viewContainer);
+    const disposableCollection = new DisposableStore();
+    disposableCollection.add({
+        dispose() {
+            ( Registry.as(Extensions.ViewsRegistry)).deregisterViews(views, viewContainer);
+            if (options.viewContainer == null) {
+                ( Registry.as(Extensions.ViewContainersRegistry)).deregisterViewContainer(viewContainer);
+            }
+        }
+    });
+    for (const action of options.actions ?? []) {
+        disposableCollection.add(registerAction2(class extends Action2 {
+            constructor() {
+                super({
+                    id: action.id,
+                    title: { value: action.title, original: action.title },
+                    category: Categories.View,
+                    menu: [{
+                            id: MenuId.ViewTitle,
+                            when: ( ContextKeyExpr.equals('view', options.id)),
+                            group: 'navigation',
+                            order: action.order
+                        }, {
+                            id: MenuId.CommandPalette
+                        }],
+                    tooltip: action.tooltip,
+                    icon: action.icon != null ? Codicon[action.icon] : undefined
+                });
+                this.run = action.run ?? (async () => { });
+            }
+        }));
+    }
+    return disposableCollection;
+}
+function isPartVisibile(part) {
+    return StandaloneServices.get(IWorkbenchLayoutService).isVisible(part, window);
+}
+function setPartVisibility(part, visible) {
+    StandaloneServices.get(IWorkbenchLayoutService).setPartHidden(!visible, part, window);
+}
+const onDidChangePanelPosition = (listener) => {
+    return StandaloneServices.get(IWorkbenchLayoutService).onDidChangePanelPosition(listener);
+};
+function getPanelPosition() {
+    return StandaloneServices.get(IWorkbenchLayoutService).getPanelPosition();
+}
+const onDidChangeSideBarPosition = (listener) => {
+    return StandaloneServices.get(IWorkbenchLayoutService).onDidChangeSideBarPosition(listener);
+};
+function getSideBarPosition() {
+    return StandaloneServices.get(IWorkbenchLayoutService).getSideBarPosition();
+}
+export { EditorInput, EditorPane, SimpleEditorInput, SimpleEditorPane, getPanelPosition, getSideBarPosition, isPartVisibile, onDidChangePanelPosition, onDidChangeSideBarPosition, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, setPartVisibility };

package/services.d.ts

@@ -34,6 +34,7 @@ import { IEditorOverrideServices } from './vscode/src/vs/editor/standalone/brows
 export { StandaloneServices } from './vscode/src/vs/editor/standalone/browser/standaloneServices.js';
 export { IProductService } from './vscode/src/vs/platform/product/common/productService.js';
 import { IWorkbenchConstructionOptions } from './vscode/src/vs/workbench/browser/web.api.js';
+import { IProductConfiguration } from './vscode/src/vs/base/common/product.js';
 export { SyncDescriptor } from './vscode/src/vs/platform/instantiation/common/descriptors.js';
 export { IBulkEditService } from './vscode/src/vs/editor/browser/services/bulkEditService.js';
 export { IFileService } from './vscode/src/vs/platform/files/common/files.js';
@@ -69,6 +70,7 @@ export { IRemoteSocketFactoryService } from './vscode/src/vs/platform/remote/com
 export { ITerminalInstanceService, ITerminalService } from './vscode/src/vs/workbench/contrib/terminal/browser/terminal.js';
 export { IFilesConfigurationService } from './vscode/src/vs/workbench/services/filesConfiguration/common/filesConfigurationService.js';
 export { ILabelService } from './vscode/src/vs/platform/label/common/label.js';
+export { IWorkbenchLayoutService } from './vscode/src/vs/workbench/services/layout/browser/layoutService.js';
 export { IActivityService, IBadge } from './vscode/src/vs/workbench/services/activity/common/activity.js';
 export { IHoverService } from './vscode/src/vs/platform/hover/browser/hover.js';
 export { IExplorerService } from './vscode/src/vs/workbench/contrib/files/browser/files.js';
@@ -76,7 +78,7 @@ export { IStatusbarService } from './vscode/src/vs/workbench/services/statusbar/
 export { ITitleService } from './vscode/src/vs/workbench/services/title/browser/titleService.js';
 export { IBannerService } from './vscode/src/vs/workbench/services/banner/browser/bannerService.js';
 
-declare function initialize(overrides: IEditorOverrideServices, container?: HTMLElement, configuration?: IWorkbenchConstructionOptions): Promise<void>;
+declare function initialize(overrides: IEditorOverrideServices, container?: HTMLElement, configuration?: IWorkbenchConstructionOptions, productConfiguration?: Partial<IProductConfiguration>): Promise<void>;
 declare function getService<T>(identifier: ServiceIdentifier<T>): Promise<T>;
 declare function createInstance<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): Promise<R>;
 declare function createInstanceSync<Ctor extends new (...args: any[]) => any, R extends InstanceType<Ctor>>(ctor: Ctor, ...args: GetLeadingNonServiceArgs<ConstructorParameters<Ctor>>): R;
@@ -85,4 +87,4 @@ declare function createInstanceSync<Ctor extends new (...args: any[]) => any, R
  */
 declare function withReadyServices(callback: (serviceAccessor: ServicesAccessor) => IDisposable): IDisposable;
 
-export { IWorkbenchConstructionOptions, createInstance, createInstanceSync, getService, initialize, withReadyServices };
+export { IEditorOverrideServices, IWorkbenchConstructionOptions, createInstance, createInstanceSync, getService, initialize, withReadyServices };

package/services.js

@@ -69,11 +69,11 @@ import { IProductService } from './vscode/src/vs/platform/product/common/product
 import { DisposableStore } from './vscode/src/vs/base/common/lifecycle.js';
 import { initialize as initialize$1 } from './workbench.js';
 import { checkServicesNotInitialized, startup, waitServicesReady, checkServicesReady, serviceInitializedBarrier, serviceInitializedEmitter } from './lifecycle.js';
-import getServiceOverride$4 from '@codingame/monaco-vscode-quickaccess-service-override';
-import getServiceOverride$1$2 from '@codingame/monaco-vscode-files-service-override';
+import getServiceOverride$2$1 from '@codingame/monaco-vscode-quickaccess-service-override';
+import getServiceOverride$1$1 from '@codingame/monaco-vscode-files-service-override';
 import getServiceOverride$2 from '@codingame/monaco-vscode-extensions-service-override';
-import getServiceOverride$1$1 from '@codingame/monaco-vscode-environment-service-override';
-import getServiceOverride$1 from '@codingame/monaco-vscode-layout-service-override';
+import getServiceOverride$1 from '@codingame/monaco-vscode-environment-service-override';
+import getServiceOverride from '@codingame/monaco-vscode-layout-service-override';
 import getServiceOverride$5 from '@codingame/monaco-vscode-host-service-override';
 import getServiceOverride$6 from '@codingame/monaco-vscode-base-service-override';
 export { SyncDescriptor } from './vscode/src/vs/platform/instantiation/common/descriptors.js';
@@ -131,6 +131,7 @@ export { IRemoteSocketFactoryService } from './vscode/src/vs/platform/remote/com
 export { ITerminalInstanceService, ITerminalService } from './vscode/src/vs/workbench/contrib/terminal/browser/terminal.js';
 export { IFilesConfigurationService } from './vscode/src/vs/workbench/services/filesConfiguration/common/filesConfigurationService.js';
 export { ILabelService } from './vscode/src/vs/platform/label/common/label.js';
+export { IWorkbenchLayoutService } from './vscode/src/vs/workbench/services/layout/browser/layoutService.js';
 export { IActivityService } from './vscode/src/vs/workbench/services/activity/common/activity.js';
 export { IHoverService } from './vscode/src/vs/platform/hover/browser/hover.js';
 export { IExplorerService } from './vscode/src/vs/workbench/contrib/files/browser/files.js';
@@ -139,7 +140,7 @@ export { ITitleService } from './vscode/src/vs/workbench/services/title/browser/
 export { IBannerService } from './vscode/src/vs/workbench/services/banner/browser/bannerService.js';
 export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from './vscode/src/vs/platform/workspace/common/workspaceTrust.js';
 export { IDialogService, IFileDialogService } from './vscode/src/vs/platform/dialogs/common/dialogs.js';
-async function initialize(overrides, container = document.body, configuration = {}) {
+async function initialize(overrides, container = document.body, configuration = {}, productConfiguration = {}) {
     checkServicesNotInitialized();
     initialize$1(container, configuration);
     const instantiationService = StandaloneServices.initialize({
@@ -155,13 +156,14 @@ async function initialize(overrides, container = document.body, configuration =
             reportIssueUrl: 'https://github.com/microsoft/vscode/issues/new',
             licenseName: 'MIT',
             licenseUrl: 'https://github.com/microsoft/vscode/blob/main/LICENSE.txt',
-            serverApplicationName: 'code-server-oss'
+            serverApplicationName: 'code-server-oss',
+            ...productConfiguration
         }, configuration.productConfiguration ?? {}),
+        ...getServiceOverride(),
         ...getServiceOverride$1(),
-        ...getServiceOverride$1$1(),
         ...getServiceOverride$2(),
-        ...getServiceOverride$1$2(),
-        ...getServiceOverride$4(),
+        ...getServiceOverride$1$1(),
+        ...getServiceOverride$2$1(),
         ...getServiceOverride$5(),
         ...getServiceOverride$6(),
         ...overrides

package/vscode/src/vs/base/browser/deviceAccess.js

@@ -0,0 +1,60 @@
+async function requestUsbDevice(options) {
+    const usb = navigator.usb;
+    if (!usb) {
+        return undefined;
+    }
+    const device = await usb.requestDevice({ filters: options?.filters ?? [] });
+    if (!device) {
+        return undefined;
+    }
+    return {
+        deviceClass: device.deviceClass,
+        deviceProtocol: device.deviceProtocol,
+        deviceSubclass: device.deviceSubclass,
+        deviceVersionMajor: device.deviceVersionMajor,
+        deviceVersionMinor: device.deviceVersionMinor,
+        deviceVersionSubminor: device.deviceVersionSubminor,
+        manufacturerName: device.manufacturerName,
+        productId: device.productId,
+        productName: device.productName,
+        serialNumber: device.serialNumber,
+        usbVersionMajor: device.usbVersionMajor,
+        usbVersionMinor: device.usbVersionMinor,
+        usbVersionSubminor: device.usbVersionSubminor,
+        vendorId: device.vendorId,
+    };
+}
+async function requestSerialPort(options) {
+    const serial = navigator.serial;
+    if (!serial) {
+        return undefined;
+    }
+    const port = await serial.requestPort({ filters: options?.filters ?? [] });
+    if (!port) {
+        return undefined;
+    }
+    const info = port.getInfo();
+    return {
+        usbVendorId: info.usbVendorId,
+        usbProductId: info.usbProductId
+    };
+}
+async function requestHidDevice(options) {
+    const hid = navigator.hid;
+    if (!hid) {
+        return undefined;
+    }
+    const devices = await hid.requestDevice({ filters: options?.filters ?? [] });
+    if (!devices.length) {
+        return undefined;
+    }
+    const device = devices[0];
+    return {
+        opened: device.opened,
+        vendorId: device.vendorId,
+        productId: device.productId,
+        productName: device.productName,
+        collections: device.collections
+    };
+}
+export { requestHidDevice, requestSerialPort, requestUsbDevice };

package/vscode/src/vs/base/browser/dom.js

@@ -1048,6 +1048,23 @@ function computeScreenAwareSize(window, cssPx) {
 function windowOpenNoOpener(url) {
     mainWindow.open(url, '_blank', 'noopener');
 }
+const popupWidth = 780, popupHeight = 640;
+function windowOpenPopup(url) {
+    const left = Math.floor(mainWindow.screenLeft + mainWindow.innerWidth / 2 - popupWidth / 2);
+    const top = Math.floor(mainWindow.screenTop + mainWindow.innerHeight / 2 - popupHeight / 2);
+    mainWindow.open(url, '_blank', `width=${popupWidth},height=${popupHeight},top=${top},left=${left}`);
+}
+function windowOpenWithSuccess(url, noOpener = true) {
+    const newTab = mainWindow.open();
+    if (newTab) {
+        if (noOpener) {
+            newTab.opener = null;
+        }
+        newTab.location.href = url;
+        return true;
+    }
+    return false;
+}
 function animate(targetWindow, fn) {
     const step = () => {
         fn();
@@ -1538,4 +1555,4 @@ function trackAttributes(from, to, filter) {
     }));
     return disposables;
 }
-export { $, DetectedFullscreenMode, Dimension, DragAndDropObserver, EventHelper, EventType, ModifierKeyEmitter, Namespace, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseUpListener, addDisposableListener, addDisposableThrottledListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, asCSSPropertyValue, asCSSUrl, asCssValueWithDefault, basicMarkupHtmlTags, clearNode, cloneGlobalStylesheets, computeScreenAwareSize, copyAttributes, createCSSRule, createLinkElement, createMetaElement, createStyleSheet, createStyleSheet2, detectFullscreen, disposableWindowInterval, finalHandler, findParentWithClass, focusWindow, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getLargestChildWidth, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasParentWithClass, hasWindow, hide, hookDomPurifyHrefAndSrcSanitizer, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEventLike, isGlobalStylesheet, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isShadowRoot, join, measure, modify, multibyteAwareBtoa, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, removeCSSRulesContainingSelector, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, safeInnerHtml, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener };
+export { $, DetectedFullscreenMode, Dimension, DragAndDropObserver, EventHelper, EventType, ModifierKeyEmitter, Namespace, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseUpListener, addDisposableListener, addDisposableThrottledListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, asCSSPropertyValue, asCSSUrl, asCssValueWithDefault, basicMarkupHtmlTags, clearNode, cloneGlobalStylesheets, computeScreenAwareSize, copyAttributes, createCSSRule, createLinkElement, createMetaElement, createStyleSheet, createStyleSheet2, detectFullscreen, disposableWindowInterval, finalHandler, findParentWithClass, focusWindow, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getLargestChildWidth, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasParentWithClass, hasWindow, hide, hookDomPurifyHrefAndSrcSanitizer, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEventLike, isGlobalStylesheet, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isShadowRoot, join, measure, modify, multibyteAwareBtoa, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, removeCSSRulesContainingSelector, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, safeInnerHtml, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener, windowOpenPopup, windowOpenWithSuccess };

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

@@ -0,0 +1,178 @@
+import { $ } from '../../dom.js';
+import { SplitView } from '../splitview/splitview.js';
+import { Event } from '../../../common/event.js';
+import { DisposableStore } from '../../../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 }, centeredLayoutFixedWidth = false) {
+        this.container = container;
+        this.view = view;
+        this.state = state;
+        this.centeredLayoutFixedWidth = centeredLayoutFixedWidth;
+        this.lastLayoutPosition = { width: 0, height: 0, left: 0, top: 0 };
+        this.didLayout = false;
+        this.splitViewDisposables = ( new DisposableStore());
+        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 };