custom-electron-titlebar 3.2.6 → 3.2.10

package/lib/vs/platform/keybinding/common/keybindingResolver.js

@@ -1,391 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.KeybindingResolver = void 0;
-
-class KeybindingResolver {
-  constructor(defaultKeybindings, overrides, log) {
-    this._log = log;
-    this._defaultKeybindings = defaultKeybindings;
-    this._defaultBoundCommands = new Map();
-
-    for (let i = 0, len = defaultKeybindings.length; i < len; i++) {
-      const command = defaultKeybindings[i].command;
-
-      if (command) {
-        this._defaultBoundCommands.set(command, true);
-      }
-    }
-
-    this._map = new Map();
-    this._lookupMap = new Map();
-    this._keybindings = KeybindingResolver.combine(defaultKeybindings, overrides);
-
-    for (let i = 0, len = this._keybindings.length; i < len; i++) {
-      let k = this._keybindings[i];
-
-      if (k.keypressParts.length === 0) {
-        // unbound
-        continue;
-      }
-
-      if (k.when && k.when.type === 0
-      /* False */
-      ) {
-          // when condition is false
-          continue;
-        } // TODO@chords
-
-
-      this._addKeyPress(k.keypressParts[0], k);
-    }
-  }
-
-  static _isTargetedForRemoval(defaultKb, keypressFirstPart, keypressChordPart, command, when) {
-    if (defaultKb.command !== command) {
-      return false;
-    } // TODO@chords
-
-
-    if (keypressFirstPart && defaultKb.keypressParts[0] !== keypressFirstPart) {
-      return false;
-    } // TODO@chords
-
-
-    if (keypressChordPart && defaultKb.keypressParts[1] !== keypressChordPart) {
-      return false;
-    }
-
-    if (when) {
-      if (!defaultKb.when) {
-        return false;
-      }
-
-      if (!when.equals(defaultKb.when)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-  /**
-   * Looks for rules containing -command in `overrides` and removes them directly from `defaults`.
-   */
-
-
-  static combine(defaults, rawOverrides) {
-    defaults = defaults.slice(0);
-    let overrides = [];
-
-    for (const override of rawOverrides) {
-      if (!override.command || override.command.length === 0 || override.command.charAt(0) !== '-') {
-        overrides.push(override);
-        continue;
-      }
-
-      const command = override.command.substr(1); // TODO@chords
-
-      const keypressFirstPart = override.keypressParts[0];
-      const keypressChordPart = override.keypressParts[1];
-      const when = override.when;
-
-      for (let j = defaults.length - 1; j >= 0; j--) {
-        if (this._isTargetedForRemoval(defaults[j], keypressFirstPart, keypressChordPart, command, when)) {
-          defaults.splice(j, 1);
-        }
-      }
-    }
-
-    return defaults.concat(overrides);
-  }
-
-  _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--) {
-      let conflict = conflicts[i];
-
-      if (conflict.command === item.command) {
-        continue;
-      }
-
-      const conflictIsChord = conflict.keypressParts.length > 1;
-      const itemIsChord = item.keypressParts.length > 1; // TODO@chords
-
-      if (conflictIsChord && itemIsChord && conflict.keypressParts[1] !== item.keypressParts[1]) {
-        // The conflict only shares the chord start with this command
-        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;
-    }
-
-    let 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) {
-      return true;
-    }
-
-    if (!a) {
-      return false;
-    }
-
-    return this._implies(a, b);
-  }
-  /**
-   * Returns true if it is provable `p` implies `q`.
-   */
-
-
-  static _implies(p, q) {
-    const notP = p.negate();
-
-    const terminals = node => {
-      if (node.type === 9
-      /* Or */
-      ) {
-          return node.expr;
-        }
-
-      return [node];
-    };
-
-    let expr = terminals(notP).concat(terminals(q));
-
-    for (let i = 0; i < expr.length; i++) {
-      const a = expr[i];
-      const notA = a.negate();
-
-      for (let j = i + 1; j < expr.length; j++) {
-        const b = expr[j];
-
-        if (notA.equals(b)) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-
-  getDefaultBoundCommands() {
-    return this._defaultBoundCommands;
-  }
-
-  getDefaultKeybindings() {
-    return this._defaultKeybindings;
-  }
-
-  getKeybindings() {
-    return this._keybindings;
-  }
-
-  lookupKeybindings(commandId) {
-    let items = this._lookupMap.get(commandId);
-
-    if (typeof items === 'undefined' || items.length === 0) {
-      return [];
-    } // Reverse to get the most specific item first
-
-
-    let result = [],
-        resultLen = 0;
-
-    for (let i = items.length - 1; i >= 0; i--) {
-      result[resultLen++] = items[i];
-    }
-
-    return result;
-  }
-
-  lookupPrimaryKeybinding(commandId) {
-    let items = this._lookupMap.get(commandId);
-
-    if (typeof items === 'undefined' || items.length === 0) {
-      return null;
-    }
-
-    return items[items.length - 1];
-  }
-
-  resolve(context, currentChord, keypress) {
-    this._log(`| Resolving ${keypress}${currentChord ? ` chorded from ${currentChord}` : ``}`);
-
-    let lookupMap = null;
-
-    if (currentChord !== null) {
-      // Fetch all chord bindings for `currentChord`
-      const candidates = this._map.get(currentChord);
-
-      if (typeof candidates === 'undefined') {
-        // No chords starting with `currentChord`
-        this._log(`\\ No keybinding entries.`);
-
-        return null;
-      }
-
-      lookupMap = [];
-
-      for (let i = 0, len = candidates.length; i < len; i++) {
-        let candidate = candidates[i]; // TODO@chords
-
-        if (candidate.keypressParts[1] === keypress) {
-          lookupMap.push(candidate);
-        }
-      }
-    } else {
-      const candidates = this._map.get(keypress);
-
-      if (typeof candidates === 'undefined') {
-        // No bindings with `keypress`
-        this._log(`\\ No keybinding entries.`);
-
-        return null;
-      }
-
-      lookupMap = candidates;
-    }
-
-    let result = this._findCommand(context, lookupMap);
-
-    if (!result) {
-      this._log(`\\ From ${lookupMap.length} keybinding entries, no when clauses matched the context.`);
-
-      return null;
-    } // TODO@chords
-
-
-    if (currentChord === null && result.keypressParts.length > 1 && result.keypressParts[1] !== null) {
-      this._log(`\\ From ${lookupMap.length} keybinding entries, matched chord, when: ${printWhenExplanation(result.when)}, source: ${printSourceExplanation(result)}.`);
-
-      return {
-        enterChord: true,
-        leaveChord: false,
-        commandId: null,
-        commandArgs: null,
-        bubble: false
-      };
-    }
-
-    this._log(`\\ From ${lookupMap.length} keybinding entries, matched ${result.command}, when: ${printWhenExplanation(result.when)}, source: ${printSourceExplanation(result)}.`);
-
-    return {
-      enterChord: false,
-      leaveChord: result.keypressParts.length > 1,
-      commandId: result.command,
-      commandArgs: result.commandArgs,
-      bubble: result.bubble
-    };
-  }
-
-  _findCommand(context, matches) {
-    for (let i = matches.length - 1; i >= 0; i--) {
-      let 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);
-  }
-
-}
-
-exports.KeybindingResolver = KeybindingResolver;
-
-function printWhenExplanation(when) {
-  if (!when) {
-    return `no when condition`;
-  }
-
-  return `${when.serialize()}`;
-}
-
-function printSourceExplanation(kb) {
-  if (kb.isDefault) {
-    if (kb.extensionId) {
-      return `built-in extension ${kb.extensionId}`;
-    }
-
-    return `built-in`;
-  }
-
-  if (kb.extensionId) {
-    return `user extension ${kb.extensionId}`;
-  }
-
-  return `user`;
-}

package/lib/vs/platform/keybinding/common/keybindingsRegistry.js

@@ -1,229 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.KeybindingsRegistry = void 0;
-
-const keyCodes_1 = require("../../../base/common/keyCodes");
-
-const platform_1 = require("../../../base/common/platform");
-
-class KeybindingsRegistryImpl {
-  constructor() {
-    this._coreKeybindings = [];
-    this._extensionKeybindings = [];
-    this._cachedMergedKeybindings = null;
-  }
-  /**
-   * Take current platform into account and reduce to primary & secondary.
-   */
-
-
-  static bindToCurrentPlatform(kb) {
-    if (platform_1.OS === 1
-    /* Windows */
-    ) {
-        if (kb && kb.win) {
-          return kb.win;
-        }
-      } else if (platform_1.OS === 2
-    /* Macintosh */
-    ) {
-        if (kb && kb.mac) {
-          return kb.mac;
-        }
-      } else {
-      if (kb && kb.linux) {
-        return kb.linux;
-      }
-    }
-
-    return kb;
-  }
-  /**
-   * Take current platform into account and reduce to primary & secondary.
-   */
-
-
-  static bindToCurrentPlatform2(kb) {
-    if (platform_1.OS === 1
-    /* Windows */
-    ) {
-        if (kb && kb.win) {
-          return kb.win;
-        }
-      } else if (platform_1.OS === 2
-    /* 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);
-
-    if (actualKb && actualKb.primary) {
-      const kk = keyCodes_1.createKeybinding(actualKb.primary, platform_1.OS);
-
-      if (kk) {
-        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 = keyCodes_1.createKeybinding(k, platform_1.OS);
-
-        if (kk) {
-          this._registerDefaultKeybinding(kk, rule.id, rule.args, rule.weight, -i - 1, rule.when);
-        }
-      }
-    }
-  }
-
-  setExtensionKeybindings(rules) {
-    let result = [],
-        keybindingsLen = 0;
-
-    for (let i = 0, len = rules.length; i < len; i++) {
-      const rule = rules[i];
-      let actualKb = KeybindingsRegistryImpl.bindToCurrentPlatform2(rule);
-
-      if (actualKb && actualKb.primary) {
-        result[keybindingsLen++] = {
-          keybinding: actualKb.primary,
-          command: rule.id,
-          commandArgs: rule.args,
-          when: rule.when,
-          weight1: rule.weight,
-          weight2: 0,
-          extensionId: rule.extensionId || null
-        };
-      }
-    }
-
-    this._extensionKeybindings = result;
-    this._cachedMergedKeybindings = null;
-  }
-
-  static _mightProduceChar(keyCode) {
-    if (keyCode >= 21
-    /* KEY_0 */
-    && keyCode <= 30
-    /* KEY_9 */
-    ) {
-        return true;
-      }
-
-    if (keyCode >= 31
-    /* KEY_A */
-    && keyCode <= 56
-    /* KEY_Z */
-    ) {
-        return true;
-      }
-
-    return keyCode === 80
-    /* US_SEMICOLON */
-    || keyCode === 81
-    /* US_EQUAL */
-    || keyCode === 82
-    /* US_COMMA */
-    || keyCode === 83
-    /* US_MINUS */
-    || keyCode === 84
-    /* US_DOT */
-    || keyCode === 85
-    /* US_SLASH */
-    || keyCode === 86
-    /* US_BACKTICK */
-    || keyCode === 110
-    /* ABNT_C1 */
-    || keyCode === 111
-    /* ABNT_C2 */
-    || keyCode === 87
-    /* US_OPEN_SQUARE_BRACKET */
-    || keyCode === 88
-    /* US_BACKSLASH */
-    || keyCode === 89
-    /* US_CLOSE_SQUARE_BRACKET */
-    || keyCode === 90
-    /* US_QUOTE */
-    || keyCode === 91
-    /* OEM_8 */
-    || keyCode === 92
-    /* OEM_102 */
-    ;
-  }
-
-  _assertNoCtrlAlt(keybinding, commandId) {
-    if (keybinding.ctrlKey && keybinding.altKey && !keybinding.metaKey) {
-      if (KeybindingsRegistryImpl._mightProduceChar(keybinding.keyCode)) {
-        console.warn('Ctrl+Alt+ keybindings should not be used by default under Windows. Offender: ', keybinding, ' for ', commandId);
-      }
-    }
-  }
-
-  _registerDefaultKeybinding(keybinding, commandId, commandArgs, weight1, weight2, when) {
-    if (platform_1.OS === 1
-    /* Windows */
-    ) {
-        this._assertNoCtrlAlt(keybinding.parts[0], commandId);
-      }
-
-    this._coreKeybindings.push({
-      keybinding: keybinding,
-      command: commandId,
-      commandArgs: commandArgs,
-      when: when,
-      weight1: weight1,
-      weight2: weight2,
-      extensionId: null
-    });
-
-    this._cachedMergedKeybindings = null;
-  }
-
-  getDefaultKeybindings() {
-    if (!this._cachedMergedKeybindings) {
-      this._cachedMergedKeybindings = [].concat(this._coreKeybindings).concat(this._extensionKeybindings);
-
-      this._cachedMergedKeybindings.sort(sorter);
-    }
-
-    return this._cachedMergedKeybindings.slice(0);
-  }
-
-}
-
-exports.KeybindingsRegistry = new KeybindingsRegistryImpl();
-
-function sorter(a, b) {
-  if (a.weight1 !== b.weight1) {
-    return a.weight1 - b.weight1;
-  }
-
-  if (a.command < b.command) {
-    return -1;
-  }
-
-  if (a.command > b.command) {
-    return 1;
-  }
-
-  return a.weight2 - b.weight2;
-}

package/lib/vs/platform/keybinding/common/resolvedKeybindingItem.js

@@ -1,47 +0,0 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.removeElementsAfterNulls = exports.ResolvedKeybindingItem = void 0;
-
-class ResolvedKeybindingItem {
-  constructor(resolvedKeybinding, command, commandArgs, when, isDefault, extensionId) {
-    this.resolvedKeybinding = resolvedKeybinding;
-    this.keypressParts = resolvedKeybinding ? removeElementsAfterNulls(resolvedKeybinding.getDispatchParts()) : [];
-    this.bubble = command ? command.charCodeAt(0) === 94
-    /* Caret */
-    : false;
-    this.command = this.bubble ? command.substr(1) : command;
-    this.commandArgs = commandArgs;
-    this.when = when;
-    this.isDefault = isDefault;
-    this.extensionId = extensionId;
-  }
-
-}
-
-exports.ResolvedKeybindingItem = ResolvedKeybindingItem;
-
-function removeElementsAfterNulls(arr) {
-  let result = [];
-
-  for (let i = 0, len = arr.length; i < len; i++) {
-    const element = arr[i];
-
-    if (!element) {
-      // stop processing at first encountered null
-      return result;
-    }
-
-    result.push(element);
-  }
-
-  return result;
-}
-
-exports.removeElementsAfterNulls = removeElementsAfterNulls;