custom-electron-titlebar 4.2.0 → 4.2.1

package/dist/base/common/decorators.js

@@ -0,0 +1,300 @@
+"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.throttle = exports.debounce = exports.memoize = void 0;
+function createDecorator(mapFn) {
+  return (target, key, descriptor) => {
+    let fnKey = null;
+    let fn = null;
+    if (typeof descriptor.value === 'function') {
+      fnKey = 'value';
+      fn = descriptor.value;
+    } else if (typeof descriptor.get === 'function') {
+      fnKey = 'get';
+      fn = descriptor.get;
+    }
+    if (!fn) {
+      throw new Error('not supported');
+    }
+    descriptor[fnKey] = mapFn(fn, key);
+  };
+}
+function memoize(_target, key, descriptor) {
+  let fnKey = null;
+  let fn = null;
+  if (typeof descriptor.value === 'function') {
+    fnKey = 'value';
+    fn = descriptor.value;
+    if (fn.length !== 0) {
+      console.warn('Memoize should only be used in functions with zero parameters');
+    }
+  } else if (typeof descriptor.get === 'function') {
+    fnKey = 'get';
+    fn = descriptor.get;
+  }
+  if (!fn) {
+    throw new Error('not supported');
+  }
+  const memoizeKey = `$memoize$${key}`;
+  descriptor[fnKey] = function (...args) {
+    if (!this.hasOwnProperty(memoizeKey)) {
+      Object.defineProperty(this, memoizeKey, {
+        configurable: false,
+        enumerable: false,
+        writable: false,
+        value: fn.apply(this, args)
+      });
+    }
+    return this[memoizeKey];
+  };
+}
+exports.memoize = _get__("memoize");
+function debounce(delay, reducer, initialValueProvider) {
+  return _get__("createDecorator")((fn, key) => {
+    const timerKey = `$debounce$${key}`;
+    const resultKey = `$debounce$result$${key}`;
+    return function (...args) {
+      if (!this[resultKey]) {
+        this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+      }
+      clearTimeout(this[timerKey]);
+      if (reducer) {
+        this[resultKey] = reducer(this[resultKey], ...args);
+        args = [this[resultKey]];
+      }
+      this[timerKey] = setTimeout(() => {
+        fn.apply(this, args);
+        this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+      }, delay);
+    };
+  });
+}
+exports.debounce = _get__("debounce");
+function throttle(delay, reducer, initialValueProvider) {
+  return _get__("createDecorator")((fn, key) => {
+    const timerKey = `$throttle$timer$${key}`;
+    const resultKey = `$throttle$result$${key}`;
+    const lastRunKey = `$throttle$lastRun$${key}`;
+    const pendingKey = `$throttle$pending$${key}`;
+    return function (...args) {
+      if (!this[resultKey]) {
+        this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+      }
+      if (this[lastRunKey] === null || this[lastRunKey] === undefined) {
+        this[lastRunKey] = -Number.MAX_VALUE;
+      }
+      if (reducer) {
+        this[resultKey] = reducer(this[resultKey], ...args);
+      }
+      if (this[pendingKey]) {
+        return;
+      }
+      const nextTime = this[lastRunKey] + delay;
+      if (nextTime <= Date.now()) {
+        this[lastRunKey] = Date.now();
+        fn.apply(this, [this[resultKey]]);
+        this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+      } else {
+        this[pendingKey] = true;
+        this[timerKey] = setTimeout(() => {
+          this[pendingKey] = false;
+          this[lastRunKey] = Date.now();
+          fn.apply(this, [this[resultKey]]);
+          this[resultKey] = initialValueProvider ? initialValueProvider() : undefined;
+        }, nextTime - Date.now());
+      }
+    };
+  });
+}
+exports.throttle = _get__("throttle");
+function _getGlobalObject() {
+  try {
+    if (!!global) {
+      return global;
+    }
+  } catch (e) {
+    try {
+      if (!!window) {
+        return window;
+      }
+    } catch (e) {
+      return this;
+    }
+  }
+}
+;
+var _RewireModuleId__ = null;
+function _getRewireModuleId__() {
+  if (_RewireModuleId__ === null) {
+    let globalVariable = _getGlobalObject();
+    if (!globalVariable.__$$GLOBAL_REWIRE_NEXT_MODULE_ID__) {
+      globalVariable.__$$GLOBAL_REWIRE_NEXT_MODULE_ID__ = 0;
+    }
+    _RewireModuleId__ = __$$GLOBAL_REWIRE_NEXT_MODULE_ID__++;
+  }
+  return _RewireModuleId__;
+}
+function _getRewireRegistry__() {
+  let theGlobalVariable = _getGlobalObject();
+  if (!theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__) {
+    theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__ = Object.create(null);
+  }
+  return theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__;
+}
+function _getRewiredData__() {
+  let moduleId = _getRewireModuleId__();
+  let registry = _getRewireRegistry__();
+  let rewireData = registry[moduleId];
+  if (!rewireData) {
+    registry[moduleId] = Object.create(null);
+    rewireData = registry[moduleId];
+  }
+  return rewireData;
+}
+(function registerResetAll() {
+  let theGlobalVariable = _getGlobalObject();
+  if (!theGlobalVariable['__rewire_reset_all__']) {
+    theGlobalVariable['__rewire_reset_all__'] = function () {
+      theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__ = Object.create(null);
+    };
+  }
+})();
+var INTENTIONAL_UNDEFINED = '__INTENTIONAL_UNDEFINED__';
+let _RewireAPI__ = {};
+(function () {
+  function addPropertyToAPIObject(name, value) {
+    Object.defineProperty(_RewireAPI__, name, {
+      value: value,
+      enumerable: false,
+      configurable: true
+    });
+  }
+  addPropertyToAPIObject('__get__', _get__);
+  addPropertyToAPIObject('__GetDependency__', _get__);
+  addPropertyToAPIObject('__Rewire__', _set__);
+  addPropertyToAPIObject('__set__', _set__);
+  addPropertyToAPIObject('__reset__', _reset__);
+  addPropertyToAPIObject('__ResetDependency__', _reset__);
+  addPropertyToAPIObject('__with__', _with__);
+})();
+function _get__(variableName) {
+  let rewireData = _getRewiredData__();
+  if (rewireData[variableName] === undefined) {
+    return _get_original__(variableName);
+  } else {
+    var value = rewireData[variableName];
+    if (value === INTENTIONAL_UNDEFINED) {
+      return undefined;
+    } else {
+      return value;
+    }
+  }
+}
+function _get_original__(variableName) {
+  switch (variableName) {
+    case "memoize":
+      return memoize;
+    case "createDecorator":
+      return createDecorator;
+    case "debounce":
+      return debounce;
+    case "throttle":
+      return throttle;
+  }
+  return undefined;
+}
+function _assign__(variableName, value) {
+  let rewireData = _getRewiredData__();
+  if (rewireData[variableName] === undefined) {
+    return _set_original__(variableName, value);
+  } else {
+    return rewireData[variableName] = value;
+  }
+}
+function _set_original__(variableName, _value) {
+  switch (variableName) {}
+  return undefined;
+}
+function _update_operation__(operation, variableName, prefix) {
+  var oldValue = _get__(variableName);
+  var newValue = operation === '++' ? oldValue + 1 : oldValue - 1;
+  _assign__(variableName, newValue);
+  return prefix ? newValue : oldValue;
+}
+function _set__(variableName, value) {
+  let rewireData = _getRewiredData__();
+  if (typeof variableName === 'object') {
+    Object.keys(variableName).forEach(function (name) {
+      rewireData[name] = variableName[name];
+    });
+    return function () {
+      Object.keys(variableName).forEach(function (name) {
+        _reset__(variableName);
+      });
+    };
+  } else {
+    if (value === undefined) {
+      rewireData[variableName] = INTENTIONAL_UNDEFINED;
+    } else {
+      rewireData[variableName] = value;
+    }
+    return function () {
+      _reset__(variableName);
+    };
+  }
+}
+function _reset__(variableName) {
+  let rewireData = _getRewiredData__();
+  delete rewireData[variableName];
+  if (Object.keys(rewireData).length == 0) {
+    delete _getRewireRegistry__()[_getRewireModuleId__];
+  }
+  ;
+}
+function _with__(object) {
+  let rewireData = _getRewiredData__();
+  var rewiredVariableNames = Object.keys(object);
+  var previousValues = {};
+  function reset() {
+    rewiredVariableNames.forEach(function (variableName) {
+      rewireData[variableName] = previousValues[variableName];
+    });
+  }
+  return function (callback) {
+    rewiredVariableNames.forEach(function (variableName) {
+      previousValues[variableName] = rewireData[variableName];
+      rewireData[variableName] = object[variableName];
+    });
+    let result = callback();
+    if (!!result && typeof result.then == 'function') {
+      result.then(reset).catch(reset);
+    } else {
+      reset();
+    }
+    return result;
+  };
+}
+let _typeOfOriginalExport = typeof module.exports;
+function addNonEnumerableProperty(name, value) {
+  Object.defineProperty(module.exports, name, {
+    value: value,
+    enumerable: false,
+    configurable: true
+  });
+}
+if ((_typeOfOriginalExport === 'object' || _typeOfOriginalExport === 'function') && Object.isExtensible(module.exports)) {
+  addNonEnumerableProperty('__get__', _get__);
+  addNonEnumerableProperty('__GetDependency__', _get__);
+  addNonEnumerableProperty('__Rewire__', _set__);
+  addNonEnumerableProperty('__set__', _set__);
+  addNonEnumerableProperty('__reset__', _reset__);
+  addNonEnumerableProperty('__ResetDependency__', _reset__);
+  addNonEnumerableProperty('__with__', _with__);
+  addNonEnumerableProperty('__RewireAPI__', _RewireAPI__);
+}

package/dist/base/common/dom.d.ts

@@ -0,0 +1,221 @@
+import { IKeyboardEvent } from '../browser/keyboardEvent';
+import { IMouseEvent } from '../browser/mouseEvent';
+import { Emitter, Event } from '../common/event';
+import { IDisposable } from '../common/lifecycle';
+export declare function clearNode(node: HTMLElement): void;
+export declare function removeNode(node: HTMLElement): void;
+export declare function isInDOM(node: Node | null): boolean;
+type ModifierKey = 'alt' | 'ctrl' | 'shift' | 'meta';
+export interface IModifierKeyStatus {
+    altKey: boolean;
+    shiftKey: boolean;
+    ctrlKey: boolean;
+    metaKey: boolean;
+    lastKeyPressed?: ModifierKey;
+    lastKeyReleased?: ModifierKey;
+    event?: KeyboardEvent;
+}
+export declare class ModifierKeyEmitter extends Emitter<IModifierKeyStatus> {
+    private _keyStatus;
+    private static instance;
+    private constructor();
+    get keyStatus(): IModifierKeyStatus;
+    get isModifierPressed(): boolean;
+    /**
+     * Allows to explicitly reset the key status based on more knowledge (#109062)
+     */
+    resetKeyStatus(): void;
+    private doResetKeyStatus;
+    static getInstance(): ModifierKeyEmitter;
+    dispose(): void;
+}
+export declare const hasClass: (node: HTMLElement, className: string) => boolean;
+export declare const addClass: (node: HTMLElement, className: string) => void;
+export declare const addClasses: (node: HTMLElement, ...classNames: string[]) => void;
+export declare const removeClass: (node: HTMLElement, className: string) => void;
+export declare const removeClasses: (node: HTMLElement, ...classNames: string[]) => void;
+export declare const toggleClass: (node: HTMLElement, className: string, shouldHaveIt?: boolean) => void;
+export declare function addDisposableListener<K extends keyof GlobalEventHandlersEventMap>(node: EventTarget, type: K, handler: (event: GlobalEventHandlersEventMap[K]) => void, useCapture?: boolean): IDisposable;
+export declare function addDisposableListener(node: EventTarget, type: string, handler: (event: any) => void, useCapture?: boolean): IDisposable;
+export declare function addDisposableListener(node: EventTarget, type: string, handler: (event: any) => void, options: AddEventListenerOptions): IDisposable;
+export interface IAddStandardDisposableListenerSignature {
+    (node: HTMLElement, type: 'click', handler: (event: IMouseEvent) => void, useCapture?: boolean): IDisposable;
+    (node: HTMLElement, type: 'mousedown', handler: (event: IMouseEvent) => void, useCapture?: boolean): IDisposable;
+    (node: HTMLElement, type: 'keydown', handler: (event: IKeyboardEvent) => void, useCapture?: boolean): IDisposable;
+    (node: HTMLElement, type: 'keypress', handler: (event: IKeyboardEvent) => void, useCapture?: boolean): IDisposable;
+    (node: HTMLElement, type: 'keyup', handler: (event: IKeyboardEvent) => void, useCapture?: boolean): IDisposable;
+    (node: HTMLElement, type: string, handler: (event: any) => void, useCapture?: boolean): IDisposable;
+}
+export declare const addStandardDisposableListener: IAddStandardDisposableListenerSignature;
+export declare function addDisposableNonBubblingMouseOutListener(node: Element, handler: (event: MouseEvent) => void): IDisposable;
+/**
+ * Schedule a callback to be run at the next animation frame.
+ * This allows multiple parties to register callbacks that should run at the next animation frame.
+ * If currently in an animation frame, `runner` will be executed immediately.
+ * @return token that can be used to cancel the scheduled runner (only if `runner` was not executed immediately).
+ */
+export declare let runAtThisOrScheduleAtNextAnimationFrame: (runner: () => void, priority?: number) => IDisposable;
+/**
+ * Schedule a callback to be run at the next animation frame.
+ * This allows multiple parties to register callbacks that should run at the next animation frame.
+ * If currently in an animation frame, `runner` will be executed at the next animation frame.
+ * @return token that can be used to cancel the scheduled runner.
+ */
+export declare let scheduleAtNextAnimationFrame: (runner: () => void, priority?: number) => IDisposable;
+export declare function measure(callback: () => void): IDisposable;
+export declare function modify(callback: () => void): IDisposable;
+/**
+ * Add a throttled listener. `handler` is fired at most every 16ms or with the next animation frame (if browser supports it).
+ */
+export interface IEventMerger<R, E> {
+    (lastEvent: R | null, currentEvent: E): R;
+}
+export interface DOMEvent {
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+export declare function addDisposableThrottledListener<R, E extends DOMEvent = DOMEvent>(node: any, type: string, handler: (event: R) => void, eventMerger?: IEventMerger<R, E>, minimumTimeMs?: number): IDisposable;
+export declare function getComputedStyle(el: HTMLElement): CSSStyleDeclaration;
+export declare function getClientArea(element: HTMLElement): Dimension;
+/**
+ * Returns the effective zoom on a given element before window zoom level is applied
+ */
+export declare function getDomNodeZoomLevel(domNode: HTMLElement): number;
+export declare class Dimension {
+    width: number;
+    height: number;
+    constructor(width: number, height: number);
+    static equals(a: Dimension | undefined, b: Dimension | undefined): boolean;
+}
+export declare function getTopLeftOffset(element: HTMLElement): {
+    left: number;
+    top: number;
+};
+export interface IDomNodePagePosition {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+export declare function size(element: HTMLElement, width: number, height: number): void;
+export declare function position(element: HTMLElement, top: number, right?: number, bottom?: number, left?: number, position?: string): void;
+/**
+ * Returns the position of a dom node relative to the entire page.
+ */
+export declare function getDomNodePagePosition(domNode: HTMLElement): IDomNodePagePosition;
+export interface IStandardWindow {
+    readonly scrollX: number;
+    readonly scrollY: number;
+}
+export declare const StandardWindow: IStandardWindow;
+export declare function getTotalWidth(element: HTMLElement): number;
+export declare function getContentWidth(element: HTMLElement): number;
+export declare function getTotalScrollWidth(element: HTMLElement): number;
+export declare function getContentHeight(element: HTMLElement): number;
+export declare function getTotalHeight(element: HTMLElement): number;
+export declare function getLargestChildWidth(parent: HTMLElement, children: HTMLElement[]): number;
+export declare function isAncestor(testChild: Node | null, testAncestor: Node | null): boolean;
+export declare function findParentWithClass(node: HTMLElement, clazz: string, stopAtClazzOrNode?: string | HTMLElement): HTMLElement | null;
+export declare function createStyleSheet(container?: HTMLElement): HTMLStyleElement;
+export declare function createCSSRule(selector: string, cssText: string, style?: HTMLStyleElement): void;
+export declare function removeCSSRulesContainingSelector(ruleName: string, style?: HTMLStyleElement): void;
+export declare function isHTMLElement(o: any): o is HTMLElement;
+export declare const EventType: {
+    readonly CLICK: "click";
+    readonly AUXCLICK: "auxclick";
+    readonly DBLCLICK: "dblclick";
+    readonly MOUSE_UP: "mouseup";
+    readonly MOUSE_DOWN: "mousedown";
+    readonly MOUSE_OVER: "mouseover";
+    readonly MOUSE_MOVE: "mousemove";
+    readonly MOUSE_OUT: "mouseout";
+    readonly MOUSE_ENTER: "mouseenter";
+    readonly MOUSE_LEAVE: "mouseleave";
+    readonly MOUSE_WHEEL: "wheel";
+    readonly POINTER_UP: "pointerup";
+    readonly POINTER_DOWN: "pointerdown";
+    readonly POINTER_MOVE: "pointermove";
+    readonly POINTER_LEAVE: "pointerleave";
+    readonly CONTEXT_MENU: "contextmenu";
+    readonly WHEEL: "wheel";
+    readonly KEY_DOWN: "keydown";
+    readonly KEY_PRESS: "keypress";
+    readonly KEY_UP: "keyup";
+    readonly LOAD: "load";
+    readonly BEFORE_UNLOAD: "beforeunload";
+    readonly UNLOAD: "unload";
+    readonly PAGE_SHOW: "pageshow";
+    readonly PAGE_HIDE: "pagehide";
+    readonly ABORT: "abort";
+    readonly ERROR: "error";
+    readonly RESIZE: "resize";
+    readonly SCROLL: "scroll";
+    readonly FULLSCREEN_CHANGE: "fullscreenchange";
+    readonly WK_FULLSCREEN_CHANGE: "webkitfullscreenchange";
+    readonly SELECT: "select";
+    readonly CHANGE: "change";
+    readonly SUBMIT: "submit";
+    readonly RESET: "reset";
+    readonly FOCUS: "focus";
+    readonly FOCUS_IN: "focusin";
+    readonly FOCUS_OUT: "focusout";
+    readonly BLUR: "blur";
+    readonly INPUT: "input";
+    readonly STORAGE: "storage";
+    readonly DRAG_START: "dragstart";
+    readonly DRAG: "drag";
+    readonly DRAG_ENTER: "dragenter";
+    readonly DRAG_LEAVE: "dragleave";
+    readonly DRAG_OVER: "dragover";
+    readonly DROP: "drop";
+    readonly DRAG_END: "dragend";
+    readonly ANIMATION_START: "animationstart" | "webkitAnimationStart";
+    readonly ANIMATION_END: "animationend" | "webkitAnimationEnd";
+    readonly ANIMATION_ITERATION: "animationiteration" | "webkitAnimationIteration";
+};
+export interface EventLike {
+    preventDefault(): void;
+    stopPropagation(): void;
+}
+export declare const EventHelper: {
+    stop: (e: EventLike, cancelBubble?: boolean) => void;
+};
+export interface IFocusTracker {
+    onDidFocus: Event<void>;
+    onDidBlur: Event<void>;
+    dispose(): void;
+}
+export declare function saveParentsScrollTop(node: Element): number[];
+export declare function restoreParentsScrollTop(node: Element, state: number[]): void;
+export declare function trackFocus(element: HTMLElement | Window): IFocusTracker;
+export declare function append<T extends Node>(parent: HTMLElement, ...children: T[]): T;
+export declare function prepend<T extends Node>(parent: HTMLElement, child: T): T;
+export declare function $<T extends HTMLElement>(description: string, attrs?: {
+    [key: string]: any;
+}, ...children: Array<Node | string>): T;
+export declare function join(nodes: Node[], separator: Node | string): Node[];
+export declare function show(...elements: HTMLElement[]): void;
+export declare function hide(...elements: HTMLElement[]): void;
+export declare function removeTabIndexAndUpdateFocus(node: HTMLElement): void;
+export declare function getElementsByTagName(tag: string): HTMLElement[];
+export declare function finalHandler<T extends DOMEvent>(fn: (event: T) => any): (event: T) => any;
+export declare function domContentLoaded(): Promise<any>;
+/**
+ * Find a value usable for a dom node size such that the likelihood that it would be
+ * displayed with constant screen pixels size is as high as possible.
+ *
+ * e.g. We would desire for the cursors to be 2px (CSS px) wide. Under a devicePixelRatio
+ * of 1.25, the cursor will be 2.5 screen pixels wide. Depending on how the dom node aligns/"snaps"
+ * with the screen pixels, it will sometimes be rendered with 2 screen pixels, and sometimes with 3 screen pixels.
+ */
+export declare function computeScreenAwareSize(cssPx: number): number;
+/**
+ * See https://github.com/Microsoft/monaco-editor/issues/601
+ * To protect against malicious code in the linked site, particularly phishing attempts,
+ * the window.opener should be set to null to prevent the linked site from having access
+ * to change the location of the current page.
+ * See https://mathiasbynens.github.io/rel-noopener/
+ */
+export declare function windowOpenNoOpener(url: string): void;
+export declare function animate(fn: () => void): IDisposable;
+export {};