@nsnanocat/util 1.7.0

package/polyfill/Storage.mjs

@@ -0,0 +1,257 @@
+import { $app } from "../lib/app.mjs";
+import { Lodash as _ } from "./Lodash.mjs";
+
+/**
+ * Storage
+ *
+ * @link https://developer.mozilla.org/zh-CN/docs/Web/API/Storage/setItem
+ * @export
+ * @class Storage
+ * @typedef {Storage}
+ */
+export class Storage {
+	/**
+	 * data
+	 *
+	 * @static
+	 * @type {file}
+	 */
+	static data = null;
+	static dataFile = "box.dat";
+	/**
+	 * nameRegex
+	 *
+	 * @static
+	 * @type {regexp}
+	 */
+	static #nameRegex = /^@(?<key>[^.]+)(?:\.(?<path>.*))?$/;
+
+	/**
+	 * getItem
+	 *
+	 * @static
+	 * @param {string} keyName
+	 * @param {*} [defaultValue]
+	 * @returns {*}
+	 */
+	static getItem(keyName, defaultValue = null) {
+		let keyValue = defaultValue;
+		// 如果以 @
+		switch (keyName.startsWith("@")) {
+			case true: {
+				const { key, path } = keyName.match(Storage.#nameRegex)?.groups;
+				keyName = key;
+				let value = Storage.getItem(keyName, {});
+				if (typeof value !== "object") value = {};
+				keyValue = _.get(value, path);
+				try {
+					keyValue = JSON.parse(keyValue);
+				} catch (e) {}
+				break;
+			}
+			default:
+				switch ($app) {
+					case "Surge":
+					case "Loon":
+					case "Stash":
+					case "Egern":
+					case "Shadowrocket":
+						keyValue = $persistentStore.read(keyName);
+						break;
+					case "Quantumult X":
+						keyValue = $prefs.valueForKey(keyName);
+						break;
+					case "Node.js":
+						Storage.data = Storage.#loaddata(Storage.dataFile);
+						keyValue = Storage.data?.[keyName];
+						break;
+					default:
+						keyValue = Storage.data?.[keyName] || null;
+						break;
+				}
+				try {
+					keyValue = JSON.parse(keyValue);
+				} catch (e) {
+					// do nothing
+				}
+				break;
+		}
+		return keyValue ?? defaultValue;
+	}
+
+	/**
+	 * setItem
+	 *
+	 * @static
+	 * @param {string} keyName
+	 * @param {*} keyValue
+	 * @returns {boolean}
+	 */
+	static setItem(keyName = new String(), keyValue = new String()) {
+		let result = false;
+		switch (typeof keyValue) {
+			case "object":
+				keyValue = JSON.stringify(keyValue);
+				break;
+			default:
+				keyValue = String(keyValue);
+				break;
+		}
+		switch (keyName.startsWith("@")) {
+			case true: {
+				const { key, path } = keyName.match(Storage.#nameRegex)?.groups;
+				keyName = key;
+				let value = Storage.getItem(keyName, {});
+				if (typeof value !== "object") value = {};
+				_.set(value, path, keyValue);
+				result = Storage.setItem(keyName, value);
+				break;
+			}
+			default:
+				switch ($app) {
+					case "Surge":
+					case "Loon":
+					case "Stash":
+					case "Egern":
+					case "Shadowrocket":
+						result = $persistentStore.write(keyValue, keyName);
+						break;
+					case "Quantumult X":
+						result = $prefs.setValueForKey(keyValue, keyName);
+						break;
+					case "Node.js":
+						Storage.data = Storage.#loaddata(Storage.dataFile);
+						Storage.data[keyName] = keyValue;
+						Storage.#writedata(Storage.dataFile);
+						result = true;
+						break;
+					default:
+						result = Storage.data?.[keyName] || null;
+						break;
+				}
+				break;
+		}
+		return result;
+	}
+
+	/**
+	 * removeItem
+	 *
+	 * @static
+	 * @param {string} keyName
+	 * @returns {boolean}
+	 */
+	static removeItem(keyName) {
+		let result = false;
+		switch (keyName.startsWith("@")) {
+			case true: {
+				const { key, path } = keyName.match(Storage.#nameRegex)?.groups;
+				keyName = key;
+				let value = Storage.getItem(keyName);
+				if (typeof value !== "object") value = {};
+				keyValue = _.unset(value, path);
+				result = Storage.setItem(keyName, value);
+				break;
+			}
+			default:
+				switch ($app) {
+					case "Surge":
+					case "Loon":
+					case "Stash":
+					case "Egern":
+					case "Shadowrocket":
+						result = false;
+						break;
+					case "Quantumult X":
+						result = $prefs.removeValueForKey(keyName);
+						break;
+					case "Node.js":
+						result = false;
+						break;
+					default:
+						result = false;
+						break;
+				}
+				break;
+		}
+		return result;
+	}
+
+	/**
+	 * clear
+	 *
+	 * @static
+	 * @returns {boolean}
+	 */
+	static clear() {
+		let result = false;
+		switch ($app) {
+			case "Surge":
+			case "Loon":
+			case "Stash":
+			case "Egern":
+			case "Shadowrocket":
+				result = false;
+				break;
+			case "Quantumult X":
+				result = $prefs.removeAllValues();
+				break;
+			case "Node.js":
+				result = false;
+				break;
+			default:
+				result = false;
+				break;
+		}
+		return result;
+	}
+
+	/**
+	 * #loaddata
+	 *
+	 * @param {string} dataFile
+	 * @returns {*}
+	 */
+	static #loaddata = dataFile => {
+		if ($app === "Node.js") {
+			this.fs = this.fs ? this.fs : require("node:fs");
+			this.path = this.path ? this.path : require("node:path");
+			const curDirDataFilePath = this.path.resolve(dataFile);
+			const rootDirDataFilePath = this.path.resolve(process.cwd(), dataFile);
+			const isCurDirDataFile = this.fs.existsSync(curDirDataFilePath);
+			const isRootDirDataFile = !isCurDirDataFile && this.fs.existsSync(rootDirDataFilePath);
+			if (isCurDirDataFile || isRootDirDataFile) {
+				const datPath = isCurDirDataFile ? curDirDataFilePath : rootDirDataFilePath;
+				try {
+					return JSON.parse(this.fs.readFileSync(datPath));
+				} catch (e) {
+					return {};
+				}
+			} else return {};
+		} else return {};
+	};
+
+	/**
+	 * #writedata
+	 *
+	 * @param {string} [dataFile=this.dataFile]
+	 */
+	static #writedata = (dataFile = this.dataFile) => {
+		if ($app === "Node.js") {
+			this.fs = this.fs ? this.fs : require("node:fs");
+			this.path = this.path ? this.path : require("node:path");
+			const curDirDataFilePath = this.path.resolve(dataFile);
+			const rootDirDataFilePath = this.path.resolve(process.cwd(), dataFile);
+			const isCurDirDataFile = this.fs.existsSync(curDirDataFilePath);
+			const isRootDirDataFile = !isCurDirDataFile && this.fs.existsSync(rootDirDataFilePath);
+			const jsondata = JSON.stringify(this.data);
+			if (isCurDirDataFile) {
+				this.fs.writeFileSync(curDirDataFilePath, jsondata);
+			} else if (isRootDirDataFile) {
+				this.fs.writeFileSync(rootDirDataFilePath, jsondata);
+			} else {
+				this.fs.writeFileSync(curDirDataFilePath, jsondata);
+			}
+		}
+	};
+}

package/polyfill/fetch.mjs

@@ -0,0 +1,176 @@
+import { $app } from "../lib/app.mjs";
+import { Console } from "./Console.mjs";
+import { Lodash as _ } from "./Lodash.mjs";
+
+/**
+ * fetch
+ *
+ * @link https://developer.mozilla.org/zh-CN/docs/Web/API/Fetch_API
+ * @export
+ * @async
+ * @param {object|string} request
+ * @param {object} [option]
+ * @returns {Promise<object>}
+ */
+export async function fetch(request, option) {
+	// 初始化参数
+	switch (request.constructor) {
+		case Object:
+			request = { ...option, ...request };
+			break;
+		case String:
+			request = { ...option, url: request };
+			break;
+	}
+	// 自动判断请求方法
+	if (!request.method) {
+		request.method = "GET";
+		if (request.body ?? request.bodyBytes) request.method = "POST";
+	}
+	// 移除请求头中的部分参数, 让其自动生成
+	delete request.headers?.Host;
+	delete request.headers?.[":authority"];
+	delete request.headers?.["Content-Length"];
+	delete request.headers?.["content-length"];
+	// 定义请求方法（小写）
+	const method = request.method.toLocaleLowerCase();
+	// 判断平台
+	switch ($app) {
+		case "Loon":
+		case "Surge":
+		case "Stash":
+		case "Egern":
+		case "Shadowrocket":
+		default:
+			// 转换请求参数
+			if (request.timeout) {
+				request.timeout = Number.parseInt(request.timeout, 10);
+				switch ($app) {
+					case "Loon":
+					case "Shadowrocket":
+					case "Stash":
+					case "Egern":
+					default:
+						request.timeout = request.timeout / 1000;
+						break;
+					case "Surge":
+						break;
+				}
+			}
+			if (request.policy) {
+				switch ($app) {
+					case "Loon":
+						request.node = request.policy;
+						break;
+					case "Stash":
+						_.set(request, "headers.X-Stash-Selected-Proxy", encodeURI(request.policy));
+						break;
+					case "Shadowrocket":
+						_.set(request, "headers.X-Surge-Proxy", request.policy);
+						break;
+				}
+			}
+			if (typeof request.redirection === "boolean") request["auto-redirect"] = request.redirection;
+			// 转换请求体
+			if (request.bodyBytes && !request.body) {
+				request.body = request.bodyBytes;
+				request.bodyBytes = undefined;
+			}
+			// 判断是否请求二进制响应体
+			switch ((request.headers?.Accept || request.headers?.accept)?.split(";")?.[0]) {
+				case "application/protobuf":
+				case "application/x-protobuf":
+				case "application/vnd.google.protobuf":
+				case "application/vnd.apple.flatbuffer":
+				case "application/grpc":
+				case "application/grpc+proto":
+				case "application/octet-stream":
+					request["binary-mode"] = true;
+					break;
+			}
+			// 发送请求
+			return await new Promise((resolve, reject) => {
+				$httpClient[method](request, (error, response, body) => {
+					if (error) reject(error);
+					else {
+						response.ok = /^2\d\d$/.test(response.status);
+						response.statusCode = response.status;
+						if (body) {
+							response.body = body;
+							if (request["binary-mode"] == true) response.bodyBytes = body;
+						}
+						resolve(response);
+					}
+				});
+			});
+		case "Quantumult X":
+			// 转换请求参数
+			if (request.policy) _.set(request, "opts.policy", request.policy);
+			if (typeof request["auto-redirect"] === "boolean") _.set(request, "opts.redirection", request["auto-redirect"]);
+			// 转换请求体
+			if (request.body instanceof ArrayBuffer) {
+				request.bodyBytes = request.body;
+				request.body = undefined;
+			} else if (ArrayBuffer.isView(request.body)) {
+				request.bodyBytes = request.body.buffer.slice(request.body.byteOffset, request.body.byteLength + request.body.byteOffset);
+				request.body = undefined;
+			} else if (request.body) request.bodyBytes = undefined;
+			// 发送请求
+			return await $task.fetch(request).then(
+				response => {
+					response.ok = /^2\d\d$/.test(response.statusCode);
+					response.status = response.statusCode;
+					switch ((response.headers?.["Content-Type"] ?? response.headers?.["content-type"])?.split(";")?.[0]) {
+						case "application/protobuf":
+						case "application/x-protobuf":
+						case "application/vnd.google.protobuf":
+						case "application/vnd.apple.flatbuffer":
+						case "application/grpc":
+						case "application/grpc+proto":
+						case "application/octet-stream":
+							response.body = response.bodyBytes;
+							break;
+						case undefined:
+						default:
+							break;
+					}
+					response.bodyBytes = undefined;
+					return response;
+				},
+				reason => Promise.reject(reason.error),
+			);
+		case "Node.js": {
+			const iconv = require("iconv-lite");
+			const got = globalThis.got ? globalThis.got : require("got");
+			const cktough = globalThis.cktough ? globalThis.cktough : require("tough-cookie");
+			const ckjar = globalThis.ckjar ? globalThis.ckjar : new cktough.CookieJar();
+			if (request) {
+				request.headers = request.headers ? request.headers : {};
+				if (undefined === request.headers.Cookie && undefined === request.cookieJar) request.cookieJar = ckjar;
+			}
+			const { url, ...option } = request;
+			return await got[method](url, option)
+				.on("redirect", (response, nextOpts) => {
+					try {
+						if (response.headers["set-cookie"]) {
+							const ck = response.headers["set-cookie"].map(cktough.Cookie.parse).toString();
+							if (ck) ckjar.setCookieSync(ck, null);
+							nextOpts.cookieJar = ckjar;
+						}
+					} catch (e) {
+						Console.error(e);
+					}
+					// ckjar.setCookieSync(response.headers["set-cookie"].map(Cookie.parse).toString())
+				})
+				.then(
+					response => {
+						response.statusCode = response.status;
+						response.body = iconv.decode(response.rawBody, "utf-8");
+						response.bodyBytes = response.rawBody;
+						return response;
+					},
+					error => Promise.reject(error.message),
+				);
+		}
+	}
+}

package/polyfill/index.js

@@ -0,0 +1,5 @@
+export * from "./Console.mjs";
+export * from "./fetch.mjs";
+export * from "./Lodash.mjs";
+export * from "./StatusCodes.mjs";
+export * from "./Storage.mjs";