@codingame/monaco-vscode-api 1.79.1 → 1.79.2-next.1

package/dist/vscode/vs/workbench/services/themes/browser/fileIconThemeData.js

@@ -1,7 +1,7 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { ExtensionData } from '../common/workbenchThemeService.js';
 import { getParseErrorMessage } from '../../../../base/common/jsonErrorMessages.js';
 import { asCSSUrl } from 'monaco-editor/esm/vs/base/browser/dom.js';
@@ -133,7 +133,7 @@ class FileIconThemeLoader {
     loadIconThemeDocument(location) {
         return this.fileService.readExtensionResource(location).then((content) => {
             const errors = [];
-            const contentValue = Json.parse(content, errors);
+            const contentValue = json.parse(content, errors);
             if (errors.length > 0) {
                 return Promise.reject(( new Error(( nls.localize(
                     'error.cannotparseicontheme',
@@ -141,7 +141,7 @@ class FileIconThemeLoader {
                     ( errors.map(e => getParseErrorMessage(e.error))).join(', ')
                 )))));
             }
-            else if (Json.getNodeType(contentValue) !== 'object') {
+            else if (json.getNodeType(contentValue) !== 'object') {
                 return Promise.reject(( new Error(( nls.localize(
                     'error.invalidformat',
                     "Invalid format for file icons theme file: Object expected."

package/dist/vscode/vs/workbench/services/themes/browser/productIconThemeData.js

@@ -1,7 +1,7 @@
 import * as nls from 'monaco-editor/esm/vs/nls.js';
 import * as path from 'monaco-editor/esm/vs/base/common/path.js';
 import * as resources from 'monaco-editor/esm/vs/base/common/resources.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { ThemeSettingDefaults, ExtensionData } from '../common/workbenchThemeService.js';
 import { getParseErrorMessage } from '../../../../base/common/jsonErrorMessages.js';
 import { fontIdRegex, fontWeightRegex, fontStyleRegex, fontFormatRegex } from '../common/productIconThemeSchema.js';
@@ -152,7 +152,7 @@ ProductIconThemeData._defaultProductIconTheme = null;
 function _loadProductIconThemeDocument(fileService, location, warnings) {
     return fileService.readExtensionResource(location).then((content) => {
         const parseErrors = [];
-        const contentValue = Json.parse(content, parseErrors);
+        const contentValue = json.parse(content, parseErrors);
         if (parseErrors.length > 0) {
             return Promise.reject(( new Error(( nls.localize(
                 'error.cannotparseicontheme',
@@ -160,7 +160,7 @@ function _loadProductIconThemeDocument(fileService, location, warnings) {
                 ( parseErrors.map(e => getParseErrorMessage(e.error))).join(', ')
             )))));
         }
-        else if (Json.getNodeType(contentValue) !== 'object') {
+        else if (json.getNodeType(contentValue) !== 'object') {
             return Promise.reject(( new Error(( nls.localize(
                 'error.invalidformat',
                 "Invalid format for product icons theme file: Object expected."

package/dist/vscode/vs/workbench/services/themes/common/colorThemeData.js

@@ -1,5 +1,5 @@
 import { basename } from 'monaco-editor/esm/vs/base/common/path.js';
-import * as Json from 'monaco-editor/esm/vs/base/common/json.js';
+import * as json from 'monaco-editor/esm/vs/base/common/json.js';
 import { Color } from 'monaco-editor/esm/vs/base/common/color.js';
 import { THEME_SCOPE_OPEN_PAREN, THEME_SCOPE_CLOSE_PAREN, THEME_SCOPE_WILDCARD, themeScopeRegex, ExtensionData, VS_HC_LIGHT_THEME, VS_HC_THEME, VS_LIGHT_THEME } from './workbenchThemeService.js';
 import { convertSettings } from './themeCompatibility.js';
@@ -580,7 +580,7 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
     if (resources.extname(themeLocation) === '.json') {
         const content = await extensionResourceLoaderService.readExtensionResource(themeLocation);
         const errors = [];
-        const contentValue = Json.parse(content, errors);
+        const contentValue = json.parse(content, errors);
         if (errors.length > 0) {
             return Promise.reject(( new Error(( nls.localize(
                 'error.cannotparsejson',
@@ -588,7 +588,7 @@ async function _loadColorTheme(extensionResourceLoaderService, themeLocation, re
                 ( errors.map(e => getParseErrorMessage(e.error))).join(', ')
             )))));
         }
-        else if (Json.getNodeType(contentValue) !== 'object') {
+        else if (json.getNodeType(contentValue) !== 'object') {
             return Promise.reject(( new Error(( nls.localize(
                 'error.invalidformat',
                 "Invalid format for JSON theme file: Object expected."

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorInput.js

@@ -8,6 +8,7 @@ import { IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.j
 import { toLocalResource, isEqual } from 'monaco-editor/esm/vs/base/common/resources.js';
 import { IWorkbenchEnvironmentService } from '../../environment/common/environmentService.js';
 import { IPathService } from '../../path/common/pathService.js';
+import { IFilesConfigurationService } from '../../filesConfiguration/common/filesConfigurationService.js';
 let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractTextResourceEditorInput {
     get typeId() {
         return UntitledTextEditorInput.ID;
@@ -15,8 +16,8 @@ let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractText
     get editorId() {
         return DEFAULT_EDITOR_ASSOCIATION.id;
     }
-    constructor(model, textFileService, labelService, editorService, fileService, environmentService, pathService) {
-        super(model.resource, undefined, editorService, textFileService, labelService, fileService);
+    constructor(model, textFileService, labelService, editorService, fileService, environmentService, pathService, filesConfigurationService) {
+        super(model.resource, undefined, editorService, textFileService, labelService, fileService, filesConfigurationService);
         this.model = model;
         this.environmentService = environmentService;
         this.pathService = pathService;
@@ -85,7 +86,7 @@ let UntitledTextEditorInput = class UntitledTextEditorInput extends AbstractText
         if (typeof options?.preserveViewState === 'number') {
             untypedInput.encoding = this.getEncoding();
             untypedInput.languageId = this.getLanguageId();
-            untypedInput.contents = this.model.isDirty() ? this.model.textEditorModel?.getValue() : undefined;
+            untypedInput.contents = this.model.isModified() ? this.model.textEditorModel?.getValue() : undefined;
             untypedInput.options.viewState = findViewStateForEditor(this, options.preserveViewState, this.editorService);
             if (typeof untypedInput.contents === 'string' && !this.model.hasAssociatedFilePath) {
                 untypedInput.resource = undefined;
@@ -117,6 +118,7 @@ UntitledTextEditorInput = ( __decorate([
     ( __param(3, IEditorService)),
     ( __param(4, IFileService)),
     ( __param(5, IWorkbenchEnvironmentService)),
-    ( __param(6, IPathService))
+    ( __param(6, IPathService)),
+    ( __param(7, IFilesConfigurationService))
 ], UntitledTextEditorInput));
 export { UntitledTextEditorInput };

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorModel.js

@@ -113,6 +113,9 @@ let UntitledTextEditorModel = class UntitledTextEditorModel extends BaseTextEdit
     isDirty() {
         return this.dirty;
     }
+    isModified() {
+        return this.isDirty();
+    }
     setDirty(dirty) {
         if (this.dirty === dirty) {
             return;

package/dist/vscode/vs/workbench/services/untitled/common/untitledTextEditorService.js

@@ -102,7 +102,11 @@ let UntitledTextEditorService = class UntitledTextEditorService extends Disposab
             this._onDidChangeDirty.fire(model);
         }
     }
+    isUntitledWithAssociatedResource(resource) {
+        return resource.scheme === Schemas.untitled && resource.path.length > 1 && !UntitledTextEditorService.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX.test(resource.path);
+    }
 };
+UntitledTextEditorService.UNTITLED_WITHOUT_ASSOCIATED_RESOURCE_REGEX = /Untitled-\d+/;
 UntitledTextEditorService = ( (__decorate([
     ( (__param(0, IInstantiationService))),
     ( (__param(1, IConfigurationService)))

package/dist/vscode/vs/workbench/services/userActivity/common/userActivityRegistry.js

@@ -0,0 +1,15 @@
+class UserActivityRegistry {
+    constructor() {
+        this.todo = [];
+        this.add = (ctor) => {
+            this.todo.push(ctor);
+        };
+    }
+    take(userActivityService, instantiation) {
+        this.add = ctor => instantiation.createInstance(ctor, userActivityService);
+        this.todo.forEach(this.add);
+        this.todo = [];
+    }
+}
+const userActivityRegistry = ( new UserActivityRegistry());
+export { userActivityRegistry };

package/dist/vscode/vs/workbench/services/userActivity/common/userActivityService.js

@@ -0,0 +1,37 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { RunOnceScheduler, runWhenIdle } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { createDecorator, IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { userActivityRegistry } from './userActivityRegistry.js';
+const IUserActivityService = ( createDecorator('IUserActivityService'));
+let UserActivityService = class UserActivityService extends Disposable {
+    constructor(instantiationService) {
+        super();
+        this.markInactive = this._register(( new RunOnceScheduler(() => {
+            this.isActive = false;
+            this.changeEmitter.fire(false);
+        }, 10000)));
+        this.changeEmitter = this._register(( new Emitter()));
+        this.active = 0;
+        this.isActive = true;
+        this.onDidChangeIsActive = this.changeEmitter.event;
+        this._register(runWhenIdle(() => userActivityRegistry.take(this, instantiationService)));
+    }
+    markActive() {
+        if (++this.active === 1) {
+            this.isActive = true;
+            this.changeEmitter.fire(true);
+            this.markInactive.cancel();
+        }
+        return toDisposable(() => {
+            if (--this.active === 0) {
+                this.markInactive.schedule();
+            }
+        });
+    }
+};
+UserActivityService = ( __decorate([
+    ( __param(0, IInstantiationService))
+], UserActivityService));
+export { IUserActivityService, UserActivityService };

package/dist/vscode/vs/workbench/services/userDataSync/common/userDataSync.js

@@ -0,0 +1,7 @@
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { registerIcon } from 'monaco-editor/esm/vs/platform/theme/common/iconRegistry.js';
+const IUserDataSyncWorkbenchService = ( createDecorator('IUserDataSyncWorkbenchService'));
+registerIcon('settings-sync-view-icon', Codicon.sync, ( localize('syncViewIcon', 'View icon of the Settings Sync view.')));
+export { IUserDataSyncWorkbenchService };

package/dist/vscode/vs/workbench/services/workingCopy/common/workingCopyEditorService.js

@@ -0,0 +1,40 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { createDecorator } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { Disposable, toDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { IEditorService } from '../../editor/common/editorService.js';
+const IWorkingCopyEditorService = ( createDecorator('workingCopyEditorService'));
+let WorkingCopyEditorService = class WorkingCopyEditorService extends Disposable {
+    constructor(editorService) {
+        super();
+        this.editorService = editorService;
+        this._onDidRegisterHandler = this._register(( new Emitter()));
+        this.onDidRegisterHandler = this._onDidRegisterHandler.event;
+        this.handlers = ( new Set());
+    }
+    registerHandler(handler) {
+        this.handlers.add(handler);
+        this._onDidRegisterHandler.fire(handler);
+        return toDisposable(() => this.handlers.delete(handler));
+    }
+    findEditor(workingCopy) {
+        for (const editorIdentifier of this.editorService.getEditors(0 )) {
+            if (this.isOpen(workingCopy, editorIdentifier.editor)) {
+                return editorIdentifier;
+            }
+        }
+        return undefined;
+    }
+    isOpen(workingCopy, editor) {
+        for (const handler of this.handlers) {
+            if (handler.isOpen(workingCopy, editor)) {
+                return true;
+            }
+        }
+        return false;
+    }
+};
+WorkingCopyEditorService = ( __decorate([
+    ( __param(0, IEditorService))
+], WorkingCopyEditorService));
+export { IWorkingCopyEditorService, WorkingCopyEditorService };

package/dist/vscode/vs/workbench/services/workingCopy/common/workingCopyService.js

@@ -92,6 +92,18 @@ class WorkingCopyService extends Disposable {
     get dirtyWorkingCopies() {
         return this.workingCopies.filter(workingCopy => workingCopy.isDirty());
     }
+    get modifiedCount() {
+        let totalModifiedCount = 0;
+        for (const workingCopy of this._workingCopies) {
+            if (workingCopy.isModified()) {
+                totalModifiedCount++;
+            }
+        }
+        return totalModifiedCount;
+    }
+    get modifiedWorkingCopies() {
+        return this.workingCopies.filter(workingCopy => workingCopy.isModified());
+    }
     isDirty(resource, typeId) {
         const workingCopies = this.mapResourceToWorkingCopies.get(resource);
         if (workingCopies) {

package/dist/vscode/vs/workbench/services/workspaces/common/canonicalUriService.js

@@ -0,0 +1,19 @@
+class CanonicalUriService {
+    constructor() {
+        this._providers = ( new Map());
+    }
+    registerCanonicalUriProvider(provider) {
+        this._providers.set(provider.scheme, provider);
+        return {
+            dispose: () => this._providers.delete(provider.scheme)
+        };
+    }
+    async provideCanonicalUri(uri, targetScheme, token) {
+        const provider = this._providers.get(uri.scheme);
+        if (provider) {
+            return provider.provideCanonicalUri(uri, targetScheme, token);
+        }
+        return undefined;
+    }
+}
+export { CanonicalUriService };