933 lines
28 KiB
TypeScript
933 lines
28 KiB
TypeScript
import chardet from "chardet";
|
||
import dayjs from "dayjs";
|
||
import iconvLite from "iconv-lite";
|
||
import { Base64 } from "js-base64";
|
||
import * as crypto from "node:crypto";
|
||
import fs from "node:fs";
|
||
import path from "node:path";
|
||
import Showdown from "showdown";
|
||
// import {Iconv} from "iconv"
|
||
import { isMac, isWin } from "./env";
|
||
import FileIndex from "../mapi/file";
|
||
|
||
export const EncodeUtil = {
|
||
base32Alphabet: "abcdefghijklmnopqrstuvwxyz234567",
|
||
base32Encode(str: string) {
|
||
const buffer = Buffer.from(str, "utf8");
|
||
let bits = "";
|
||
let output = "";
|
||
// 将每个字节转为8位二进制
|
||
for (let i = 0; i < buffer.length; i++) {
|
||
const byte = buffer[i];
|
||
bits += byte.toString(2).padStart(8, "0");
|
||
}
|
||
// 每5位一组，转为 Base32 字符
|
||
for (let i = 0; i < bits.length; i += 5) {
|
||
const chunk = bits.slice(i, i + 5);
|
||
const paddedChunk = chunk.padEnd(5, "0"); // 不足5位补0
|
||
const index = parseInt(paddedChunk, 2);
|
||
output += EncodeUtil.base32Alphabet[index];
|
||
}
|
||
return output;
|
||
},
|
||
base32Decode(str: string) {
|
||
const base32Alphabet = "abcdefghijklmnopqrstuvwxyz234567";
|
||
let bits = "";
|
||
for (let i = 0; i < str.length; i++) {
|
||
const char = str[i];
|
||
const index = base32Alphabet.indexOf(char);
|
||
if (index === -1) {
|
||
throw new Error("Invalid Base32 character: " + char);
|
||
}
|
||
bits += index.toString(2).padStart(5, "0");
|
||
}
|
||
|
||
const bytes: number[] = [];
|
||
for (let i = 0; i + 8 <= bits.length; i += 8) {
|
||
const byte = bits.slice(i, i + 8);
|
||
bytes.push(parseInt(byte, 2));
|
||
}
|
||
|
||
return Buffer.from(bytes).toString("utf8");
|
||
},
|
||
base64Encode(str: string) {
|
||
return Base64.encode(str);
|
||
},
|
||
base64Decode(str: string) {
|
||
return Base64.decode(str);
|
||
},
|
||
md5(str: string) {
|
||
return crypto.createHash("md5").update(str).digest("hex");
|
||
},
|
||
aesEncode(str: string, key: string) {
|
||
const cipher = crypto.createCipheriv("aes-128-ecb", key, "");
|
||
let crypted = cipher.update(str, "utf8", "base64");
|
||
crypted += cipher.final("base64");
|
||
return crypted;
|
||
},
|
||
aesDecode(str: string, key: string) {
|
||
const decipher = crypto.createDecipheriv("aes-128-ecb", key, "");
|
||
let dec = decipher.update(str, "base64", "utf8");
|
||
dec += decipher.final("utf8");
|
||
return dec;
|
||
},
|
||
async fileXzipEncode(pathname: string): Promise<string> {
|
||
if (!fs.existsSync(pathname)) {
|
||
throw new Error(`Input file not found: ${pathname}`);
|
||
}
|
||
|
||
// Generate new filepath with .xzip extension
|
||
const basePath = pathname.substring(0, pathname.lastIndexOf("."));
|
||
const outputPath = basePath + ".xzip";
|
||
|
||
// Get file info
|
||
const fileStats = fs.statSync(pathname);
|
||
const fileSize = fileStats.size;
|
||
const fileExt = pathname.split(".").pop() || "";
|
||
|
||
// Generate random 16-character key
|
||
const encryptionKey = StrUtil.randomString(16);
|
||
|
||
// Create metadata
|
||
const filemeta = {
|
||
version: 1,
|
||
format: fileExt,
|
||
size: fileSize,
|
||
key: encryptionKey,
|
||
};
|
||
|
||
// Convert metadata to JSON and then base64 encode
|
||
const metaJson = JSON.stringify(filemeta);
|
||
const metaB64 = Buffer.from(metaJson, "utf-8").toString("base64");
|
||
const metaLength = metaB64.length;
|
||
|
||
// Prepare encryption key
|
||
const keyBytes = Buffer.from(encryptionKey, "utf-8");
|
||
const keyLength = keyBytes.length;
|
||
|
||
// Stream processing: read, encrypt and write in chunks
|
||
const inputStream = fs.createReadStream(pathname);
|
||
const outputStream = fs.createWriteStream(outputPath);
|
||
|
||
// Write metadata length (4 bytes, little-endian)
|
||
const metaLengthBuffer = Buffer.allocUnsafe(4);
|
||
metaLengthBuffer.writeUInt32LE(metaLength, 0);
|
||
outputStream.write(metaLengthBuffer);
|
||
|
||
// Write base64 encoded metadata
|
||
outputStream.write(Buffer.from(metaB64, "utf-8"));
|
||
|
||
// Stream encrypt the file content
|
||
let bytesProcessed = 0;
|
||
return new Promise((resolve, reject) => {
|
||
inputStream.on("data", (chunk: Buffer) => {
|
||
// XOR encrypt the chunk
|
||
const encryptedChunk = Buffer.alloc(chunk.length);
|
||
for (let i = 0; i < chunk.length; i++) {
|
||
encryptedChunk[i] =
|
||
chunk[i] ^ keyBytes[bytesProcessed % keyLength];
|
||
bytesProcessed++;
|
||
}
|
||
|
||
// Write encrypted chunk
|
||
outputStream.write(encryptedChunk);
|
||
});
|
||
|
||
inputStream.on("end", () => {
|
||
outputStream.end();
|
||
resolve(outputPath);
|
||
});
|
||
|
||
inputStream.on("error", (error) => {
|
||
outputStream.destroy();
|
||
reject(error);
|
||
});
|
||
|
||
outputStream.on("error", (error) => {
|
||
inputStream.destroy();
|
||
reject(error);
|
||
});
|
||
});
|
||
},
|
||
async fileXzipDecode(pathname: string): Promise<string> {
|
||
if (!fs.existsSync(pathname)) {
|
||
throw new Error(`Input file not found: ${pathname}`);
|
||
}
|
||
|
||
if (!pathname.endsWith(".xzip")) {
|
||
return pathname; // Not an xzip file, return as is
|
||
}
|
||
|
||
let outputPath = pathname.replace(/\.xzip$/, "");
|
||
|
||
return new Promise((resolve, reject) => {
|
||
const inputStream = fs.createReadStream(pathname);
|
||
let metadataRead = false;
|
||
let filemeta: any = null;
|
||
let keyBytes: Buffer;
|
||
let bytesProcessed = 0;
|
||
let outputStream: fs.WriteStream;
|
||
let remainingMetaBytes = 0;
|
||
let metaBuffer = Buffer.alloc(0);
|
||
|
||
inputStream.on("data", (chunk: Buffer) => {
|
||
let chunkOffset = 0;
|
||
|
||
if (!metadataRead) {
|
||
if (remainingMetaBytes === 0) {
|
||
// Read metadata length (first 4 bytes)
|
||
if (chunk.length < 4) {
|
||
reject(
|
||
new Error(
|
||
"Invalid xzip file: insufficient data for metadata length",
|
||
),
|
||
);
|
||
return;
|
||
}
|
||
const metaLength = chunk.readUInt32LE(0);
|
||
remainingMetaBytes = metaLength;
|
||
chunkOffset = 4;
|
||
}
|
||
|
||
// Read metadata
|
||
const availableMetaBytes = Math.min(
|
||
remainingMetaBytes,
|
||
chunk.length - chunkOffset,
|
||
);
|
||
const metaChunk = chunk.subarray(
|
||
chunkOffset,
|
||
chunkOffset + availableMetaBytes,
|
||
);
|
||
metaBuffer = Buffer.concat([
|
||
metaBuffer,
|
||
metaChunk,
|
||
] as readonly Uint8Array[]);
|
||
remainingMetaBytes -= availableMetaBytes;
|
||
chunkOffset += availableMetaBytes;
|
||
|
||
if (remainingMetaBytes === 0) {
|
||
// Parse metadata
|
||
try {
|
||
const metaB64 = metaBuffer.toString("utf-8");
|
||
const metaJson = Buffer.from(
|
||
metaB64,
|
||
"base64",
|
||
).toString("utf-8");
|
||
filemeta = JSON.parse(metaJson);
|
||
keyBytes = Buffer.from(filemeta.key, "utf-8");
|
||
|
||
// Create output file with correct extension
|
||
const finalOutputPath =
|
||
outputPath +
|
||
(filemeta.format ? "." + filemeta.format : "");
|
||
outputStream =
|
||
fs.createWriteStream(finalOutputPath);
|
||
|
||
metadataRead = true;
|
||
|
||
// Set the final output path for resolution
|
||
outputPath = finalOutputPath;
|
||
} catch (error) {
|
||
reject(
|
||
new Error(
|
||
"Invalid xzip file: corrupted metadata",
|
||
),
|
||
);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (metadataRead && chunkOffset < chunk.length) {
|
||
// Decrypt remaining chunk data
|
||
const encryptedChunk = chunk.subarray(chunkOffset);
|
||
const decryptedChunk = Buffer.alloc(encryptedChunk.length);
|
||
const keyLength = keyBytes.length;
|
||
|
||
for (let i = 0; i < encryptedChunk.length; i++) {
|
||
decryptedChunk[i] =
|
||
encryptedChunk[i] ^
|
||
keyBytes[bytesProcessed % keyLength];
|
||
bytesProcessed++;
|
||
}
|
||
|
||
outputStream.write(decryptedChunk);
|
||
}
|
||
});
|
||
|
||
inputStream.on("end", () => {
|
||
if (outputStream) {
|
||
outputStream.end();
|
||
resolve(outputPath);
|
||
} else {
|
||
reject(new Error("Invalid xzip file: incomplete metadata"));
|
||
}
|
||
});
|
||
|
||
inputStream.on("error", (error) => {
|
||
if (outputStream) {
|
||
outputStream.destroy();
|
||
}
|
||
reject(error);
|
||
});
|
||
|
||
if (outputStream) {
|
||
outputStream.on("error", (error) => {
|
||
inputStream.destroy();
|
||
reject(error);
|
||
});
|
||
}
|
||
});
|
||
},
|
||
};
|
||
|
||
export const IconvUtil = {
|
||
convert(str: string, to?: string, from?: string) {
|
||
if (!from) {
|
||
from = chardet.detect(Buffer.from(str));
|
||
}
|
||
to = to || "utf8";
|
||
const buffer = iconvLite.encode(str, from);
|
||
return iconvLite.decode(buffer, to);
|
||
},
|
||
bufferToUtf8(buffer: Buffer) {
|
||
const encoding = chardet.detect(buffer);
|
||
// if ('ISO-2022-CN' === encoding) {
|
||
// const iconvInstance = new Iconv('ISO-2022-CN', 'UTF-8//TRANSLIT//IGNORE');
|
||
// return iconvInstance.convert(buffer).toString()
|
||
// }
|
||
return iconvLite.decode(buffer, encoding).toString();
|
||
},
|
||
detect(buffer: Uint8Array) {
|
||
// detect str encoding
|
||
return chardet.detect(buffer);
|
||
},
|
||
};
|
||
|
||
export const StrUtil = {
|
||
randomString(len: number = 32) {
|
||
const chars =
|
||
"0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
|
||
let result = "";
|
||
for (let i = len; i > 0; --i) {
|
||
result += chars[Math.floor(Math.random() * chars.length)];
|
||
}
|
||
return result;
|
||
},
|
||
uuid() {
|
||
return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
|
||
/[xy]/g,
|
||
function (c) {
|
||
const r = (Math.random() * 16) | 0;
|
||
const v = c === "x" ? r : (r & 0x3) | 0x8;
|
||
return v.toString(16);
|
||
},
|
||
);
|
||
},
|
||
hashCode(str: string, length: number = 8) {
|
||
let hash = 0;
|
||
if (str.length === 0) return hash + "";
|
||
for (let i = 0; i < str.length; i++) {
|
||
const char = str.charCodeAt(i);
|
||
hash = (hash << 5) - hash + char;
|
||
hash = hash & hash;
|
||
}
|
||
let result = Math.abs(hash).toString(16);
|
||
if (result.length < length) {
|
||
result = "0".repeat(length - result.length) + result;
|
||
}
|
||
return result;
|
||
},
|
||
hashCodeWithDuplicateCheck(
|
||
str: string,
|
||
check: string[],
|
||
length: number = 8,
|
||
) {
|
||
let code = this.hashCode(str, length);
|
||
while (check.includes(code)) {
|
||
code = this.uuid().substring(0, length);
|
||
}
|
||
return code;
|
||
},
|
||
bigIntegerId() {
|
||
return [
|
||
Date.now(),
|
||
(Math.floor(Math.random() * 1000000) + "").padStart(6, "0"),
|
||
].join("");
|
||
},
|
||
ucFirst(str: string) {
|
||
if (!str) return "";
|
||
return str.charAt(0).toUpperCase() + str.slice(1);
|
||
},
|
||
};
|
||
|
||
export const TimeUtil = {
|
||
timestampInMs() {
|
||
return Date.now();
|
||
},
|
||
timestamp() {
|
||
return Math.floor(Date.now() / 1000);
|
||
},
|
||
format(time: number, format: string = "YYYY-MM-DD HH:mm:ss") {
|
||
return dayjs(time).format(format);
|
||
},
|
||
formatDate(time: number) {
|
||
return dayjs(time).format("YYYY-MM-DD");
|
||
},
|
||
dateString() {
|
||
return dayjs().format("YYYYMMDD");
|
||
},
|
||
datetimeString() {
|
||
return dayjs().format("YYYYMMDD_HHmmss_SSS");
|
||
},
|
||
timestampDayStart(msTimestamp?: number) {
|
||
let date = msTimestamp ? new Date(msTimestamp) : new Date();
|
||
date.setHours(0, 0, 0, 0);
|
||
return Math.floor(date.getTime() / 1000);
|
||
},
|
||
replacePattern(text: string) {
|
||
// @ts-ignore
|
||
return text
|
||
.replaceAll("{year}", dayjs().format("YYYY"))
|
||
.replaceAll("{month}", dayjs().format("MM"))
|
||
.replaceAll("{day}", dayjs().format("DD"))
|
||
.replaceAll("{hour}", dayjs().format("HH"))
|
||
.replaceAll("{minute}", dayjs().format("mm"))
|
||
.replaceAll("{second}", dayjs().format("ss"));
|
||
},
|
||
};
|
||
|
||
export const FileUtil = {
|
||
MIME_TYPES: {
|
||
html: "text/html",
|
||
htm: "text/html",
|
||
js: "application/javascript",
|
||
css: "text/css",
|
||
json: "application/json",
|
||
png: "image/png",
|
||
jpg: "image/jpeg",
|
||
jpeg: "image/jpeg",
|
||
gif: "image/gif",
|
||
svg: "image/svg+xml",
|
||
webp: "image/webp",
|
||
woff: "font/woff",
|
||
woff2: "font/woff2",
|
||
ttf: "font/ttf",
|
||
otf: "font/otf",
|
||
mp3: "audio/mpeg",
|
||
mp4: "video/mp4",
|
||
wav: "audio/wav",
|
||
wasm: "application/wasm",
|
||
eot: "application/vnd.ms-fontobject",
|
||
},
|
||
getMimeByExt(ext: string, defaultMime: string = ""): string {
|
||
ext = ext.toLowerCase();
|
||
if (ext.startsWith(".")) {
|
||
ext = ext.substring(1);
|
||
}
|
||
return FileUtil.MIME_TYPES[ext] || defaultMime;
|
||
},
|
||
getMimeByPath(p: string, defaultMime: string = ""): string {
|
||
const extension = p.split(".").pop().toLowerCase();
|
||
return FileUtil.getMimeByExt(extension, defaultMime);
|
||
},
|
||
streamToBase64(stream: NodeJS.ReadableStream): Promise<string> {
|
||
return new Promise((resolve, reject) => {
|
||
const chunks = [];
|
||
stream.on("data", (chunk) => {
|
||
chunks.push(chunk);
|
||
});
|
||
stream.on("end", () => {
|
||
const buffer = Buffer.concat(chunks);
|
||
resolve(buffer.toString("base64"));
|
||
});
|
||
stream.on("error", (error) => {
|
||
reject(error);
|
||
});
|
||
});
|
||
},
|
||
bufferToBase64(buffer: Buffer) {
|
||
let binary = "";
|
||
let bytes = new Uint8Array(buffer);
|
||
let len = bytes.byteLength;
|
||
for (let i = 0; i < len; i++) {
|
||
binary += String.fromCharCode(bytes[i]);
|
||
}
|
||
return EncodeUtil.base64Encode(binary);
|
||
},
|
||
base64ToBuffer(base64: string): Buffer {
|
||
if (base64.startsWith("data:")) {
|
||
base64 = base64.split("base64,")[1];
|
||
}
|
||
return Buffer.from(base64, "base64");
|
||
},
|
||
formatSize(size: number) {
|
||
if (size < 1024) {
|
||
return size + "B";
|
||
} else if (size < 1024 * 1024) {
|
||
return (size / 1024).toFixed(2) + "KB";
|
||
} else if (size < 1024 * 1024 * 1024) {
|
||
return (size / 1024 / 1024).toFixed(2) + "MB";
|
||
} else {
|
||
return (size / 1024 / 1024 / 1024).toFixed(2) + "GB";
|
||
}
|
||
},
|
||
async md5(filePath: string) {
|
||
return new Promise((resolve, reject) => {
|
||
const hash = crypto.createHash("md5");
|
||
const stream = fs.createReadStream(filePath);
|
||
stream.on("data", (data) => {
|
||
hash.update(data);
|
||
});
|
||
stream.on("end", () => {
|
||
resolve(hash.digest("hex"));
|
||
});
|
||
stream.on("error", (error) => {
|
||
reject(error);
|
||
});
|
||
});
|
||
},
|
||
};
|
||
|
||
export const JsonUtil = {
|
||
stringifyOrdered(obj: any) {
|
||
return JSON.stringify(obj, Object.keys(obj).sort(), 4);
|
||
},
|
||
stringifyValueOrdered(obj: any) {
|
||
const sortedData = Object.fromEntries(
|
||
Object.entries(obj).sort(([, a], [, b]) => {
|
||
// @ts-ignore
|
||
return ((a as any) - b) as any;
|
||
}),
|
||
);
|
||
return JSON.stringify(sortedData, null, 4);
|
||
},
|
||
};
|
||
|
||
export const ImportUtil = {
|
||
async loadCommonJs(cjsPath: string, forceReload: boolean = true) {
|
||
let tempPath = cjsPath;
|
||
if (forceReload) {
|
||
const md5 = await FileUtil.md5(cjsPath);
|
||
tempPath = path.join(
|
||
await FileIndex.tempDir("commonJs"),
|
||
`${md5}.cjs`,
|
||
);
|
||
if (!fs.existsSync(tempPath)) {
|
||
fs.copyFileSync(cjsPath, tempPath);
|
||
}
|
||
}
|
||
const backend = await import(/* @vite-ignore */ `file://${tempPath}`);
|
||
// console.log('loadCommonJs', `${cjsPath}?t=${md5}`)
|
||
return backend.default;
|
||
},
|
||
};
|
||
|
||
export const MemoryCacheUtil = {
|
||
pool: {} as {
|
||
[key: string]: {
|
||
value: any;
|
||
expire: number;
|
||
};
|
||
},
|
||
_gc() {
|
||
const now = TimeUtil.timestamp();
|
||
for (const key in this.pool) {
|
||
if (this.pool[key].expire < now) {
|
||
delete this.pool[key];
|
||
}
|
||
}
|
||
},
|
||
async remember(
|
||
key: string,
|
||
callback: () => Promise<any>,
|
||
ttl: number = 60,
|
||
) {
|
||
if (this.pool[key] && this.pool[key].expire > TimeUtil.timestamp()) {
|
||
return this.pool[key].value;
|
||
}
|
||
const value = await callback();
|
||
this.pool[key] = {
|
||
value,
|
||
expire: TimeUtil.timestamp() + ttl,
|
||
};
|
||
this._gc();
|
||
return value;
|
||
},
|
||
get(key: string) {
|
||
if (this.pool[key] && this.pool[key].expire > TimeUtil.timestamp()) {
|
||
return this.pool[key].value;
|
||
}
|
||
this._gc();
|
||
return null;
|
||
},
|
||
set(key: string, value: any, ttl: number = 86400) {
|
||
this.pool[key] = {
|
||
value,
|
||
expire: TimeUtil.timestamp() + ttl,
|
||
};
|
||
this._gc();
|
||
},
|
||
forget(key: string) {
|
||
delete this.pool[key];
|
||
},
|
||
};
|
||
|
||
export const MemoryMapCacheUtil = {
|
||
pool: {} as {
|
||
[group: string]: {
|
||
[key: string]: {
|
||
value: any;
|
||
expire: number;
|
||
};
|
||
};
|
||
},
|
||
_gc() {
|
||
const now = TimeUtil.timestamp();
|
||
for (const group in this.pool) {
|
||
for (const key in this.pool[group]) {
|
||
if (this.pool[group][key].expire < now) {
|
||
delete this.pool[group][key];
|
||
}
|
||
}
|
||
}
|
||
},
|
||
get(group: string, key: string) {
|
||
if (
|
||
this.pool[group] &&
|
||
this.pool[group][key] &&
|
||
this.pool[group][key].expire > TimeUtil.timestamp()
|
||
) {
|
||
return this.pool[group][key].value;
|
||
}
|
||
this._gc();
|
||
return null;
|
||
},
|
||
set(group: string, key: string, value: any, ttl: number = 86400) {
|
||
if (!this.pool[group]) {
|
||
this.pool[group] = {};
|
||
}
|
||
this.pool[group][key] = {
|
||
value,
|
||
expire: TimeUtil.timestamp() + ttl,
|
||
};
|
||
this._gc();
|
||
},
|
||
forget(group: string, key: string) {
|
||
if (this.pool[group]) {
|
||
delete this.pool[group][key];
|
||
}
|
||
},
|
||
};
|
||
|
||
export const ShellUtil = {
|
||
quotaPath(p: string) {
|
||
return `"${p}"`;
|
||
},
|
||
parseCommandArgs(command: string) {
|
||
let args = [];
|
||
let arg = "";
|
||
let quote = "";
|
||
let escape = false;
|
||
for (let i = 0; i < command.length; i++) {
|
||
const c = command[i];
|
||
if (escape) {
|
||
arg += c;
|
||
escape = false;
|
||
continue;
|
||
}
|
||
if ("\\" === c) {
|
||
escape = true;
|
||
arg += c;
|
||
continue;
|
||
}
|
||
if ("" === quote && (" " === c || "\t" === c)) {
|
||
if (arg) {
|
||
args.push(arg);
|
||
arg = "";
|
||
}
|
||
continue;
|
||
}
|
||
if ("" === quote && ('"' === c || "'" === c)) {
|
||
quote = c;
|
||
arg += c;
|
||
continue;
|
||
}
|
||
if ('"' === quote && '"' === c) {
|
||
quote = "";
|
||
arg += c;
|
||
continue;
|
||
}
|
||
if ("'" === quote && "'" === c) {
|
||
quote = "";
|
||
arg += c;
|
||
continue;
|
||
}
|
||
arg += c;
|
||
}
|
||
if (arg) {
|
||
args.push(arg);
|
||
}
|
||
return args;
|
||
},
|
||
};
|
||
|
||
export const VersionUtil = {
|
||
/**
|
||
* 检测版本是否匹配
|
||
* @param v string
|
||
* @param match string 如 * 或 >=1.0.0 或 >1.0.0 或 <1.0.0 或 <=1.0.0 或 1.0.0
|
||
*/
|
||
match(v: string, match: string) {
|
||
if (match === "*") {
|
||
return true;
|
||
}
|
||
if (match.startsWith(">=")) {
|
||
if (this.ge(v, match.substring(2))) {
|
||
return true;
|
||
}
|
||
} else if (match.startsWith("<=")) {
|
||
if (this.le(v, match.substring(2))) {
|
||
return true;
|
||
}
|
||
} else if (match.startsWith(">")) {
|
||
if (this.gt(v, match.substring(1))) {
|
||
return true;
|
||
}
|
||
} else if (match.startsWith("<")) {
|
||
if (this.lt(v, match.substring(1))) {
|
||
return true;
|
||
}
|
||
} else {
|
||
return this.eq(v, match);
|
||
}
|
||
return false;
|
||
},
|
||
compare(v1: string, v2: string) {
|
||
const v1Arr = v1.split(".");
|
||
const v2Arr = v2.split(".");
|
||
for (let i = 0; i < v1Arr.length; i++) {
|
||
const v1Num = parseInt(v1Arr[i]);
|
||
const v2Num = parseInt(v2Arr[i]);
|
||
if (v1Num > v2Num) {
|
||
return 1;
|
||
} else if (v1Num < v2Num) {
|
||
return -1;
|
||
}
|
||
}
|
||
return 0;
|
||
},
|
||
gt(v1: string, v2: string) {
|
||
return VersionUtil.compare(v1, v2) > 0;
|
||
},
|
||
ge(v1: string, v2: string) {
|
||
return VersionUtil.compare(v1, v2) >= 0;
|
||
},
|
||
lt(v1: string, v2: string) {
|
||
return VersionUtil.compare(v1, v2) < 0;
|
||
},
|
||
le: (v1: string, v2: string) => {
|
||
return VersionUtil.compare(v1, v2) <= 0;
|
||
},
|
||
eq: (v1: string, v2: string) => {
|
||
return VersionUtil.compare(v1, v2) === 0;
|
||
},
|
||
};
|
||
|
||
export const UIUtil = {
|
||
sizeToPx(size: string, sizeFull: number) {
|
||
if (/^\d+$/.test(size)) {
|
||
// 纯数字
|
||
return parseInt(size);
|
||
} else if (size.endsWith("%")) {
|
||
// 百分比
|
||
let result = Math.floor((sizeFull * parseInt(size)) / 100);
|
||
result = Math.min(result, sizeFull);
|
||
return result;
|
||
} else {
|
||
throw "UnsupportSizeString";
|
||
}
|
||
},
|
||
};
|
||
|
||
export const ReUtil = {
|
||
match(regex: string, text: string) {
|
||
if ("" === regex || null === regex) {
|
||
return false;
|
||
}
|
||
if (regex.startsWith("/")) {
|
||
const index = regex.lastIndexOf("/");
|
||
const source = regex.slice(1, index);
|
||
const flags = regex.slice(index + 1);
|
||
return new RegExp(source, flags).test(text);
|
||
}
|
||
return new RegExp(regex).test(text);
|
||
},
|
||
};
|
||
|
||
const converter = new Showdown.Converter({
|
||
tables: true,
|
||
});
|
||
export const MarkdownUtil = {
|
||
toHtml(markdown: string): string {
|
||
return converter.makeHtml(markdown);
|
||
},
|
||
};
|
||
|
||
type HotkeyModifierType =
|
||
| "Control"
|
||
| "Option"
|
||
| "Command"
|
||
| "Ctrl"
|
||
| "Alt"
|
||
| "Win"
|
||
| "Meta"
|
||
| "Shift";
|
||
type HotkeyType = { key: string; modifiers: HotkeyModifierType[] };
|
||
|
||
export const HotKeyUtil = {
|
||
orderModifiers(modifiers: HotkeyModifierType[]) {
|
||
const order = [
|
||
"Control",
|
||
"Ctrl",
|
||
"Command",
|
||
"Meta",
|
||
"Win",
|
||
"Option",
|
||
"Alt",
|
||
"Shift",
|
||
];
|
||
return modifiers.sort((a, b) => {
|
||
return order.indexOf(a) - order.indexOf(b);
|
||
});
|
||
},
|
||
unifyObject(hotkey: HotkeyType) {
|
||
return {
|
||
key: hotkey.key.toUpperCase(),
|
||
modifiers: this.orderModifiers(
|
||
hotkey.modifiers.map((modifier) => StrUtil.ucFirst(modifier)),
|
||
),
|
||
};
|
||
},
|
||
unifyString(hotkey: string): HotkeyType {
|
||
const parts = hotkey.split("+");
|
||
const key = parts.pop() || "";
|
||
const modifiers: any[] = [];
|
||
parts.forEach((part) => {
|
||
modifiers.push(StrUtil.ucFirst(part.trim()));
|
||
});
|
||
return this.unifyObject({ key, modifiers });
|
||
},
|
||
unify(
|
||
hotkeys: string | string[] | HotkeyType | HotkeyType[],
|
||
): HotkeyType[] {
|
||
if (typeof hotkeys === "string") {
|
||
return [this.unifyString(hotkeys)];
|
||
} else if (Array.isArray(hotkeys)) {
|
||
return hotkeys.map((hotkey) => {
|
||
if (typeof hotkey === "string") {
|
||
return this.unifyString(hotkey);
|
||
} else {
|
||
return this.unifyObject(hotkey);
|
||
}
|
||
});
|
||
} else {
|
||
return [this.unifyObject(hotkeys)];
|
||
}
|
||
},
|
||
getFromEvent(event: any): HotkeyType | null {
|
||
const valid = [
|
||
"A",
|
||
"B",
|
||
"C",
|
||
"D",
|
||
"E",
|
||
"F",
|
||
"G",
|
||
"H",
|
||
"I",
|
||
"J",
|
||
"K",
|
||
"L",
|
||
"M",
|
||
"N",
|
||
"O",
|
||
"P",
|
||
"Q",
|
||
"R",
|
||
"S",
|
||
"T",
|
||
"U",
|
||
"V",
|
||
"W",
|
||
"X",
|
||
"Y",
|
||
"Z",
|
||
"1",
|
||
"2",
|
||
"3",
|
||
"4",
|
||
"5",
|
||
"6",
|
||
"7",
|
||
"8",
|
||
"9",
|
||
"0",
|
||
"Space",
|
||
];
|
||
const key = (event.key || "").toUpperCase();
|
||
if (!event || !event.key || !valid.includes(key)) {
|
||
return null;
|
||
}
|
||
const modifiers: HotkeyModifierType[] = [];
|
||
if (isWin) {
|
||
if (event.ctrlKey || event.control) {
|
||
modifiers.push("Ctrl");
|
||
}
|
||
if (event.altKey || event.alt) {
|
||
modifiers.push("Alt");
|
||
}
|
||
if (event.metaKey || event.meta) {
|
||
modifiers.push("Win");
|
||
}
|
||
} else if (isMac) {
|
||
if (event.ctrlKey || event.control) {
|
||
modifiers.push("Control");
|
||
}
|
||
if (event.altKey || event.alt) {
|
||
modifiers.push("Option");
|
||
}
|
||
if (event.metaKey || event.meta) {
|
||
modifiers.push("Command");
|
||
}
|
||
} else {
|
||
if (event.ctrlKey || event.control) {
|
||
modifiers.push("Ctrl");
|
||
}
|
||
if (event.altKey || event.alt) {
|
||
modifiers.push("Alt");
|
||
}
|
||
if (event.metaKey || event.meta) {
|
||
modifiers.push("Meta");
|
||
}
|
||
}
|
||
if (event.shiftKey || event.shift) {
|
||
modifiers.push("Shift");
|
||
}
|
||
return this.unifyObject({ key, modifiers });
|
||
},
|
||
match(hotkeysForMatch: HotkeyType[], hotkey: HotkeyType): boolean {
|
||
if (!hotkeysForMatch || !hotkey) {
|
||
return false;
|
||
}
|
||
const hotKeyStr = hotkey.modifiers.join("+") + "+" + hotkey.key;
|
||
for (const key of hotkeysForMatch) {
|
||
const keyStr = key.modifiers.join("+") + "+" + key.key;
|
||
if (keyStr === hotKeyStr) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
},
|
||
};
|