custom-electron-titlebar 3.2.6 → 3.2.10

package/lib/vs/base/browser/ui/list/rangeMap.js

@@ -1,223 +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.RangeMap = exports.consolidate = exports.shift = exports.groupIntersect = void 0;
-
-const range_1 = require("../../../common/range");
-/**
- * Returns the intersection between a ranged group and a range.
- * Returns `[]` if the intersection is empty.
- */
-
-
-function groupIntersect(range, groups) {
-  const result = [];
-
-  for (let r of groups) {
-    if (range.start >= r.range.end) {
-      continue;
-    }
-
-    if (range.end < r.range.start) {
-      break;
-    }
-
-    const intersection = range_1.Range.intersect(range, r.range);
-
-    if (range_1.Range.isEmpty(intersection)) {
-      continue;
-    }
-
-    result.push({
-      range: intersection,
-      size: r.size
-    });
-  }
-
-  return result;
-}
-
-exports.groupIntersect = groupIntersect;
-/**
- * Shifts a range by that `much`.
- */
-
-function shift({
-  start,
-  end
-}, much) {
-  return {
-    start: start + much,
-    end: end + much
-  };
-}
-
-exports.shift = shift;
-/**
- * Consolidates a collection of ranged groups.
- *
- * Consolidation is the process of merging consecutive ranged groups
- * that share the same `size`.
- */
-
-function consolidate(groups) {
-  const result = [];
-  let previousGroup = null;
-
-  for (let group of groups) {
-    const start = group.range.start;
-    const end = group.range.end;
-    const size = group.size;
-
-    if (previousGroup && size === previousGroup.size) {
-      previousGroup.range.end = end;
-      continue;
-    }
-
-    previousGroup = {
-      range: {
-        start,
-        end
-      },
-      size
-    };
-    result.push(previousGroup);
-  }
-
-  return result;
-}
-
-exports.consolidate = consolidate;
-/**
- * Concatenates several collections of ranged groups into a single
- * collection.
- */
-
-function concat(...groups) {
-  return consolidate(groups.reduce((r, g) => r.concat(g), []));
-}
-
-class RangeMap {
-  constructor() {
-    this.groups = [];
-    this._size = 0;
-  }
-
-  splice(index, deleteCount, items = []) {
-    const diff = items.length - deleteCount;
-    const before = groupIntersect({
-      start: 0,
-      end: index
-    }, this.groups);
-    const after = groupIntersect({
-      start: index + deleteCount,
-      end: Number.POSITIVE_INFINITY
-    }, this.groups).map(g => ({
-      range: shift(g.range, diff),
-      size: g.size
-    }));
-    const middle = items.map((item, i) => ({
-      range: {
-        start: index + i,
-        end: index + i + 1
-      },
-      size: item.size
-    }));
-    this.groups = concat(before, middle, after);
-    this._size = this.groups.reduce((t, g) => t + g.size * (g.range.end - g.range.start), 0);
-  }
-  /**
-   * Returns the number of items in the range map.
-   */
-
-
-  get count() {
-    const len = this.groups.length;
-
-    if (!len) {
-      return 0;
-    }
-
-    return this.groups[len - 1].range.end;
-  }
-  /**
-   * Returns the sum of the sizes of all items in the range map.
-   */
-
-
-  get size() {
-    return this._size;
-  }
-  /**
-   * Returns the index of the item at the given position.
-   */
-
-
-  indexAt(position) {
-    if (position < 0) {
-      return -1;
-    }
-
-    let index = 0;
-    let size = 0;
-
-    for (let group of this.groups) {
-      const count = group.range.end - group.range.start;
-      const newSize = size + count * group.size;
-
-      if (position < newSize) {
-        return index + Math.floor((position - size) / group.size);
-      }
-
-      index += count;
-      size = newSize;
-    }
-
-    return index;
-  }
-  /**
-   * Returns the index of the item right after the item at the
-   * index of the given position.
-   */
-
-
-  indexAfter(position) {
-    return Math.min(this.indexAt(position) + 1, this.count);
-  }
-  /**
-   * Returns the start position of the item at the given index.
-   */
-
-
-  positionAt(index) {
-    if (index < 0) {
-      return -1;
-    }
-
-    let position = 0;
-    let count = 0;
-
-    for (let group of this.groups) {
-      const groupCount = group.range.end - group.range.start;
-      const newCount = count + groupCount;
-
-      if (index < newCount) {
-        return position + (index - count) * group.size;
-      }
-
-      position += groupCount * group.size;
-      count = newCount;
-    }
-
-    return -1;
-  }
-
-}
-
-exports.RangeMap = RangeMap;

package/lib/vs/base/browser/ui/list/rowCache.js

@@ -1,113 +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.RowCache = void 0;
-
-const dom_1 = require("../../dom");
-
-function removeFromParent(element) {
-  try {
-    if (element.parentElement) {
-      element.parentElement.removeChild(element);
-    }
-  } catch (e) {// this will throw if this happens due to a blur event, nasty business
-  }
-}
-
-class RowCache {
-  constructor(renderers) {
-    this.renderers = renderers;
-    this.cache = new Map();
-  }
-  /**
-   * Returns a row either by creating a new one or reusing
-   * a previously released row which shares the same templateId.
-   */
-
-
-  alloc(templateId) {
-    let result = this.getTemplateCache(templateId).pop();
-
-    if (!result) {
-      const domNode = dom_1.$('.monaco-list-row');
-      const renderer = this.getRenderer(templateId);
-      const templateData = renderer.renderTemplate(domNode);
-      result = {
-        domNode,
-        templateId,
-        templateData
-      };
-    }
-
-    return result;
-  }
-  /**
-   * Releases the row for eventual reuse.
-   */
-
-
-  release(row) {
-    if (!row) {
-      return;
-    }
-
-    this.releaseRow(row);
-  }
-
-  releaseRow(row) {
-    const {
-      domNode,
-      templateId
-    } = row;
-
-    if (domNode) {
-      domNode.classList.remove('scrolling');
-      removeFromParent(domNode);
-    }
-
-    const cache = this.getTemplateCache(templateId);
-    cache.push(row);
-  }
-
-  getTemplateCache(templateId) {
-    let result = this.cache.get(templateId);
-
-    if (!result) {
-      result = [];
-      this.cache.set(templateId, result);
-    }
-
-    return result;
-  }
-
-  dispose() {
-    this.cache.forEach((cachedRows, templateId) => {
-      for (const cachedRow of cachedRows) {
-        const renderer = this.getRenderer(templateId);
-        renderer.disposeTemplate(cachedRow.templateData);
-        cachedRow.domNode = null;
-        cachedRow.templateData = null;
-      }
-    });
-    this.cache.clear();
-  }
-
-  getRenderer(templateId) {
-    const renderer = this.renderers.get(templateId);
-
-    if (!renderer) {
-      throw new Error(`No renderer found for ${templateId}`);
-    }
-
-    return renderer;
-  }
-
-}
-
-exports.RowCache = RowCache;

package/lib/vs/base/browser/ui/list/splice.js

@@ -1,23 +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.CombinedSpliceable = void 0;
-
-class CombinedSpliceable {
-  constructor(spliceables) {
-    this.spliceables = spliceables;
-  }
-
-  splice(start, deleteCount, elements) {
-    this.spliceables.forEach(s => s.splice(start, deleteCount, elements));
-  }
-
-}
-
-exports.CombinedSpliceable = CombinedSpliceable;