wowok 2.1.38 → 2.1.40

package/dist/cjs/w/local/token.js

@@ -1,8 +1,3 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * coin type cache
- */
 import { SuiClient } from "../../client/index.js";
 import { getFullnodeUrl } from "../../client/network.js";
 import { GasTokenType } from "../common.js";
@@ -26,7 +21,6 @@ export class TokenInfo {
         }
         return undefined;
     }
-    // alice - name - symbol - tokenType
     async fetch(tokenType, alias, network) {
         tokenType = tokenType ?? GasTokenType;
         const net = await Config.Instance().network_get(network);
@@ -36,29 +30,22 @@ export class TokenInfo {
                 data: [],
             };
         });
-        // 检查缓存中是否已有匹配的token
         let foundToken = cachedData?.data?.find((token) => token.type === tokenType);
         if (!foundToken) {
-            // 如果没找到，从网络获取
             foundToken = await this.fetch_imp(net, tokenType, alias);
             if (!foundToken) {
                 W_ERROR(WErrors.TokenNotFoundLocally, `token type: ${tokenType}`);
                 return undefined;
             }
-            // 将新token添加到缓存数组中
             const updatedTokens = [...(cachedData?.data || []), foundToken];
-            // 更新缓存
             await Cache.read([...this.cacheKey, net], async (_) => ({
                 expire: "INFINITE",
                 data: updatedTokens,
             }), true);
         }
         else if (alias && foundToken.alias !== alias) {
-            // 如果找到了token但alias需要更新
             foundToken.alias = alias;
-            // 更新缓存数组
             const updatedTokens = cachedData?.data?.map((token) => token.type === tokenType ? foundToken : token) || [];
-            // 更新缓存
             await Cache.read([...this.cacheKey, net], async (_) => ({
                 expire: "INFINITE",
                 data: updatedTokens,
@@ -75,22 +62,17 @@ export class TokenInfo {
             };
         });
         let tokens = cachedData?.data || [];
-        // 确定要查询的 token type：优先使用 filter.type，否则默认 GasTokenType
         const targetType = filter?.type ?? GasTokenType;
-        // 如果本地没有找到该 type，从网络获取
-        // 只在指定了 type 时，才用 alias_or_name 作为 alias
         const alias = filter?.type ? filter?.alias_or_name : undefined;
         const foundByType = tokens.find((t) => t.type === targetType);
         if (!foundByType) {
             const fetched = await this.fetch_imp(net, targetType, alias);
             if (fetched) {
-                // 更新缓存
                 const updatedTokens = [...tokens, fetched];
                 await Cache.read([...this.cacheKey, net], async (_) => ({
                     expire: "INFINITE",
                     data: updatedTokens,
                 }), true);
-                // 重新读取缓存
                 cachedData = await Cache.read([...this.cacheKey, net], async (_) => ({
                     expire: "INFINITE",
                     data: updatedTokens,
@@ -101,54 +83,43 @@ export class TokenInfo {
         if (filter) {
             tokens = tokens.filter((token) => {
                 let match = true;
-                // 检查symbol条件
                 if (filter.symbol && match) {
                     match = token.symbol === filter.symbol;
                 }
-                // 检查tokenType条件（使用 targetType，支持默认 GasTokenType）
                 if (filter.type && match) {
                     match = token.type === targetType;
                 }
                 return match;
             });
-            // 对alias_or_name进行模糊搜索并排序
             if (filter.alias_or_name) {
                 const searchTerm = filter.alias_or_name.toLowerCase();
-                // 添加匹配分数
                 tokens = tokens.map((token) => {
                     let score = 0;
                     const alias = token.alias?.toLowerCase() || "";
                     const name = token.name?.toLowerCase() || "";
-                    // 完全匹配得分最高
                     if (alias === searchTerm || name === searchTerm) {
                         score = 3;
                     }
-                    // 以搜索词开头得分次之
                     else if (alias.startsWith(searchTerm) ||
                         name.startsWith(searchTerm)) {
                         score = 2;
                     }
-                    // 包含搜索词得分最低
                     else if (alias.includes(searchTerm) ||
                         name.includes(searchTerm)) {
                         score = 1;
                     }
                     return { ...token, _score: score };
                 });
-                // 过滤掉没有匹配的结果并按分数排序
                 tokens = tokens
                     .filter((token) => token._score > 0)
                     .sort((a, b) => {
-                    // 按匹配分数降序排序
                     const scoreDiff = b._score - a._score;
                     if (scoreDiff !== 0)
                         return scoreDiff;
-                    // 分数相同时，按名称长度升序排序
                     const aNameLength = (a.alias?.length || 0) + (a.name?.length || 0);
                     const bNameLength = (b.alias?.length || 0) + (b.name?.length || 0);
                     return aNameLength - bNameLength;
                 });
-                // 移除临时的_score属性
                 tokens = tokens.map((token) => {
                     const { _score, ...rest } = token;
                     return rest;
@@ -158,4 +129,3 @@ export class TokenInfo {
         return tokens;
     }
 }
-//# sourceMappingURL=token.js.map

package/dist/cjs/w/local/util.d.ts

@@ -1,5 +1 @@
-/**
- * 获取跨平台的 .wow 目录路径
- * 支持通过 WOWOK_DATA_DIR 环境变量覆盖默认路径（主要用于测试隔离）
- */
 export declare function getWowDir(): string;

package/dist/cjs/w/local/util.js

@@ -1,50 +1,26 @@
-// Copyright (c) Wowok.
-// SPDX-License-Identifier: Apache-2.0
-/**
- * 获取跨平台的 .wow 目录路径
- * - Windows: %USERPROFILE%\.wow
- * - macOS: ~/Library/Application Support/.wow
- * - Linux: ~/.config/.wow 或 ~/.local/share/.wow (遵循 XDG 规范)
- *
- * 用于存储 wowok SDK 的数据库文件和配置文件
- */
-// ================================================
-// 跨平台 .wow 目录路径获取
-// ================================================
 import * as path from "path";
 import * as os from "os";
-/**
- * 获取跨平台的 .wow 目录路径
- * 支持通过 WOWOK_DATA_DIR 环境变量覆盖默认路径（主要用于测试隔离）
- */
 export function getWowDir() {
-    // 优先使用环境变量指定的路径（用于测试隔离）
     if (process.env.WOWOK_DATA_DIR) {
         return process.env.WOWOK_DATA_DIR;
     }
     const home = os.homedir();
     const platform = os.platform();
     if (platform === "win32") {
-        // Windows: 使用用户主目录下的 .wow
         return path.join(home, ".wow");
     }
     else if (platform === "darwin") {
-        // macOS: 使用 ~/Library/Application Support/.wow
         return path.join(home, "Library", "Application Support", ".wow");
     }
     else {
-        // Linux 和其他系统: 使用 XDG 规范，优先使用 ~/.config/.wow
         const xdgConfig = process.env.XDG_CONFIG_HOME;
         if (xdgConfig) {
             return path.join(xdgConfig, ".wow");
         }
-        // 回退到 ~/.local/share/.wow
         const xdgData = process.env.XDG_DATA_HOME;
         if (xdgData) {
             return path.join(xdgData, ".wow");
         }
-        // 最后回退到 ~/.wow
         return path.join(home, ".wow");
     }
 }
-//# sourceMappingURL=util.js.map

package/dist/cjs/w/local/wip.d.ts

@@ -56,15 +56,6 @@ export interface WipLimits {
     maxImageCount: number;
     maxTextLength: number;
 }
-/**
- * 默认限制配置
- *
- * 设计考虑:
- * - maxImageSize: 2MB - 单张图片限制，确保 Base64 编码后不会过大
- * - maxTotalSize: 10MB - 整个 WIP 文件大小限制，适合网络传输
- * - maxImageCount: 10 - 最多10张图片，满足大多数承诺场景
- * - maxTextLength: 10000 - 文字内容长度限制，约5000个汉字
- */
 export declare const DEFAULT_LIMITS: WipLimits;
 export declare class WipError extends Error {
     constructor(message: string);
@@ -79,21 +70,9 @@ export declare class WIP {
     private limits;
     private resourceLoader;
     constructor(limits?: Partial<WipLimits>);
-    /**
-     * 创建 WIP 文件
-     */
     create(options: WipCreateOptions): Promise<WipFile>;
-    /**
-     * 处理图片源
-     */
     private processImage;
-    /**
-     * 签名（真实实现）
-     */
     private sign;
-    /**
-     * 验证 WIP 文件（私有方法，内部使用）
-     */
     verify(wipFile: WipFile): Promise<{
         valid: boolean;
         error?: string;
@@ -102,50 +81,18 @@ export declare class WIP {
             valid: boolean;
         }[];
     }>;
-    /**
-     * 验证签名
-     */
     private verifySignature;
-    /**
-     * 转换为 HTML
-     */
     toHtml(wipFile: WipFile, options?: {
         title?: string;
         theme?: "light" | "dark";
     }): Promise<string>;
-    /**
-     * 序列化为 JSON
-     */
     stringify(wipFile: WipFile, pretty?: boolean): string;
-    /**
-     * 从 JSON 解析
-     */
     parse(jsonString: string): WipFile;
-    /**
-     * 从 URL 或本地路径加载 WIP 文件
-     */
     load(source: string): Promise<WipFile>;
-    /**
-     * 获取 WIP 文件的哈希值（用于 Service 销售）
-     * @param wipFile WIP 文件
-     * @returns 纯哈希值（不含 sha256: 前缀）
-     */
     getHash(wipFile: WipFile): string;
-    /**
-     * 提取图片
-     */
     extractImages(wipFile: WipFile, outputDir: string): string[];
-    /**
-     * 保存到文件
-     */
     save(wipFile: WipFile, filePath: string, pretty?: boolean): void;
-    /**
-     * 获取限制配置
-     */
     getLimits(): WipLimits;
-    /**
-     * 更新限制配置
-     */
     setLimits(limits: Partial<WipLimits>): void;
 }
 export declare function createWip(options: WipCreateOptions, limits?: Partial<WipLimits>): Promise<WipFile>;
@@ -181,47 +128,8 @@ export interface WipToHtmlOptions {
     theme?: "light" | "dark";
     outputPath?: string;
 }
-/**
- * 生成 WIP 文件并保存到指定路径
- *
- * @param options 生成选项
- * @param outputPath 输出文件路径
- * @param limits 可选的限制配置
- * @returns 生成的 WIP 文件路径
- */
 export declare function generate_wip(options: WipGenerationOptions, outputPath: string): Promise<string>;
-/**
- * 验证 WIP 文件
- * 验证内容包括：
- * 1. 基本结构验证
- * 2. 哈希值验证（内容完整性）
- * 3. 数字签名验证（如果存在）
- * 4. 可选：要求必须有签名
- *
- * @param wipFilePath WIP 文件路径（支持本地文件和网络 URL）
- * @param hash_equal 可选的预期哈希值，用于验证文件哈希是否匹配
- * @param requireSignature 可选的标志，如果为 true，则文件必须有签名
- * @returns 验证结果，包含哈希验证和签名验证状态
- */
 export declare function verify_wip(wipFilePath: string, hash_equal?: string, requireSignature?: boolean): Promise<WipVerificationResult>;
-/**
- * 对 WIP 文件进行签名
- *
- * 该函数会加载 WIP 文件、验证格式、使用 Account 添加数字签名并保存。
- * 支持多签名，如果文件已有签名，新签名会追加到签名列表中。
- *
- * @param wipFilePath WIP 文件路径
- * @param account 签名账号（账户名或地址）
- * @param outputPath 输出文件路径（可选，默认覆盖原文件）
- * @returns 签名后的 WIP 文件路径
- */
 export declare function sign_wip(wipFilePath: string, account: string | undefined | null, outputPath?: string): Promise<string>;
-/**
- * 将 WIP 文件或文件夹转换为 HTML
- *
- * @param wipPath WIP 文件路径或文件夹路径
- * @param options 转换选项（支持 outputPath 直接保存到文件）
- * @returns HTML 字符串、保存的文件路径，或转换的文件路径数组
- */
 export declare function wip2html(wipPath: string, options?: WipToHtmlOptions): Promise<string | string[]>;
 export default WIP;