@codingame/monaco-vscode-api 1.78.4-next.0 → 1.78.4-next.1

package/dist/extensions2.js

@@ -0,0 +1,77 @@
+import { equalsIgnoreCase } from 'monaco-editor/esm/vs/base/common/strings.js';
+const EXTENSION_CATEGORIES = [
+    'Azure',
+    'Data Science',
+    'Debuggers',
+    'Extension Packs',
+    'Education',
+    'Formatters',
+    'Keymaps',
+    'Language Packs',
+    'Linters',
+    'Machine Learning',
+    'Notebooks',
+    'Programming Languages',
+    'SCM Providers',
+    'Snippets',
+    'Testing',
+    'Themes',
+    'Visualization',
+    'Other',
+];
+class ExtensionIdentifier {
+    constructor(value) {
+        this.value = value;
+        this._lower = value.toLowerCase();
+    }
+    static equals(a, b) {
+        if (typeof a === 'undefined' || a === null) {
+            return (typeof b === 'undefined' || b === null);
+        }
+        if (typeof b === 'undefined' || b === null) {
+            return false;
+        }
+        if (typeof a === 'string' || typeof b === 'string') {
+            const aValue = (typeof a === 'string' ? a : a.value);
+            const bValue = (typeof b === 'string' ? b : b.value);
+            return equalsIgnoreCase(aValue, bValue);
+        }
+        return (a._lower === b._lower);
+    }
+    static toKey(id) {
+        if (typeof id === 'string') {
+            return id.toLowerCase();
+        }
+        return id._lower;
+    }
+}
+class ExtensionIdentifierMap {
+    constructor() {
+        this._map = ( new Map());
+    }
+    clear() {
+        this._map.clear();
+    }
+    delete(id) {
+        this._map.delete(ExtensionIdentifier.toKey(id));
+    }
+    get(id) {
+        return this._map.get(ExtensionIdentifier.toKey(id));
+    }
+    has(id) {
+        return this._map.has(ExtensionIdentifier.toKey(id));
+    }
+    set(id, value) {
+        this._map.set(ExtensionIdentifier.toKey(id), value);
+    }
+    values() {
+        return ( this._map.values());
+    }
+    forEach(callbackfn) {
+        this._map.forEach(callbackfn);
+    }
+    [Symbol.iterator]() {
+        return this._map[Symbol.iterator]();
+    }
+}
+export { EXTENSION_CATEGORIES, ExtensionIdentifierMap };

package/dist/keybindings.js

@@ -1,13 +1,13 @@
-import { isProposedApiEnabled, __decorate, index, __param, IUserDataProfilesService, IFileService, IKeyboardLayoutService, IEditorService, IExtensionService, IEditorGroupsService, IPreferencesService, IProductService, Emitter, getKeyboardLayoutId, IUserDataProfileService, IHostService, parse$1, getNodeType, FallbackKeyboardMapper } from './polyfill.js';
+import { __decorate, __param, IUserDataProfilesService, IFileService, IKeyboardLayoutService, index, IEditorService, IExtensionService, IEditorGroupsService, IPreferencesService, IProductService, Emitter, getKeyboardLayoutId, IUserDataProfileService, IHostService, parse$1, getNodeType, FallbackKeyboardMapper } from './polyfill.js';
 import { KeyCodeChord, ScanCodeChord, Keybinding } from 'monaco-editor/esm/vs/base/common/keybindings.js';
 import { KeyCodeUtils, IMMUTABLE_CODE_TO_KEY_CODE, NATIVE_WINDOWS_KEY_CODE_TO_KEY_CODE, IMMUTABLE_KEY_CODE_TO_CODE } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
 import { ExtensionsRegistry } from './extensionsRegistry.js';
 import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
 import { joinPath, dirname } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { MenuId, MenuRegistry, MenuItemAction, Action2, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { MenuRegistry, MenuId, MenuItemAction, Action2, IMenuService } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
 import { ContextKeyExpr, IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { DisposableStore, Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
 import { isFalsyOrWhitespace } from 'monaco-editor/esm/vs/base/common/strings.js';
 import { getAllUnboundCommands } from './unboundCommands.js';
 import { AbstractKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/abstractKeybindingService.js';
@@ -1334,183 +1334,6 @@ commandsExtensionPoint.setHandler(extensions => {
         }
     }
 });
-const _submenus = ( (new Map()));
-const submenusExtensionPoint = ( (ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'submenus',
-    jsonSchema: schema.submenusContribution
-})));
-submenusExtensionPoint.setHandler(extensions => {
-    _submenus.clear();
-    for (const extension of extensions) {
-        const { value, collector } = extension;
-        for (const [, submenuInfo] of Object.entries(value)) {
-            if (!schema.isValidSubmenu(submenuInfo, collector)) {
-                continue;
-            }
-            if (!submenuInfo.id) {
-                collector.warn(( (localize(
-                    'submenuId.invalid.id',
-                    "`{0}` is not a valid submenu identifier",
-                    submenuInfo.id
-                ))));
-                continue;
-            }
-            if (_submenus.has(submenuInfo.id)) {
-                collector.info(( (localize(
-                    'submenuId.duplicate.id',
-                    "The `{0}` submenu was already previously registered.",
-                    submenuInfo.id
-                ))));
-                continue;
-            }
-            if (!submenuInfo.label) {
-                collector.warn(( (localize(
-                    'submenuId.invalid.label',
-                    "`{0}` is not a valid submenu label",
-                    submenuInfo.label
-                ))));
-                continue;
-            }
-            let absoluteIcon;
-            if (submenuInfo.icon) {
-                if (typeof submenuInfo.icon === 'string') {
-                    absoluteIcon = ThemeIcon.fromString(submenuInfo.icon) || { dark: joinPath(extension.description.extensionLocation, submenuInfo.icon) };
-                }
-                else {
-                    absoluteIcon = {
-                        dark: joinPath(extension.description.extensionLocation, submenuInfo.icon.dark),
-                        light: joinPath(extension.description.extensionLocation, submenuInfo.icon.light)
-                    };
-                }
-            }
-            const item = {
-                id: MenuId.for(`api:${submenuInfo.id}`),
-                label: submenuInfo.label,
-                icon: absoluteIcon
-            };
-            _submenus.set(submenuInfo.id, item);
-        }
-    }
-});
-const _apiMenusByKey = ( (new Map( (apiMenus.map(menu => ([menu.key, menu]))))));
-const _menuRegistrations = ( (new DisposableStore()));
-const _submenuMenuItems = ( (new Map()));
-const menusExtensionPoint = ( (ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'menus',
-    jsonSchema: schema.menusContribution,
-    deps: [submenusExtensionPoint]
-})));
-menusExtensionPoint.setHandler(extensions => {
-    _menuRegistrations.clear();
-    _submenuMenuItems.clear();
-    for (const extension of extensions) {
-        const { value, collector } = extension;
-        for (const entry of Object.entries(value)) {
-            if (!schema.isValidItems(entry[1], collector)) {
-                continue;
-            }
-            let menu = _apiMenusByKey.get(entry[0]);
-            if (!menu) {
-                const submenu = _submenus.get(entry[0]);
-                if (submenu) {
-                    menu = {
-                        key: entry[0],
-                        id: submenu.id,
-                        description: ''
-                    };
-                }
-            }
-            if (!menu) {
-                continue;
-            }
-            if (menu.proposed && !isProposedApiEnabled(extension.description, menu.proposed)) {
-                collector.error(( (localize(
-                    'proposedAPI.invalid',
-                    "{0} is a proposed menu identifier. It requires 'package.json#enabledApiProposals: [\"{1}\"]' and is only available when running out of dev or with the following command line switch: --enable-proposed-api {2}",
-                    entry[0],
-                    menu.proposed,
-                    extension.description.identifier.value
-                ))));
-                continue;
-            }
-            for (const menuItem of entry[1]) {
-                let item;
-                if (schema.isMenuItem(menuItem)) {
-                    const command = MenuRegistry.getCommand(menuItem.command);
-                    const alt = menuItem.alt && MenuRegistry.getCommand(menuItem.alt) || undefined;
-                    if (!command) {
-                        collector.error(( (localize(
-                            'missing.command',
-                            "Menu item references a command `{0}` which is not defined in the 'commands' section.",
-                            menuItem.command
-                        ))));
-                        continue;
-                    }
-                    if (menuItem.alt && !alt) {
-                        collector.warn(( (localize(
-                            'missing.altCommand',
-                            "Menu item references an alt-command `{0}` which is not defined in the 'commands' section.",
-                            menuItem.alt
-                        ))));
-                    }
-                    if (menuItem.command === menuItem.alt) {
-                        collector.info(( (localize(
-                            'dupe.command',
-                            "Menu item references the same command as default and alt-command"
-                        ))));
-                    }
-                    item = { command, alt, group: undefined, order: undefined, when: undefined };
-                }
-                else {
-                    if (menu.supportsSubmenus === false) {
-                        collector.error(( (localize(
-                            'unsupported.submenureference',
-                            "Menu item references a submenu for a menu which doesn't have submenu support."
-                        ))));
-                        continue;
-                    }
-                    const submenu = _submenus.get(menuItem.submenu);
-                    if (!submenu) {
-                        collector.error(( (localize(
-                            'missing.submenu',
-                            "Menu item references a submenu `{0}` which is not defined in the 'submenus' section.",
-                            menuItem.submenu
-                        ))));
-                        continue;
-                    }
-                    let submenuRegistrations = _submenuMenuItems.get(menu.id.id);
-                    if (!submenuRegistrations) {
-                        submenuRegistrations = ( (new Set()));
-                        _submenuMenuItems.set(menu.id.id, submenuRegistrations);
-                    }
-                    if (submenuRegistrations.has(submenu.id.id)) {
-                        collector.warn(( (localize(
-                            'submenuItem.duplicate',
-                            "The `{0}` submenu was already contributed to the `{1}` menu.",
-                            menuItem.submenu,
-                            entry[0]
-                        ))));
-                        continue;
-                    }
-                    submenuRegistrations.add(submenu.id.id);
-                    item = { submenu: submenu.id, icon: submenu.icon, title: submenu.label, group: undefined, order: undefined, when: undefined };
-                }
-                if (menuItem.group) {
-                    const idx = menuItem.group.lastIndexOf('@');
-                    if (idx > 0) {
-                        item.group = menuItem.group.substr(0, idx);
-                        item.order = Number(menuItem.group.substr(idx + 1)) || undefined;
-                    }
-                    else {
-                        item.group = menuItem.group;
-                    }
-                }
-                item.when = ContextKeyExpr.deserialize(menuItem.when);
-                _menuRegistrations.add(MenuRegistry.appendMenuItem(menu.id, item));
-            }
-        }
-    }
-});
 class KeybindingIO {
     static writeKeybindingItem(out, item) {
         if (!item.resolvedKeybinding) {

package/dist/layout.js

@@ -0,0 +1,41 @@
+import { Emitter } from './missing-services.js';
+import { IWorkbenchLayoutService } from './layoutService.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { getClientArea } from 'monaco-editor/esm/vs/base/browser/dom.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { ICodeEditorService } from 'monaco-editor/esm/vs/editor/browser/services/codeEditorService.js';
+class LayoutService {
+    constructor(container) {
+        this.container = container;
+        this.onDidChangePartVisibility = Event.None;
+        this.offset = { top: 0, quickPickTop: 0 };
+        this._onDidLayout = new Emitter();
+        this.onDidLayout = this._onDidLayout.event;
+        window.addEventListener('resize', () => this.layout());
+        this.layout();
+    }
+    isVisible() {
+        return false;
+    }
+    get dimension() { return this._dimension; }
+    layout() {
+        this._dimension = getClientArea(window.document.body);
+        this._onDidLayout.fire(this._dimension);
+    }
+    get hasContainer() {
+        return true;
+    }
+    focus() {
+        StandaloneServices.get(ICodeEditorService).getFocusedCodeEditor()?.focus();
+    }
+}
+function getServiceOverride(container = document.body) {
+    container.classList.add('monaco-workbench');
+    return {
+        [( ILayoutService.toString())]: new SyncDescriptor(LayoutService, [container]),
+        [( IWorkbenchLayoutService.toString())]: new SyncDescriptor(LayoutService, [container])
+    };
+}
+export { getServiceOverride };

package/dist/layoutService.js

@@ -0,0 +1,12 @@
+import { refineServiceDecorator } from './missing-services.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+const IWorkbenchLayoutService = refineServiceDecorator(ILayoutService);
+function positionToString(position) {
+    switch (position) {
+        case 0 : return 'left';
+        case 1 : return 'right';
+        case 2 : return 'bottom';
+        default: return 'bottom';
+    }
+}
+export { IWorkbenchLayoutService, positionToString };