@codingame/monaco-vscode-api 1.82.4 → 1.82.5-next.0

package/vscode/src/vs/workbench/contrib/customEditor/common/contributedCustomEditors.js

@@ -1,72 +0,0 @@
-import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { Memento } from '../../../common/memento.js';
-import { CustomEditorInfo } from './customEditor.js';
-import { customEditorsExtensionPoint } from './extensionPoint.js';
-import { RegisteredEditorPriority } from '../../../services/editor/common/editorResolverService.js';
-class ContributedCustomEditors extends Disposable {
-    static { this.CUSTOM_EDITORS_STORAGE_ID = 'customEditors'; }
-    static { this.CUSTOM_EDITORS_ENTRY_ID = 'editors'; }
-    constructor(storageService) {
-        super();
-        this._editors = ( new Map());
-        this._onChange = this._register(( new Emitter()));
-        this.onChange = this._onChange.event;
-        this._memento = ( new Memento(ContributedCustomEditors.CUSTOM_EDITORS_STORAGE_ID, storageService));
-        const mementoObject = this._memento.getMemento(0 , 1 );
-        for (const info of (mementoObject[ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID] || [])) {
-            this.add(( new CustomEditorInfo(info)));
-        }
-        customEditorsExtensionPoint.setHandler(extensions => {
-            this.update(extensions);
-        });
-    }
-    update(extensions) {
-        this._editors.clear();
-        for (const extension of extensions) {
-            for (const webviewEditorContribution of extension.value) {
-                this.add(( new CustomEditorInfo({
-                    id: webviewEditorContribution.viewType,
-                    displayName: webviewEditorContribution.displayName,
-                    providerDisplayName: extension.description.isBuiltin ? ( nls.localize('builtinProviderDisplayName', "Built-in")) : extension.description.displayName || extension.description.identifier.value,
-                    selector: webviewEditorContribution.selector || [],
-                    priority: getPriorityFromContribution(webviewEditorContribution, extension.description),
-                })));
-            }
-        }
-        const mementoObject = this._memento.getMemento(0 , 1 );
-        mementoObject[ContributedCustomEditors.CUSTOM_EDITORS_ENTRY_ID] = Array.from(( this._editors.values()));
-        this._memento.saveMemento();
-        this._onChange.fire();
-    }
-    [Symbol.iterator]() {
-        return ( this._editors.values());
-    }
-    get(viewType) {
-        return this._editors.get(viewType);
-    }
-    getContributedEditors(resource) {
-        return Array.from(( this._editors.values()))
-            .filter(customEditor => customEditor.matches(resource));
-    }
-    add(info) {
-        if (( this._editors.has(info.id))) {
-            console.error(`Custom editor with id '${info.id}' already registered`);
-            return;
-        }
-        this._editors.set(info.id, info);
-    }
-}
-function getPriorityFromContribution(contribution, extension) {
-    switch (contribution.priority) {
-        case RegisteredEditorPriority.default:
-        case RegisteredEditorPriority.option:
-            return contribution.priority;
-        case RegisteredEditorPriority.builtin:
-            return extension.isBuiltin ? RegisteredEditorPriority.builtin : RegisteredEditorPriority.default;
-        default:
-            return RegisteredEditorPriority.default;
-    }
-}
-export { ContributedCustomEditors };

package/vscode/src/vs/workbench/contrib/customEditor/common/customEditorModelManager.js

@@ -1,61 +0,0 @@
-import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
-class CustomEditorModelManager {
-    constructor() {
-        this._references = ( (new Map()));
-    }
-    async getAllModels(resource) {
-        const keyStart = `${( ( resource.toString()))}@@@`;
-        const models = [];
-        for (const [key, entry] of this._references) {
-            if (key.startsWith(keyStart) && entry.model) {
-                models.push(await entry.model);
-            }
-        }
-        return models;
-    }
-    async get(resource, viewType) {
-        const key = this.key(resource, viewType);
-        const entry = this._references.get(key);
-        return entry?.model;
-    }
-    tryRetain(resource, viewType) {
-        const key = this.key(resource, viewType);
-        const entry = this._references.get(key);
-        if (!entry) {
-            return undefined;
-        }
-        entry.counter++;
-        return entry.model.then(model => {
-            return {
-                object: model,
-                dispose: once(() => {
-                    if (--entry.counter <= 0) {
-                        entry.model.then(x => x.dispose());
-                        this._references.delete(key);
-                    }
-                }),
-            };
-        });
-    }
-    add(resource, viewType, model) {
-        const key = this.key(resource, viewType);
-        const existing = this._references.get(key);
-        if (existing) {
-            throw new Error('Model already exists');
-        }
-        this._references.set(key, { viewType, model, counter: 0 });
-        return this.tryRetain(resource, viewType);
-    }
-    disposeAllModelsForView(viewType) {
-        for (const [key, value] of this._references) {
-            if (value.viewType === viewType) {
-                value.model.then(x => x.dispose());
-                this._references.delete(key);
-            }
-        }
-    }
-    key(resource, viewType) {
-        return `${( ( resource.toString()))}@@@${viewType}`;
-    }
-}
-export { CustomEditorModelManager };

package/vscode/src/vs/workbench/contrib/customEditor/common/extensionPoint.js

@@ -1,106 +0,0 @@
-import * as nls from 'monaco-editor/esm/vs/nls.js';
-import { ExtensionsRegistry } from '../../../services/extensions/common/extensionsRegistry.js';
-import { languagesExtPoint } from '../../../services/language/common/languageService.js';
-const Fields = ( Object.freeze({
-    viewType: 'viewType',
-    displayName: 'displayName',
-    selector: 'selector',
-    priority: 'priority',
-}));
-const CustomEditorsContribution = {
-    description: ( nls.localize('contributes.customEditors', 'Contributed custom editors.')),
-    type: 'array',
-    defaultSnippets: [{
-            body: [{
-                    [Fields.viewType]: '$1',
-                    [Fields.displayName]: '$2',
-                    [Fields.selector]: [{
-                            filenamePattern: '$3'
-                        }],
-                }]
-        }],
-    items: {
-        type: 'object',
-        required: [
-            Fields.viewType,
-            Fields.displayName,
-            Fields.selector,
-        ],
-        properties: {
-            [Fields.viewType]: {
-                type: 'string',
-                markdownDescription: ( nls.localize(
-                    'contributes.viewType',
-                    'Identifier for the custom editor. This must be unique across all custom editors, so we recommend including your extension id as part of `viewType`. The `viewType` is used when registering custom editors with `vscode.registerCustomEditorProvider` and in the `onCustomEditor:${id}` [activation event](https://code.visualstudio.com/api/references/activation-events).'
-                )),
-            },
-            [Fields.displayName]: {
-                type: 'string',
-                description: ( nls.localize(
-                    'contributes.displayName',
-                    'Human readable name of the custom editor. This is displayed to users when selecting which editor to use.'
-                )),
-            },
-            [Fields.selector]: {
-                type: 'array',
-                description: ( nls.localize(
-                    'contributes.selector',
-                    'Set of globs that the custom editor is enabled for.'
-                )),
-                items: {
-                    type: 'object',
-                    defaultSnippets: [{
-                            body: {
-                                filenamePattern: '$1',
-                            }
-                        }],
-                    properties: {
-                        filenamePattern: {
-                            type: 'string',
-                            description: ( nls.localize(
-                                'contributes.selector.filenamePattern',
-                                'Glob that the custom editor is enabled for.'
-                            )),
-                        },
-                    }
-                }
-            },
-            [Fields.priority]: {
-                type: 'string',
-                markdownDeprecationMessage: ( nls.localize(
-                    'contributes.priority',
-                    'Controls if the custom editor is enabled automatically when the user opens a file. This may be overridden by users using the `workbench.editorAssociations` setting.'
-                )),
-                enum: [
-                    "default" ,
-                    "option" ,
-                ],
-                markdownEnumDescriptions: [
-                    ( nls.localize(
-                        'contributes.priority.default',
-                        'The editor is automatically used when the user opens a resource, provided that no other default custom editors are registered for that resource.'
-                    )),
-                    ( nls.localize(
-                        'contributes.priority.option',
-                        'The editor is not automatically used when the user opens a resource, but a user can switch to the editor using the `Reopen With` command.'
-                    )),
-                ],
-                default: 'default'
-            }
-        }
-    }
-};
-const customEditorsExtensionPoint = ( ExtensionsRegistry.registerExtensionPoint({
-    extensionPoint: 'customEditors',
-    deps: [languagesExtPoint],
-    jsonSchema: CustomEditorsContribution,
-    activationEventsGenerator: (contribs, result) => {
-        for (const contrib of contribs) {
-            const viewType = contrib[Fields.viewType];
-            if (viewType) {
-                result.push(`onCustomEditor:${viewType}`);
-            }
-        }
-    },
-}));
-export { customEditorsExtensionPoint };

package/vscode/src/vs/workbench/contrib/debug/browser/baseDebugView.js

@@ -1,198 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import * as dom from 'monaco-editor/esm/vs/base/browser/dom.js';
-import { ActionBar } from 'monaco-editor/esm/vs/base/browser/ui/actionbar/actionbar.js';
-import { HighlightedLabel } from 'monaco-editor/esm/vs/base/browser/ui/highlightedlabel/highlightedLabel.js';
-import { InputBox } from 'monaco-editor/esm/vs/base/browser/ui/inputbox/inputBox.js';
-import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
-import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
-import { createMatches } from 'monaco-editor/esm/vs/base/common/filters.js';
-import { once } from 'monaco-editor/esm/vs/base/common/functional.js';
-import { dispose, toDisposable, DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { IContextViewService } from 'monaco-editor/esm/vs/platform/contextview/browser/contextView.js';
-import { defaultInputBoxStyles } from 'monaco-editor/esm/vs/platform/theme/browser/defaultStyles.js';
-import { IDebugService } from '../common/debug.js';
-import { Expression, Variable, ExpressionContainer } from '../common/debugModel.js';
-import { ReplEvaluationResult } from '../common/replModel.js';
-const MAX_VALUE_RENDER_LENGTH_IN_VIEWLET = 1024;
-const booleanRegex = /^(true|false)$/i;
-const stringRegex = /^(['"]).*\1$/;
-const $ = dom.$;
-function renderViewTree(container) {
-    const treeContainer = $('.');
-    treeContainer.classList.add('debug-view-content');
-    container.appendChild(treeContainer);
-    return treeContainer;
-}
-function renderExpressionValue(expressionOrValue, container, options) {
-    let value = typeof expressionOrValue === 'string' ? expressionOrValue : expressionOrValue.value;
-    container.className = 'value';
-    if (value === null || ((expressionOrValue instanceof Expression || expressionOrValue instanceof Variable || expressionOrValue instanceof ReplEvaluationResult) && !expressionOrValue.available)) {
-        container.classList.add('unavailable');
-        if (value !== Expression.DEFAULT_VALUE) {
-            container.classList.add('error');
-        }
-    }
-    else {
-        if ((expressionOrValue instanceof ExpressionContainer) && options.showChanged && expressionOrValue.valueChanged && value !== Expression.DEFAULT_VALUE) {
-            container.className = 'value changed';
-            expressionOrValue.valueChanged = false;
-        }
-        if (options.colorize && typeof expressionOrValue !== 'string') {
-            if (expressionOrValue.type === 'number' || expressionOrValue.type === 'boolean' || expressionOrValue.type === 'string') {
-                container.classList.add(expressionOrValue.type);
-            }
-            else if (!isNaN(+value)) {
-                container.classList.add('number');
-            }
-            else if (booleanRegex.test(value)) {
-                container.classList.add('boolean');
-            }
-            else if (stringRegex.test(value)) {
-                container.classList.add('string');
-            }
-        }
-    }
-    if (options.maxValueLength && value && value.length > options.maxValueLength) {
-        value = value.substring(0, options.maxValueLength) + '...';
-    }
-    if (!value) {
-        value = '';
-    }
-    if (options.linkDetector) {
-        container.textContent = '';
-        const session = (expressionOrValue instanceof ExpressionContainer) ? expressionOrValue.getSession() : undefined;
-        container.appendChild(options.linkDetector.linkify(value, false, session ? session.root : undefined, true));
-    }
-    else {
-        container.textContent = value;
-    }
-    if (options.showHover) {
-        container.title = value || '';
-    }
-}
-function renderVariable(variable, data, showChanged, highlights, linkDetector) {
-    if (variable.available) {
-        let text = variable.name;
-        if (variable.value && typeof variable.name === 'string') {
-            text += ':';
-        }
-        data.label.set(text, highlights, variable.type ? variable.type : variable.name);
-        data.name.classList.toggle('virtual', variable.presentationHint?.kind === 'virtual');
-        data.name.classList.toggle('internal', variable.presentationHint?.visibility === 'internal');
-    }
-    else if (variable.value && typeof variable.name === 'string' && variable.name) {
-        data.label.set(':');
-    }
-    data.expression.classList.toggle('lazy', !!variable.presentationHint?.lazy);
-    renderExpressionValue(variable, data.value, {
-        showChanged,
-        maxValueLength: MAX_VALUE_RENDER_LENGTH_IN_VIEWLET,
-        showHover: true,
-        colorize: true,
-        linkDetector
-    });
-}
-let AbstractExpressionsRenderer = class AbstractExpressionsRenderer {
-    constructor(debugService, contextViewService) {
-        this.debugService = debugService;
-        this.contextViewService = contextViewService;
-    }
-    renderTemplate(container) {
-        const expression = dom.append(container, $('.expression'));
-        const name = dom.append(expression, $('span.name'));
-        const lazyButton = dom.append(expression, $('span.lazy-button'));
-        lazyButton.classList.add(...ThemeIcon.asClassNameArray(Codicon.eye));
-        lazyButton.title = ( localize('debug.lazyButton.tooltip', "Click to expand"));
-        const value = dom.append(expression, $('span.value'));
-        const label = ( new HighlightedLabel(name));
-        const inputBoxContainer = dom.append(expression, $('.inputBoxContainer'));
-        const templateDisposable = ( new DisposableStore());
-        let actionBar;
-        if (this.renderActionBar) {
-            dom.append(expression, $('.span.actionbar-spacer'));
-            actionBar = templateDisposable.add(( new ActionBar(expression)));
-        }
-        const template = { expression, name, value, label, inputBoxContainer, actionBar, elementDisposable: [], templateDisposable, lazyButton, currentElement: undefined };
-        templateDisposable.add(dom.addDisposableListener(lazyButton, dom.EventType.CLICK, () => {
-            if (template.currentElement) {
-                this.debugService.getViewModel().evaluateLazyExpression(template.currentElement);
-            }
-        }));
-        return template;
-    }
-    renderExpressionElement(element, node, data) {
-        data.currentElement = element;
-        this.renderExpression(node.element, data, createMatches(node.filterData));
-        if (data.actionBar) {
-            this.renderActionBar(data.actionBar, element, data);
-        }
-        const selectedExpression = this.debugService.getViewModel().getSelectedExpression();
-        if (element === selectedExpression?.expression || (element instanceof Variable && element.errorMessage)) {
-            const options = this.getInputBoxOptions(element, !!selectedExpression?.settingWatch);
-            if (options) {
-                data.elementDisposable.push(this.renderInputBox(data.name, data.value, data.inputBoxContainer, options));
-            }
-        }
-    }
-    renderInputBox(nameElement, valueElement, inputBoxContainer, options) {
-        nameElement.style.display = 'none';
-        valueElement.style.display = 'none';
-        inputBoxContainer.style.display = 'initial';
-        dom.clearNode(inputBoxContainer);
-        const inputBox = ( new InputBox(
-            inputBoxContainer,
-            this.contextViewService,
-            { ...options, inputBoxStyles: defaultInputBoxStyles }
-        ));
-        inputBox.value = options.initialValue;
-        inputBox.focus();
-        inputBox.select();
-        const done = once((success, finishEditing) => {
-            nameElement.style.display = '';
-            valueElement.style.display = '';
-            inputBoxContainer.style.display = 'none';
-            const value = inputBox.value;
-            dispose(toDispose);
-            if (finishEditing) {
-                this.debugService.getViewModel().setSelectedExpression(undefined, false);
-                options.onFinish(value, success);
-            }
-        });
-        const toDispose = [
-            inputBox,
-            dom.addStandardDisposableListener(inputBox.inputElement, dom.EventType.KEY_DOWN, (e) => {
-                const isEscape = e.equals(9 );
-                const isEnter = e.equals(3 );
-                if (isEscape || isEnter) {
-                    e.preventDefault();
-                    e.stopPropagation();
-                    done(isEnter, true);
-                }
-            }),
-            dom.addDisposableListener(inputBox.inputElement, dom.EventType.BLUR, () => {
-                done(true, true);
-            }),
-            dom.addDisposableListener(inputBox.inputElement, dom.EventType.CLICK, e => {
-                e.preventDefault();
-                e.stopPropagation();
-            })
-        ];
-        return toDisposable(() => {
-            done(false, false);
-        });
-    }
-    disposeElement(node, index, templateData) {
-        dispose(templateData.elementDisposable);
-        templateData.elementDisposable = [];
-    }
-    disposeTemplate(templateData) {
-        dispose(templateData.elementDisposable);
-        templateData.templateDisposable.dispose();
-    }
-};
-AbstractExpressionsRenderer = ( __decorate([
-    ( __param(0, IDebugService)),
-    ( __param(1, IContextViewService))
-], AbstractExpressionsRenderer));
-export { AbstractExpressionsRenderer, renderExpressionValue, renderVariable, renderViewTree };