@codingame/monaco-vscode-api 1.81.3 → 1.81.5-next.0

package/dist/monaco.d.ts

@@ -2,7 +2,7 @@ import { create, createDiffEditor } from './vscode/vs/editor/standalone/browser/
 export { errorHandler } from './vscode/vs/base/common/errors.js';
 export { FoldingModel, setCollapseStateForMatchingLines } from './vscode/vs/editor/contrib/folding/browser/foldingModel.js';
 export { FoldingController } from './vscode/vs/editor/contrib/folding/browser/folding.js';
-import { IReference } from './vscode/vs/base/common/lifecycle.js';
+import { IReference, IDisposable } from './vscode/vs/base/common/lifecycle.js';
 export { DisposableStore } from './vscode/vs/base/common/lifecycle.js';
 export { Registry } from './vscode/vs/platform/registry/common/platform.js';
 export { IJSONContributionRegistry } from './vscode/vs/platform/jsonschemas/common/jsonContributionRegistry.js';
@@ -12,10 +12,17 @@ export { registerColor } from './vscode/vs/platform/theme/common/colorRegistry.j
 import { URI } from './vscode/vs/base/common/uri.js';
 import { IFileDeleteOptions } from './vscode/vs/platform/files/common/files.js';
 import { ITextFileEditorModel } from './vscode/vs/workbench/services/textfile/common/textfiles.js';
+import { IKeybindingService } from './vscode/vs/platform/keybinding/common/keybinding.js';
+import { KeybindingResolver } from './vscode/vs/platform/keybinding/common/keybindingResolver.js';
+import { ResolvedKeybindingItem } from './vscode/vs/platform/keybinding/common/resolvedKeybindingItem.js';
 
 declare function writeFile(uri: URI, content: string): Promise<void>;
 declare function deleteFile(uri: URI, options?: Partial<IFileDeleteOptions>): Promise<void>;
 declare function createModelReference(resource: URI, content?: string): Promise<IReference<ITextFileEditorModel>>;
+interface DynamicKeybindingService extends IKeybindingService {
+    registerKeybindingProvider(provider: () => ResolvedKeybindingItem[]): IDisposable;
+    _getResolver(): KeybindingResolver;
+}
 declare const createConfiguredEditor: typeof create;
 declare const createConfiguredDiffEditor: typeof createDiffEditor;
 declare const Extensions: {
@@ -23,4 +30,4 @@ declare const Extensions: {
     JSONContribution: string;
 };
 
-export { Extensions, IReference, ITextFileEditorModel, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, writeFile };
+export { DynamicKeybindingService, Extensions, IReference, ITextFileEditorModel, createConfiguredDiffEditor, createConfiguredEditor, createModelReference, deleteFile, writeFile };

package/dist/monaco.js

@@ -33,8 +33,6 @@ import { INotificationService } from 'monaco-editor/esm/vs/platform/notification
 import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
 import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
 import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { KeybindingResolver } from 'monaco-editor/esm/vs/platform/keybinding/common/keybindingResolver.js';
-import { WorkbenchKeybindingService } from './vscode/vs/workbench/services/keybinding/browser/keybindingService.js';
 import { createInjectedClass } from './tools/injection.js';
 import './vscode/vs/workbench/contrib/codeEditor/browser/workbenchReferenceSearch.js';
 import './vscode/vs/workbench/contrib/codeEditor/browser/menuPreventer.js';
@@ -135,25 +133,17 @@ async function createModelReference(resource, content) {
     }
     return (await StandaloneServices.get(ITextModelService).createModelReference(resource));
 }
+function isDynamicKeybindingService(keybindingService) {
+    return keybindingService.registerKeybindingProvider != null;
+}
 let DelegateStandaloneKeybindingService = class DelegateStandaloneKeybindingService extends StandaloneKeybindingService {
     constructor(delegate, contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService) {
         super(contextKeyService, commandService, telemetryService, notificationService, logService, codeEditorService);
         this.delegate = delegate;
-        this._cachedOverridenResolver = null;
-        this.onDidUpdateKeybindings(() => {
-            this._cachedOverridenResolver = null;
-        });
-        this.delegate.onDidUpdateKeybindings(() => {
-            this._cachedOverridenResolver = null;
-        });
+        this._register(delegate.registerKeybindingProvider(() => this.getUserKeybindingItems()));
     }
     _getResolver() {
-        if (this._cachedOverridenResolver == null) {
-            const overrides = this['_toNormalizedKeybindingItems'](this['_dynamicKeybindings'], false);
-            this._cachedOverridenResolver = new KeybindingResolver(
-            [...this.delegate['_getResolver']().getKeybindings()], overrides, (str) => this._log(str));
-        }
-        return this._cachedOverridenResolver;
+        return this.delegate._getResolver();
     }
 };
 DelegateStandaloneKeybindingService = __decorate([
@@ -170,7 +160,7 @@ function getStandaloneEditorInstantiationService() {
         const serviceCollection = new ServiceCollection();
         serviceCollection.set(IQuickInputService, new SyncDescriptor(StandaloneQuickInputService, undefined, true));
         const keybindingService = StandaloneServices.get(IKeybindingService);
-        if (keybindingService instanceof WorkbenchKeybindingService) {
+        if (!(keybindingService instanceof StandaloneKeybindingService) && isDynamicKeybindingService(keybindingService)) {
             serviceCollection.set(IKeybindingService, new SyncDescriptor(DelegateStandaloneKeybindingService, [keybindingService], true));
         }
         standaloneEditorInstantiationService = StandaloneServices.get(IInstantiationService).createChild(serviceCollection);

package/dist/service-override/keybindings.js

@@ -10,6 +10,7 @@ import { BrowserKeyboardLayoutService } from '../vscode/vs/workbench/services/ke
 import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
 import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 import { CommandService } from '../vscode/vs/workbench/services/commands/common/commandService.js';
+import { toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import getServiceOverride$1 from './files.js';
 import '../vscode/vs/workbench/browser/workbench.contribution.js';
 import '../vscode/vs/workbench/contrib/keybindings/browser/keybindings.contribution.js';
@@ -17,10 +18,33 @@ async function updateUserKeybindings(keybindingsJson) {
     const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
     await StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.keybindingsResource, VSBuffer.fromString(keybindingsJson));
 }
+class DynamicWorkbenchKeybindingService extends WorkbenchKeybindingService {
+    constructor() {
+        super(...arguments);
+        this.keybindingProviders = [];
+    }
+    registerKeybindingProvider(provider) {
+        this.keybindingProviders.push(provider);
+        this.updateResolver();
+        return toDisposable(() => {
+            const idx = this.keybindingProviders.indexOf(provider);
+            if (idx >= 0) {
+                this.keybindingProviders.splice(idx, 1);
+                this.updateResolver();
+            }
+        });
+    }
+    _getResolver() {
+        return super._getResolver();
+    }
+    getUserKeybindingItems() {
+        return [...super.getUserKeybindingItems(), ...this.keybindingProviders.flatMap(provider => provider())];
+    }
+}
 function getServiceOverride() {
     return {
         ...getServiceOverride$1(),
-        [( IKeybindingService.toString())]: new SyncDescriptor(WorkbenchKeybindingService, [], false),
+        [( IKeybindingService.toString())]: new SyncDescriptor(DynamicWorkbenchKeybindingService, [], false),
         [( IKeyboardLayoutService.toString())]: new SyncDescriptor(BrowserKeyboardLayoutService, undefined, true),
         [( ICommandService.toString())]: new SyncDescriptor(CommandService, [], true)
     };

package/dist/service-override/storage.d.ts

@@ -37,4 +37,4 @@ declare class InjectedBrowserStorageService extends BrowserStorageService {
 }
 declare function getStorageServiceOverride(provider?: IStorageProvider): IEditorOverrideServices;
 
-export { ExternalStorageService, IStorageItemsChangeEvent, IStorageProvider, InjectedBrowserStorageService, StorageScope, getStorageServiceOverride as default };
+export { InjectedBrowserStorageService as BrowserStorageService, ExternalStorageService, IStorageItemsChangeEvent, IStorageProvider, StorageScope, getStorageServiceOverride as default };

package/dist/service-override/storage.js

@@ -113,4 +113,4 @@ function getStorageServiceOverride(provider) {
         };
     }
 }
-export { ExternalStorageService, InjectedBrowserStorageService, StorageScope, getStorageServiceOverride as default };
+export { InjectedBrowserStorageService as BrowserStorageService, ExternalStorageService, StorageScope, getStorageServiceOverride as default };

package/dist/service-override/views.js

@@ -93,6 +93,7 @@ import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/st
 import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 export { ConfirmResult } from '../override/vs/platform/dialogs/common/dialogs.js';
 import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { StandaloneCodeEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
 import { wrapOpenEditor } from './tools/editor.js';
 import getServiceOverride$2 from './bulkEdit.js';
 import getServiceOverride$1 from './layout.js';
@@ -350,9 +351,21 @@ let EditorDropService = class EditorDropService {
 EditorDropService = __decorate([
     ( __param(0, IEditorGroupsService))
 ], EditorDropService);
+function isElementVisible(el) {
+    if (!el.isConnected) {
+        return false;
+    }
+    if (el.checkVisibility != null) {
+        return el.checkVisibility({
+            checkOpacity: true,
+            checkVisibilityCSS: true
+        });
+    }
+    return el.offsetHeight > 0 && el.offsetWidth > 0;
+}
 function isEditorPartVisible() {
-    const editorPart = StandaloneServices.get(IEditorGroupsService);
-    return editorPart.getContainer()?.isConnected ?? false;
+    const container = StandaloneServices.get(IEditorGroupsService).getContainer();
+    return container != null && isElementVisible(container);
 }
 let MonacoEditorService = class MonacoEditorService extends EditorService {
     constructor(_openEditorFallback, _editorGroupService, instantiationService, fileService, configurationService, contextService, uriIdentityService, editorResolverService, workspaceTrustRequestService, hostService, textEditorService, textModelService) {
@@ -360,7 +373,11 @@ let MonacoEditorService = class MonacoEditorService extends EditorService {
         this.openEditor = wrapOpenEditor(textModelService, this.openEditor.bind(this), _openEditorFallback);
     }
     get activeTextEditorControl() {
-        return super.activeTextEditorControl ?? StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor() ?? undefined;
+        const focusedCodeEditor = StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor();
+        if (focusedCodeEditor != null && focusedCodeEditor instanceof StandaloneCodeEditor) {
+            return focusedCodeEditor;
+        }
+        return super.activeTextEditorControl;
     }
     async openEditor(editor, optionsOrPreferredGroup, preferredGroup) {
         if (!isEditorPartVisible()) {

package/dist/vscode/vs/platform/keybinding/common/keybindingResolver.d.ts

@@ -1,3 +1,6 @@
+import { ContextKeyExpression, IContextKeyService, IContext } from '../../contextkey/common/contextkey.js';
+import { ResolvedKeybindingItem } from './resolvedKeybindingItem.js';
+
 declare const enum ResultKind {
     /** No keybinding found this sequence of chords */
     NoMatchingKb = 0,
@@ -16,5 +19,48 @@ type ResolutionResult = {
     commandArgs: any;
     isBubble: boolean;
 };
+/**
+ * Stores mappings from keybindings to commands and from commands to keybindings.
+ * Given a sequence of chords, `resolve`s which keybinding it matches
+ */
+declare class KeybindingResolver {
+    private readonly _log;
+    private readonly _defaultKeybindings;
+    private readonly _keybindings;
+    private readonly _defaultBoundCommands;
+    private readonly _map;
+    private readonly _lookupMap;
+    constructor(
+    /** built-in and extension-provided keybindings */
+    defaultKeybindings: ResolvedKeybindingItem[], 
+    /** user's keybindings */
+    overrides: ResolvedKeybindingItem[], log: (str: string) => void);
+    private static _isTargetedForRemoval;
+    /**
+     * Looks for rules containing "-commandId" and removes them.
+     */
+    static handleRemovals(rules: ResolvedKeybindingItem[]): ResolvedKeybindingItem[];
+    private _addKeyPress;
+    private _addToLookupMap;
+    private _removeFromLookupMap;
+    /**
+     * Returns true if it is provable `a` implies `b`.
+     */
+    static whenIsEntirelyIncluded(a: ContextKeyExpression | null | undefined, b: ContextKeyExpression | null | undefined): boolean;
+    getDefaultBoundCommands(): Map<string, boolean>;
+    getDefaultKeybindings(): readonly ResolvedKeybindingItem[];
+    getKeybindings(): readonly ResolvedKeybindingItem[];
+    lookupKeybindings(commandId: string): ResolvedKeybindingItem[];
+    lookupPrimaryKeybinding(commandId: string, context: IContextKeyService): ResolvedKeybindingItem | null;
+    /**
+     * Looks up a keybinding trigged as a result of pressing a sequence of chords - `[...currentChords, keypress]`
+     *
+     * Example: resolving 3 chords pressed sequentially - `cmd+k cmd+p cmd+i`:
+     * 	`currentChords = [ 'cmd+k' , 'cmd+p' ]` and `keypress = `cmd+i` - last pressed chord
+     */
+    resolve(context: IContext, currentChords: string[], keypress: string): ResolutionResult;
+    private _findCommand;
+    private static _contextMatchesRules;
+}
 
-export { ResolutionResult, ResultKind };
+export { KeybindingResolver, ResolutionResult, ResultKind };

package/dist/vscode/vs/workbench/api/worker/extensionHostWorker.js

@@ -98,6 +98,9 @@ function patchWorker(asBrowserUri, getAllStaticBrowserUris) {
                     self.importScripts = (...urls) => {
                         nativeImportScripts(...( urls.map(asWorkerBrowserUrl)));
                     };
+                    self.importExt = (url) => {
+                        return ( new Function('url', 'return import(url)'))(asWorkerBrowserUrl(url));
+                    };
                     nativeImportScripts(workerUrl);
                 }).toString());
                 const js = `(${bootstrapFnSource}('${browserUrl}', ${JSON.stringify(staticBrowserUrls)}))`;

package/dist/vscode/vs/workbench/services/keybinding/browser/keybindingService.js

@@ -344,10 +344,13 @@ let WorkbenchKeybindingService = class WorkbenchKeybindingService extends Abstra
         this._cachedResolver = null;
         this._onDidUpdateKeybindings.fire();
     }
+    getUserKeybindingItems() {
+        return this._resolveUserKeybindingItems(this.userKeybindings.keybindings, false);
+    }
     _getResolver() {
         if (!this._cachedResolver) {
             const defaults = this._resolveKeybindingItems(KeybindingsRegistry.getDefaultKeybindings(), true);
-            const overrides = this._resolveUserKeybindingItems(this.userKeybindings.keybindings, false);
+            const overrides = this.getUserKeybindingItems();
             this._cachedResolver = ( new KeybindingResolver(defaults, overrides, (str) => this._log(str)));
         }
         return this._cachedResolver;