wowok 2.1.9 → 2.1.12

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

@@ -1,654 +1,659 @@
-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);
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * manage address name and tags locally
+ */
 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"
+export const BUITIN_IDS = [
+    "0x5",
+    "0x6",
+    "0x7",
+    "0x8",
+    "0x9",
+    "@0xaaa",
+    "@0xaab",
+    "@0x403",
+    "@0xacc",
+    "@0xc",
 ];
-const isValidAddress = (address) => {
-  return address && (isValidWowAddress(address) || BUITIN_IDS.includes(address));
+export 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}`
-            );
-          }
+export const LocalMarkNameMaxLength = 64;
+export const LocalMarkTagMaxLength = 64;
+export const LocalMarkTagMaxCount = 50;
+export const LocalInfoNameMaxLength = 64;
+export const LocalInfoContentMaxLength = 300;
+export const LocalInfoContentMaxCount = 50;
+export const LocalInfoNameDefault = "Address of delivery";
+export class LocalMark {
+    static _instance;
+    cacheKey = [CachePrefix.local_mark];
+    static Instance() {
+        if (!LocalMark._instance) {
+            LocalMark._instance = new LocalMark();
         }
-      });
-      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);
+        return LocalMark._instance;
     }
-    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;
+    resolve_tags(tags) {
+        tags = tags?.slice(0, LocalMarkTagMaxCount);
+        tags = tags
+            ?.filter((tag) => tag !== "" && tag)
+            ?.map((tag) => {
+            return tag.slice(0, LocalMarkTagMaxLength);
+        });
+        return tags;
     }
-    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;
+    resolve_name(name) {
+        return name.slice(0, LocalMarkNameMaxLength);
     }
-    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 [];
+    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) {
+            // object address invalid
+            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中检查，包括之前添加的标记
+            allMarks.forEach((m) => {
+                if (mark?.name?.value != null && m.name === mark?.name?.value) {
+                    if (mark?.name?.replaceExistName) {
+                        m.name = undefined;
+                    }
+                    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;
     }
-    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;
+    async get(name_or_address) {
+        if (name_or_address === undefined || name_or_address === null) {
+            return undefined;
+        }
+        const cachedData = await Cache.read(this.cacheKey, async (_) => {
+            return {
+                expire: "INFINITE",
+                data: [],
+            };
+        });
+        // 检查缓存中是否已有匹配的token
+        return cachedData?.data?.find((d) => d.name === name_or_address || d.address === name_or_address);
     }
-    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
-      );
+    async get_address(name_or_address) {
+        // IMPORTANT: ADDRESS MAYBE NOT IN LOCAL MARK
+        if (name_or_address && isValidAddress(name_or_address)) {
+            return name_or_address;
+        }
+        return (await this.get(name_or_address))?.address;
     }
-    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;
+    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 || [];
+        // 为每个输入的name_or_address查找匹配的标记
+        return name_or_address.map((input) => {
+            return allMarks.find((mark) => mark.name === input || mark.address === input);
+        });
     }
-    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;
+    async get_many_address(name_or_address) {
+        // 创建结果数组，初始化为undefined
+        const results = new Array(name_or_address.length).fill(undefined);
+        // 收集非地址输入及其在原始数组中的索引
+        const nonAddressMap = new Map();
+        // 遍历原始数组，处理每个元素
+        name_or_address.forEach((input, index) => {
+            if (input === null || input === undefined) {
+                // 保持空值在原始位置
+                results[index] = undefined;
+            }
+            else if (isValidAddress(input)) {
+                // 保持有效地址在原始位置
+                results[index] = input;
+            }
+            else {
+                // 记录非地址输入及其索引
+                nonAddressMap.set(index, input);
+            }
+        });
+        // 提取非地址输入列表
+        const nonAddressInputs = Array.from(nonAddressMap.values());
+        // 如果没有非地址输入，直接返回结果
+        if (nonAddressInputs.length === 0) {
+            return results;
+        }
+        // 对非地址输入调用get_many获取对应的地址
+        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;
     }
-    return false;
-  }
-  async swap_name(name1, name2) {
-    if (name1 === name2) {
-      return true;
+    async get_many_address_availables(name_or_addresses) {
+        return (await this.get_many_address(name_or_addresses)).filter((v) => v != null);
     }
-    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;
+    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) => {
+            // 检查是否匹配输入的名称或地址
+            // 只有当mark.name存在时才检查它是否在输入数组中
+            const matchesName = mark.name !== undefined &&
+                mark.name !== null &&
+                name_or_address.includes(mark.name);
+            const matchesAddress = name_or_address.includes(mark.address);
+            const matchesInput = matchesName || matchesAddress;
+            // 检查名称是否为无效（undefined或null，但不包括空字符串）
+            const isNameInvalid = mark.name === undefined || mark.name === null;
+            // 根据delNotNamed参数决定删除逻辑
+            if (delNotNamed) {
+                // 如果为true，删除匹配输入的标记和名称无效的标记
+                // 保留不匹配输入且名称有效的标记
+                return !matchesInput && !isNameInvalid;
+            }
+            else {
+                // 如果为false，只删除匹配输入的标记
+                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;
     }
-    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;
+    // 使用Cache API重写clear方法
+    async clear() {
+        // 获取所有标记
+        const allMarksCacheKey = [
+            CachePrefix.local_mark,
+        ];
+        await Cache.read(allMarksCacheKey, async () => ({
+            expire: "INFINITE",
+            data: [],
+        }), 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)
+    // 使用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;
-      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;
+    }
+    async swap_name(name1, name2) {
+        if (name1 === name2) {
+            return true;
         }
-      }
-      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();
+        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;
     }
-    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);
+    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;
+            // 应用createdAt过滤
+            if (filter?.createdAt) {
+                if (filter.createdAt.gte !== undefined &&
+                    (!mark.createdAt ||
+                        mark.createdAt < filter.createdAt.gte))
+                    return false;
+                if (filter.createdAt.lte !== undefined &&
+                    (!mark.createdAt ||
+                        mark.createdAt > filter.createdAt.lte))
+                    return false;
+            }
+            // 应用updatedAt过滤
+            if (filter?.updatedAt) {
+                if (filter.updatedAt.gte !== undefined &&
+                    (!mark.updatedAt ||
+                        mark.updatedAt < filter.updatedAt.gte))
+                    return false;
+                if (filter.updatedAt.lte !== undefined &&
+                    (!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() || "";
+            // 名称匹配评分（参考token.ts的评分机制）
+            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; // 标签包含匹配
+                            }
+                        });
+                    }
+                });
+            }
+            // 如果有搜索条件但没有匹配项，将分数设为-1以过滤掉
+            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;
+            }
+            // 分数相同时按名称长度升序排序（参考token.ts的排序机制）
+            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));
+    }
+}
+export class LocalInfo {
+    static _instance;
+    cacheKey = [CachePrefix.local_info];
+    static Instance() {
+        if (!LocalInfo._instance) {
+            LocalInfo._instance = new LocalInfo();
         }
-        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;
-      }
+        return LocalInfo._instance;
     }
-    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 [];
+    resolve_contents(contents) {
+        contents = contents.slice(0, LocalInfoContentMaxCount);
+        return contents.map((v) => v.slice(0, LocalInfoContentMaxLength));
     }
-    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 () => ({
+    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: allInfo
-          }),
-          true
-        );
+            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;
+                // 只有当item.contents不为undefined时才更新contents
+                if (item.contents !== undefined) {
+                    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;
-      }
     }
-    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;
+    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 } : undefined;
+    }
+    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 [];
         }
-      }
-      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;
-              }
-            });
-          }
+        // 只从缓存中读取一次所有信息
+        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 } : undefined;
         });
-      }
-      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
-};
+    }
+    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 };
+            // 名称匹配评分（参考LocalMark.name的评分机制）
+            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; // 包含匹配
+                            }
+                        });
+                    }
+                });
+            }
+            // 如果有搜索条件但没有匹配项，将分数设为-1以过滤掉
+            if ((filter?.name || filter?.default || filter?.contents) &&
+                score === 0) {
+                score = -1;
+            }
+            return { info: infoWithName, score };
+        })
+            // 过滤掉没有匹配项的结果
+            .filter(({ score, info }) => {
+            if (score < 0)
+                return false;
+            // 应用createdAt过滤
+            if (filter?.createdAt) {
+                if (filter.createdAt.gte !== undefined &&
+                    (!info.createdAt ||
+                        info.createdAt < filter.createdAt.gte))
+                    return false;
+                if (filter.createdAt.lte !== undefined &&
+                    (!info.createdAt ||
+                        info.createdAt > filter.createdAt.lte))
+                    return false;
+            }
+            // 应用updatedAt过滤
+            if (filter?.updatedAt) {
+                if (filter.updatedAt.gte !== undefined &&
+                    (!info.updatedAt ||
+                        info.updatedAt < filter.updatedAt.gte))
+                    return false;
+                if (filter.updatedAt.lte !== undefined &&
+                    (!info.updatedAt ||
+                        info.updatedAt > filter.updatedAt.lte))
+                    return false;
+            }
+            return true;
+        })
+            // 按分数降序排序，分数相同时按名称长度升序排序
+            .sort((a, b) => {
+            if (b.score !== a.score) {
+                return b.score - a.score;
+            }
+            // 分数相同时按名称长度升序排序（参考LocalMark的排序机制）
+            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);
+        })
+            // 提取InfoData对象
+            .map(({ info }) => info));
+    }
+}
+//# sourceMappingURL=local.js.map