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

package/README.md

@@ -194,6 +194,8 @@ Additionally, several packages that include the VSCode version of some services
   - Support for the outline view. *Hint*: It only makes sense to enable it when *Views* service is used.
 - **Timeline**: `@codingame/monaco-vscode-timeline-service-override`
   - Support for the timeline view. *Hint*: It only makes sense to enable it when *Views* service is used.
+- **Workbench**: `@codingame/monaco-vscode-workbench-service-override`
+  - Allows to render the full workbench layout. Is exclusive with the `views` service. Do not use both services at the same time.
 
 Usage:
 

package/contributions.js

@@ -26,6 +26,7 @@ import './vscode/src/vs/workbench/contrib/codeActions/browser/codeActions.contri
 import './vscode/src/vs/workbench/contrib/list/browser/list.contribution.js';
 import './vscode/src/vs/workbench/contrib/codeEditor/browser/editorFeatures.js';
 import './vscode/src/vs/workbench/contrib/contextmenu/browser/contextmenu.contribution.js';
+import './vscode/src/vs/workbench/contrib/mappedEdits/common/mappedEdits.contribution.js';
 let ExtensionPoints = class ExtensionPoints {
     constructor(instantiationService) {
         this.instantiationService = instantiationService;

package/extensions.d.ts

@@ -86,7 +86,7 @@
 /// <reference path="./vscode-dts/vscode.proposed.windowActivity.d.ts" />
 /// <reference path="./vscode-dts/vscode.proposed.workspaceTrust.d.ts" />
 import * as vscode from 'vscode';
-import { IExtensionManifest } from './vscode/src/vs/platform/extensions/common/extensions.js';
+import { IExtension, IExtensionManifest } from './vscode/src/vs/platform/extensions/common/extensions.js';
 export { IExtensionContributions } from './vscode/src/vs/platform/extensions/common/extensions.js';
 import { IDisposable } from './vscode/src/vs/base/common/lifecycle.js';
 export { ITranslations } from './vscode/src/vs/platform/extensionManagement/common/extensionNls.js';
@@ -95,8 +95,10 @@ import { ExtensionHostKind } from './vscode/src/vs/workbench/services/extensions
 type ApiFactory = (extensionId?: string) => Promise<typeof vscode>;
 declare function registerLocalApiFactory(_apiFactory: ApiFactory): void;
 interface RegisterExtensionParams {
-    builtin?: boolean;
     path?: string;
+    system?: boolean;
+    readmePath?: string;
+    changelogPath?: string;
 }
 interface RegisterRemoteExtensionParams extends RegisterExtensionParams {
     path: string;
@@ -116,9 +118,10 @@ interface RegisterLocalProcessExtensionResult extends RegisterLocalExtensionResu
     setAsDefaultApi(): Promise<void>;
 }
 declare function registerRemoteExtension(directory: string): Promise<RegisterRemoteExtensionResult>;
+declare function getExtensionManifests(): IExtension[];
 declare function registerExtension(manifest: IExtensionManifest, extHostKind: ExtensionHostKind.LocalProcess, params?: RegisterExtensionParams): RegisterLocalProcessExtensionResult;
 declare function registerExtension(manifest: IExtensionManifest, extHostKind: ExtensionHostKind.LocalWebWorker, params?: RegisterExtensionParams): RegisterLocalExtensionResult;
 declare function registerExtension(manifest: IExtensionManifest, extHostKind: ExtensionHostKind.Remote, params?: RegisterRemoteExtensionParams): RegisterRemoteExtensionResult;
 declare function registerExtension(manifest: IExtensionManifest, extHostKind?: ExtensionHostKind, params?: RegisterExtensionParams): RegisterExtensionResult;
 
-export { type ApiFactory, ExtensionHostKind, IExtensionManifest, registerExtension, registerLocalApiFactory, registerRemoteExtension };
+export { type ApiFactory, ExtensionHostKind, IExtensionManifest, getExtensionManifests, registerExtension, registerLocalApiFactory, registerRemoteExtension };

package/extensions.js

@@ -49,8 +49,11 @@ async function registerRemoteExtension(directory) {
     const manifest = parse(( content.value.toString()));
     return registerExtension(manifest, 3 , { path: directory });
 }
-function registerExtension(manifest, extHostKind, { builtin = manifest.publisher === 'vscode', path = '/' } = {}) {
-    const disposableStore = new DisposableStore();
+const extensions = [];
+function getExtensionManifests() {
+    return extensions;
+}
+function registerExtension(manifest, extHostKind, { path = '/', system = false, readmePath, changelogPath } = {}) {
     const id = getExtensionId(manifest.publisher, manifest.name);
     const location = ( URI.from({ scheme: CustomSchemas.extensionFile, authority: id, path }));
     const addExtensionPromise = (async () => {
@@ -64,15 +67,20 @@ function registerExtension(manifest, extHostKind, { builtin = manifest.publisher
         const localizedManifest = await translator.translateManifest(realLocation, manifest);
         const extension = {
             manifest: localizedManifest,
-            type: builtin ? 0  : 1 ,
-            isBuiltin: builtin,
+            type: system ? 0  : 1 ,
+            isBuiltin: true,
             identifier: { id },
             location: realLocation,
             targetPlatform: "web" ,
             isValid: true,
             validations: [],
-            extHostKind
+            extHostKind,
+            readmeUrl: readmePath != null ? URI.joinPath(realLocation, readmePath) : undefined,
+            changelogUrl: changelogPath != null ? URI.joinPath(realLocation, changelogPath) : undefined
         };
+        if (extHostKind !== 3 ) {
+            extensions.push(extension);
+        }
         await deltaExtensions({ toAdd: [extension], toRemove: [] });
         return extension;
     })();
@@ -83,8 +91,11 @@ function registerExtension(manifest, extHostKind, { builtin = manifest.publisher
         },
         async dispose() {
             const extension = await addExtensionPromise;
+            const index = extensions.indexOf(extension);
+            if (index >= 0) {
+                extensions.splice(extensions.indexOf(extension), 1);
+            }
             await deltaExtensions({ toAdd: [], toRemove: [extension] });
-            disposableStore.dispose();
         }
     };
     if (extHostKind !== 3 ) {
@@ -114,4 +125,4 @@ function registerExtension(manifest, extHostKind, { builtin = manifest.publisher
     }
     return api;
 }
-export { registerExtension, registerLocalApiFactory, registerRemoteExtension };
+export { getExtensionManifests, registerExtension, registerLocalApiFactory, registerRemoteExtension };

package/lifecycle.js

@@ -1,11 +1,14 @@
 import { Registry } from './vscode/src/vs/platform/registry/common/platform.js';
 import { Extensions } from './vscode/src/vs/workbench/common/contributions.js';
 import { ILifecycleService } from './vscode/src/vs/workbench/services/lifecycle/common/lifecycle.js';
-import { Barrier, RunOnceScheduler, _runWhenIdle } from './vscode/src/vs/base/common/async.js';
+import { Barrier, timeout, RunOnceScheduler, _runWhenIdle } from './vscode/src/vs/base/common/async.js';
 import { Emitter } from './vscode/src/vs/base/common/event.js';
 import { EditorExtensions } from './vscode/src/vs/workbench/common/editor.js';
 import { StandaloneServices } from './vscode/src/vs/editor/standalone/browser/standaloneServices.js';
 import { Disposable } from './vscode/src/vs/base/common/lifecycle.js';
+import { IWorkbenchLayoutService } from './vscode/src/vs/workbench/services/layout/browser/layoutService.js';
+const layoutEmitter = new Emitter();
+const onLayout = layoutEmitter.event;
 const renderWorkbenchEmitter = new Emitter();
 const onRenderWorkbench = renderWorkbenchEmitter.event;
 const serviceInitializedBarrier = new Barrier();
@@ -36,11 +39,16 @@ async function startup(instantiationService) {
     });
     serviceInitializedBarrier.open();
     serviceInitializedEmitter.fire();
-    instantiationService.invokeFunction(accessor => {
+    void instantiationService.invokeFunction(async (accessor) => {
         const lifecycleService = accessor.get(ILifecycleService);
         ( Registry.as(Extensions.Workbench)).start(accessor);
         ( Registry.as(EditorExtensions.EditorFactory)).start(accessor);
+        layoutEmitter.fire(accessor);
         renderWorkbenchEmitter.fire(accessor);
+        await Promise.race([
+            accessor.get(IWorkbenchLayoutService).whenRestored,
+            timeout(2000)
+        ]);
         lifecycleService.phase = 3 ;
         const eventuallyPhaseScheduler = new RunOnceScheduler(() => {
             _runWhenIdle(window, () => {
@@ -68,4 +76,4 @@ function checkServicesNotInitialized() {
         throw new Error('Services are already initialized');
     }
 }
-export { checkServicesNotInitialized, checkServicesReady, onRenderWorkbench, registerServiceInitializeParticipant, registerServiceInitializePostParticipant, registerServiceInitializePreParticipant, serviceInitializedBarrier, serviceInitializedEmitter, startup, waitServicesReady };
+export { checkServicesNotInitialized, checkServicesReady, onLayout, onRenderWorkbench, registerServiceInitializeParticipant, registerServiceInitializePostParticipant, registerServiceInitializePreParticipant, serviceInitializedBarrier, serviceInitializedEmitter, startup, waitServicesReady };

package/missing-services.js

@@ -26,7 +26,7 @@ import { IContextKeyService } from './vscode/src/vs/platform/contextkey/common/c
 import { StandaloneServices } from './vscode/src/vs/editor/standalone/browser/standaloneServices.js';
 import { ICodeEditorService } from './vscode/src/vs/editor/browser/services/codeEditorService.js';
 import { IUserDataProfilesService, toUserDataProfile } from './vscode/src/vs/platform/userDataProfile/common/userDataProfile.js';
-import { IPolicyService } from './vscode/src/vs/platform/policy/common/policy.js';
+import { NullPolicyService, IPolicyService } from './vscode/src/vs/platform/policy/common/policy.js';
 import { IUserDataProfileService, IUserDataProfileImportExportService, IUserDataProfileManagementService } from './vscode/src/vs/workbench/services/userDataProfile/common/userDataProfile.js';
 import { UserDataProfileService } from './vscode/src/vs/workbench/services/userDataProfile/common/userDataProfileService.js';
 import { ISnippetsService } from './vscode/src/vs/workbench/contrib/snippets/browser/snippets.js';
@@ -186,6 +186,11 @@ import { IInlineChatSessionService } from './vscode/src/vs/workbench/contrib/inl
 import { IInlineChatSavingService } from './vscode/src/vs/workbench/contrib/inlineChat/browser/inlineChatSavingService.js';
 import { INotebookDocumentService } from './vscode/src/vs/workbench/services/notebook/common/notebookDocumentService.js';
 import { IDebugVisualizerService } from './vscode/src/vs/workbench/contrib/debug/common/debugVisualizers.js';
+import { IEditSessionsLogService, IEditSessionsStorageService } from './vscode/src/vs/workbench/contrib/editSessions/common/editSessions.js';
+import { IMultiDiffSourceResolverService } from './vscode/src/vs/workbench/contrib/multiDiffEditor/browser/multiDiffSourceResolverService.js';
+import { IInteractiveHistoryService } from './vscode/src/vs/workbench/contrib/interactive/browser/interactiveHistoryService.js';
+import { IWorkspaceTagsService } from './vscode/src/vs/workbench/contrib/tags/common/workspaceTags.js';
+import { NoOpWorkspaceTagsService } from './vscode/src/vs/workbench/contrib/tags/browser/workspaceTagsService.js';
 import { unsupported } from './tools.js';
 import { getBuiltInExtensionTranslationsUris } from './l10n.js';
 import { IFileDialogService } from './vscode/src/vs/platform/dialogs/common/dialogs.js';
@@ -680,15 +685,7 @@ InjectedUserDataProfileService = __decorate([
     ( __param(0, IEnvironmentService))
 ], InjectedUserDataProfileService);
 registerSingleton(IUserDataProfileService, InjectedUserDataProfileService, 0 );
-registerSingleton(IPolicyService, class PolicyService {
-    constructor() {
-        this.updatePolicyDefinitions = unsupported;
-        this.onDidChange = Event.None;
-        this.registerPolicyDefinitions = unsupported;
-        this.getPolicyValue = () => undefined;
-        this.serialize = () => undefined;
-    }
-}, 0 );
+registerSingleton(IPolicyService, NullPolicyService, 0 );
 registerSingleton(ISnippetsService, class SnippetsService {
     constructor() {
         this.getSnippetFiles = unsupported;
@@ -2271,6 +2268,16 @@ registerSingleton(INotebookRendererMessagingService, class NotebookRendererMessa
         this.receiveMessage = unsupported;
     }
 }, 1 );
+registerSingleton(IInteractiveHistoryService, class InteractiveHistoryService {
+    constructor() {
+        this.addToHistory = unsupported;
+        this.getPreviousValue = unsupported;
+        this.getNextValue = unsupported;
+        this.replaceLast = unsupported;
+        this.clearHistory = unsupported;
+        this.has = unsupported;
+    }
+}, 1 );
 registerSingleton(IInteractiveDocumentService, class InteractiveDocumentService {
     constructor() {
         this.onWillAddInteractiveDocument = Event.None;
@@ -2930,3 +2937,41 @@ registerSingleton(IDebugVisualizerService, class DebugVisualizerService {
         this.register = unsupported;
     }
 }, 1 );
+registerSingleton(IEditSessionsLogService, class EditSessionsLogService {
+    constructor() {
+        this.onDidChangeLogLevel = Event.None;
+        this.getLevel = unsupported;
+        this.setLevel = unsupported;
+        this.trace = unsupported;
+        this.debug = unsupported;
+        this.info = unsupported;
+        this.warn = unsupported;
+        this.error = unsupported;
+        this.flush = unsupported;
+        this.dispose = unsupported;
+    }
+}, 1 );
+registerSingleton(IEditSessionsStorageService, class EditSessionsWorkbenchService {
+    constructor() {
+        this.SIZE_LIMIT = 0;
+        this.isSignedIn = false;
+        this.onDidSignIn = Event.None;
+        this.onDidSignOut = Event.None;
+        this.storeClient = undefined;
+        this.lastReadResources = new Map();
+        this.lastWrittenResources = new Map();
+        this.initialize = unsupported;
+        this.read = unsupported;
+        this.write = unsupported;
+        this.delete = unsupported;
+        this.list = unsupported;
+        this.getMachineById = unsupported;
+    }
+}, 1 );
+registerSingleton(IMultiDiffSourceResolverService, class MultiDiffSourceResolverService {
+    constructor() {
+        this.registerResolver = unsupported;
+        this.resolve = unsupported;
+    }
+}, 1 );
+registerSingleton(IWorkspaceTagsService, NoOpWorkspaceTagsService, 1 );

package/monaco.js

@@ -34,6 +34,7 @@ import { ICodeEditorService } from './vscode/src/vs/editor/browser/services/code
 import { IKeybindingService } from './vscode/src/vs/platform/keybinding/common/keybinding.js';
 import { Emitter } from './vscode/src/vs/base/common/event.js';
 import { createInjectedClass } from './tools/injection.js';
+import { getService } from './services.js';
 function computeConfiguration(configuration, overrides) {
     const editorConfiguration = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null);
     Object.assign(editorConfiguration, deepClone(overrides));
@@ -164,16 +165,19 @@ ConfiguredStandaloneDiffEditor = __decorate([
     ( __param(3, ITextResourceConfigurationService))
 ], ConfiguredStandaloneDiffEditor);
 async function writeFile(uri, content) {
-    await StandaloneServices.get(IFileService).writeFile(uri, VSBuffer.fromString(content));
+    const fileService = await getService(IFileService);
+    await fileService.writeFile(uri, VSBuffer.fromString(content));
 }
 async function deleteFile(uri, options) {
-    await StandaloneServices.get(IFileService).del(uri, options);
+    const fileService = await getService(IFileService);
+    await fileService.del(uri, options);
 }
 async function createModelReference(resource, content) {
     if (content != null) {
         await writeFile(resource, content);
     }
-    return (await StandaloneServices.get(ITextModelService).createModelReference(resource));
+    const textModelService = await getService(ITextModelService);
+    return (await textModelService.createModelReference(resource));
 }
 function isDynamicKeybindingService(keybindingService) {
     return keybindingService.registerKeybindingProvider != null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "2.1.4",
+  "version": "2.2.0-next.1",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -96,12 +96,12 @@
   "dependencies": {
     "vscode-marked": "npm:marked@=3.0.2",
     "vscode-semver": "npm:semver@=5.5.0",
-    "@codingame/monaco-vscode-extensions-service-override": "2.1.4",
-    "@codingame/monaco-vscode-files-service-override": "2.1.4",
-    "@codingame/monaco-vscode-quickaccess-service-override": "2.1.4",
-    "@codingame/monaco-vscode-environment-service-override": "2.1.4",
-    "@codingame/monaco-vscode-layout-service-override": "2.1.4",
-    "@codingame/monaco-vscode-host-service-override": "2.1.4",
-    "@codingame/monaco-vscode-base-service-override": "2.1.4"
+    "@codingame/monaco-vscode-quickaccess-service-override": "2.2.0-next.1",
+    "@codingame/monaco-vscode-files-service-override": "2.2.0-next.1",
+    "@codingame/monaco-vscode-extensions-service-override": "2.2.0-next.1",
+    "@codingame/monaco-vscode-environment-service-override": "2.2.0-next.1",
+    "@codingame/monaco-vscode-layout-service-override": "2.2.0-next.1",
+    "@codingame/monaco-vscode-host-service-override": "2.2.0-next.1",
+    "@codingame/monaco-vscode-base-service-override": "2.2.0-next.1"
   }
 }

package/service-override/tools/views.d.ts

@@ -0,0 +1,98 @@
+import { ViewContainerLocation, ViewContainer } from '../../vscode/src/vs/workbench/common/views.js';
+import { BrandedService, ServicesAccessor } from '../../vscode/src/vs/platform/instantiation/common/instantiation.js';
+import { IDisposable } from '../../vscode/src/vs/base/common/lifecycle.js';
+import { Dimension } from '../../vscode/src/vs/base/browser/dom.js';
+import { URI } from '../../vscode/src/vs/base/common/uri.js';
+import { Codicon } from '../../vscode/src/vs/base/common/codicons.js';
+import { RegisteredEditorInfo, RegisteredEditorOptions, EditorInputFactoryObject } from '../../vscode/src/vs/workbench/services/editor/common/editorResolverService.js';
+export { RegisteredEditorPriority } from '../../vscode/src/vs/workbench/services/editor/common/editorResolverService.js';
+import { EditorInput, IEditorCloseHandler } from '../../vscode/src/vs/workbench/common/editor/editorInput.js';
+import { IEditorOpenContext, EditorInputCapabilities, Verbosity, IEditorSerializer } from '../../vscode/src/vs/workbench/common/editor.js';
+import { IEditorOptions } from '../../vscode/src/vs/platform/editor/common/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 { CancellationToken } from '../../vscode/src/vs/base/common/cancellation.js';
+import { Event } from '../../vscode/src/vs/base/common/event.js';
+import '../../vscode/src/vs/editor/editor.api.js';
+import { Parts, Position } from '../../vscode/src/vs/workbench/services/layout/browser/layoutService.js';
+
+type Label = string | {
+    short: string;
+    medium: string;
+    long: string;
+};
+declare abstract class SimpleEditorPane extends EditorPane {
+    protected container: HTMLElement;
+    private scrollbar;
+    private inputDisposable;
+    constructor(id: string, telemetryService: ITelemetryService, themeService: IThemeService, storageService: IStorageService);
+    protected createEditor(parent: HTMLElement): void;
+    setInput(input: EditorInput, editorOptions: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    layout(dimension: Dimension): void;
+    focus(): void;
+    clearInput(): void;
+    abstract initialize(): HTMLElement;
+    abstract renderInput?(input: EditorInput, options: IEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<IDisposable>;
+}
+declare abstract class SimpleEditorInput extends EditorInput {
+    closeHandler?: IEditorCloseHandler | undefined;
+    private dirty;
+    private _capabilities;
+    private name;
+    private title;
+    private description;
+    resource: URI | undefined;
+    constructor(resource?: URI, closeHandler?: IEditorCloseHandler | undefined);
+    get capabilities(): EditorInputCapabilities;
+    addCapability(capability: EditorInputCapabilities): void;
+    removeCapability(capability: EditorInputCapabilities): void;
+    get editorId(): string | undefined;
+    setName(name: string): void;
+    setTitle(title: Label): void;
+    setDescription(description: string): void;
+    private getLabelValue;
+    getName(): string;
+    getTitle(verbosity?: Verbosity): string;
+    getDescription(verbosity?: Verbosity): string;
+    isDirty(): boolean;
+    setDirty(dirty: boolean): void;
+}
+declare function registerEditorPane<Services extends BrandedService[]>(typeId: string, name: string, ctor: new (...services: Services) => EditorPane, inputCtors: (new (...args: any[]) => EditorInput)[]): IDisposable;
+declare function registerEditor(globPattern: string, editorInfo: RegisteredEditorInfo, editorOptions: RegisteredEditorOptions, factory: EditorInputFactoryObject): IDisposable;
+declare function registerEditorSerializer<Services extends BrandedService[]>(editorTypeId: string, ctor: {
+    new (...Services: Services): IEditorSerializer;
+}): IDisposable;
+interface CustomViewOption {
+    readonly id: string;
+    name: string;
+    order?: number;
+    renderBody(container: HTMLElement): IDisposable;
+    location: ViewContainerLocation;
+    icon?: string;
+    canMoveView?: boolean;
+    default?: boolean;
+    actions?: {
+        id: string;
+        title: string;
+        tooltip?: string;
+        order?: number;
+        run?(accessor: ServicesAccessor): Promise<void>;
+        icon?: keyof typeof Codicon;
+        render?(container: HTMLElement): void;
+    }[];
+    viewContainer?: ViewContainer;
+    canToggleVisibility?: boolean;
+    hideByDefault?: boolean;
+    collapsed?: boolean;
+}
+declare function registerCustomView(options: CustomViewOption): IDisposable;
+declare function isPartVisibile(part: Parts): boolean;
+declare function setPartVisibility(part: Exclude<Parts, Parts.STATUSBAR_PART | Parts.TITLEBAR_PART>, visible: boolean): void;
+declare const onDidChangePanelPosition: Event<string>;
+declare function getPanelPosition(): Position;
+declare const onDidChangeSideBarPosition: Event<string>;
+declare function getSideBarPosition(): Position;
+
+export { type CustomViewOption, EditorInput, EditorInputCapabilities, EditorInputFactoryObject, EditorPane, IEditorCloseHandler, IEditorSerializer, Parts, RegisteredEditorInfo, RegisteredEditorOptions, SimpleEditorInput, SimpleEditorPane, ViewContainerLocation, getPanelPosition, getSideBarPosition, isPartVisibile, onDidChangePanelPosition, onDidChangeSideBarPosition, registerCustomView, registerEditor, registerEditorPane, registerEditorSerializer, setPartVisibility };

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 };