@codingame/monaco-vscode-api 1.67.17 → 1.67.18

package/README.md

@@ -58,7 +58,7 @@ Usage:
 import { StandaloneService } from 'vscode/services'
 import getModelEditorServiceOverride from 'vscode/service-override/modelEditor'
 import getMessageServiceOverride from 'vscode/service-override/messages'
-import getConfigurationServiceOverride from 'vscode/service-override/configuration'
+import getConfigurationServiceOverride, { updateUserConfiguration, configurationRegistry } from 'vscode/service-override/configuration'
 
 StandaloneServices.initialize({
   ...getModelEditorServiceOverride((model, input, sideBySide) => {
@@ -66,8 +66,21 @@ StandaloneServices.initialize({
     // It will be called when for instance the user ctrl+click on an import
   }),
   ...getMessageServiceOverride(document.body),
-  ...getConfigurationServiceOverride(() => userConfigurationJson, configurationChangeEvent)
+  ...getConfigurationServiceOverride()
 })
+
+configurationRegistry.registerDefaultConfigurations([{
+  overrides: {
+    'editor.fontSize': 10
+  }
+}])
+
+updateUserConfiguration(`{
+  "editor.fontSize": 12,
+  "[java]": {
+    "editor.fontSize": 15,
+  }
+}`)
 ```
 
 Note: using `vscode/service-override/modelEditor`, you'll be able to use the `vscode.workspace.registerTextDocumentContentProvider` api

package/dist/configuration.d.ts

@@ -285,8 +285,254 @@ interface UriComponents {
     fragment: string;
 }
 
+declare type JSONSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'null' | 'array' | 'object';
+interface IJSONSchema {
+    id?: string;
+    $id?: string;
+    $schema?: string;
+    type?: JSONSchemaType | JSONSchemaType[];
+    title?: string;
+    default?: any;
+    definitions?: IJSONSchemaMap;
+    description?: string;
+    properties?: IJSONSchemaMap;
+    patternProperties?: IJSONSchemaMap;
+    additionalProperties?: boolean | IJSONSchema;
+    minProperties?: number;
+    maxProperties?: number;
+    dependencies?: IJSONSchemaMap | {
+        [prop: string]: string[];
+    };
+    items?: IJSONSchema | IJSONSchema[];
+    minItems?: number;
+    maxItems?: number;
+    uniqueItems?: boolean;
+    additionalItems?: boolean | IJSONSchema;
+    pattern?: string;
+    minLength?: number;
+    maxLength?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: boolean | number;
+    exclusiveMaximum?: boolean | number;
+    multipleOf?: number;
+    required?: string[];
+    $ref?: string;
+    anyOf?: IJSONSchema[];
+    allOf?: IJSONSchema[];
+    oneOf?: IJSONSchema[];
+    not?: IJSONSchema;
+    enum?: any[];
+    format?: string;
+    const?: any;
+    contains?: IJSONSchema;
+    propertyNames?: IJSONSchema;
+    $comment?: string;
+    if?: IJSONSchema;
+    then?: IJSONSchema;
+    else?: IJSONSchema;
+    defaultSnippets?: IJSONSchemaSnippet[];
+    errorMessage?: string;
+    patternErrorMessage?: string;
+    deprecationMessage?: string;
+    markdownDeprecationMessage?: string;
+    enumDescriptions?: string[];
+    markdownEnumDescriptions?: string[];
+    markdownDescription?: string;
+    doNotSuggest?: boolean;
+    suggestSortText?: string;
+    allowComments?: boolean;
+    allowTrailingCommas?: boolean;
+}
+interface IJSONSchemaMap {
+    [name: string]: IJSONSchema;
+}
+interface IJSONSchemaSnippet {
+    label?: string;
+    description?: string;
+    body?: any;
+    bodyText?: string;
+}
+
+/**
+ * An interface for a JavaScript object that
+ * acts a dictionary. The keys are strings.
+ */
+declare type IStringDictionary<V> = Record<string, V>;
+
+declare enum EditPresentationTypes {
+    Multiline = "multilineText",
+    Singleline = "singlelineText"
+}
+interface IConfigurationRegistry {
+    /**
+     * Register a configuration to the registry.
+     */
+    registerConfiguration(configuration: IConfigurationNode): void;
+    /**
+     * Register multiple configurations to the registry.
+     */
+    registerConfigurations(configurations: IConfigurationNode[], validate?: boolean): void;
+    /**
+     * Deregister multiple configurations from the registry.
+     */
+    deregisterConfigurations(configurations: IConfigurationNode[]): void;
+    /**
+     * update the configuration registry by
+     * 	- registering the configurations to add
+     * 	- dereigstering the configurations to remove
+     */
+    updateConfigurations(configurations: {
+        add: IConfigurationNode[];
+        remove: IConfigurationNode[];
+    }): void;
+    /**
+     * Register multiple default configurations to the registry.
+     */
+    registerDefaultConfigurations(defaultConfigurations: IConfigurationDefaults[]): void;
+    /**
+     * Deregister multiple default configurations from the registry.
+     */
+    deregisterDefaultConfigurations(defaultConfigurations: IConfigurationDefaults[]): void;
+    /**
+     * Return the registered configuration defaults overrides
+     */
+    getConfigurationDefaultsOverrides(): Map<string, IConfigurationDefaultOverride>;
+    /**
+     * Signal that the schema of a configuration setting has changes. It is currently only supported to change enumeration values.
+     * Property or default value changes are not allowed.
+     */
+    notifyConfigurationSchemaUpdated(...configurations: IConfigurationNode[]): void;
+    /**
+     * Event that fires whenever a configuration has been
+     * registered.
+     */
+    readonly onDidSchemaChange: Event<void>;
+    /**
+     * Event that fires whenever a configuration has been
+     * registered.
+     */
+    readonly onDidUpdateConfiguration: Event<{
+        properties: string[];
+        defaultsOverrides?: boolean;
+    }>;
+    /**
+     * Returns all configuration nodes contributed to this registry.
+     */
+    getConfigurations(): IConfigurationNode[];
+    /**
+     * Returns all configurations settings of all configuration nodes contributed to this registry.
+     */
+    getConfigurationProperties(): IStringDictionary<IRegisteredConfigurationPropertySchema>;
+    /**
+     * Returns all excluded configurations settings of all configuration nodes contributed to this registry.
+     */
+    getExcludedConfigurationProperties(): IStringDictionary<IRegisteredConfigurationPropertySchema>;
+    /**
+     * Register the identifiers for editor configurations
+     */
+    registerOverrideIdentifiers(identifiers: string[]): void;
+}
+declare const enum ConfigurationScope {
+    /**
+     * Application specific configuration, which can be configured only in local user settings.
+     */
+    APPLICATION = 1,
+    /**
+     * Machine specific configuration, which can be configured only in local and remote user settings.
+     */
+    MACHINE = 2,
+    /**
+     * Window specific configuration, which can be configured in the user or workspace settings.
+     */
+    WINDOW = 3,
+    /**
+     * Resource specific configuration, which can be configured in the user, workspace or folder settings.
+     */
+    RESOURCE = 4,
+    /**
+     * Resource specific configuration that can be configured in language specific settings
+     */
+    LANGUAGE_OVERRIDABLE = 5,
+    /**
+     * Machine specific configuration that can also be configured in workspace or folder settings.
+     */
+    MACHINE_OVERRIDABLE = 6
+}
+interface IConfigurationPropertySchema extends IJSONSchema {
+    scope?: ConfigurationScope;
+    /**
+     * When restricted, value of this configuration will be read only from trusted sources.
+     * For eg., If the workspace is not trusted, then the value of this configuration is not read from workspace settings file.
+     */
+    restricted?: boolean;
+    /**
+     * When `false` this property is excluded from the registry. Default is to include.
+     */
+    included?: boolean;
+    /**
+     * List of tags associated to the property.
+     *  - A tag can be used for filtering
+     *  - Use `experimental` tag for marking the setting as experimental. **Note:** Defaults of experimental settings can be changed by the running experiments.
+     */
+    tags?: string[];
+    /**
+     * When enabled this setting is ignored during sync and user can override this.
+     */
+    ignoreSync?: boolean;
+    /**
+     * When enabled this setting is ignored during sync and user cannot override this.
+     */
+    disallowSyncIgnore?: boolean;
+    /**
+     * Labels for enumeration items
+     */
+    enumItemLabels?: string[];
+    /**
+     * When specified, controls the presentation format of string settings.
+     * Otherwise, the presentation format defaults to `singleline`.
+     */
+    editPresentation?: EditPresentationTypes;
+    /**
+     * When specified, gives an order number for the setting
+     * within the settings editor. Otherwise, the setting is placed at the end.
+     */
+    order?: number;
+}
+interface IExtensionInfo {
+    id: string;
+    displayName?: string;
+}
+interface IConfigurationNode {
+    id?: string;
+    order?: number;
+    type?: string | string[];
+    title?: string;
+    description?: string;
+    properties?: IStringDictionary<IConfigurationPropertySchema>;
+    allOf?: IConfigurationNode[];
+    scope?: ConfigurationScope;
+    extensionInfo?: IExtensionInfo;
+    restrictedProperties?: string[];
+}
+interface IConfigurationDefaults {
+    overrides: IStringDictionary<any>;
+    source?: IExtensionInfo | string;
+}
+declare type IRegisteredConfigurationPropertySchema = IConfigurationPropertySchema & {
+    defaultDefaultValue?: any;
+    source?: IExtensionInfo;
+    defaultValueSource?: IExtensionInfo | string;
+};
+declare type IConfigurationDefaultOverride = {
+    value: any;
+    source?: IExtensionInfo | string;
+};
+
 type IEditorOverrideServices = monaco.editor.IEditorOverrideServices
 
-declare function getServiceOverride(readConfiguration: () => string, onChange: Event<void>, settingsResource?: URI): IEditorOverrideServices;
+declare function updateUserConfiguration(configurationJson: string): void;
+declare const configurationRegistry: IConfigurationRegistry;
+declare function getServiceOverride(settingsResource?: URI): IEditorOverrideServices;
 
-export { getServiceOverride as default };
+export { configurationRegistry, getServiceOverride as default, updateUserConfiguration };

package/dist/configuration.js

@@ -2162,10 +2162,17 @@ function createConfigurationFileSystemProvider(settingsResource, readConfigurati
     };
     return provider;
 }
-function getServiceOverride(readConfiguration, onChange, settingsResource = URI.file('/userSettings.json')) {
+let userConfigurationJson = '{}';
+const userConfigurationChangeEmitter = new Emitter();
+function updateUserConfiguration(configurationJson) {
+    userConfigurationJson = configurationJson;
+    userConfigurationChangeEmitter.fire(undefined);
+}
+const configurationRegistry = Registry.as(Extensions.Configuration);
+function getServiceOverride(settingsResource = URI.file('/userSettings.json')) {
     const logService = StandaloneServices.get(ILogService);
     const fileService = new FileService(logService);
-    fileService.registerProvider(Schemas.file, createConfigurationFileSystemProvider(settingsResource, readConfiguration, onChange));
+    fileService.registerProvider(Schemas.file, createConfigurationFileSystemProvider(settingsResource, () => userConfigurationJson, userConfigurationChangeEmitter.event));
     const configurationService = new ConfigurationService(settingsResource, fileService);
     configurationService.initialize().catch(error => {
         logService.error(error);
@@ -2175,4 +2182,4 @@ function getServiceOverride(readConfiguration, onChange, settingsResource = URI.
         [ITextResourceConfigurationService.toString()]: new SyncDescriptor(TextResourceConfigurationService)
     };
 }
-export { getServiceOverride as default };
+export { configurationRegistry, getServiceOverride as default, updateUserConfiguration };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "1.67.17",
+  "version": "1.67.18",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],