@codingame/monaco-vscode-extensions-service-override 3.2.3 → 4.1.0

package/vscode/src/vs/workbench/api/browser/mainThreadWebviews.js

@@ -1,135 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Disposable, DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { Schemas } from 'vscode/vscode/vs/base/common/network';
-import { isWeb } from 'vscode/vscode/vs/base/common/platform';
-import { escape } from 'vscode/vscode/vs/base/common/strings';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { IProductService } from 'vscode/vscode/vs/platform/product/common/productService';
-import { ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { deserializeWebviewMessage, serializeWebviewMessage } from 'vscode/vscode/vs/workbench/api/common/extHostWebviewMessaging';
-import { SerializableObjectWithBuffers } from 'vscode/vscode/vs/workbench/services/extensions/common/proxyIdentifier';
-
-var MainThreadWebviews_1;
-let MainThreadWebviews = class MainThreadWebviews extends Disposable {
-    static { MainThreadWebviews_1 = this; }
-    static { this.standardSupportedLinkSchemes = ( new Set([
-        Schemas.http,
-        Schemas.https,
-        Schemas.mailto,
-        Schemas.vscode,
-        'vscode-insider',
-    ])); }
-    constructor(context, _openerService, _productService) {
-        super();
-        this._openerService = _openerService;
-        this._productService = _productService;
-        this._webviews = ( new Map());
-        this._proxy = ( context.getProxy(ExtHostContext.ExtHostWebviews));
-    }
-    addWebview(handle, webview, options) {
-        if (( this._webviews.has(handle))) {
-            throw new Error('Webview already registered');
-        }
-        this._webviews.set(handle, webview);
-        this.hookupWebviewEventDelegate(handle, webview, options);
-    }
-    $setHtml(handle, value) {
-        this.tryGetWebview(handle)?.setHtml(value);
-    }
-    $setOptions(handle, options) {
-        const webview = this.tryGetWebview(handle);
-        if (webview) {
-            webview.contentOptions = reviveWebviewContentOptions(options);
-        }
-    }
-    async $postMessage(handle, jsonMessage, ...buffers) {
-        const webview = this.tryGetWebview(handle);
-        if (!webview) {
-            return false;
-        }
-        const { message, arrayBuffers } = deserializeWebviewMessage(jsonMessage, buffers);
-        return webview.postMessage(message, arrayBuffers);
-    }
-    hookupWebviewEventDelegate(handle, webview, options) {
-        const disposables = ( new DisposableStore());
-        disposables.add(webview.onDidClickLink((uri) => this.onDidClickLink(handle, uri)));
-        disposables.add(webview.onMessage((message) => {
-            const serialized = serializeWebviewMessage(message.message, options);
-            this._proxy.$onMessage(handle, serialized.message, ( new SerializableObjectWithBuffers(serialized.buffers)));
-        }));
-        disposables.add(webview.onMissingCsp((extension) => this._proxy.$onMissingCsp(handle, extension.value)));
-        disposables.add(webview.onDidDispose(() => {
-            disposables.dispose();
-            this._webviews.delete(handle);
-        }));
-    }
-    onDidClickLink(handle, link) {
-        const webview = this.getWebview(handle);
-        if (this.isSupportedLink(webview, ( URI.parse(link)))) {
-            this._openerService.open(link, { fromUserGesture: true, allowContributedOpeners: true, allowCommands: Array.isArray(webview.contentOptions.enableCommandUris) || webview.contentOptions.enableCommandUris === true, fromWorkspace: true });
-        }
-    }
-    isSupportedLink(webview, link) {
-        if (( MainThreadWebviews_1.standardSupportedLinkSchemes.has(link.scheme))) {
-            return true;
-        }
-        if (!isWeb && this._productService.urlProtocol === link.scheme) {
-            return true;
-        }
-        if (link.scheme === Schemas.command) {
-            if (Array.isArray(webview.contentOptions.enableCommandUris)) {
-                return webview.contentOptions.enableCommandUris.includes(link.path);
-            }
-            return webview.contentOptions.enableCommandUris === true;
-        }
-        return false;
-    }
-    tryGetWebview(handle) {
-        return this._webviews.get(handle);
-    }
-    getWebview(handle) {
-        const webview = this.tryGetWebview(handle);
-        if (!webview) {
-            throw new Error(`Unknown webview handle:${handle}`);
-        }
-        return webview;
-    }
-    getWebviewResolvedFailedContent(viewType) {
-        return `<!DOCTYPE html>
-		<html>
-			<head>
-				<meta http-equiv="Content-type" content="text/html;charset=UTF-8">
-				<meta http-equiv="Content-Security-Policy" content="default-src 'none';">
-			</head>
-			<body>${( localizeWithPath(
-            'vs/workbench/api/browser/mainThreadWebviews',
-            'errorMessage',
-            "An error occurred while loading view: {0}",
-            escape(viewType)
-        ))}</body>
-		</html>`;
-    }
-};
-MainThreadWebviews = MainThreadWebviews_1 = ( __decorate([
-    ( __param(1, IOpenerService)),
-    ( __param(2, IProductService))
-], MainThreadWebviews));
-function reviveWebviewExtension(extensionData) {
-    return {
-        id: extensionData.id,
-        location: URI.revive(extensionData.location),
-    };
-}
-function reviveWebviewContentOptions(webviewOptions) {
-    return {
-        allowScripts: webviewOptions.enableScripts,
-        allowForms: webviewOptions.enableForms,
-        enableCommandUris: webviewOptions.enableCommandUris,
-        localResourceRoots: Array.isArray(webviewOptions.localResourceRoots) ? ( webviewOptions.localResourceRoots.map(r => URI.revive(r))) : undefined,
-        portMapping: webviewOptions.portMapping,
-    };
-}
-
-export { MainThreadWebviews, reviveWebviewContentOptions, reviveWebviewExtension };

package/vscode/src/vs/workbench/api/browser/mainThreadWindow.js

@@ -1,57 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { Event } from 'vscode/vscode/vs/base/common/event';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { IOpenerService } from 'vscode/vscode/vs/platform/opener/common/opener';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IHostService } from 'vscode/vscode/vs/workbench/services/host/browser/host';
-import { IUserActivityService } from 'vscode/vscode/vs/workbench/services/userActivity/common/userActivityService';
-
-let MainThreadWindow = class MainThreadWindow {
-    constructor(extHostContext, hostService, openerService, userActivityService) {
-        this.hostService = hostService;
-        this.openerService = openerService;
-        this.userActivityService = userActivityService;
-        this.disposables = ( new DisposableStore());
-        this.proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWindow));
-        Event.latch(hostService.onDidChangeFocus)(this.proxy.$onDidChangeWindowFocus, this.proxy, this.disposables);
-        userActivityService.onDidChangeIsActive(this.proxy.$onDidChangeWindowActive, this.proxy, this.disposables);
-    }
-    dispose() {
-        this.disposables.dispose();
-    }
-    $getInitialState() {
-        return Promise.resolve({
-            isFocused: this.hostService.hasFocus,
-            isActive: this.userActivityService.isActive,
-        });
-    }
-    async $openUri(uriComponents, uriString, options) {
-        const uri = ( URI.from(uriComponents));
-        let target;
-        if (uriString && ( ( URI.parse(uriString)).toString()) === ( uri.toString())) {
-            target = uriString;
-        }
-        else {
-            target = uri;
-        }
-        return this.openerService.open(target, {
-            openExternal: true,
-            allowTunneling: options.allowTunneling,
-            allowContributedOpeners: options.allowContributedOpeners,
-        });
-    }
-    async $asExternalUri(uriComponents, options) {
-        const result = await this.openerService.resolveExternalUri(URI.revive(uriComponents), options);
-        return result.resolved;
-    }
-};
-MainThreadWindow = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadWindow),
-    ( __param(1, IHostService)),
-    ( __param(2, IOpenerService)),
-    ( __param(3, IUserActivityService))
-], MainThreadWindow);
-
-export { MainThreadWindow };

package/vscode/src/vs/workbench/api/browser/mainThreadWorkspace.js

@@ -1,268 +0,0 @@
-import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
-import { isCancellationError } from 'vscode/vscode/vs/base/common/errors';
-import { DisposableStore } from 'vscode/vscode/vs/base/common/lifecycle';
-import { isNative } from 'vscode/vscode/vs/base/common/platform';
-import { URI } from 'vscode/vscode/vs/base/common/uri';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { IEnvironmentService } from 'vscode/vscode/vs/platform/environment/common/environment';
-import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { ILabelService } from 'vscode/vscode/vs/platform/label/common/label';
-import { INotificationService } from 'vscode/vscode/vs/platform/notification/common/notification';
-import { IRequestService } from 'vscode/vscode/vs/platform/request/common/request';
-import { IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from 'vscode/vscode/vs/platform/workspace/common/workspaceTrust';
-import { IWorkspaceContextService, isUntitledWorkspace } from 'vscode/vscode/vs/platform/workspace/common/workspace';
-import { extHostNamedCustomer } from '../../services/extensions/common/extHostCustomers.js';
-import { checkGlobFileExists } from 'vscode/vscode/vs/workbench/services/extensions/common/workspaceContains';
-import { QueryBuilder } from 'vscode/vscode/vs/workbench/services/search/common/queryBuilder';
-import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
-import { ISearchService } from 'vscode/vscode/vs/workbench/services/search/common/search';
-import { IWorkspaceEditingService } from 'vscode/vscode/vs/workbench/services/workspaces/common/workspaceEditing';
-import { MainContext, ExtHostContext } from 'vscode/vscode/vs/workbench/api/common/extHost.protocol';
-import { IEditSessionIdentityService } from 'vscode/vscode/vs/platform/workspace/common/editSessions';
-import { SideBySideEditor, EditorResourceAccessor } from 'vscode/vscode/vs/workbench/common/editor';
-import { firstOrDefault, coalesce } from 'vscode/vscode/vs/base/common/arrays';
-import { ICanonicalUriService } from 'vscode/vscode/vs/platform/workspace/common/canonicalUri';
-
-let MainThreadWorkspace = class MainThreadWorkspace {
-    constructor(extHostContext, _searchService, _contextService, _editSessionIdentityService, _canonicalUriService, _editorService, _workspaceEditingService, _notificationService, _requestService, _instantiationService, _labelService, _environmentService, fileService, _workspaceTrustManagementService, _workspaceTrustRequestService) {
-        this._searchService = _searchService;
-        this._contextService = _contextService;
-        this._editSessionIdentityService = _editSessionIdentityService;
-        this._canonicalUriService = _canonicalUriService;
-        this._editorService = _editorService;
-        this._workspaceEditingService = _workspaceEditingService;
-        this._notificationService = _notificationService;
-        this._requestService = _requestService;
-        this._instantiationService = _instantiationService;
-        this._labelService = _labelService;
-        this._environmentService = _environmentService;
-        this._workspaceTrustManagementService = _workspaceTrustManagementService;
-        this._workspaceTrustRequestService = _workspaceTrustRequestService;
-        this._toDispose = ( new DisposableStore());
-        this._activeCancelTokens = Object.create(null);
-        this._queryBuilder = this._instantiationService.createInstance(QueryBuilder);
-        this.registeredEditSessionProviders = ( new Map());
-        this.registeredCanonicalUriProviders = ( new Map());
-        this._proxy = ( extHostContext.getProxy(ExtHostContext.ExtHostWorkspace));
-        const workspace = this._contextService.getWorkspace();
-        if (workspace.configuration && !isNative && !fileService.hasProvider(workspace.configuration)) {
-            this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted());
-        }
-        else {
-            this._contextService.getCompleteWorkspace().then(workspace => this._proxy.$initializeWorkspace(this.getWorkspaceData(workspace), this.isWorkspaceTrusted()));
-        }
-        this._contextService.onDidChangeWorkspaceFolders(this._onDidChangeWorkspace, this, this._toDispose);
-        this._contextService.onDidChangeWorkbenchState(this._onDidChangeWorkspace, this, this._toDispose);
-        this._workspaceTrustManagementService.onDidChangeTrust(this._onDidGrantWorkspaceTrust, this, this._toDispose);
-    }
-    dispose() {
-        this._toDispose.dispose();
-        for (const requestId in this._activeCancelTokens) {
-            const tokenSource = this._activeCancelTokens[requestId];
-            tokenSource.cancel();
-        }
-    }
-    $updateWorkspaceFolders(extensionName, index, deleteCount, foldersToAdd) {
-        const workspaceFoldersToAdd = ( foldersToAdd.map(f => ({ uri: URI.revive(f.uri), name: f.name })));
-        this._notificationService.status(this.getStatusMessage(extensionName, workspaceFoldersToAdd.length, deleteCount), { hideAfter: 10 * 1000  });
-        return this._workspaceEditingService.updateFolders(index, deleteCount, workspaceFoldersToAdd, true);
-    }
-    getStatusMessage(extensionName, addCount, removeCount) {
-        let message;
-        const wantsToAdd = addCount > 0;
-        const wantsToDelete = removeCount > 0;
-        if (wantsToAdd && !wantsToDelete) {
-            if (addCount === 1) {
-                message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageAddSingleFolder',
-                    "Extension '{0}' added 1 folder to the workspace",
-                    extensionName
-                ));
-            }
-            else {
-                message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageAddMultipleFolders',
-                    "Extension '{0}' added {1} folders to the workspace",
-                    extensionName,
-                    addCount
-                ));
-            }
-        }
-        else if (wantsToDelete && !wantsToAdd) {
-            if (removeCount === 1) {
-                message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageRemoveSingleFolder',
-                    "Extension '{0}' removed 1 folder from the workspace",
-                    extensionName
-                ));
-            }
-            else {
-                message = ( localizeWithPath(
-                    'vs/workbench/api/browser/mainThreadWorkspace',
-                    'folderStatusMessageRemoveMultipleFolders',
-                    "Extension '{0}' removed {1} folders from the workspace",
-                    extensionName,
-                    removeCount
-                ));
-            }
-        }
-        else {
-            message = ( localizeWithPath(
-                'vs/workbench/api/browser/mainThreadWorkspace',
-                'folderStatusChangeFolder',
-                "Extension '{0}' changed folders of the workspace",
-                extensionName
-            ));
-        }
-        return message;
-    }
-    _onDidChangeWorkspace() {
-        this._proxy.$acceptWorkspaceData(this.getWorkspaceData(this._contextService.getWorkspace()));
-    }
-    getWorkspaceData(workspace) {
-        if (this._contextService.getWorkbenchState() === 1 ) {
-            return null;
-        }
-        return {
-            configuration: workspace.configuration || undefined,
-            isUntitled: workspace.configuration ? isUntitledWorkspace(workspace.configuration, this._environmentService) : false,
-            folders: workspace.folders,
-            id: workspace.id,
-            name: this._labelService.getWorkspaceLabel(workspace),
-            transient: workspace.transient
-        };
-    }
-    $startFileSearch(_includeFolder, options, token) {
-        const includeFolder = URI.revive(_includeFolder);
-        const workspace = this._contextService.getWorkspace();
-        const query = this._queryBuilder.file(includeFolder ? [includeFolder] : workspace.folders, options);
-        return this._searchService.fileSearch(query, token).then(result => {
-            return ( result.results.map(m => m.resource));
-        }, err => {
-            if (!isCancellationError(err)) {
-                return Promise.reject(err);
-            }
-            return null;
-        });
-    }
-    $startTextSearch(pattern, _folder, options, requestId, token) {
-        const folder = URI.revive(_folder);
-        const workspace = this._contextService.getWorkspace();
-        const folders = folder ? [folder] : ( workspace.folders.map(folder => folder.uri));
-        const query = this._queryBuilder.text(pattern, folders, options);
-        query._reason = 'startTextSearch';
-        const onProgress = (p) => {
-            if (p.results) {
-                this._proxy.$handleTextSearchResult(p, requestId);
-            }
-        };
-        const search = this._searchService.textSearch(query, token, onProgress).then(result => {
-            return { limitHit: result.limitHit };
-        }, err => {
-            if (!isCancellationError(err)) {
-                return Promise.reject(err);
-            }
-            return null;
-        });
-        return search;
-    }
-    $checkExists(folders, includes, token) {
-        return this._instantiationService.invokeFunction((accessor) => checkGlobFileExists(accessor, folders, includes, token));
-    }
-    async $save(uriComponents, options) {
-        const uri = URI.revive(uriComponents);
-        const editors = [...this._editorService.findEditors(uri, { supportSideBySide: SideBySideEditor.PRIMARY })];
-        const result = await this._editorService.save(editors, {
-            reason: 1 ,
-            saveAs: options.saveAs,
-            force: !options.saveAs
-        });
-        return firstOrDefault(this._saveResultToUris(result));
-    }
-    _saveResultToUris(result) {
-        if (!result.success) {
-            return [];
-        }
-        return coalesce(( result.editors.map(
-            editor => EditorResourceAccessor.getCanonicalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY })
-        )));
-    }
-    $saveAll(includeUntitled) {
-        return this._editorService.saveAll({ includeUntitled }).then(res => res.success);
-    }
-    $resolveProxy(url) {
-        return this._requestService.resolveProxy(url);
-    }
-    $loadCertificates() {
-        return this._requestService.loadCertificates();
-    }
-    $requestWorkspaceTrust(options) {
-        return this._workspaceTrustRequestService.requestWorkspaceTrust(options);
-    }
-    isWorkspaceTrusted() {
-        return this._workspaceTrustManagementService.isWorkspaceTrusted();
-    }
-    _onDidGrantWorkspaceTrust() {
-        this._proxy.$onDidGrantWorkspaceTrust();
-    }
-    $registerEditSessionIdentityProvider(handle, scheme) {
-        const disposable = this._editSessionIdentityService.registerEditSessionIdentityProvider({
-            scheme: scheme,
-            getEditSessionIdentifier: async (workspaceFolder, token) => {
-                return this._proxy.$getEditSessionIdentifier(workspaceFolder.uri, token);
-            },
-            provideEditSessionIdentityMatch: async (workspaceFolder, identity1, identity2, token) => {
-                return this._proxy.$provideEditSessionIdentityMatch(workspaceFolder.uri, identity1, identity2, token);
-            }
-        });
-        this.registeredEditSessionProviders.set(handle, disposable);
-        this._toDispose.add(disposable);
-    }
-    $unregisterEditSessionIdentityProvider(handle) {
-        const disposable = this.registeredEditSessionProviders.get(handle);
-        disposable?.dispose();
-        this.registeredEditSessionProviders.delete(handle);
-    }
-    $registerCanonicalUriProvider(handle, scheme) {
-        const disposable = this._canonicalUriService.registerCanonicalUriProvider({
-            scheme: scheme,
-            provideCanonicalUri: async (uri, targetScheme, token) => {
-                const result = await this._proxy.$provideCanonicalUri(uri, targetScheme, token);
-                if (result) {
-                    return URI.revive(result);
-                }
-                return result;
-            }
-        });
-        this.registeredCanonicalUriProviders.set(handle, disposable);
-        this._toDispose.add(disposable);
-    }
-    $unregisterCanonicalUriProvider(handle) {
-        const disposable = this.registeredCanonicalUriProviders.get(handle);
-        disposable?.dispose();
-        this.registeredCanonicalUriProviders.delete(handle);
-    }
-};
-MainThreadWorkspace = __decorate([
-    extHostNamedCustomer(MainContext.MainThreadWorkspace),
-    ( __param(1, ISearchService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IEditSessionIdentityService)),
-    ( __param(4, ICanonicalUriService)),
-    ( __param(5, IEditorService)),
-    ( __param(6, IWorkspaceEditingService)),
-    ( __param(7, INotificationService)),
-    ( __param(8, IRequestService)),
-    ( __param(9, IInstantiationService)),
-    ( __param(10, ILabelService)),
-    ( __param(11, IEnvironmentService)),
-    ( __param(12, IFileService)),
-    ( __param(13, IWorkspaceTrustManagementService)),
-    ( __param(14, IWorkspaceTrustRequestService))
-], MainThreadWorkspace);
-
-export { MainThreadWorkspace };

package/vscode/src/vs/workbench/api/common/shared/dataTransferCache.js

@@ -1,35 +0,0 @@
-import { coalesce } from 'vscode/vscode/vs/base/common/arrays';
-import { VSBuffer } from 'vscode/vscode/vs/base/common/buffer';
-
-class DataTransferFileCache {
-    constructor() {
-        this.requestIdPool = 0;
-        this.dataTransferFiles = ( new Map());
-    }
-    add(dataTransfer) {
-        const requestId = this.requestIdPool++;
-        this.dataTransferFiles.set(requestId, coalesce(Array.from(dataTransfer, ([, item]) => item.asFile())));
-        return {
-            id: requestId,
-            dispose: () => {
-                this.dataTransferFiles.delete(requestId);
-            }
-        };
-    }
-    async resolveFileData(requestId, dataItemId) {
-        const files = this.dataTransferFiles.get(requestId);
-        if (!files) {
-            throw new Error('No data transfer found');
-        }
-        const file = files.find(file => file.id === dataItemId);
-        if (!file) {
-            throw new Error('No matching file found in data transfer');
-        }
-        return VSBuffer.wrap(await file.data());
-    }
-    dispose() {
-        this.dataTransferFiles.clear();
-    }
-}
-
-export { DataTransferFileCache };

package/vscode/src/vs/workbench/contrib/customEditor/common/customTextEditorModel.js

@@ -1,73 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { isEqual } from 'vscode/vscode/vs/base/common/resources';
-import { ITextModelService } from 'vscode/vscode/vs/editor/common/services/resolverService';
-import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
-
-var CustomTextEditorModel_1;
-let CustomTextEditorModel = CustomTextEditorModel_1 = class CustomTextEditorModel extends Disposable {
-    static async create(instantiationService, viewType, resource) {
-        return instantiationService.invokeFunction(async (accessor) => {
-            const textModelResolverService = accessor.get(ITextModelService);
-            const model = await textModelResolverService.createModelReference(resource);
-            return instantiationService.createInstance(CustomTextEditorModel_1, viewType, resource, model);
-        });
-    }
-    constructor(viewType, _resource, _model, textFileService) {
-        super();
-        this.viewType = viewType;
-        this._resource = _resource;
-        this._model = _model;
-        this.textFileService = textFileService;
-        this._onDidChangeOrphaned = this._register(( new Emitter()));
-        this.onDidChangeOrphaned = this._onDidChangeOrphaned.event;
-        this._onDidChangeReadonly = this._register(( new Emitter()));
-        this.onDidChangeReadonly = this._onDidChangeReadonly.event;
-        this._onDidChangeDirty = this._register(( new Emitter()));
-        this.onDidChangeDirty = this._onDidChangeDirty.event;
-        this._onDidChangeContent = this._register(( new Emitter()));
-        this.onDidChangeContent = this._onDidChangeContent.event;
-        this._register(_model);
-        this._textFileModel = this.textFileService.files.get(_resource);
-        if (this._textFileModel) {
-            this._register(this._textFileModel.onDidChangeOrphaned(() => this._onDidChangeOrphaned.fire()));
-            this._register(this._textFileModel.onDidChangeReadonly(() => this._onDidChangeReadonly.fire()));
-        }
-        this._register(this.textFileService.files.onDidChangeDirty(e => {
-            if (isEqual(this.resource, e.resource)) {
-                this._onDidChangeDirty.fire();
-                this._onDidChangeContent.fire();
-            }
-        }));
-    }
-    get resource() {
-        return this._resource;
-    }
-    isReadonly() {
-        return this._model.object.isReadonly();
-    }
-    get backupId() {
-        return undefined;
-    }
-    isDirty() {
-        return this.textFileService.isDirty(this.resource);
-    }
-    isOrphaned() {
-        return !!this._textFileModel?.hasState(4 );
-    }
-    async revert(options) {
-        return this.textFileService.revert(this.resource, options);
-    }
-    saveCustomEditor(options) {
-        return this.textFileService.save(this.resource, options);
-    }
-    async saveCustomEditorAs(resource, targetResource, options) {
-        return !!(await this.textFileService.saveAs(resource, targetResource, options));
-    }
-};
-CustomTextEditorModel = CustomTextEditorModel_1 = ( __decorate([
-    ( __param(3, ITextFileService))
-], CustomTextEditorModel));
-
-export { CustomTextEditorModel };

package/vscode/src/vs/workbench/contrib/externalUriOpener/common/contributedOpeners.js

@@ -1,83 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { IStorageService } from 'vscode/vscode/vs/platform/storage/common/storage';
-import { Memento } from 'vscode/vscode/vs/workbench/common/memento';
-import { updateContributedOpeners } from 'vscode/vscode/vs/workbench/contrib/externalUriOpener/common/configuration';
-import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
-
-var ContributedExternalUriOpenersStore_1;
-let ContributedExternalUriOpenersStore = class ContributedExternalUriOpenersStore extends Disposable {
-    static { ContributedExternalUriOpenersStore_1 = this; }
-    static { this.STORAGE_ID = 'externalUriOpeners'; }
-    constructor(storageService, _extensionService) {
-        super();
-        this._extensionService = _extensionService;
-        this._openers = ( new Map());
-        this._memento = ( new Memento(ContributedExternalUriOpenersStore_1.STORAGE_ID, storageService));
-        this._mementoObject = this._memento.getMemento(0 , 1 );
-        for (const [id, value] of Object.entries(this._mementoObject || {})) {
-            this.add(id, value.extensionId, { isCurrentlyRegistered: false });
-        }
-        this.invalidateOpenersOnExtensionsChanged();
-        this._register(this._extensionService.onDidChangeExtensions(() => this.invalidateOpenersOnExtensionsChanged()));
-        this._register(this._extensionService.onDidChangeExtensionsStatus(() => this.invalidateOpenersOnExtensionsChanged()));
-    }
-    didRegisterOpener(id, extensionId) {
-        this.add(id, extensionId, {
-            isCurrentlyRegistered: true
-        });
-    }
-    add(id, extensionId, options) {
-        const existing = this._openers.get(id);
-        if (existing) {
-            existing.isCurrentlyRegistered = existing.isCurrentlyRegistered || options.isCurrentlyRegistered;
-            return;
-        }
-        const entry = {
-            extensionId,
-            isCurrentlyRegistered: options.isCurrentlyRegistered
-        };
-        this._openers.set(id, entry);
-        this._mementoObject[id] = entry;
-        this._memento.saveMemento();
-        this.updateSchema();
-    }
-    delete(id) {
-        this._openers.delete(id);
-        delete this._mementoObject[id];
-        this._memento.saveMemento();
-        this.updateSchema();
-    }
-    async invalidateOpenersOnExtensionsChanged() {
-        await this._extensionService.whenInstalledExtensionsRegistered();
-        const registeredExtensions = this._extensionService.extensions;
-        for (const [id, entry] of this._openers) {
-            const extension = registeredExtensions.find(r => r.identifier.value === entry.extensionId);
-            if (extension) {
-                if (!this._extensionService.canRemoveExtension(extension)) {
-                    if (!entry.isCurrentlyRegistered) {
-                        this.delete(id);
-                    }
-                }
-            }
-            else {
-                this.delete(id);
-            }
-        }
-    }
-    updateSchema() {
-        const ids = [];
-        const descriptions = [];
-        for (const [id, entry] of this._openers) {
-            ids.push(id);
-            descriptions.push(entry.extensionId);
-        }
-        updateContributedOpeners(ids, descriptions);
-    }
-};
-ContributedExternalUriOpenersStore = ContributedExternalUriOpenersStore_1 = ( __decorate([
-    ( __param(0, IStorageService)),
-    ( __param(1, IExtensionService))
-], ContributedExternalUriOpenersStore));
-
-export { ContributedExternalUriOpenersStore };