@codingame/monaco-vscode-emmet-service-override 4.1.0 → 4.1.1

package/emmet.js

@@ -1,4 +1,4 @@
-import 'vscode/vscode/vs/workbench/contrib/emmet/browser/actions/expandAbbreviation';
+import './vscode/src/vs/workbench/contrib/emmet/browser/actions/expandAbbreviation.js';
 
 function getServiceOverride() {
     return {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-emmet-service-override",
-  "version": "4.1.0",
+  "version": "4.1.1",
   "keywords": [],
   "author": {
     "name": "CodinGame",
@@ -18,6 +18,6 @@
   "module": "index.js",
   "types": "index.d.ts",
   "dependencies": {
-    "vscode": "npm:@codingame/monaco-vscode-api@4.1.0"
+    "vscode": "npm:@codingame/monaco-vscode-api@4.1.1"
   }
 }

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

@@ -0,0 +1,42 @@
+import { localizeWithPath } from 'vscode/vscode/vs/nls';
+import { EmmetEditorAction } from '../emmetActions.js';
+import { registerEditorAction } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { EditorContextKeys } from 'vscode/vscode/vs/editor/common/editorContextKeys';
+import { ContextKeyExpr } from 'vscode/vscode/vs/platform/contextkey/common/contextkey';
+import { MenuId } from 'vscode/vscode/vs/platform/actions/common/actions';
+
+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

@@ -0,0 +1,90 @@
+import { EditorAction } from 'vscode/vscode/vs/editor/browser/editorExtensions';
+import { grammarsExtPoint } from 'vscode/vscode/vs/workbench/services/textMate/common/TMGrammars';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { ICommandService } from 'vscode/vscode/vs/platform/commands/common/commands';
+
+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 };