mirror of
https://github.com/neocities/neocities.git
synced 2025-04-30 03:58:00 +02:00
1525 lines
54 KiB
JavaScript
1525 lines
54 KiB
JavaScript
/*---------------------------------------------------------------------------------------------
|
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
|
* Licensed under the MIT License. See License.txt in the project root for license information.
|
|
*--------------------------------------------------------------------------------------------*/
|
|
import * as browser from './browser.js';
|
|
import { BrowserFeatures } from './canIUse.js';
|
|
import { StandardKeyboardEvent } from './keyboardEvent.js';
|
|
import { StandardMouseEvent } from './mouseEvent.js';
|
|
import { AbstractIdleValue, IntervalTimer, _runWhenIdle } from '../common/async.js';
|
|
import { onUnexpectedError } from '../common/errors.js';
|
|
import * as event from '../common/event.js';
|
|
import * as dompurify from './dompurify/dompurify.js';
|
|
import { Disposable, DisposableStore, toDisposable } from '../common/lifecycle.js';
|
|
import { FileAccess, RemoteAuthorities } from '../common/network.js';
|
|
import * as platform from '../common/platform.js';
|
|
import { hash } from '../common/hash.js';
|
|
import { ensureCodeWindow, mainWindow } from './window.js';
|
|
//# region Multi-Window Support Utilities
|
|
export const { registerWindow, getWindow, getDocument, getWindows, getWindowsCount, getWindowId, getWindowById, hasWindow, onDidRegisterWindow, onWillUnregisterWindow, onDidUnregisterWindow } = (function () {
|
|
const windows = new Map();
|
|
ensureCodeWindow(mainWindow, 1);
|
|
const mainWindowRegistration = { window: mainWindow, disposables: new DisposableStore() };
|
|
windows.set(mainWindow.vscodeWindowId, mainWindowRegistration);
|
|
const onDidRegisterWindow = new event.Emitter();
|
|
const onDidUnregisterWindow = new event.Emitter();
|
|
const onWillUnregisterWindow = new event.Emitter();
|
|
function getWindowById(windowId, fallbackToMain) {
|
|
const window = typeof windowId === 'number' ? windows.get(windowId) : undefined;
|
|
return window ?? (fallbackToMain ? mainWindowRegistration : undefined);
|
|
}
|
|
return {
|
|
onDidRegisterWindow: onDidRegisterWindow.event,
|
|
onWillUnregisterWindow: onWillUnregisterWindow.event,
|
|
onDidUnregisterWindow: onDidUnregisterWindow.event,
|
|
registerWindow(window) {
|
|
if (windows.has(window.vscodeWindowId)) {
|
|
return Disposable.None;
|
|
}
|
|
const disposables = new DisposableStore();
|
|
const registeredWindow = {
|
|
window,
|
|
disposables: disposables.add(new DisposableStore())
|
|
};
|
|
windows.set(window.vscodeWindowId, registeredWindow);
|
|
disposables.add(toDisposable(() => {
|
|
windows.delete(window.vscodeWindowId);
|
|
onDidUnregisterWindow.fire(window);
|
|
}));
|
|
disposables.add(addDisposableListener(window, EventType.BEFORE_UNLOAD, () => {
|
|
onWillUnregisterWindow.fire(window);
|
|
}));
|
|
onDidRegisterWindow.fire(registeredWindow);
|
|
return disposables;
|
|
},
|
|
getWindows() {
|
|
return windows.values();
|
|
},
|
|
getWindowsCount() {
|
|
return windows.size;
|
|
},
|
|
getWindowId(targetWindow) {
|
|
return targetWindow.vscodeWindowId;
|
|
},
|
|
hasWindow(windowId) {
|
|
return windows.has(windowId);
|
|
},
|
|
getWindowById,
|
|
getWindow(e) {
|
|
const candidateNode = e;
|
|
if (candidateNode?.ownerDocument?.defaultView) {
|
|
return candidateNode.ownerDocument.defaultView.window;
|
|
}
|
|
const candidateEvent = e;
|
|
if (candidateEvent?.view) {
|
|
return candidateEvent.view.window;
|
|
}
|
|
return mainWindow;
|
|
},
|
|
getDocument(e) {
|
|
const candidateNode = e;
|
|
return getWindow(candidateNode).document;
|
|
}
|
|
};
|
|
})();
|
|
//#endregion
|
|
export function clearNode(node) {
|
|
while (node.firstChild) {
|
|
node.firstChild.remove();
|
|
}
|
|
}
|
|
class DomListener {
|
|
constructor(node, type, handler, options) {
|
|
this._node = node;
|
|
this._type = type;
|
|
this._handler = handler;
|
|
this._options = (options || false);
|
|
this._node.addEventListener(this._type, this._handler, this._options);
|
|
}
|
|
dispose() {
|
|
if (!this._handler) {
|
|
// Already disposed
|
|
return;
|
|
}
|
|
this._node.removeEventListener(this._type, this._handler, this._options);
|
|
// Prevent leakers from holding on to the dom or handler func
|
|
this._node = null;
|
|
this._handler = null;
|
|
}
|
|
}
|
|
export function addDisposableListener(node, type, handler, useCaptureOrOptions) {
|
|
return new DomListener(node, type, handler, useCaptureOrOptions);
|
|
}
|
|
function _wrapAsStandardMouseEvent(targetWindow, handler) {
|
|
return function (e) {
|
|
return handler(new StandardMouseEvent(targetWindow, e));
|
|
};
|
|
}
|
|
function _wrapAsStandardKeyboardEvent(handler) {
|
|
return function (e) {
|
|
return handler(new StandardKeyboardEvent(e));
|
|
};
|
|
}
|
|
export const addStandardDisposableListener = function addStandardDisposableListener(node, type, handler, useCapture) {
|
|
let wrapHandler = handler;
|
|
if (type === 'click' || type === 'mousedown' || type === 'contextmenu') {
|
|
wrapHandler = _wrapAsStandardMouseEvent(getWindow(node), handler);
|
|
}
|
|
else if (type === 'keydown' || type === 'keypress' || type === 'keyup') {
|
|
wrapHandler = _wrapAsStandardKeyboardEvent(handler);
|
|
}
|
|
return addDisposableListener(node, type, wrapHandler, useCapture);
|
|
};
|
|
export const addStandardDisposableGenericMouseDownListener = function addStandardDisposableListener(node, handler, useCapture) {
|
|
const wrapHandler = _wrapAsStandardMouseEvent(getWindow(node), handler);
|
|
return addDisposableGenericMouseDownListener(node, wrapHandler, useCapture);
|
|
};
|
|
export const addStandardDisposableGenericMouseUpListener = function addStandardDisposableListener(node, handler, useCapture) {
|
|
const wrapHandler = _wrapAsStandardMouseEvent(getWindow(node), handler);
|
|
return addDisposableGenericMouseUpListener(node, wrapHandler, useCapture);
|
|
};
|
|
export function addDisposableGenericMouseDownListener(node, handler, useCapture) {
|
|
return addDisposableListener(node, platform.isIOS && BrowserFeatures.pointerEvents ? EventType.POINTER_DOWN : EventType.MOUSE_DOWN, handler, useCapture);
|
|
}
|
|
export function addDisposableGenericMouseUpListener(node, handler, useCapture) {
|
|
return addDisposableListener(node, platform.isIOS && BrowserFeatures.pointerEvents ? EventType.POINTER_UP : EventType.MOUSE_UP, handler, useCapture);
|
|
}
|
|
/**
|
|
* Execute the callback the next time the browser is idle, returning an
|
|
* {@link IDisposable} that will cancel the callback when disposed. This wraps
|
|
* [requestIdleCallback] so it will fallback to [setTimeout] if the environment
|
|
* doesn't support it.
|
|
*
|
|
* @param targetWindow The window for which to run the idle callback
|
|
* @param callback The callback to run when idle, this includes an
|
|
* [IdleDeadline] that provides the time alloted for the idle callback by the
|
|
* browser. Not respecting this deadline will result in a degraded user
|
|
* experience.
|
|
* @param timeout A timeout at which point to queue no longer wait for an idle
|
|
* callback but queue it on the regular event loop (like setTimeout). Typically
|
|
* this should not be used.
|
|
*
|
|
* [IdleDeadline]: https://developer.mozilla.org/en-US/docs/Web/API/IdleDeadline
|
|
* [requestIdleCallback]: https://developer.mozilla.org/en-US/docs/Web/API/Window/requestIdleCallback
|
|
* [setTimeout]: https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout
|
|
*/
|
|
export function runWhenWindowIdle(targetWindow, callback, timeout) {
|
|
return _runWhenIdle(targetWindow, callback, timeout);
|
|
}
|
|
/**
|
|
* An implementation of the "idle-until-urgent"-strategy as introduced
|
|
* here: https://philipwalton.com/articles/idle-until-urgent/
|
|
*/
|
|
export class WindowIdleValue extends AbstractIdleValue {
|
|
constructor(targetWindow, executor) {
|
|
super(targetWindow, executor);
|
|
}
|
|
}
|
|
/**
|
|
* 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 let runAtThisOrScheduleAtNextAnimationFrame;
|
|
/**
|
|
* 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 let scheduleAtNextAnimationFrame;
|
|
export class WindowIntervalTimer extends IntervalTimer {
|
|
/**
|
|
*
|
|
* @param node The optional node from which the target window is determined
|
|
*/
|
|
constructor(node) {
|
|
super();
|
|
this.defaultTarget = node && getWindow(node);
|
|
}
|
|
cancelAndSet(runner, interval, targetWindow) {
|
|
return super.cancelAndSet(runner, interval, targetWindow ?? this.defaultTarget);
|
|
}
|
|
}
|
|
class AnimationFrameQueueItem {
|
|
constructor(runner, priority = 0) {
|
|
this._runner = runner;
|
|
this.priority = priority;
|
|
this._canceled = false;
|
|
}
|
|
dispose() {
|
|
this._canceled = true;
|
|
}
|
|
execute() {
|
|
if (this._canceled) {
|
|
return;
|
|
}
|
|
try {
|
|
this._runner();
|
|
}
|
|
catch (e) {
|
|
onUnexpectedError(e);
|
|
}
|
|
}
|
|
// Sort by priority (largest to lowest)
|
|
static sort(a, b) {
|
|
return b.priority - a.priority;
|
|
}
|
|
}
|
|
(function () {
|
|
/**
|
|
* The runners scheduled at the next animation frame
|
|
*/
|
|
const NEXT_QUEUE = new Map();
|
|
/**
|
|
* The runners scheduled at the current animation frame
|
|
*/
|
|
const CURRENT_QUEUE = new Map();
|
|
/**
|
|
* A flag to keep track if the native requestAnimationFrame was already called
|
|
*/
|
|
const animFrameRequested = new Map();
|
|
/**
|
|
* A flag to indicate if currently handling a native requestAnimationFrame callback
|
|
*/
|
|
const inAnimationFrameRunner = new Map();
|
|
const animationFrameRunner = (targetWindowId) => {
|
|
animFrameRequested.set(targetWindowId, false);
|
|
const currentQueue = NEXT_QUEUE.get(targetWindowId) ?? [];
|
|
CURRENT_QUEUE.set(targetWindowId, currentQueue);
|
|
NEXT_QUEUE.set(targetWindowId, []);
|
|
inAnimationFrameRunner.set(targetWindowId, true);
|
|
while (currentQueue.length > 0) {
|
|
currentQueue.sort(AnimationFrameQueueItem.sort);
|
|
const top = currentQueue.shift();
|
|
top.execute();
|
|
}
|
|
inAnimationFrameRunner.set(targetWindowId, false);
|
|
};
|
|
scheduleAtNextAnimationFrame = (targetWindow, runner, priority = 0) => {
|
|
const targetWindowId = getWindowId(targetWindow);
|
|
const item = new AnimationFrameQueueItem(runner, priority);
|
|
let nextQueue = NEXT_QUEUE.get(targetWindowId);
|
|
if (!nextQueue) {
|
|
nextQueue = [];
|
|
NEXT_QUEUE.set(targetWindowId, nextQueue);
|
|
}
|
|
nextQueue.push(item);
|
|
if (!animFrameRequested.get(targetWindowId)) {
|
|
animFrameRequested.set(targetWindowId, true);
|
|
targetWindow.requestAnimationFrame(() => animationFrameRunner(targetWindowId));
|
|
}
|
|
return item;
|
|
};
|
|
runAtThisOrScheduleAtNextAnimationFrame = (targetWindow, runner, priority) => {
|
|
const targetWindowId = getWindowId(targetWindow);
|
|
if (inAnimationFrameRunner.get(targetWindowId)) {
|
|
const item = new AnimationFrameQueueItem(runner, priority);
|
|
let currentQueue = CURRENT_QUEUE.get(targetWindowId);
|
|
if (!currentQueue) {
|
|
currentQueue = [];
|
|
CURRENT_QUEUE.set(targetWindowId, currentQueue);
|
|
}
|
|
currentQueue.push(item);
|
|
return item;
|
|
}
|
|
else {
|
|
return scheduleAtNextAnimationFrame(targetWindow, runner, priority);
|
|
}
|
|
};
|
|
})();
|
|
export function getComputedStyle(el) {
|
|
return getWindow(el).getComputedStyle(el, null);
|
|
}
|
|
export function getClientArea(element, fallback) {
|
|
const elWindow = getWindow(element);
|
|
const elDocument = elWindow.document;
|
|
// Try with DOM clientWidth / clientHeight
|
|
if (element !== elDocument.body) {
|
|
return new Dimension(element.clientWidth, element.clientHeight);
|
|
}
|
|
// If visual view port exits and it's on mobile, it should be used instead of window innerWidth / innerHeight, or document.body.clientWidth / document.body.clientHeight
|
|
if (platform.isIOS && elWindow?.visualViewport) {
|
|
return new Dimension(elWindow.visualViewport.width, elWindow.visualViewport.height);
|
|
}
|
|
// Try innerWidth / innerHeight
|
|
if (elWindow?.innerWidth && elWindow.innerHeight) {
|
|
return new Dimension(elWindow.innerWidth, elWindow.innerHeight);
|
|
}
|
|
// Try with document.body.clientWidth / document.body.clientHeight
|
|
if (elDocument.body && elDocument.body.clientWidth && elDocument.body.clientHeight) {
|
|
return new Dimension(elDocument.body.clientWidth, elDocument.body.clientHeight);
|
|
}
|
|
// Try with document.documentElement.clientWidth / document.documentElement.clientHeight
|
|
if (elDocument.documentElement && elDocument.documentElement.clientWidth && elDocument.documentElement.clientHeight) {
|
|
return new Dimension(elDocument.documentElement.clientWidth, elDocument.documentElement.clientHeight);
|
|
}
|
|
if (fallback) {
|
|
return getClientArea(fallback);
|
|
}
|
|
throw new Error('Unable to figure out browser width and height');
|
|
}
|
|
class SizeUtils {
|
|
// Adapted from WinJS
|
|
// Converts a CSS positioning string for the specified element to pixels.
|
|
static convertToPixels(element, value) {
|
|
return parseFloat(value) || 0;
|
|
}
|
|
static getDimension(element, cssPropertyName, jsPropertyName) {
|
|
const computedStyle = getComputedStyle(element);
|
|
const value = computedStyle ? computedStyle.getPropertyValue(cssPropertyName) : '0';
|
|
return SizeUtils.convertToPixels(element, value);
|
|
}
|
|
static getBorderLeftWidth(element) {
|
|
return SizeUtils.getDimension(element, 'border-left-width', 'borderLeftWidth');
|
|
}
|
|
static getBorderRightWidth(element) {
|
|
return SizeUtils.getDimension(element, 'border-right-width', 'borderRightWidth');
|
|
}
|
|
static getBorderTopWidth(element) {
|
|
return SizeUtils.getDimension(element, 'border-top-width', 'borderTopWidth');
|
|
}
|
|
static getBorderBottomWidth(element) {
|
|
return SizeUtils.getDimension(element, 'border-bottom-width', 'borderBottomWidth');
|
|
}
|
|
static getPaddingLeft(element) {
|
|
return SizeUtils.getDimension(element, 'padding-left', 'paddingLeft');
|
|
}
|
|
static getPaddingRight(element) {
|
|
return SizeUtils.getDimension(element, 'padding-right', 'paddingRight');
|
|
}
|
|
static getPaddingTop(element) {
|
|
return SizeUtils.getDimension(element, 'padding-top', 'paddingTop');
|
|
}
|
|
static getPaddingBottom(element) {
|
|
return SizeUtils.getDimension(element, 'padding-bottom', 'paddingBottom');
|
|
}
|
|
static getMarginLeft(element) {
|
|
return SizeUtils.getDimension(element, 'margin-left', 'marginLeft');
|
|
}
|
|
static getMarginTop(element) {
|
|
return SizeUtils.getDimension(element, 'margin-top', 'marginTop');
|
|
}
|
|
static getMarginRight(element) {
|
|
return SizeUtils.getDimension(element, 'margin-right', 'marginRight');
|
|
}
|
|
static getMarginBottom(element) {
|
|
return SizeUtils.getDimension(element, 'margin-bottom', 'marginBottom');
|
|
}
|
|
}
|
|
export class Dimension {
|
|
static { this.None = new Dimension(0, 0); }
|
|
constructor(width, height) {
|
|
this.width = width;
|
|
this.height = height;
|
|
}
|
|
with(width = this.width, height = this.height) {
|
|
if (width !== this.width || height !== this.height) {
|
|
return new Dimension(width, height);
|
|
}
|
|
else {
|
|
return this;
|
|
}
|
|
}
|
|
static is(obj) {
|
|
return typeof obj === 'object' && typeof obj.height === 'number' && typeof obj.width === 'number';
|
|
}
|
|
static lift(obj) {
|
|
if (obj instanceof Dimension) {
|
|
return obj;
|
|
}
|
|
else {
|
|
return new Dimension(obj.width, obj.height);
|
|
}
|
|
}
|
|
static equals(a, b) {
|
|
if (a === b) {
|
|
return true;
|
|
}
|
|
if (!a || !b) {
|
|
return false;
|
|
}
|
|
return a.width === b.width && a.height === b.height;
|
|
}
|
|
}
|
|
export function getTopLeftOffset(element) {
|
|
// Adapted from WinJS.Utilities.getPosition
|
|
// and added borders to the mix
|
|
let offsetParent = element.offsetParent;
|
|
let top = element.offsetTop;
|
|
let left = element.offsetLeft;
|
|
while ((element = element.parentNode) !== null
|
|
&& element !== element.ownerDocument.body
|
|
&& element !== element.ownerDocument.documentElement) {
|
|
top -= element.scrollTop;
|
|
const c = isShadowRoot(element) ? null : getComputedStyle(element);
|
|
if (c) {
|
|
left -= c.direction !== 'rtl' ? element.scrollLeft : -element.scrollLeft;
|
|
}
|
|
if (element === offsetParent) {
|
|
left += SizeUtils.getBorderLeftWidth(element);
|
|
top += SizeUtils.getBorderTopWidth(element);
|
|
top += element.offsetTop;
|
|
left += element.offsetLeft;
|
|
offsetParent = element.offsetParent;
|
|
}
|
|
}
|
|
return {
|
|
left: left,
|
|
top: top
|
|
};
|
|
}
|
|
export function size(element, width, height) {
|
|
if (typeof width === 'number') {
|
|
element.style.width = `${width}px`;
|
|
}
|
|
if (typeof height === 'number') {
|
|
element.style.height = `${height}px`;
|
|
}
|
|
}
|
|
/**
|
|
* Returns the position of a dom node relative to the entire page.
|
|
*/
|
|
export function getDomNodePagePosition(domNode) {
|
|
const bb = domNode.getBoundingClientRect();
|
|
const window = getWindow(domNode);
|
|
return {
|
|
left: bb.left + window.scrollX,
|
|
top: bb.top + window.scrollY,
|
|
width: bb.width,
|
|
height: bb.height
|
|
};
|
|
}
|
|
/**
|
|
* Returns the effective zoom on a given element before window zoom level is applied
|
|
*/
|
|
export function getDomNodeZoomLevel(domNode) {
|
|
let testElement = domNode;
|
|
let zoom = 1.0;
|
|
do {
|
|
const elementZoomLevel = getComputedStyle(testElement).zoom;
|
|
if (elementZoomLevel !== null && elementZoomLevel !== undefined && elementZoomLevel !== '1') {
|
|
zoom *= elementZoomLevel;
|
|
}
|
|
testElement = testElement.parentElement;
|
|
} while (testElement !== null && testElement !== testElement.ownerDocument.documentElement);
|
|
return zoom;
|
|
}
|
|
// Adapted from WinJS
|
|
// Gets the width of the element, including margins.
|
|
export function getTotalWidth(element) {
|
|
const margin = SizeUtils.getMarginLeft(element) + SizeUtils.getMarginRight(element);
|
|
return element.offsetWidth + margin;
|
|
}
|
|
export function getContentWidth(element) {
|
|
const border = SizeUtils.getBorderLeftWidth(element) + SizeUtils.getBorderRightWidth(element);
|
|
const padding = SizeUtils.getPaddingLeft(element) + SizeUtils.getPaddingRight(element);
|
|
return element.offsetWidth - border - padding;
|
|
}
|
|
// Adapted from WinJS
|
|
// Gets the height of the content of the specified element. The content height does not include borders or padding.
|
|
export function getContentHeight(element) {
|
|
const border = SizeUtils.getBorderTopWidth(element) + SizeUtils.getBorderBottomWidth(element);
|
|
const padding = SizeUtils.getPaddingTop(element) + SizeUtils.getPaddingBottom(element);
|
|
return element.offsetHeight - border - padding;
|
|
}
|
|
// Adapted from WinJS
|
|
// Gets the height of the element, including its margins.
|
|
export function getTotalHeight(element) {
|
|
const margin = SizeUtils.getMarginTop(element) + SizeUtils.getMarginBottom(element);
|
|
return element.offsetHeight + margin;
|
|
}
|
|
// ----------------------------------------------------------------------------------------
|
|
export function isAncestor(testChild, testAncestor) {
|
|
return Boolean(testAncestor?.contains(testChild));
|
|
}
|
|
export function findParentWithClass(node, clazz, stopAtClazzOrNode) {
|
|
while (node && node.nodeType === node.ELEMENT_NODE) {
|
|
if (node.classList.contains(clazz)) {
|
|
return node;
|
|
}
|
|
if (stopAtClazzOrNode) {
|
|
if (typeof stopAtClazzOrNode === 'string') {
|
|
if (node.classList.contains(stopAtClazzOrNode)) {
|
|
return null;
|
|
}
|
|
}
|
|
else {
|
|
if (node === stopAtClazzOrNode) {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
node = node.parentNode;
|
|
}
|
|
return null;
|
|
}
|
|
export function hasParentWithClass(node, clazz, stopAtClazzOrNode) {
|
|
return !!findParentWithClass(node, clazz, stopAtClazzOrNode);
|
|
}
|
|
export function isShadowRoot(node) {
|
|
return (node && !!node.host && !!node.mode);
|
|
}
|
|
export function isInShadowDOM(domNode) {
|
|
return !!getShadowRoot(domNode);
|
|
}
|
|
export function getShadowRoot(domNode) {
|
|
while (domNode.parentNode) {
|
|
if (domNode === domNode.ownerDocument?.body) {
|
|
// reached the body
|
|
return null;
|
|
}
|
|
domNode = domNode.parentNode;
|
|
}
|
|
return isShadowRoot(domNode) ? domNode : null;
|
|
}
|
|
/**
|
|
* Returns the active element across all child windows
|
|
* based on document focus. Falls back to the main
|
|
* window if no window has focus.
|
|
*/
|
|
export function getActiveElement() {
|
|
let result = getActiveDocument().activeElement;
|
|
while (result?.shadowRoot) {
|
|
result = result.shadowRoot.activeElement;
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Returns true if the focused window active element matches
|
|
* the provided element. Falls back to the main window if no
|
|
* window has focus.
|
|
*/
|
|
export function isActiveElement(element) {
|
|
return getActiveElement() === element;
|
|
}
|
|
/**
|
|
* Returns true if the focused window active element is contained in
|
|
* `ancestor`. Falls back to the main window if no window has focus.
|
|
*/
|
|
export function isAncestorOfActiveElement(ancestor) {
|
|
return isAncestor(getActiveElement(), ancestor);
|
|
}
|
|
/**
|
|
* Returns the active document across main and child windows.
|
|
* Prefers the window with focus, otherwise falls back to
|
|
* the main windows document.
|
|
*/
|
|
export function getActiveDocument() {
|
|
if (getWindowsCount() <= 1) {
|
|
return mainWindow.document;
|
|
}
|
|
const documents = Array.from(getWindows()).map(({ window }) => window.document);
|
|
return documents.find(doc => doc.hasFocus()) ?? mainWindow.document;
|
|
}
|
|
/**
|
|
* Returns the active window across main and child windows.
|
|
* Prefers the window with focus, otherwise falls back to
|
|
* the main window.
|
|
*/
|
|
export function getActiveWindow() {
|
|
const document = getActiveDocument();
|
|
return (document.defaultView?.window ?? mainWindow);
|
|
}
|
|
const globalStylesheets = new Map();
|
|
/**
|
|
* A version of createStyleSheet which has a unified API to initialize/set the style content.
|
|
*/
|
|
export function createStyleSheet2() {
|
|
return new WrappedStyleElement();
|
|
}
|
|
class WrappedStyleElement {
|
|
constructor() {
|
|
this._currentCssStyle = '';
|
|
this._styleSheet = undefined;
|
|
}
|
|
setStyle(cssStyle) {
|
|
if (cssStyle === this._currentCssStyle) {
|
|
return;
|
|
}
|
|
this._currentCssStyle = cssStyle;
|
|
if (!this._styleSheet) {
|
|
this._styleSheet = createStyleSheet(mainWindow.document.head, (s) => s.innerText = cssStyle);
|
|
}
|
|
else {
|
|
this._styleSheet.innerText = cssStyle;
|
|
}
|
|
}
|
|
dispose() {
|
|
if (this._styleSheet) {
|
|
this._styleSheet.remove();
|
|
this._styleSheet = undefined;
|
|
}
|
|
}
|
|
}
|
|
export function createStyleSheet(container = mainWindow.document.head, beforeAppend, disposableStore) {
|
|
const style = document.createElement('style');
|
|
style.type = 'text/css';
|
|
style.media = 'screen';
|
|
beforeAppend?.(style);
|
|
container.appendChild(style);
|
|
if (disposableStore) {
|
|
disposableStore.add(toDisposable(() => style.remove()));
|
|
}
|
|
// With <head> as container, the stylesheet becomes global and is tracked
|
|
// to support auxiliary windows to clone the stylesheet.
|
|
if (container === mainWindow.document.head) {
|
|
const globalStylesheetClones = new Set();
|
|
globalStylesheets.set(style, globalStylesheetClones);
|
|
for (const { window: targetWindow, disposables } of getWindows()) {
|
|
if (targetWindow === mainWindow) {
|
|
continue; // main window is already tracked
|
|
}
|
|
const cloneDisposable = disposables.add(cloneGlobalStyleSheet(style, globalStylesheetClones, targetWindow));
|
|
disposableStore?.add(cloneDisposable);
|
|
}
|
|
}
|
|
return style;
|
|
}
|
|
function cloneGlobalStyleSheet(globalStylesheet, globalStylesheetClones, targetWindow) {
|
|
const disposables = new DisposableStore();
|
|
const clone = globalStylesheet.cloneNode(true);
|
|
targetWindow.document.head.appendChild(clone);
|
|
disposables.add(toDisposable(() => clone.remove()));
|
|
for (const rule of getDynamicStyleSheetRules(globalStylesheet)) {
|
|
clone.sheet?.insertRule(rule.cssText, clone.sheet?.cssRules.length);
|
|
}
|
|
disposables.add(sharedMutationObserver.observe(globalStylesheet, disposables, { childList: true })(() => {
|
|
clone.textContent = globalStylesheet.textContent;
|
|
}));
|
|
globalStylesheetClones.add(clone);
|
|
disposables.add(toDisposable(() => globalStylesheetClones.delete(clone)));
|
|
return disposables;
|
|
}
|
|
export const sharedMutationObserver = new class {
|
|
constructor() {
|
|
this.mutationObservers = new Map();
|
|
}
|
|
observe(target, disposables, options) {
|
|
let mutationObserversPerTarget = this.mutationObservers.get(target);
|
|
if (!mutationObserversPerTarget) {
|
|
mutationObserversPerTarget = new Map();
|
|
this.mutationObservers.set(target, mutationObserversPerTarget);
|
|
}
|
|
const optionsHash = hash(options);
|
|
let mutationObserverPerOptions = mutationObserversPerTarget.get(optionsHash);
|
|
if (!mutationObserverPerOptions) {
|
|
const onDidMutate = new event.Emitter();
|
|
const observer = new MutationObserver(mutations => onDidMutate.fire(mutations));
|
|
observer.observe(target, options);
|
|
const resolvedMutationObserverPerOptions = mutationObserverPerOptions = {
|
|
users: 1,
|
|
observer,
|
|
onDidMutate: onDidMutate.event
|
|
};
|
|
disposables.add(toDisposable(() => {
|
|
resolvedMutationObserverPerOptions.users -= 1;
|
|
if (resolvedMutationObserverPerOptions.users === 0) {
|
|
onDidMutate.dispose();
|
|
observer.disconnect();
|
|
mutationObserversPerTarget?.delete(optionsHash);
|
|
if (mutationObserversPerTarget?.size === 0) {
|
|
this.mutationObservers.delete(target);
|
|
}
|
|
}
|
|
}));
|
|
mutationObserversPerTarget.set(optionsHash, mutationObserverPerOptions);
|
|
}
|
|
else {
|
|
mutationObserverPerOptions.users += 1;
|
|
}
|
|
return mutationObserverPerOptions.onDidMutate;
|
|
}
|
|
};
|
|
let _sharedStyleSheet = null;
|
|
function getSharedStyleSheet() {
|
|
if (!_sharedStyleSheet) {
|
|
_sharedStyleSheet = createStyleSheet();
|
|
}
|
|
return _sharedStyleSheet;
|
|
}
|
|
function getDynamicStyleSheetRules(style) {
|
|
if (style?.sheet?.rules) {
|
|
// Chrome, IE
|
|
return style.sheet.rules;
|
|
}
|
|
if (style?.sheet?.cssRules) {
|
|
// FF
|
|
return style.sheet.cssRules;
|
|
}
|
|
return [];
|
|
}
|
|
export function createCSSRule(selector, cssText, style = getSharedStyleSheet()) {
|
|
if (!style || !cssText) {
|
|
return;
|
|
}
|
|
style.sheet?.insertRule(`${selector} {${cssText}}`, 0);
|
|
// Apply rule also to all cloned global stylesheets
|
|
for (const clonedGlobalStylesheet of globalStylesheets.get(style) ?? []) {
|
|
createCSSRule(selector, cssText, clonedGlobalStylesheet);
|
|
}
|
|
}
|
|
export function removeCSSRulesContainingSelector(ruleName, style = getSharedStyleSheet()) {
|
|
if (!style) {
|
|
return;
|
|
}
|
|
const rules = getDynamicStyleSheetRules(style);
|
|
const toDelete = [];
|
|
for (let i = 0; i < rules.length; i++) {
|
|
const rule = rules[i];
|
|
if (isCSSStyleRule(rule) && rule.selectorText.indexOf(ruleName) !== -1) {
|
|
toDelete.push(i);
|
|
}
|
|
}
|
|
for (let i = toDelete.length - 1; i >= 0; i--) {
|
|
style.sheet?.deleteRule(toDelete[i]);
|
|
}
|
|
// Remove rules also from all cloned global stylesheets
|
|
for (const clonedGlobalStylesheet of globalStylesheets.get(style) ?? []) {
|
|
removeCSSRulesContainingSelector(ruleName, clonedGlobalStylesheet);
|
|
}
|
|
}
|
|
function isCSSStyleRule(rule) {
|
|
return typeof rule.selectorText === 'string';
|
|
}
|
|
export function isHTMLElement(e) {
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
return e instanceof HTMLElement || e instanceof getWindow(e).HTMLElement;
|
|
}
|
|
export function isHTMLAnchorElement(e) {
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
return e instanceof HTMLAnchorElement || e instanceof getWindow(e).HTMLAnchorElement;
|
|
}
|
|
export function isSVGElement(e) {
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
return e instanceof SVGElement || e instanceof getWindow(e).SVGElement;
|
|
}
|
|
export function isMouseEvent(e) {
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
return e instanceof MouseEvent || e instanceof getWindow(e).MouseEvent;
|
|
}
|
|
export function isKeyboardEvent(e) {
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
return e instanceof KeyboardEvent || e instanceof getWindow(e).KeyboardEvent;
|
|
}
|
|
export const EventType = {
|
|
// Mouse
|
|
CLICK: 'click',
|
|
AUXCLICK: 'auxclick',
|
|
DBLCLICK: 'dblclick',
|
|
MOUSE_UP: 'mouseup',
|
|
MOUSE_DOWN: 'mousedown',
|
|
MOUSE_OVER: 'mouseover',
|
|
MOUSE_MOVE: 'mousemove',
|
|
MOUSE_OUT: 'mouseout',
|
|
MOUSE_ENTER: 'mouseenter',
|
|
MOUSE_LEAVE: 'mouseleave',
|
|
MOUSE_WHEEL: 'wheel',
|
|
POINTER_UP: 'pointerup',
|
|
POINTER_DOWN: 'pointerdown',
|
|
POINTER_MOVE: 'pointermove',
|
|
POINTER_LEAVE: 'pointerleave',
|
|
CONTEXT_MENU: 'contextmenu',
|
|
WHEEL: 'wheel',
|
|
// Keyboard
|
|
KEY_DOWN: 'keydown',
|
|
KEY_PRESS: 'keypress',
|
|
KEY_UP: 'keyup',
|
|
// HTML Document
|
|
LOAD: 'load',
|
|
BEFORE_UNLOAD: 'beforeunload',
|
|
UNLOAD: 'unload',
|
|
PAGE_SHOW: 'pageshow',
|
|
PAGE_HIDE: 'pagehide',
|
|
PASTE: 'paste',
|
|
ABORT: 'abort',
|
|
ERROR: 'error',
|
|
RESIZE: 'resize',
|
|
SCROLL: 'scroll',
|
|
FULLSCREEN_CHANGE: 'fullscreenchange',
|
|
WK_FULLSCREEN_CHANGE: 'webkitfullscreenchange',
|
|
// Form
|
|
SELECT: 'select',
|
|
CHANGE: 'change',
|
|
SUBMIT: 'submit',
|
|
RESET: 'reset',
|
|
FOCUS: 'focus',
|
|
FOCUS_IN: 'focusin',
|
|
FOCUS_OUT: 'focusout',
|
|
BLUR: 'blur',
|
|
INPUT: 'input',
|
|
// Local Storage
|
|
STORAGE: 'storage',
|
|
// Drag
|
|
DRAG_START: 'dragstart',
|
|
DRAG: 'drag',
|
|
DRAG_ENTER: 'dragenter',
|
|
DRAG_LEAVE: 'dragleave',
|
|
DRAG_OVER: 'dragover',
|
|
DROP: 'drop',
|
|
DRAG_END: 'dragend',
|
|
// Animation
|
|
ANIMATION_START: browser.isWebKit ? 'webkitAnimationStart' : 'animationstart',
|
|
ANIMATION_END: browser.isWebKit ? 'webkitAnimationEnd' : 'animationend',
|
|
ANIMATION_ITERATION: browser.isWebKit ? 'webkitAnimationIteration' : 'animationiteration'
|
|
};
|
|
export function isEventLike(obj) {
|
|
const candidate = obj;
|
|
return !!(candidate && typeof candidate.preventDefault === 'function' && typeof candidate.stopPropagation === 'function');
|
|
}
|
|
export const EventHelper = {
|
|
stop: (e, cancelBubble) => {
|
|
e.preventDefault();
|
|
if (cancelBubble) {
|
|
e.stopPropagation();
|
|
}
|
|
return e;
|
|
}
|
|
};
|
|
export function saveParentsScrollTop(node) {
|
|
const r = [];
|
|
for (let i = 0; node && node.nodeType === node.ELEMENT_NODE; i++) {
|
|
r[i] = node.scrollTop;
|
|
node = node.parentNode;
|
|
}
|
|
return r;
|
|
}
|
|
export function restoreParentsScrollTop(node, state) {
|
|
for (let i = 0; node && node.nodeType === node.ELEMENT_NODE; i++) {
|
|
if (node.scrollTop !== state[i]) {
|
|
node.scrollTop = state[i];
|
|
}
|
|
node = node.parentNode;
|
|
}
|
|
}
|
|
class FocusTracker extends Disposable {
|
|
static hasFocusWithin(element) {
|
|
if (isHTMLElement(element)) {
|
|
const shadowRoot = getShadowRoot(element);
|
|
const activeElement = (shadowRoot ? shadowRoot.activeElement : element.ownerDocument.activeElement);
|
|
return isAncestor(activeElement, element);
|
|
}
|
|
else {
|
|
const window = element;
|
|
return isAncestor(window.document.activeElement, window.document);
|
|
}
|
|
}
|
|
constructor(element) {
|
|
super();
|
|
this._onDidFocus = this._register(new event.Emitter());
|
|
this.onDidFocus = this._onDidFocus.event;
|
|
this._onDidBlur = this._register(new event.Emitter());
|
|
this.onDidBlur = this._onDidBlur.event;
|
|
let hasFocus = FocusTracker.hasFocusWithin(element);
|
|
let loosingFocus = false;
|
|
const onFocus = () => {
|
|
loosingFocus = false;
|
|
if (!hasFocus) {
|
|
hasFocus = true;
|
|
this._onDidFocus.fire();
|
|
}
|
|
};
|
|
const onBlur = () => {
|
|
if (hasFocus) {
|
|
loosingFocus = true;
|
|
(isHTMLElement(element) ? getWindow(element) : element).setTimeout(() => {
|
|
if (loosingFocus) {
|
|
loosingFocus = false;
|
|
hasFocus = false;
|
|
this._onDidBlur.fire();
|
|
}
|
|
}, 0);
|
|
}
|
|
};
|
|
this._refreshStateHandler = () => {
|
|
const currentNodeHasFocus = FocusTracker.hasFocusWithin(element);
|
|
if (currentNodeHasFocus !== hasFocus) {
|
|
if (hasFocus) {
|
|
onBlur();
|
|
}
|
|
else {
|
|
onFocus();
|
|
}
|
|
}
|
|
};
|
|
this._register(addDisposableListener(element, EventType.FOCUS, onFocus, true));
|
|
this._register(addDisposableListener(element, EventType.BLUR, onBlur, true));
|
|
if (isHTMLElement(element)) {
|
|
this._register(addDisposableListener(element, EventType.FOCUS_IN, () => this._refreshStateHandler()));
|
|
this._register(addDisposableListener(element, EventType.FOCUS_OUT, () => this._refreshStateHandler()));
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Creates a new `IFocusTracker` instance that tracks focus changes on the given `element` and its descendants.
|
|
*
|
|
* @param element The `HTMLElement` or `Window` to track focus changes on.
|
|
* @returns An `IFocusTracker` instance.
|
|
*/
|
|
export function trackFocus(element) {
|
|
return new FocusTracker(element);
|
|
}
|
|
export function after(sibling, child) {
|
|
sibling.after(child);
|
|
return child;
|
|
}
|
|
export function append(parent, ...children) {
|
|
parent.append(...children);
|
|
if (children.length === 1 && typeof children[0] !== 'string') {
|
|
return children[0];
|
|
}
|
|
}
|
|
export function prepend(parent, child) {
|
|
parent.insertBefore(child, parent.firstChild);
|
|
return child;
|
|
}
|
|
/**
|
|
* Removes all children from `parent` and appends `children`
|
|
*/
|
|
export function reset(parent, ...children) {
|
|
parent.innerText = '';
|
|
append(parent, ...children);
|
|
}
|
|
const SELECTOR_REGEX = /([\w\-]+)?(#([\w\-]+))?((\.([\w\-]+))*)/;
|
|
export var Namespace;
|
|
(function (Namespace) {
|
|
Namespace["HTML"] = "http://www.w3.org/1999/xhtml";
|
|
Namespace["SVG"] = "http://www.w3.org/2000/svg";
|
|
})(Namespace || (Namespace = {}));
|
|
function _$(namespace, description, attrs, ...children) {
|
|
const match = SELECTOR_REGEX.exec(description);
|
|
if (!match) {
|
|
throw new Error('Bad use of emmet');
|
|
}
|
|
const tagName = match[1] || 'div';
|
|
let result;
|
|
if (namespace !== Namespace.HTML) {
|
|
result = document.createElementNS(namespace, tagName);
|
|
}
|
|
else {
|
|
result = document.createElement(tagName);
|
|
}
|
|
if (match[3]) {
|
|
result.id = match[3];
|
|
}
|
|
if (match[4]) {
|
|
result.className = match[4].replace(/\./g, ' ').trim();
|
|
}
|
|
if (attrs) {
|
|
Object.entries(attrs).forEach(([name, value]) => {
|
|
if (typeof value === 'undefined') {
|
|
return;
|
|
}
|
|
if (/^on\w+$/.test(name)) {
|
|
result[name] = value;
|
|
}
|
|
else if (name === 'selected') {
|
|
if (value) {
|
|
result.setAttribute(name, 'true');
|
|
}
|
|
}
|
|
else {
|
|
result.setAttribute(name, value);
|
|
}
|
|
});
|
|
}
|
|
result.append(...children);
|
|
return result;
|
|
}
|
|
export function $(description, attrs, ...children) {
|
|
return _$(Namespace.HTML, description, attrs, ...children);
|
|
}
|
|
$.SVG = function (description, attrs, ...children) {
|
|
return _$(Namespace.SVG, description, attrs, ...children);
|
|
};
|
|
export function setVisibility(visible, ...elements) {
|
|
if (visible) {
|
|
show(...elements);
|
|
}
|
|
else {
|
|
hide(...elements);
|
|
}
|
|
}
|
|
export function show(...elements) {
|
|
for (const element of elements) {
|
|
element.style.display = '';
|
|
element.removeAttribute('aria-hidden');
|
|
}
|
|
}
|
|
export function hide(...elements) {
|
|
for (const element of elements) {
|
|
element.style.display = 'none';
|
|
element.setAttribute('aria-hidden', 'true');
|
|
}
|
|
}
|
|
/**
|
|
* 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 function computeScreenAwareSize(window, cssPx) {
|
|
const screenPx = window.devicePixelRatio * cssPx;
|
|
return Math.max(1, Math.floor(screenPx)) / window.devicePixelRatio;
|
|
}
|
|
/**
|
|
* Open safely a new window. This is the best way to do so, but you cannot tell
|
|
* if the window was opened or if it was blocked by the browser's popup blocker.
|
|
* If you want to tell if the browser blocked the new window, use {@link windowOpenWithSuccess}.
|
|
*
|
|
* 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 function windowOpenNoOpener(url) {
|
|
// By using 'noopener' in the `windowFeatures` argument, the newly created window will
|
|
// not be able to use `window.opener` to reach back to the current page.
|
|
// See https://stackoverflow.com/a/46958731
|
|
// See https://developer.mozilla.org/en-US/docs/Web/API/Window/open#noopener
|
|
// However, this also doesn't allow us to realize if the browser blocked
|
|
// the creation of the window.
|
|
mainWindow.open(url, '_blank', 'noopener');
|
|
}
|
|
export function animate(targetWindow, fn) {
|
|
const step = () => {
|
|
fn();
|
|
stepDisposable = scheduleAtNextAnimationFrame(targetWindow, step);
|
|
};
|
|
let stepDisposable = scheduleAtNextAnimationFrame(targetWindow, step);
|
|
return toDisposable(() => stepDisposable.dispose());
|
|
}
|
|
RemoteAuthorities.setPreferredWebSchema(/^https:/.test(mainWindow.location.href) ? 'https' : 'http');
|
|
/**
|
|
* returns url('...')
|
|
*/
|
|
export function asCSSUrl(uri) {
|
|
if (!uri) {
|
|
return `url('')`;
|
|
}
|
|
return `url('${FileAccess.uriToBrowserUri(uri).toString(true).replace(/'/g, '%27')}')`;
|
|
}
|
|
export function asCSSPropertyValue(value) {
|
|
return `'${value.replace(/'/g, '%27')}'`;
|
|
}
|
|
export function asCssValueWithDefault(cssPropertyValue, dflt) {
|
|
if (cssPropertyValue !== undefined) {
|
|
const variableMatch = cssPropertyValue.match(/^\s*var\((.+)\)$/);
|
|
if (variableMatch) {
|
|
const varArguments = variableMatch[1].split(',', 2);
|
|
if (varArguments.length === 2) {
|
|
dflt = asCssValueWithDefault(varArguments[1].trim(), dflt);
|
|
}
|
|
return `var(${varArguments[0]}, ${dflt})`;
|
|
}
|
|
return cssPropertyValue;
|
|
}
|
|
return dflt;
|
|
}
|
|
// -- sanitize and trusted html
|
|
/**
|
|
* Hooks dompurify using `afterSanitizeAttributes` to check that all `href` and `src`
|
|
* attributes are valid.
|
|
*/
|
|
export function hookDomPurifyHrefAndSrcSanitizer(allowedProtocols, allowDataImages = false) {
|
|
// https://github.com/cure53/DOMPurify/blob/main/demos/hooks-scheme-allowlist.html
|
|
// build an anchor to map URLs to
|
|
const anchor = document.createElement('a');
|
|
dompurify.addHook('afterSanitizeAttributes', (node) => {
|
|
// check all href/src attributes for validity
|
|
for (const attr of ['href', 'src']) {
|
|
if (node.hasAttribute(attr)) {
|
|
const attrValue = node.getAttribute(attr);
|
|
if (attr === 'href' && attrValue.startsWith('#')) {
|
|
// Allow fragment links
|
|
continue;
|
|
}
|
|
anchor.href = attrValue;
|
|
if (!allowedProtocols.includes(anchor.protocol.replace(/:$/, ''))) {
|
|
if (allowDataImages && attr === 'src' && anchor.href.startsWith('data:')) {
|
|
continue;
|
|
}
|
|
node.removeAttribute(attr);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
return toDisposable(() => {
|
|
dompurify.removeHook('afterSanitizeAttributes');
|
|
});
|
|
}
|
|
/**
|
|
* List of safe, non-input html tags.
|
|
*/
|
|
export const basicMarkupHtmlTags = Object.freeze([
|
|
'a',
|
|
'abbr',
|
|
'b',
|
|
'bdo',
|
|
'blockquote',
|
|
'br',
|
|
'caption',
|
|
'cite',
|
|
'code',
|
|
'col',
|
|
'colgroup',
|
|
'dd',
|
|
'del',
|
|
'details',
|
|
'dfn',
|
|
'div',
|
|
'dl',
|
|
'dt',
|
|
'em',
|
|
'figcaption',
|
|
'figure',
|
|
'h1',
|
|
'h2',
|
|
'h3',
|
|
'h4',
|
|
'h5',
|
|
'h6',
|
|
'hr',
|
|
'i',
|
|
'img',
|
|
'input',
|
|
'ins',
|
|
'kbd',
|
|
'label',
|
|
'li',
|
|
'mark',
|
|
'ol',
|
|
'p',
|
|
'pre',
|
|
'q',
|
|
'rp',
|
|
'rt',
|
|
'ruby',
|
|
'samp',
|
|
'small',
|
|
'small',
|
|
'source',
|
|
'span',
|
|
'strike',
|
|
'strong',
|
|
'sub',
|
|
'summary',
|
|
'sup',
|
|
'table',
|
|
'tbody',
|
|
'td',
|
|
'tfoot',
|
|
'th',
|
|
'thead',
|
|
'time',
|
|
'tr',
|
|
'tt',
|
|
'u',
|
|
'ul',
|
|
'var',
|
|
'video',
|
|
'wbr',
|
|
]);
|
|
const defaultDomPurifyConfig = Object.freeze({
|
|
ALLOWED_TAGS: ['a', 'button', 'blockquote', 'code', 'div', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'input', 'label', 'li', 'p', 'pre', 'select', 'small', 'span', 'strong', 'textarea', 'ul', 'ol'],
|
|
ALLOWED_ATTR: ['href', 'data-href', 'data-command', 'target', 'title', 'name', 'src', 'alt', 'class', 'id', 'role', 'tabindex', 'style', 'data-code', 'width', 'height', 'align', 'x-dispatch', 'required', 'checked', 'placeholder', 'type', 'start'],
|
|
RETURN_DOM: false,
|
|
RETURN_DOM_FRAGMENT: false,
|
|
RETURN_TRUSTED_TYPE: true
|
|
});
|
|
export class ModifierKeyEmitter extends event.Emitter {
|
|
constructor() {
|
|
super();
|
|
this._subscriptions = new DisposableStore();
|
|
this._keyStatus = {
|
|
altKey: false,
|
|
shiftKey: false,
|
|
ctrlKey: false,
|
|
metaKey: false
|
|
};
|
|
this._subscriptions.add(event.Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => this.registerListeners(window, disposables), { window: mainWindow, disposables: this._subscriptions }));
|
|
}
|
|
registerListeners(window, disposables) {
|
|
disposables.add(addDisposableListener(window, 'keydown', e => {
|
|
if (e.defaultPrevented) {
|
|
return;
|
|
}
|
|
const event = new StandardKeyboardEvent(e);
|
|
// If Alt-key keydown event is repeated, ignore it #112347
|
|
// Only known to be necessary for Alt-Key at the moment #115810
|
|
if (event.keyCode === 6 /* KeyCode.Alt */ && e.repeat) {
|
|
return;
|
|
}
|
|
if (e.altKey && !this._keyStatus.altKey) {
|
|
this._keyStatus.lastKeyPressed = 'alt';
|
|
}
|
|
else if (e.ctrlKey && !this._keyStatus.ctrlKey) {
|
|
this._keyStatus.lastKeyPressed = 'ctrl';
|
|
}
|
|
else if (e.metaKey && !this._keyStatus.metaKey) {
|
|
this._keyStatus.lastKeyPressed = 'meta';
|
|
}
|
|
else if (e.shiftKey && !this._keyStatus.shiftKey) {
|
|
this._keyStatus.lastKeyPressed = 'shift';
|
|
}
|
|
else if (event.keyCode !== 6 /* KeyCode.Alt */) {
|
|
this._keyStatus.lastKeyPressed = undefined;
|
|
}
|
|
else {
|
|
return;
|
|
}
|
|
this._keyStatus.altKey = e.altKey;
|
|
this._keyStatus.ctrlKey = e.ctrlKey;
|
|
this._keyStatus.metaKey = e.metaKey;
|
|
this._keyStatus.shiftKey = e.shiftKey;
|
|
if (this._keyStatus.lastKeyPressed) {
|
|
this._keyStatus.event = e;
|
|
this.fire(this._keyStatus);
|
|
}
|
|
}, true));
|
|
disposables.add(addDisposableListener(window, 'keyup', e => {
|
|
if (e.defaultPrevented) {
|
|
return;
|
|
}
|
|
if (!e.altKey && this._keyStatus.altKey) {
|
|
this._keyStatus.lastKeyReleased = 'alt';
|
|
}
|
|
else if (!e.ctrlKey && this._keyStatus.ctrlKey) {
|
|
this._keyStatus.lastKeyReleased = 'ctrl';
|
|
}
|
|
else if (!e.metaKey && this._keyStatus.metaKey) {
|
|
this._keyStatus.lastKeyReleased = 'meta';
|
|
}
|
|
else if (!e.shiftKey && this._keyStatus.shiftKey) {
|
|
this._keyStatus.lastKeyReleased = 'shift';
|
|
}
|
|
else {
|
|
this._keyStatus.lastKeyReleased = undefined;
|
|
}
|
|
if (this._keyStatus.lastKeyPressed !== this._keyStatus.lastKeyReleased) {
|
|
this._keyStatus.lastKeyPressed = undefined;
|
|
}
|
|
this._keyStatus.altKey = e.altKey;
|
|
this._keyStatus.ctrlKey = e.ctrlKey;
|
|
this._keyStatus.metaKey = e.metaKey;
|
|
this._keyStatus.shiftKey = e.shiftKey;
|
|
if (this._keyStatus.lastKeyReleased) {
|
|
this._keyStatus.event = e;
|
|
this.fire(this._keyStatus);
|
|
}
|
|
}, true));
|
|
disposables.add(addDisposableListener(window.document.body, 'mousedown', () => {
|
|
this._keyStatus.lastKeyPressed = undefined;
|
|
}, true));
|
|
disposables.add(addDisposableListener(window.document.body, 'mouseup', () => {
|
|
this._keyStatus.lastKeyPressed = undefined;
|
|
}, true));
|
|
disposables.add(addDisposableListener(window.document.body, 'mousemove', e => {
|
|
if (e.buttons) {
|
|
this._keyStatus.lastKeyPressed = undefined;
|
|
}
|
|
}, true));
|
|
disposables.add(addDisposableListener(window, 'blur', () => {
|
|
this.resetKeyStatus();
|
|
}));
|
|
}
|
|
get keyStatus() {
|
|
return this._keyStatus;
|
|
}
|
|
/**
|
|
* Allows to explicitly reset the key status based on more knowledge (#109062)
|
|
*/
|
|
resetKeyStatus() {
|
|
this.doResetKeyStatus();
|
|
this.fire(this._keyStatus);
|
|
}
|
|
doResetKeyStatus() {
|
|
this._keyStatus = {
|
|
altKey: false,
|
|
shiftKey: false,
|
|
ctrlKey: false,
|
|
metaKey: false
|
|
};
|
|
}
|
|
static getInstance() {
|
|
if (!ModifierKeyEmitter.instance) {
|
|
ModifierKeyEmitter.instance = new ModifierKeyEmitter();
|
|
}
|
|
return ModifierKeyEmitter.instance;
|
|
}
|
|
dispose() {
|
|
super.dispose();
|
|
this._subscriptions.dispose();
|
|
}
|
|
}
|
|
export class DragAndDropObserver extends Disposable {
|
|
constructor(element, callbacks) {
|
|
super();
|
|
this.element = element;
|
|
this.callbacks = callbacks;
|
|
// A helper to fix issues with repeated DRAG_ENTER / DRAG_LEAVE
|
|
// calls see https://github.com/microsoft/vscode/issues/14470
|
|
// when the element has child elements where the events are fired
|
|
// repeadedly.
|
|
this.counter = 0;
|
|
// Allows to measure the duration of the drag operation.
|
|
this.dragStartTime = 0;
|
|
this.registerListeners();
|
|
}
|
|
registerListeners() {
|
|
if (this.callbacks.onDragStart) {
|
|
this._register(addDisposableListener(this.element, EventType.DRAG_START, (e) => {
|
|
this.callbacks.onDragStart?.(e);
|
|
}));
|
|
}
|
|
if (this.callbacks.onDrag) {
|
|
this._register(addDisposableListener(this.element, EventType.DRAG, (e) => {
|
|
this.callbacks.onDrag?.(e);
|
|
}));
|
|
}
|
|
this._register(addDisposableListener(this.element, EventType.DRAG_ENTER, (e) => {
|
|
this.counter++;
|
|
this.dragStartTime = e.timeStamp;
|
|
this.callbacks.onDragEnter?.(e);
|
|
}));
|
|
this._register(addDisposableListener(this.element, EventType.DRAG_OVER, (e) => {
|
|
e.preventDefault(); // needed so that the drop event fires (https://stackoverflow.com/questions/21339924/drop-event-not-firing-in-chrome)
|
|
this.callbacks.onDragOver?.(e, e.timeStamp - this.dragStartTime);
|
|
}));
|
|
this._register(addDisposableListener(this.element, EventType.DRAG_LEAVE, (e) => {
|
|
this.counter--;
|
|
if (this.counter === 0) {
|
|
this.dragStartTime = 0;
|
|
this.callbacks.onDragLeave?.(e);
|
|
}
|
|
}));
|
|
this._register(addDisposableListener(this.element, EventType.DRAG_END, (e) => {
|
|
this.counter = 0;
|
|
this.dragStartTime = 0;
|
|
this.callbacks.onDragEnd?.(e);
|
|
}));
|
|
this._register(addDisposableListener(this.element, EventType.DROP, (e) => {
|
|
this.counter = 0;
|
|
this.dragStartTime = 0;
|
|
this.callbacks.onDrop?.(e);
|
|
}));
|
|
}
|
|
}
|
|
const H_REGEX = /(?<tag>[\w\-]+)?(?:#(?<id>[\w\-]+))?(?<class>(?:\.(?:[\w\-]+))*)(?:@(?<name>(?:[\w\_])+))?/;
|
|
export function h(tag, ...args) {
|
|
let attributes;
|
|
let children;
|
|
if (Array.isArray(args[0])) {
|
|
attributes = {};
|
|
children = args[0];
|
|
}
|
|
else {
|
|
attributes = args[0] || {};
|
|
children = args[1];
|
|
}
|
|
const match = H_REGEX.exec(tag);
|
|
if (!match || !match.groups) {
|
|
throw new Error('Bad use of h');
|
|
}
|
|
const tagName = match.groups['tag'] || 'div';
|
|
const el = document.createElement(tagName);
|
|
if (match.groups['id']) {
|
|
el.id = match.groups['id'];
|
|
}
|
|
const classNames = [];
|
|
if (match.groups['class']) {
|
|
for (const className of match.groups['class'].split('.')) {
|
|
if (className !== '') {
|
|
classNames.push(className);
|
|
}
|
|
}
|
|
}
|
|
if (attributes.className !== undefined) {
|
|
for (const className of attributes.className.split('.')) {
|
|
if (className !== '') {
|
|
classNames.push(className);
|
|
}
|
|
}
|
|
}
|
|
if (classNames.length > 0) {
|
|
el.className = classNames.join(' ');
|
|
}
|
|
const result = {};
|
|
if (match.groups['name']) {
|
|
result[match.groups['name']] = el;
|
|
}
|
|
if (children) {
|
|
for (const c of children) {
|
|
if (isHTMLElement(c)) {
|
|
el.appendChild(c);
|
|
}
|
|
else if (typeof c === 'string') {
|
|
el.append(c);
|
|
}
|
|
else if ('root' in c) {
|
|
Object.assign(result, c);
|
|
el.appendChild(c.root);
|
|
}
|
|
}
|
|
}
|
|
for (const [key, value] of Object.entries(attributes)) {
|
|
if (key === 'className') {
|
|
continue;
|
|
}
|
|
else if (key === 'style') {
|
|
for (const [cssKey, cssValue] of Object.entries(value)) {
|
|
el.style.setProperty(camelCaseToHyphenCase(cssKey), typeof cssValue === 'number' ? cssValue + 'px' : '' + cssValue);
|
|
}
|
|
}
|
|
else if (key === 'tabIndex') {
|
|
el.tabIndex = value;
|
|
}
|
|
else {
|
|
el.setAttribute(camelCaseToHyphenCase(key), value.toString());
|
|
}
|
|
}
|
|
result['root'] = el;
|
|
return result;
|
|
}
|
|
export function svgElem(tag, ...args) {
|
|
let attributes;
|
|
let children;
|
|
if (Array.isArray(args[0])) {
|
|
attributes = {};
|
|
children = args[0];
|
|
}
|
|
else {
|
|
attributes = args[0] || {};
|
|
children = args[1];
|
|
}
|
|
const match = H_REGEX.exec(tag);
|
|
if (!match || !match.groups) {
|
|
throw new Error('Bad use of h');
|
|
}
|
|
const tagName = match.groups['tag'] || 'div';
|
|
const el = document.createElementNS('http://www.w3.org/2000/svg', tagName);
|
|
if (match.groups['id']) {
|
|
el.id = match.groups['id'];
|
|
}
|
|
const classNames = [];
|
|
if (match.groups['class']) {
|
|
for (const className of match.groups['class'].split('.')) {
|
|
if (className !== '') {
|
|
classNames.push(className);
|
|
}
|
|
}
|
|
}
|
|
if (attributes.className !== undefined) {
|
|
for (const className of attributes.className.split('.')) {
|
|
if (className !== '') {
|
|
classNames.push(className);
|
|
}
|
|
}
|
|
}
|
|
if (classNames.length > 0) {
|
|
el.className = classNames.join(' ');
|
|
}
|
|
const result = {};
|
|
if (match.groups['name']) {
|
|
result[match.groups['name']] = el;
|
|
}
|
|
if (children) {
|
|
for (const c of children) {
|
|
if (isHTMLElement(c)) {
|
|
el.appendChild(c);
|
|
}
|
|
else if (typeof c === 'string') {
|
|
el.append(c);
|
|
}
|
|
else if ('root' in c) {
|
|
Object.assign(result, c);
|
|
el.appendChild(c.root);
|
|
}
|
|
}
|
|
}
|
|
for (const [key, value] of Object.entries(attributes)) {
|
|
if (key === 'className') {
|
|
continue;
|
|
}
|
|
else if (key === 'style') {
|
|
for (const [cssKey, cssValue] of Object.entries(value)) {
|
|
el.style.setProperty(camelCaseToHyphenCase(cssKey), typeof cssValue === 'number' ? cssValue + 'px' : '' + cssValue);
|
|
}
|
|
}
|
|
else if (key === 'tabIndex') {
|
|
el.tabIndex = value;
|
|
}
|
|
else {
|
|
el.setAttribute(camelCaseToHyphenCase(key), value.toString());
|
|
}
|
|
}
|
|
result['root'] = el;
|
|
return result;
|
|
}
|
|
function camelCaseToHyphenCase(str) {
|
|
return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
|
|
}
|