custom-electron-titlebar 4.2.0 → 4.2.1

package/dist/base/browser/mouseEvent.js

@@ -0,0 +1,327 @@
+"use strict";
+
+/* ---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *-------------------------------------------------------------------------------------------- */
+var __createBinding = this && this.__createBinding || (Object.create ? function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  var desc = Object.getOwnPropertyDescriptor(m, k);
+  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+    desc = {
+      enumerable: true,
+      get: function () {
+        return m[k];
+      }
+    };
+  }
+  Object.defineProperty(o, k2, desc);
+} : function (o, m, k, k2) {
+  if (k2 === undefined) k2 = k;
+  o[k2] = m[k];
+});
+var __setModuleDefault = this && this.__setModuleDefault || (Object.create ? function (o, v) {
+  Object.defineProperty(o, "default", {
+    enumerable: true,
+    value: v
+  });
+} : function (o, v) {
+  o["default"] = v;
+});
+var __importStar = this && this.__importStar || function (mod) {
+  if (mod && mod.__esModule) return mod;
+  var result = {};
+  if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) _get__("__createBinding")(result, mod, k);
+  _get__("__setModuleDefault")(result, mod);
+  return result;
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StandardWheelEvent = exports.DragMouseEvent = exports.StandardMouseEvent = void 0;
+const browser = _get__("__importStar")(require("../browser/browser"));
+const platform = _get__("__importStar")(require("../common/platform"));
+class StandardMouseEvent {
+  constructor(e) {
+    this.timestamp = Date.now();
+    this.browserEvent = e;
+    this.leftButton = e.button === 0;
+    this.middleButton = e.button === 1;
+    this.rightButton = e.button === 2;
+    this.target = e.target;
+    this.detail = e.detail || 1;
+    if (e.type === 'dblclick') {
+      this.detail = 2;
+    }
+    this.ctrlKey = e.ctrlKey;
+    this.shiftKey = e.shiftKey;
+    this.altKey = e.altKey;
+    this.metaKey = e.metaKey;
+    if (typeof e.pageX === 'number') {
+      this.posx = e.pageX;
+      this.posy = e.pageY;
+    } else {
+      // Probably hit by MSGestureEvent
+      this.posx = e.clientX + document.body.scrollLeft + document.documentElement?.scrollLeft;
+      this.posy = e.clientY + document.body.scrollTop + document.documentElement?.scrollTop;
+    }
+  }
+  preventDefault() {
+    if (this.browserEvent.preventDefault) {
+      this.browserEvent.preventDefault();
+    }
+  }
+  stopPropagation() {
+    if (this.browserEvent.stopPropagation) {
+      this.browserEvent.stopPropagation();
+    }
+  }
+}
+exports.StandardMouseEvent = _get__("StandardMouseEvent");
+class DragMouseEvent extends _get__("StandardMouseEvent") {
+  constructor(e) {
+    super(e);
+    this.dataTransfer = e.dataTransfer;
+  }
+}
+exports.DragMouseEvent = _get__("DragMouseEvent");
+class StandardWheelEvent {
+  constructor(e, deltaX = 0, deltaY = 0) {
+    this.browserEvent = e || null;
+    this.target = e ? e.target || e.targetNode || e.srcElement : null;
+    this.deltaY = deltaY;
+    this.deltaX = deltaX;
+    if (e) {
+      const e1 = e;
+      const e2 = e;
+      // vertical delta scroll
+      if (typeof e1.wheelDeltaY !== 'undefined') {
+        this.deltaY = e1.wheelDeltaY / 120;
+      } else if (typeof e2.VERTICAL_AXIS !== 'undefined' && e2.axis === e2.VERTICAL_AXIS) {
+        this.deltaY = -e2.detail / 3;
+      }
+      // horizontal delta scroll
+      if (typeof e1.wheelDeltaX !== 'undefined') {
+        if (_get__("browser").isSafari && _get__("platform").isWindows) {
+          this.deltaX = -(e1.wheelDeltaX / 120);
+        } else {
+          this.deltaX = e1.wheelDeltaX / 120;
+        }
+      } else if (typeof e2.HORIZONTAL_AXIS !== 'undefined' && e2.axis === e2.HORIZONTAL_AXIS) {
+        this.deltaX = -e.detail / 3;
+      }
+      // Assume a vertical scroll if nothing else worked
+      if (this.deltaY === 0 && this.deltaX === 0 && e.wheelDelta) {
+        this.deltaY = e.wheelDelta / 120;
+      }
+    }
+  }
+  preventDefault() {
+    if (this.browserEvent) {
+      if (this.browserEvent.preventDefault) {
+        this.browserEvent.preventDefault();
+      }
+    }
+  }
+  stopPropagation() {
+    if (this.browserEvent) {
+      if (this.browserEvent.stopPropagation) {
+        this.browserEvent.stopPropagation();
+      }
+    }
+  }
+}
+exports.StandardWheelEvent = _get__("StandardWheelEvent");
+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 "__createBinding":
+      return __createBinding;
+    case "__setModuleDefault":
+      return __setModuleDefault;
+    case "__importStar":
+      return __importStar;
+    case "StandardMouseEvent":
+      return StandardMouseEvent;
+    case "DragMouseEvent":
+      return DragMouseEvent;
+    case "browser":
+      return browser;
+    case "platform":
+      return platform;
+    case "StandardWheelEvent":
+      return StandardWheelEvent;
+  }
+  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/browser/touch.d.ts

@@ -0,0 +1,39 @@
+import { Disposable, IDisposable } from '../common/lifecycle';
+export declare namespace EventType {
+    const Tap = "-monaco-gesturetap";
+    const Change = "-monaco-gesturechange";
+    const Start = "-monaco-gesturestart";
+    const End = "-monaco-gesturesend";
+    const Contextmenu = "-monaco-gesturecontextmenu";
+}
+export interface GestureEvent extends MouseEvent {
+    initialTarget: EventTarget | undefined;
+    translationX: number;
+    translationY: number;
+    pageX: number;
+    pageY: number;
+    tapCount: number;
+}
+export declare class Gesture extends Disposable {
+    private static readonly SCROLL_FRICTION;
+    private static INSTANCE;
+    private static readonly HOLD_DELAY;
+    private dispatched;
+    private readonly targets;
+    private readonly ignoreTargets;
+    private handle;
+    private readonly activeTouches;
+    private _lastSetTapCountTime;
+    private static readonly CLEAR_TAP_COUNT_TIME;
+    private constructor();
+    static addTarget(element: HTMLElement): IDisposable;
+    static ignoreTarget(element: HTMLElement): IDisposable;
+    static isTouchDevice(): boolean;
+    dispose(): void;
+    private onTouchStart;
+    private onTouchEnd;
+    private newGestureEvent;
+    private dispatchEvent;
+    private inertia;
+    private onTouchMove;
+}