@iftc/yete 0.0.1-alpha.4 → 0.0.1-alpha.6

package/function/md2html.js

@@ -0,0 +1,6 @@
+const { marked } = require('marked');
+module.exports = function (md) {
+    if (md) {
+        return marked(md);
+    }
+}

package/index.js

@@ -12,6 +12,53 @@ class YeteError extends Error {
         this.name = 'YeteError';
     }
 }
+/**
+ * 检查浏览器兼容性
+ * @throws {YeteError} 如果不兼容或无法判断则抛出错误
+ */
+(function checkBrowserCompatibility() {
+    const ua = navigator.userAgent;
+    let browser = null;
+    let version = 0;
+    if (/Edg\/(\d+)/.test(ua)) {
+        browser = 'Edge';
+        version = parseInt(ua.match(/Edg\/(\d+)/)[1], 10);
+    } else if (/Chrome\/(\d+)/.test(ua) && !/Chromium/.test(ua)) {
+        browser = 'Chrome';
+        version = parseInt(ua.match(/Chrome\/(\d+)/)[1], 10);
+    } else if (/Firefox\/(\d+)/.test(ua)) {
+        browser = 'Firefox';
+        version = parseInt(ua.match(/Firefox\/(\d+)/)[1], 10);
+    } else if (/Version\/(\d+)/.test(ua) && /Safari/.test(ua)) {
+        browser = 'Safari';
+        version = parseInt(ua.match(/Version\/(\d+)/)[1], 10);
+    } else if (/VVBrowser\/(\d+)/.test(ua)) {
+        browser = 'VVBrowser';
+        version = parseInt(ua.match(/VVBrowser\/(\d+)/)[1], 10);
+    }
+    console.log(browser, version);
+    const minVersions = {
+        'Chrome': 87,
+        'Firefox': 140,
+        'Safari': 18.4,
+        'Edge': 87,
+        'VVBrowser': 1
+    };
+    let isCompatible = false;
+    if (browser && minVersions[browser] !== undefined) {
+        if (version >= minVersions[browser]) {
+            isCompatible = true;
+        }
+    }
+    if (!isCompatible) {
+        const msg = browser
+            ? `您的浏览器版本过低 (${browser} ${version})，请使用 Chrome 71+, Firefox 69+, Safari 12.1+, Edge 79+ 或 VVBrowser 1+ 浏览器。`
+            : `无法识别您的浏览器环境，请使用现代浏览器 (Chrome, Firefox, Safari, Edge, VVBrowser)。`;
+
+        alert(msg);
+        console.error(new YeteError('Browser incompatible'));
+    }
+})();
 /**
  * 页面基类
  * @example
@@ -69,6 +116,8 @@ let custom502Page = null;
 
 let searchParams = new URLSearchParams("");
 
+const hostname = location.hostname;
+
 /**
  * 导出的对象
  */
@@ -561,6 +610,26 @@ const obj = {
         static async readHeaders(response) {
             return response.headers;
         }
+        /**
+         * 读取响应 Cookie
+         * @param {Response} response 
+         * @returns {Promise<Cookie[]>}
+         * @example
+         * const cookies = await HTTP.readCookies(res);
+         */
+        static async readCookies(response) {
+            return response.cookies;
+        }
+        /**
+         * 获取代理 URL
+         * @param {String} url 
+         * @returns {String}
+         * @example
+         * const proxyURL = HTTP.proxy("https://example.com");
+         */
+        static proxy(url) {
+            return "https://iftc.koyeb.app/proxy?url=" + encodeURIComponent(url);
+        }
     },
     /**
      * 获取 URL 参数
@@ -592,6 +661,615 @@ const obj = {
         } else {
             return loadUI(str);
         }
+    },
+    /**
+     * 认证管理类
+     * @description 提供用户认证、令牌管理、授权验证等功能
+     */
+    Auth: class {
+        /**
+         * 构造函数
+         * @param {Object} options 配置选项
+         * @property {String} apiBaseUrl API 基础地址
+         * @property {String} tokenKey localStorage 中存储 token 的键名
+         */
+        constructor(options = {}) {
+            this.apiBaseUrl = options.apiBaseUrl || 'https://iftc.koyeb.app/api/auth';
+            this.tokenKey = options.tokenKey || 'auth_token';
+            this.checkInterval = options.checkInterval || 2000;
+            this.onAuthSuccess = options.onAuthSuccess || null;
+            this.onAuthFail = options.onAuthFail || null;
+        }
+
+        /**
+         * 获取存储的 auth_token
+         * @returns {String|null}
+         * @example
+         * const token = auth.getAuthToken();
+         */
+        getAuthToken() {
+            return localStorage.getItem(this.tokenKey);
+        }
+
+        /**
+         * 设置存储的 auth_token
+         * @param {String} token 
+         * @example
+         * auth.setAuthToken('your_token_here');
+         */
+        setAuthToken(token) {
+            localStorage.setItem(this.tokenKey, token);
+        }
+
+        /**
+         * 清除存储的 auth_token
+         * @example
+         * auth.clearAuthToken();
+         */
+        clearAuthToken() {
+            localStorage.removeItem(this.tokenKey);
+        }
+
+        /**
+         * 检查是否已授权
+         * @returns {Promise<Boolean>}
+         * @example
+         * if (auth.isAuthorized()) { ... }
+         */
+        async isAuthorized() {
+            return !!await cookieStore.get("ID");
+        }
+
+        /**
+         * 获取授权链接
+         * @param {String} redirectUrl 回调地址
+         * @returns {String}
+         * @example
+         * const url = auth.getAuthUrl(location.href);
+         */
+        getAuthUrl(redirectUrl) {
+            return `${this.apiBaseUrl}/token?redirect=${encodeURIComponent(redirectUrl)}`;
+        }
+
+        /**
+         * 发起授权请求
+         * @description 跳转到授权页面
+         * @param {String} redirectUrl 回调地址
+         * @example
+         * auth.requestAuth(location.href);
+         */
+        async requestAuth(redirectUrl) {
+            const url = this.getAuthUrl(redirectUrl);
+            const response = await fetch(url);
+            const json = await response.json();
+
+            if (json.code !== 200) {
+                throw new YeteError(json.msg || '获取授权令牌失败');
+            }
+
+            this.setAuthToken(json.data.token);
+            location.href = json.data.url;
+            return json;
+        }
+
+        /**
+         * 验证 auth_token 有效性
+         * @param {String} token 可选，不传则使用存储的 auth_token
+         * @returns {Promise<Boolean>}
+         * @example
+         * const isValid = await auth.verify();
+         */
+        async verify(token = null) {
+            const targetToken = token || this.getAuthToken();
+
+            if (!targetToken) {
+                throw new YeteError('未找到授权令牌');
+            }
+
+            const response = await fetch(`${this.apiBaseUrl}/verify?token=${targetToken}`);
+            const json = await response.json();
+
+            if (json.code === 200) {
+                await this.setCookie('ID', json.data.id, 365);
+                localStorage.setItem("ID", json.data.id);
+                return true;
+            }
+
+            return false;
+        }
+        /**
+         * 设置 cookie
+         * @param {String} name 键名
+         * @param {String} value 键值
+         * @param {Number} days 过期天数
+         */
+        async setCookie(name, value, days = 1) {
+            const expires = new Date();
+            expires.setTime(expires.getTime() + days * 24 * 60 * 60 * 1000);
+
+            try {
+                console.log(location.hostname);
+                await cookieStore.set({
+                    name,
+                    value,
+                    expires: expires.toISOString(),
+                    path: '/',
+                    domain: hostname,
+                    secure: true
+                });
+            } catch (error) {
+                console.warn('cookieStore not supported, falling back to document.cookie');
+                document.cookie = `${name}=${value}; expires=${expires.toUTCString()}; path=/`;
+            }
+        }
+
+        /**
+         * 获取 cookie
+         * @param {String} name 键名
+         * @returns {String|null}
+         */
+        async getCookie(name) {
+            try {
+                const cookies = await cookieStore.get(name);
+                return cookies ? cookies.value : null;
+            } catch (error) {
+                // 如果 cookieStore 不支持，降级到 document.cookie
+                console.warn('cookieStore not supported, falling back to document.cookie');
+                return this.getCookieFromDocument(name);
+            }
+        }
+
+        /**
+         * 从 document.cookie 获取 cookie（备用方案）
+         * @param {String} name 键名
+         * @returns {String|null}
+         */
+        getCookieFromDocument(name) {
+            const nameEQ = name + "=";
+            const ca = document.cookie.split(';');
+            for (let i = 0; i < ca.length; i++) {
+                let c = ca[i];
+                while (c.charAt(0) === ' ') c = c.substring(1, c.length);
+                if (c.indexOf(nameEQ) === 0) {
+                    return c.substring(nameEQ.length, c.length);
+                }
+            }
+            return null;
+        }
+
+        /**
+         * 获取用户 ID
+         * @returns {String|null}
+         */
+        getUserId() {
+            return localStorage.getItem("ID");
+        }
+
+        /**
+         * 检查授权状态并等待授权完成
+         * @param {Function} callback 授权成功后的回调
+         * @param {Number} timeout 超时时间（毫秒）
+         * @returns {Promise<Object>}
+         * @example
+         * await auth.waitForAuth((userInfo) => {
+         *     console.log('用户 ID:', userInfo.id);
+         * });
+         */
+        async waitForAuth(callback, timeout = 60000) {
+            const url = new URL(location.href);
+            const authParam = url.searchParams.get('auth');
+
+            if (!authParam) {
+                throw new YeteError('缺少 auth 参数');
+            }
+
+            return new Promise((resolve, reject) => {
+                const startTime = Date.now();
+                const intervalId = setInterval(async () => {
+                    // 检查超时
+                    if (Date.now() - startTime > timeout) {
+                        clearInterval(intervalId);
+                        reject(new YeteError('授权超时'));
+                        return;
+                    }
+
+                    try {
+                        const json = await this.verify();
+                        if (json.code === 200) {
+                            clearInterval(intervalId);
+                            if (callback) callback(json.data);
+                            if (this.onAuthSuccess) this.onAuthSuccess(json.data);
+                            resolve(json);
+                        }
+                    } catch (error) {
+                        console.error('验证失败:', error);
+                    }
+                }, this.checkInterval);
+            });
+        }
+
+        /**
+         * 处理授权回调
+         * @description 在授权回调页面调用此方法
+         * @param {Function} successCallback 授权成功回调
+         * @param {Function} failCallback 授权失败回调
+         * @example
+         * auth.handleAuthCallback((userInfo) => {
+         *     document.write('授权成功，用户 ID: ' + userInfo.id);
+         * });
+         */
+        async handleAuthCallback(successCallback, failCallback) {
+            const url = new URL(location.href);
+            const authParam = url.searchParams.get('auth');
+
+            if (!authParam) {
+                return;
+            }
+
+            try {
+                const result = await this.waitForAuth(successCallback);
+                if (successCallback) {
+                    successCallback(result.data);
+                }
+            } catch (error) {
+                console.error('授权失败:', error);
+                if (failCallback) {
+                    failCallback(error);
+                }
+                if (this.onAuthFail) {
+                    this.onAuthFail(error);
+                }
+            }
+        }
+
+        /**
+         * 获取用户信息
+         * @returns {Promise<Object>}
+         * @example
+         * const userInfo = await auth.getUserInfo();
+         */
+        async getUserInfo() {
+            const res = await fetch(`${this.apiBaseUrl}/api/user/details?ID=${this.getUserId()}`);
+        }
+
+        /**
+         * 登出
+         * @example
+         * auth.logout();
+         */
+        logout() {
+            this.clearAuthToken();
+            location.reload();
+        }
+    },
+    Complex: Complex,
+    /**
+     * 屏幕颜色选择器
+     * @description 该功能必须由用户主动触发（如点击按钮）才行。
+     * @returns {Promise<string>} 十六进制颜色值(如#FF0000)
+     * @throws {YeteError} 如果用户取消了选择或浏览器不支持 EyeDropper API
+     * @example
+     * button.addEventListener('click', async () => {
+     *   const color = await colorPicker();
+     *   console.log(color);
+     * })
+     */
+    colorPicker: function () {
+        if (!globalThis.EyeDropper) {
+            throw new YeteError("Your browser does not support the EyeDropper API. Please use a compatible browser (Chrome 95+, Edge 95+, or Opera 81+).");
+        }
+        const eyeDropper = new EyeDropper();
+        const abortController = new AbortController();
+        return eyeDropper.open({ signal: abortController.signal }).then(result => result.sRGBHex).catch(error => {
+            if (error.name === 'AbortError') {
+                throw new YeteError('用户取消了选择');
+            } else {
+                throw error;
+            }
+        });
+    }
+};
+
+/**
+ * 复数类
+ */
+class Complex {
+    /**
+     * 复数构造函数
+     * @param {number} real 实部
+     * @param {number} imag 虚部
+     */
+    constructor(real = 0, imag = 0) {
+        this.real = real;
+        this.imag = imag;
+    }
+    /**
+     * 字符串转复数类
+     * @param {String} complexString 
+     * @returns {Complex}
+     * @example
+     * const complex = new Complex();
+     * complex.toClass("2+3i"); // 输出：Complex(2, 3)
+     */
+    toClass(complexString) {
+        const parts = complexString.split('+');
+        const real = parseFloat(parts[0]) || 0;
+        const imag = parseFloat(parts[1].slice(0, -1)) || 0;
+        this.real = real;
+        this.imag = imag;
+        return this;
+    }
+    /**
+     * 加法
+     * @param {Complex} other 另一个复数
+     * @returns {Complex} 结果
+     * @example
+     * const c1 = new Complex(2, 3);
+     * const c2 = new Complex(1, 4);
+     * console.log(c1.add(c2)); // 输出：Complex(3, 7)
+     */
+    add(other) {
+        return new Complex(
+            this.real + other.real,
+            this.imag + other.imag
+        );
+    }
+    /**
+     * 减法
+     * @param {Complex} other 另一个复数
+     * @returns {Complex} 减法结果
+     * @example
+     * const c1 = new Complex(2, 3);
+     * const c2 = new Complex(1, 4);
+     * console.log(c1.subtract(c2)); // 输出：Complex(1, -1)
+     */
+    subtract(other) {
+        return new Complex(
+            this.real - other.real,
+            this.imag - other.imag
+        );
+    }
+    /**
+     * 乘法
+     * @param {Complex} other 乘数
+     * @returns {Complex} 乘法结果
+     * @example
+     * const c1 = new Complex(2, 3);
+     * const c2 = new Complex(1, 4);
+     * console.log(c1.multiply(c2)); // 输出：Complex(5, 14)
+     */
+    multiply(other) {
+        return new Complex(
+            this.real * other.real - this.imag * other.imag,
+            this.real * other.imag + this.imag * other.real
+        );
+    }
+    /**
+     * 除法
+     * @param {Complex} other 被除数
+     * @returns {Complex} 除法结果
+     * @example
+     * const c1 = new Complex(2, 3);
+     * const c2 = new Complex(1, 4);
+     * console.log(c1.divide(c2)); // 输出：Complex(0.6, -0.2)
+     */
+    divide(other) {
+        const denominator = other.real * other.real + other.imag * other.imag;
+        if (denominator === 0) {
+            throw new Error("Division by zero complex number");
+        }
+        return new Complex(
+            (this.real * other.real + this.imag * other.imag) / denominator,
+            (this.imag * other.real - this.real * other.imag) / denominator
+        );
+    }
+    /**
+     * 复数转为字符串
+     * @returns {string} 复数字符串表示
+     * @example
+     * const c = new Complex(2, 3);
+     * console.log(c.toString()); // 输出：2+3i
+     */
+    toString() {
+        const sign = this.imag >= 0 ? '+' : '-';
+        return `${this.real} ${sign} ${Math.abs(this.imag)}i`;
+    }
+    /**
+     * 获取复数的模
+     * @returns {number} 模
+     * @example
+     * const c = new Complex(3, 4);
+     * console.log(c.magnitude()); // 输出：5
+     */
+    magnitude() {
+        return Math.sqrt(this.real * this.real + this.imag * this.imag);
+    }
+}
+
+obj.Complex = Complex;
+
+/**
+ * 生成哈希值
+ * @description 与Java的用法一致
+ * @returns {Number}
+ * @example
+ * const hash = 'hello world'.hashCode();
+ */
+String.prototype.hashCode = function () {
+    let hash = 0;
+    for (let i = 0; i < this.length; i++) {
+        const char = this.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash |= 0;
+    }
+    return hash;
+};
+
+/**
+ * 将任意进制的数字转换为十进制(支持小数)
+ * @param {Number} fromRadix - 源进制 (2-36)
+ * @param {Number} toRadix - 目标进制 (2-36)
+ * @returns {String} - 转换后的目标进制的字符串
+ * @example
+ * const result = "10.1".convertBase(2, 10); // 二进制 "10.1" 转换为十进制 "2.5"
+ */
+String.prototype.convertBase = function (fromRadix = 10, toRadix = 10) {
+    return convertBase(this, fromRadix, toRadix);
+};
+
+/**
+ * 将任意进制的数字转换为另一种进制的数字
+ * @param {string} numStr - 输入的数字字符串（例如 "10.1"）
+ * @param {number} fromRadix - 源进制 (2-36)
+ * @param {number} toRadix - 目标进制 (2-36)
+ * @returns {string} - 转换后的字符串
+ */
+function convertBase(numStr, fromRadix, toRadix) {
+    if (fromRadix < 2 || fromRadix > 36 || toRadix < 2 || toRadix > 36) {
+        throw new YeteError("进制必须在 2 到 36 之间");
+    }
+    const decimalValue = convertToDecimal(numStr, fromRadix);
+    return decimalValue.toString(toRadix);
+}
+
+/**
+ * 将任意进制（2-36）的字符串转换为十进制数字（支持小数）
+ * @param {string} str - 输入的数字字符串 (例如 "10.1")
+ * @param {number} radix - 进制数 (例如 2, 8, 16)
+ * @returns {number} - 转换后的十进制数
+ */
+function convertToDecimal(str, radix) {
+    if (radix < 2 || radix > 36) {
+        throw new YeteError("进制必须在 2 到 36 之间");
+    }
+    const input = str.toLowerCase();
+    const parts = input.split('.');
+    const integerPart = parts[0];
+    const fractionalPart = parts[1] || '';
+    let result = 0;
+    let isNegative = input.startsWith('-');
+    if (integerPart && integerPart !== '-') {
+        const cleanInt = integerPart.replace('-', '');
+        result = parseInt(cleanInt, radix);
+        if (isNaN(result)) {
+            throw new YeteError(`整数部分 "${integerPart}" 包含非法字符`);
+        }
+    }
+    let fractionValue = 0;
+    for (let i = 0; i < fractionalPart.length; i++) {
+        const char = fractionalPart[i];
+        const digitValue = parseInt(char, 36);
+        if (isNaN(digitValue) || digitValue >= radix) {
+            throw new YeteError(`小数部分 "${char}" 超出了进制 ${radix} 的范围`);
+        }
+        fractionValue += digitValue * Math.pow(radix, -(i + 1));
+    }
+    result = result + fractionValue;
+    if (isNegative) {
+        result = -result;
+    }
+    return result;
+}
+
+/**
+ * 响应事件监听
+ */
+Response.prototype.events = {};
+/**
+ * 是否正在监听响应事件
+ */
+Response.prototype.listening = false;
+/**
+ * 添加响应事件监听
+ * @param {string} eventName 事件名
+ * @param {function} callback 回调函数
+ * @example
+ * response.on('eventName', function() {})
+ */
+Response.prototype.on = function (eventName, callback) {
+    if (!this.events[eventName]) {
+        this.events[eventName] = [];
+    }
+    this.events[eventName].push(callback);
+};
+/**
+ * 触发事件
+ * @param {string} eventName 事件名
+ * @param {...any} args 参数
+ * @example
+ * response.emit('eventName', '参数1', '参数2', ...);
+ */
+Response.prototype.emit = function (eventName, ...args) {
+    if (this.events[eventName]) {
+        this.events[eventName].forEach(callback => callback(...args));
+    }
+};
+/**
+ * 移除事件监听
+ * @param {string} eventName 事件名
+ * @param {Function} callback 回调函数
+ * @example
+ * response.off('eventName', callback);
+ */
+Response.prototype.off = function (eventName, callback) {
+    if (this.events[eventName]) {
+        this.events[eventName] = this.events[eventName].filter(cb => cb !== callback);
+    }
+};
+/**
+ * 开始同步监听（开启后将无法使用异步）
+ * @returns {Promise<void>}
+ * @example
+ * response.listen();
+ */
+Response.prototype.listen = async function () {
+    if (this.listening) {
+        throw new YeteError('已开启同步监听，请勿重复开启');
+    }
+    const res = this;
+    const headers = res.headers;
+    this.listening = true;
+    const contentType = headers.get('Content-Type');
+    if (contentType && contentType.includes('application/json')) {
+        const json = await res.json();
+        res.emit('res', {
+            type: 'json',
+            data: json,
+        });
+    } else if (contentType && contentType.includes('text/html')) {
+        const text = await res.text();
+        const doc = new DOMParser().parseFromString(text, "text/html");
+        res.emit('res', {
+            type: 'html',
+            data: doc,
+        });
+    } else if (contentType && contentType.includes('text/plain')) {
+        const text = await res.text();
+        res.emit('res', {
+            type: 'text',
+            data: text,
+        })
+    } else if (contentType && contentType.includes('text/xml')) {
+        const text = await res.text();
+        const xmlDoc = new DOMParser().parseFromString(text, "text/xml");
+        res.emit('res', {
+            type: 'xml',
+            data: xmlDoc,
+        });
+    } else if (contentType && contentType.includes('text/event-stream')) {
+        obj.HTTP.readStream(res, ({ chunk, done }) => {
+            res.emit('res', {
+                type: 'stream',
+                data: chunk,
+                done: done,
+            });
+        });
+    } else {
+        const blob = await res.blob();
+        res.emit('res', {
+            type: 'blob',
+            data: blob,
+        });
     }
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iftc/yete",
-  "version": "0.0.1-alpha.4",
+  "version": "0.0.1-alpha.6",
   "description": "",
   "keywords": [
     "IFTC",
@@ -16,6 +16,7 @@
   },
   "dependencies": {
     "dexie": "^4.3.0",
-    "esbuild": "^0.27.3"
+    "esbuild": "^0.27.3",
+    "marked": "^17.0.5"
   }
 }