@difizen/mana-core/lib/keybinding/vs/contextKeyService.js

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.VSContextKeyService = exports.OverlayContextKeyService = exports.Context = exports.AbstractContextKeyService = void 0;
var _manaCommon = require("@difizen/mana-common");
var _manaObservable = require("@difizen/mana-observable");
var _manaSyringe = require("@difizen/mana-syringe");
var _utils = require("../../utils");
var _map = require("../../utils/map");
var _configuration = require("./configuration/configuration");
var _contextkey = require("./contextkey");
var _dec, _class, _descriptor, _NullContext, _dec2, _class2, _dec3, _class3;
/*---------------------------------------------------------------------------------------------
 *  Copyright (c) Microsoft Corporation. All rights reserved.
 *  Licensed under the MIT License. See License.txt in the project root for license information.
 *--------------------------------------------------------------------------------------------*/
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _initializerDefineProperty(target, property, descriptor, context) { if (!descriptor) return; Object.defineProperty(target, property, { enumerable: descriptor.enumerable, configurable: descriptor.configurable, writable: descriptor.writable, value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 }); }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { var desc = {}; Object.keys(descriptor).forEach(function (key) { desc[key] = descriptor[key]; }); desc.enumerable = !!desc.enumerable; desc.configurable = !!desc.configurable; if ('value' in desc || desc.initializer) { desc.writable = true; } desc = decorators.slice().reverse().reduce(function (desc, decorator) { return decorator(target, property, desc) || desc; }, desc); if (context && desc.initializer !== void 0) { desc.value = desc.initializer ? desc.initializer.call(context) : void 0; desc.initializer = undefined; } if (desc.initializer === void 0) { Object.defineProperty(target, property, desc); desc = null; } return desc; }
function _initializerWarningHelper(descriptor, context) { throw new Error('Decorating class property failed. Please ensure that ' + 'transform-class-properties is enabled and runs after the decorators transform.'); }
var KEYBINDING_CONTEXT_ATTR = 'data-mana-keybinding-context';
var Context = exports.Context = (_dec = (0, _manaObservable.prop)(), (_class = /*#__PURE__*/function () {
  function Context(id, parent) {
    _classCallCheck(this, Context);
    _initializerDefineProperty(this, "_value", _descriptor, this);
    this._id = id;
    this._parent = parent;
    this._value = Object.create(null);
    this._value['_contextId'] = id;
  }
  _createClass(Context, [{
    key: "setValue",
    value: function setValue(key, value) {
      if (this._value[key] !== value) {
        this._value[key] = value;
        return true;
      }
      return false;
    }
  }, {
    key: "removeValue",
    value: function removeValue(key) {
      if (key in this._value) {
        delete this._value[key];
        return true;
      }
      return false;
    }
  }, {
    key: "getValue",
    value: function getValue(key) {
      var ret = this._value[key];
      if (typeof ret === 'undefined' && this._parent) {
        return this._parent.getValue(key);
      }
      return ret;
    }
  }, {
    key: "updateParent",
    value: function updateParent(parent) {
      this._parent = parent;
    }
  }, {
    key: "collectAllValues",
    value: function collectAllValues() {
      var result = this._parent ? this._parent.collectAllValues() : Object.create(null);
      result = _objectSpread(_objectSpread({}, result), this._value);
      delete result._contextId;
      return result;
    }
  }]);
  return Context;
}(), (_descriptor = _applyDecoratedDescriptor(_class.prototype, "_value", [_dec], {
  configurable: true,
  enumerable: true,
  writable: true,
  initializer: null
})), _class));
var NullContext = /*#__PURE__*/function (_Context2) {
  _inherits(NullContext, _Context2);
  var _super = _createSuper(NullContext);
  function NullContext() {
    _classCallCheck(this, NullContext);
    return _super.call(this, -1, null);
  }
  _createClass(NullContext, [{
    key: "setValue",
    value: function setValue(_key, _value) {
      return false;
    }
  }, {
    key: "removeValue",
    value: function removeValue(_key) {
      return false;
    }
  }, {
    key: "getValue",
    value: function getValue(_key) {
      return undefined;
    }
  }, {
    key: "collectAllValues",
    value: function collectAllValues() {
      return Object.create(null);
    }
  }]);
  return NullContext;
}(Context);
_NullContext = NullContext;
NullContext.INSTANCE = new _NullContext();
var ConfigAwareContextValuesContainer = /*#__PURE__*/function (_Context3) {
  _inherits(ConfigAwareContextValuesContainer, _Context3);
  var _super2 = _createSuper(ConfigAwareContextValuesContainer);
  function ConfigAwareContextValuesContainer(id, _configurationService, emitter) {
    var _this;
    _classCallCheck(this, ConfigAwareContextValuesContainer);
    _this = _super2.call(this, id, null);
    _this._values = _map.TernarySearchTree.forConfigKeys();
    _this._configurationService = _configurationService;
    _this._listener = _this._configurationService.onDidChangeConfiguration(function (event) {
      if (event.source === _configuration.ConfigurationTarget.DEFAULT) {
        // new setting, reset everything
        var allKeys = Array.from(_manaCommon.Iterable.map(_this._values, function (_ref) {
          var _ref2 = _slicedToArray(_ref, 1),
            k = _ref2[0];
          return k;
        }));
        _this._values.clear();
        emitter.fire(new ArrayContextKeyChangeEvent(allKeys));
      } else {
        var changedKeys = [];
        var _iterator = _createForOfIteratorHelper(event.affectedKeys),
          _step;
        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var configKey = _step.value;
            var contextKey = "config.".concat(configKey);
            var cachedItems = _this._values.findSuperstr(contextKey);
            if (cachedItems !== undefined) {
              changedKeys.push.apply(changedKeys, _toConsumableArray(_manaCommon.Iterable.map(cachedItems, function (_ref3) {
                var _ref4 = _slicedToArray(_ref3, 1),
                  key = _ref4[0];
                return key;
              })));
              _this._values.deleteSuperstr(contextKey);
            }
            if (_this._values.has(contextKey)) {
              changedKeys.push(contextKey);
              _this._values.delete(contextKey);
            }
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }
        emitter.fire(new ArrayContextKeyChangeEvent(changedKeys));
      }
    });
    return _this;
  }
  _createClass(ConfigAwareContextValuesContainer, [{
    key: "dispose",
    value: function dispose() {
      this._listener.dispose();
    }
  }, {
    key: "getValue",
    value: function getValue(key) {
      if (key.indexOf(ConfigAwareContextValuesContainer._keyPrefix) !== 0) {
        return _get(_getPrototypeOf(ConfigAwareContextValuesContainer.prototype), "getValue", this).call(this, key);
      }
      if (this._values.has(key)) {
        return this._values.get(key);
      }
      var configKey = key.substr(ConfigAwareContextValuesContainer._keyPrefix.length);
      var configValue = this._configurationService.getValue(configKey);
      var value;
      switch (_typeof(configValue)) {
        case 'number':
        case 'boolean':
        case 'string':
          value = configValue;
          break;
        default:
          if (Array.isArray(configValue)) {
            value = JSON.stringify(configValue);
          } else {
            value = configValue;
          }
      }
      this._values.set(key, value);
      return value;
    }
  }, {
    key: "setValue",
    value: function setValue(key, value) {
      return _get(_getPrototypeOf(ConfigAwareContextValuesContainer.prototype), "setValue", this).call(this, key, value);
    }
  }, {
    key: "removeValue",
    value: function removeValue(key) {
      return _get(_getPrototypeOf(ConfigAwareContextValuesContainer.prototype), "removeValue", this).call(this, key);
    }
  }, {
    key: "collectAllValues",
    value: function collectAllValues() {
      var result = Object.create(null);
      this._values.forEach(function (value, index) {
        return result[index] = value;
      });
      return _objectSpread(_objectSpread({}, result), _get(_getPrototypeOf(ConfigAwareContextValuesContainer.prototype), "collectAllValues", this).call(this));
    }
  }]);
  return ConfigAwareContextValuesContainer;
}(Context);
ConfigAwareContextValuesContainer._keyPrefix = 'config.';
var ContextKey = /*#__PURE__*/function () {
  function ContextKey(service, key, defaultValue) {
    _classCallCheck(this, ContextKey);
    this._service = service;
    this._key = key;
    this._defaultValue = defaultValue;
    this.reset();
  }
  _createClass(ContextKey, [{
    key: "set",
    value: function set(value) {
      this._service.setContext(this._key, value);
    }
  }, {
    key: "reset",
    value: function reset() {
      if (typeof this._defaultValue === 'undefined') {
        this._service.removeContext(this._key);
      } else {
        this._service.setContext(this._key, this._defaultValue);
      }
    }
  }, {
    key: "get",
    value: function get() {
      return this._service.getContextKeyValue(this._key);
    }
  }]);
  return ContextKey;
}();
var SimpleContextKeyChangeEvent = /*#__PURE__*/function () {
  function SimpleContextKeyChangeEvent(key) {
    _classCallCheck(this, SimpleContextKeyChangeEvent);
    this.key = key;
  }
  _createClass(SimpleContextKeyChangeEvent, [{
    key: "affectsSome",
    value: function affectsSome(keys) {
      return keys.has(this.key);
    }
  }]);
  return SimpleContextKeyChangeEvent;
}();
var ArrayContextKeyChangeEvent = /*#__PURE__*/function () {
  function ArrayContextKeyChangeEvent(keys) {
    _classCallCheck(this, ArrayContextKeyChangeEvent);
    this.keys = keys;
  }
  _createClass(ArrayContextKeyChangeEvent, [{
    key: "affectsSome",
    value: function affectsSome(keys) {
      var _iterator2 = _createForOfIteratorHelper(this.keys),
        _step2;
      try {
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
          var key = _step2.value;
          if (keys.has(key)) {
            return true;
          }
        }
      } catch (err) {
        _iterator2.e(err);
      } finally {
        _iterator2.f();
      }
      return false;
    }
  }]);
  return ArrayContextKeyChangeEvent;
}();
var CompositeContextKeyChangeEvent = /*#__PURE__*/function () {
  function CompositeContextKeyChangeEvent(events) {
    _classCallCheck(this, CompositeContextKeyChangeEvent);
    this.events = events;
  }
  _createClass(CompositeContextKeyChangeEvent, [{
    key: "affectsSome",
    value: function affectsSome(keys) {
      var _iterator3 = _createForOfIteratorHelper(this.events),
        _step3;
      try {
        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
          var e = _step3.value;
          if (e.affectsSome(keys)) {
            return true;
          }
        }
      } catch (err) {
        _iterator3.e(err);
      } finally {
        _iterator3.f();
      }
      return false;
    }
  }]);
  return CompositeContextKeyChangeEvent;
}();
var AbstractContextKeyService = exports.AbstractContextKeyService = (_dec2 = (0, _manaSyringe.injectable)(), _dec2(_class2 = /*#__PURE__*/function () {
  function AbstractContextKeyService(myContextId) {
    _classCallCheck(this, AbstractContextKeyService);
    this._onDidChangeContext = new _manaCommon.PauseableEmitter({
      merge: function merge(input) {
        return new CompositeContextKeyChangeEvent(input);
      }
    });
    this.onDidChangeContext = this._onDidChangeContext.event;
    this._isDisposed = false;
    this._myContextId = myContextId;
  }
  _createClass(AbstractContextKeyService, [{
    key: "contextId",
    get: function get() {
      return this._myContextId;
    }
  }, {
    key: "createKey",
    value: function createKey(key, defaultValue) {
      if (this._isDisposed) {
        throw new Error("AbstractContextKeyService has been disposed");
      }
      return new ContextKey(this, key, defaultValue);
    }
  }, {
    key: "bufferChangeEvents",
    value: function bufferChangeEvents(callback) {
      this._onDidChangeContext.pause();
      try {
        callback();
      } finally {
        this._onDidChangeContext.resume();
      }
    }
  }, {
    key: "createScoped",
    value: function createScoped(domNode) {
      if (this._isDisposed) {
        throw new Error("AbstractContextKeyService has been disposed");
      }
      return new ScopedContextKeyService(this, domNode);
    }
  }, {
    key: "createOverlay",
    value: function createOverlay() {
      var overlay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _manaCommon.Iterable.empty();
      if (this._isDisposed) {
        throw new Error("AbstractContextKeyService has been disposed");
      }
      return new OverlayContextKeyService(this, overlay);
    }
  }, {
    key: "contextMatchesRules",
    value: function contextMatchesRules(rules) {
      if (this._isDisposed) {
        throw new Error("AbstractContextKeyService has been disposed");
      }
      var context = this.getContextValuesContainer(this._myContextId);
      if (!rules) {
        return true;
      }
      return rules.evaluate(context);
      // console.group(rules.serialize() + ' -> ' + result);
      // rules.keys().forEach(key => { console.log(key, ctx[key]); });
      // console.groupEnd();
      // return result;
    }
  }, {
    key: "getContextKeyValue",
    value: function getContextKeyValue(key) {
      if (this._isDisposed) {
        return undefined;
      }
      return this.getContextValuesContainer(this._myContextId).getValue(key);
    }
  }, {
    key: "setContext",
    value: function setContext(key, value) {
      if (this._isDisposed) {
        return;
      }
      var myContext = this.getContextValuesContainer(this._myContextId);
      if (!myContext) {
        return;
      }
      if (myContext.setValue(key, value)) {
        this._onDidChangeContext.fire(new SimpleContextKeyChangeEvent(key));
      }
    }
  }, {
    key: "removeContext",
    value: function removeContext(key) {
      if (this._isDisposed) {
        return;
      }
      if (this.getContextValuesContainer(this._myContextId).removeValue(key)) {
        this._onDidChangeContext.fire(new SimpleContextKeyChangeEvent(key));
      }
    }
  }, {
    key: "getContext",
    value: function getContext(target) {
      if (this._isDisposed) {
        return NullContext.INSTANCE;
      }
      return this.getContextValuesContainer(findContextAttr(target));
    }
  }]);
  return AbstractContextKeyService;
}()) || _class2);
var VSContextKeyService = exports.VSContextKeyService = (_dec3 = (0, _manaSyringe.singleton)({
  contrib: _contextkey.IContextKeyService
}), _dec3(_class3 = /*#__PURE__*/function (_AbstractContextKeySe) {
  _inherits(VSContextKeyService, _AbstractContextKeySe);
  var _super3 = _createSuper(VSContextKeyService);
  function VSContextKeyService(configurationService) {
    var _this2;
    _classCallCheck(this, VSContextKeyService);
    _this2 = _super3.call(this, 0);
    _this2._contexts = new Map();
    _this2._toDispose = new _utils.DisposableStore();
    _this2.configurationService = configurationService;
    _this2._lastContextId = 0;
    var myContext = new ConfigAwareContextValuesContainer(_this2._myContextId, configurationService, _this2._onDidChangeContext);
    _this2._contexts.set(_this2._myContextId, myContext);
    _this2._toDispose.add(myContext);

    // Uncomment this to see the contexts continuously logged
    // let lastLoggedValue: string | null = null;
    // setInterval(() => {
    // 	let values = Object.keys(this._contexts).map((key) => this._contexts[key]);
    // 	let logValue = values.map(v => JSON.stringify(v._value, null, '\t')).join('\n');
    // 	if (lastLoggedValue !== logValue) {
    // 		lastLoggedValue = logValue;
    // 		console.log(lastLoggedValue);
    // 	}
    // }, 2000);
    return _this2;
  }
  VSContextKeyService = (0, _manaSyringe.inject)(_configuration.IConfigurationService)(VSContextKeyService, undefined, 0) || VSContextKeyService;
  _createClass(VSContextKeyService, [{
    key: "registerCommands",
    value: function registerCommands(commands) {
      var _this3 = this;
      commands.registerCommand({
        id: _contextkey.SET_CONTEXT_COMMAND_ID
      }, {
        execute: function execute(contextKey, contextValue) {
          _this3.createKey(String(contextKey), contextValue);
        }
      });
      commands.registerCommand({
        id: 'getContextKeyInfo',
        label: 'getContextKeyInfo, A command that returns information about context keys'
      }, {
        execute: function execute() {
          return _toConsumableArray(_contextkey.RawContextKey.all()).sort(function (a, b) {
            return a.key.localeCompare(b.key);
          });
        }
      });
      commands.registerCommand({
        id: '_generateContextKeyInfo'
      }, {
        execute: function execute() {
          var result = [];
          var seen = new Set();
          var _iterator4 = _createForOfIteratorHelper(_contextkey.RawContextKey.all()),
            _step4;
          try {
            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
              var info = _step4.value;
              if (!seen.has(info.key)) {
                seen.add(info.key);
                result.push(info);
              }
            }
          } catch (err) {
            _iterator4.e(err);
          } finally {
            _iterator4.f();
          }
          result.sort(function (a, b) {
            return a.key.localeCompare(b.key);
          });
        }
      });
    }
  }, {
    key: "dispose",
    value: function dispose() {
      this._onDidChangeContext.dispose();
      this._isDisposed = true;
      this._toDispose.dispose();
    }
  }, {
    key: "getContextValuesContainer",
    value: function getContextValuesContainer(contextId) {
      if (this._isDisposed) {
        return NullContext.INSTANCE;
      }
      return this._contexts.get(contextId) || NullContext.INSTANCE;
    }
  }, {
    key: "createChildContext",
    value: function createChildContext() {
      var parentContextId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._myContextId;
      if (this._isDisposed) {
        throw new Error("ContextKeyService has been disposed");
      }
      var id = ++this._lastContextId;
      this._contexts.set(id, new Context(id, this.getContextValuesContainer(parentContextId)));
      return id;
    }
  }, {
    key: "disposeContext",
    value: function disposeContext(contextId) {
      if (!this._isDisposed) {
        this._contexts.delete(contextId);
      }
    }
  }, {
    key: "updateParent",
    value: function updateParent(_parentContextKeyService) {
      throw new Error('Cannot update parent of root ContextKeyService');
    }
  }]);
  return VSContextKeyService;
}(AbstractContextKeyService)) || _class3);
var ScopedContextKeyService = /*#__PURE__*/function (_AbstractContextKeySe2) {
  _inherits(ScopedContextKeyService, _AbstractContextKeySe2);
  var _super4 = _createSuper(ScopedContextKeyService);
  function ScopedContextKeyService(parent, domNode) {
    var _this4;
    _classCallCheck(this, ScopedContextKeyService);
    _this4 = _super4.call(this, parent.createChildContext());
    _this4._parentChangeListener = new _utils.MutableDisposable();
    _this4._parent = parent;
    _this4._updateParentChangeListener();
    _this4._domNode = domNode;
    if (_this4._domNode.hasAttribute(KEYBINDING_CONTEXT_ATTR)) {
      var extraInfo = '';
      if (_this4._domNode.classList) {
        extraInfo = Array.from(_this4._domNode.classList.values()).join(', ');
      }
      console.error("Element already has context attribute".concat(extraInfo ? ": ".concat(extraInfo) : ''));
    }
    _this4._domNode.setAttribute(KEYBINDING_CONTEXT_ATTR, String(_this4._myContextId));
    return _this4;
  }
  _createClass(ScopedContextKeyService, [{
    key: "_updateParentChangeListener",
    value: function _updateParentChangeListener() {
      // Forward parent events to this listener. Parent will change.
      this._parentChangeListener.value = this._parent.onDidChangeContext(this._onDidChangeContext.fire, this._onDidChangeContext);
    }
  }, {
    key: "dispose",
    value: function dispose() {
      if (this._isDisposed) {
        return;
      }
      this._onDidChangeContext.dispose();
      this._parent.disposeContext(this._myContextId);
      this._parentChangeListener.dispose();
      this._domNode.removeAttribute(KEYBINDING_CONTEXT_ATTR);
      this._isDisposed = true;
    }
  }, {
    key: "getContextValuesContainer",
    value: function getContextValuesContainer(contextId) {
      if (this._isDisposed) {
        return NullContext.INSTANCE;
      }
      return this._parent.getContextValuesContainer(contextId);
    }
  }, {
    key: "createChildContext",
    value: function createChildContext() {
      var parentContextId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this._myContextId;
      if (this._isDisposed) {
        throw new Error("ScopedContextKeyService has been disposed");
      }
      return this._parent.createChildContext(parentContextId);
    }
  }, {
    key: "disposeContext",
    value: function disposeContext(contextId) {
      if (this._isDisposed) {
        return;
      }
      this._parent.disposeContext(contextId);
    }
  }, {
    key: "updateParent",
    value: function updateParent(parentContextKeyService) {
      var thisContainer = this._parent.getContextValuesContainer(this._myContextId);
      var oldAllValues = thisContainer.collectAllValues();
      this._parent = parentContextKeyService;
      this._updateParentChangeListener();
      var newParentContainer = this._parent.getContextValuesContainer(this._parent.contextId);
      thisContainer.updateParent(newParentContainer);
      var newAllValues = thisContainer.collectAllValues();
      var allValuesDiff = _objectSpread(_objectSpread({}, _manaCommon.objects.distinct(oldAllValues, newAllValues)), _manaCommon.objects.distinct(newAllValues, oldAllValues));
      var changedKeys = Object.keys(allValuesDiff);
      this._onDidChangeContext.fire(new ArrayContextKeyChangeEvent(changedKeys));
    }
  }]);
  return ScopedContextKeyService;
}(AbstractContextKeyService);
var OverlayContext = /*#__PURE__*/function () {
  function OverlayContext(parent, overlay) {
    _classCallCheck(this, OverlayContext);
    this.parent = parent;
    this.overlay = overlay;
  }
  _createClass(OverlayContext, [{
    key: "getValue",
    value: function getValue(key) {
      return this.overlay.has(key) ? this.overlay.get(key) : this.parent.getValue(key);
    }
  }]);
  return OverlayContext;
}();
var OverlayContextKeyService = exports.OverlayContextKeyService = /*#__PURE__*/function () {
  function OverlayContextKeyService(parent, overlay) {
    _classCallCheck(this, OverlayContextKeyService);
    this.parent = parent;
    this.overlay = new Map(overlay);
  }
  _createClass(OverlayContextKeyService, [{
    key: "contextId",
    get: function get() {
      return this.parent.contextId;
    }
  }, {
    key: "onDidChangeContext",
    get: function get() {
      return this.parent.onDidChangeContext;
    }
  }, {
    key: "bufferChangeEvents",
    value: function bufferChangeEvents(callback) {
      this.parent.bufferChangeEvents(callback);
    }
  }, {
    key: "createKey",
    value: function createKey() {
      throw new Error('Not supported.');
    }
  }, {
    key: "getContext",
    value: function getContext(target) {
      return new OverlayContext(this.parent.getContext(target), this.overlay);
    }
  }, {
    key: "getContextValuesContainer",
    value: function getContextValuesContainer(contextId) {
      var parentContext = this.parent.getContextValuesContainer(contextId);
      return new OverlayContext(parentContext, this.overlay);
    }
  }, {
    key: "contextMatchesRules",
    value: function contextMatchesRules(rules) {
      var context = this.getContextValuesContainer(this.contextId);
      if (!rules) {
        return true;
      }
      return rules.evaluate(context);
      // return result;
    }
  }, {
    key: "getContextKeyValue",
    value: function getContextKeyValue(key) {
      return this.overlay.has(key) ? this.overlay.get(key) : this.parent.getContextKeyValue(key);
    }
  }, {
    key: "createScoped",
    value: function createScoped() {
      throw new Error('Not supported.');
    }
  }, {
    key: "createOverlay",
    value: function createOverlay() {
      var overlay = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _manaCommon.Iterable.empty();
      return new OverlayContextKeyService(this, overlay);
    }
  }, {
    key: "updateParent",
    value: function updateParent() {
      throw new Error('Not supported.');
    }
  }, {
    key: "dispose",
    value: function dispose() {
      // noop
    }
  }]);
  return OverlayContextKeyService;
}();
function findContextAttr(domNode) {
  while (domNode) {
    if (domNode.hasAttribute(KEYBINDING_CONTEXT_ATTR)) {
      var attr = domNode.getAttribute(KEYBINDING_CONTEXT_ATTR);
      if (attr) {
        return parseInt(attr, 10);
      }
      return NaN;
    }
    domNode = domNode.parentElement;
  }
  return 0;
}