@codingame/monaco-vscode-api 1.67.15 → 1.67.18

package/dist/monaco.js

@@ -0,0 +1,149 @@
+import { b as __decorate, c as __param } from './tslib.es6-16b40665.js';
+import { _util, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { isObject } from 'monaco-editor/esm/vs/base/common/types.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { StandaloneEditor, StandaloneDiffEditor } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneCodeEditor.js';
+function equals(one, other) {
+    if (one === other) {
+        return true;
+    }
+    if (one === null || one === undefined || other === null || other === undefined) {
+        return false;
+    }
+    if (typeof one !== typeof other) {
+        return false;
+    }
+    if (typeof one !== 'object') {
+        return false;
+    }
+    if ((Array.isArray(one)) !== (Array.isArray(other))) {
+        return false;
+    }
+    let i;
+    let key;
+    if (Array.isArray(one)) {
+        if (one.length !== other.length) {
+            return false;
+        }
+        for (i = 0; i < one.length; i++) {
+            if (!equals(one[i], other[i])) {
+                return false;
+            }
+        }
+    }
+    else {
+        const oneKeys = [];
+        for (key in one) {
+            oneKeys.push(key);
+        }
+        oneKeys.sort();
+        const otherKeys = [];
+        for (key in other) {
+            otherKeys.push(key);
+        }
+        otherKeys.sort();
+        if (!equals(oneKeys, otherKeys)) {
+            return false;
+        }
+        for (i = 0; i < oneKeys.length; i++) {
+            if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function distinct(base, target) {
+    const result = Object.create(null);
+    if (!base || !target) {
+        return result;
+    }
+    const targetKeys = Object.keys(target);
+    targetKeys.forEach(k => {
+        const baseValue = base[k];
+        const targetValue = target[k];
+        if (!equals(baseValue, targetValue)) {
+            result[k] = targetValue;
+        }
+    });
+    return result;
+}
+function getInjectedParameters(instantiationService, ctor) {
+    return instantiationService.invokeFunction((accessor) => {
+        return _util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index).map(d => accessor.get(d.id));
+    });
+}
+function createInjectedClass(ctor) {
+    const _ctor = ctor;
+    return class extends _ctor {
+        constructor(...args) {
+            super(...args.slice(1), ...getInjectedParameters(args[0], ctor));
+        }
+    };
+}
+function computeConfiguration(configuration, isDiffEditor, overrides) {
+    const editorConfiguration = isObject(configuration.editor) ? deepClone(configuration.editor) : Object.create(null);
+    if (isDiffEditor && isObject(configuration.diffEditor)) {
+        Object.assign(editorConfiguration, configuration.diffEditor);
+    }
+    if (isObject(configuration.diffEditor)) {
+        Object.assign(editorConfiguration, overrides);
+    }
+    return editorConfiguration;
+}
+let ConfiguredStandaloneEditor = class ConfiguredStandaloneEditor extends createInjectedClass(StandaloneEditor) {
+    constructor(domElement, isDiffEditor, _options, instantiationService, textResourceConfigurationService) {
+        const computedOptions = computeConfiguration(textResourceConfigurationService.getValue(_options?.model?.uri), isDiffEditor, _options);
+        super(instantiationService, domElement, computedOptions);
+        this.isDiffEditor = isDiffEditor;
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.lastAppliedEditorOptions = computedOptions;
+        this.optionsOverrides = _options;
+        this._register(textResourceConfigurationService.onDidChangeConfiguration(() => this.updateEditorConfiguration()));
+        this._register(this.onDidChangeModelLanguage(() => this.updateEditorConfiguration()));
+        this._register(this.onDidChangeModel(() => this.updateEditorConfiguration()));
+    }
+    updateEditorConfiguration() {
+        const resource = this.getModel()?.uri;
+        if (resource == null) {
+            return;
+        }
+        const configuration = this.textResourceConfigurationService.getValue(resource);
+        if (configuration == null) {
+            return;
+        }
+        const editorConfiguration = computeConfiguration(configuration, this.isDiffEditor, this.optionsOverrides);
+        let editorSettingsToApply = editorConfiguration;
+        if (this.lastAppliedEditorOptions != null) {
+            editorSettingsToApply = distinct(this.lastAppliedEditorOptions, editorSettingsToApply);
+        }
+        if (Object.keys(editorSettingsToApply).length > 0) {
+            this.lastAppliedEditorOptions = editorConfiguration;
+            super.updateOptions(editorSettingsToApply);
+        }
+    }
+    updateOptions(newOptions) {
+        this.optionsOverrides = newOptions;
+        this.updateEditorConfiguration();
+    }
+};
+ConfiguredStandaloneEditor = __decorate([
+    __param(3, IInstantiationService),
+    __param(4, ITextResourceConfigurationService)
+], ConfiguredStandaloneEditor);
+class ConfiguredStandaloneDiffEditor extends StandaloneDiffEditor {
+    _createInnerEditor(instantiationService, container, options) {
+        return instantiationService.createInstance(ConfiguredStandaloneEditor, container, true, options);
+    }
+}
+const createConfiguredEditor = (domElement, options, override) => {
+    const instantiationService = StandaloneServices.initialize(override ?? {});
+    return instantiationService.createInstance(ConfiguredStandaloneEditor, domElement, false, options);
+};
+const createConfiguredDiffEditor = (domElement, options, override) => {
+    const instantiationService = StandaloneServices.initialize(override ?? {});
+    return instantiationService.createInstance(ConfiguredStandaloneDiffEditor, domElement, options);
+};
+export { createConfiguredDiffEditor, createConfiguredEditor };

package/dist/position-291dfe99.js

@@ -0,0 +1,3 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api.js';
+const Position = monaco.Position;
+export { Position as P };

package/dist/{services-7a462d46.js → services-9299c4ca.js}

@@ -1,5 +1,6 @@
 import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
 import { IEnvironmentService } from 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import { b as __decorate, c as __param } from './tslib.es6-16b40665.js';
 import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
 import { isWindows, OS } from 'monaco-editor/esm/vs/base/common/platform.js';
 import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
@@ -379,26 +380,6 @@ class NoOpProgress {
     total(value) { }
     worked(value) { }
 }
-function __decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function __param(paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-}
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
 const IFileService =  createDecorator('fileService');
 var FileType;
  (function(FileType) {
@@ -1032,4 +1013,4 @@ var Services;
     }
     Services.install = install;
 })(Services || (Services = {}));
-export { ACTIVE_GROUP as A, NeverShowAgainScope as B, CancellationTokenSource as C, isPreferredGroup as D, ensureFileSystemProviderError as E, FileSystemProviderErrorCode as F, createFileSystemProviderError as G, FileChangesEvent as H, IProgressService as I, FileOperationError as J, hasOpenReadWriteCloseCapability as K, hasReadWriteCapability as L, hasFileReadStreamCapability as M, NoOpNotification as N, toFileSystemProviderErrorCode as O, etag as P, FileOperationEvent as Q, toFileOperationResult as R, SIDE_GROUP as S, ETAG_DISABLED as T, hasFileAtomicReadCapability as U, NotModifiedSinceFileOperationError as V, hasFileFolderCopyCapability as W, __classPrivateFieldSet as _, __classPrivateFieldGet as a, __decorate as b, coalesceInPlace as c, __param as d, delta as e, mapArrayOrNot as f, ITextFileService as g, IFileService as h, IWorkbenchEnvironmentService as i, IUriIdentityService as j, IWorkingCopyFileService as k, IPathService as l, markAsFileSystemProviderError as m, disposed as n, IEditorService as o, IEditorGroupsService as p, IPaneCompositePartService as q, readonly as r, IProductService as s, ILanguageStatusService as t, IHostService as u, Services as v, FileType as w, FilePermission as x, NotificationsFilter as y, refineServiceDecorator as z };
+export { ACTIVE_GROUP as A, createFileSystemProviderError as B, CancellationTokenSource as C, FileChangesEvent as D, FileOperationError as E, FileSystemProviderErrorCode as F, hasOpenReadWriteCloseCapability as G, hasReadWriteCapability as H, IProgressService as I, hasFileReadStreamCapability as J, toFileSystemProviderErrorCode as K, etag as L, FileOperationEvent as M, NoOpNotification as N, toFileOperationResult as O, ETAG_DISABLED as P, hasFileAtomicReadCapability as Q, NotModifiedSinceFileOperationError as R, SIDE_GROUP as S, hasFileFolderCopyCapability as T, mapArrayOrNot as a, ITextFileService as b, coalesceInPlace as c, delta as d, IFileService as e, IWorkbenchEnvironmentService as f, IUriIdentityService as g, IWorkingCopyFileService as h, IPathService as i, disposed as j, IEditorService as k, IEditorGroupsService as l, markAsFileSystemProviderError as m, IPaneCompositePartService as n, IProductService as o, ILanguageStatusService as p, IHostService as q, readonly as r, Services as s, FileType as t, FilePermission as u, NotificationsFilter as v, refineServiceDecorator as w, NeverShowAgainScope as x, isPreferredGroup as y, ensureFileSystemProviderError as z };

package/dist/services.d.ts

@@ -8402,9 +8402,7 @@ interface ILanguageFeaturesService {
     setNotebookTypeResolver(resolver: NotebooTypeResolver | undefined): void;
 }
 
-interface IEditorOverrideServices {
-    [index: string]: any;
-}
+type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 /**
  * We don't want to eagerly instantiate services because embedders get a one time chance
  * to override services when they create the first editor.

package/dist/services.js

@@ -1,4 +1,4 @@
-export { p as IEditorGroupsService, o as IEditorService, h as IFileService, u as IHostService, t as ILanguageStatusService, q as IPaneCompositePartService, l as IPathService, s as IProductService, g as ITextFileService, j as IUriIdentityService, i as IWorkbenchEnvironmentService, k as IWorkingCopyFileService, y as NotificationsFilter, v as Services } from './services-7a462d46.js';
+export { l as IEditorGroupsService, k as IEditorService, e as IFileService, q as IHostService, p as ILanguageStatusService, n as IPaneCompositePartService, i as IPathService, o as IProductService, b as ITextFileService, g as IUriIdentityService, f as IWorkbenchEnvironmentService, h as IWorkingCopyFileService, v as NotificationsFilter, s as Services } from './services-9299c4ca.js';
 export { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
 export { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
 export { INotificationService } from 'monaco-editor/esm/vs/platform/notification/common/notification.js';
@@ -20,6 +20,7 @@ export { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/commo
 export { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
 export { default as Severity } from 'monaco-editor/esm/vs/base/common/severity.js';
 import 'monaco-editor/esm/vs/platform/environment/common/environment.js';
+import './tslib.es6-16b40665.js';
 import 'monaco-editor/esm/vs/base/common/network.js';
 import 'monaco-editor/esm/vs/base/common/platform.js';
 import 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';

package/dist/tslib.es6-16b40665.js

@@ -0,0 +1,21 @@
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+export { __classPrivateFieldSet as _, __classPrivateFieldGet as a, __decorate as b, __param as c };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.67.15",
+  "version": "1.67.18",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
@@ -35,6 +35,10 @@
     "./service-override/configuration": {
       "types": "./dist/configuration.d.ts",
       "default": "./dist/configuration.js"
+    },
+    "./monaco": {
+      "types": "./dist/monaco.d.ts",
+      "default": "./dist/monaco.js"
     }
   },
   "typesVersions": {
@@ -50,6 +54,9 @@
       ],
       "service-override/configuration": [
         "./dist/configuration.d.ts"
+      ],
+      "monaco": [
+        "./dist/monaco.d.ts"
       ]
     }
   },