@codingame/monaco-vscode-api 4.1.0 → 4.1.1

package/vscode/src/vs/workbench/contrib/editSessions/browser/editSessionsViews.js

@@ -1,337 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Disposable } from '../../../../base/common/lifecycle.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { SyncDescriptor } from '../../../../platform/instantiation/common/descriptors.js';
-import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
-import { Registry } from '../../../../platform/registry/common/platform.js';
-import { TreeView, TreeViewPane } from '../../../browser/parts/views/treeView.js';
-import { TreeItemCollapsibleState, Extensions } from '../../../common/views.js';
-import { EDIT_SESSIONS_TITLE, EDIT_SESSIONS_SHOW_VIEW, ChangeType, EDIT_SESSIONS_DATA_VIEW_ID, IEditSessionsStorageService, EDIT_SESSIONS_SCHEME } from '../common/editSessions.js';
-import { URI } from '../../../../base/common/uri.js';
-import { fromNow } from '../../../../base/common/date.js';
-import { Codicon } from '../../../../base/common/codicons.js';
-import { API_OPEN_EDITOR_COMMAND_ID } from '../../../browser/parts/editor/editorCommands.js';
-import { registerAction2, Action2, MenuId } from '../../../../platform/actions/common/actions.js';
-import { ContextKeyExpr, RawContextKey, IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.js';
-import '../../../../../../../override/vs/platform/dialogs/common/dialogs.js';
-import { IWorkspaceContextService } from '../../../../platform/workspace/common/workspace.js';
-import { joinPath } from '../../../../base/common/resources.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { basename } from '../../../../base/common/path.js';
-import { IDialogService } from '../../../../platform/dialogs/common/dialogs.js';
-const EDIT_SESSIONS_COUNT_KEY = 'editSessionsCount';
-const EDIT_SESSIONS_COUNT_CONTEXT_KEY = ( new RawContextKey(EDIT_SESSIONS_COUNT_KEY, 0));
-let EditSessionsDataViews = class EditSessionsDataViews extends Disposable {
-    constructor(container, instantiationService) {
-        super();
-        this.instantiationService = instantiationService;
-        this.registerViews(container);
-    }
-    registerViews(container) {
-        const viewId = EDIT_SESSIONS_DATA_VIEW_ID;
-        const treeView = this.instantiationService.createInstance(TreeView, viewId, EDIT_SESSIONS_TITLE.value);
-        treeView.showCollapseAllAction = true;
-        treeView.showRefreshAction = true;
-        treeView.dataProvider = this.instantiationService.createInstance(EditSessionDataViewDataProvider);
-        const viewsRegistry = ( Registry.as(Extensions.ViewsRegistry));
-        viewsRegistry.registerViews([{
-                id: viewId,
-                name: EDIT_SESSIONS_TITLE,
-                ctorDescriptor: ( new SyncDescriptor(TreeViewPane)),
-                canToggleVisibility: true,
-                canMoveView: false,
-                treeView,
-                collapsed: false,
-                when: ( ContextKeyExpr.and(EDIT_SESSIONS_SHOW_VIEW)),
-                order: 100,
-                hideByDefault: true,
-            }], container);
-        viewsRegistry.registerViewWelcomeContent(viewId, {
-            content: ( localizeWithPath(
-                'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                'noStoredChanges',
-                'You have no stored changes in the cloud to display.\n{0}',
-                `[${( localizeWithPath(
-                    'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                    'storeWorkingChangesTitle',
-                    'Store Working Changes'
-                ))}](command:workbench.editSessions.actions.store)`
-            )),
-            when: ( ContextKeyExpr.equals(EDIT_SESSIONS_COUNT_KEY, 0)),
-            order: 1
-        });
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.editSessions.actions.resume',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                        'workbench.editSessions.actions.resume.v2',
-                        "Resume Working Changes"
-                    )),
-                    icon: Codicon.desktopDownload,
-                    menu: {
-                        id: MenuId.ViewItemContext,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', viewId)), ( ContextKeyExpr.regex('viewItem', /edit-session/i)))),
-                        group: 'inline'
-                    }
-                });
-            }
-            async run(accessor, handle) {
-                const editSessionId = ( URI.parse(handle.$treeItemHandle)).path.substring(1);
-                const commandService = accessor.get(ICommandService);
-                await commandService.executeCommand('workbench.editSessions.actions.resumeLatest', editSessionId, true);
-                await treeView.refresh();
-            }
-        }));
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.editSessions.actions.store',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                        'workbench.editSessions.actions.store.v2',
-                        "Store Working Changes"
-                    )),
-                    icon: Codicon.cloudUpload,
-                });
-            }
-            async run(accessor, handle) {
-                const commandService = accessor.get(ICommandService);
-                await commandService.executeCommand('workbench.editSessions.actions.storeCurrent');
-                await treeView.refresh();
-            }
-        }));
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.editSessions.actions.delete',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                        'workbench.editSessions.actions.delete.v2',
-                        "Delete Working Changes"
-                    )),
-                    icon: Codicon.trash,
-                    menu: {
-                        id: MenuId.ViewItemContext,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', viewId)), ( ContextKeyExpr.regex('viewItem', /edit-session/i)))),
-                        group: 'inline'
-                    }
-                });
-            }
-            async run(accessor, handle) {
-                const editSessionId = ( URI.parse(handle.$treeItemHandle)).path.substring(1);
-                const dialogService = accessor.get(IDialogService);
-                const editSessionStorageService = accessor.get(IEditSessionsStorageService);
-                const result = await dialogService.confirm({
-                    message: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                        'confirm delete.v2',
-                        'Are you sure you want to permanently delete your working changes with ref {0}?',
-                        editSessionId
-                    )),
-                    detail: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                        'confirm delete detail.v2',
-                        ' You cannot undo this action.'
-                    )),
-                    type: 'warning',
-                    title: EDIT_SESSIONS_TITLE.value
-                });
-                if (result.confirmed) {
-                    await editSessionStorageService.delete('editSessions', editSessionId);
-                    await treeView.refresh();
-                }
-            }
-        }));
-        this._register(registerAction2(class extends Action2 {
-            constructor() {
-                super({
-                    id: 'workbench.editSessions.actions.deleteAll',
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                        'workbench.editSessions.actions.deleteAll',
-                        "Delete All Working Changes from Cloud"
-                    )),
-                    icon: Codicon.trash,
-                    menu: {
-                        id: MenuId.ViewTitle,
-                        when: ( ContextKeyExpr.and(( ContextKeyExpr.equals('view', viewId)), ContextKeyExpr.greater(EDIT_SESSIONS_COUNT_KEY, 0))),
-                    }
-                });
-            }
-            async run(accessor) {
-                const dialogService = accessor.get(IDialogService);
-                const editSessionStorageService = accessor.get(IEditSessionsStorageService);
-                const result = await dialogService.confirm({
-                    message: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                        'confirm delete all',
-                        'Are you sure you want to permanently delete all stored changes from the cloud?'
-                    )),
-                    detail: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                        'confirm delete all detail',
-                        ' You cannot undo this action.'
-                    )),
-                    type: 'warning',
-                    title: EDIT_SESSIONS_TITLE.value
-                });
-                if (result.confirmed) {
-                    await editSessionStorageService.delete('editSessions', null);
-                    await treeView.refresh();
-                }
-            }
-        }));
-    }
-};
-EditSessionsDataViews = ( __decorate([
-    ( __param(1, IInstantiationService))
-], EditSessionsDataViews));
-let EditSessionDataViewDataProvider = class EditSessionDataViewDataProvider {
-    constructor(editSessionsStorageService, contextKeyService, workspaceContextService, fileService) {
-        this.editSessionsStorageService = editSessionsStorageService;
-        this.contextKeyService = contextKeyService;
-        this.workspaceContextService = workspaceContextService;
-        this.fileService = fileService;
-        this.editSessionsCount = EDIT_SESSIONS_COUNT_CONTEXT_KEY.bindTo(this.contextKeyService);
-    }
-    async getChildren(element) {
-        if (!element) {
-            return this.getAllEditSessions();
-        }
-        const [ref, folderName, filePath] = ( URI.parse(element.handle)).path.substring(1).split('/');
-        if (ref && !folderName) {
-            return this.getEditSession(ref);
-        }
-        else if (ref && folderName && !filePath) {
-            return this.getEditSessionFolderContents(ref, folderName);
-        }
-        return [];
-    }
-    async getAllEditSessions() {
-        const allEditSessions = await this.editSessionsStorageService.list('editSessions');
-        this.editSessionsCount.set(allEditSessions.length);
-        const editSessions = [];
-        for (const session of allEditSessions) {
-            const resource = ( URI.from(
-                { scheme: EDIT_SESSIONS_SCHEME, authority: 'remote-session-content', path: `/${session.ref}` }
-            ));
-            const sessionData = await this.editSessionsStorageService.read('editSessions', session.ref);
-            if (!sessionData) {
-                continue;
-            }
-            const content = JSON.parse(sessionData.content);
-            const label = ( content.folders.map((folder) => folder.name)).join(', ') ?? session.ref;
-            const machineId = content.machine;
-            const machineName = machineId ? await this.editSessionsStorageService.getMachineById(machineId) : undefined;
-            const description = machineName === undefined ? fromNow(session.created, true) : `${fromNow(session.created, true)}\u00a0\u00a0\u2022\u00a0\u00a0${machineName}`;
-            editSessions.push({
-                handle: ( resource.toString()),
-                collapsibleState: TreeItemCollapsibleState.Collapsed,
-                label: { label },
-                description: description,
-                themeIcon: Codicon.repo,
-                contextValue: `edit-session`
-            });
-        }
-        return editSessions;
-    }
-    async getEditSession(ref) {
-        const data = await this.editSessionsStorageService.read('editSessions', ref);
-        if (!data) {
-            return [];
-        }
-        const content = JSON.parse(data.content);
-        if (content.folders.length === 1) {
-            const folder = content.folders[0];
-            return this.getEditSessionFolderContents(ref, folder.name);
-        }
-        return ( content.folders.map((folder) => {
-            const resource = ( URI.from(
-                { scheme: EDIT_SESSIONS_SCHEME, authority: 'remote-session-content', path: `/${data.ref}/${folder.name}` }
-            ));
-            return {
-                handle: ( resource.toString()),
-                collapsibleState: TreeItemCollapsibleState.Collapsed,
-                label: { label: folder.name },
-                themeIcon: Codicon.folder
-            };
-        }));
-    }
-    async getEditSessionFolderContents(ref, folderName) {
-        const data = await this.editSessionsStorageService.read('editSessions', ref);
-        if (!data) {
-            return [];
-        }
-        const content = JSON.parse(data.content);
-        const currentWorkspaceFolder = this.workspaceContextService.getWorkspace().folders.find((folder) => folder.name === folderName);
-        const editSessionFolder = content.folders.find((folder) => folder.name === folderName);
-        if (!editSessionFolder) {
-            return [];
-        }
-        return Promise.all(( editSessionFolder.workingChanges.map(async (change) => {
-            const cloudChangeUri = ( URI.from(
-                { scheme: EDIT_SESSIONS_SCHEME, authority: 'remote-session-content', path: `/${data.ref}/${folderName}/${change.relativeFilePath}` }
-            ));
-            if (currentWorkspaceFolder?.uri) {
-                const localCopy = joinPath(currentWorkspaceFolder.uri, change.relativeFilePath);
-                if (change.type === ChangeType.Addition && (await this.fileService.exists(localCopy))) {
-                    return {
-                        handle: ( cloudChangeUri.toString()),
-                        resourceUri: cloudChangeUri,
-                        collapsibleState: TreeItemCollapsibleState.None,
-                        label: { label: change.relativeFilePath },
-                        themeIcon: Codicon.file,
-                        command: {
-                            id: 'vscode.diff',
-                            title: ( localizeWithPath(
-                                'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                                'compare changes',
-                                'Compare Changes'
-                            )),
-                            arguments: [
-                                localCopy,
-                                cloudChangeUri,
-                                `${basename(change.relativeFilePath)} (${( localizeWithPath(
-                                    'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                                    'local copy',
-                                    'Local Copy'
-                                ))} \u2194 ${( localizeWithPath(
-                                    'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                                    'cloud changes',
-                                    'Cloud Changes'
-                                ))})`,
-                                undefined
-                            ]
-                        }
-                    };
-                }
-            }
-            return {
-                handle: ( cloudChangeUri.toString()),
-                resourceUri: cloudChangeUri,
-                collapsibleState: TreeItemCollapsibleState.None,
-                label: { label: change.relativeFilePath },
-                themeIcon: Codicon.file,
-                command: {
-                    id: API_OPEN_EDITOR_COMMAND_ID,
-                    title: ( localizeWithPath(
-                        'vs/workbench/contrib/editSessions/browser/editSessionsViews',
-                        'open file',
-                        'Open File'
-                    )),
-                    arguments: [cloudChangeUri, undefined, undefined]
-                }
-            };
-        })));
-    }
-};
-EditSessionDataViewDataProvider = ( __decorate([
-    ( __param(0, IEditSessionsStorageService)),
-    ( __param(1, IContextKeyService)),
-    ( __param(2, IWorkspaceContextService)),
-    ( __param(3, IFileService))
-], EditSessionDataViewDataProvider));
-export { EditSessionsDataViews };

package/vscode/src/vs/workbench/contrib/editSessions/common/editSessionsLogService.js

@@ -1,39 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { joinPath } from '../../../../base/common/resources.js';
-import { localizeWithPath } from '../../../../nls.js';
-import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
-import { AbstractLogger, ILoggerService } from '../../../../platform/log/common/log.js';
-import { editSessionsLogId } from './editSessions.js';
-let EditSessionsLogService = class EditSessionsLogService extends AbstractLogger {
-    constructor(loggerService, environmentService) {
-        super();
-        this.logger = this._register(loggerService.createLogger(joinPath(environmentService.logsHome, `${editSessionsLogId}.log`), { id: editSessionsLogId, name: ( localizeWithPath(
-            'vs/workbench/contrib/editSessions/common/editSessionsLogService',
-            'cloudChangesLog',
-            "Cloud Changes"
-        )) }));
-    }
-    trace(message, ...args) {
-        this.logger.trace(message, ...args);
-    }
-    debug(message, ...args) {
-        this.logger.debug(message, ...args);
-    }
-    info(message, ...args) {
-        this.logger.info(message, ...args);
-    }
-    warn(message, ...args) {
-        this.logger.warn(message, ...args);
-    }
-    error(message, ...args) {
-        this.logger.error(message, ...args);
-    }
-    flush() {
-        this.logger.flush();
-    }
-};
-EditSessionsLogService = ( __decorate([
-    ( __param(0, ILoggerService)),
-    ( __param(1, IEnvironmentService))
-], EditSessionsLogService));
-export { EditSessionsLogService };

package/vscode/src/vs/workbench/contrib/editSessions/common/editSessionsStorageClient.js

@@ -1,4 +0,0 @@
-import { UserDataSyncStoreClient } from '../../../../platform/userDataSync/common/userDataSyncStoreService.js';
-class EditSessionsStoreClient extends UserDataSyncStoreClient {
-}
-export { EditSessionsStoreClient };

package/vscode/src/vs/workbench/contrib/editSessions/common/workspaceStateSync.js

@@ -1,140 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { CancellationTokenSource } from '../../../../base/common/cancellation.js';
-import { Emitter } from '../../../../base/common/event.js';
-import { stringify, parse } from '../../../../base/common/marshalling.js';
-import { IConfigurationService } from '../../../../platform/configuration/common/configuration.js';
-import { IEnvironmentService } from '../../../../platform/environment/common/environment.js';
-import { IFileService } from '../../../../platform/files/common/files.js';
-import { IStorageService } from '../../../../platform/storage/common/storage.js';
-import { ITelemetryService } from '../../../../platform/telemetry/common/telemetry.js';
-import { IUriIdentityService } from '../../../../platform/uriIdentity/common/uriIdentity.js';
-import { AbstractSynchroniser } from '../../../../platform/userDataSync/common/abstractSynchronizer.js';
-import { IEditSessionsStorageService } from './editSessions.js';
-import { IWorkspaceIdentityService } from '../../../services/workspaces/common/workspaceIdentityService.js';
-class NullBackupStoreService {
-    async writeResource() {
-        return;
-    }
-    async getAllResourceRefs() {
-        return [];
-    }
-    async resolveResourceContent() {
-        return null;
-    }
-}
-class NullEnablementService {
-    constructor() {
-        this._onDidChangeEnablement = ( new Emitter());
-        this.onDidChangeEnablement = this._onDidChangeEnablement.event;
-        this._onDidChangeResourceEnablement = ( new Emitter());
-        this.onDidChangeResourceEnablement = this._onDidChangeResourceEnablement.event;
-    }
-    isEnabled() { return true; }
-    canToggleEnablement() { return true; }
-    setEnablement(_enabled) { }
-    isResourceEnabled(_resource) { return true; }
-    setResourceEnablement(_resource, _enabled) { }
-    getResourceSyncStateVersion(_resource) { return undefined; }
-}
-let WorkspaceStateSynchroniser = class WorkspaceStateSynchroniser extends AbstractSynchroniser {
-    constructor(profile, collection, userDataSyncStoreService, logService, fileService, environmentService, telemetryService, configurationService, storageService, uriIdentityService, workspaceIdentityService, editSessionsStorageService) {
-        const userDataSyncLocalStoreService = ( new NullBackupStoreService());
-        const userDataSyncEnablementService = ( new NullEnablementService());
-        super({ syncResource: "workspaceState" , profile }, collection, fileService, environmentService, storageService, userDataSyncStoreService, userDataSyncLocalStoreService, userDataSyncEnablementService, telemetryService, logService, configurationService, uriIdentityService);
-        this.workspaceIdentityService = workspaceIdentityService;
-        this.editSessionsStorageService = editSessionsStorageService;
-        this.version = 1;
-    }
-    async sync() {
-        const cancellationTokenSource = ( new CancellationTokenSource());
-        const folders = await this.workspaceIdentityService.getWorkspaceStateFolders(cancellationTokenSource.token);
-        if (!folders.length) {
-            return;
-        }
-        await this.storageService.flush();
-        const keys = ( this.storageService.keys(1, 0 ));
-        if (!keys.length) {
-            return;
-        }
-        const contributedData = {};
-        keys.forEach((key) => {
-            const data = this.storageService.get(key, 1 );
-            if (data) {
-                contributedData[key] = data;
-            }
-        });
-        const content = { folders, storage: contributedData, version: this.version };
-        await this.editSessionsStorageService.write('workspaceState', stringify(content));
-    }
-    async apply() {
-        const payload = this.editSessionsStorageService.lastReadResources.get('editSessions')?.content;
-        const workspaceStateId = payload ? JSON.parse(payload).workspaceStateId : undefined;
-        const resource = await this.editSessionsStorageService.read('workspaceState', workspaceStateId);
-        if (!resource) {
-            return null;
-        }
-        const remoteWorkspaceState = parse(resource.content);
-        if (!remoteWorkspaceState) {
-            this.logService.info('Skipping initializing workspace state because remote workspace state does not exist.');
-            return null;
-        }
-        const cancellationTokenSource = ( new CancellationTokenSource());
-        const replaceUris = await this.workspaceIdentityService.matches(remoteWorkspaceState.folders, cancellationTokenSource.token);
-        if (!replaceUris) {
-            this.logService.info('Skipping initializing workspace state because remote workspace state does not match current workspace.');
-            return null;
-        }
-        const storage = {};
-        for (const key of ( Object.keys(remoteWorkspaceState.storage))) {
-            storage[key] = remoteWorkspaceState.storage[key];
-        }
-        if (( Object.keys(storage)).length) {
-            const storageEntries = [];
-            for (const key of ( Object.keys(storage))) {
-                try {
-                    const value = parse(storage[key]);
-                    replaceUris(value);
-                    storageEntries.push({ key, value, scope: 1 , target: 0  });
-                }
-                catch {
-                    storageEntries.push({ key, value: storage[key], scope: 1 , target: 0  });
-                }
-            }
-            this.storageService.storeAll(storageEntries, true);
-        }
-        this.editSessionsStorageService.delete('workspaceState', resource.ref);
-        return null;
-    }
-    applyResult(remoteUserData, lastSyncUserData, result, force) {
-        throw new Error('Method not implemented.');
-    }
-    async generateSyncPreview(remoteUserData, lastSyncUserData, isRemoteDataFromCurrentMachine, userDataSyncConfiguration, token) {
-        return [];
-    }
-    getMergeResult(resourcePreview, token) {
-        throw new Error('Method not implemented.');
-    }
-    getAcceptResult(resourcePreview, resource, content, token) {
-        throw new Error('Method not implemented.');
-    }
-    async hasRemoteChanged(lastSyncUserData) {
-        return true;
-    }
-    async hasLocalData() {
-        return false;
-    }
-    async resolveContent(uri) {
-        return null;
-    }
-};
-WorkspaceStateSynchroniser = ( __decorate([
-    ( __param(4, IFileService)),
-    ( __param(5, IEnvironmentService)),
-    ( __param(6, ITelemetryService)),
-    ( __param(7, IConfigurationService)),
-    ( __param(8, IStorageService)),
-    ( __param(9, IUriIdentityService)),
-    ( __param(10, IWorkspaceIdentityService)),
-    ( __param(11, IEditSessionsStorageService))
-], WorkspaceStateSynchroniser));
-export { WorkspaceStateSynchroniser };

package/vscode/src/vs/workbench/contrib/emmet/browser/actions/expandAbbreviation.js

@@ -1,41 +0,0 @@
-import { localizeWithPath } from '../../../../../nls.js';
-import { EmmetEditorAction } from '../emmetActions.js';
-import { registerEditorAction } from '../../../../../editor/browser/editorExtensions.js';
-import { EditorContextKeys } from '../../../../../editor/common/editorContextKeys.js';
-import { ContextKeyExpr } from '../../../../../platform/contextkey/common/contextkey.js';
-import { MenuId } from '../../../../../platform/actions/common/actions.js';
-class ExpandAbbreviationAction extends EmmetEditorAction {
-    constructor() {
-        super({
-            id: 'editor.emmet.action.expandAbbreviation',
-            label: ( localizeWithPath(
-                'vs/workbench/contrib/emmet/browser/actions/expandAbbreviation',
-                'expandAbbreviationAction',
-                "Emmet: Expand Abbreviation"
-            )),
-            alias: 'Emmet: Expand Abbreviation',
-            precondition: EditorContextKeys.writable,
-            actionName: 'expand_abbreviation',
-            kbOpts: {
-                primary: 2 ,
-                kbExpr: ( ContextKeyExpr.and(
-                    EditorContextKeys.editorTextFocus,
-                    EditorContextKeys.tabDoesNotMoveFocus,
-                    ( ContextKeyExpr.has('config.emmet.triggerExpansionOnTab'))
-                )),
-                weight: 100
-            },
-            menuOpts: {
-                menuId: MenuId.MenubarEditMenu,
-                group: '5_insert',
-                title: ( localizeWithPath(
-                    'vs/workbench/contrib/emmet/browser/actions/expandAbbreviation',
-                    { key: 'miEmmetExpandAbbreviation', comment: ['&& denotes a mnemonic'] },
-                    "Emmet: E&&xpand Abbreviation"
-                )),
-                order: 3
-            }
-        });
-    }
-}
-registerEditorAction(ExpandAbbreviationAction);

package/vscode/src/vs/workbench/contrib/emmet/browser/emmetActions.js

@@ -1,88 +0,0 @@
-import { EditorAction } from '../../../../editor/browser/editorExtensions.js';
-import { grammarsExtPoint } from '../../../services/textMate/common/TMGrammars.js';
-import { IExtensionService } from '../../../services/extensions/common/extensions.js';
-import { ICommandService } from '../../../../platform/commands/common/commands.js';
-class GrammarContributions {
-    static { this._grammars = {}; }
-    constructor(contributions) {
-        if (!( Object.keys(GrammarContributions._grammars)).length) {
-            this.fillModeScopeMap(contributions);
-        }
-    }
-    fillModeScopeMap(contributions) {
-        contributions.forEach((contribution) => {
-            contribution.value.forEach((grammar) => {
-                if (grammar.language && grammar.scopeName) {
-                    GrammarContributions._grammars[grammar.language] = grammar.scopeName;
-                }
-            });
-        });
-    }
-    getGrammar(mode) {
-        return GrammarContributions._grammars[mode];
-    }
-}
-class EmmetEditorAction extends EditorAction {
-    constructor(opts) {
-        super(opts);
-        this._lastGrammarContributions = null;
-        this._lastExtensionService = null;
-        this.emmetActionName = opts.actionName;
-    }
-    static { this.emmetSupportedModes = ['html', 'css', 'xml', 'xsl', 'haml', 'jade', 'jsx', 'slim', 'scss', 'sass', 'less', 'stylus', 'styl', 'svg']; }
-    _withGrammarContributions(extensionService) {
-        if (this._lastExtensionService !== extensionService) {
-            this._lastExtensionService = extensionService;
-            this._lastGrammarContributions = extensionService.readExtensionPointContributions(grammarsExtPoint).then((contributions) => {
-                return ( new GrammarContributions(contributions));
-            });
-        }
-        return this._lastGrammarContributions || Promise.resolve(null);
-    }
-    run(accessor, editor) {
-        const extensionService = accessor.get(IExtensionService);
-        const commandService = accessor.get(ICommandService);
-        return this._withGrammarContributions(extensionService).then((grammarContributions) => {
-            if (this.id === 'editor.emmet.action.expandAbbreviation' && grammarContributions) {
-                return commandService.executeCommand('emmet.expandAbbreviation', EmmetEditorAction.getLanguage(editor, grammarContributions));
-            }
-            return undefined;
-        });
-    }
-    static getLanguage(editor, grammars) {
-        const model = editor.getModel();
-        const selection = editor.getSelection();
-        if (!model || !selection) {
-            return null;
-        }
-        const position = selection.getStartPosition();
-        model.tokenization.tokenizeIfCheap(position.lineNumber);
-        const languageId = model.getLanguageIdAtPosition(position.lineNumber, position.column);
-        const syntax = languageId.split('.').pop();
-        if (!syntax) {
-            return null;
-        }
-        const checkParentMode = () => {
-            const languageGrammar = grammars.getGrammar(syntax);
-            if (!languageGrammar) {
-                return syntax;
-            }
-            const languages = languageGrammar.split('.');
-            if (languages.length < 2) {
-                return syntax;
-            }
-            for (let i = 1; i < languages.length; i++) {
-                const language = languages[languages.length - i];
-                if (this.emmetSupportedModes.indexOf(language) !== -1) {
-                    return language;
-                }
-            }
-            return syntax;
-        };
-        return {
-            language: syntax,
-            parentMode: checkParentMode()
-        };
-    }
-}
-export { EmmetEditorAction };