rentgen/util.ts

234 lines
6.1 KiB
TypeScript

import { EventEmitter } from "events";
import { Dispatch, SetStateAction, useEffect, useState } from "react";
export type Unpromisify<T> = T extends Promise<infer R> ? R : T;
export type Unarray<T> = T extends Array<infer R> ? R : T;
export type Tab = Unarray<Unpromisify<ReturnType<typeof browser.tabs.query>>>;
export type Request = {
cookieStoreId?: string;
documentUrl?: string; // RL of the document in which the resource will be loaded. For example, if the web page at "https://example.com" contains an image or an iframe, then the documentUrl for the image or iframe will be "https://example.com". For a top-level document, documentUrl is undefined.
frameId: number;
incognito?: boolean;
method: string;
originUrl: string;
parentFrameId: number;
proxyInfo?: {
host: string;
port: number;
type: string;
username: string;
proxyDNS: boolean;
failoverTimeout: number;
};
requestHeaders?: { name: string; value?: string; binaryValue?: number[] }[];
requestId: string;
tabId: number;
thirdParty?: boolean;
timeStamp: number;
type: string;
url: string; // the target of the request;
urlClassification?: { firstParty: string[]; thirdParty: string[] };
};
export function getshorthost(host: string) {
const parts = host
.replace(/^.*:\/\//, "")
.replace(/\/.*$/, "")
.split(".");
let lookback = parts.at(-2).length > 3 ? -2 : -3;
if (parts.at(-2) == "doubleclick") {
lookback = -4; // to distinguish between google ads and stats
}
return parts.slice(lookback).join(".");
}
export function useEmitter(
e: EventEmitter
): [number, Dispatch<SetStateAction<number>>] {
const [counter, setCounter] = useState<number>(0);
useEffect(() => {
const callback = () => {
setCounter((counter) => counter + 1);
};
e.on("change", callback);
return () => {
e.removeListener("change", callback);
};
}, []);
return [counter, setCounter];
}
export function parseCookie(cookie: string): Record<string, string> {
return cookie
.split(";")
.map((l) => l.split("="))
.reduce(
(acc, [key, value]) => ({
...acc,
[key]: value,
}),
{}
);
}
export async function getTabByID(id: number) {
const tabs = await browser.tabs.query({ currentWindow: true });
return tabs.find((tab) => tab.id == id);
}
export function parseToObject(str: unknown): Record<string | symbol, unknown> {
let result: Record<string | symbol, unknown>;
let original_string: string;
if (typeof str === "string") {
original_string = str;
result = JSON.parse(str);
} else if (typeof str == "object") {
result = str as Record<string | symbol, unknown>;
original_string =
(result[Symbol.for("originalString")] as string) || JSON.stringify(str);
}
result[Symbol.for("originalString")] = original_string;
return result;
}
export function isJSONObject(
str: unknown
): str is Record<string, unknown> | string | number {
try {
return JSON.stringify(parseToObject(str))[0] == "{";
} catch (e) {
return false;
}
}
export function isURL(str: unknown): str is string {
try {
return !!(typeof str === "string" && new URL(str));
} catch (e) {
return false;
}
}
export function hyphenate(str: string): string {
return str.replace(/[_\[A-Z]/g, `${String.fromCharCode(173)}$&`);
}
export function unique<T>(array: T[]): Array<T> {
return Array.from(new Set<T>(array));
}
export function allSubhosts(host: string) {
const parts = host.split(".");
const result = [];
for (let i = 0; i < parts.length - 2; i++) {
result.push(parts.slice(i).join("."));
}
return result;
}
export function reduceConcat<T>(a: T[], b: T[]): T[] {
return a.concat(b);
}
export function getDate() {
const d = new Date();
return `${d.getFullYear()}-${(d.getMonth() + 1)
.toString()
.padStart(2, "0")}-${d.getDate().toString().padStart(2, "0")}`;
}
export function toBase64(file: File): Promise<string> {
return new Promise((resolve) => {
const FR = new FileReader();
FR.addEventListener("load", (e) => {
resolve(e.target.result as string);
});
FR.readAsDataURL(file);
});
}
export function makeThrottle(interval: number) {
let last_emit = 0;
function emit(callback: () => void) {
if (Date.now() - last_emit > interval) {
callback();
last_emit = Date.now();
return true;
} else {
return false;
}
}
return function (callback: () => void) {
if (!emit(callback)) {
setTimeout(() => emit(callback), interval);
}
};
}
export function isSameURL(url1: string, url2: string): boolean {
if (url1 === url2) {
return true;
}
url1 = url1.replace(/^https?:\/\//, "").replace(/\/$/, "");
url2 = url2.replace(/^https?:\/\//, "").replace(/\/$/, "");
return url1 === url2;
}
export function isBase64(s: string): boolean {
try {
atob(s);
return true;
} catch (e) {}
return false;
}
export function isBase64JSON(s: unknown): s is string {
return typeof s === "string" && isBase64(s) && isJSONObject(atob(s));
}
export function flattenObject(
obj: Record<string, unknown>
): [string, string][] {
const ret: [string, string][] = [];
for (const [key, value] of Object.entries(obj)) {
const value = obj[key];
if (value === null) {
ret.push([key, "null"]);
continue;
}
if (typeof value === "object") {
const flattened = flattenObject(value as Record<string, unknown>);
for (const [subkey, subvalue] of flattened) {
ret.push([`${key}.${subkey}`, subvalue]);
}
} else {
ret.push([key, value.toString()]);
}
}
return ret;
}
export function flattenObjectEntries(
entries: [string, unknown][]
): [string, string][] {
return flattenObject(Object.fromEntries(entries));
}
export function maskString(
str: string,
max_fraction_remaining: number,
max_chars_total: number
): string {
const amount_of_chars_to_cut =
str.length - Math.min(str.length * max_fraction_remaining, max_chars_total);
if (amount_of_chars_to_cut == 0) {
return str;
}
return (
str.slice(0, str.length / 2 - amount_of_chars_to_cut / 2) +
"(...)" +
str.slice(str.length / 2 + amount_of_chars_to_cut / 2)
);
}