monaco-languageclient 9.7.1 → 10.0.0-next.0

package/src/vscode/apiWrapper.ts

@@ -0,0 +1,333 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import { initialize, LogLevel } from '@codingame/monaco-vscode-api';
+import { ExtensionHostKind, getExtensionManifests, registerExtension, type IExtensionManifest, type RegisterExtensionResult } from '@codingame/monaco-vscode-api/extensions';
+import { DisposableStore, setUnexpectedErrorHandler } from '@codingame/monaco-vscode-api/monaco';
+import getConfigurationServiceOverride, { initUserConfiguration } from '@codingame/monaco-vscode-configuration-service-override';
+import getLanguagesServiceOverride from '@codingame/monaco-vscode-languages-service-override';
+import getLogServiceOverride from '@codingame/monaco-vscode-log-service-override';
+import getModelServiceOverride from '@codingame/monaco-vscode-model-service-override';
+import { ConsoleLogger, verifyUrlOrCreateDataUrl, type Logger } from 'monaco-languageclient/common';
+import { useWorkerFactory } from 'monaco-languageclient/workerFactory';
+import * as vscode from 'vscode';
+import 'vscode/localExtensionHost';
+import type { MonacoVscodeApiConfig } from './config.js';
+import { configureExtHostWorker, getEnhancedMonacoEnvironment, mergeServices, reportServiceLoading, useOpenEditorStub } from './utils.js';
+
+export interface InitServicesInstructions {
+    caller?: string;
+    performServiceConsistencyChecks?: boolean;
+    htmlContainer?: HTMLElement | null;
+}
+
+export class MonacoVscodeApiWrapper {
+
+    private logger: Logger = new ConsoleLogger();
+    private extensionRegisterResults: Map<string, | RegisterExtensionResult> = new Map();
+    private disposableStore: DisposableStore = new DisposableStore();
+    private apiConfig: MonacoVscodeApiConfig;
+
+    constructor(apiConfig: MonacoVscodeApiConfig) {
+        this.apiConfig = apiConfig;
+        this.apiConfig.logLevel = this.apiConfig.logLevel ?? LogLevel.Off;
+        this.logger.setLevel(this.apiConfig.logLevel);
+    }
+
+    getLogger(): Logger {
+        return this.logger;
+    }
+
+    getExtensionRegisterResult(extensionName: string) {
+        return this.extensionRegisterResults.get(extensionName);
+    }
+
+    getMonacoVscodeApiConfig(): MonacoVscodeApiConfig {
+        return this.apiConfig;
+    }
+
+    protected configureMonacoWorkers() {
+        if (typeof this.apiConfig.monacoWorkerFactory === 'function') {
+            this.apiConfig.monacoWorkerFactory(this.logger);
+        } else {
+            useWorkerFactory({
+                logger: this.logger
+            });
+        }
+    }
+
+    protected async configureHighlightingServices() {
+        if (this.apiConfig.$type === 'extended') {
+            const getTextmateServiceOverride = (await import('@codingame/monaco-vscode-textmate-service-override')).default;
+            const getThemeServiceOverride = (await import('@codingame/monaco-vscode-theme-service-override')).default;
+            mergeServices(this.apiConfig.serviceOverrides, {
+                ...getTextmateServiceOverride(),
+                ...getThemeServiceOverride()
+            });
+        } else {
+            const getMonarchServiceOverride = (await import('@codingame/monaco-vscode-monarch-service-override')).default;
+            mergeServices(this.apiConfig.serviceOverrides, {
+                ...getMonarchServiceOverride()
+            });
+        }
+    }
+
+    protected async configureViewsServices() {
+        const viewServiceType = this.apiConfig.viewsConfig?.viewServiceType ?? 'EditorService';
+        if (this.apiConfig.$type === 'classic' && (viewServiceType === 'ViewsService' || viewServiceType === 'WorkspaceService')) {
+            throw new Error(`View Service Type "${viewServiceType}" cannot be used with classic configuration.`);
+        }
+
+        const envEnhanced = getEnhancedMonacoEnvironment();
+        if (this.apiConfig.viewsConfig?.viewServiceType === 'ViewsService') {
+            const getViewsServiceOverride = (await import('@codingame/monaco-vscode-views-service-override')).default;
+            mergeServices(this.apiConfig.serviceOverrides, {
+                ...getViewsServiceOverride(this.apiConfig.viewsConfig.openEditorFunc ?? useOpenEditorStub)
+            });
+            envEnhanced.viewServiceType = 'ViewsService';
+        } else if (this.apiConfig.viewsConfig?.viewServiceType === 'WorkspaceService') {
+            const getWorkbenchServiceOverride = (await import('@codingame/monaco-vscode-workbench-service-override')).default;
+            mergeServices(this.apiConfig.serviceOverrides, {
+                ...getWorkbenchServiceOverride()
+            });
+            envEnhanced.viewServiceType = 'WorkspaceService';
+        } else {
+            const getEditorServiceOverride = (await import('@codingame/monaco-vscode-editor-service-override')).default;
+            mergeServices(this.apiConfig.serviceOverrides, {
+                ...getEditorServiceOverride(this.apiConfig.viewsConfig?.openEditorFunc ?? useOpenEditorStub)
+            });
+            envEnhanced.viewServiceType = 'EditorService';
+        }
+    }
+
+    protected async applyViewsPostConfig() {
+        this.apiConfig.viewsConfig?.htmlAugmentationInstructions?.(this.apiConfig.htmlContainer);
+        await this.apiConfig.viewsConfig?.viewsInitFunc?.();
+    }
+
+    /**
+     * Adding the default workspace config if not provided
+     */
+    protected configureWorkspaceConfig() {
+        if (this.apiConfig.workspaceConfig === undefined) {
+            this.apiConfig.workspaceConfig = {
+                workspaceProvider: {
+                    trusted: true,
+                    workspace: {
+                        workspaceUri: vscode.Uri.file('/workspace.code-workspace')
+                    },
+                    async open() {
+                        window.open(window.location.href);
+                        return true;
+                    }
+                },
+            };
+        }
+    }
+
+    /**
+     * set the log-level via the development settings
+     */
+    protected configureDevLogLevel() {
+        const devLogLevel = this.apiConfig.workspaceConfig?.developmentOptions?.logLevel;
+        if (devLogLevel === undefined) {
+
+            // this needs to be done so complicated, because developmentOptions is read-only
+            const devOptions: Record<string, unknown> = {
+                ...this.apiConfig.workspaceConfig!.developmentOptions
+            };
+            devOptions.logLevel = this.apiConfig.logLevel;
+            (this.apiConfig.workspaceConfig!.developmentOptions as Record<string, unknown>) = Object.assign({}, devOptions);
+        } else if (devLogLevel !== this.apiConfig.logLevel) {
+            throw new Error(`You have configured mismatching logLevels: ${this.apiConfig.logLevel} (wrapperConfig) ${devLogLevel} (workspaceConfig.developmentOptions)`);
+        } else {
+            this.logger.debug('Development log level and api log level are in aligned.');
+        }
+    }
+
+    /**
+     * enable semantic highlighting in the default configuration
+     */
+    protected configureSemanticHighlighting() {
+        if (this.apiConfig.advanced?.enforceSemanticHighlighting === true) {
+            const configDefaults: Record<string, unknown> = {
+                ...this.apiConfig.workspaceConfig!.configurationDefaults ?? {}
+            };
+            configDefaults['editor.semanticHighlighting.enabled'] = true;
+            (this.apiConfig.workspaceConfig!.configurationDefaults as Record<string, unknown>) = Object.assign({}, configDefaults);
+        }
+    }
+
+    protected async initUserConfiguration() {
+        if (this.apiConfig.userConfiguration?.json !== undefined) {
+            await initUserConfiguration(this.apiConfig.userConfiguration.json);
+        }
+    }
+
+    protected async supplyRequiredServices() {
+        return {
+            ...getConfigurationServiceOverride(),
+            ...getLanguagesServiceOverride(),
+            ...getLogServiceOverride(),
+            ...getModelServiceOverride()
+        };
+    }
+
+    protected checkServiceConsistency() {
+        const userServices = this.apiConfig.serviceOverrides;
+        const haveThemeService = Object.keys(userServices).includes('themeService');
+        const haveTextmateService = Object.keys(userServices).includes('textMateTokenizationFeature');
+        const haveMarkersService = Object.keys(userServices).includes('markersService');
+        const haveViewsService = Object.keys(userServices).includes('viewsService');
+
+        // theme requires textmate
+        if (haveThemeService && !haveTextmateService) {
+            throw new Error('"theme" service requires "textmate" service. Please add it to the "userServices".');
+        }
+
+        // markers service requires views service
+        if (haveMarkersService && !haveViewsService) {
+            throw new Error('"markers" service requires "views" service. Please add it to the "userServices".');
+        }
+    }
+
+    /**
+     * monaco-vscode-api automatically loads the following services:
+     *  - layout
+     *  - environment
+     *  - extension
+     *  - files
+     *  - quickAccess
+     * monaco-languageclient always adds the following services:
+     *   - languages
+     *   - log
+     *   - model
+     */
+    protected async importAllServices(instructions?: InitServicesInstructions) {
+        const services = await this.supplyRequiredServices();
+
+        mergeServices(services, this.apiConfig.serviceOverrides);
+        await configureExtHostWorker(this.apiConfig.advanced?.enableExtHostWorker === true, services);
+
+        reportServiceLoading(services, this.logger);
+
+        if (instructions?.performServiceConsistencyChecks === true) {
+            this.checkServiceConsistency();
+        }
+
+        if (this.apiConfig.viewsConfig?.viewServiceType === 'ViewsService' || this.apiConfig.viewsConfig?.viewServiceType === 'WorkspaceService') {
+            await initialize(services, this.apiConfig.htmlContainer, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
+        } else {
+            await initialize(services, undefined, this.apiConfig.workspaceConfig, this.apiConfig.envOptions);
+        }
+
+        setUnexpectedErrorHandler((e) => {
+            this.logger.createErrorAndLog('Unexpected error', e);
+        });
+    }
+
+    async initExtensions(): Promise<void> {
+        if (this.apiConfig.$type === 'extended' && (this.apiConfig.advanced?.loadThemes === undefined ? true : this.apiConfig.advanced.loadThemes === true)) {
+            await import('@codingame/monaco-vscode-theme-defaults-default-extension');
+        }
+
+        const extensions = this.apiConfig.extensions;
+        if (this.apiConfig.extensions) {
+            const allPromises: Array<Promise<void>> = [];
+            const extensionIds: string[] = [];
+            getExtensionManifests().forEach((ext) => {
+                extensionIds.push(ext.identifier.id);
+            });
+            for (const extensionConfig of extensions ?? []) {
+                if (!extensionIds.includes(`${extensionConfig.config.publisher}.${extensionConfig.config.name}`)) {
+                    const manifest = extensionConfig.config as IExtensionManifest;
+                    const extRegResult = registerExtension(manifest, ExtensionHostKind.LocalProcess);
+                    this.extensionRegisterResults.set(manifest.name, extRegResult);
+                    if (extensionConfig.filesOrContents && Object.hasOwn(extRegResult, 'registerFileUrl')) {
+                        for (const entry of extensionConfig.filesOrContents) {
+                            this.disposableStore.add(extRegResult.registerFileUrl(entry[0], verifyUrlOrCreateDataUrl(entry[1])));
+                        }
+                    }
+                    allPromises.push(extRegResult.whenReady());
+                }
+            }
+            await Promise.all(allPromises);
+        }
+    }
+
+    protected markGlobalInit() {
+        this.logger.debug('markGlobalInit');
+
+        const envEnhanced = getEnhancedMonacoEnvironment();
+        envEnhanced.vscodeApiGlobalInitAwait = new Promise<void>((resolve) => {
+            envEnhanced.vscodeApiGlobalInitResolve = resolve;
+        });
+    }
+
+    protected markGlobalInitDone() {
+        const envEnhanced = getEnhancedMonacoEnvironment();
+        if (typeof envEnhanced.vscodeApiGlobalInitResolve === 'function') {
+            envEnhanced.vscodeApiGlobalInitResolve();
+        }
+        envEnhanced.vscodeApiInitialised = true;
+        envEnhanced.vscodeApiGlobalInitAwait = undefined;
+        envEnhanced.vscodeApiGlobalInitResolve = undefined;
+        this.logger.debug('markGlobalInitDone');
+    }
+
+    async init(instructions?: InitServicesInstructions): Promise<void> {
+        const envEnhanced = getEnhancedMonacoEnvironment();
+        if (envEnhanced.vscodeApiInitialised === true) {
+            this.logger.warn('Initialization of monaco-vscode api can only performed once!');
+        } else {
+            if (!(envEnhanced.vscodeApiInitialising === true)) {
+                envEnhanced.vscodeApiInitialising = true;
+                this.markGlobalInit();
+                if (instructions?.htmlContainer !== undefined && instructions.htmlContainer !== null) {
+                    this.apiConfig.htmlContainer = instructions.htmlContainer;
+                }
+
+                // ensures "vscodeApiConfig.workspaceConfig" is available
+                this.configureWorkspaceConfig();
+
+                // ensure logging and development logging options are in-line
+                this.configureDevLogLevel();
+                this.logger.info(`Initializing monaco-vscode api. Caller: ${instructions?.caller ?? 'unknown'}`);
+
+                await this.configureMonacoWorkers();
+
+                // ensure either classic (monarch) or textmate (extended) highlighting is used
+                await this.configureHighlightingServices();
+
+                // ensure one of the three potential view services are configured
+                await this.configureViewsServices();
+
+                // enforece semantic highlighting if configured
+                this.configureSemanticHighlighting();
+
+                await this.initUserConfiguration();
+
+                await this.importAllServices(instructions);
+
+                await this.applyViewsPostConfig();
+
+                await this.initExtensions();
+
+                this.markGlobalInitDone();
+                this.logger.debug('Initialization of monaco-vscode api completed successfully.');
+            } else {
+                this.logger.debug('Initialization of monaco-vscode api is already ongoing.');
+            }
+        }
+    }
+
+    dispose() {
+        this.extensionRegisterResults.forEach((k) => k.dispose());
+        this.disposableStore.dispose();
+
+        // re-create disposable stores
+        this.disposableStore = new DisposableStore();
+    }
+}

package/src/vscode/config.ts

@@ -0,0 +1,55 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as monaco from '@codingame/monaco-vscode-editor-api';
+import { LogLevel } from '@codingame/monaco-vscode-api';
+import type { IWorkbenchConstructionOptions } from '@codingame/monaco-vscode-api';
+import type { IExtensionManifest } from '@codingame/monaco-vscode-api/extensions';
+import type { EnvironmentOverride } from '@codingame/monaco-vscode-api/workbench';
+import type { OpenEditor } from '@codingame/monaco-vscode-editor-service-override';
+import type { Logger } from 'monaco-languageclient/common';
+
+export interface MonacoEnvironmentEnhanced extends monaco.Environment {
+    vscodeApiInitialising?: boolean;
+    vscodeApiInitialised?: boolean;
+    vscodeApiGlobalInitAwait?: Promise<void>;
+    vscodeApiGlobalInitResolve?: ((value: void | PromiseLike<void>) => void);
+    viewServiceType?: 'EditorService' | 'ViewsService' | 'WorkspaceService';
+}
+
+export type OverallConfigType = 'extended' | 'classic';
+
+export interface UserConfiguration {
+    json?: string;
+}
+export interface ViewsConfig {
+    viewServiceType: 'EditorService' | 'ViewsService' | 'WorkspaceService';
+    openEditorFunc?: OpenEditor;
+    htmlAugmentationInstructions?: (htmlContainer: HTMLElement | null | undefined) => void;
+    viewsInitFunc?: () => Promise<void>;
+}
+
+export interface ExtensionConfig {
+    config: IExtensionManifest;
+    filesOrContents?: Map<string, string | URL>;
+}
+
+export interface MonacoVscodeApiConfig {
+    $type: OverallConfigType;
+    htmlContainer?: HTMLElement;
+    serviceOverrides: monaco.editor.IEditorOverrideServices;
+    logLevel?: LogLevel | number;
+    workspaceConfig?: IWorkbenchConstructionOptions;
+    userConfiguration?: UserConfiguration;
+    viewsConfig?: ViewsConfig,
+    envOptions?: EnvironmentOverride;
+    extensions?: ExtensionConfig[];
+    monacoWorkerFactory?: (logger?: Logger) => void;
+    advanced?: {
+        enableExtHostWorker?: boolean;
+        loadThemes?: boolean;
+        enforceSemanticHighlighting?: boolean;
+    };
+}

package/src/vscode/index.ts

@@ -3,5 +3,7 @@
  * Licensed under the MIT License. See LICENSE in the package root for license information.
  * ------------------------------------------------------------------------------------------ */
 
-export * from './fakeWorker.js';
-export * from './services.js';
+export * from './config.js';
+export * from './apiWrapper.js';
+export * from './utils.js';
+export * from './viewsService.js';

package/src/vscode/locales.ts

@@ -0,0 +1,128 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import type { LocalizationOptions } from '@codingame/monaco-vscode-localization-service-override';
+
+export const createDefaultLocaleConfiguration = (): LocalizationOptions => {
+    return {
+        async clearLocale() {
+            const url = new URL(window.location.href);
+            url.searchParams.delete('locale');
+            window.history.pushState(null, '', url.toString());
+        },
+        async setLocale(id: string) {
+            const url = new URL(window.location.href);
+            url.searchParams.set('locale', id);
+            window.history.pushState(null, '', url.toString());
+        },
+        availableLanguages: [{
+            locale: 'en',
+            languageName: 'English'
+        }, {
+            locale: 'cs',
+            languageName: 'Czech'
+        }, {
+            locale: 'de',
+            languageName: 'German'
+        }, {
+            locale: 'es',
+            languageName: 'Spanish'
+        }, {
+            locale: 'fr',
+            languageName: 'French'
+        }, {
+            locale: 'it',
+            languageName: 'Italian'
+        }, {
+            locale: 'ja',
+            languageName: 'Japanese'
+        }, {
+            locale: 'ko',
+            languageName: 'Korean'
+        }, {
+            locale: 'pl',
+            languageName: 'Polish'
+        }, {
+            locale: 'pt-br',
+            languageName: 'Portuguese (Brazil)'
+        }, {
+            locale: 'qps-ploc',
+            languageName: 'Pseudo Language'
+        }, {
+            locale: 'ru',
+            languageName: 'Russian'
+        }, {
+            locale: 'tr',
+            languageName: 'Turkish'
+        }, {
+            locale: 'zh-hans',
+            languageName: 'Chinese (Simplified)'
+        }, {
+            locale: 'zh-hant',
+            languageName: 'Chinese (Traditional)'
+        }, {
+            locale: 'en',
+            languageName: 'English'
+        }]
+    };
+};
+
+const localeLoader: Partial<Record<string, () => Promise<void>>> = {
+    cs: async () => {
+        await import('@codingame/monaco-vscode-language-pack-cs');
+    },
+    de: async () => {
+        await import('@codingame/monaco-vscode-language-pack-de');
+    },
+    es: async () => {
+        await import('@codingame/monaco-vscode-language-pack-es');
+    },
+    fr: async () => {
+        await import('@codingame/monaco-vscode-language-pack-fr');
+    },
+    it: async () => {
+        await import('@codingame/monaco-vscode-language-pack-it');
+    },
+    ja: async () => {
+        await import('@codingame/monaco-vscode-language-pack-ja');
+    },
+    ko: async () => {
+        await import('@codingame/monaco-vscode-language-pack-ko');
+    },
+    pl: async () => {
+        await import('@codingame/monaco-vscode-language-pack-pl');
+    },
+    'pt-br': async () => {
+        await import('@codingame/monaco-vscode-language-pack-pt-br');
+    },
+    'qps-ploc': async () => {
+        await import('@codingame/monaco-vscode-language-pack-qps-ploc');
+    },
+    ru: async () => {
+        await import('@codingame/monaco-vscode-language-pack-ru');
+    },
+    tr: async () => {
+        await import('@codingame/monaco-vscode-language-pack-tr');
+    },
+    'zh-hans': async () => {
+        await import('@codingame/monaco-vscode-language-pack-zh-hans');
+    },
+    'zh-hant': async () => {
+        await import('@codingame/monaco-vscode-language-pack-zh-hant');
+    }
+};
+
+export const locales = Object.keys(localeLoader);
+
+export const initLocaleLoader = async (locale = new URLSearchParams(window.location.search).get('locale')) => {
+    if (locale !== null) {
+        const loader = localeLoader[locale];
+        if (loader) {
+            await loader();
+        } else {
+            console.error(`Unknown locale ${locale}`);
+        }
+    }
+};

package/src/vscode/utils.ts

@@ -0,0 +1,67 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+import * as monaco from '@codingame/monaco-vscode-editor-api';
+import type { OpenEditor } from '@codingame/monaco-vscode-editor-service-override';
+import type { WorkerConfig } from '@codingame/monaco-vscode-extensions-service-override';
+import getExtensionServiceOverride from '@codingame/monaco-vscode-extensions-service-override';
+import type { Logger } from 'monaco-languageclient/common';
+import { FakeWorker as Worker } from 'monaco-languageclient/workerFactory';
+import type { MonacoEnvironmentEnhanced } from './config.js';
+
+export const getEnhancedMonacoEnvironment = (): MonacoEnvironmentEnhanced => {
+    const monWin = (self as Window);
+    if (monWin.MonacoEnvironment === undefined) {
+        monWin.MonacoEnvironment = {};
+    }
+    const envEnhanced = monWin.MonacoEnvironment as MonacoEnvironmentEnhanced;
+    if (envEnhanced.vscodeApiInitialising === undefined) {
+        envEnhanced.vscodeApiInitialising = false;
+    }
+    if (envEnhanced.vscodeApiInitialised === undefined) {
+        envEnhanced.vscodeApiInitialised = false;
+    }
+    if (envEnhanced.viewServiceType === undefined) {
+        envEnhanced.viewServiceType = 'EditorService';
+    }
+
+    return envEnhanced;
+};
+
+export const reportServiceLoading = (services: monaco.editor.IEditorOverrideServices, logger?: Logger) => {
+    for (const serviceName of Object.keys(services)) {
+        logger?.debug(`Loading service: ${serviceName}`);
+    }
+};
+
+export const mergeServices = (overrideServices: monaco.editor.IEditorOverrideServices, services?: monaco.editor.IEditorOverrideServices) => {
+    if (services !== undefined) {
+        for (const [name, service] of Object.entries(services)) {
+            overrideServices[name] = service;
+        }
+    }
+};
+
+/**
+ * Enable ext host to run in a worker
+ */
+export const configureExtHostWorker = async (enableExtHostWorker: boolean, userServices: monaco.editor.IEditorOverrideServices) => {
+    if (enableExtHostWorker) {
+        const fakeWorker = new Worker(new URL('@codingame/monaco-vscode-api/workers/extensionHost.worker', import.meta.url), { type: 'module' });
+        const workerConfig: WorkerConfig = {
+            url: fakeWorker.url.toString(),
+            options: fakeWorker.options
+        };
+
+        mergeServices(userServices, {
+            ...getExtensionServiceOverride(workerConfig),
+        });
+    }
+};
+
+export const useOpenEditorStub: OpenEditor = async (modelRef, options, sideBySide) => {
+    console.log('Received open editor call with parameters: ', modelRef, options, sideBySide);
+    return undefined;
+};

package/src/vscode/viewsService.ts

@@ -0,0 +1,73 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+export const defaultViewsInit = async () => {
+    const { Parts, Position, onPartVisibilityChange, isPartVisibile, attachPart, getSideBarPosition, onDidChangeSideBarPosition } = await import('@codingame/monaco-vscode-views-service-override');
+
+    for (const config of [
+        { part: Parts.TITLEBAR_PART, element: '#titleBar' },
+        { part: Parts.BANNER_PART, element: '#banner' },
+        {
+            part: Parts.SIDEBAR_PART, get element() {
+                return getSideBarPosition() === Position.LEFT ? '#sidebar' : '#sidebar-right';
+            }, onDidElementChange: onDidChangeSideBarPosition
+        },
+        {
+            part: Parts.ACTIVITYBAR_PART, get element() {
+                return getSideBarPosition() === Position.LEFT ? '#activityBar' : '#activityBar-right';
+            }, onDidElementChange: onDidChangeSideBarPosition
+        },
+        {
+            part: Parts.AUXILIARYBAR_PART, get element() {
+                return getSideBarPosition() === Position.LEFT ? '#auxiliaryBar' : '#auxiliaryBar-left';
+            }, onDidElementChange: onDidChangeSideBarPosition
+        },
+        { part: Parts.EDITOR_PART, element: '#editors' },
+        { part: Parts.PANEL_PART, element: '#panel' },
+        { part: Parts.STATUSBAR_PART, element: '#statusBar' }
+    ]) {
+        attachPart(config.part, document.querySelector<HTMLDivElement>(config.element)!);
+
+        config.onDidElementChange?.(() => {
+            attachPart(config.part, document.querySelector<HTMLDivElement>(config.element)!);
+        });
+
+        if (!isPartVisibile(config.part)) {
+            document.querySelector<HTMLDivElement>(config.element)!.style.display = 'none';
+        }
+
+        onPartVisibilityChange(config.part, visible => {
+            document.querySelector<HTMLDivElement>(config.element)!.style.display = visible ? 'block' : 'none';
+        });
+    }
+};
+
+export const defaultViewsHtml = `<div id="workbench-container">
+    <div id="titleBar"></div>
+    <div id="banner"></div>
+    <div id="workbench-top">
+        <div id="sidebarDiv">
+            <div id="activityBar"></div>
+            <div id="sidebar"></div>
+            <div id="auxiliaryBar-left"></div>
+        </div>
+        <div id="editorsDiv">
+            <div id="editors"></div>
+        </div>
+        <div id="sidebarRightDiv">
+            <div id="sidebar-right"></div>
+            <div id="activityBar-right"></div>
+            <div id="auxiliaryBar"></div>
+        </div>
+    </div>
+    <div id="panel"></div>
+    <div id="statusBar"></div>
+</div>`;
+
+export const defaultHtmlAugmentationInstructions = (htmlElement: HTMLElement | null | undefined) => {
+    const htmlContainer = document.createElement('div', { is: 'app' });
+    htmlContainer.innerHTML = defaultViewsHtml;
+    htmlElement?.append(htmlContainer);
+};

package/src/worker/index.ts

@@ -0,0 +1,8 @@
+/* --------------------------------------------------------------------------------------------
+ * Copyright (c) 2024 TypeFox and others.
+ * Licensed under the MIT License. See LICENSE in the package root for license information.
+ * ------------------------------------------------------------------------------------------ */
+
+export * from './fakeWorker.js';
+export * from './workerFactory.js';
+export * from './workerLoaders.js';