@codingame/monaco-vscode-api 1.80.0-next.6 → 1.80.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.80.0-next.6",
+  "version": "1.80.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
@@ -170,8 +170,7 @@
     "xterm-addon-serialize": "0.10.0",
     "xterm-addon-unicode11": "0.5.0",
     "xterm-addon-webgl": "0.15.0",
-    "yauzl": "^2.10.0",
-    "@vscode/vscode-languagedetection": "^1.0.22"
+    "yauzl": "^2.10.0"
   },
   "overrides": {
     "typescript": "5.1.6",

package/dist/override/vs/platform/dialogs/common/dialogs.js

@@ -1,7 +0,0 @@
-var ConfirmResult;
-( (function(ConfirmResult) {
-    ConfirmResult[ConfirmResult["SAVE"] = 0] = "SAVE";
-    ConfirmResult[ConfirmResult["DONT_SAVE"] = 1] = "DONT_SAVE";
-    ConfirmResult[ConfirmResult["CANCEL"] = 2] = "CANCEL";
-})(ConfirmResult || (ConfirmResult = {})));
-export { ConfirmResult };

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

@@ -1,5 +0,0 @@
-import { IEditorOverrideServices } from '../vscode/vs/editor/standalone/browser/standaloneServices.js';
-
-declare function getServiceOverride(): IEditorOverrideServices;
-
-export { getServiceOverride as default };

package/dist/service-override/languageDetectionWorker.js

@@ -1,15 +0,0 @@
-import '../missing-services.js';
-import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
-import { LanguageDetectionService } from '../vscode/vs/workbench/services/languageDetection/browser/languageDetectionWorkerServiceImpl.js';
-import { ILanguageDetectionService } from '../vscode/vs/workbench/services/languageDetection/common/languageDetectionWorkerService.js';
-import { registerAssets } from '../assets.js';
-registerAssets({
-    'vs/../../node_modules/@vscode/vscode-languagedetection/model/model.json': new URL('@vscode/vscode-languagedetection/model/model.json', import.meta.url).href,
-    'vs/../../node_modules/@vscode/vscode-languagedetection/model/group1-shard1of1.bin': new URL('@vscode/vscode-languagedetection/model/group1-shard1of1.bin', import.meta.url).href
-});
-function getServiceOverride() {
-    return {
-        [( ILanguageDetectionService.toString())]: new SyncDescriptor(LanguageDetectionService)
-    };
-}
-export { getServiceOverride as default };

package/dist/vscode/vs/platform/diagnostics/common/diagnostics.js

@@ -1,27 +0,0 @@
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const ID = 'diagnosticsService';
-const IDiagnosticsService = ( createDecorator(ID));
-class NullDiagnosticsService {
-    async getPerformanceInfo(mainProcessInfo, remoteInfo) {
-        return {};
-    }
-    async getSystemInfo(mainProcessInfo, remoteInfo) {
-        return {
-            processArgs: 'nullProcessArgs',
-            gpuStatus: 'nullGpuStatus',
-            screenReader: 'nullScreenReader',
-            remoteData: [],
-            os: 'nullOs',
-            memory: 'nullMemory',
-            vmHint: 'nullVmHint',
-        };
-    }
-    async getDiagnostics(mainProcessInfo, remoteInfo) {
-        return '';
-    }
-    async getWorkspaceFileExtensions(workspace) {
-        return { extensions: [] };
-    }
-    async reportWorkspaceStats(workspace) { }
-}
-export { ID, IDiagnosticsService, NullDiagnosticsService };

package/dist/vscode/vs/platform/dialogs/common/dialogs.js

@@ -1,126 +0,0 @@
-import { basename } from 'monaco-editor/esm/vs/base/common/resources.js';
-import Severity from 'monaco-editor/esm/vs/base/common/severity.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
-const IDialogService = ( createDecorator('dialogService'));
-var DialogKind;
-( (function(DialogKind) {
-    DialogKind[DialogKind["Confirmation"] = 1] = "Confirmation";
-    DialogKind[DialogKind["Prompt"] = 2] = "Prompt";
-    DialogKind[DialogKind["Input"] = 3] = "Input";
-})(DialogKind || (DialogKind = {})));
-class AbstractDialogHandler {
-    getConfirmationButtons(dialog) {
-        return this.getButtons(dialog, DialogKind.Confirmation);
-    }
-    getPromptButtons(dialog) {
-        return this.getButtons(dialog, DialogKind.Prompt);
-    }
-    getInputButtons(dialog) {
-        return this.getButtons(dialog, DialogKind.Input);
-    }
-    getButtons(dialog, kind) {
-        const buttons = [];
-        switch (kind) {
-            case DialogKind.Confirmation: {
-                const confirmationDialog = dialog;
-                if (confirmationDialog.primaryButton) {
-                    buttons.push(confirmationDialog.primaryButton);
-                }
-                else {
-                    buttons.push(( localize({ key: 'yesButton', comment: ['&& denotes a mnemonic'] }, "&&Yes")));
-                }
-                if (confirmationDialog.cancelButton) {
-                    buttons.push(confirmationDialog.cancelButton);
-                }
-                else {
-                    buttons.push(( localize('cancelButton', "Cancel")));
-                }
-                break;
-            }
-            case DialogKind.Prompt: {
-                const promptDialog = dialog;
-                if (Array.isArray(promptDialog.buttons) && promptDialog.buttons.length > 0) {
-                    buttons.push(...( promptDialog.buttons.map(button => button.label)));
-                }
-                if (promptDialog.cancelButton) {
-                    if (promptDialog.cancelButton === true) {
-                        buttons.push(( localize('cancelButton', "Cancel")));
-                    }
-                    else if (typeof promptDialog.cancelButton === 'string') {
-                        buttons.push(promptDialog.cancelButton);
-                    }
-                    else {
-                        if (promptDialog.cancelButton.label) {
-                            buttons.push(promptDialog.cancelButton.label);
-                        }
-                        else {
-                            buttons.push(( localize('cancelButton', "Cancel")));
-                        }
-                    }
-                }
-                if (buttons.length === 0) {
-                    buttons.push(( localize({ key: 'okButton', comment: ['&& denotes a mnemonic'] }, "&&OK")));
-                }
-                break;
-            }
-            case DialogKind.Input: {
-                const inputDialog = dialog;
-                if (inputDialog.primaryButton) {
-                    buttons.push(inputDialog.primaryButton);
-                }
-                else {
-                    buttons.push(( localize({ key: 'okButton', comment: ['&& denotes a mnemonic'] }, "&&OK")));
-                }
-                if (inputDialog.cancelButton) {
-                    buttons.push(inputDialog.cancelButton);
-                }
-                else {
-                    buttons.push(( localize('cancelButton', "Cancel")));
-                }
-                break;
-            }
-        }
-        return buttons;
-    }
-    getDialogType(type) {
-        if (typeof type === 'string') {
-            return type;
-        }
-        if (typeof type === 'number') {
-            return (type === Severity.Info) ? 'info' : (type === Severity.Error) ? 'error' : (type === Severity.Warning) ? 'warning' : 'none';
-        }
-        return undefined;
-    }
-    async getPromptResult(prompt, buttonIndex, checkboxChecked) {
-        const promptButtons = [...(prompt.buttons ?? [])];
-        if (prompt.cancelButton && typeof prompt.cancelButton !== 'string' && typeof prompt.cancelButton !== 'boolean') {
-            promptButtons.push(prompt.cancelButton);
-        }
-        const result = await promptButtons[buttonIndex]?.run({ checkboxChecked });
-        return { result, checkboxChecked };
-    }
-}
-const IFileDialogService = ( createDecorator('fileDialogService'));
-const MAX_CONFIRM_FILES = 10;
-function getFileNamesMessage(fileNamesOrResources) {
-    const message = [];
-    message.push(...( fileNamesOrResources.slice(0, MAX_CONFIRM_FILES).map(
-        fileNameOrResource => typeof fileNameOrResource === 'string' ? fileNameOrResource : basename(fileNameOrResource)
-    )));
-    if (fileNamesOrResources.length > MAX_CONFIRM_FILES) {
-        if (fileNamesOrResources.length - MAX_CONFIRM_FILES === 1) {
-            message.push(( localize('moreFile', "...1 additional file not shown")));
-        }
-        else {
-            message.push(( localize(
-                'moreFiles',
-                "...{0} additional files not shown",
-                fileNamesOrResources.length - MAX_CONFIRM_FILES
-            )));
-        }
-    }
-    message.push('');
-    return message.join('\n');
-}
-export { AbstractDialogHandler, IDialogService, IFileDialogService, getFileNamesMessage };

package/dist/vscode/vs/workbench/contrib/languageDetection/browser/languageDetection.contribution.js

@@ -1,132 +0,0 @@
-import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
-import { DisposableStore } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
-import { localize } from 'monaco-editor/esm/vs/nls.js';
-import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
-import { Extensions } from '../../../common/contributions.js';
-import { IEditorService } from '../../../services/editor/common/editorService.js';
-import { IStatusbarService } from '../../../services/statusbar/browser/statusbar.js';
-import { ILanguageDetectionService, LanguageDetectionLanguageEventSource } from '../../../services/languageDetection/common/languageDetectionWorkerService.js';
-import { ThrottledDelayer } from 'monaco-editor/esm/vs/base/common/async.js';
-import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
-import { IKeybindingService } from 'monaco-editor/esm/vs/platform/keybinding/common/keybinding.js';
-import { registerAction2, Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
-import { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
-import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-import { NOTEBOOK_EDITOR_EDITABLE } from '../../notebook/common/notebookContextKeys.js';
-import { EditorContextKeys } from 'monaco-editor/esm/vs/editor/common/editorContextKeys.js';
-import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
-import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
-const detectLanguageCommandId = 'editor.detectLanguage';
-let LanguageDetectionStatusContribution = class LanguageDetectionStatusContribution {
-    constructor(_languageDetectionService, _statusBarService, _configurationService, _editorService, _languageService, _keybindingService) {
-        this._languageDetectionService = _languageDetectionService;
-        this._statusBarService = _statusBarService;
-        this._configurationService = _configurationService;
-        this._editorService = _editorService;
-        this._languageService = _languageService;
-        this._keybindingService = _keybindingService;
-        this._disposables = ( new DisposableStore());
-        this._delayer = ( new ThrottledDelayer(1000));
-        this._renderDisposables = ( new DisposableStore());
-        _editorService.onDidActiveEditorChange(() => this._update(true), this, this._disposables);
-        this._update(false);
-    }
-    dispose() {
-        this._disposables.dispose();
-        this._delayer.dispose();
-        this._combinedEntry?.dispose();
-        this._renderDisposables.dispose();
-    }
-    _update(clear) {
-        if (clear) {
-            this._combinedEntry?.dispose();
-            this._combinedEntry = undefined;
-        }
-        this._delayer.trigger(() => this._doUpdate());
-    }
-    async _doUpdate() {
-        const editor = getCodeEditor(this._editorService.activeTextEditorControl);
-        this._renderDisposables.clear();
-        editor?.onDidChangeModelLanguage(() => this._update(true), this, this._renderDisposables);
-        editor?.onDidChangeModelContent(() => this._update(false), this, this._renderDisposables);
-        const editorModel = editor?.getModel();
-        const editorUri = editorModel?.uri;
-        const existingId = editorModel?.getLanguageId();
-        const enablementConfig = this._configurationService.getValue('workbench.editor.languageDetectionHints');
-        const enabled = typeof enablementConfig === 'object' && enablementConfig?.untitledEditors;
-        const disableLightbulb = !enabled || editorUri?.scheme !== Schemas.untitled || !existingId;
-        if (disableLightbulb || !editorUri) {
-            this._combinedEntry?.dispose();
-            this._combinedEntry = undefined;
-        }
-        else {
-            const lang = await this._languageDetectionService.detectLanguage(editorUri);
-            const skip = { 'jsonc': 'json' };
-            const existing = editorModel.getLanguageId();
-            if (lang && lang !== existing && skip[existing] !== lang) {
-                const detectedName = this._languageService.getLanguageName(lang) || lang;
-                let tooltip = ( localize('status.autoDetectLanguage', "Accept Detected Language: {0}", detectedName));
-                const keybinding = this._keybindingService.lookupKeybinding(detectLanguageCommandId);
-                const label = keybinding?.getLabel();
-                if (label) {
-                    tooltip += ` (${label})`;
-                }
-                const props = {
-                    name: ( localize('langDetection.name', "Language Detection")),
-                    ariaLabel: ( localize('langDetection.aria', "Change to Detected Language: {0}", lang)),
-                    tooltip,
-                    command: detectLanguageCommandId,
-                    text: '$(lightbulb-autofix)',
-                };
-                if (!this._combinedEntry) {
-                    this._combinedEntry = this._statusBarService.addEntry(props, LanguageDetectionStatusContribution._id, 1 , { id: 'status.editor.mode', alignment: 1 , compact: true });
-                }
-                else {
-                    this._combinedEntry.update(props);
-                }
-            }
-            else {
-                this._combinedEntry?.dispose();
-                this._combinedEntry = undefined;
-            }
-        }
-    }
-};
-LanguageDetectionStatusContribution._id = 'status.languageDetectionStatus';
-LanguageDetectionStatusContribution = ( __decorate([
-    ( __param(0, ILanguageDetectionService)),
-    ( __param(1, IStatusbarService)),
-    ( __param(2, IConfigurationService)),
-    ( __param(3, IEditorService)),
-    ( __param(4, ILanguageService)),
-    ( __param(5, IKeybindingService))
-], LanguageDetectionStatusContribution));
-( Registry.as(Extensions.Workbench)).registerWorkbenchContribution(LanguageDetectionStatusContribution, 3 );
-registerAction2(class extends Action2 {
-    constructor() {
-        super({
-            id: detectLanguageCommandId,
-            title: { value: ( localize('detectlang', 'Detect Language from Content')), original: 'Detect Language from Content' },
-            f1: true,
-            precondition: ( ContextKeyExpr.and(( NOTEBOOK_EDITOR_EDITABLE.toNegated()), EditorContextKeys.editorTextFocus)),
-            keybinding: { primary: 34  | 512  | 1024 , weight: 200  }
-        });
-    }
-    async run(accessor) {
-        const editorService = accessor.get(IEditorService);
-        const languageDetectionService = accessor.get(ILanguageDetectionService);
-        const editor = getCodeEditor(editorService.activeTextEditorControl);
-        const notificationService = accessor.get(INotificationService);
-        const editorUri = editor?.getModel()?.uri;
-        if (editorUri) {
-            const lang = await languageDetectionService.detectLanguage(editorUri);
-            if (lang) {
-                editor.getModel()?.setLanguage(lang, LanguageDetectionLanguageEventSource);
-            }
-            else {
-                notificationService.warn(( localize('noDetection', "Unable to detect editor language")));
-            }
-        }
-    }
-});

package/dist/vscode/vs/workbench/contrib/notebook/common/notebookContextKeys.js

@@ -1,3 +0,0 @@
-import { RawContextKey } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
-const NOTEBOOK_EDITOR_EDITABLE = ( new RawContextKey('notebookEditable', true));
-export { NOTEBOOK_EDITOR_EDITABLE };

package/dist/vscode/vs/workbench/services/languageDetection/browser/languageDetectionSimpleWorker.js

@@ -1,173 +0,0 @@
-import { ModelOperations } from '@vscode/vscode-languagedetection';
-import { StopWatch } from 'monaco-editor/esm/vs/base/common/stopwatch.js';
-import { EditorSimpleWorker } from 'monaco-editor/esm/vs/editor/common/services/editorSimpleWorker.js';
-function create(host) {
-    return ( new LanguageDetectionSimpleWorker(host, null));
-}
-class LanguageDetectionSimpleWorker extends EditorSimpleWorker {
-    constructor() {
-        super(...arguments);
-        this._loadFailed = false;
-        this.modelIdToCoreId = ( new Map());
-    }
-    async detectLanguage(uri, langBiases, preferHistory, supportedLangs) {
-        const languages = [];
-        const confidences = [];
-        const stopWatch = ( new StopWatch());
-        const documentTextSample = this.getTextForDetection(uri);
-        if (!documentTextSample) {
-            return;
-        }
-        const neuralResolver = async () => {
-            for await (const language of this.detectLanguagesImpl(documentTextSample)) {
-                if (!( this.modelIdToCoreId.has(language.languageId))) {
-                    this.modelIdToCoreId.set(language.languageId, await this._host.fhr('getLanguageId', [language.languageId]));
-                }
-                const coreId = this.modelIdToCoreId.get(language.languageId);
-                if (coreId && (!supportedLangs?.length || supportedLangs.includes(coreId))) {
-                    languages.push(coreId);
-                    confidences.push(language.confidence);
-                }
-            }
-            stopWatch.stop();
-            if (languages.length) {
-                this._host.fhr('sendTelemetryEvent', [languages, confidences, stopWatch.elapsed()]);
-                return languages[0];
-            }
-            return undefined;
-        };
-        const neural = await neuralResolver();
-        if (neural) {
-            return neural;
-        }
-        return undefined;
-    }
-    getTextForDetection(uri) {
-        const editorModel = this._getModel(uri);
-        if (!editorModel) {
-            return;
-        }
-        const end = editorModel.positionAt(10000);
-        const content = editorModel.getValueInRange({
-            startColumn: 1,
-            startLineNumber: 1,
-            endColumn: end.column,
-            endLineNumber: end.lineNumber
-        });
-        return content;
-    }
-    async getModelOperations() {
-        if (this._modelOperations) {
-            return this._modelOperations;
-        }
-        this._modelOperations = ( new ModelOperations({
-            modelJsonLoaderFunc: async () => {
-                const response = await fetch(await this._host.fhr('getModelJsonUri', []));
-                try {
-                    const modelJSON = await response.json();
-                    return modelJSON;
-                }
-                catch (e) {
-                    const message = `Failed to parse model JSON.`;
-                    throw new Error(message);
-                }
-            },
-            weightsLoaderFunc: async () => {
-                const response = await fetch(await this._host.fhr('getWeightsUri', []));
-                const buffer = await response.arrayBuffer();
-                return buffer;
-            }
-        }));
-        return this._modelOperations;
-    }
-    adjustLanguageConfidence(modelResult) {
-        switch (modelResult.languageId) {
-            case 'js':
-            case 'html':
-            case 'json':
-            case 'ts':
-            case 'css':
-            case 'py':
-            case 'xml':
-            case 'php':
-                modelResult.confidence += LanguageDetectionSimpleWorker.positiveConfidenceCorrectionBucket1;
-                break;
-            case 'cpp':
-            case 'sh':
-            case 'java':
-            case 'cs':
-            case 'c':
-                modelResult.confidence += LanguageDetectionSimpleWorker.positiveConfidenceCorrectionBucket2;
-                break;
-            case 'bat':
-            case 'ini':
-            case 'makefile':
-            case 'sql':
-            case 'csv':
-            case 'toml':
-                modelResult.confidence -= LanguageDetectionSimpleWorker.negativeConfidenceCorrection;
-                break;
-        }
-        return modelResult;
-    }
-    async *detectLanguagesImpl(content) {
-        if (this._loadFailed) {
-            return;
-        }
-        let modelOperations;
-        try {
-            modelOperations = await this.getModelOperations();
-        }
-        catch (e) {
-            console.log(e);
-            this._loadFailed = true;
-            return;
-        }
-        let modelResults;
-        try {
-            modelResults = await modelOperations.runModel(content);
-        }
-        catch (e) {
-            console.warn(e);
-        }
-        if (!modelResults
-            || modelResults.length === 0
-            || modelResults[0].confidence < LanguageDetectionSimpleWorker.expectedRelativeConfidence) {
-            return;
-        }
-        const firstModelResult = this.adjustLanguageConfidence(modelResults[0]);
-        if (firstModelResult.confidence < LanguageDetectionSimpleWorker.expectedRelativeConfidence) {
-            return;
-        }
-        const possibleLanguages = [firstModelResult];
-        for (let current of modelResults) {
-            if (current === firstModelResult) {
-                continue;
-            }
-            current = this.adjustLanguageConfidence(current);
-            const currentHighest = possibleLanguages[possibleLanguages.length - 1];
-            if (currentHighest.confidence - current.confidence >= LanguageDetectionSimpleWorker.expectedRelativeConfidence) {
-                while (possibleLanguages.length) {
-                    yield possibleLanguages.shift();
-                }
-                if (current.confidence > LanguageDetectionSimpleWorker.expectedRelativeConfidence) {
-                    possibleLanguages.push(current);
-                    continue;
-                }
-                return;
-            }
-            else {
-                if (current.confidence > LanguageDetectionSimpleWorker.expectedRelativeConfidence) {
-                    possibleLanguages.push(current);
-                    continue;
-                }
-                return;
-            }
-        }
-    }
-}
-LanguageDetectionSimpleWorker.expectedRelativeConfidence = 0.2;
-LanguageDetectionSimpleWorker.positiveConfidenceCorrectionBucket1 = 0.05;
-LanguageDetectionSimpleWorker.positiveConfidenceCorrectionBucket2 = 0.025;
-LanguageDetectionSimpleWorker.negativeConfidenceCorrection = 0.5;
-export { LanguageDetectionSimpleWorker, create };