custom-electron-titlebar 3.2.6 → 3.2.10

package/lib/vs/base/common/scrollable.js

@@ -1,397 +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.SmoothScrollingOperation = exports.SmoothScrollingUpdate = exports.Scrollable = exports.ScrollState = void 0;
-
-const event_1 = require("./event");
-
-const lifecycle_1 = require("./lifecycle");
-
-class ScrollState {
-  constructor(width, scrollWidth, scrollLeft, height, scrollHeight, scrollTop) {
-    width = width | 0;
-    scrollWidth = scrollWidth | 0;
-    scrollLeft = scrollLeft | 0;
-    height = height | 0;
-    scrollHeight = scrollHeight | 0;
-    scrollTop = scrollTop | 0;
-    this.rawScrollLeft = scrollLeft; // before validation
-
-    this.rawScrollTop = scrollTop; // before validation
-
-    if (width < 0) {
-      width = 0;
-    }
-
-    if (scrollLeft + width > scrollWidth) {
-      scrollLeft = scrollWidth - width;
-    }
-
-    if (scrollLeft < 0) {
-      scrollLeft = 0;
-    }
-
-    if (height < 0) {
-      height = 0;
-    }
-
-    if (scrollTop + height > scrollHeight) {
-      scrollTop = scrollHeight - height;
-    }
-
-    if (scrollTop < 0) {
-      scrollTop = 0;
-    }
-
-    this.width = width;
-    this.scrollWidth = scrollWidth;
-    this.scrollLeft = scrollLeft;
-    this.height = height;
-    this.scrollHeight = scrollHeight;
-    this.scrollTop = scrollTop;
-  }
-
-  equals(other) {
-    return this.rawScrollLeft === other.rawScrollLeft && this.rawScrollTop === other.rawScrollTop && this.width === other.width && this.scrollWidth === other.scrollWidth && this.scrollLeft === other.scrollLeft && this.height === other.height && this.scrollHeight === other.scrollHeight && this.scrollTop === other.scrollTop;
-  }
-
-  withScrollDimensions(update, useRawScrollPositions) {
-    return new ScrollState(typeof update.width !== 'undefined' ? update.width : this.width, typeof update.scrollWidth !== 'undefined' ? update.scrollWidth : this.scrollWidth, useRawScrollPositions ? this.rawScrollLeft : this.scrollLeft, typeof update.height !== 'undefined' ? update.height : this.height, typeof update.scrollHeight !== 'undefined' ? update.scrollHeight : this.scrollHeight, useRawScrollPositions ? this.rawScrollTop : this.scrollTop);
-  }
-
-  withScrollPosition(update) {
-    return new ScrollState(this.width, this.scrollWidth, typeof update.scrollLeft !== 'undefined' ? update.scrollLeft : this.rawScrollLeft, this.height, this.scrollHeight, typeof update.scrollTop !== 'undefined' ? update.scrollTop : this.rawScrollTop);
-  }
-
-  createScrollEvent(previous) {
-    const widthChanged = this.width !== previous.width;
-    const scrollWidthChanged = this.scrollWidth !== previous.scrollWidth;
-    const scrollLeftChanged = this.scrollLeft !== previous.scrollLeft;
-    const heightChanged = this.height !== previous.height;
-    const scrollHeightChanged = this.scrollHeight !== previous.scrollHeight;
-    const scrollTopChanged = this.scrollTop !== previous.scrollTop;
-    return {
-      oldWidth: previous.width,
-      oldScrollWidth: previous.scrollWidth,
-      oldScrollLeft: previous.scrollLeft,
-      width: this.width,
-      scrollWidth: this.scrollWidth,
-      scrollLeft: this.scrollLeft,
-      oldHeight: previous.height,
-      oldScrollHeight: previous.scrollHeight,
-      oldScrollTop: previous.scrollTop,
-      height: this.height,
-      scrollHeight: this.scrollHeight,
-      scrollTop: this.scrollTop,
-      widthChanged: widthChanged,
-      scrollWidthChanged: scrollWidthChanged,
-      scrollLeftChanged: scrollLeftChanged,
-      heightChanged: heightChanged,
-      scrollHeightChanged: scrollHeightChanged,
-      scrollTopChanged: scrollTopChanged
-    };
-  }
-
-}
-
-exports.ScrollState = ScrollState;
-
-class Scrollable extends lifecycle_1.Disposable {
-  constructor(smoothScrollDuration, scheduleAtNextAnimationFrame) {
-    super();
-    this._onScroll = this._register(new event_1.Emitter());
-    this.onScroll = this._onScroll.event;
-    this._smoothScrollDuration = smoothScrollDuration;
-    this._scheduleAtNextAnimationFrame = scheduleAtNextAnimationFrame;
-    this._state = new ScrollState(0, 0, 0, 0, 0, 0);
-    this._smoothScrolling = null;
-  }
-
-  dispose() {
-    if (this._smoothScrolling) {
-      this._smoothScrolling.dispose();
-
-      this._smoothScrolling = null;
-    }
-
-    super.dispose();
-  }
-
-  setSmoothScrollDuration(smoothScrollDuration) {
-    this._smoothScrollDuration = smoothScrollDuration;
-  }
-
-  validateScrollPosition(scrollPosition) {
-    return this._state.withScrollPosition(scrollPosition);
-  }
-
-  getScrollDimensions() {
-    return this._state;
-  }
-
-  setScrollDimensions(dimensions, useRawScrollPositions) {
-    const newState = this._state.withScrollDimensions(dimensions, useRawScrollPositions);
-
-    this._setState(newState); // Validate outstanding animated scroll position target
-
-
-    if (this._smoothScrolling) {
-      this._smoothScrolling.acceptScrollDimensions(this._state);
-    }
-  }
-  /**
-   * Returns the final scroll position that the instance will have once the smooth scroll animation concludes.
-   * If no scroll animation is occurring, it will return the current scroll position instead.
-   */
-
-
-  getFutureScrollPosition() {
-    if (this._smoothScrolling) {
-      return this._smoothScrolling.to;
-    }
-
-    return this._state;
-  }
-  /**
-   * Returns the current scroll position.
-   * Note: This result might be an intermediate scroll position, as there might be an ongoing smooth scroll animation.
-   */
-
-
-  getCurrentScrollPosition() {
-    return this._state;
-  }
-
-  setScrollPositionNow(update) {
-    // no smooth scrolling requested
-    const newState = this._state.withScrollPosition(update); // Terminate any outstanding smooth scrolling
-
-
-    if (this._smoothScrolling) {
-      this._smoothScrolling.dispose();
-
-      this._smoothScrolling = null;
-    }
-
-    this._setState(newState);
-  }
-
-  setScrollPositionSmooth(update) {
-    if (this._smoothScrollDuration === 0) {
-      // Smooth scrolling not supported.
-      return this.setScrollPositionNow(update);
-    }
-
-    if (this._smoothScrolling) {
-      // Combine our pending scrollLeft/scrollTop with incoming scrollLeft/scrollTop
-      update = {
-        scrollLeft: typeof update.scrollLeft === 'undefined' ? this._smoothScrolling.to.scrollLeft : update.scrollLeft,
-        scrollTop: typeof update.scrollTop === 'undefined' ? this._smoothScrolling.to.scrollTop : update.scrollTop
-      }; // Validate `update`
-
-      const validTarget = this._state.withScrollPosition(update);
-
-      if (this._smoothScrolling.to.scrollLeft === validTarget.scrollLeft && this._smoothScrolling.to.scrollTop === validTarget.scrollTop) {
-        // No need to interrupt or extend the current animation since we're going to the same place
-        return;
-      }
-
-      const newSmoothScrolling = this._smoothScrolling.combine(this._state, validTarget, this._smoothScrollDuration);
-
-      this._smoothScrolling.dispose();
-
-      this._smoothScrolling = newSmoothScrolling;
-    } else {
-      // Validate `update`
-      const validTarget = this._state.withScrollPosition(update);
-
-      this._smoothScrolling = SmoothScrollingOperation.start(this._state, validTarget, this._smoothScrollDuration);
-    } // Begin smooth scrolling animation
-
-
-    this._smoothScrolling.animationFrameDisposable = this._scheduleAtNextAnimationFrame(() => {
-      if (!this._smoothScrolling) {
-        return;
-      }
-
-      this._smoothScrolling.animationFrameDisposable = null;
-
-      this._performSmoothScrolling();
-    });
-  }
-
-  _performSmoothScrolling() {
-    if (!this._smoothScrolling) {
-      return;
-    }
-
-    const update = this._smoothScrolling.tick();
-
-    const newState = this._state.withScrollPosition(update);
-
-    this._setState(newState);
-
-    if (!this._smoothScrolling) {
-      // Looks like someone canceled the smooth scrolling
-      // from the scroll event handler
-      return;
-    }
-
-    if (update.isDone) {
-      this._smoothScrolling.dispose();
-
-      this._smoothScrolling = null;
-      return;
-    } // Continue smooth scrolling animation
-
-
-    this._smoothScrolling.animationFrameDisposable = this._scheduleAtNextAnimationFrame(() => {
-      if (!this._smoothScrolling) {
-        return;
-      }
-
-      this._smoothScrolling.animationFrameDisposable = null;
-
-      this._performSmoothScrolling();
-    });
-  }
-
-  _setState(newState) {
-    const oldState = this._state;
-
-    if (oldState.equals(newState)) {
-      // no change
-      return;
-    }
-
-    this._state = newState;
-
-    this._onScroll.fire(this._state.createScrollEvent(oldState));
-  }
-
-}
-
-exports.Scrollable = Scrollable;
-
-class SmoothScrollingUpdate {
-  constructor(scrollLeft, scrollTop, isDone) {
-    this.scrollLeft = scrollLeft;
-    this.scrollTop = scrollTop;
-    this.isDone = isDone;
-  }
-
-}
-
-exports.SmoothScrollingUpdate = SmoothScrollingUpdate;
-
-function createEaseOutCubic(from, to) {
-  const delta = to - from;
-  return function (completion) {
-    return from + delta * easeOutCubic(completion);
-  };
-}
-
-function createComposed(a, b, cut) {
-  return function (completion) {
-    if (completion < cut) {
-      return a(completion / cut);
-    }
-
-    return b((completion - cut) / (1 - cut));
-  };
-}
-
-class SmoothScrollingOperation {
-  constructor(from, to, startTime, duration) {
-    this.from = from;
-    this.to = to;
-    this.duration = duration;
-    this._startTime = startTime;
-    this.animationFrameDisposable = null;
-
-    this._initAnimations();
-  }
-
-  _initAnimations() {
-    this.scrollLeft = this._initAnimation(this.from.scrollLeft, this.to.scrollLeft, this.to.width);
-    this.scrollTop = this._initAnimation(this.from.scrollTop, this.to.scrollTop, this.to.height);
-  }
-
-  _initAnimation(from, to, viewportSize) {
-    const delta = Math.abs(from - to);
-
-    if (delta > 2.5 * viewportSize) {
-      let stop1, stop2;
-
-      if (from < to) {
-        // scroll to 75% of the viewportSize
-        stop1 = from + 0.75 * viewportSize;
-        stop2 = to - 0.75 * viewportSize;
-      } else {
-        stop1 = from - 0.75 * viewportSize;
-        stop2 = to + 0.75 * viewportSize;
-      }
-
-      return createComposed(createEaseOutCubic(from, stop1), createEaseOutCubic(stop2, to), 0.33);
-    }
-
-    return createEaseOutCubic(from, to);
-  }
-
-  dispose() {
-    if (this.animationFrameDisposable !== null) {
-      this.animationFrameDisposable.dispose();
-      this.animationFrameDisposable = null;
-    }
-  }
-
-  acceptScrollDimensions(state) {
-    this.to = state.withScrollPosition(this.to);
-
-    this._initAnimations();
-  }
-
-  tick() {
-    return this._tick(Date.now());
-  }
-
-  _tick(now) {
-    const completion = (now - this._startTime) / this.duration;
-
-    if (completion < 1) {
-      const newScrollLeft = this.scrollLeft(completion);
-      const newScrollTop = this.scrollTop(completion);
-      return new SmoothScrollingUpdate(newScrollLeft, newScrollTop, false);
-    }
-
-    return new SmoothScrollingUpdate(this.to.scrollLeft, this.to.scrollTop, true);
-  }
-
-  combine(from, to, duration) {
-    return SmoothScrollingOperation.start(from, to, duration);
-  }
-
-  static start(from, to, duration) {
-    // +10 / -10 : pretend the animation already started for a quicker response to a scroll request
-    duration = duration + 10;
-    const startTime = Date.now() - 10;
-    return new SmoothScrollingOperation(from, to, startTime, duration);
-  }
-
-}
-
-exports.SmoothScrollingOperation = SmoothScrollingOperation;
-
-function easeInCubic(t) {
-  return Math.pow(t, 3);
-}
-
-function easeOutCubic(t) {
-  return 1 - easeInCubic(1 - t);
-}

package/lib/vs/base/common/search.js

@@ -1,55 +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.buildReplaceStringWithCasePreserved = void 0;
-
-const strings = require("./strings");
-
-function buildReplaceStringWithCasePreserved(matches, pattern) {
-  if (matches && matches[0] !== '') {
-    const containsHyphens = validateSpecificSpecialCharacter(matches, pattern, '-');
-    const containsUnderscores = validateSpecificSpecialCharacter(matches, pattern, '_');
-
-    if (containsHyphens && !containsUnderscores) {
-      return buildReplaceStringForSpecificSpecialCharacter(matches, pattern, '-');
-    } else if (!containsHyphens && containsUnderscores) {
-      return buildReplaceStringForSpecificSpecialCharacter(matches, pattern, '_');
-    }
-
-    if (matches[0].toUpperCase() === matches[0]) {
-      return pattern.toUpperCase();
-    } else if (matches[0].toLowerCase() === matches[0]) {
-      return pattern.toLowerCase();
-    } else if (strings.containsUppercaseCharacter(matches[0][0]) && pattern.length > 0) {
-      return pattern[0].toUpperCase() + pattern.substr(1);
-    } else {
-      // we don't understand its pattern yet.
-      return pattern;
-    }
-  } else {
-    return pattern;
-  }
-}
-
-exports.buildReplaceStringWithCasePreserved = buildReplaceStringWithCasePreserved;
-
-function validateSpecificSpecialCharacter(matches, pattern, specialCharacter) {
-  const doesContainSpecialCharacter = matches[0].indexOf(specialCharacter) !== -1 && pattern.indexOf(specialCharacter) !== -1;
-  return doesContainSpecialCharacter && matches[0].split(specialCharacter).length === pattern.split(specialCharacter).length;
-}
-
-function buildReplaceStringForSpecificSpecialCharacter(matches, pattern, specialCharacter) {
-  const splitPatternAtSpecialCharacter = pattern.split(specialCharacter);
-  const splitMatchAtSpecialCharacter = matches[0].split(specialCharacter);
-  let replaceString = '';
-  splitPatternAtSpecialCharacter.forEach((splitValue, index) => {
-    replaceString += buildReplaceStringWithCasePreserved([splitMatchAtSpecialCharacter[index]], splitValue) + specialCharacter;
-  });
-  return replaceString.slice(0, -1);
-}

package/lib/vs/base/common/sequence.js

@@ -1,64 +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.SimpleSequence = exports.Sequence = void 0;
-
-const event_1 = require("./event");
-
-class Sequence {
-  constructor() {
-    this.elements = [];
-    this._onDidSplice = new event_1.Emitter();
-    this.onDidSplice = this._onDidSplice.event;
-  }
-
-  splice(start, deleteCount, toInsert = []) {
-    this.elements.splice(start, deleteCount, ...toInsert);
-
-    this._onDidSplice.fire({
-      start,
-      deleteCount,
-      toInsert
-    });
-  }
-
-}
-
-exports.Sequence = Sequence;
-
-class SimpleSequence {
-  constructor(elements, onDidAdd, onDidRemove) {
-    this._elements = [...elements];
-    this.onDidSplice = event_1.Event.any(event_1.Event.map(onDidAdd, e => ({
-      start: this.elements.length,
-      deleteCount: 0,
-      toInsert: [e]
-    })), event_1.Event.map(event_1.Event.filter(event_1.Event.map(onDidRemove, e => this.elements.indexOf(e)), i => i > -1), i => ({
-      start: i,
-      deleteCount: 1,
-      toInsert: []
-    })));
-    this.disposable = this.onDidSplice(({
-      start,
-      deleteCount,
-      toInsert
-    }) => this._elements.splice(start, deleteCount, ...toInsert));
-  }
-
-  get elements() {
-    return this._elements;
-  }
-
-  dispose() {
-    this.disposable.dispose();
-  }
-
-}
-
-exports.SimpleSequence = SimpleSequence;

package/lib/vs/base/common/severity.js

@@ -1,55 +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
-});
-
-const strings = require("./strings");
-
-var Severity;
-
-(function (Severity) {
-  Severity[Severity["Ignore"] = 0] = "Ignore";
-  Severity[Severity["Info"] = 1] = "Info";
-  Severity[Severity["Warning"] = 2] = "Warning";
-  Severity[Severity["Error"] = 3] = "Error";
-})(Severity || (Severity = {}));
-
-(function (Severity) {
-  const _error = 'error';
-  const _warning = 'warning';
-  const _warn = 'warn';
-  const _info = 'info';
-  /**
-   * Parses 'error', 'warning', 'warn', 'info' in call casings
-   * and falls back to ignore.
-   */
-
-  function fromValue(value) {
-    if (!value) {
-      return Severity.Ignore;
-    }
-
-    if (strings.equalsIgnoreCase(_error, value)) {
-      return Severity.Error;
-    }
-
-    if (strings.equalsIgnoreCase(_warning, value) || strings.equalsIgnoreCase(_warn, value)) {
-      return Severity.Warning;
-    }
-
-    if (strings.equalsIgnoreCase(_info, value)) {
-      return Severity.Info;
-    }
-
-    return Severity.Ignore;
-  }
-
-  Severity.fromValue = fromValue;
-})(Severity || (Severity = {}));
-
-exports.default = Severity;