monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/keybindingLabels.js

@@ -0,0 +1,139 @@
+import { localize } from '../../nls.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class ModifierLabelProvider {
+    constructor(mac, windows, linux = windows) {
+        this.modifierLabels = [null]; // index 0 will never me accessed.
+        this.modifierLabels[2 /* OperatingSystem.Macintosh */] = mac;
+        this.modifierLabels[1 /* OperatingSystem.Windows */] = windows;
+        this.modifierLabels[3 /* OperatingSystem.Linux */] = linux;
+    }
+    toLabel(OS, chords, keyLabelProvider) {
+        if (chords.length === 0) {
+            return null;
+        }
+        const result = [];
+        for (let i = 0, len = chords.length; i < len; i++) {
+            const chord = chords[i];
+            const keyLabel = keyLabelProvider(chord);
+            if (keyLabel === null) {
+                // this keybinding cannot be expressed...
+                return null;
+            }
+            result[i] = _simpleAsString(chord, keyLabel, this.modifierLabels[OS]);
+        }
+        return result.join(' ');
+    }
+}
+/**
+ * A label provider that prints modifiers in a suitable format for displaying in the UI.
+ */
+const UILabelProvider = new ModifierLabelProvider({
+    ctrlKey: '\u2303',
+    shiftKey: '⇧',
+    altKey: '⌥',
+    metaKey: '⌘',
+    separator: '',
+}, {
+    ctrlKey: localize(35, "Ctrl"),
+    shiftKey: localize(36, "Shift"),
+    altKey: localize(37, "Alt"),
+    metaKey: localize(38, "Windows"),
+    separator: '+',
+}, {
+    ctrlKey: localize(39, "Ctrl"),
+    shiftKey: localize(40, "Shift"),
+    altKey: localize(41, "Alt"),
+    metaKey: localize(42, "Super"),
+    separator: '+',
+});
+/**
+ * A label provider that prints modifiers in a suitable format for ARIA.
+ */
+const AriaLabelProvider = new ModifierLabelProvider({
+    ctrlKey: localize(43, "Control"),
+    shiftKey: localize(44, "Shift"),
+    altKey: localize(45, "Option"),
+    metaKey: localize(46, "Command"),
+    separator: '+',
+}, {
+    ctrlKey: localize(47, "Control"),
+    shiftKey: localize(48, "Shift"),
+    altKey: localize(49, "Alt"),
+    metaKey: localize(50, "Windows"),
+    separator: '+',
+}, {
+    ctrlKey: localize(51, "Control"),
+    shiftKey: localize(52, "Shift"),
+    altKey: localize(53, "Alt"),
+    metaKey: localize(54, "Super"),
+    separator: '+',
+});
+/**
+ * A label provider that prints modifiers in a suitable format for Electron Accelerators.
+ * See https://github.com/electron/electron/blob/master/docs/api/accelerator.md
+ */
+const ElectronAcceleratorLabelProvider = new ModifierLabelProvider({
+    ctrlKey: 'Ctrl',
+    shiftKey: 'Shift',
+    altKey: 'Alt',
+    metaKey: 'Cmd',
+    separator: '+',
+}, {
+    ctrlKey: 'Ctrl',
+    shiftKey: 'Shift',
+    altKey: 'Alt',
+    metaKey: 'Super',
+    separator: '+',
+});
+/**
+ * A label provider that prints modifiers in a suitable format for user settings.
+ */
+const UserSettingsLabelProvider = new ModifierLabelProvider({
+    ctrlKey: 'ctrl',
+    shiftKey: 'shift',
+    altKey: 'alt',
+    metaKey: 'cmd',
+    separator: '+',
+}, {
+    ctrlKey: 'ctrl',
+    shiftKey: 'shift',
+    altKey: 'alt',
+    metaKey: 'win',
+    separator: '+',
+}, {
+    ctrlKey: 'ctrl',
+    shiftKey: 'shift',
+    altKey: 'alt',
+    metaKey: 'meta',
+    separator: '+',
+});
+function _simpleAsString(modifiers, key, labels) {
+    if (key === null) {
+        return '';
+    }
+    const result = [];
+    // translate modifier keys: Ctrl-Shift-Alt-Meta
+    if (modifiers.ctrlKey) {
+        result.push(labels.ctrlKey);
+    }
+    if (modifiers.shiftKey) {
+        result.push(labels.shiftKey);
+    }
+    if (modifiers.altKey) {
+        result.push(labels.altKey);
+    }
+    if (modifiers.metaKey) {
+        result.push(labels.metaKey);
+    }
+    // the actual key
+    if (key !== '') {
+        result.push(key);
+    }
+    return result.join(labels.separator);
+}
+
+export { AriaLabelProvider, ElectronAcceleratorLabelProvider, ModifierLabelProvider, UILabelProvider, UserSettingsLabelProvider };

package/dist/workers/keybindingResolver.js

@@ -0,0 +1,304 @@
+import { expressionsAreEqualWithConstantSubstitution, implies } from '../../contextkey/common/contextkey.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+// util definitions to make working with the above types easier within this module:
+const NoMatchingKb = { kind: 0 /* ResultKind.NoMatchingKb */ };
+const MoreChordsNeeded = { kind: 1 /* ResultKind.MoreChordsNeeded */ };
+function KbFound(commandId, commandArgs, isBubble) {
+    return { kind: 2 /* ResultKind.KbFound */, commandId, commandArgs, isBubble };
+}
+//#endregion
+/**
+ * Stores mappings from keybindings to commands and from commands to keybindings.
+ * Given a sequence of chords, `resolve`s which keybinding it matches
+ */
+class KeybindingResolver {
+    constructor(
+    /** built-in and extension-provided keybindings */
+    defaultKeybindings, 
+    /** user's keybindings */
+    overrides, log) {
+        this._log = log;
+        this._defaultKeybindings = defaultKeybindings;
+        this._defaultBoundCommands = new Map();
+        for (const defaultKeybinding of defaultKeybindings) {
+            const command = defaultKeybinding.command;
+            if (command && command.charAt(0) !== '-') {
+                this._defaultBoundCommands.set(command, true);
+            }
+        }
+        this._map = new Map();
+        this._lookupMap = new Map();
+        this._keybindings = KeybindingResolver.handleRemovals([].concat(defaultKeybindings).concat(overrides));
+        for (let i = 0, len = this._keybindings.length; i < len; i++) {
+            const k = this._keybindings[i];
+            if (k.chords.length === 0) {
+                // unbound
+                continue;
+            }
+            // substitute with constants that are registered after startup - https://github.com/microsoft/vscode/issues/174218#issuecomment-1437972127
+            const when = k.when?.substituteConstants();
+            if (when && when.type === 0 /* ContextKeyExprType.False */) {
+                // when condition is false
+                continue;
+            }
+            this._addKeyPress(k.chords[0], k);
+        }
+    }
+    static _isTargetedForRemoval(defaultKb, keypress, when) {
+        if (keypress) {
+            for (let i = 0; i < keypress.length; i++) {
+                if (keypress[i] !== defaultKb.chords[i]) {
+                    return false;
+                }
+            }
+        }
+        // `true` means always, as does `undefined`
+        // so we will treat `true` === `undefined`
+        if (when && when.type !== 1 /* ContextKeyExprType.True */) {
+            if (!defaultKb.when) {
+                return false;
+            }
+            if (!expressionsAreEqualWithConstantSubstitution(when, defaultKb.when)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Looks for rules containing "-commandId" and removes them.
+     */
+    static handleRemovals(rules) {
+        // Do a first pass and construct a hash-map for removals
+        const removals = new Map();
+        for (let i = 0, len = rules.length; i < len; i++) {
+            const rule = rules[i];
+            if (rule.command && rule.command.charAt(0) === '-') {
+                const command = rule.command.substring(1);
+                if (!removals.has(command)) {
+                    removals.set(command, [rule]);
+                }
+                else {
+                    removals.get(command).push(rule);
+                }
+            }
+        }
+        if (removals.size === 0) {
+            // There are no removals
+            return rules;
+        }
+        // Do a second pass and keep only non-removed keybindings
+        const result = [];
+        for (let i = 0, len = rules.length; i < len; i++) {
+            const rule = rules[i];
+            if (!rule.command || rule.command.length === 0) {
+                result.push(rule);
+                continue;
+            }
+            if (rule.command.charAt(0) === '-') {
+                continue;
+            }
+            const commandRemovals = removals.get(rule.command);
+            if (!commandRemovals || !rule.isDefault) {
+                result.push(rule);
+                continue;
+            }
+            let isRemoved = false;
+            for (const commandRemoval of commandRemovals) {
+                const when = commandRemoval.when;
+                if (this._isTargetedForRemoval(rule, commandRemoval.chords, when)) {
+                    isRemoved = true;
+                    break;
+                }
+            }
+            if (!isRemoved) {
+                result.push(rule);
+                continue;
+            }
+        }
+        return result;
+    }
+    _addKeyPress(keypress, item) {
+        const conflicts = this._map.get(keypress);
+        if (typeof conflicts === 'undefined') {
+            // There is no conflict so far
+            this._map.set(keypress, [item]);
+            this._addToLookupMap(item);
+            return;
+        }
+        for (let i = conflicts.length - 1; i >= 0; i--) {
+            const conflict = conflicts[i];
+            if (conflict.command === item.command) {
+                continue;
+            }
+            // Test if the shorter keybinding is a prefix of the longer one.
+            // If the shorter keybinding is a prefix, it effectively will shadow the longer one and is considered a conflict.
+            let isShorterKbPrefix = true;
+            for (let i = 1; i < conflict.chords.length && i < item.chords.length; i++) {
+                if (conflict.chords[i] !== item.chords[i]) {
+                    // The ith step does not conflict
+                    isShorterKbPrefix = false;
+                    break;
+                }
+            }
+            if (!isShorterKbPrefix) {
+                continue;
+            }
+            if (KeybindingResolver.whenIsEntirelyIncluded(conflict.when, item.when)) {
+                // `item` completely overwrites `conflict`
+                // Remove conflict from the lookupMap
+                this._removeFromLookupMap(conflict);
+            }
+        }
+        conflicts.push(item);
+        this._addToLookupMap(item);
+    }
+    _addToLookupMap(item) {
+        if (!item.command) {
+            return;
+        }
+        let arr = this._lookupMap.get(item.command);
+        if (typeof arr === 'undefined') {
+            arr = [item];
+            this._lookupMap.set(item.command, arr);
+        }
+        else {
+            arr.push(item);
+        }
+    }
+    _removeFromLookupMap(item) {
+        if (!item.command) {
+            return;
+        }
+        const arr = this._lookupMap.get(item.command);
+        if (typeof arr === 'undefined') {
+            return;
+        }
+        for (let i = 0, len = arr.length; i < len; i++) {
+            if (arr[i] === item) {
+                arr.splice(i, 1);
+                return;
+            }
+        }
+    }
+    /**
+     * Returns true if it is provable `a` implies `b`.
+     */
+    static whenIsEntirelyIncluded(a, b) {
+        if (!b || b.type === 1 /* ContextKeyExprType.True */) {
+            return true;
+        }
+        if (!a || a.type === 1 /* ContextKeyExprType.True */) {
+            return false;
+        }
+        return implies(a, b);
+    }
+    getKeybindings() {
+        return this._keybindings;
+    }
+    lookupPrimaryKeybinding(commandId, context, enforceContextCheck = false) {
+        const items = this._lookupMap.get(commandId);
+        if (typeof items === 'undefined' || items.length === 0) {
+            return null;
+        }
+        if (items.length === 1 && !enforceContextCheck) {
+            return items[0];
+        }
+        for (let i = items.length - 1; i >= 0; i--) {
+            const item = items[i];
+            if (context.contextMatchesRules(item.when)) {
+                return item;
+            }
+        }
+        if (enforceContextCheck) {
+            return null;
+        }
+        return items[items.length - 1];
+    }
+    /**
+     * Looks up a keybinding trigged as a result of pressing a sequence of chords - `[...currentChords, keypress]`
+     *
+     * Example: resolving 3 chords pressed sequentially - `cmd+k cmd+p cmd+i`:
+     * 	`currentChords = [ 'cmd+k' , 'cmd+p' ]` and `keypress = `cmd+i` - last pressed chord
+     */
+    resolve(context, currentChords, keypress) {
+        const pressedChords = [...currentChords, keypress];
+        this._log(`| Resolving ${pressedChords}`);
+        const kbCandidates = this._map.get(pressedChords[0]);
+        if (kbCandidates === undefined) {
+            // No bindings with such 0-th chord
+            this._log(`\\ No keybinding entries.`);
+            return NoMatchingKb;
+        }
+        let lookupMap = null;
+        if (pressedChords.length < 2) {
+            lookupMap = kbCandidates;
+        }
+        else {
+            // Fetch all chord bindings for `currentChords`
+            lookupMap = [];
+            for (let i = 0, len = kbCandidates.length; i < len; i++) {
+                const candidate = kbCandidates[i];
+                if (pressedChords.length > candidate.chords.length) { // # of pressed chords can't be less than # of chords in a keybinding to invoke
+                    continue;
+                }
+                let prefixMatches = true;
+                for (let i = 1; i < pressedChords.length; i++) {
+                    if (candidate.chords[i] !== pressedChords[i]) {
+                        prefixMatches = false;
+                        break;
+                    }
+                }
+                if (prefixMatches) {
+                    lookupMap.push(candidate);
+                }
+            }
+        }
+        // check there's a keybinding with a matching when clause
+        const result = this._findCommand(context, lookupMap);
+        if (!result) {
+            this._log(`\\ From ${lookupMap.length} keybinding entries, no when clauses matched the context.`);
+            return NoMatchingKb;
+        }
+        // check we got all chords necessary to be sure a particular keybinding needs to be invoked
+        if (pressedChords.length < result.chords.length) {
+            // The chord sequence is not complete
+            this._log(`\\ From ${lookupMap.length} keybinding entries, awaiting ${result.chords.length - pressedChords.length} more chord(s), when: ${printWhenExplanation(result.when)}, source: ${printSourceExplanation(result)}.`);
+            return MoreChordsNeeded;
+        }
+        this._log(`\\ From ${lookupMap.length} keybinding entries, matched ${result.command}, when: ${printWhenExplanation(result.when)}, source: ${printSourceExplanation(result)}.`);
+        return KbFound(result.command, result.commandArgs, result.bubble);
+    }
+    _findCommand(context, matches) {
+        for (let i = matches.length - 1; i >= 0; i--) {
+            const k = matches[i];
+            if (!KeybindingResolver._contextMatchesRules(context, k.when)) {
+                continue;
+            }
+            return k;
+        }
+        return null;
+    }
+    static _contextMatchesRules(context, rules) {
+        if (!rules) {
+            return true;
+        }
+        return rules.evaluate(context);
+    }
+}
+function printWhenExplanation(when) {
+    if (!when) {
+        return `no when condition`;
+    }
+    return `${when.serialize()}`;
+}
+function printSourceExplanation(kb) {
+    return (kb.extensionId
+        ? (kb.isBuiltinExtension ? `built-in extension ${kb.extensionId}` : `user extension ${kb.extensionId}`)
+        : (kb.isDefault ? `built-in` : `user`));
+}
+
+export { KeybindingResolver, NoMatchingKb };

package/dist/workers/keybindings.js

@@ -0,0 +1,104 @@
+import { illegalArgument } from './errors.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function decodeKeybinding(keybinding, OS) {
+    if (typeof keybinding === 'number') {
+        if (keybinding === 0) {
+            return null;
+        }
+        const firstChord = (keybinding & 0x0000FFFF) >>> 0;
+        const secondChord = (keybinding & 0xFFFF0000) >>> 16;
+        if (secondChord !== 0) {
+            return new Keybinding([
+                createSimpleKeybinding(firstChord, OS),
+                createSimpleKeybinding(secondChord, OS)
+            ]);
+        }
+        return new Keybinding([createSimpleKeybinding(firstChord, OS)]);
+    }
+    else {
+        const chords = [];
+        for (let i = 0; i < keybinding.length; i++) {
+            chords.push(createSimpleKeybinding(keybinding[i], OS));
+        }
+        return new Keybinding(chords);
+    }
+}
+function createSimpleKeybinding(keybinding, OS) {
+    const ctrlCmd = (keybinding & 2048 /* BinaryKeybindingsMask.CtrlCmd */ ? true : false);
+    const winCtrl = (keybinding & 256 /* BinaryKeybindingsMask.WinCtrl */ ? true : false);
+    const ctrlKey = (OS === 2 /* OperatingSystem.Macintosh */ ? winCtrl : ctrlCmd);
+    const shiftKey = (keybinding & 1024 /* BinaryKeybindingsMask.Shift */ ? true : false);
+    const altKey = (keybinding & 512 /* BinaryKeybindingsMask.Alt */ ? true : false);
+    const metaKey = (OS === 2 /* OperatingSystem.Macintosh */ ? ctrlCmd : winCtrl);
+    const keyCode = (keybinding & 255 /* BinaryKeybindingsMask.KeyCode */);
+    return new KeyCodeChord(ctrlKey, shiftKey, altKey, metaKey, keyCode);
+}
+/**
+ * Represents a chord which uses the `keyCode` field of keyboard events.
+ * A chord is a combination of keys pressed simultaneously.
+ */
+class KeyCodeChord {
+    constructor(ctrlKey, shiftKey, altKey, metaKey, keyCode) {
+        this.ctrlKey = ctrlKey;
+        this.shiftKey = shiftKey;
+        this.altKey = altKey;
+        this.metaKey = metaKey;
+        this.keyCode = keyCode;
+    }
+    equals(other) {
+        return (other instanceof KeyCodeChord
+            && this.ctrlKey === other.ctrlKey
+            && this.shiftKey === other.shiftKey
+            && this.altKey === other.altKey
+            && this.metaKey === other.metaKey
+            && this.keyCode === other.keyCode);
+    }
+    isModifierKey() {
+        return (this.keyCode === 0 /* KeyCode.Unknown */
+            || this.keyCode === 5 /* KeyCode.Ctrl */
+            || this.keyCode === 57 /* KeyCode.Meta */
+            || this.keyCode === 6 /* KeyCode.Alt */
+            || this.keyCode === 4 /* KeyCode.Shift */);
+    }
+    /**
+     * Does this keybinding refer to the key code of a modifier and it also has the modifier flag?
+     */
+    isDuplicateModifierCase() {
+        return ((this.ctrlKey && this.keyCode === 5 /* KeyCode.Ctrl */)
+            || (this.shiftKey && this.keyCode === 4 /* KeyCode.Shift */)
+            || (this.altKey && this.keyCode === 6 /* KeyCode.Alt */)
+            || (this.metaKey && this.keyCode === 57 /* KeyCode.Meta */));
+    }
+}
+/**
+ * A keybinding is a sequence of chords.
+ */
+class Keybinding {
+    constructor(chords) {
+        if (chords.length === 0) {
+            throw illegalArgument(`chords`);
+        }
+        this.chords = chords;
+    }
+}
+class ResolvedChord {
+    constructor(ctrlKey, shiftKey, altKey, metaKey, keyLabel, keyAriaLabel) {
+        this.ctrlKey = ctrlKey;
+        this.shiftKey = shiftKey;
+        this.altKey = altKey;
+        this.metaKey = metaKey;
+        this.keyLabel = keyLabel;
+        this.keyAriaLabel = keyAriaLabel;
+    }
+}
+/**
+ * A resolved keybinding. Consists of one or multiple chords.
+ */
+class ResolvedKeybinding {
+}
+
+export { KeyCodeChord, Keybinding, ResolvedChord, ResolvedKeybinding, createSimpleKeybinding, decodeKeybinding };

package/dist/workers/keybindingsRegistry.js

@@ -0,0 +1,111 @@
+import { decodeKeybinding } from '../../../base/common/keybindings.js';
+import { OS } from '../../../base/common/platform.js';
+import { CommandsRegistry } from '../../commands/common/commands.js';
+import { Registry } from '../../registry/common/platform.js';
+import { DisposableStore, combinedDisposable, toDisposable } from '../../../base/common/lifecycle.js';
+import { LinkedList } from '../../../base/common/linkedList.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Stores all built-in and extension-provided keybindings (but not ones that user defines themselves)
+ */
+class KeybindingsRegistryImpl {
+    constructor() {
+        this._coreKeybindings = new LinkedList();
+        this._extensionKeybindings = [];
+        this._cachedMergedKeybindings = null;
+    }
+    /**
+     * Take current platform into account and reduce to primary & secondary.
+     */
+    static bindToCurrentPlatform(kb) {
+        if (OS === 1 /* OperatingSystem.Windows */) {
+            if (kb && kb.win) {
+                return kb.win;
+            }
+        }
+        else if (OS === 2 /* OperatingSystem.Macintosh */) {
+            if (kb && kb.mac) {
+                return kb.mac;
+            }
+        }
+        else {
+            if (kb && kb.linux) {
+                return kb.linux;
+            }
+        }
+        return kb;
+    }
+    registerKeybindingRule(rule) {
+        const actualKb = KeybindingsRegistryImpl.bindToCurrentPlatform(rule);
+        const result = new DisposableStore();
+        if (actualKb && actualKb.primary) {
+            const kk = decodeKeybinding(actualKb.primary, OS);
+            if (kk) {
+                result.add(this._registerDefaultKeybinding(kk, rule.id, rule.args, rule.weight, 0, rule.when));
+            }
+        }
+        if (actualKb && Array.isArray(actualKb.secondary)) {
+            for (let i = 0, len = actualKb.secondary.length; i < len; i++) {
+                const k = actualKb.secondary[i];
+                const kk = decodeKeybinding(k, OS);
+                if (kk) {
+                    result.add(this._registerDefaultKeybinding(kk, rule.id, rule.args, rule.weight, -i - 1, rule.when));
+                }
+            }
+        }
+        return result;
+    }
+    registerCommandAndKeybindingRule(desc) {
+        return combinedDisposable(this.registerKeybindingRule(desc), CommandsRegistry.registerCommand(desc));
+    }
+    _registerDefaultKeybinding(keybinding, commandId, commandArgs, weight1, weight2, when) {
+        const remove = this._coreKeybindings.push({
+            keybinding: keybinding,
+            command: commandId,
+            commandArgs: commandArgs,
+            when: when,
+            weight1: weight1,
+            weight2: weight2,
+            extensionId: null,
+            isBuiltinExtension: false
+        });
+        this._cachedMergedKeybindings = null;
+        return toDisposable(() => {
+            remove();
+            this._cachedMergedKeybindings = null;
+        });
+    }
+    getDefaultKeybindings() {
+        if (!this._cachedMergedKeybindings) {
+            this._cachedMergedKeybindings = Array.from(this._coreKeybindings).concat(this._extensionKeybindings);
+            this._cachedMergedKeybindings.sort(sorter);
+        }
+        return this._cachedMergedKeybindings.slice(0);
+    }
+}
+const KeybindingsRegistry = new KeybindingsRegistryImpl();
+// Define extension point ids
+const Extensions = {
+    EditorModes: 'platform.keybindingsRegistry'
+};
+Registry.add(Extensions.EditorModes, KeybindingsRegistry);
+function sorter(a, b) {
+    if (a.weight1 !== b.weight1) {
+        return a.weight1 - b.weight1;
+    }
+    if (a.command && b.command) {
+        if (a.command < b.command) {
+            return -1;
+        }
+        if (a.command > b.command) {
+            return 1;
+        }
+    }
+    return a.weight2 - b.weight2;
+}
+
+export { Extensions, KeybindingsRegistry };