wowok 1.8.2 → 2.1.9

package/dist/esm/w/local/local.js

@@ -0,0 +1,654 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { isValidWowAddress } from "../../utils/sui-types.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { Cache, CachePrefix } from "./cache.js";
+const BUITIN_IDS = [
+  "0x5",
+  "0x6",
+  "0x7",
+  "0x8",
+  "0x9",
+  "@0xaaa",
+  "@0xaab",
+  "@0x403",
+  "@0xacc",
+  "@0xc"
+];
+const isValidAddress = (address) => {
+  return address && (isValidWowAddress(address) || BUITIN_IDS.includes(address));
+};
+const LocalMarkNameMaxLength = 64;
+const LocalMarkTagMaxLength = 64;
+const LocalMarkTagMaxCount = 50;
+const LocalInfoNameMaxLength = 64;
+const LocalInfoContentMaxLength = 300;
+const LocalInfoContentMaxCount = 50;
+const LocalInfoNameDefault = "Address of delivery";
+const _LocalMark = class _LocalMark {
+  constructor() {
+    __publicField(this, "cacheKey", [CachePrefix.local_mark]);
+  }
+  static Instance() {
+    if (!_LocalMark._instance) {
+      _LocalMark._instance = new _LocalMark();
+    }
+    return _LocalMark._instance;
+  }
+  resolve_tags(tags) {
+    tags = tags?.slice(0, LocalMarkTagMaxCount);
+    tags = tags?.filter((tag) => tag !== "" && tag)?.map((tag) => {
+      return tag.slice(0, LocalMarkTagMaxLength);
+    });
+    return tags;
+  }
+  resolve_name(name) {
+    return name.slice(0, LocalMarkNameMaxLength);
+  }
+  async put(marks) {
+    const allMarksData = await Cache.read(
+      this.cacheKey,
+      async () => {
+        return {
+          expire: "INFINITE",
+          data: []
+        };
+      }
+    );
+    const allMarks = allMarksData?.data || [];
+    const addedMarks = [];
+    for (const mark of marks) {
+      if (!isValidAddress(mark.address)) {
+        W_ERROR(
+          WErrors.IsValidAddress,
+          `LocalMark.put.mark.address: ${mark.address}`
+        );
+      }
+      if (mark?.name?.value) {
+        mark.name.value = this.resolve_name(mark?.name?.value);
+      }
+      mark.tags = this.resolve_tags(mark?.tags);
+      allMarks.forEach((m) => {
+        if (mark?.name?.value != null && m.name === mark?.name?.value) {
+          if (mark?.name?.replaceExistName) {
+            m.name = void 0;
+          } else {
+            W_ERROR(
+              WErrors.LocalMarkNameExist,
+              `LocalMark.put.mark.name: ${mark.name.value}`
+            );
+          }
+        }
+      });
+      const now = Date.now();
+      const newMark = {
+        name: mark?.name?.value,
+        address: mark.address,
+        tags: mark.tags,
+        createdAt: now,
+        updatedAt: now
+      };
+      allMarks.push(newMark);
+      addedMarks.push(newMark);
+    }
+    await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: allMarks
+      }),
+      true
+    );
+    return addedMarks;
+  }
+  async get(name_or_address) {
+    if (name_or_address === void 0 || name_or_address === null) {
+      return void 0;
+    }
+    const cachedData = await Cache.read(
+      this.cacheKey,
+      async (_) => {
+        return {
+          expire: "INFINITE",
+          data: []
+        };
+      }
+    );
+    return cachedData?.data?.find(
+      (d) => d.name === name_or_address || d.address === name_or_address
+    );
+  }
+  async get_address(name_or_address) {
+    if (name_or_address && isValidAddress(name_or_address)) {
+      return name_or_address;
+    }
+    return (await this.get(name_or_address))?.address;
+  }
+  async get_many(name_or_address) {
+    if (!Array.isArray(name_or_address) || name_or_address.length === 0) {
+      return [];
+    }
+    const cachedData = await Cache.read(
+      this.cacheKey,
+      async (_) => {
+        return {
+          expire: "INFINITE",
+          data: []
+        };
+      }
+    );
+    const allMarks = cachedData?.data || [];
+    return name_or_address.map((input) => {
+      return allMarks.find(
+        (mark) => mark.name === input || mark.address === input
+      );
+    });
+  }
+  async get_many_address(name_or_address) {
+    const results = new Array(
+      name_or_address.length
+    ).fill(void 0);
+    const nonAddressMap = /* @__PURE__ */ new Map();
+    name_or_address.forEach((input, index) => {
+      if (input === null || input === void 0) {
+        results[index] = void 0;
+      } else if (isValidAddress(input)) {
+        results[index] = input;
+      } else {
+        nonAddressMap.set(index, input);
+      }
+    });
+    const nonAddressInputs = Array.from(nonAddressMap.values());
+    if (nonAddressInputs.length === 0) {
+      return results;
+    }
+    const nonAddressResults = await this.get_many(nonAddressInputs);
+    let resultIndex = 0;
+    nonAddressMap.forEach((input, originalIndex) => {
+      const result = nonAddressResults[resultIndex];
+      results[originalIndex] = result?.address;
+      resultIndex++;
+    });
+    return results;
+  }
+  async get_many_address_availables(name_or_addresses) {
+    return (await this.get_many_address(name_or_addresses)).filter(
+      (v) => v != null
+    );
+  }
+  async del(name_or_address, delNotNamed = false) {
+    const allMarksCacheKey = [
+      CachePrefix.local_mark
+    ];
+    const allMarksData = await Cache.read(
+      allMarksCacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: []
+      })
+    );
+    const allMarks = allMarksData?.data || [];
+    const filteredMarks = allMarks.filter((mark) => {
+      const matchesName = mark.name !== void 0 && mark.name !== null && name_or_address.includes(mark.name);
+      const matchesAddress = name_or_address.includes(mark.address);
+      const matchesInput = matchesName || matchesAddress;
+      const isNameInvalid = mark.name === void 0 || mark.name === null;
+      if (delNotNamed) {
+        return !matchesInput && !isNameInvalid;
+      } else {
+        return !matchesInput;
+      }
+    });
+    const deletedMarks = allMarks.filter(
+      (mark) => !filteredMarks.includes(mark)
+    );
+    if (filteredMarks.length !== allMarks.length) {
+      await Cache.read(
+        allMarksCacheKey,
+        async () => ({
+          expire: "INFINITE",
+          data: filteredMarks
+        }),
+        true
+      );
+    }
+    return deletedMarks;
+  }
+  // 使用Cache API重写clear方法
+  async clear() {
+    const allMarksCacheKey = [
+      CachePrefix.local_mark
+    ];
+    await Cache.read(
+      allMarksCacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: []
+      }),
+      true
+    );
+    return true;
+  }
+  // 使用Cache API重写rename方法
+  async rename(name, new_name) {
+    new_name = this.resolve_name(new_name);
+    if (name === new_name) {
+      return true;
+    }
+    const allMarksData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: []
+      })
+    );
+    const allMarks = allMarksData?.data || [];
+    const old = allMarks.find((d) => d.name === name);
+    if (old && allMarks.findIndex((d) => d.name === new_name) === -1) {
+      const now = Date.now();
+      old.name = new_name;
+      old.updatedAt = now;
+      await Cache.read(
+        this.cacheKey,
+        async () => ({
+          expire: "INFINITE",
+          data: allMarks
+        }),
+        true
+      );
+      return true;
+    }
+    return false;
+  }
+  async swap_name(name1, name2) {
+    if (name1 === name2) {
+      return true;
+    }
+    const allMarksData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: []
+      })
+    );
+    const allMarks = allMarksData?.data || [];
+    const n1 = allMarks.find((d) => d.name === name1);
+    const n2 = allMarks.find((d) => d.name === name2);
+    if (n1 && n2) {
+      const now = Date.now();
+      n1.name = name2;
+      n1.updatedAt = now;
+      n2.name = name1;
+      n2.updatedAt = now;
+      await Cache.read(
+        this.cacheKey,
+        async () => ({
+          expire: "INFINITE",
+          data: allMarks
+        }),
+        true
+      );
+      return true;
+    }
+    return false;
+  }
+  async set_tags(name, tags) {
+    tags = this.resolve_tags(tags);
+    const allMarksData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: []
+      })
+    );
+    const allMarks = allMarksData?.data || [];
+    const mark = allMarks.find((d) => d.name === name);
+    if (mark) {
+      const now = Date.now();
+      mark.tags = tags;
+      mark.updatedAt = now;
+      await Cache.read(
+        this.cacheKey,
+        async () => ({
+          expire: "INFINITE",
+          data: allMarks
+        }),
+        true
+      );
+      return true;
+    }
+    return false;
+  }
+  // 使用Cache API重写list方法
+  async list(filter) {
+    if (filter && filter.tags)
+      filter.tags = filter.tags.filter((v) => v !== "" && v);
+    const allMarksData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: []
+      })
+    );
+    const allMarks = allMarksData?.data || [];
+    return allMarks.filter((mark) => {
+      if (filter?.address && mark.address !== filter.address)
+        return false;
+      if (filter?.createdAt) {
+        if (filter.createdAt.gte !== void 0 && (!mark.createdAt || mark.createdAt < filter.createdAt.gte))
+          return false;
+        if (filter.createdAt.lte !== void 0 && (!mark.createdAt || mark.createdAt > filter.createdAt.lte))
+          return false;
+      }
+      if (filter?.updatedAt) {
+        if (filter.updatedAt.gte !== void 0 && (!mark.updatedAt || mark.updatedAt < filter.updatedAt.gte))
+          return false;
+        if (filter.updatedAt.lte !== void 0 && (!mark.updatedAt || mark.updatedAt > filter.updatedAt.lte))
+          return false;
+      }
+      return true;
+    }).map((mark) => {
+      let score = 0;
+      const lowerName = mark.name?.toLowerCase() || "";
+      const lowerFilterName = filter?.name?.toLowerCase() || "";
+      if (filter?.name) {
+        if (lowerName === lowerFilterName) {
+          score += 100;
+        } else if (lowerName.startsWith(lowerFilterName)) {
+          score += 50;
+        } else if (lowerName.includes(lowerFilterName)) {
+          score += 25;
+        }
+      }
+      if (filter?.tags && filter.tags.length > 0) {
+        filter.tags.forEach((filterTag) => {
+          const lowerFilterTag = filterTag.toLowerCase();
+          if (mark.tags) {
+            mark.tags.forEach((tag) => {
+              const lowerTag = tag.toLowerCase();
+              if (lowerTag === lowerFilterTag) {
+                score += 20;
+              } else if (lowerTag.startsWith(lowerFilterTag)) {
+                score += 15;
+              } else if (lowerTag.includes(lowerFilterTag)) {
+                score += 10;
+              }
+            });
+          }
+        });
+      }
+      if ((filter?.name || filter?.tags) && score === 0) {
+        score = -1;
+      }
+      return { mark, score };
+    }).filter(({ score }) => score >= 0).sort((a, b) => {
+      if (b.score !== a.score) {
+        return b.score - a.score;
+      }
+      const aNameLength = (a.mark.name || "").length;
+      const bNameLength = (b.mark.name || "").length;
+      if (aNameLength !== bNameLength) {
+        return aNameLength - bNameLength;
+      }
+      return (a.mark.name || "").localeCompare(b.mark.name || "");
+    }).map(({ mark }) => mark);
+  }
+};
+__publicField(_LocalMark, "_instance");
+let LocalMark = _LocalMark;
+const _LocalInfo = class _LocalInfo {
+  constructor() {
+    __publicField(this, "cacheKey", [CachePrefix.local_info]);
+  }
+  static Instance() {
+    if (!_LocalInfo._instance) {
+      _LocalInfo._instance = new _LocalInfo();
+    }
+    return _LocalInfo._instance;
+  }
+  resolve_contents(contents) {
+    contents = contents.slice(0, LocalInfoContentMaxCount);
+    return contents.map((v) => v.slice(0, LocalInfoContentMaxLength));
+  }
+  resolve_name(name) {
+    return name.slice(0, LocalInfoNameMaxLength);
+  }
+  // 使用Cache API重写put方法
+  async add(data) {
+    const allInfoData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: {}
+      })
+    );
+    const allInfo = allInfoData?.data || {};
+    for (const item of data) {
+      const resolvedName = this.resolve_name(item.name);
+      const resolvedDefault = item.default.slice(
+        0,
+        LocalInfoContentMaxLength
+      );
+      if (allInfo[resolvedName]) {
+        const now = Date.now();
+        const obj = allInfo[resolvedName];
+        obj.default = resolvedDefault;
+        if (item.contents !== void 0) {
+          obj.contents = this.resolve_contents(item.contents);
+        }
+        obj.updatedAt = now;
+      } else {
+        const now = Date.now();
+        const obj = {
+          default: resolvedDefault,
+          contents: item.contents ? this.resolve_contents(item.contents) : [],
+          // 新创建时如果contents为undefined则使用空数组
+          createdAt: now,
+          updatedAt: now
+        };
+        allInfo[resolvedName] = obj;
+      }
+    }
+    await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: allInfo
+      }),
+      true
+    );
+    return true;
+  }
+  async get(name = LocalInfoNameDefault) {
+    const allInfoData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: {}
+      })
+    );
+    const allInfo = allInfoData?.data || {};
+    const inner = allInfo[name];
+    return inner ? { name, ...inner } : void 0;
+  }
+  async get_default(name = LocalInfoNameDefault) {
+    const info = await this.get(name);
+    return info?.default;
+  }
+  async get_many(names) {
+    if (!Array.isArray(names) || names.length === 0) {
+      return [];
+    }
+    const allInfoData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: {}
+      })
+    );
+    const allInfo = allInfoData?.data || {};
+    return names.map((name) => {
+      const inner = allInfo[name];
+      return inner ? { name, ...inner } : void 0;
+    });
+  }
+  async del(name = LocalInfoNameDefault) {
+    const allInfoData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: {}
+      })
+    );
+    const allInfo = allInfoData?.data || {};
+    delete allInfo[name];
+    await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: allInfo
+      }),
+      true
+    );
+  }
+  async reset_contents(name = LocalInfoNameDefault, contents) {
+    const allInfoData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: {}
+      })
+    );
+    const allInfo = allInfoData?.data || {};
+    const info = allInfo[name];
+    if (info) {
+      if (info.contents && info.contents.length > 0) {
+        const now = Date.now();
+        info.contents = this.resolve_contents(contents);
+        info.updatedAt = now;
+        await Cache.read(
+          this.cacheKey,
+          async () => ({
+            expire: "INFINITE",
+            data: allInfo
+          }),
+          true
+        );
+        return true;
+      }
+    }
+    return false;
+  }
+  async clear() {
+    await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: {}
+      }),
+      true
+    );
+  }
+  async list(filter) {
+    const allInfoData = await Cache.read(
+      this.cacheKey,
+      async () => ({
+        expire: "INFINITE",
+        data: {}
+      })
+    );
+    const allInfo = allInfoData?.data || {};
+    return Object.entries(allInfo).map(([name, info]) => {
+      let score = 0;
+      const infoWithName = { name, ...info };
+      if (filter?.name) {
+        const lowerName = name.toLowerCase();
+        const lowerFilterName = filter.name.toLowerCase();
+        if (lowerName === lowerFilterName) {
+          score += 100;
+        } else if (lowerName.startsWith(lowerFilterName)) {
+          score += 50;
+        } else if (lowerName.includes(lowerFilterName)) {
+          score += 25;
+        }
+      }
+      if (filter?.default) {
+        const lowerDefault = info.default.toLowerCase();
+        const lowerFilterDefault = filter.default.toLowerCase();
+        if (lowerDefault === lowerFilterDefault) {
+          score += 90;
+        } else if (lowerDefault.startsWith(lowerFilterDefault)) {
+          score += 45;
+        } else if (lowerDefault.includes(lowerFilterDefault)) {
+          score += 22;
+        }
+      }
+      if (filter?.contents && filter.contents.length > 0) {
+        filter.contents.forEach((filterContent) => {
+          const lowerFilterContent = filterContent.toLowerCase();
+          if (info.contents) {
+            info.contents.forEach((content) => {
+              const lowerContent = content.toLowerCase();
+              if (lowerContent === lowerFilterContent) {
+                score += 20;
+              } else if (lowerContent.startsWith(
+                lowerFilterContent
+              )) {
+                score += 15;
+              } else if (lowerContent.includes(
+                lowerFilterContent
+              )) {
+                score += 10;
+              }
+            });
+          }
+        });
+      }
+      if ((filter?.name || filter?.default || filter?.contents) && score === 0) {
+        score = -1;
+      }
+      return { info: infoWithName, score };
+    }).filter(({ score, info }) => {
+      if (score < 0) return false;
+      if (filter?.createdAt) {
+        if (filter.createdAt.gte !== void 0 && (!info.createdAt || info.createdAt < filter.createdAt.gte))
+          return false;
+        if (filter.createdAt.lte !== void 0 && (!info.createdAt || info.createdAt > filter.createdAt.lte))
+          return false;
+      }
+      if (filter?.updatedAt) {
+        if (filter.updatedAt.gte !== void 0 && (!info.updatedAt || info.updatedAt < filter.updatedAt.gte))
+          return false;
+        if (filter.updatedAt.lte !== void 0 && (!info.updatedAt || info.updatedAt > filter.updatedAt.lte))
+          return false;
+      }
+      return true;
+    }).sort((a, b) => {
+      if (b.score !== a.score) {
+        return b.score - a.score;
+      }
+      const aNameLength = a.info.name.length;
+      const bNameLength = b.info.name.length;
+      if (aNameLength !== bNameLength) {
+        return aNameLength - bNameLength;
+      }
+      return a.info.name.localeCompare(b.info.name);
+    }).map(({ info }) => info);
+  }
+};
+__publicField(_LocalInfo, "_instance");
+let LocalInfo = _LocalInfo;
+export {
+  BUITIN_IDS,
+  LocalInfo,
+  LocalInfoContentMaxCount,
+  LocalInfoContentMaxLength,
+  LocalInfoNameDefault,
+  LocalInfoNameMaxLength,
+  LocalMark,
+  LocalMarkNameMaxLength,
+  LocalMarkTagMaxCount,
+  LocalMarkTagMaxLength,
+  isValidAddress
+};

package/dist/esm/w/local/storage.d.ts

@@ -0,0 +1,61 @@
+/**
+ * SQLite 存储实现
+ *
+ * 架构：
+ * - cache.db: 通用缓存数据
+ * - account.db: 账户数据（更高安全级别）
+ *
+ * 特点：
+ * 1. 进程安全 - 支持多进程并发访问
+ * 2. 业务隔离 - cache 和 account 完全分离
+ * 3. WAL 模式 - 高性能读写
+ */
+import Database from "better-sqlite3";
+export interface IStorage {
+    put(key: string, value: string): Promise<void>;
+    get(key: string): Promise<string | undefined>;
+    getMany(keys: string[]): Promise<(string | undefined)[]>;
+    del(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export interface IAccountStorage {
+    get(): Promise<string | undefined>;
+    put(data: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class SQLiteStorage implements IStorage {
+    private _db;
+    private _dbSource;
+    constructor(db?: Database.Database);
+    private get db();
+    get(key: string): Promise<string | undefined>;
+    getMany(keys: string[]): Promise<(string | undefined)[]>;
+    put(key: string, value: string): Promise<void>;
+    putMany(items: {
+        key: string;
+        value: string;
+    }[]): Promise<void>;
+    del(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+export declare class SQLiteAccountStorage implements IAccountStorage {
+    private _db;
+    private _dbSource;
+    constructor(db?: Database.Database);
+    private get db();
+    get(): Promise<string | undefined>;
+    put(data: string): Promise<void>;
+    clear(): Promise<void>;
+}
+/**
+ * 关闭并重置所有数据库连接
+ * 用于测试时清理数据
+ */
+export declare function resetAllDbConnections(): void;
+/**
+ * 重置所有存储实例和数据库连接
+ * 用于测试时完全清理数据
+ */
+export declare function resetAllStorage(): void;
+export declare const defaultStorage: SQLiteStorage;
+export declare const defaultAccountStorage: SQLiteAccountStorage;