Dieses Skript sollte nicht direkt installiert werden. Es handelt sich hier um eine Bibliothek für andere Skripte, welche über folgenden Befehl in den Metadaten eines Skriptes eingebunden wird // @require https://update.greasyfork.org/scripts/474549/1263250/akkd-common.js
// ==UserScript==
// #region Info
// @namespace https://greasyfork.org/en/users/1123632-93akkord
// @exclude *
// @author Michael Barros (https://greasyfork.org/en/users/1123632-93akkord)
// @icon data:image/png;base64,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
// #endregion Info
// ==UserLibrary==
// @name akkd-common
// @description Common functions
// @copyright 2022+, Michael Barros (https://greasyfork.org/en/users/1123632-93akkord)
// @license CC-BY-NC-SA-4.0; https://creativecommons.org/licenses/by-nc-sa/4.0/legalcode
// @license GPL-3.0-or-later; https://www.gnu.org/licenses/gpl-3.0.txt
// @version 0.0.20
// ==/UserScript==
// ==/UserLibrary==
// ==OpenUserJS==
// @author 93Akkord
// ==/OpenUserJS==
/// <reference path='C:/Users/mbarros/Documents/DevProjects/Web/Tampermonkey/Palantir/@types/__fullReferencePaths__.js' />
/*
# akkd-common
A collection of commonly used classes and functions.
## Required requires:
- https://code.jquery.com/jquery-3.2.1.min.js
- https://greasyfork.org/scripts/474546-loglevel/code/loglevel.js
*/
// #region Events
// Setup location change events
/**
*
* Example usage:
* ```javascript
* window.addEventListener('popstate', () => {
* window.dispatchEvent(new Event('locationchange'));
* });
*/
(() => {
class LocationChangeEvent extends Event {
constructor(type, prevUrl, newUrl) {
super(type);
this.prevUrl = prevUrl;
this.newUrl = newUrl;
}
}
let prevUrl = document.location.href;
let oldPushState = history.pushState;
history.pushState = function pushState() {
let ret = oldPushState.apply(this, arguments);
let newUrl = document.location.href;
window.dispatchEvent(new LocationChangeEvent('pushstate', prevUrl, newUrl));
window.dispatchEvent(new LocationChangeEvent('locationchange', prevUrl, newUrl));
prevUrl = newUrl;
return ret;
};
let oldReplaceState = history.replaceState;
history.replaceState = function replaceState() {
let ret = oldReplaceState.apply(this, arguments);
let newUrl = document.location.href;
window.dispatchEvent(new LocationChangeEvent('replacestate', prevUrl, newUrl));
window.dispatchEvent(new LocationChangeEvent('locationchange', prevUrl, newUrl));
prevUrl = newUrl;
return ret;
};
window.addEventListener('popstate', () => {
let newUrl = document.location.href;
window.dispatchEvent(new LocationChangeEvent('locationchange', prevUrl, newUrl));
prevUrl = newUrl;
});
})();
// #endregion Events
// #region Helper Classes
class Logger {
/**
* Creates an instance of Logger.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Window} _window
* @param {string | null} devTag
* @memberof Logger
*/
constructor(_window = null, devTag = null) {
/**
* @type {Window}
* @private
*/
this.window = _window || getWindow();
/** @type {string | null} */
this.devTag = devTag;
/** @type {string[]} */
this._additionalTags = [];
}
/**
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @type {string[]}
* @public
* @memberof Logger
*/
get additionalTags() {
return this._additionalTags;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string[]} value
* @memberof Logger
*/
set additionalTags(value) {
if (getType(value) != 'array') {
value = [value];
}
this._additionalTags = value;
}
/** @type {string} */
get label() {
return [].concat([this.devTag], this.additionalTags).join(' ');
}
/** @type {(...data: any[]) => void} */
get log() {
if (this.devTag) {
return console.log.bind(console, `${this.label}`);
} else {
return console.log.bind(console);
}
}
/** @type {(...data: any[]) => void} */
get info() {
if (this.devTag) {
return console.info.bind(console, `${this.label}`);
} else {
return console.info.bind(console);
}
}
/** @type {(...data: any[]) => void} */
get error() {
if (this.devTag) {
return console.error.bind(console, `${this.label}`);
} else {
return console.error.bind(console);
}
}
/** @type {(...data: any[]) => void} */
get debug() {
if (this.devTag) {
return console.debug.bind(console, `${this.label}`);
} else {
return console.debug.bind(console);
}
}
/** @type {(...data: any[]) => void} */
get warn() {
if (this.devTag) {
return console.warn.bind(console, `${this.label}`);
} else {
return console.warn.bind(console);
}
}
/**
* Maybe use later?
*
* @memberof Logger
*/
_setupFunctions() {
let self = this;
let funcs = ['log', 'info', 'error', 'debug', 'warn'];
for (let i = 0; i < funcs.length; i++) {
let func = funcs[i];
self[func] = function () {
let args = [...arguments];
if (self.devTag) args.unshift(self.label);
self.window.console.debug.bind(self.window.console, ...args);
};
}
}
}
class Base64 {
static keyStr = 'ABCDEFGHIJKLMNOP' + 'QRSTUVWXYZabcdef' + 'ghijklmnopqrstuv' + 'wxyz0123456789+/' + '=';
/**
*
*
* @static
* @param {string} input
* @returns {string}
* @memberof Base64
*/
static encode(input) {
input = escape(input);
let output = '';
let chr1;
let chr2;
let chr3 = '';
let enc1;
let enc2;
let enc3;
let enc4 = '';
let i = 0;
do {
chr1 = input.charCodeAt(i++);
chr2 = input.charCodeAt(i++);
chr3 = input.charCodeAt(i++);
enc1 = chr1 >> 2;
enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
enc4 = chr3 & 63;
if (isNaN(chr2)) {
enc3 = enc4 = 64;
} else if (isNaN(chr3)) {
enc4 = 64;
}
output = output + Base64.keyStr.charAt(enc1) + Base64.keyStr.charAt(enc2) + Base64.keyStr.charAt(enc3) + Base64.keyStr.charAt(enc4);
chr1 = chr2 = chr3 = '';
enc1 = enc2 = enc3 = enc4 = '';
} while (i < input.length);
return output;
}
/**
*
*
* @static
* @param {string} input
* @returns {string}
* @memberof Base64
*/
static decode(input) {
let output = '';
let chr1;
let chr2;
let chr3 = '';
let enc1;
let enc2;
let enc3;
let enc4 = '';
let i = 0;
let base64test = /[^A-Za-z0-9\+\/\=]/g;
if (base64test.exec(input)) {
throw new Error(`There were invalid base64 characters in the input text. Valid base64 characters are: ['A-Z', 'a-z', '0-9,' '+', '/', '=']`);
}
input = input.replace(/[^A-Za-z0-9\+\/\=]/g, '');
do {
enc1 = Base64.keyStr.indexOf(input.charAt(i++));
enc2 = Base64.keyStr.indexOf(input.charAt(i++));
enc3 = Base64.keyStr.indexOf(input.charAt(i++));
enc4 = Base64.keyStr.indexOf(input.charAt(i++));
chr1 = (enc1 << 2) | (enc2 >> 4);
chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
chr3 = ((enc3 & 3) << 6) | enc4;
output = output + String.fromCharCode(chr1);
if (enc3 != 64) output = output + String.fromCharCode(chr2);
if (enc4 != 64) output = output + String.fromCharCode(chr3);
chr1 = chr2 = chr3 = '';
enc1 = enc2 = enc3 = enc4 = '';
} while (i < input.length);
return unescape(output);
}
}
class MultiRegExp {
constructor(baseRegExp) {
const { regexp, groupIndexMapper, previousGroupsForGroup } = this._fillGroups(baseRegExp);
this.regexp = regexp;
this.groupIndexMapper = groupIndexMapper;
this.previousGroupsForGroup = previousGroupsForGroup;
}
execForAllGroups(str, includeFullMatch) {
let matches = RegExp.prototype.exec.call(this.regexp, str);
if (!matches) return matches;
let firstIndex = matches.index;
let indexMapper = includeFullMatch
? Object.assign(
{
0: 0,
},
this.groupIndexMapper
)
: this.groupIndexMapper;
let previousGroups = includeFullMatch
? Object.assign(
{
0: [],
},
this.previousGroupsForGroup
)
: this.previousGroupsForGroup;
let res = Object.keys(indexMapper).map((group) => {
let mapped = indexMapper[group];
let match = matches[mapped];
let start = firstIndex + previousGroups[group].reduce((sum, i) => sum + (matches[i] ? matches[i].length : 0), 0);
let end = start + (matches[mapped] ? matches[mapped].length : 0);
let lineColumnStart = LineColumnFinder(str).fromIndex(start);
let lineColumnEnd = LineColumnFinder(str).fromIndex(end - 1);
return {
match,
start,
end,
startLineNumber: lineColumnStart.line,
startColumnNumber: lineColumnStart.col,
endLineNumber: lineColumnEnd.line,
endColumnNumber: lineColumnEnd.col,
};
});
return res;
}
execForGroup(string, group) {
const matches = RegExp.prototype.exec.call(this.regexp, string);
if (!matches) return matches;
const firstIndex = matches.index;
const mapped = group == 0 ? 0 : this.groupIndexMapper[group];
const previousGroups = group == 0 ? [] : this.previousGroupsForGroup[group];
let r = {
match: matches[mapped],
start: firstIndex + previousGroups.reduce((sum, i) => sum + (matches[i] ? matches[i].length : 0), 0),
};
r.end = r.start + (matches[mapped] ? matches[mapped].length : 0);
return r;
}
/**
* Adds brackets before and after a part of string
* @param str string the hole regex string
* @param start int marks the position where ( should be inserted
* @param end int marks the position where ) should be inserted
* @param groupsAdded int defines the offset to the original string because of inserted brackets
* @return {string}
*/
_addGroupToRegexString(str, start, end, groupsAdded) {
start += groupsAdded * 2;
end += groupsAdded * 2;
return str.substring(0, start) + '(' + str.substring(start, end + 1) + ')' + str.substring(end + 1);
}
/**
* converts the given regex to a regex where all not captured string are going to be captured
* it along sides generates a mapper which maps the original group index to the shifted group offset and
* generates a list of groups indexes (including new generated capturing groups)
* which have been closed before a given group index (unshifted)
*
* Example:
* regexp: /a(?: )bc(def(ghi)xyz)/g => /(a(?: )bc)((def)(ghi)(xyz))/g
* groupIndexMapper: {'1': 2, '2', 4}
* previousGroupsForGroup: {'1': [1], '2': [1, 3]}
*
* @param regex RegExp
* @return {{regexp: RegExp, groupIndexMapper: {}, previousGroupsForGroup: {}}}
*/
_fillGroups(regex) {
let regexString;
let modifier;
if (regex.source && regex.flags) {
regexString = regex.source;
modifier = regex.flags;
} else {
regexString = regex.toString();
modifier = regexString.substring(regexString.lastIndexOf(regexString[0]) + 1); // sometimes order matters ;)
regexString = regexString.substr(1, regex.toString().lastIndexOf(regexString[0]) - 1);
}
// regexp is greedy so it should match (? before ( right?
// brackets may be not quoted by \
// closing bracket may look like: ), )+, )+?, ){1,}?, ){1,1111}?
const tester = /(\\\()|(\\\))|(\(\?)|(\()|(\)(?:\{\d+,?\d*}|[*+?])?\??)/g;
let modifiedRegex = regexString;
let lastGroupStartPosition = -1;
let lastGroupEndPosition = -1;
let lastNonGroupStartPosition = -1;
let lastNonGroupEndPosition = -1;
let groupsAdded = 0;
let groupCount = 0;
let matchArr;
const nonGroupPositions = [];
const groupPositions = [];
const groupNumber = [];
let currentLengthIndexes = [];
const groupIndexMapper = {};
const previousGroupsForGroup = {};
while ((matchArr = tester.exec(regexString)) !== null) {
if (matchArr[1] || matchArr[2]) {
// ignore escaped brackets \(, \)
}
if (matchArr[3]) {
// non capturing group (?
let index = matchArr.index + matchArr[0].length - 1;
lastNonGroupStartPosition = index;
nonGroupPositions.push(index);
} else if (matchArr[4]) {
// capturing group (
let index = matchArr.index + matchArr[0].length - 1;
let lastGroupPosition = Math.max(lastGroupStartPosition, lastGroupEndPosition);
// if a (? is found add ) before it
if (lastNonGroupStartPosition > lastGroupPosition) {
// check if between ) of capturing group lies a non capturing group
if (lastGroupPosition < lastNonGroupEndPosition) {
// add groups for x1 and x2 on (?:()x1)x2(?:...
if (lastNonGroupEndPosition - 1 - (lastGroupPosition + 1) > 0) {
modifiedRegex = this._addGroupToRegexString(modifiedRegex, lastGroupPosition + 1, lastNonGroupEndPosition - 1, groupsAdded);
groupsAdded++;
lastGroupEndPosition = lastNonGroupEndPosition - 1; // imaginary position as it is not in regex but modifiedRegex
currentLengthIndexes.push(groupCount + groupsAdded);
}
if (lastNonGroupStartPosition - 1 - (lastNonGroupEndPosition + 1) > 0) {
modifiedRegex = this._addGroupToRegexString(modifiedRegex, lastNonGroupEndPosition + 1, lastNonGroupStartPosition - 2, groupsAdded);
groupsAdded++;
lastGroupEndPosition = lastNonGroupStartPosition - 1; // imaginary position as it is not in regex but modifiedRegex
currentLengthIndexes.push(groupCount + groupsAdded);
}
} else {
modifiedRegex = this._addGroupToRegexString(modifiedRegex, lastGroupPosition + 1, lastNonGroupStartPosition - 2, groupsAdded);
groupsAdded++;
lastGroupEndPosition = lastNonGroupStartPosition - 1; // imaginary position as it is not in regex but modifiedRegex
currentLengthIndexes.push(groupCount + groupsAdded);
}
// if necessary also add group between (? and opening bracket
if (index > lastNonGroupStartPosition + 2) {
modifiedRegex = this._addGroupToRegexString(modifiedRegex, lastNonGroupStartPosition + 2, index - 1, groupsAdded);
groupsAdded++;
lastGroupEndPosition = index - 1; // imaginary position as it is not in regex but modifiedRegex
currentLengthIndexes.push(groupCount + groupsAdded);
}
} else if (lastGroupPosition < index - 1) {
modifiedRegex = this._addGroupToRegexString(modifiedRegex, lastGroupPosition + 1, index - 1, groupsAdded);
groupsAdded++;
lastGroupEndPosition = index - 1; // imaginary position as it is not in regex but modifiedRegex
currentLengthIndexes.push(groupCount + groupsAdded);
}
groupCount++;
lastGroupStartPosition = index;
groupPositions.push(index);
groupNumber.push(groupCount + groupsAdded);
groupIndexMapper[groupCount] = groupCount + groupsAdded;
previousGroupsForGroup[groupCount] = currentLengthIndexes.slice();
} else if (matchArr[5]) {
// closing bracket ), )+, )+?, ){1,}?, ){1,1111}?
let index = matchArr.index + matchArr[0].length - 1;
if ((groupPositions.length && !nonGroupPositions.length) || groupPositions[groupPositions.length - 1] > nonGroupPositions[nonGroupPositions.length - 1]) {
if (lastGroupStartPosition < lastGroupEndPosition && lastGroupEndPosition < index - 1) {
modifiedRegex = this._addGroupToRegexString(modifiedRegex, lastGroupEndPosition + 1, index - 1, groupsAdded);
groupsAdded++;
//lastGroupEndPosition = index - 1; will be set anyway
currentLengthIndexes.push(groupCount + groupsAdded);
}
groupPositions.pop();
lastGroupEndPosition = index;
let toPush = groupNumber.pop();
currentLengthIndexes.push(toPush);
currentLengthIndexes = currentLengthIndexes.filter((index) => index <= toPush);
} else if (nonGroupPositions.length) {
nonGroupPositions.pop();
lastNonGroupEndPosition = index;
}
}
}
return {
regexp: new RegExp(modifiedRegex, modifier),
groupIndexMapper,
previousGroupsForGroup,
};
}
}
class MoveableElement {
/**
* Creates an instance of MoveableElement.
* @param {HTMLElement} element
* @param {boolean} requireKeyDown
* @memberof MoveableElement
*/
constructor(element, requireKeyDown) {
this.element = element;
this.requireKeyDown = requireKeyDown || false;
this.handleMouseDown = this.handleMouseDown.bind(this);
this.handleMouseUp = this.handleMouseUp.bind(this);
this.handleMouseMove = this.handleMouseMove.bind(this);
this.moving = false;
this.keyPressed = false;
this.originalCursor = getStyle(this.element, 'cursor');
this.setupEvents();
}
setupEvents() {
if (!document.body) {
setTimeout(() => {
this.setupEvents();
}, 250);
} else {
document.body.addEventListener('keydown', (ev) => {
if (ev.which == '17') {
this.keyPressed = true;
}
});
document.body.addEventListener('keyup', (ev) => {
this.keyPressed = false;
});
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {MouseEvent} ev
* @memberof MoveableElement
*/
handleMouseDown(ev) {
if (this.keyPressed || !this.requireKeyDown) {
ev.preventDefault();
this.element.style.cursor = 'move';
this.changePointerEvents('none');
document.body.removeEventListener('mouseup', this.handleMouseUp);
document.body.addEventListener('mouseup', this.handleMouseUp);
document.body.removeEventListener('mousemove', this.handleMouseMove);
document.body.removeEventListener('mouseleave', this.handleMouseUp);
document.body.addEventListener('mousemove', this.handleMouseMove);
document.body.addEventListener('mouseleave', this.handleMouseUp);
try {
document.querySelectorAll('iframe')[0].style.pointerEvents = 'none';
} catch (error) {}
}
}
changePointerEvents(value) {
for (let i = 0; i < this.element.children.length; i++) {
const child = this.element.children[i];
child.style.pointerEvents = value;
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {MouseEvent} ev
* @memberof MoveableElement
*/
handleMouseUp(ev) {
this.moving = false;
this.element.style.cursor = this.originalCursor;
this.changePointerEvents('auto');
document.body.removeEventListener('mouseup', this.handleMouseUp);
document.body.removeEventListener('mousemove', this.handleMouseMove);
document.body.removeEventListener('mouseleave', this.handleMouseUp);
try {
document.querySelectorAll('iframe')[0].style.pointerEvents = '';
} catch (error) {}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {MouseEvent} ev
* @memberof MoveableElement
*/
handleMouseMove(ev) {
this.moving = true;
let top = ev.clientY - getStyle(this.element, 'height') / 2;
let bottom = ev.clientX - getStyle(this.element, 'width') / 2;
this.element.style.top = `${top}px`;
this.element.style.left = `${bottom}px`;
}
padCoord(coord) {
return coord.toString().padStart(5, ' ');
}
init() {
this.element.addEventListener('mousedown', this.handleMouseDown);
}
}
class CurrentLine {
/**
* @typedef ILineInfo
* @prop {string} method
* @prop {number} line
* @prop {string} file
* @prop {string} filename
*/
/**
* Returns a single item
*
* @param {number} [level] Useful to return levels up on the stack. If not informed, the first (0, zero index) element of the stack will be returned
* @returns {ILineInfo}
*/
get(level = 0) {
const stack = getStack();
const i = Math.min(level + 1, stack.length - 1);
const item = stack[i];
const result = CurrentLine.parse(item);
return result;
}
/**
* Returns all stack
*
* @returns {ILineInfo[]}
*/
all() {
const stack = getStack();
const result = [];
for (let i = 1; i < stack.length; i++) {
const item = stack[i];
result.push(CurrentLine.parse(item));
}
return result;
}
/**
*
*
* @param {NodeJS.CallSite} item
* @returns {ILineInfo}
*/
static parse(item) {
const result = {
method: item.getMethodName() || item.getFunctionName(),
line: item.getLineNumber(),
file: item.getFileName() || item.getScriptNameOrSourceURL(),
};
result.filename = result.file ? result.file.replace(/^.*\/|\\/gm, '').replace(/\.\w+$/gm, '') : null;
return result;
}
}
/**
*
*
* @returns {NodeJS.CallSite[]}
*/
function getStack() {
const orig = Error.prepareStackTrace;
Error.prepareStackTrace = function (_, stack) {
return stack;
};
const err = new Error();
Error.captureStackTrace(err, arguments.callee);
const stack = err.stack;
Error.prepareStackTrace = orig;
return stack;
}
class ProgressTimer {
/**
* Creates an instance of ProgressTimer.
* @param {number} total
* @memberof ProgressTimer
*/
constructor(total) {
this.startTime;
this.total = total;
this.loaded = 0;
this.estimatedFinishDt = '';
this.progressMessage = '';
}
/**
*
*
* @memberof ProgressTimer
*/
start() {
this.startTime = new Date();
}
/**
*
*
* @param {number} loaded
* @param {string} msg
* @memberof ProgressTimer
*/
updateProgress(loaded, msg) {
this.loaded = loaded;
this.progress = `${((this.loaded * 100) / this.total).toFixed(2)}%`;
this.timeRemaining = this._estimatedTimeRemaining(this.startTime, this.loaded, this.total);
this.downloaded = `${this.loaded}/${this.total}`;
this.completionTime = `${this._dateToISOLikeButLocal(this.estimatedFinishDt)}`;
this.totalRuntime = `${this._ms2Timestamp(this.timeTaken)}`;
this.updateProgressMessage(msg);
this.printProgress();
}
/**
*
*
* @param {string} msg
* @memberof ProgressTimer
*/
updateProgressMessage(msg) {
let msgLines = [];
msgLines.push(` completed: ${this.progress}`);
msgLines.push(` downloaded: ${this.downloaded}`);
msgLines.push(` total runtime: ${this.totalRuntime}`);
msgLines.push(` time remaining: ${this.timeRemaining}`);
msgLines.push(`completion time: ${this.completionTime}`);
if (msg) {
msgLines.push(msg);
}
this.progressMessage = msgLines.join('\n');
}
/**
*
*
* @memberof ProgressTimer
*/
printProgress() {
console.clear();
console.debug(this.progressMessage);
}
/**
*
*
* @param {Date} startTime
* @param {number} itemsProcessed
* @param {number} totalItems
* @returns {string}
* @memberof ProgressTimer
*/
_estimatedTimeRemaining(startTime, itemsProcessed, totalItems) {
// if (itemsProcessed == 0) {
// return '';
// }
let currentTime = new Date();
this.timeTaken = currentTime - startTime;
this.timeLeft = itemsProcessed == 0 ? this.timeTaken * (totalItems - itemsProcessed) : (this.timeTaken / itemsProcessed) * (totalItems - itemsProcessed);
this.estimatedFinishDt = new Date(currentTime.getTime() + this.timeLeft);
return this._ms2Timestamp(this.timeLeft);
}
/**
*
*
* @param {number} ms
* @returns {string}
* @memberof ProgressTimer
*/
_ms2Timestamp(ms) {
// 1- Convert to seconds:
let seconds = ms / 1000;
// 2- Extract hours:
let hours = parseInt(seconds / 3600); // 3,600 seconds in 1 hour
seconds = seconds % 3600; // seconds remaining after extracting hours
// 3- Extract minutes:
let minutes = parseInt(seconds / 60); // 60 seconds in 1 minute
// 4- Keep only seconds not extracted to minutes:
seconds = seconds % 60;
let parts = seconds.toString().split('.');
seconds = parseInt(parts[0]);
let milliseconds = parts.length > 1 ? parts[1].substring(0, 3).padEnd(3, 0) : '000';
hours = hours.toString().padStart(2, '0');
minutes = minutes.toString().padStart(2, '0');
seconds = seconds.toString().padStart(2, '0');
return `${hours}:${minutes}:${seconds}.${milliseconds}`; // hours + ':' + minutes + ':' + seconds;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Date} date
* @returns {string}
* @memberof ProgressTimer
*/
_dateToISOLikeButLocal(date) {
let offsetMs = date.getTimezoneOffset() * 60 * 1000;
let msLocal = date.getTime() - offsetMs;
let dateLocal = new Date(msLocal);
let iso = dateLocal.toISOString();
let isoLocal = iso.slice(0, 19);
return isoLocal.replace(/T/g, ' ');
}
}
class Benchmark {
constructor({ logger, printResults } = {}) {
this.namedPerformances = {};
this.defaultName = 'default';
this.logger = logger;
this.printResults = printResults == undefined ? (this.logger ? true : false) : printResults;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string=} name
* @memberof Benchmark
*/
start(name) {
name = name || this.defaultName;
this.namedPerformances[name] = {
startAt: this._hrtime(),
};
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string=} name
* @memberof Benchmark
*/
stop(name) {
name = name || this.defaultName;
const startAt = this.namedPerformances[name] && this.namedPerformances[name].startAt;
if (!startAt) throw new Error(`Namespace: ${name} doesnt exist`);
const diff = this._hrtime(startAt);
const time = diff[0] * 1e3 + diff[1] * 1e-6;
const words = this.getWords(diff);
const preciseWords = this.getPreciseWords(diff);
const verboseWords = this.getVerboseWords(diff);
const verboseAbbrWords = this.getVerboseAbbrWords(diff);
if (this.printResults) {
let output = name != 'default' ? `[${name}] execution time:` : `execution time:`;
this.logger(output, time); // words
}
return {
name,
time,
words,
preciseWords,
verboseWords,
verboseAbbrWords,
diff,
};
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {T} func
* @param {{name: string, measure: boolean}=} { name, measure }
* @returns {T}
* @memberof Benchmark
* @template T
*/
wrapFunc(func, { name, measure = true } = {}) {
name = this._getFuncName(func, name);
let self = this;
wrappedFunc.measure = measure;
wrappedFunc.benchmark = {
name,
results: {
runs: [],
avg: null,
min: null,
max: null,
total: null,
times: null,
runCount: 0,
},
reset: function () {
this.results.runs = [];
this.results.avg = null;
this.results.min = null;
this.results.max = null;
this.results.total = null;
this.results.times = null;
this.results.runCount = 0;
},
printResults: function (logger = console.debug) {
let output = this.name != 'default' ? `[${this.name}] execution summary:` : `execution summary:`;
let times = wrappedFunc.benchmark.results.runs.map((run) => {
return run.time;
});
wrappedFunc.benchmark.results.times = times;
wrappedFunc.benchmark.results.avg = self._getAvgTime(times);
wrappedFunc.benchmark.results.total = self._getSumTime(times);
wrappedFunc.benchmark.results.min = Math.min(...times);
wrappedFunc.benchmark.results.max = Math.max(...times);
logger(output, `times: ${this.results.runCount} total: ${self.getWords(this.results.total)} min: ${self.getWords(this.results.min)} max: ${self.getWords(this.results.max)} avg: ${self.getWords(this.results.avg)} total: ${self.getWords(this.results.total)}`);
},
};
function wrappedFunc() {
if (wrappedFunc.measure) {
self.start(name);
}
let res = func(...arguments);
if (wrappedFunc.measure) {
wrappedFunc.benchmark.results.runCount++;
wrappedFunc.benchmark.results.runs.push(self.stop(name));
}
return res;
}
return this._defineWrappedFuncProperties(wrappedFunc, name);
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {T} func
* @param {{name: string, measure: boolean}=} { name, measure }
* @returns {T}
* @memberof Benchmark
* @template T
*/
wrapAsyncFunc(func, { name, measure = true } = {}) {
name = this._getFuncName(func, name);
let self = this;
wrappedFunc.measure = measure;
wrappedFunc.benchmark = {
name,
results: {
runs: [],
avg: null,
min: null,
max: null,
total: null,
times: null,
runCount: 0,
},
reset: function () {
this.results.runs = [];
this.results.avg = null;
this.results.min = null;
this.results.max = null;
this.results.total = null;
this.results.times = null;
this.results.runCount = 0;
},
printResults: function (logger = console.debug) {
let output = this.name != 'default' ? `[${this.name}] execution summary:` : `execution summary:`;
let times = wrappedFunc.benchmark.results.runs.map((run) => {
return run.time;
});
wrappedFunc.benchmark.results.times = times;
wrappedFunc.benchmark.results.avg = self._getAvgTime(times);
wrappedFunc.benchmark.results.total = self._getSumTime(times);
wrappedFunc.benchmark.results.min = Math.min(...times);
wrappedFunc.benchmark.results.max = Math.max(...times);
logger(output, `times: ${this.results.runCount} total: ${self.getWords(this.results.total)} min: ${self.getWords(this.results.min)} max: ${self.getWords(this.results.max)} avg: ${self.getWords(this.results.avg)} total: ${self.getWords(this.results.total)}`);
},
};
async function wrappedFunc() {
if (wrappedFunc.measure) {
self.start(name);
}
let res = await func(...arguments);
if (wrappedFunc.measure) {
wrappedFunc.benchmark.results.runCount++;
wrappedFunc.benchmark.results.runs.push(self.stop(name));
}
return res;
}
return this._defineWrappedFuncProperties(wrappedFunc, name);
}
getWords(diff) {
let ms = typeof diff === 'number' ? diff : this._hrtime2Ms(diff);
return this._msToHms(ms);
// return this._prettyHrtime(diff);
}
getPreciseWords(diff) {
return this._prettyHrtime(diff, { precise: true });
}
getVerboseWords(diff) {
return this._prettyHrtime(diff, { verbose: true });
}
getVerboseAbbrWords(diff) {
return this._prettyHrtime(diff, { verbose: true, verboseAbbrv: true, precise: true });
}
_msToHms(ms) {
// Extract days
let days = Math.floor(ms / (86400 * 1000));
ms %= (86400 * 1000);
// Extract hours
let hours = Math.floor(ms / (3600 * 1000));
ms %= (3600 * 1000);
// Extract minutes
let minutes = Math.floor(ms / (60 * 1000));
ms = ms % (60 * 1000);
// Extract seconds
let seconds = Math.floor(ms / 1000);
ms = ms % 1000;
let result = [];
if (days > 0) {
result.push(`${days} day${days === 1 ? '' : 's'}`);
}
if (hours > 0) {
result.push(`${hours} hr${hours === 1 ? '' : 's'}`);
}
if (minutes > 0) {
result.push(`${minutes} min${minutes === 1 ? '' : 's'}`);
}
if (seconds > 0) {
result.push(`${seconds} sec${seconds === 1 ? '' : 's'}`);
}
if (ms > 0) {
result.push(`${ms} ms`);
}
return result.join(', ');
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number[][]} times
* @returns {number}
*/
_getAvgTime(times) {
return this._getSumTime(times) / times.length;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number[][]} times
* @returns {number}
*/
_getSumTime(times) {
return times.reduce((a, b) => a + b);
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number} ms
* @returns {number[][]}
* @memberof Benchmark
*/
_ms2Hrtime(ms) {
let seconds = Math.round(ms / 1000);
let nanoSeconds = Math.round(ms * 1000000 - seconds * 1000000 * 1000);
return [seconds, nanoSeconds];
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {[number, number]} hrtime
* @returns {number}
* @memberof Benchmark
*/
_hrtime2Ms(hrtime) {
return hrtime[0] * 1000 + hrtime[1] / 1000000;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {T} func
* @param {string=} name
* @returns {T}
* @memberof Benchmark
* @template T
*/
_getFuncName(func, name) {
return name ? name : 'name' in func && func.name.trim() !== '' ? func.name : '[wrapped.func]';
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Function} wrappedFunc
* @param {string} name
* @returns {Function}
* @memberof Benchmark
*/
_defineWrappedFuncProperties(wrappedFunc, name) {
Object.defineProperty(wrappedFunc, 'name', {
value: name,
writable: false,
configurable: false,
enumerable: false,
});
Object.defineProperty(wrappedFunc, 'toString', {
value: () => func.toString(),
writable: false,
configurable: false,
enumerable: false,
});
return wrappedFunc;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {[number, number]=} time
* @returns {[number, number]}
* @memberof Benchmark
*/
_hrtime(time) {
if (typeof process !== 'undefined') return process.hrtime(time);
var performance = typeof performance !== 'undefined' ? performance : {};
let performanceNow = performance.now || performance.mozNow || performance.msNow || performance.oNow || performance.webkitNow || (() => new Date().getTime());
let clocktime = performanceNow.call(performance) * 1e-3;
let seconds = Math.floor(clocktime);
let nanoseconds = Math.floor((clocktime % 1) * 1e9);
if (time) {
seconds = seconds - time[0];
nanoseconds = nanoseconds - time[1];
if (nanoseconds < 0) {
seconds--;
nanoseconds += 1e9;
}
}
return [seconds, nanoseconds];
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {[number, number]=} time
* @param {{verbose: boolean; verboseAbbrv: boolean; precise: boolean}} { verbose = false, verboseAbbrv = false, precise = false }
* @returns {string}
* @memberof Benchmark
*/
_prettyHrtime(time, { verbose = false, verboseAbbrv = false, precise = false } = {}) {
let i, spot, sourceAtStep, valAtStep, decimals, strAtStep, results, totalSeconds;
let minimalDesc = ['h', 'min', 's', 'ms', 'μs', 'ns'];
let verboseDesc = !verboseAbbrv ? ['hour', 'minute', 'second', 'millisecond', 'microsecond', 'nanosecond'] : minimalDesc;
let convert = [60 * 60, 60, 1, 1e6, 1e3, 1];
if (typeof time === 'number') {
time = this._ms2Hrtime(time);
}
if (!Array.isArray(time) || time.length !== 2) return '';
if (typeof time[0] !== 'number' || typeof time[1] !== 'number') return '';
// normalize source array due to changes in node v5.4+
if (time[1] < 0) {
totalSeconds = time[0] + time[1] / 1e9;
time[0] = parseInt(totalSeconds);
time[1] = parseFloat((totalSeconds % 1).toPrecision(9)) * 1e9;
}
results = '';
for (i = 0; i < 6; i++) {
// grabbing first or second spot in source array
spot = i < 3 ? 0 : 1;
sourceAtStep = time[spot];
if (i !== 3 && i !== 0) {
// trim off previous portions
sourceAtStep = sourceAtStep % convert[i - 1];
}
if (i === 2) {
// get partial seconds from other portion of the array
sourceAtStep += time[1] / 1e9;
}
// val at this unit
valAtStep = sourceAtStep / convert[i];
if (valAtStep >= 1) {
if (verbose) {
// deal in whole units, subsequent laps will get the decimal portion
valAtStep = Math.floor(valAtStep);
}
if (!precise) {
// don't fling too many decimals
decimals = valAtStep >= 10 ? 0 : 2;
strAtStep = valAtStep.toFixed(decimals);
} else {
strAtStep = valAtStep.toString();
}
if (strAtStep.indexOf('.') > -1 && strAtStep[strAtStep.length - 1] === '0') {
// remove trailing zeros
strAtStep = strAtStep.replace(/\.?0+$/, '');
}
if (results) {
// append space if we have a previous value
results += ' ';
}
// append the value
results += strAtStep;
// append units
if (verbose) {
results += verboseAbbrv ? `${verboseDesc[i]}` : ` ${verboseDesc[i]}`;
if (!verboseAbbrv && strAtStep !== '1') {
results += 's';
}
} else {
results += ` ${minimalDesc[i]}`;
}
if (!verbose) {
// verbose gets as many groups as necessary, the rest get only one
break;
}
}
}
return results;
}
}
class ArrayStat {
/**
* Creates an instance of ArrayStat.
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number[]} array
* @memberof ArrayStat
*/
constructor(array) {
this.array = array;
}
_getCloned() {
return this.array.slice(0);
}
min() {
return Math.min.apply(null, this.array);
}
max() {
return Math.max.apply(null, this.array);
}
range() {
return this.max(this.array) - this.min(this.array);
}
midrange() {
return this.range(this.array) / 2;
}
sum(array) {
array = array || this.array;
let total = 0;
for (let i = 0, l = array.length; i < l; i++) total += array[i];
return total;
}
mean(array) {
array = array || this.array;
return this.sum(array) / array.length;
}
median() {
let array = this._getCloned();
array.sort(function (a, b) {
return a - b;
});
let mid = array.length / 2;
return mid % 1 ? array[mid - 0.5] : (array[mid - 1] + array[mid]) / 2;
}
modes() {
if (!this.array.length) return [];
let modeMap = {};
let maxCount = 0;
let modes = [];
this.array.forEach(function (val) {
if (!modeMap[val]) modeMap[val] = 1;
else modeMap[val]++;
if (modeMap[val] > maxCount) {
modes = [val];
maxCount = modeMap[val];
} else if (modeMap[val] === maxCount) {
modes.push(val);
maxCount = modeMap[val];
}
});
return modes;
}
letiance() {
let mean = this.mean();
return this.mean(
this._getCloned().map(function (num) {
return Math.pow(num - mean, 2);
})
);
}
standardDeviation() {
return Math.sqrt(this.letiance());
}
meanAbsoluteDeviation() {
let mean = this.mean();
return this.mean(
this._getCloned().map(function (num) {
return Math.abs(num - mean);
})
);
}
zScores() {
let mean = this.mean();
let standardDeviation = this.standardDeviation();
return this._getCloned().map(function (num) {
return (num - mean) / standardDeviation;
});
}
withinStd(val, stdev) {
let low = this.mean() - stdev * this.standardDeviation(); // x.deviation;
let hi = this.mean() + stdev * this.standardDeviation(); // x.deviation;
let res = val > low && val < hi;
console.log(`val: ${val.toString().padEnd(5, ' ')} mean: ${this.mean()} stdev: ${this.standardDeviation()} hi: ${hi} low: ${low} res: ${res}`);
return res;
}
}
memoizeClass(ArrayStat);
let LineColumnFinder = (function LineColumnFinder() {
let isArray = Array.isArray;
let isObject = (val) => val != null && typeof val === 'object' && Array.isArray(val) === false;
let slice = Array.prototype.slice;
/**
* Finder for index and line-column from given string.
*
* You can call this without `new` operator as it returns an instance anyway.
*
* @class
* @param {string} str - A string to be parsed.
* @param {Object|number} [options] - Options.
* This can be an index in the string for shorthand of `lineColumn(str, index)`.
* @param {number} [options.origin=1] - The origin value of line and column.
*/
function LineColumnFinder(str, options) {
if (!(this instanceof LineColumnFinder)) {
if (typeof options === 'number') {
return new LineColumnFinder(str).fromIndex(options);
}
return new LineColumnFinder(str, options);
}
this.str = str || '';
this.lineToIndex = buildLineToIndex(this.str);
options = options || {};
this.origin = typeof options.origin === 'undefined' ? 1 : options.origin;
}
/**
* Find line and column from index in the string.
*
* @param {number} index - Index in the string. (0-origin)
* @return {Object|null}
* Found line number and column number in object `{ line: X, col: Y }`.
* If the given index is out of range, it returns `null`.
*/
LineColumnFinder.prototype.fromIndex = function (index) {
if (index < 0 || index >= this.str.length || isNaN(index)) {
return null;
}
let line = findLowerIndexInRangeArray(index, this.lineToIndex);
return {
line: line + this.origin,
col: index - this.lineToIndex[line] + this.origin,
};
};
/**
* Find index from line and column in the string.
*
* @param {number|Object|Array} line - Line number in the string.
* This can be an Object of `{ line: X, col: Y }`, or
* an Array of `[line, col]`.
* @param {number} [column] - Column number in the string.
* This must be omitted or undefined when Object or Array is given
* to the first argument.
* @return {number}
* Found index in the string. (always 0-origin)
* If the given line or column is out of range, it returns `-1`.
*/
LineColumnFinder.prototype.toIndex = function (line, column) {
if (typeof column === 'undefined') {
if (isArray(line) && line.length >= 2) {
return this.toIndex(line[0], line[1]);
}
if (isObject(line) && 'line' in line && ('col' in line || 'column' in line)) {
return this.toIndex(line.line, 'col' in line ? line.col : line.column);
}
return -1;
}
if (isNaN(line) || isNaN(column)) {
return -1;
}
line -= this.origin;
column -= this.origin;
if (line >= 0 && column >= 0 && line < this.lineToIndex.length) {
let lineIndex = this.lineToIndex[line];
let nextIndex = line === this.lineToIndex.length - 1 ? this.str.length : this.lineToIndex[line + 1];
if (column < nextIndex - lineIndex) {
return lineIndex + column;
}
}
return -1;
};
/**
* Build an array of indexes of each line from a string.
*
* @private
* @param str {string} An input string.
* @return {number[]} Built array of indexes. The key is line number.
*/
function buildLineToIndex(str) {
let lines = str.split('\n');
let lineToIndex = new Array(lines.length);
let index = 0;
for (let i = 0, l = lines.length; i < l; i++) {
lineToIndex[i] = index;
index += lines[i].length + /* "\n".length */ 1;
}
return lineToIndex;
}
/**
* Find a lower-bound index of a value in a sorted array of ranges.
*
* Assume `arr = [0, 5, 10, 15, 20]` and
* this returns `1` for `value = 7` (5 <= value < 10),
* and returns `3` for `value = 18` (15 <= value < 20).
*
* @private
* @param arr {number[]} An array of values representing ranges.
* @param value {number} A value to be searched.
* @return {number} Found index. If not found `-1`.
*/
function findLowerIndexInRangeArray(value, arr) {
if (value >= arr[arr.length - 1]) {
return arr.length - 1;
}
let min = 0,
max = arr.length - 2,
mid;
while (min < max) {
mid = min + ((max - min) >> 1);
if (value < arr[mid]) {
max = mid - 1;
} else if (value >= arr[mid + 1]) {
min = mid + 1;
} else {
// value >= arr[mid] && value < arr[mid + 1]
min = mid;
break;
}
}
return min;
}
return LineColumnFinder;
})();
class CustomContextMenu {
/**
* Example menuItems
*
* ```javascript
* let menuItems = [
* {
* type: 'item',
* label: 'Test1',
* onClick: () => {
* alert('test1');
* },
* },
* {
* type: 'item',
* label: 'Test2',
* onClick: () => {
* console.debug('test2');
* },
* },
* {
* type: 'break',
* },
* {
* type: 'item',
* label: 'Test3',
* onClick: () => {
* console.debug('test3');
* },
* },
* ];
* ```
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {HTMLElement} elemToAttachTo
* @param {*} menuItems
* @memberof CustomContextMenu
*/
constructor(elemToAttachTo, menuItems, onContextMenu) {
this.elem = elemToAttachTo;
this.menuItems = menuItems;
this.menu = null;
this.onContextMenu = onContextMenu;
this._createMenu();
this._setupEvents();
this.hide = debounce(this.hide.bind(this), 500, true);
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number} top
* @param {number} left
* @memberof CustomContextMenu
*/
show(top, left) {
document.body.appendChild(this.menu);
this.menu.style.display = 'block';
this.menu.style.top = `${top}px`;
this.menu.style.left = `${left}px`;
this.menu.setAttribute('tabindex', '0');
this.menu.focus();
}
hide() {
this.menu.style.display = 'none';
if (document.body.contains(this.menu)) {
this.menu.remove();
}
}
_setupEvents() {
this.elem.addEventListener('contextmenu', (ev) => {
ev.preventDefault();
if (this.onContextMenu) {
this.onContextMenu(ev);
}
this.show(ev.pageY, ev.pageX);
});
document.addEventListener('click', (ev) => {
if (document.body.contains(this.menu) && !this._isHover(this.menu)) {
this.hide();
}
});
window.addEventListener('blur', (ev) => {
this.hide();
});
this.menu.addEventListener('blur', (ev) => {
this.hide();
});
}
_createMenu() {
this.menu = this._createMenuContainer();
for (let i = 0; i < this.menuItems.length; i++) {
let itemConfig = this.menuItems[i];
switch (itemConfig.type) {
case 'item':
this.menu.appendChild(this._createItem(itemConfig));
break;
case 'break':
this.menu.appendChild(this._createBreak());
break;
default:
break;
}
}
// document.body.appendChild(this.menu);
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @returns {HTMLElement}
* @memberof CustomContextMenu
*/
_createMenuContainer() {
let html = `<div class="context" hidden></div>`;
let elem = this._createElementsFromHTML(html);
return elem;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {*} itemConfig
* @returns {HTMLElement}
* @memberof CustomContextMenu
*/
_createItem(itemConfig) {
let html = `<div class="context_item">
<div class="inner_item">
${itemConfig.label}
</div>
</div>`;
let elem = this._createElementsFromHTML(html);
if (itemConfig.id) {
elem.id = itemConfig.id;
}
if (itemConfig.onClick) {
elem.addEventListener('click', (ev) => {
itemConfig.onClick(ev);
this.hide();
});
}
return elem;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @returns {HTMLElement}
* @memberof CustomContextMenu
*/
_createBreak() {
let html = `<div class="context_hr"></div>`;
let elem = this._createElementsFromHTML(html);
return elem;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} htmlStr
* @returns {HTMLElement}
*/
_createElementsFromHTML(htmlStr) {
let div = document.createElement('div');
div.innerHTML = htmlStr.trim();
return div.firstChild;
}
_isHover(elem) {
return elem.parentElement.querySelector(':hover') === elem;
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @class LocalStorageEx
*/
class LocalStorageEx {
/**
* Creates an instance of LocalStorageEx.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @memberof LocalStorageEx
*/
constructor() {
this.__storage = localStorage;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @readonly
* @memberof LocalStorageEx
*/
get UNDEFINED_SAVED_VALUE() {
return '__** undefined **__';
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @readonly
* @memberof LocalStorageEx
*/
get size() {
let total = 0;
for (let x in this.__storage) {
// Value is multiplied by 2 due to data being stored in `utf-16` format, which requires twice the space.
let amount = this.__storage[x].length * 2;
if (!isNaN(amount) && this.__storage.hasOwnProperty(x)) {
total += amount;
}
}
return total;
}
/**
* Determine if browser supports local storage.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @returns {boolean}
* @memberof LocalStorageEx
*/
isSupported() {
return typeof Storage !== 'undefined';
}
/**
* Check if key exists in local storage.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {*} key
* @returns {boolean}
* @memberof LocalStorageEx
*/
has(key) {
if (typeof key === 'object') {
key = JSON.stringify(key);
}
return this.__storage.hasOwnProperty(key);
}
/**
* Retrieve an object from local storage.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {*} key
* @param {*} [defaultValue=null]
* @returns {*}
* @memberof LocalStorageEx
*/
get(key, defaultValue = null) {
if (typeof key === 'object') {
key = JSON.stringify(key);
}
if (!this.has(key)) {
return defaultValue;
}
let item = this.__storage.getItem(key);
try {
if (item === '__** undefined **__') {
return undefined;
} else {
return JSON.parse(item);
}
} catch (error) {
return item;
}
}
/**
* Save some value to local storage.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} key
* @param {*} value
* @returns {void}
* @memberof LocalStorageEx
*/
set(key, value) {
if (typeof key === 'object') {
key = JSON.stringify(key);
}
if (value === undefined) {
value = this.UNDEFINED_SAVED_VALUE;
} else if (typeof value === 'object') {
value = JSON.stringify(value);
}
this.__storage.setItem(key, value);
}
/**
* Remove element from local storage.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {*} key
* @returns {void}
* @memberof LocalStorageEx
*/
remove(key) {
if (typeof key === 'object') {
key = JSON.stringify(key);
}
this.__storage.removeItem(key);
}
toString() {
return JSON.parse(JSON.stringify(this.__storage));
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @class SessionStorageEx
* @extends {LocalStorageEx}
*/
class SessionStorageEx extends LocalStorageEx {
/**
* Creates an instance of SessionStorageEx.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @memberof SessionStorageEx
*/
constructor() {
super();
this.__storage = sessionStorage;
}
}
class IgnoreCaseMap extends Map {
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} key
* @param {*} value
* @returns {this}
* @memberof IgnoreCaseMap
*/
set(key, value) {
return super.set(key.toLocaleLowerCase(), value);
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} key
* @returns {*}
* @memberof IgnoreCaseMap
*/
get(key) {
return super.get(key.toLocaleLowerCase());
}
}
// #endregion Helper Classes
// #region Helper Functions
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} name
* @param {{logLevel: log.LogLevelDesc, tag: string}} logLevel
* @return {log.Logger}
*/
function getLogger(name, { logLevel, tag }) {
prefix.reg(log);
const colors = {
TRACE: '220;86;220',
DEBUG: '86;86;220',
INFO: '134;134;221',
WARN: '220;220;86',
ERROR: '220;86;86',
};
/** @type {prefix.LoglevelPluginPrefixOptions} */
let options = {
// template: tag ? `[%t] %l [${tag}] %n:` : '[%t] %l %n:',
levelFormatter: function (level) {
return level.toUpperCase();
},
nameFormatter: function (name) {
return name || 'root';
},
timestampFormatter: function (date) {
return date.toTimeString().replace(/.*(\d{2}:\d{2}:\d{2}).*/, '$1');
},
format: function (level, name, timestamp) {
let _timestamp = `\x1B[90m[${timestamp}]\x1B[m`;
let _level = `\x1B[38;2;${colors[level.toUpperCase()]}m${level.toUpperCase()}\x1B[m`;
let _name = `\x1B[38;2;38;177;38m${tag ? `[${tag}-` : '['}${name}]\x1B[m`;
let _format = `${_timestamp} ${_level} ${_name}:`;
return _format;
},
};
const logger = log.getLogger(name);
prefix.apply(logger, options);
logger.setLevel(logLevel || 'WARN');
return logger;
}
function pp(obj, fn) {
fn = fn || console.log;
fn(pformat(obj));
}
function pformat(obj, space = 4) {
return JSON.stringify(obj, null, space);
}
function removeAllButLastStrPattern(string, token) {
let parts = string.split(token);
if (parts[1] === undefined) return string;
else return parts.slice(0, -1).join('') + token + parts.slice(-1);
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Array.<T> | Array} arr
* @param {?function(T, T): boolean} callbackObjs
* @return {T[]}
* @template T
*/
function dedupeArr(arr, callbackObjs) {
if (callbackObjs) {
let tempArr = /** @type {[]} */ (arr).filter((value, index) => {
return (
index ===
arr.findIndex((other) => {
return callbackObjs(value, other);
})
);
});
return tempArr;
} else {
return [...new Set(arr)];
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {any} obj
* @returns {boolean}
*/
function isClass(obj) {
return typeof obj === 'function' && /^\s*class\s+/.test(obj.toString());
}
/**
* Checks whether a variable is a class or an instance created with `new`.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {*} value The variable to check.
* @returns {boolean} `true` if the variable is a class or an instance created with `new`, `false` otherwise.
*/
function isClassOrInstance(value) {
// prettier-ignore
if (typeof value === 'function' &&
value.prototype &&
typeof value.prototype.constructor === 'function' &&
value.prototype.constructor !== Array &&
value.prototype.constructor !== Object) {
return true; // It's a class
} else if (typeof value === 'object' &&
value.constructor &&
typeof value.constructor === 'function' &&
value.constructor.prototype &&
typeof value.constructor.prototype.constructor === 'function' &&
value.constructor !== Array &&
value.constructor !== Object) {
return true; // It's an instance created with new
}
return false;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {*} value The variable to check.
* @returns {boolean}
*/
function isFunction(value) {
try {
return typeof value == 'function';
} catch (error) {
return false;
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {object} obj
* @param {{ propsToExclude?: string[]; namesOnly: boolean; removeDuplicates: boolean; asObject: boolean }} [{ propsToExclude = [], namesOnly = false, removeDuplicates = true, asObject = false } = {}]
* @returns
*/
function getObjProps(obj, { propsToExclude = [], namesOnly = false, removeDuplicates = true, asObject = false } = {}) {
// Default
let _propsToExclude = [
//
'__defineGetter__',
'__defineSetter__',
'__lookupSetter__',
'__lookupGetter__',
'__proto__',
'__original__',
'caller',
'callee',
'arguments',
'toString',
'valueOf',
'constructor',
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'toLocaleString',
];
_propsToExclude = propsToExclude && Array.isArray(propsToExclude) ? _propsToExclude.concat(propsToExclude) : _propsToExclude;
let objHierarchy = getObjHierarchy(obj);
let propNames = getPropNames(objHierarchy);
let plainObj = {};
let objKeys = [];
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {any} obj
* @returns {Array<any>}
*/
function getObjHierarchy(obj) {
let objs = [obj];
obj = isClassOrInstance(obj) ? obj.prototype || obj.__proto__ : obj;
do {
objs.push(obj);
} while ((obj = Object.getPrototypeOf(obj)));
return objs;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Array<any>} objHierarchy
* @returns {string[]}
*/
function getPropNames(objHierarchy) {
/** @type {string[]} */
let propNames = [];
for (let i = 0; i < objHierarchy.length; i++) {
const _obj = objHierarchy[i];
let getPropFuncs = [Object.getOwnPropertyNames, Object.getOwnPropertySymbols];
getPropFuncs.forEach((func) => {
let _propNames = func(_obj);
_propNames.forEach((propName) => {
if (!_propsToExclude.includes(propName) && !propNames.includes(propName)) {
propNames.push(propName);
}
});
});
}
return propNames;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{ name: string, value: any }[]} props
* @return {{ name: string, value: any }[]}
*/
function dedupeProps(props) {
function findNonNullProp(props, name) {
let res = props.find((prop) => prop.name == name && prop.value != null);
if (!res) {
res = props.find((prop) => prop.name == name);
}
return res;
}
function propsContains(props, name) {
return props.some((prop) => prop.name == name);
}
let newProps = [];
for (let i = 0; i < props.length; i++) {
const prop = props[i];
let tempProp = findNonNullProp(props, prop.name);
if (!propsContains(newProps, tempProp.name)) {
newProps.push(tempProp);
}
}
return newProps;
}
function getProps(objHierarchy, doFuncs = false) {
/** @type {{ name: string, value: any }} */
let props = [];
for (let o = 0; o < objHierarchy.length; o++) {
const _obj = objHierarchy[o];
for (let p = 0; p < propNames.length; p++) {
const propName = propNames[p];
let value;
try {
value = _obj[propName];
} catch (error) {}
if (!_propsToExclude.includes(propName)) {
if (asObject) {
if (!objKeys.includes(propName)) {
objKeys.push(propName);
plainObj[propName] = value;
}
} else {
props.push({
name: propName,
value: value,
});
}
}
}
}
if (!asObject) {
if (removeDuplicates) {
props = dedupeProps(props);
}
props = props.filter(function (prop, i, props) {
let exprs = [
//
!_propsToExclude.includes(prop.name),
// props[i + 1] && prop.name != props[i + 1].name,
...(doFuncs ? [isFunction(prop.value)] : [!isFunction(prop.value)]),
];
return exprs.every(Boolean);
});
}
if (asObject) {
return plainObj;
} else {
return props.sort(function (a, b) {
let aName = typeof a.name == 'symbol' ? a.name.toString() : a.name;
let bName = typeof b.name == 'symbol' ? b.name.toString() : b.name;
if (aName < bName) return -1;
if (aName > bName) return 1;
return 0;
});
}
}
let res;
if (asObject) {
getProps(objHierarchy, true);
getProps(objHierarchy);
res = plainObj;
} else {
res = {
funcs: getProps(objHierarchy, true),
props: getProps(objHierarchy),
};
if (namesOnly) {
res.funcs = res.funcs.filter((func) => func.name.toString() != 'Symbol(Symbol.hasInstance)').map((func) => func.name);
res.props = res.props.filter((prop) => prop.name.toString() != 'Symbol(Symbol.hasInstance)').map((prop) => prop.name);
}
}
objHierarchy = null;
return res;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Window} [_window=window]
* @param {{ namesOnly: boolean; asObject: boolean }} [{ namesOnly = false, asObject = false } = {}]
* @returns
*/
function getUserDefinedGlobalProps(_window = null, { namesOnly = false, asObject = false } = {}) {
_window = _window || getWindow();
let iframe = document.createElement('iframe');
iframe.style.display = 'none';
document.body.appendChild(iframe);
let plainObj = {};
let objKeys = [];
function getProps(obj, doFuncs = false) {
let props = [];
let _obj = obj;
let getPropFuncs = [Object.getOwnPropertyNames, Object.getOwnPropertySymbols];
getPropFuncs.forEach((func) => {
let propNames = func(_obj);
for (let i = 0; i < propNames.length; i++) {
const propName = propNames[i];
let value;
try {
value = _obj[propName];
} catch (error) {}
if (isNumber(propName) && value?.constructor?.name == 'Window') continue;
if (!iframe.contentWindow.hasOwnProperty(propName)) {
if (asObject) {
if (!objKeys.includes(propName)) {
objKeys.push(propName);
plainObj[propName] = value;
}
} else {
props.push({
name: propName,
value: value,
});
}
}
}
});
if (!asObject) {
props = props.filter(function (prop, i, props) {
let propName1 = prop.name;
let propName2 = props[i + 1] ? props[i + 1].name : undefined;
let propValue1 = prop.value;
let propValue2 = props[i + 1] ? props[i + 1].value : undefined;
let exprs = [
//
// props[i + 1] && propName1 != propName2,
(props[i + 1] && propName1.constructor.name == 'Symbol' && propName2.constructor.name == 'Symbol' && propValue1 != propValue2) || propName1 != propName2,
...(doFuncs ? [isFunction(obj[propName1])] : [!isFunction(obj[propName1])]),
];
return exprs.every(Boolean);
});
}
if (asObject) {
return plainObj;
} else {
return props.sort(function (a, b) {
let aName = typeof a.name == 'symbol' ? a.name.toString() : a.name;
let bName = typeof b.name == 'symbol' ? b.name.toString() : b.name;
if (aName < bName) return -1;
if (aName > bName) return 1;
return 0;
});
}
}
let res;
if (asObject) {
getProps(_window, true);
getProps(_window);
res = plainObj;
} else {
res = {
funcs: getProps(_window, true),
props: getProps(_window),
};
if (namesOnly) {
res.funcs = res.funcs.filter((func) => func.name.toString() != 'Symbol(Symbol.hasInstance)').map((func) => func.name);
res.props = res.props.filter((prop) => prop.name.toString() != 'Symbol(Symbol.hasInstance)').map((prop) => prop.name);
}
}
document.body.removeChild(iframe);
return res;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {T} obj
* @param {T | boolean} thisArg
* @returns {T}
* @template T
*/
function storeObjOriginalFuncs(obj, thisArg = true) {
let props = getObjProps(obj);
obj.__original__ = {};
for (let i = 0; i < props.funcs.length; i++) {
const func = props.funcs[i];
if (thisArg == true) {
obj.__original__[func.name] = func.value.bind(obj);
} else {
obj.__original__[func.name] = thisArg != false && thisArg != null && thisArg != undefined ? func.value.bind(thisArg) : func.value;
}
}
return obj;
}
function printProps(obj, title) {
let headerFooterBanner = '*********************************************************';
console.log(headerFooterBanner);
console.log(`* ${title || ''}`);
console.log(headerFooterBanner);
for (let key in obj) console.log(key + ': ', [obj[key]]);
console.log(headerFooterBanner);
}
function sortObject(o, desc) {
let sorted = {};
let key;
let a = [];
for (key in o) {
if (o.hasOwnProperty(key)) a.push(key);
}
if (desc) a.sort(sortDescending);
else a.sort(sortAscending);
for (key = 0; key < a.length; key++) sorted[a[key]] = o[a[key]];
return sorted;
}
function sortAscending(a, b) {
if (typeof a == 'string') {
a = a.toLowerCase();
b = b.toLowerCase();
}
if (a < b) return -1;
else if (a > b) return 1;
else return 0;
}
function sortDescending(a, b) {
if (typeof a == 'string') {
a = a.toLowerCase();
b = b.toLowerCase();
}
if (a > b) return -1;
else if (a < b) return 1;
else return 0;
}
function getFileExtension(sFile) {
return sFile.replace(/^(.*)(\.[^/.]+)$/, '$2');
}
/**
* Async wait function.
* Example:
* (async () => {
* await wait(4000).then(() => {
* console.log(new Date().toLocaleTimeString());
* }).then(() => {
* console.log('here');
* });
* })();
*
* @param {number} ms - Milliseconds to wait.
* @param {boolean} [synchronous=false] - Wait synchronously.
*/
async function wait(ms, synchronous = false) {
let _wait = (ms, synchronous) => {
if (synchronous) {
let start = Date.now();
let now = start;
while (now - start < ms) now = Date.now();
} else {
return new Promise((resolve) => setTimeout(resolve, ms));
}
};
await _wait(ms, synchronous);
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {() => bool} condition
* @param {{ timeout?: number; callback: () => T; conditionIsAsync: boolean; }} [{ timeout, callback, conditionIsAsync = false } = {}]
* @returns {T}
* @template T
*/
async function waitUntil(condition, { timeout, callback, conditionIsAsync = false } = {}) {
timeout = timeout || -1;
let maxTime = timeout == -1 ? 20000 : -1;
let startTime = new Date();
let timeRanOut = false;
let done = (() => {
let deferred = {};
deferred.promise = new Promise((resolve, reject) => {
deferred.resolve = resolve;
deferred.reject = reject;
});
return deferred;
})();
/** @type {number} */
let timeoutId;
if (timeout && timeout > 0) {
timeoutId = setTimeout(() => {
timeRanOut = true;
return done.reject();
}, timeout);
}
let loop = async () => {
let endTime = new Date();
let elapsed = endTime - startTime;
let conditionResult = conditionIsAsync ? await condition() : condition();
if (conditionResult || timeRanOut || (maxTime != -1 && elapsed > maxTime)) {
clearTimeout(timeoutId);
return done.resolve(callback ? await callback() : undefined);
}
setTimeout(loop, 0);
};
setTimeout(loop, 0);
return done.promise;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {any} obj
* @param {boolean} [getInherited=false]
* @returns {string}
*/
function getType(obj, getInherited = false) {
let _typeVar = (function (global) {
let cache = {};
return function (obj) {
let key;
// null
if (obj == null) return 'null';
// window/global
if (obj == global) return 'global';
// basic: string, boolean, number, undefined
if (!['object', 'function'].includes((key = typeof obj))) return key;
if (obj.constructor != undefined && obj.constructor.name != 'Object' && !getInherited) return obj.constructor.name;
// cached. date, regexp, error, object, array, math
// and get XXXX from [object XXXX], and cache it
return cache[(key = {}.toString.call(obj))] || (cache[key] = key.slice(8, -1));
};
})(globalThis);
return _typeVar(obj);
}
/**
* Returns a function, that, as long as it continues to be invoked, will not
* be triggered. The function will be called after it stops being called for
* N milliseconds. If `immediate` is passed, trigger the function on the
* leading edge, instead of the trailing.
*
* @param {function} func
* @param {Number} wait
* @param {Boolean} immediate
* @returns
*/
function debounce(func, wait, immediate) {
let timeout;
return function () {
let context = this,
args = arguments;
let later = function () {
timeout = null;
if (!immediate) func.apply(context, args);
};
let callNow = immediate && !timeout;
clearTimeout(timeout);
timeout = setTimeout(later, wait);
if (callNow) func.apply(context, args);
};
}
function equals(x, y) {
if (x === y) return true;
// if both x and y are null or undefined and exactly the same
if (!(x instanceof Object) || !(y instanceof Object)) return false;
// if they are not strictly equal, they both need to be Objects
if (x.constructor !== y.constructor) return false;
// they must have the exact same prototype chain, the closest we can do is
// test there constructor.
for (let p in x) {
if (!x.hasOwnProperty(p)) continue;
// other properties were tested using x.constructor === y.constructor
if (!y.hasOwnProperty(p)) return false;
// allows to compare x[ p ] and y[ p ] when set to undefined
if (x[p] === y[p]) continue;
// if they have the same strict value or identity then they are equal
if (typeof x[p] !== 'object') return false;
// Numbers, Strings, Functions, Booleans must be strictly equal
if (!equals(x[p], y[p])) return false;
// Objects and Arrays must be tested recursively
}
for (p in y) {
if (y.hasOwnProperty(p) && !x.hasOwnProperty(p)) return false;
// allows x[ p ] to be set to undefined
}
return true;
}
function isEncoded(uri) {
uri = uri || '';
return uri !== decodeURIComponent(uri);
}
function fullyDecodeURI(uri) {
while (isEncoded(uri)) uri = decodeURIComponent(uri);
return uri;
}
/**
* Get difference in days between two dates.
*
* @param {Date} a
* @param {Date} b
* @returns
*/
function dateDiffInDays(a, b) {
let _MS_PER_DAY = 1000 * 60 * 60 * 24;
// Discard the time and time-zone information.
let utc1 = Date.UTC(a.getFullYear(), a.getMonth(), a.getDate());
let utc2 = Date.UTC(b.getFullYear(), b.getMonth(), b.getDate());
return Math.floor((utc1 - utc2) / _MS_PER_DAY);
}
function randomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1) + min);
}
function randomFloat(min, max) {
return Math.random() * (max - min + 1) + min;
}
function keySort(keys, desc) {
return function (a, b) {
let aVal = null;
let bVal = null;
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
if (i == 0) {
aVal = a[key];
bVal = b[key];
} else {
aVal = aVal[key];
bVal = bVal[key];
}
}
return desc ? ~~(aVal < bVal) : ~~(aVal > bVal);
};
}
function observe(obj, handler) {
return new Proxy(obj, {
get(target, key) {
return target[key];
},
set(target, key, value) {
target[key] = value;
if (handler) handler();
},
});
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Console} console
*/
function addSaveToConsole(console) {
console.save = function (data, filename) {
if (!data) {
console.error('Console.save: No data');
return;
}
if (!filename) filename = 'console.json';
if (typeof data === 'object') data = JSON.stringify(data, undefined, 4);
let blob = new Blob([data], {
type: 'text/json',
});
let event = document.createEvent('MouseEvents');
let tempElem = document.createElement('a');
tempElem.download = filename;
tempElem.href = window.URL.createObjectURL(blob);
tempElem.dataset.downloadurl = ['text/json', tempElem.download, tempElem.href].join(':');
event.initMouseEvent('click', true, false, window, 0, 0, 0, 0, 0, false, false, false, false, 0, null);
tempElem.dispatchEvent(event);
};
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Window} _window
* @param {string} propName
* @param {{} | [] | any} value
*/
function setupWindowProps(_window, propName, value) {
if (getType(value) == 'object') {
if (typeof _window[propName] === 'undefined' || _window[propName] == null) {
_window[propName] = {};
}
let keys = Object.keys(value);
for (let i = 0; i < keys.length; i++) {
const key = keys[i];
if (!(/** @type {{}} */ (_window[propName].hasOwnProperty(key)))) {
_window[propName][key] = null;
}
if (_window[propName][key] == null) {
_window[propName][key] = value[key];
}
}
} else {
if (typeof _window[propName] === 'undefined' || _window[propName] == null) {
_window[propName] = value;
}
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{ name: string; value: any; }[]} variables
*/
function exposeGlobalVariables(variables) {
variables.forEach((variable, index, variables) => {
try {
setupWindowProps(getWindow(), variable.name, variable.value);
} catch (error) {
logger.error(`Unable to expose variable ${variable.name} into the global scope.`);
}
});
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} str
* @returns {string}
*/
function htmlEntitiesDecode(str) {
return str
.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"');
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} metaName
* @returns {string}
*/
function getMeta(metaName) {
const metas = document.getElementsByTagName('meta');
for (let i = 0; i < metas.length; i++) {
if (metas[i].getAttribute('name') === metaName) {
return metas[i].getAttribute('content');
}
}
return '';
}
/**
*
*
* @returns {Window & typeof globalThis}
*/
function getWindow() {
return globalThis.GM_info && GM_info.script.grant.includes('unsafeWindow') ? unsafeWindow : globalThis;
}
/**
*
*
* @param {Window} _window
*/
function getTopWindow(_window = null) {
_window = _window || getWindow();
try {
if (_window.self !== _window.top) {
_window = getTopWindow(_window.parent);
}
} catch (e) {}
return _window;
}
/**
* Setup global error handler
*
* **Example:**
* ```javascript
* setupGlobalErrorHandler({
* callback: (error) => console.error('Error:', error),
* continuous: true,
* prevent_default: true,
* tag: '[test-global-error-handler]',
* });
* ```
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{ callback: (error: ErrorEx) => void; continuous?: boolean; prevent_default?: boolean; tag?: string; logFunc?: (...data: any[]) => void; _window: Window; }} [{ callback, continuous = true, prevent_default = false, tag = '[akkd]', logFunc = console.error, _window = window } = {}]
*/
function setupGlobalErrorHandler({ callback, continuous = true, prevent_default = false, tag = null, logFunc = console.error, _window = window } = {}) {
// respect existing onerror handlers
let _onerror_original = _window.onerror;
// install our new error handler
_window.onerror = function (event, source, lineno, colno, error) {
if (_onerror_original) {
_onerror_original(event, source, lineno, colno, error);
}
// unset onerror to prevent loops and spamming
let _onerror = _window.onerror;
_window.onerror = null;
// now deal with the error
let errorObject = new ErrorEx(event, source, lineno, colno, error);
let errorMessage = createErrorMessage(errorObject);
if (tag) {
let rgb = '38;177;38';
tag = `\x1B[38;2;${rgb}m${tag}\x1B[m`;
logFunc(tag, errorMessage);
} else {
logFunc(errorMessage);
}
// run callback if provided
if (callback) {
callback(errorObject);
}
// re-install this error handler again if continuous mode
if (continuous) {
_window.onerror = _onerror;
}
// true if normal error propagation should be suppressed
// (i.e. normally console.error is logged by the browser)
return prevent_default;
};
class ErrorEx {
/**
* Creates an instance of ErrorEx.
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string | Event} event
* @param {string} source
* @param {number} lineno
* @param {number} colno
* @param {Error} error
* @memberof ErrorEx
*/
constructor(event, source, lineno, colno, error) {
this.name = error.name;
this.message = error && error.message ? error.message : null;
this.stack = error && error.stack ? error.stack : null;
this.event = event;
this.location = document.location.href;
this.url = source;
this.lineno = lineno;
this.colno = colno;
this.useragent = navigator.userAgent;
this.fileName = error && error.fileName ? error.fileName : null;
this.description = error && error.description ? error.description : null;
this.name = error && error.name ? error.name : null;
this.error = error;
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {ErrorEx} error
* @returns {string}
*/
function createErrorMessage(error) {
let name = error && error.name ? error.name : 'Error';
let message = error && error.message ? error.message : 'Unknown error occured';
let stack = error && error.stack ? error.stack.split('\n').splice(1).join('\n') : 'Error';
let errorMessage = `Uncaught Global ${name}: ${message}\n${stack}`;
return errorMessage;
}
}
function applyCss(cssFiles) {
/** @type {{ css: string, node?: HTMLElement }[]} */
let cssArr = [];
for (let i = 0; i < cssFiles.length; i++) {
let cssStr = GM_getResourceText(cssFiles[i]);
cssArr.push({
css: cssStr,
});
}
addStyles(cssArr);
}
function applyCss2(cssFiles) {
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} cssStyleStr
* @returns {HTMLStyleElement}
*/
function createStyleElementFromCss(cssStyleStr) {
let style = document.createElement('style');
style.innerHTML = cssStyleStr.trim();
return style;
}
let ranOnce = false;
/** @type {HTMLStyleElement[]} */
getWindow().akkd.styleElements = [];
function removeStyleElements() {
for (let i = 0; i < getWindow().akkd.styleElements.length; i++) {
let styleElement = getWindow().akkd.styleElements[i];
styleElement.remove();
}
getWindow().akkd.styleElements = [];
}
function _editStyleSheets() {
$(document).arrive('style, link', async function () {
if (this.tagName == 'LINK' && this.href.includes('.css')) {
removeStyleElements();
for (let i = 0; i < cssFiles.length; i++) {
let cssFile = cssFiles[i];
let css = GM_getResourceText(cssFile);
let styleElem = createStyleElementFromCss(css);
styleElem.id = `akkd-transform-style-${(i + 1).toString().padStart(2, '0')}`;
getWindow().akkd.styleElements.push(styleElem);
document.body.appendChild(styleElem);
}
}
});
if (!ranOnce) {
for (let i = 0; i < cssFiles.length; i++) {
let cssFile = cssFiles[i];
let css = GM_getResourceText(cssFile);
let styleElem = createStyleElementFromCss(css);
styleElem.id = `akkd-transform-style-${(i + 1).toString().padStart(2, '0')}`;
getWindow().akkd.styleElements.push(styleElem);
document.body.appendChild(styleElem);
}
ranOnce = true;
}
}
_editStyleSheets();
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{ css: string, node?: HTMLElement }[]} cssArr
*/
let addStyles = (function () {
/** @type {string[]} */
const addedStyleIds = [];
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{ css: string, node?: HTMLElement }[]} cssArr
* @param {{ useGM: boolean }} cssArr { useGM = true } = {}
*/
function _addStyles(cssArr, { useGM = true } = {}) {
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} css
* @returns {HTMLStyleElement}
*/
function createStyleElementFromCss(css) {
let style = document.createElement('style');
style.innerHTML = css.trim();
return style;
}
function removeStyleElements() {
for (let i = addedStyleIds.length - 1; i >= 0; i--) {
/** @type {HTMLStyleElement} */
let styleElem = document.getElementById(addedStyleIds[i]);
if (styleElem) {
styleElem.remove();
addedStyleIds.splice(i, 1);
}
}
}
function addStyleElements() {
for (let i = 0; i < cssArr.length; i++) {
try {
const css = cssArr[i].css;
const node = cssArr[i].node || document.head;
/** @type {HTMLStyleElement} */
let elem = useGM ? GM_addStyle(css) : createStyleElementFromCss(css);
elem.id = `akkd-custom-style-${(i + 1).toString().padStart(2, '0')}`;
node.append(elem);
addedStyleIds.push(elem.id);
} catch (error) {
console.error(error);
}
}
}
removeStyleElements();
addStyleElements();
return addedStyleIds;
}
return _addStyles;
})();
/**
* Return uuid of form xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @returns {string}
*/
function uuid4() {
let uuid = '';
let ii;
for (ii = 0; ii < 32; ii += 1) {
switch (ii) {
case 8:
case 20:
uuid += '-';
uuid += ((Math.random() * 16) | 0).toString(16);
break;
case 12:
uuid += '-';
uuid += '4';
break;
case 16:
uuid += '-';
uuid += ((Math.random() * 4) | 8).toString(16);
break;
default:
uuid += ((Math.random() * 16) | 0).toString(16);
}
}
return uuid;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{} | []} obj
* @param {string | {oldName: string, newName: string}[]} oldName
* @param {string=} newName
* @returns
*/
function renameProperty(obj, oldName, newName) {
function _renameProperty(obj, oldName, newName) {
let keys = Object.keys(obj);
for (let i = 0; i < keys.length; i++) {
let key = keys[i];
let value = obj[key];
if (value && typeof value == 'object') {
obj[key] = _renameProperty(value, oldName, newName);
}
if (obj.hasOwnProperty(oldName)) {
obj[newName] = obj[oldName];
delete obj[oldName];
}
}
return obj;
}
let renames = Array.isArray(oldName) ? oldName : [{ oldName, newName }];
for (let i = 0; i < renames.length; i++) {
const rename = renames[i];
obj = _renameProperty(obj, rename.oldName, rename.newName);
}
return obj;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Promise<T>} fn
* @param {{ retries?: number; interval?: number; maxTime?: number; throwError?: boolean; }} { retries = 3, interval = 100, maxTime = null, throwError = false }
* @returns {Promise<T>}
* @template T
*/
async function retry(fn, { retries = 3, interval = 100, maxTime = null, throwError = false }) {
let start = new Date();
let timeLapsed;
async function _retry() {
try {
return await fn;
} catch (error) {
timeLapsed = new Date() - start;
await wait(interval);
if (maxTime) {
if (timeLapsed >= maxTime) {
if (throwError) {
throw error;
} else {
return null;
}
}
} else {
--retries;
if (retries === 0) {
if (throwError) {
throw error;
} else {
return null;
}
}
}
return await _retry();
}
}
return await _retry();
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} htmlStr
* @returns {NodeListOf<ChildNode>}
*/
function createElementsFromHTML(htmlStr) {
let div = document.createElement('div');
div.innerHTML = htmlStr.trim();
return div.childNodes;
}
/**
* Checks if a variable is a number.
*
* @param {*} variable - The variable to check.
* @returns {boolean} - `true` if the variable is a number or a number represented as a string, `false` otherwise.
*/
function isNumber(variable) {
return (typeof variable == 'string' || typeof variable == 'number') && !isNaN(variable - 0) && variable !== '';
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string | number} val
* @returns
*/
function parseNumberSafe(val) {
if (isNumber(val)) {
val = parseFloat(val);
}
return val;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number} num
* @returns {boolean}
*/
function isInt(num) {
return Number(num) === num && num % 1 === 0;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number} num
* @returns {boolean}
*/
function isFloat(num) {
return Number(num) === num && num % 1 !== 0;
}
/*
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {HTMLElement} elem
* @param {string} prop
* @param {Window=} _window
* @returns {string | number | null}
*/
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {HTMLElement} elem
* @param {string} prop
* @param {Window} [_window=getWindow()]
* @returns {string | number | null}
*/
function getStyle(elem, prop, _window = null) {
_window = _window || getWindow();
let value = parseNumberSafe(
window
.getComputedStyle(elem, null)
.getPropertyValue(prop)
.replace(/^(\d+)px$/, '$1')
);
return value;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {HTMLElement} beforeElem
* @param {HTMLElement=} afterElem
*/
function attachHorizontalResizer(beforeElem, afterElem) {
let resizer = document.createElement('span');
resizer.className = 'akkd-horz-resizer';
beforeElem.after(resizer);
afterElem = afterElem ? afterElem : resizer.nextElementSibling;
// resizer.addEventListener('mousedown', init, false);
// /**
// *
// *
// * @author Michael Barros <michaelcbarros@gmail.com>
// * @param {MouseEvent} ev
// */
// function init(ev) {
// getWindow().addEventListener('mousemove', resize, false);
// getWindow().addEventListener('mouseup', stopResize, false);
// }
// /**
// *
// *
// * @author Michael Barros <michaelcbarros@gmail.com>
// * @param {MouseEvent} ev
// */
// function resize(ev) {
// beforeElem.style.height = `${ev.clientY - beforeElem.offsetTop}px`;
// }
// /**
// *
// *
// * @author Michael Barros <michaelcbarros@gmail.com>
// * @param {MouseEvent} ev
// */
// function stopResize(ev) {
// getWindow().removeEventListener('mousemove', resize, false);
// getWindow().removeEventListener('mouseup', stopResize, false);
// }
let prevX = -1;
let prevY = -1;
let dir = null;
$(resizer).on('mousedown', function (e) {
prevX = e.clientX;
prevY = e.clientY;
dir = 'n'; // $(this).attr('id');
$(document).on('mousemove', resize);
$(document).on('mouseup', stopResize);
});
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {JQuery.MouseMoveEvent<Document, undefined, Document, Document>} ev
*/
function resize(ev) {
if (prevX == -1) return;
let boxX = $(afterElem).position().left;
let boxY = $(afterElem).position().top;
let boxW = $(afterElem).width();
let boxH = $(afterElem).height();
let dx = ev.clientX - prevX;
let dy = ev.clientY - prevY;
switch (dir) {
case 'n':
// north
boxY += dy;
boxH -= dy;
break;
case 's':
// south
boxH += dy;
break;
case 'w':
// west
boxX += dx;
boxW -= dx;
break;
case 'e':
// east
boxW += dx;
break;
default:
break;
}
$(afterElem).css({
// top: boxY + 'px',
// left: boxX + 'px',
// width: boxW + 'px',
height: boxH + 'px',
});
let lines = [
//
// ['newHeight', newHeight],
['clientY', ev.clientY],
['beforeElem.top', roundNumber($(beforeElem).position().top)],
['beforeElem.height', $(beforeElem).height()],
'',
['afterElem.top', roundNumber($(afterElem).position().top)],
['afterElem.height', $(afterElem).height()],
];
// writeDebugMsg(lines);
console.debug([`y: ${ev.clientY}`, `b.top: ${roundNumber($(beforeElem).position().top)}`, `b.height: ${$(beforeElem).height()}`, `a.top: ${roundNumber($(afterElem).position().top)}`, `a.height: ${$(afterElem).height()}`].join(' '));
function writeDebugMsg(lines) {
let outputLines = ['*'.repeat(60)];
let tags = lines.map((line) => (Array.isArray(line) ? line[0] : line));
lines.forEach((line) => {
if (Array.isArray(line)) {
// need to require lpad-align
// outputLines.push(`${lpadAlign(line[0], tags)}: ${line[1]}`);
} else {
outputLines.push(line);
}
});
outputLines.push('*'.repeat(60));
console.debug(outputLines.join('\n'));
}
function roundNumber(num, places = 2) {
return parseFloat(parseFloat(num.toString()).toFixed(places));
// Math.round(num * 100) / 100
}
prevX = ev.clientX;
prevY = ev.clientY;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {JQuery.MouseMoveEvent<Document, undefined, Document, Document>} ev
*/
function stopResize(ev) {
prevX = -1;
prevY = -1;
$(document).off('mousemove', resize);
$(document).off('mouseup', stopResize);
}
}
function traceMethodCalls(obj) {
/** @type {ProxyHandler} */
let handler = {
get(target, propKey, receiver) {
if (propKey == 'isProxy') return true;
const prop = target[propKey];
if (typeof prop == 'undefined') return;
if (typeof prop === 'object' && target[propKey] !== null) {
if (!prop.isProxy) {
target[propKey] = new Proxy(prop, handler);
return target[propKey];
} else {
return target[propKey];
}
}
if (typeof target[propKey] == 'function') {
const origMethod = target[propKey];
return function (...args) {
let result = origMethod.apply(this, args);
console.log(propKey + JSON.stringify(args) + ' -> ' + JSON.stringify(result));
return result;
};
} else {
return target[propKey];
}
},
};
return new Proxy(obj, handler);
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {HTMLElement} elem
* @param {number} [topOffset=0]
* @returns {boolean}
*/
function isVisible(elem, topOffset = 0) {
/**
* Checks if a DOM element is visible. Takes into
* consideration its parents and overflow.
*
* @param {HTMLElement} el the DOM element to check if is visible
*
* These params are optional that are sent in recursively,
* you typically won't use these:
*
* @param {number} top Top corner position number
* @param {number} right Right corner position number
* @param {number} bottom Bottom corner position number
* @param {number} left Left corner position number
* @param {number} width Element width number
* @param {number} height Element height number
* @returns {boolean}
*/
function _isVisible(el, top, right, bottom, left, width, height) {
let parent = el.parentNode;
let VISIBLE_PADDING = 2;
if (!_elementInDocument(el)) {
return false;
}
// Return true for document node
if (9 === parent.nodeType) {
return true;
}
// Return false if our element is invisible
if ('0' === _getStyle(el, 'opacity') || 'none' === _getStyle(el, 'display') || 'hidden' === _getStyle(el, 'visibility')) {
return false;
}
if ('undefined' === typeof top || 'undefined' === typeof right || 'undefined' === typeof bottom || 'undefined' === typeof left || 'undefined' === typeof width || 'undefined' === typeof height) {
top = el.offsetTop + topOffset;
left = el.offsetLeft;
bottom = top + el.offsetHeight;
right = left + el.offsetWidth;
width = el.offsetWidth;
height = el.offsetHeight;
}
// If we have a parent, let's continue:
if (parent) {
// Check if the parent can hide its children.
if ('hidden' === _getStyle(parent, 'overflow') || 'scroll' === _getStyle(parent, 'overflow')) {
// Only check if the offset is different for the parent
if (
// If the target element is to the right of the parent elm
left + VISIBLE_PADDING > parent.offsetWidth + parent.scrollLeft ||
// If the target element is to the left of the parent elm
left + width - VISIBLE_PADDING < parent.scrollLeft ||
// If the target element is under the parent elm
top + VISIBLE_PADDING > parent.offsetHeight + parent.scrollTop ||
// If the target element is above the parent elm
top + height - VISIBLE_PADDING < parent.scrollTop
) {
// Our target element is out of bounds:
return false;
}
}
// Add the offset parent's left/top coords to our element's offset:
if (el.offsetParent === parent) {
left += parent.offsetLeft;
top += parent.offsetTop;
}
// Let's recursively check upwards:
return _isVisible(parent, top, right, bottom, left, width, height);
}
return true;
}
// Cross browser method to get style properties:
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {HTMLElement} el
* @param {string} property
* @returns
*/
function _getStyle(el, property) {
let value;
if (window.getComputedStyle) {
value = document.defaultView.getComputedStyle(el, null)[property];
}
if (el.currentStyle) {
value = el.currentStyle[property];
}
return value;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {HTMLElement} element
* @returns {boolean}
*/
function _elementInDocument(element) {
while ((element = element.parentNode)) {
if (element == document) {
return true;
}
}
return false;
}
return _isVisible(elem);
}
/**
* @summary
* High-order function that memoizes a function, by creating a scope
* to store the result of each function call, returning the cached
* result when the same inputs is given.
*
* @description
* Memoization is an optimization technique used primarily to speed up
* functions by storing the results of expensive function calls, and returning
* the cached result when the same inputs occur again.
*
* Each time a memoized function is called, its parameters are used as keys to index the cache.
* If the index (key) is present, then it can be returned, without executing the entire function.
* If the index is not cached, then all the body of the function is executed, and the result is
* added to the cache.
*
* @see https://www.sitepoint.com/implementing-memoization-in-javascript/
*
* @export
* @param {Function} func: function to memoize
* @returns {Function}
*/
function memoize(func) {
const cache = {};
function memoized(...args) {
const key = JSON.stringify(args);
if (key in cache) return cache[key];
if (globalThis instanceof this.constructor) {
return (cache[key] = func.apply(null, args));
} else {
return (cache[key] = func.apply(this, args));
}
}
memoized.toString = () => func.toString();
return memoized;
}
function memoizeClass(clazz, options = { toIgnore: [] }) {
let funcs = getObjProps(clazz, { namesOnly: true }).funcs;
for (let i = 0; i < funcs.length; i++) {
let funcName = funcs[i];
if (options.toIgnore.includes(funcName)) continue;
let func = Object.getOwnPropertyDescriptor(clazz.prototype, funcName);
let memFunc = memoize(func.value);
Object.defineProperty(clazz.prototype, funcName, {
get: function () {
return memFunc;
},
});
}
let props = getObjProps(clazz, { namesOnly: true }).props;
for (let i = 0; i < props.length; i++) {
let propName = props[i];
if (options.toIgnore.includes(propName)) continue;
let prop = Object.getOwnPropertyDescriptor(clazz.prototype, propName);
let cacheKey = `_${propName}-cache_`;
Object.defineProperty(clazz.prototype, propName, {
get: function () {
return (this[cacheKey] = this[cacheKey] || prop.get.call(this));
},
});
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {any[]} objects
* @returns {object}
*/
function merge(...objects) {
const isObject = (obj) => Object.prototype.toString.call(obj) == '[object Object]' && obj.constructor && obj.constructor.name == 'Object';
let _merge = (_target, _source, _isMergingArrays) => {
if (!isObject(_target) || !isObject(_source)) {
return _source;
}
Object.keys(_source).forEach((key) => {
const targetValue = _target[key];
const sourceValue = _source[key];
if (Array.isArray(targetValue) && Array.isArray(sourceValue)) {
if (_isMergingArrays) {
_target[key] = targetValue.map((x, i) => (sourceValue.length <= i ? x : _merge(x, sourceValue[i], _isMergingArrays)));
if (sourceValue.length > targetValue.length) {
_target[key] = _target[key].concat(sourceValue.slice(targetValue.length));
}
} else {
_target[key] = targetValue.concat(sourceValue);
}
} else if (isObject(targetValue) && isObject(sourceValue)) {
_target[key] = _merge(Object.assign({}, targetValue), sourceValue, _isMergingArrays);
} else {
_target[key] = sourceValue;
}
});
return _target;
};
const isMergingArrays = typeof objects[objects.length - 1] == 'boolean' ? objects.pop() : false;
if (objects.length < 2) throw new Error('mergeEx: this function expects at least 2 objects to be provided');
if (objects.some((object) => !isObject(object))) throw new Error('mergeEx: all values should be of type "object"');
const target = objects.shift();
let source;
while ((source = objects.shift())) {
_merge(target, source, isMergingArrays);
}
return target;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {Window} [windowOrFrame=getTopWindow()]
* @param {Window[]} [allFrameArray=[]]
* @returns {Window[]}
*/
function getAllFrames(windowOrFrame = getTopWindow(), allFrameArray = []) {
allFrameArray.push(windowOrFrame.frames);
for (var i = 0; i < windowOrFrame.frames.length; i++) {
getAllFrames(windowOrFrame.frames[i], allFrameArray);
}
return allFrameArray;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @returns {boolean}
*/
function windowIsFocused() {
let frames = getAllFrames();
for (let i = 0; i < frames.length; i++) {
const frame = frames[i];
try {
if (frame.document.hasFocus()) {
return true;
}
} catch (error) {}
}
return false;
}
function setupWindowHasFocused() {
let frames = getAllFrames();
for (let i = 0; i < frames.length; i++) {
const frame = frames[i];
try {
frame.hasFocus = windowIsFocused;
} catch (error) {}
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {[]} array
* @param {any} element
* @param {number} index
*/
function moveArrayElement(array, filter, index) {
let item = array.filter((item) => item === filter)[0];
if (item) {
array = array.filter((item) => item !== filter);
array.unshift(item);
}
return array;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {HTMLElement} elem
* @param {(elem: HTMLElement, level: number) => void} callback
* @param {number} [level=0]
*/
function walkDom(elem, callback, level = 0) {
let children = elem.children;
callback(elem, level);
for (let i = 0; i < children.length; i++) {
/** @type {HTMLElement} */
let child = children[i];
walkDom(child, callback, level + 1);
if (child.shadowRoot) {
walkDom(child.shadowRoot, callback, level + 2);
}
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {T} obj
* @param {(key: string | number, value: any, keyPath: string, callbackRes: { doBreak: boolean, returnValue: any | null }, obj: T) => boolean} callback
* @template T
* @returns {{ dottedObj: T, returnValue: any }}
*/
function walkObj(obj, callback) {
let callbackRes = {
doBreak: false,
returnValue: null,
};
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{}} _obj
* @param {string[]} keyPath
* @param {{}} newObj
*/
function _walk(_obj, keyPath, newObj) {
keyPath = typeof keyPath === 'undefined' ? [] : keyPath;
newObj = typeof newObj === 'undefined' ? {} : newObj;
for (let key in _obj) {
if (_obj.hasOwnProperty(key)) {
let value = _obj[key];
keyPath.push(key);
callback.apply(this, [key, value, keyPath.join('.'), callbackRes, obj]);
if (typeof value === 'object' && value !== null) {
newObj = _walk(value, keyPath, newObj);
} else {
let newKey = keyPath.join('.');
newObj[newKey] = value;
}
keyPath.pop();
if (callbackRes.doBreak) {
break;
}
}
}
return newObj;
}
let newObj = _walk(obj);
return {
dottedObj: newObj,
returnValue: callbackRes.returnValue,
};
}
/**
* A function to take a string written in dot notation style, and use it to
* find a nested object property inside of an object.
*
* Useful in a plugin or module that accepts a JSON array of objects, but
* you want to let the user specify where to find various bits of data
* inside of each custom object instead of forcing a standardized
* property list.
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{}} obj
* @param {string} dotPath
* @returns {*}
*/
function getNestedDot(obj, dotPath) {
let parts = dotPath.split('.');
let length = parts.length;
let property = obj || this;
for (let i = 0; i < length; i++) {
property = property[parts[i]];
}
return property;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{}} obj
* @param {number} maxLevel
*/
function getDottedObj(obj, maxLevel = 50) {
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {{}} _obj
* @param {string[]} keyPath
* @param {{}} newObj
* @param {number} level
*/
function _worker(_obj, keyPath, newObj, level = 0) {
keyPath = typeof keyPath === 'undefined' ? [] : keyPath;
newObj = typeof newObj === 'undefined' ? {} : newObj;
for (let key in _obj) {
if (_obj.hasOwnProperty(key)) {
let value = _obj[key];
keyPath.push(key);
if (typeof value === 'object' && value !== null) {
newObj = _worker(value, keyPath, newObj, level++);
} else {
let newKey = keyPath.join('.');
newObj[newKey] = value;
}
keyPath.pop();
if (maxLevel > 0 && level >= maxLevel) {
break;
}
}
}
return newObj;
}
let dottedObj = _worker(obj);
return dottedObj;
}
function isNode() {
return !(typeof window !== 'undefined' && typeof window.document !== 'undefined');
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @returns {number}
*/
function getCurrentTimeMs() {
if (isNode()) {
const NS_PER_MS = 1e6;
let time = process.hrtime();
return time[0] * 1000 + time[1] / NS_PER_MS;
} else {
return performance.now();
}
}
const intervalIDsMap = new Map();
const timeoutIDsMap = new Map();
/**
* Schedules the repeated execution of a function (callback) with a fixed time delay between each call.
* @param {TimerHandler} handler - A function to be executed repeatedly.
* @param {number} [timeout] - The time, in milliseconds, between each function call. Default is 0.
* @param {...any} [args] - Additional arguments to be passed to the function.
* @returns {number} - An identifier representing the interval. This value can be used with clearInterval to cancel the interval.
*/
function setIntervalEx(handler, timeout, ...args) {
if (isNode()) {
return setInterval(handler, timeout, ...args);
} else {
let startTime = getCurrentTimeMs();
let elapsedTime = 0;
/** @type {number} */
let intervalId;
let intervalIdTemp;
function loop(currentTime) {
if (intervalIDsMap.get(intervalId)) {
const deltaTime = currentTime - startTime;
elapsedTime += deltaTime;
if (elapsedTime >= timeout) {
handler(...args);
elapsedTime = 0;
}
startTime = currentTime;
intervalIdTemp = window.requestAnimationFrame(loop);
} else {
window.cancelAnimationFrame(intervalIdTemp);
intervalIDsMap.delete(intervalId);
}
}
intervalId = window.requestAnimationFrame(loop);
intervalIDsMap.set(intervalId, true);
return intervalId;
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number} intervalId
*/
function clearIntervalEx(intervalId) {
if (isNode()) {
clearInterval(intervalId);
} else {
intervalIDsMap.set(intervalId, false);
window.cancelAnimationFrame(intervalId);
}
}
/**
* Schedules the execution of a function (callback) after a specified time delay.
* @param {TimerHandler} handler - A function to be executed.
* @param {number} [timeout] - The time, in milliseconds, to wait before executing the function. Default is 0.
* @param {...any} [args] - Additional arguments to be passed to the function.
* @returns {number} - An identifier representing the timeout. This value can be used with clearTimeout to cancel the timeout.
*/
function setTimeoutEx(handler, timeout, ...args) {
if (isNode()) {
return setTimeout(handler, timeout, ...args);
} else {
let startTime = getCurrentTimeMs();
/** @type {number} */
let timeoutId;
let timeoutIdTemp;
function loop(currentTime) {
if (timeoutIDsMap.get(timeoutId)) {
const deltaTime = currentTime - startTime;
if (deltaTime >= timeout) {
handler(...args);
} else {
timeoutIdTemp = window.requestAnimationFrame(loop);
}
} else {
window.cancelAnimationFrame(timeoutIdTemp);
timeoutIDsMap.delete(timeoutId);
}
}
timeoutId = window.requestAnimationFrame(loop);
timeoutIDsMap.set(timeoutId, true);
return timeoutId;
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number} timeoutId
*/
function clearTimeoutEx(timeoutId) {
if (isNode()) {
clearTimeout(timeoutId);
} else {
timeoutIDsMap.set(timeoutId, false);
window.cancelAnimationFrame(timeoutId);
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} attribute
* @param {string} value
* @param {string} elementType
* @returns {HTMLElement[]}
*/
function findByAttributeValue(attribute, value, elementType) {
elementType = elementType || '*';
let all = document.getElementsByTagName(elementType);
let foundElements = [];
for (let i = 0; i < all.length; i++) {
if (all[i].getAttribute(attribute).includes(value)) {
foundElements.push(all[i]);
}
}
return foundElements;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @returns {number}
*/
function getLocalStorageSize() {
let total = 0;
for (let x in localStorage) {
// Value is multiplied by 2 due to data being stored in `utf-16` format, which requires twice the space.
let amount = localStorage[x].length * 2;
if (!isNaN(amount) && localStorage.hasOwnProperty(x)) {
total += amount;
}
}
return total;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number} bytes
* @param {boolean} [si=false]
* @returns {string}
*/
function bytes2HumanReadable(bytes, si = false) {
let thresh = si ? 1000 : 1024;
if (Math.abs(bytes) < thresh) {
return bytes + ' B';
}
let units = si ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'] : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
let u = -1;
while (true) {
bytes = bytes / thresh;
u++;
if (!(Math.abs(bytes) >= thresh && u < units.length - 1)) {
break;
}
}
return bytes.toFixed(1) + ' ' + units[u];
}
async function GM_fetch(url, fetchInit = {}) {
if (!window.GM_xmlhttpRequest) {
console.warn('GM_xmlhttpRequest not required. Using native fetch.');
return await fetch(url, fetchInit);
}
let parseHeaders = function (headersString) {
const headers = new Headers();
for (const line of headersString.trim().split('\n')) {
const [key, ...valueParts] = line.split(':');
if (key) {
headers.set(key.trim().toLowerCase(), valueParts.join(':').trim());
}
}
return headers;
};
const defaultFetchInit = { method: 'get' };
const { headers, method } = { ...defaultFetchInit, ...fetchInit };
const isStreamSupported = GM_xmlhttpRequest?.RESPONSE_TYPE_STREAM;
const HEADERS_RECEIVED = 2;
if (!isStreamSupported) {
return new Promise((resolve, _reject) => {
const blobPromise = new Promise((resolve, reject) => {
GM_xmlhttpRequest({
url,
method,
headers,
responseType: 'blob',
onload: async (response) => resolve(response.response),
onerror: reject,
onreadystatechange: onHeadersReceived,
});
});
blobPromise.catch(_reject);
function onHeadersReceived(gmResponse) {
const { readyState, responseHeaders, status, statusText } = gmResponse;
if (readyState === HEADERS_RECEIVED) {
const headers = parseHeaders(responseHeaders);
resolve({
headers,
status,
statusText,
arrayBuffer: () => blobPromise.then((blob) => blob.arrayBuffer()),
blob: () => blobPromise,
json: () => blobPromise.then((blob) => blob.text()).then((text) => JSON.parse(text)),
text: () => blobPromise.then((blob) => blob.text()),
});
}
}
});
} else {
return new Promise((resolve, _reject) => {
const responsePromise = new Promise((resolve, reject) => {
void GM_xmlhttpRequest({
url,
method,
headers,
responseType: 'stream',
onerror: reject,
onreadystatechange: onHeadersReceived,
// onloadstart: (gmResponse) => logDebug('[onloadstart]', gmResponse), // debug
});
});
responsePromise.catch(_reject);
function onHeadersReceived(gmResponse) {
const { readyState, responseHeaders, status, statusText, response: readableStream } = gmResponse;
if (readyState === HEADERS_RECEIVED) {
const headers = parseHeaders(responseHeaders);
let newResp;
if (status === 0) {
newResp = new Response(readableStream, { headers /*status, statusText*/ });
} else {
newResp = new Response(readableStream, { headers, status, statusText });
}
resolve(newResp);
}
}
});
}
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {T} items
* @param {{name: string, desc: boolean, case_sensitive: boolean}[]} columns
* @param {{cmpFunc: any}} [{ cmpFunc = cmp }={}]
* @returns {T}
* @template T
*/
function multiKeySort(items, columns, { cmpFunc = null } = {}) {
function cmp(a, b) {
if (a < b) {
return -1;
} else {
if (a > b) {
return 1;
} else {
return 0;
}
}
}
cmpFunc = cmpFunc != null ? cmpFunc : cmp;
let comparers = [];
columns.forEach((col) => {
let column = col.name;
let desc = 'desc' in col ? col.desc : false;
let case_sensitive = 'case_sensitive' in col ? col.case_sensitive : true;
comparers.push([column, desc ? -1 : 1, case_sensitive]);
});
function comparer(left, right) {
for (let i = 0; i < comparers.length; i++) {
const column = comparers[i][0];
const polarity = comparers[i][1];
const case_sensitive = comparers[i][2];
let result = 0;
if (case_sensitive) {
result = cmpFunc(left[column], right[column]);
} else {
result = cmpFunc(left[column].toLowerCase(), right[column].toLowerCase());
}
if (result) {
return polarity * result;
}
}
return 0;
}
return items.sort(comparer);
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} text
* @param {string} [nodeType='div']
* @returns {HTMLElement}
*/
function getElementByTextContent(text, nodeType = 'div') {
let xpath = `//${nodeType}[text()='${text}']`;
/** @type {HTMLElement} */
let elem = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
return elem;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} text
* @param {string} [nodeType='div']
* @returns {HTMLElement}
*/
function getElementByTextContentContains(text, nodeType = 'div') {
let xpath = `//${nodeType}[contains(text(),'${text}')]`;
/** @type {HTMLElement} */
let elem = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
return elem;
}
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {HTMLElement} element
* @param {(elem: HTMLElement) => void} callback
*/
function onRemove(element, callback) {
const parent = element.parentNode;
if (!parent) {
throw new Error('The node must already be attached');
}
const observer = new MutationObserver((mutations) => {
let removed = false;
for (const mutation of mutations) {
for (const node of mutation.removedNodes) {
if (node === element) {
observer.disconnect();
callback(element);
removed = true;
break;
}
}
if (removed) {
break;
}
}
});
observer.observe(parent, {
childList: true,
});
}
// #endregion Helper Functions
// #region Prototype Functions
// #region Array
/**
* Function to setup custom prototype functions for the Array class
* (For no conflicts, Object.defineProperty must be used)
*
*/
function setupArrayPrototypes() {
let funcs = [
function pushUnique(item) {
let index = -1;
for (let i = 0; i < this.length; i++) {
if (equals(this[i], item)) index = i;
}
if (index === -1) this.push(item);
},
];
for (let i = 0; i < funcs.length; i++) {
let func = funcs[i];
Object.defineProperty(Array.prototype, func.name, {
enumerable: false,
configurable: true,
writable: true,
value: func,
});
}
}
setupArrayPrototypes();
// #endregion Array
// #endregion Prototype Functions
// #region jQuery
function setupJqueryExtendedFuncs() {
if ('jQuery' in getWindow() || 'jQuery' in window) {
jQuery.fn.extend({
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @returns {boolean}
* @this {JQuery<HTMLElement>}
*/
exists: function exists() {
return this.length !== 0;
},
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {() => void} callback
* @returns {JQuery<HTMLElement>}
* @this {JQuery<HTMLElement>}
*/
ready: function ready(callback) {
let cb = function cb() {
return setTimeout(callback, 0, jQuery);
};
if (document.readyState !== 'loading') {
cb();
} else {
document.addEventListener('DOMContentLoaded', cb);
}
return this;
},
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {string} method
* @param {{}} options
* @returns {number | string | null}
* @this {JQuery<HTMLElement>}
*/
actual: function actual(method, options) {
// check if the jQuery method exist
if (!this[method]) {
throw '$.actual => The jQuery method "' + method + '" you called does not exist';
}
let defaults = {
absolute: false,
clone: false,
includeMargin: false,
display: 'block',
};
let configs = jQuery.extend(defaults, options);
let $target = this.eq(0);
let fix;
let restore;
if (configs.clone === true) {
fix = function () {
let style = 'position: absolute !important; top: -1000 !important; ';
// this is useful with css3pie
$target = $target.clone().attr('style', style).appendTo('body');
};
restore = function () {
// remove DOM element after getting the width
$target.remove();
};
} else {
let tmp = [];
let style = '';
let $hidden;
fix = function () {
// get all hidden parents
$hidden = $target.parents().addBack().filter(':hidden');
style += 'visibility: hidden !important; display: ' + configs.display + ' !important; ';
if (configs.absolute === true) {
style += 'position: absolute !important; ';
}
// save the origin style props
// set the hidden el css to be got the actual value later
$hidden.each(function () {
// Save original style. If no style was set, attr() returns undefined
let $this = jQuery(this);
let thisStyle = $this.attr('style');
tmp.push(thisStyle);
// Retain as much of the original style as possible, if there is one
$this.attr('style', thisStyle ? thisStyle + ';' + style : style);
});
};
restore = function () {
// restore origin style values
$hidden.each(function (i) {
let $this = jQuery(this);
let _tmp = tmp[i];
if (_tmp === undefined) {
$this.removeAttr('style');
} else {
$this.attr('style', _tmp);
}
});
};
}
fix();
// get the actual value with user specific methed
// it can be 'width', 'height', 'outerWidth', 'innerWidth'... etc
// configs.includeMargin only works for 'outerWidth' and 'outerHeight'
let actual = /(outer)/.test(method) ? $target[method](configs.includeMargin) : $target[method]();
restore();
// IMPORTANT, this plugin only return the value of the first element
return actual;
},
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @returns {DOMRect}
* @this {JQuery<HTMLElement>}
*/
rect: function rect() {
return this[0].getBoundingClientRect();
},
/**
*
*
* @author Michael Barros <michaelcbarros@gmail.com>
* @param {number} levels
* @returns {JQuery<HTMLElement>}
* @this {JQuery<HTMLElement>}
*/
parentEx: function parentEx(levels = 1) {
let parent = this;
for (let i = 0; i < levels; i++) {
if (parent.parent().length == 0) {
break;
}
parent = parent.parent();
}
return parent;
},
});
}
}
setupJqueryExtendedFuncs();
// #endregion jQuery
