@codingame/monaco-vscode-configuration-service-override 1.82.4 → 1.82.5-next.1

package/configuration.d.ts

@@ -0,0 +1,15 @@
+import { IEditorOverrideServices } from 'vscode/vscode/vs/editor/standalone/browser/standaloneServices';
+import { IConfigurationRegistry } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+export { ConfigurationScope, IConfigurationDefaults, IConfigurationNode } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+import { Disposable } from 'vscode';
+import { IAnyWorkspaceIdentifier } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+export { IAnyWorkspaceIdentifier, IEmptyWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+import { URI } from 'vscode/vscode/vs/base/common/uri';
+
+declare function updateUserConfiguration(configurationJson: string): Promise<void>;
+declare function getUserConfiguration(): Promise<string>;
+declare function onUserConfigurationChange(callback: () => void): Disposable;
+declare const configurationRegistry: IConfigurationRegistry;
+declare function getServiceOverride(defaultWorkspace: URI | IAnyWorkspaceIdentifier): IEditorOverrideServices;
+
+export { configurationRegistry, getServiceOverride as default, getUserConfiguration, onUserConfigurationChange, updateUserConfiguration };

package/configuration.js

@@ -0,0 +1,118 @@
+import { __decorate, __param } from './external/tslib/tslib.es6.js';
+import { StandaloneServices } from 'monaco-editor/esm/vs/editor/standalone/browser/standaloneServices.js';
+import { WorkspaceService } from './vscode/src/vs/workbench/services/configuration/browser/configurationService.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { TextResourceConfigurationService } from './vscode/src/vs/editor/common/services/textResourceConfigurationService.js';
+import { SyncDescriptor } from 'monaco-editor/esm/vs/platform/instantiation/common/descriptors.js';
+export { ConfigurationScope } from './vscode/src/vs/platform/configuration/common/configurationRegistry.js';
+import { Extensions } from 'monaco-editor/esm/vs/platform/configuration/common/configurationRegistry.js';
+import { Registry } from 'monaco-editor/esm/vs/platform/registry/common/platform.js';
+import { VSBuffer } from 'monaco-editor/esm/vs/base/common/buffer.js';
+import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+import { IUserDataProfilesService } from 'monaco-editor/esm/vs/platform/userDataProfile/common/userDataProfile.js';
+import { IPolicyService } from 'monaco-editor/esm/vs/platform/policy/common/policy.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { IUserDataProfileService } from 'vscode/vscode/vs/workbench/services/userDataProfile/common/userDataProfile';
+import { IRemoteAgentService } from 'vscode/vscode/vs/workbench/services/remote/common/remoteAgentService';
+import { IUriIdentityService } from 'monaco-editor/esm/vs/platform/uriIdentity/common/uriIdentity.js';
+import { ConfigurationCache } from './vscode/src/vs/workbench/services/configuration/common/configurationCache.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IWorkbenchEnvironmentService } from 'vscode/vscode/vs/workbench/services/environment/common/environmentService';
+import { IWorkspaceContextService } from 'monaco-editor/esm/vs/platform/workspace/common/workspace.js';
+import { LabelService } from './vscode/src/vs/workbench/services/label/common/labelService.js';
+import { ILabelService } from 'monaco-editor/esm/vs/platform/label/common/label.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { IWorkspacesService } from 'vscode/vscode/vs/platform/workspaces/common/workspaces';
+import { BrowserWorkspacesService } from './vscode/src/vs/workbench/services/workspaces/browser/workspacesService.js';
+import { IWorkspaceEditingService } from 'vscode/vscode/vs/workbench/services/workspaces/common/workspaceEditing';
+import { AbstractWorkspaceEditingService } from './vscode/src/vs/workbench/services/workspaces/browser/abstractWorkspaceEditingService.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import './vscode/src/vs/workbench/api/common/configurationExtensionPoint.js';
+import getServiceOverride$1 from 'vscode/service-override/files';
+import { memoizedConstructor, unsupported } from './tools.js';
+import { registerServiceInitializePreParticipant } from 'vscode/lifecycle';
+
+async function updateUserConfiguration(configurationJson) {
+    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
+    await StandaloneServices.get(IFileService).writeFile(userDataProfilesService.defaultProfile.settingsResource, VSBuffer.fromString(configurationJson));
+}
+async function getUserConfiguration() {
+    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
+    return ( (await StandaloneServices.get(IFileService).readFile(userDataProfilesService.defaultProfile.settingsResource)).value.toString());
+}
+function onUserConfigurationChange(callback) {
+    const userDataProfilesService = StandaloneServices.get(IUserDataProfilesService);
+    return StandaloneServices.get(IFileService).onDidFilesChange(e => {
+        if (e.affects(userDataProfilesService.defaultProfile.settingsResource)) {
+            callback();
+        }
+    });
+}
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+let InjectedConfigurationService = class InjectedConfigurationService extends WorkspaceService {
+    constructor(workbenchEnvironmentService, userDataProfileService, userDataProfilesService, fileService, remoteAgentService, uriIdentityService, logService, policyService) {
+        const configurationCache = new ConfigurationCache([Schemas.file, Schemas.vscodeUserData, Schemas.tmp], workbenchEnvironmentService, fileService);
+        super({ configurationCache }, workbenchEnvironmentService, userDataProfileService, userDataProfilesService, fileService, remoteAgentService, uriIdentityService, logService, policyService);
+    }
+};
+InjectedConfigurationService = __decorate([
+    ( __param(0, IWorkbenchEnvironmentService)),
+    ( __param(1, IUserDataProfileService)),
+    ( __param(2, IUserDataProfilesService)),
+    ( __param(3, IFileService)),
+    ( __param(4, IRemoteAgentService)),
+    ( __param(5, IUriIdentityService)),
+    ( __param(6, ILogService)),
+    ( __param(7, IPolicyService))
+], InjectedConfigurationService);
+class MonacoWorkspaceEditingService extends AbstractWorkspaceEditingService {
+    constructor() {
+        super(...arguments);
+        this.enterWorkspace = unsupported;
+    }
+}
+let _defaultWorkspace = URI.file('/workspace');
+registerServiceInitializePreParticipant(async (accessor) => {
+    const workspaceService = accessor.get(IWorkspaceContextService);
+    workspaceService.acquireInstantiationService(accessor.get(IInstantiationService));
+    if (URI.isUri(_defaultWorkspace)) {
+        const configPath = _defaultWorkspace.with({ path: '/workspace.code-workspace' });
+        try {
+            const fileService = accessor.get(IFileService);
+            await fileService.createFolder(_defaultWorkspace);
+            await fileService.writeFile(configPath, VSBuffer.fromString(JSON.stringify({
+                folders: [
+                    {
+                        path: _defaultWorkspace.path
+                    }
+                ]
+            })));
+        }
+        catch (err) {
+        }
+        await workspaceService.initialize({
+            id: generateUuid(),
+            configPath
+        });
+    }
+    else {
+        await workspaceService.initialize(_defaultWorkspace);
+    }
+});
+const MemoizedInjectedConfigurationService = memoizedConstructor(InjectedConfigurationService);
+function getServiceOverride(defaultWorkspace) {
+    _defaultWorkspace = defaultWorkspace;
+    return {
+        ...getServiceOverride$1(),
+        [( ILabelService.toString())]: new SyncDescriptor(LabelService, undefined, true),
+        [( IConfigurationService.toString())]: new SyncDescriptor(MemoizedInjectedConfigurationService, [], true),
+        [( IWorkspaceContextService.toString())]: new SyncDescriptor(MemoizedInjectedConfigurationService, [], true),
+        [( ITextResourceConfigurationService.toString())]: new SyncDescriptor(TextResourceConfigurationService, [], true),
+        [( IWorkspaceEditingService.toString())]: new SyncDescriptor(MonacoWorkspaceEditingService, [], true),
+        [( IWorkspacesService.toString())]: new SyncDescriptor(BrowserWorkspacesService, undefined, true)
+    };
+}
+
+export { configurationRegistry, getServiceOverride as default, getUserConfiguration, onUserConfigurationChange, updateUserConfiguration };

package/external/tslib/tslib.es6.js

@@ -0,0 +1,11 @@
+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); }
+}
+
+export { __decorate, __param };

package/index.d.ts

@@ -1,2 +1,5 @@
-export { default } from 'vscode/service-override/configuration'
-export * from 'vscode/service-override/configuration'
+export { configurationRegistry, default, getUserConfiguration, onUserConfigurationChange, updateUserConfiguration } from './configuration.js';
+export { ConfigurationScope, IConfigurationDefaults, IConfigurationNode } from 'vscode/vscode/vs/platform/configuration/common/configurationRegistry';
+export { IColorCustomizations, IThemeScopedColorCustomizations } from 'vscode/vscode/vs/workbench/services/themes/common/workbenchThemeService';
+export { IAnyWorkspaceIdentifier, IEmptyWorkspaceIdentifier, ISingleFolderWorkspaceIdentifier, IWorkspaceIdentifier } from 'vscode/vscode/vs/platform/workspace/common/workspace';
+export { IWorkspaceFolderCreationData } from 'vscode/vscode/vs/platform/workspaces/common/workspaces';

package/index.js

@@ -1,2 +1,2 @@
-export { default } from 'vscode/service-override/configuration'
-export * from 'vscode/service-override/configuration'
+export { configurationRegistry, default, getUserConfiguration, onUserConfigurationChange, updateUserConfiguration } from './configuration.js';
+export { ConfigurationScope } from './vscode/src/vs/platform/configuration/common/configurationRegistry.js';

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

@@ -0,0 +1,8 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-configuration-service-override",
-  "version": "1.82.4",
+  "version": "1.82.5-next.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,7 +18,7 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@1.82.4",
+    "vscode": "npm:@codingame/monaco-vscode-api@1.82.5-next.1",
     "monaco-editor": "0.43.0"
   }
 }

package/tools.js

@@ -0,0 +1,21 @@
+function unsupported() {
+    throw new Error('unsupported');
+}
+function memoized(fct) {
+    let v = null;
+    return (...args) => {
+        if (v == null) {
+            v = fct(...args);
+        }
+        return v;
+    };
+}
+function memoizedConstructor(ctor) {
+    return new Proxy(ctor, {
+        construct: memoized((target, args) => {
+            return Reflect.construct(ctor, args);
+        })
+    });
+}
+
+export { memoized, memoizedConstructor, unsupported };

package/vscode/src/vs/editor/common/services/textResourceConfigurationService.js

@@ -0,0 +1,118 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { Position } from 'monaco-editor/esm/vs/editor/common/core/position.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+
+let TextResourceConfigurationService = class TextResourceConfigurationService extends Disposable {
+    constructor(configurationService, modelService, languageService) {
+        super();
+        this.configurationService = configurationService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this._onDidChangeConfiguration = this._register(( new Emitter()));
+        this.onDidChangeConfiguration = this._onDidChangeConfiguration.event;
+        this._register(this.configurationService.onDidChangeConfiguration(e => this._onDidChangeConfiguration.fire(this.toResourceConfigurationChangeEvent(e))));
+    }
+    getValue(resource, arg2, arg3) {
+        if (typeof arg3 === 'string') {
+            return this._getValue(resource, Position.isIPosition(arg2) ? arg2 : null, arg3);
+        }
+        return this._getValue(resource, null, typeof arg2 === 'string' ? arg2 : undefined);
+    }
+    updateValue(resource, key, value, configurationTarget) {
+        const language = this.getLanguage(resource, null);
+        const configurationValue = this.configurationService.inspect(key, { resource, overrideIdentifier: language });
+        if (configurationTarget === undefined) {
+            configurationTarget = this.deriveConfigurationTarget(configurationValue, language);
+        }
+        switch (configurationTarget) {
+            case 8 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.memory?.override, resource, language);
+            case 6 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.workspaceFolder?.override, resource, language);
+            case 5 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.workspace?.override, resource, language);
+            case 4 :
+                return this._updateValue(key, value, configurationTarget, configurationValue.userRemote?.override, resource, language);
+            default:
+                return this._updateValue(key, value, configurationTarget, configurationValue.userLocal?.override, resource, language);
+        }
+    }
+    _updateValue(key, value, configurationTarget, overriddenValue, resource, language) {
+        if (language && overriddenValue !== undefined) {
+            return this.configurationService.updateValue(key, value, { resource, overrideIdentifier: language }, configurationTarget);
+        }
+        else {
+            return this.configurationService.updateValue(key, value, { resource }, configurationTarget);
+        }
+    }
+    deriveConfigurationTarget(configurationValue, language) {
+        if (language) {
+            if (configurationValue.memory?.override !== undefined) {
+                return 8 ;
+            }
+            if (configurationValue.workspaceFolder?.override !== undefined) {
+                return 6 ;
+            }
+            if (configurationValue.workspace?.override !== undefined) {
+                return 5 ;
+            }
+            if (configurationValue.userRemote?.override !== undefined) {
+                return 4 ;
+            }
+            if (configurationValue.userLocal?.override !== undefined) {
+                return 3 ;
+            }
+        }
+        if (configurationValue.memory?.value !== undefined) {
+            return 8 ;
+        }
+        if (configurationValue.workspaceFolder?.value !== undefined) {
+            return 6 ;
+        }
+        if (configurationValue.workspace?.value !== undefined) {
+            return 5 ;
+        }
+        if (configurationValue.userRemote?.value !== undefined) {
+            return 4 ;
+        }
+        return 3 ;
+    }
+    _getValue(resource, position, section) {
+        const language = resource ? this.getLanguage(resource, position) : undefined;
+        if (typeof section === 'undefined') {
+            return this.configurationService.getValue({ resource, overrideIdentifier: language });
+        }
+        return this.configurationService.getValue(section, { resource, overrideIdentifier: language });
+    }
+    inspect(resource, position, section) {
+        const language = resource ? this.getLanguage(resource, position) : undefined;
+        return this.configurationService.inspect(section, { resource, overrideIdentifier: language });
+    }
+    getLanguage(resource, position) {
+        const model = this.modelService.getModel(resource);
+        if (model) {
+            return position ? model.getLanguageIdAtPosition(position.lineNumber, position.column) : model.getLanguageId();
+        }
+        return this.languageService.guessLanguageIdByFilepathOrFirstLine(resource);
+    }
+    toResourceConfigurationChangeEvent(configurationChangeEvent) {
+        return {
+            affectedKeys: configurationChangeEvent.affectedKeys,
+            affectsConfiguration: (resource, configuration) => {
+                const overrideIdentifier = resource ? this.getLanguage(resource, null) : undefined;
+                return configurationChangeEvent.affectsConfiguration(configuration, { resource, overrideIdentifier });
+            }
+        };
+    }
+};
+TextResourceConfigurationService = ( __decorate([
+    ( __param(0, IConfigurationService)),
+    ( __param(1, IModelService)),
+    ( __param(2, ILanguageService))
+], TextResourceConfigurationService));
+
+export { TextResourceConfigurationService };

package/vscode/src/vs/platform/configuration/common/configurationRegistry.js

@@ -0,0 +1,11 @@
+var ConfigurationScope;
+( (function(ConfigurationScope) {
+    ConfigurationScope[ConfigurationScope["APPLICATION"] = 1] = "APPLICATION";
+    ConfigurationScope[ConfigurationScope["MACHINE"] = 2] = "MACHINE";
+    ConfigurationScope[ConfigurationScope["WINDOW"] = 3] = "WINDOW";
+    ConfigurationScope[ConfigurationScope["RESOURCE"] = 4] = "RESOURCE";
+    ConfigurationScope[ConfigurationScope["LANGUAGE_OVERRIDABLE"] = 5] = "LANGUAGE_OVERRIDABLE";
+    ConfigurationScope[ConfigurationScope["MACHINE_OVERRIDABLE"] = 6] = "MACHINE_OVERRIDABLE";
+})(ConfigurationScope || (ConfigurationScope = {})));
+
+export { ConfigurationScope };