custom-electron-titlebar 3.2.6 → 3.2.10

package/lib/vs/base/common/numbers.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.MovingAverage = exports.Counter = exports.rot = exports.clamp = void 0;
-
-function clamp(value, min, max) {
-  return Math.min(Math.max(value, min), max);
-}
-
-exports.clamp = clamp;
-
-function rot(index, modulo) {
-  return (modulo + index % modulo) % modulo;
-}
-
-exports.rot = rot;
-
-class Counter {
-  constructor() {
-    this._next = 0;
-  }
-
-  getNext() {
-    return this._next++;
-  }
-
-}
-
-exports.Counter = Counter;
-
-class MovingAverage {
-  constructor() {
-    this._n = 1;
-    this._val = 0;
-  }
-
-  update(value) {
-    this._val = this._val + (value - this._val) / this._n;
-    this._n += 1;
-    return this;
-  }
-
-  get value() {
-    return this._val;
-  }
-
-}
-
-exports.MovingAverage = MovingAverage;

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

@@ -1,268 +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.distinct = exports.getOrDefault = exports.safeStringify = exports.equals = exports.mixin = exports.cloneAndChange = exports.deepFreeze = exports.deepClone = void 0;
-
-const types_1 = require("./types");
-
-function deepClone(obj) {
-  if (!obj || typeof obj !== 'object') {
-    return obj;
-  }
-
-  if (obj instanceof RegExp) {
-    // See https://github.com/microsoft/TypeScript/issues/10990
-    return obj;
-  }
-
-  const result = Array.isArray(obj) ? [] : {};
-  Object.keys(obj).forEach(key => {
-    if (obj[key] && typeof obj[key] === 'object') {
-      result[key] = deepClone(obj[key]);
-    } else {
-      result[key] = obj[key];
-    }
-  });
-  return result;
-}
-
-exports.deepClone = deepClone;
-
-function deepFreeze(obj) {
-  if (!obj || typeof obj !== 'object') {
-    return obj;
-  }
-
-  const stack = [obj];
-
-  while (stack.length > 0) {
-    const obj = stack.shift();
-    Object.freeze(obj);
-
-    for (const key in obj) {
-      if (_hasOwnProperty.call(obj, key)) {
-        const prop = obj[key];
-
-        if (typeof prop === 'object' && !Object.isFrozen(prop)) {
-          stack.push(prop);
-        }
-      }
-    }
-  }
-
-  return obj;
-}
-
-exports.deepFreeze = deepFreeze;
-const _hasOwnProperty = Object.prototype.hasOwnProperty;
-
-function cloneAndChange(obj, changer) {
-  return _cloneAndChange(obj, changer, new Set());
-}
-
-exports.cloneAndChange = cloneAndChange;
-
-function _cloneAndChange(obj, changer, seen) {
-  if (types_1.isUndefinedOrNull(obj)) {
-    return obj;
-  }
-
-  const changed = changer(obj);
-
-  if (typeof changed !== 'undefined') {
-    return changed;
-  }
-
-  if (types_1.isArray(obj)) {
-    const r1 = [];
-
-    for (const e of obj) {
-      r1.push(_cloneAndChange(e, changer, seen));
-    }
-
-    return r1;
-  }
-
-  if (types_1.isObject(obj)) {
-    if (seen.has(obj)) {
-      throw new Error('Cannot clone recursive data-structure');
-    }
-
-    seen.add(obj);
-    const r2 = {};
-
-    for (let i2 in obj) {
-      if (_hasOwnProperty.call(obj, i2)) {
-        r2[i2] = _cloneAndChange(obj[i2], changer, seen);
-      }
-    }
-
-    seen.delete(obj);
-    return r2;
-  }
-
-  return obj;
-}
-/**
- * Copies all properties of source into destination. The optional parameter "overwrite" allows to control
- * if existing properties on the destination should be overwritten or not. Defaults to true (overwrite).
- */
-
-
-function mixin(destination, source, overwrite = true) {
-  if (!types_1.isObject(destination)) {
-    return source;
-  }
-
-  if (types_1.isObject(source)) {
-    Object.keys(source).forEach(key => {
-      if (key in destination) {
-        if (overwrite) {
-          if (types_1.isObject(destination[key]) && types_1.isObject(source[key])) {
-            mixin(destination[key], source[key], overwrite);
-          } else {
-            destination[key] = source[key];
-          }
-        }
-      } else {
-        destination[key] = source[key];
-      }
-    });
-  }
-
-  return destination;
-}
-
-exports.mixin = mixin;
-
-function equals(one, other) {
-  if (one === other) {
-    return true;
-  }
-
-  if (one === null || one === undefined || other === null || other === undefined) {
-    return false;
-  }
-
-  if (typeof one !== typeof other) {
-    return false;
-  }
-
-  if (typeof one !== 'object') {
-    return false;
-  }
-
-  if (Array.isArray(one) !== Array.isArray(other)) {
-    return false;
-  }
-
-  let i;
-  let key;
-
-  if (Array.isArray(one)) {
-    if (one.length !== other.length) {
-      return false;
-    }
-
-    for (i = 0; i < one.length; i++) {
-      if (!equals(one[i], other[i])) {
-        return false;
-      }
-    }
-  } else {
-    const oneKeys = [];
-
-    for (key in one) {
-      oneKeys.push(key);
-    }
-
-    oneKeys.sort();
-    const otherKeys = [];
-
-    for (key in other) {
-      otherKeys.push(key);
-    }
-
-    otherKeys.sort();
-
-    if (!equals(oneKeys, otherKeys)) {
-      return false;
-    }
-
-    for (i = 0; i < oneKeys.length; i++) {
-      if (!equals(one[oneKeys[i]], other[oneKeys[i]])) {
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
-exports.equals = equals;
-/**
- * Calls `JSON.Stringify` with a replacer to break apart any circular references.
- * This prevents `JSON`.stringify` from throwing the exception
- *  "Uncaught TypeError: Converting circular structure to JSON"
- */
-
-function safeStringify(obj) {
-  const seen = new Set();
-  return JSON.stringify(obj, (key, value) => {
-    if (types_1.isObject(value) || Array.isArray(value)) {
-      if (seen.has(value)) {
-        return '[Circular]';
-      } else {
-        seen.add(value);
-      }
-    }
-
-    return value;
-  });
-}
-
-exports.safeStringify = safeStringify;
-
-function getOrDefault(obj, fn, defaultValue) {
-  const result = fn(obj);
-  return typeof result === 'undefined' ? defaultValue : result;
-}
-
-exports.getOrDefault = getOrDefault;
-/**
- * Returns an object that has keys for each value that is different in the base object. Keys
- * that do not exist in the target but in the base object are not considered.
- *
- * Note: This is not a deep-diffing method, so the values are strictly taken into the resulting
- * object if they differ.
- *
- * @param base the object to diff against
- * @param obj the object to use for diffing
- */
-
-function distinct(base, target) {
-  const result = Object.create(null);
-
-  if (!base || !target) {
-    return result;
-  }
-
-  const targetKeys = Object.keys(target);
-  targetKeys.forEach(k => {
-    const baseValue = base[k];
-    const targetValue = target[k];
-
-    if (!equals(baseValue, targetValue)) {
-      result[k] = targetValue;
-    }
-  });
-  return result;
-}
-
-exports.distinct = distinct;

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

@@ -1,190 +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.mergePagers = exports.mapPager = exports.DelayedPagedModel = exports.PagedModel = exports.singlePagePager = void 0;
-
-const types_1 = require("./types");
-
-const cancellation_1 = require("./cancellation");
-
-const errors_1 = require("./errors");
-
-const arrays_1 = require("./arrays");
-
-function createPage(elements) {
-  return {
-    isResolved: !!elements,
-    promise: null,
-    cts: null,
-    promiseIndexes: new Set(),
-    elements: elements || []
-  };
-}
-
-function singlePagePager(elements) {
-  return {
-    firstPage: elements,
-    total: elements.length,
-    pageSize: elements.length,
-    getPage: (pageIndex, cancellationToken) => {
-      return Promise.resolve(elements);
-    }
-  };
-}
-
-exports.singlePagePager = singlePagePager;
-
-class PagedModel {
-  constructor(arg) {
-    this.pages = [];
-    this.pager = types_1.isArray(arg) ? singlePagePager(arg) : arg;
-    const totalPages = Math.ceil(this.pager.total / this.pager.pageSize);
-    this.pages = [createPage(this.pager.firstPage.slice()), ...arrays_1.range(totalPages - 1).map(() => createPage())];
-  }
-
-  get length() {
-    return this.pager.total;
-  }
-
-  isResolved(index) {
-    const pageIndex = Math.floor(index / this.pager.pageSize);
-    const page = this.pages[pageIndex];
-    return !!page.isResolved;
-  }
-
-  get(index) {
-    const pageIndex = Math.floor(index / this.pager.pageSize);
-    const indexInPage = index % this.pager.pageSize;
-    const page = this.pages[pageIndex];
-    return page.elements[indexInPage];
-  }
-
-  resolve(index, cancellationToken) {
-    if (cancellationToken.isCancellationRequested) {
-      return Promise.reject(errors_1.canceled());
-    }
-
-    const pageIndex = Math.floor(index / this.pager.pageSize);
-    const indexInPage = index % this.pager.pageSize;
-    const page = this.pages[pageIndex];
-
-    if (page.isResolved) {
-      return Promise.resolve(page.elements[indexInPage]);
-    }
-
-    if (!page.promise) {
-      page.cts = new cancellation_1.CancellationTokenSource();
-      page.promise = this.pager.getPage(pageIndex, page.cts.token).then(elements => {
-        page.elements = elements;
-        page.isResolved = true;
-        page.promise = null;
-        page.cts = null;
-      }, err => {
-        page.isResolved = false;
-        page.promise = null;
-        page.cts = null;
-        return Promise.reject(err);
-      });
-    }
-
-    cancellationToken.onCancellationRequested(() => {
-      if (!page.cts) {
-        return;
-      }
-
-      page.promiseIndexes.delete(index);
-
-      if (page.promiseIndexes.size === 0) {
-        page.cts.cancel();
-      }
-    });
-    page.promiseIndexes.add(index);
-    return page.promise.then(() => page.elements[indexInPage]);
-  }
-
-}
-
-exports.PagedModel = PagedModel;
-
-class DelayedPagedModel {
-  constructor(model, timeout = 500) {
-    this.model = model;
-    this.timeout = timeout;
-  }
-
-  get length() {
-    return this.model.length;
-  }
-
-  isResolved(index) {
-    return this.model.isResolved(index);
-  }
-
-  get(index) {
-    return this.model.get(index);
-  }
-
-  resolve(index, cancellationToken) {
-    return new Promise((c, e) => {
-      if (cancellationToken.isCancellationRequested) {
-        return e(errors_1.canceled());
-      }
-
-      const timer = setTimeout(() => {
-        if (cancellationToken.isCancellationRequested) {
-          return e(errors_1.canceled());
-        }
-
-        timeoutCancellation.dispose();
-        this.model.resolve(index, cancellationToken).then(c, e);
-      }, this.timeout);
-      const timeoutCancellation = cancellationToken.onCancellationRequested(() => {
-        clearTimeout(timer);
-        timeoutCancellation.dispose();
-        e(errors_1.canceled());
-      });
-    });
-  }
-
-}
-
-exports.DelayedPagedModel = DelayedPagedModel;
-/**
- * Similar to array.map, `mapPager` lets you map the elements of an
- * abstract paged collection to another type.
- */
-
-function mapPager(pager, fn) {
-  return {
-    firstPage: pager.firstPage.map(fn),
-    total: pager.total,
-    pageSize: pager.pageSize,
-    getPage: (pageIndex, token) => pager.getPage(pageIndex, token).then(r => r.map(fn))
-  };
-}
-
-exports.mapPager = mapPager;
-/**
- * Merges two pagers.
- */
-
-function mergePagers(one, other) {
-  return {
-    firstPage: [...one.firstPage, ...other.firstPage],
-    total: one.total + other.total,
-    pageSize: one.pageSize + other.pageSize,
-
-    getPage(pageIndex, token) {
-      return Promise.all([one.getPage(pageIndex, token), other.getPage(pageIndex, token)]).then(([onePage, otherPage]) => [...onePage, ...otherPage]);
-    }
-
-  };
-}
-
-exports.mergePagers = mergePagers;

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

@@ -1,78 +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.Parser = exports.ValidationStatus = void 0;
-
-class ValidationStatus {
-  constructor() {
-    this._state = 0
-    /* OK */
-    ;
-  }
-
-  get state() {
-    return this._state;
-  }
-
-  set state(value) {
-    if (value > this._state) {
-      this._state = value;
-    }
-  }
-
-  isOK() {
-    return this._state === 0
-    /* OK */
-    ;
-  }
-
-  isFatal() {
-    return this._state === 4
-    /* Fatal */
-    ;
-  }
-
-}
-
-exports.ValidationStatus = ValidationStatus;
-
-class Parser {
-  constructor(problemReporter) {
-    this._problemReporter = problemReporter;
-  }
-
-  reset() {
-    this._problemReporter.status.state = 0
-    /* OK */
-    ;
-  }
-
-  get problemReporter() {
-    return this._problemReporter;
-  }
-
-  info(message) {
-    this._problemReporter.info(message);
-  }
-
-  warn(message) {
-    this._problemReporter.warn(message);
-  }
-
-  error(message) {
-    this._problemReporter.error(message);
-  }
-
-  fatal(message) {
-    this._problemReporter.fatal(message);
-  }
-
-}
-
-exports.Parser = Parser;