@codingame/monaco-vscode-api 1.79.0 → 1.79.2-next.0

package/dist/vscode/vs/workbench/services/hover/browser/hoverService.js

@@ -1,5 +1,5 @@
 import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import "../../../../../../assets/hover.css";
+import './media/hover.css.js';
 import { registerThemingParticipant } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
 import { editorHoverBorder } from 'monaco-editor/esm/vs/platform/theme/common/colorRegistry.js';
 import { IContextViewService, IContextMenuService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
@@ -84,7 +84,7 @@ let HoverService = class HoverService {
         }
         const event = ( (new StandardKeyboardEvent(e)));
         const keybinding = this._keybindingService.resolveKeyboardEvent(event);
-        if (( (keybinding.getSingleModifierDispatchChords().some(value => !!value))) || this._keybindingService.softDispatch(event, event.target)) {
+        if (( (keybinding.getSingleModifierDispatchChords().some(value => !!value))) || this._keybindingService.softDispatch(event, event.target).kind !== 0 ) {
             return;
         }
         if (hideOnKeyDown && (!this._currentHoverOptions?.trapFocus || e.key !== 'Tab')) {

package/dist/vscode/vs/workbench/services/hover/browser/hoverWidget.js

@@ -135,7 +135,8 @@ let HoverWidget = class HoverWidget extends Widget {
         }
         else {
             if (options.hideOnHover === undefined) {
-                hideOnHover = typeof options.content === 'string' || isMarkdownString(options.content) && !options.content.value.includes('](');
+                hideOnHover = typeof options.content === 'string' ||
+                    isMarkdownString(options.content) && !options.content.value.includes('](') && !options.content.value.includes('</a>');
             }
             else {
                 hideOnHover = options.hideOnHover;

package/dist/vscode/vs/workbench/services/hover/browser/media/hover.css.js

@@ -0,0 +1,4 @@
+import n from '../../../../../../../node_modules/rollup-plugin-styles/dist/runtime/inject-css.js';
+var css = ".monaco-workbench .workbench-hover{background:var(--vscode-editorHoverWidget-background);border:1px solid var(--vscode-editorHoverWidget-border);border-radius:3px;box-shadow:0 2px 8px var(--vscode-widget-shadow);color:var(--vscode-editorHoverWidget-foreground);font-size:13px;line-height:19px;max-width:700px;overflow:hidden;position:relative;z-index:40}.monaco-workbench .workbench-hover hr{border-bottom:none}.monaco-workbench .workbench-hover:not(.skip-fade-in){animation:fadein .1s linear}.monaco-workbench .workbench-hover.compact{font-size:12px}.monaco-workbench .workbench-hover.compact .hover-contents{padding:2px 8px}.monaco-workbench .workbench-hover-container.locked .workbench-hover{outline:1px solid var(--vscode-editorHoverWidget-border)}.monaco-workbench .workbench-hover-container.locked .workbench-hover:focus,.monaco-workbench .workbench-hover-lock:focus{outline:1px solid var(--vscode-focusBorder)}.monaco-workbench .workbench-hover-container.locked .workbench-hover-lock:hover{background:var(--vscode-toolbar-hoverBackground)}.monaco-workbench .workbench-hover-pointer{pointer-events:none;position:absolute;z-index:41}.monaco-workbench .workbench-hover-pointer:after{background-color:var(--vscode-editorHoverWidget-background);border-bottom:1px solid var(--vscode-editorHoverWidget-border);border-right:1px solid var(--vscode-editorHoverWidget-border);content:\"\";height:5px;position:absolute;width:5px}.monaco-workbench .locked .workbench-hover-pointer:after{border-bottom-width:2px;border-right-width:2px;height:4px;width:4px}.monaco-workbench .workbench-hover-pointer.left{left:-3px}.monaco-workbench .workbench-hover-pointer.right{right:3px}.monaco-workbench .workbench-hover-pointer.top{top:-3px}.monaco-workbench .workbench-hover-pointer.bottom{bottom:3px}.monaco-workbench .workbench-hover-pointer.left:after{transform:rotate(135deg)}.monaco-workbench .workbench-hover-pointer.right:after{transform:rotate(315deg)}.monaco-workbench .workbench-hover-pointer.top:after{transform:rotate(225deg)}.monaco-workbench .workbench-hover-pointer.bottom:after{transform:rotate(45deg)}.monaco-workbench .workbench-hover a{color:var(--vscode-textLink-foreground)}.monaco-workbench .workbench-hover a:focus{outline:1px solid;outline-color:var(--vscode-focusBorder);outline-offset:-1px;text-decoration:underline}.monaco-workbench .workbench-hover a:active,.monaco-workbench .workbench-hover a:hover{color:var(--vscode-textLink-activeForeground)}.monaco-workbench .workbench-hover code{background:var(--vscode-textCodeBlock-background)}.monaco-workbench .workbench-hover .hover-row .actions{background:var(--vscode-editorHoverWidget-statusBarBackground)}.monaco-workbench .workbench-hover.right-aligned{left:1px}.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions{flex-direction:row-reverse}.monaco-workbench .workbench-hover.right-aligned .hover-row.status-bar .actions .action-container{margin-left:16px;margin-right:0}";
+n(css,{});
+export { css, css as default };

package/dist/vscode/vs/workbench/services/keybinding/common/keybindingEditing.js

@@ -0,0 +1,275 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Queue } from 'monaco-editor/esm/vs/base/common/async.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as objects from 'monaco-editor/esm/vs/base/common/objects.js';
+import { setProperty } from '../../../../base/common/jsonEdit.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { EditOperation } from 'monaco-editor/esm/vs/editor/common/core/editOperation.js';
+import { Range } from 'monaco-editor/esm/vs/editor/common/core/range.js';
+import { Selection } from 'monaco-editor/esm/vs/editor/common/core/selection.js';
+import { ITextModelService } from 'monaco-editor/esm/vs/editor/common/services/resolverService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITextFileService } from '../../textfile/common/textfiles.js';
+import { IUserDataProfileService } from '../../userDataProfile/common/userDataProfile.js';
+const IKeybindingEditingService = ( createDecorator('keybindingEditingService'));
+let KeybindingsEditingService = class KeybindingsEditingService extends Disposable {
+    constructor(textModelResolverService, textFileService, fileService, configurationService, userDataProfileService) {
+        super();
+        this.textModelResolverService = textModelResolverService;
+        this.textFileService = textFileService;
+        this.fileService = fileService;
+        this.configurationService = configurationService;
+        this.userDataProfileService = userDataProfileService;
+        this.queue = ( new Queue());
+    }
+    addKeybinding(keybindingItem, key, when) {
+        return this.queue.queue(() => this.doEditKeybinding(keybindingItem, key, when, true));
+    }
+    editKeybinding(keybindingItem, key, when) {
+        return this.queue.queue(() => this.doEditKeybinding(keybindingItem, key, when, false));
+    }
+    resetKeybinding(keybindingItem) {
+        return this.queue.queue(() => this.doResetKeybinding(keybindingItem));
+    }
+    removeKeybinding(keybindingItem) {
+        return this.queue.queue(() => this.doRemoveKeybinding(keybindingItem));
+    }
+    async doEditKeybinding(keybindingItem, key, when, add) {
+        const reference = await this.resolveAndValidate();
+        const model = reference.object.textEditorModel;
+        if (add) {
+            this.updateKeybinding(keybindingItem, key, when, model, -1);
+        }
+        else {
+            const userKeybindingEntries = json.parse(model.getValue());
+            const userKeybindingEntryIndex = this.findUserKeybindingEntryIndex(keybindingItem, userKeybindingEntries);
+            this.updateKeybinding(keybindingItem, key, when, model, userKeybindingEntryIndex);
+            if (keybindingItem.isDefault && keybindingItem.resolvedKeybinding) {
+                this.removeDefaultKeybinding(keybindingItem, model);
+            }
+        }
+        try {
+            await this.save();
+        }
+        finally {
+            reference.dispose();
+        }
+    }
+    doRemoveKeybinding(keybindingItem) {
+        return this.resolveAndValidate()
+            .then(reference => {
+            const model = reference.object.textEditorModel;
+            if (keybindingItem.isDefault) {
+                this.removeDefaultKeybinding(keybindingItem, model);
+            }
+            else {
+                this.removeUserKeybinding(keybindingItem, model);
+            }
+            return this.save().finally(() => reference.dispose());
+        });
+    }
+    doResetKeybinding(keybindingItem) {
+        return this.resolveAndValidate()
+            .then(reference => {
+            const model = reference.object.textEditorModel;
+            if (!keybindingItem.isDefault) {
+                this.removeUserKeybinding(keybindingItem, model);
+                this.removeUnassignedDefaultKeybinding(keybindingItem, model);
+            }
+            return this.save().finally(() => reference.dispose());
+        });
+    }
+    save() {
+        return this.textFileService.save(this.userDataProfileService.currentProfile.keybindingsResource);
+    }
+    updateKeybinding(keybindingItem, newKey, when, model, userKeybindingEntryIndex) {
+        const { tabSize, insertSpaces } = model.getOptions();
+        const eol = model.getEOL();
+        if (userKeybindingEntryIndex !== -1) {
+            this.applyEditsToBuffer(setProperty(model.getValue(), [userKeybindingEntryIndex, 'key'], newKey, { tabSize, insertSpaces, eol })[0], model);
+            const edits = setProperty(model.getValue(), [userKeybindingEntryIndex, 'when'], when, { tabSize, insertSpaces, eol });
+            if (edits.length > 0) {
+                this.applyEditsToBuffer(edits[0], model);
+            }
+        }
+        else {
+            this.applyEditsToBuffer(setProperty(model.getValue(), [-1], this.asObject(newKey, keybindingItem.command, when, false), { tabSize, insertSpaces, eol })[0], model);
+        }
+    }
+    removeUserKeybinding(keybindingItem, model) {
+        const { tabSize, insertSpaces } = model.getOptions();
+        const eol = model.getEOL();
+        const userKeybindingEntries = json.parse(model.getValue());
+        const userKeybindingEntryIndex = this.findUserKeybindingEntryIndex(keybindingItem, userKeybindingEntries);
+        if (userKeybindingEntryIndex !== -1) {
+            this.applyEditsToBuffer(setProperty(model.getValue(), [userKeybindingEntryIndex], undefined, { tabSize, insertSpaces, eol })[0], model);
+        }
+    }
+    removeDefaultKeybinding(keybindingItem, model) {
+        const { tabSize, insertSpaces } = model.getOptions();
+        const eol = model.getEOL();
+        const key = keybindingItem.resolvedKeybinding ? keybindingItem.resolvedKeybinding.getUserSettingsLabel() : null;
+        if (key) {
+            const entry = this.asObject(key, keybindingItem.command, keybindingItem.when ? keybindingItem.when.serialize() : undefined, true);
+            const userKeybindingEntries = json.parse(model.getValue());
+            if (userKeybindingEntries.every(e => !this.areSame(e, entry))) {
+                this.applyEditsToBuffer(setProperty(model.getValue(), [-1], entry, { tabSize, insertSpaces, eol })[0], model);
+            }
+        }
+    }
+    removeUnassignedDefaultKeybinding(keybindingItem, model) {
+        const { tabSize, insertSpaces } = model.getOptions();
+        const eol = model.getEOL();
+        const userKeybindingEntries = json.parse(model.getValue());
+        const indices = this.findUnassignedDefaultKeybindingEntryIndex(keybindingItem, userKeybindingEntries).reverse();
+        for (const index of indices) {
+            this.applyEditsToBuffer(setProperty(model.getValue(), [index], undefined, { tabSize, insertSpaces, eol })[0], model);
+        }
+    }
+    findUserKeybindingEntryIndex(keybindingItem, userKeybindingEntries) {
+        for (let index = 0; index < userKeybindingEntries.length; index++) {
+            const keybinding = userKeybindingEntries[index];
+            if (keybinding.command === keybindingItem.command) {
+                if (!keybinding.when && !keybindingItem.when) {
+                    return index;
+                }
+                if (keybinding.when && keybindingItem.when) {
+                    const contextKeyExpr = ContextKeyExpr.deserialize(keybinding.when);
+                    if (contextKeyExpr && contextKeyExpr.serialize() === keybindingItem.when.serialize()) {
+                        return index;
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+    findUnassignedDefaultKeybindingEntryIndex(keybindingItem, userKeybindingEntries) {
+        const indices = [];
+        for (let index = 0; index < userKeybindingEntries.length; index++) {
+            if (userKeybindingEntries[index].command === `-${keybindingItem.command}`) {
+                indices.push(index);
+            }
+        }
+        return indices;
+    }
+    asObject(key, command, when, negate) {
+        const object = { key };
+        if (command) {
+            object['command'] = negate ? `-${command}` : command;
+        }
+        if (when) {
+            object['when'] = when;
+        }
+        return object;
+    }
+    areSame(a, b) {
+        if (a.command !== b.command) {
+            return false;
+        }
+        if (a.key !== b.key) {
+            return false;
+        }
+        const whenA = ContextKeyExpr.deserialize(a.when);
+        const whenB = ContextKeyExpr.deserialize(b.when);
+        if ((whenA && !whenB) || (!whenA && whenB)) {
+            return false;
+        }
+        if (whenA && whenB && !whenA.equals(whenB)) {
+            return false;
+        }
+        if (!objects.equals(a.args, b.args)) {
+            return false;
+        }
+        return true;
+    }
+    applyEditsToBuffer(edit, model) {
+        const startPosition = model.getPositionAt(edit.offset);
+        const endPosition = model.getPositionAt(edit.offset + edit.length);
+        const range = ( new Range(
+            startPosition.lineNumber,
+            startPosition.column,
+            endPosition.lineNumber,
+            endPosition.column
+        ));
+        const currentText = model.getValueInRange(range);
+        const editOperation = currentText ? EditOperation.replace(range, edit.content) : EditOperation.insert(startPosition, edit.content);
+        model.pushEditOperations([( new Selection(
+            startPosition.lineNumber,
+            startPosition.column,
+            startPosition.lineNumber,
+            startPosition.column
+        ))], [editOperation], () => []);
+    }
+    resolveModelReference() {
+        return this.fileService.exists(this.userDataProfileService.currentProfile.keybindingsResource)
+            .then(exists => {
+            const EOL = this.configurationService.getValue('files', { overrideIdentifier: 'json' })['eol'];
+            const result = exists ? Promise.resolve(null) : this.textFileService.write(this.userDataProfileService.currentProfile.keybindingsResource, this.getEmptyContent(EOL), { encoding: 'utf8' });
+            return result.then(() => this.textModelResolverService.createModelReference(this.userDataProfileService.currentProfile.keybindingsResource));
+        });
+    }
+    resolveAndValidate() {
+        if (this.textFileService.isDirty(this.userDataProfileService.currentProfile.keybindingsResource)) {
+            return Promise.reject(( new Error(( localize(
+                'errorKeybindingsFileDirty',
+                "Unable to write because the keybindings configuration file has unsaved changes. Please save it first and then try again."
+            )))));
+        }
+        return this.resolveModelReference()
+            .then(reference => {
+            const model = reference.object.textEditorModel;
+            const EOL = model.getEOL();
+            if (model.getValue()) {
+                const parsed = this.parse(model);
+                if (parsed.parseErrors.length) {
+                    reference.dispose();
+                    return Promise.reject(( new Error(( localize(
+                        'parseErrors',
+                        "Unable to write to the keybindings configuration file. Please open it to correct errors/warnings in the file and try again."
+                    )))));
+                }
+                if (parsed.result) {
+                    if (!Array.isArray(parsed.result)) {
+                        reference.dispose();
+                        return Promise.reject(( new Error(( localize(
+                            'errorInvalidConfiguration',
+                            "Unable to write to the keybindings configuration file. It has an object which is not of type Array. Please open the file to clean up and try again."
+                        )))));
+                    }
+                }
+                else {
+                    const content = EOL + '[]';
+                    this.applyEditsToBuffer({ content, length: content.length, offset: model.getValue().length }, model);
+                }
+            }
+            else {
+                const content = this.getEmptyContent(EOL);
+                this.applyEditsToBuffer({ content, length: content.length, offset: 0 }, model);
+            }
+            return reference;
+        });
+    }
+    parse(model) {
+        const parseErrors = [];
+        const result = json.parse(model.getValue(), parseErrors, { allowTrailingComma: true, allowEmptyContent: true });
+        return { result, parseErrors };
+    }
+    getEmptyContent(EOL) {
+        return '// ' + ( localize(
+            'emptyKeybindingsHeader',
+            "Place your key bindings in this file to override the defaults"
+        )) + EOL + '[]';
+    }
+};
+KeybindingsEditingService = ( __decorate([
+    ( __param(0, ITextModelService)),
+    ( __param(1, ITextFileService)),
+    ( __param(2, IFileService)),
+    ( __param(3, IConfigurationService)),
+    ( __param(4, IUserDataProfileService))
+], KeybindingsEditingService));
+export { IKeybindingEditingService, KeybindingsEditingService };

package/dist/vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService.js

@@ -1,4 +1,5 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 const ILanguageDetectionService = ( createDecorator('ILanguageDetectionService'));
 const LanguageDetectionLanguageEventSource = 'languageDetection';
-export { ILanguageDetectionService, LanguageDetectionLanguageEventSource };
+const AutomaticLanguageDetectionLikelyWrongId = 'automaticlanguagedetection.likelywrong';
+export { AutomaticLanguageDetectionLikelyWrongId, ILanguageDetectionService, LanguageDetectionLanguageEventSource };

package/dist/vscode/vs/workbench/services/localization/common/locale.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const ILocaleService = ( createDecorator('localizationService'));
+export { ILocaleService };

package/dist/vscode/vs/workbench/services/log/common/logConstants.js

@@ -0,0 +1,2 @@
+const showWindowLogActionId = 'workbench.action.showWindowLog';
+export { showWindowLogActionId };

package/dist/vscode/vs/workbench/services/outline/browser/outline.js

@@ -0,0 +1,3 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+const IOutlineService = ( createDecorator('IOutlineService'));
+export { IOutlineService };

package/dist/vscode/vs/workbench/services/output/common/output.js

@@ -6,9 +6,12 @@ const OUTPUT_MIME = 'text/x-code-output';
 const OUTPUT_SCHEME = 'output';
 const OUTPUT_MODE_ID = 'Log';
 const LOG_MIME = 'text/x-code-log-output';
+const LOG_SCHEME = 'log';
 const LOG_MODE_ID = 'log';
 const OUTPUT_VIEW_ID = 'workbench.panel.output';
+const CONTEXT_IN_OUTPUT = ( new RawContextKey('inOutput', false));
 const CONTEXT_ACTIVE_LOG_OUTPUT = ( new RawContextKey('activeLogOutput', false));
+const CONTEXT_OUTPUT_SCROLL_LOCK = ( new RawContextKey(`outputView.scrollLock`, false));
 const IOutputService = ( createDecorator('outputService'));
 var OutputChannelUpdateMode;
 ( (function(OutputChannelUpdateMode) {
@@ -48,4 +51,4 @@ class OutputChannelRegistry {
 }
 Registry.add(Extensions.OutputChannels, ( new OutputChannelRegistry()));
 const ACTIVE_OUTPUT_CHANNEL_CONTEXT = ( new RawContextKey('activeOutputChannel', ''));
-export { ACTIVE_OUTPUT_CHANNEL_CONTEXT, CONTEXT_ACTIVE_LOG_OUTPUT, Extensions, IOutputService, LOG_MIME, LOG_MODE_ID, OUTPUT_MIME, OUTPUT_MODE_ID, OUTPUT_SCHEME, OUTPUT_VIEW_ID, OutputChannelUpdateMode };
+export { ACTIVE_OUTPUT_CHANNEL_CONTEXT, CONTEXT_ACTIVE_LOG_OUTPUT, CONTEXT_IN_OUTPUT, CONTEXT_OUTPUT_SCROLL_LOCK, Extensions, IOutputService, LOG_MIME, LOG_MODE_ID, LOG_SCHEME, OUTPUT_MIME, OUTPUT_MODE_ID, OUTPUT_SCHEME, OUTPUT_VIEW_ID, OutputChannelUpdateMode };

package/dist/vscode/vs/workbench/services/preferences/common/preferences.js

@@ -1,5 +1,25 @@
 import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { DEFAULT_EDITOR_ASSOCIATION } from '../../../common/editor.js';
+var SettingValueType;
+( (function(SettingValueType) {
+    SettingValueType["Null"] = "null";
+    SettingValueType["Enum"] = "enum";
+    SettingValueType["String"] = "string";
+    SettingValueType["MultilineString"] = "multiline-string";
+    SettingValueType["Integer"] = "integer";
+    SettingValueType["Number"] = "number";
+    SettingValueType["Boolean"] = "boolean";
+    SettingValueType["Array"] = "array";
+    SettingValueType["Exclude"] = "exclude";
+    SettingValueType["Include"] = "include";
+    SettingValueType["Complex"] = "complex";
+    SettingValueType["NullableInteger"] = "nullable-integer";
+    SettingValueType["NullableNumber"] = "nullable-number";
+    SettingValueType["Object"] = "object";
+    SettingValueType["BooleanObject"] = "boolean-object";
+    SettingValueType["LanguageTag"] = "language-tag";
+    SettingValueType["ExtensionToggle"] = "extension-toggle";
+})(SettingValueType || (SettingValueType = {})));
 var SettingMatchType;
 ( (function(SettingMatchType) {
     SettingMatchType[SettingMatchType["None"] = 0] = "None";
@@ -14,7 +34,8 @@ function validateSettingsEditorOptions(options) {
     };
 }
 const IPreferencesService = ( createDecorator('preferencesService'));
+const DEFINE_KEYBINDING_EDITOR_CONTRIB_ID = 'editor.contrib.defineKeybinding';
 const FOLDER_SETTINGS_PATH = '.vscode/settings.json';
 const DEFAULT_SETTINGS_EDITOR_SETTING = 'workbench.settings.openDefaultSettings';
 const USE_SPLIT_JSON_SETTING = 'workbench.settings.useSplitJSON';
-export { DEFAULT_SETTINGS_EDITOR_SETTING, FOLDER_SETTINGS_PATH, IPreferencesService, SettingMatchType, USE_SPLIT_JSON_SETTING, validateSettingsEditorOptions };
+export { DEFAULT_SETTINGS_EDITOR_SETTING, DEFINE_KEYBINDING_EDITOR_CONTRIB_ID, FOLDER_SETTINGS_PATH, IPreferencesService, SettingMatchType, SettingValueType, USE_SPLIT_JSON_SETTING, validateSettingsEditorOptions };

package/dist/vscode/vs/workbench/services/preferences/common/preferencesModels.js

@@ -223,9 +223,15 @@ let Settings2EditorModel = class Settings2EditorModel extends AbstractSettingsMo
     }
     get settingsGroups() {
         const groups = this._defaultSettings.getSettingsGroups(this.dirty);
+        if (this.additionalGroups?.length) {
+            groups.push(...this.additionalGroups);
+        }
         this.dirty = false;
         return groups;
     }
+    setAdditionalGroups(groups) {
+        this.additionalGroups = groups;
+    }
     findValueMatches(filter, setting) {
         return [];
     }

package/dist/vscode/vs/workbench/services/preferences/common/preferencesValidation.js

@@ -63,6 +63,42 @@ function createValidator(prop) {
         return '';
     };
 }
+function getInvalidTypeError(value, type) {
+    if (typeof type === 'undefined') {
+        return;
+    }
+    const typeArr = Array.isArray(type) ? type : [type];
+    if (!( typeArr.some(_type => valueValidatesAsType(value, _type)))) {
+        return ( nls.localize(
+            'invalidTypeError',
+            "Setting has an invalid type, expected {0}. Fix in JSON.",
+            JSON.stringify(type)
+        ));
+    }
+    return;
+}
+function valueValidatesAsType(value, type) {
+    const valueType = typeof value;
+    if (type === 'boolean') {
+        return valueType === 'boolean';
+    }
+    else if (type === 'object') {
+        return value && !Array.isArray(value) && valueType === 'object';
+    }
+    else if (type === 'null') {
+        return value === null;
+    }
+    else if (type === 'array') {
+        return Array.isArray(value);
+    }
+    else if (type === 'string') {
+        return valueType === 'string';
+    }
+    else if (type === 'number' || type === 'integer') {
+        return valueType === 'number';
+    }
+    return true;
+}
 function getStringValidators(prop) {
     const uriRegex = /^(([^:/?#]+?):)?(\/\/([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?/;
     let patternRegex;
@@ -354,4 +390,4 @@ function getErrorsForSchema(propertySchema, data) {
     const errorMessage = validator(data);
     return errorMessage;
 }
-export { createValidator };
+export { createValidator, getInvalidTypeError };

package/dist/vscode/vs/workbench/services/progress/browser/progressIndicator.js

@@ -1,5 +1,76 @@
 import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
 import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { emptyProgressRunner } from 'monaco-editor/esm/vs/platform/progress/common/progress.js';
+class EditorProgressIndicator extends Disposable {
+    constructor(progressBar, group) {
+        super();
+        this.progressBar = progressBar;
+        this.group = group;
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.group.onDidModelChange(e => {
+            if (e.kind === 6  ||
+                (e.kind === 4  && this.group.isEmpty)) {
+                this.progressBar.stop().hide();
+            }
+        }));
+    }
+    show(infiniteOrTotal, delay) {
+        if (this.group.isEmpty) {
+            return emptyProgressRunner;
+        }
+        if (infiniteOrTotal === true) {
+            return this.doShow(true, delay);
+        }
+        return this.doShow(infiniteOrTotal, delay);
+    }
+    doShow(infiniteOrTotal, delay) {
+        if (typeof infiniteOrTotal === 'boolean') {
+            this.progressBar.infinite().show(delay);
+        }
+        else {
+            this.progressBar.total(infiniteOrTotal).show(delay);
+        }
+        return {
+            total: (total) => {
+                this.progressBar.total(total);
+            },
+            worked: (worked) => {
+                if (this.progressBar.hasTotal()) {
+                    this.progressBar.worked(worked);
+                }
+                else {
+                    this.progressBar.infinite().show();
+                }
+            },
+            done: () => {
+                this.progressBar.stop().hide();
+            }
+        };
+    }
+    async showWhile(promise, delay) {
+        if (this.group.isEmpty) {
+            try {
+                await promise;
+            }
+            catch (error) {
+            }
+        }
+        return this.doShowWhile(promise, delay);
+    }
+    async doShowWhile(promise, delay) {
+        try {
+            this.progressBar.infinite().show(delay);
+            await promise;
+        }
+        catch (error) {
+        }
+        finally {
+            this.progressBar.stop().hide();
+        }
+    }
+}
 var ProgressIndicatorState;
 ( (function(ProgressIndicatorState) {
     ( (function(Type) {
@@ -171,4 +242,4 @@ class AbstractProgressScope extends Disposable {
         }
     }
 }
-export { AbstractProgressScope, ScopedProgressIndicator };
+export { AbstractProgressScope, EditorProgressIndicator, ScopedProgressIndicator };

package/dist/vscode/vs/workbench/services/quickinput/browser/quickInputService.js

@@ -0,0 +1,67 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { ILayoutService } from 'monaco-editor/esm/vs/platform/layout/browser/layoutService.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { IContextKeyService } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
+import { QuickInputService as QuickInputService$1 } from 'monaco-editor/esm/vs/platform/quickinput/browser/quickInputService.js';
+import { InQuickPickContextKey } from '../../../browser/quickaccess.js';
+import { IHoverService } from '../../hover/browser/hover.js';
+let QuickInputService = class QuickInputService extends QuickInputService$1 {
+    constructor(configurationService, instantiationService, keybindingService, contextKeyService, themeService, layoutService, hoverService) {
+        super(instantiationService, contextKeyService, themeService, layoutService);
+        this.configurationService = configurationService;
+        this.keybindingService = keybindingService;
+        this.hoverService = hoverService;
+        this.hoverDelegate = ( new QuickInputHoverDelegate(this.configurationService, this.hoverService));
+        this.inQuickInputContext = InQuickPickContextKey.bindTo(this.contextKeyService);
+        this.registerListeners();
+    }
+    registerListeners() {
+        this._register(this.onShow(() => this.inQuickInputContext.set(true)));
+        this._register(this.onHide(() => this.inQuickInputContext.set(false)));
+    }
+    createController() {
+        return super.createController(this.layoutService, {
+            ignoreFocusOut: () => !this.configurationService.getValue('workbench.quickOpen.closeOnFocusLost'),
+            backKeybindingLabel: () => this.keybindingService.lookupKeybinding('workbench.action.quickInputBack')?.getLabel() || undefined,
+            hoverDelegate: this.hoverDelegate
+        });
+    }
+};
+QuickInputService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IInstantiationService)),
+    ( __param(2, IKeybindingService)),
+    ( __param(3, IContextKeyService)),
+    ( __param(4, IThemeService)),
+    ( __param(5, ILayoutService)),
+    ( __param(6, IHoverService))
+], QuickInputService));
+class QuickInputHoverDelegate {
+    get delay() {
+        if (Date.now() - this.lastHoverHideTime < 200) {
+            return 0;
+        }
+        return this.configurationService.getValue('workbench.hover.delay');
+    }
+    constructor(configurationService, hoverService) {
+        this.configurationService = configurationService;
+        this.hoverService = hoverService;
+        this.lastHoverHideTime = 0;
+        this.placement = 'element';
+    }
+    showHover(options, focus) {
+        return this.hoverService.showHover({
+            ...options,
+            showHoverHint: true,
+            hideOnKeyDown: false,
+            skipFadeInAnimation: true,
+        }, focus);
+    }
+    onDidHideHover() {
+        this.lastHoverHideTime = Date.now();
+    }
+}
+export { QuickInputService };