custom-electron-titlebar 3.2.6 → 3.2.10

package/lib/vs/platform/instantiation/common/instantiationService.js

@@ -1,361 +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.InstantiationService = void 0;
-
-const errors_1 = require("../../../base/common/errors");
-
-const graph_1 = require("./graph");
-
-const descriptors_1 = require("./descriptors");
-
-const instantiation_1 = require("./instantiation");
-
-const serviceCollection_1 = require("./serviceCollection");
-
-const async_1 = require("../../../base/common/async"); // TRACING
-
-
-const _enableTracing = false;
-
-class CyclicDependencyError extends Error {
-  constructor(graph) {
-    super('cyclic dependency between services');
-    this.message = graph.toString();
-  }
-
-}
-
-class InstantiationService {
-  constructor(services = new serviceCollection_1.ServiceCollection(), strict = false, parent) {
-    this._services = services;
-    this._strict = strict;
-    this._parent = parent;
-
-    this._services.set(instantiation_1.IInstantiationService, this);
-  }
-
-  createChild(services) {
-    return new InstantiationService(services, this._strict, this);
-  }
-
-  invokeFunction(fn, ...args) {
-    let _trace = Trace.traceInvocation(fn);
-
-    let _done = false;
-
-    try {
-      const accessor = {
-        get: (id, isOptional) => {
-          if (_done) {
-            throw errors_1.illegalState('service accessor is only valid during the invocation of its target method');
-          }
-
-          const result = this._getOrCreateServiceInstance(id, _trace);
-
-          if (!result && isOptional !== instantiation_1.optional) {
-            throw new Error(`[invokeFunction] unknown service '${id}'`);
-          }
-
-          return result;
-        }
-      };
-      return fn(accessor, ...args);
-    } finally {
-      _done = true;
-
-      _trace.stop();
-    }
-  }
-
-  createInstance(ctorOrDescriptor, ...rest) {
-    let _trace;
-
-    let result;
-
-    if (ctorOrDescriptor instanceof descriptors_1.SyncDescriptor) {
-      _trace = Trace.traceCreation(ctorOrDescriptor.ctor);
-      result = this._createInstance(ctorOrDescriptor.ctor, ctorOrDescriptor.staticArguments.concat(rest), _trace);
-    } else {
-      _trace = Trace.traceCreation(ctorOrDescriptor);
-      result = this._createInstance(ctorOrDescriptor, rest, _trace);
-    }
-
-    _trace.stop();
-
-    return result;
-  }
-
-  _createInstance(ctor, args = [], _trace) {
-    // arguments defined by service decorators
-    let serviceDependencies = instantiation_1._util.getServiceDependencies(ctor).sort((a, b) => a.index - b.index);
-
-    let serviceArgs = [];
-
-    for (const dependency of serviceDependencies) {
-      let service = this._getOrCreateServiceInstance(dependency.id, _trace);
-
-      if (!service && this._strict && !dependency.optional) {
-        throw new Error(`[createInstance] ${ctor.name} depends on UNKNOWN service ${dependency.id}.`);
-      }
-
-      serviceArgs.push(service);
-    }
-
-    let firstServiceArgPos = serviceDependencies.length > 0 ? serviceDependencies[0].index : args.length; // check for argument mismatches, adjust static args if needed
-
-    if (args.length !== firstServiceArgPos) {
-      console.warn(`[createInstance] First service dependency of ${ctor.name} at position ${firstServiceArgPos + 1} conflicts with ${args.length} static arguments`);
-      let delta = firstServiceArgPos - args.length;
-
-      if (delta > 0) {
-        args = args.concat(new Array(delta));
-      } else {
-        args = args.slice(0, firstServiceArgPos);
-      }
-    } // now create the instance
-
-
-    return new ctor(...[...args, ...serviceArgs]);
-  }
-
-  _setServiceInstance(id, instance) {
-    if (this._services.get(id) instanceof descriptors_1.SyncDescriptor) {
-      this._services.set(id, instance);
-    } else if (this._parent) {
-      this._parent._setServiceInstance(id, instance);
-    } else {
-      throw new Error('illegalState - setting UNKNOWN service instance');
-    }
-  }
-
-  _getServiceInstanceOrDescriptor(id) {
-    let instanceOrDesc = this._services.get(id);
-
-    if (!instanceOrDesc && this._parent) {
-      return this._parent._getServiceInstanceOrDescriptor(id);
-    } else {
-      return instanceOrDesc;
-    }
-  }
-
-  _getOrCreateServiceInstance(id, _trace) {
-    let thing = this._getServiceInstanceOrDescriptor(id);
-
-    if (thing instanceof descriptors_1.SyncDescriptor) {
-      return this._createAndCacheServiceInstance(id, thing, _trace.branch(id, true));
-    } else {
-      _trace.branch(id, false);
-
-      return thing;
-    }
-  }
-
-  _createAndCacheServiceInstance(id, desc, _trace) {
-    const graph = new graph_1.Graph(data => data.id.toString());
-    let cycleCount = 0;
-    const stack = [{
-      id,
-      desc,
-      _trace
-    }];
-
-    while (stack.length) {
-      const item = stack.pop();
-      graph.lookupOrInsertNode(item); // a weak but working heuristic for cycle checks
-
-      if (cycleCount++ > 1000) {
-        throw new CyclicDependencyError(graph);
-      } // check all dependencies for existence and if they need to be created first
-
-
-      for (let dependency of instantiation_1._util.getServiceDependencies(item.desc.ctor)) {
-        let instanceOrDesc = this._getServiceInstanceOrDescriptor(dependency.id);
-
-        if (!instanceOrDesc && !dependency.optional) {
-          console.warn(`[createInstance] ${id} depends on ${dependency.id} which is NOT registered.`);
-        }
-
-        if (instanceOrDesc instanceof descriptors_1.SyncDescriptor) {
-          const d = {
-            id: dependency.id,
-            desc: instanceOrDesc,
-            _trace: item._trace.branch(dependency.id, true)
-          };
-          graph.insertEdge(item, d);
-          stack.push(d);
-        }
-      }
-    }
-
-    while (true) {
-      const roots = graph.roots(); // if there is no more roots but still
-      // nodes in the graph we have a cycle
-
-      if (roots.length === 0) {
-        if (!graph.isEmpty()) {
-          throw new CyclicDependencyError(graph);
-        }
-
-        break;
-      }
-
-      for (const {
-        data
-      } of roots) {
-        // Repeat the check for this still being a service sync descriptor. That's because
-        // instantiating a dependency might have side-effect and recursively trigger instantiation
-        // so that some dependencies are now fullfilled already.
-        const instanceOrDesc = this._getServiceInstanceOrDescriptor(data.id);
-
-        if (instanceOrDesc instanceof descriptors_1.SyncDescriptor) {
-          // create instance and overwrite the service collections
-          const instance = this._createServiceInstanceWithOwner(data.id, data.desc.ctor, data.desc.staticArguments, data.desc.supportsDelayedInstantiation, data._trace);
-
-          this._setServiceInstance(data.id, instance);
-        }
-
-        graph.removeNode(data);
-      }
-    }
-
-    return this._getServiceInstanceOrDescriptor(id);
-  }
-
-  _createServiceInstanceWithOwner(id, ctor, args = [], supportsDelayedInstantiation, _trace) {
-    if (this._services.get(id) instanceof descriptors_1.SyncDescriptor) {
-      return this._createServiceInstance(ctor, args, supportsDelayedInstantiation, _trace);
-    } else if (this._parent) {
-      return this._parent._createServiceInstanceWithOwner(id, ctor, args, supportsDelayedInstantiation, _trace);
-    } else {
-      throw new Error(`illegalState - creating UNKNOWN service instance ${ctor.name}`);
-    }
-  }
-
-  _createServiceInstance(ctor, args = [], _supportsDelayedInstantiation, _trace) {
-    if (!_supportsDelayedInstantiation) {
-      // eager instantiation
-      return this._createInstance(ctor, args, _trace);
-    } else {
-      // Return a proxy object that's backed by an idle value. That
-      // strategy is to instantiate services in our idle time or when actually
-      // needed but not when injected into a consumer
-      const idle = new async_1.IdleValue(() => this._createInstance(ctor, args, _trace));
-      return new Proxy(Object.create(null), {
-        get(target, key) {
-          if (key in target) {
-            return target[key];
-          }
-
-          let obj = idle.value;
-          let prop = obj[key];
-
-          if (typeof prop !== 'function') {
-            return prop;
-          }
-
-          prop = prop.bind(obj);
-          target[key] = prop;
-          return prop;
-        },
-
-        set(_target, p, value) {
-          idle.value[p] = value;
-          return true;
-        }
-
-      });
-    }
-  }
-
-}
-
-exports.InstantiationService = InstantiationService;
-
-class Trace {
-  constructor(type, name) {
-    this.type = type;
-    this.name = name;
-    this._start = Date.now();
-    this._dep = [];
-  }
-
-  static traceInvocation(ctor) {
-    return !_enableTracing ? Trace._None : new Trace(1
-    /* Invocation */
-    , ctor.name || ctor.toString().substring(0, 42).replace(/\n/g, ''));
-  }
-
-  static traceCreation(ctor) {
-    return !_enableTracing ? Trace._None : new Trace(0
-    /* Creation */
-    , ctor.name);
-  }
-
-  branch(id, first) {
-    let child = new Trace(2
-    /* Branch */
-    , id.toString());
-
-    this._dep.push([id, first, child]);
-
-    return child;
-  }
-
-  stop() {
-    let dur = Date.now() - this._start;
-
-    Trace._totals += dur;
-    let causedCreation = false;
-
-    function printChild(n, trace) {
-      let res = [];
-      let prefix = new Array(n + 1).join('\t');
-
-      for (const [id, first, child] of trace._dep) {
-        if (first && child) {
-          causedCreation = true;
-          res.push(`${prefix}CREATES -> ${id}`);
-          let nested = printChild(n + 1, child);
-
-          if (nested) {
-            res.push(nested);
-          }
-        } else {
-          res.push(`${prefix}uses -> ${id}`);
-        }
-      }
-
-      return res.join('\n');
-    }
-
-    let lines = [`${this.type === 0
-    /* Creation */
-    ? 'CREATE' : 'CALL'} ${this.name}`, `${printChild(1, this)}`, `DONE, took ${dur.toFixed(2)}ms (grand total ${Trace._totals.toFixed(2)}ms)`];
-
-    if (dur > 2 || causedCreation) {
-      console.log(lines.join('\n'));
-    }
-  }
-
-}
-
-Trace._None = new class extends Trace {
-  constructor() {
-    super(-1, null);
-  }
-
-  stop() {}
-
-  branch() {
-    return this;
-  }
-
-}();
-Trace._totals = 0; //#endregion

package/lib/vs/platform/instantiation/common/serviceCollection.js

@@ -1,39 +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.ServiceCollection = void 0;
-
-class ServiceCollection {
-  constructor(...entries) {
-    this._entries = new Map();
-
-    for (let [id, service] of entries) {
-      this.set(id, service);
-    }
-  }
-
-  set(id, instanceOrDescriptor) {
-    const result = this._entries.get(id);
-
-    this._entries.set(id, instanceOrDescriptor);
-
-    return result;
-  }
-
-  has(id) {
-    return this._entries.has(id);
-  }
-
-  get(id) {
-    return this._entries.get(id);
-  }
-
-}
-
-exports.ServiceCollection = ServiceCollection;

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

@@ -1,73 +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.BaseResolvedKeybinding = void 0;
-
-const errors_1 = require("../../../base/common/errors");
-
-const keybindingLabels_1 = require("../../../base/common/keybindingLabels");
-
-const keyCodes_1 = require("../../../base/common/keyCodes");
-
-class BaseResolvedKeybinding extends keyCodes_1.ResolvedKeybinding {
-  constructor(os, parts) {
-    super();
-
-    if (parts.length === 0) {
-      throw errors_1.illegalArgument(`parts`);
-    }
-
-    this._os = os;
-    this._parts = parts;
-  }
-
-  getLabel() {
-    return keybindingLabels_1.UILabelProvider.toLabel(this._os, this._parts, keybinding => this._getLabel(keybinding));
-  }
-
-  getAriaLabel() {
-    return keybindingLabels_1.AriaLabelProvider.toLabel(this._os, this._parts, keybinding => this._getAriaLabel(keybinding));
-  }
-
-  getElectronAccelerator() {
-    if (this._parts.length > 1) {
-      // Electron cannot handle chords
-      return null;
-    }
-
-    return keybindingLabels_1.ElectronAcceleratorLabelProvider.toLabel(this._os, this._parts, keybinding => this._getElectronAccelerator(keybinding));
-  }
-
-  getUserSettingsLabel() {
-    return keybindingLabels_1.UserSettingsLabelProvider.toLabel(this._os, this._parts, keybinding => this._getUserSettingsLabel(keybinding));
-  }
-
-  isWYSIWYG() {
-    return this._parts.every(keybinding => this._isWYSIWYG(keybinding));
-  }
-
-  isChord() {
-    return this._parts.length > 1;
-  }
-
-  getParts() {
-    return this._parts.map(keybinding => this._getPart(keybinding));
-  }
-
-  _getPart(keybinding) {
-    return new keyCodes_1.ResolvedKeybindingPart(keybinding.ctrlKey, keybinding.shiftKey, keybinding.altKey, keybinding.metaKey, this._getLabel(keybinding), this._getAriaLabel(keybinding));
-  }
-
-  getDispatchParts() {
-    return this._parts.map(keybinding => this._getDispatchPart(keybinding));
-  }
-
-}
-
-exports.BaseResolvedKeybinding = BaseResolvedKeybinding;

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

@@ -1,14 +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.IKeybindingService = void 0;
-
-const instantiation_1 = require("../../instantiation/common/instantiation");
-
-exports.IKeybindingService = instantiation_1.createDecorator('keybindingService');