@yh-ui/hooks 0.1.10 → 0.1.12

package/dist/index.cjs

@@ -4,10 +4,6 @@ const vue = require('vue');
 const locale = require('@yh-ui/locale');
 const _dayjs = require('dayjs');
 require('dayjs/locale/en');
-require('dayjs/locale/zh-cn');
-require('dayjs/locale/zh-tw');
-require('dayjs/locale/ja');
-require('dayjs/locale/ko');
 
 function _interopNamespaceCompat(e) {
   if (e && typeof e === 'object' && 'default' in e) return e;
@@ -161,13 +157,16 @@ const useConfig = () => {
 };
 
 const dayjs = _dayjs__namespace.default || _dayjs__namespace;
-const loadedLocales = /* @__PURE__ */ new Set(["en", "zh-cn", "zh-tw", "ja", "ko"]);
+const dayjsLocales = undefined(
+  ["../../../../node_modules/dayjs/locale/*.js", "!../../../../node_modules/dayjs/locale/en.js"],
+  { eager: false }
+);
+const loadedLocales = /* @__PURE__ */ new Set(["en"]);
 const localeMapping = {
   "zh-cn": "zh-cn",
   "zh-tw": "zh-tw",
   "zh-hk": "zh-hk",
   "zh-mo": "zh-tw",
-  // 澳门使用繁体
   en: "en",
   ja: "ja",
   ko: "ko",
@@ -241,12 +240,21 @@ const setDayjsLocale = async (localeCode) => {
     dayjs.locale(dayjsLocale);
     return;
   }
-  try {
-    await import(`../../../../node_modules/dayjs/locale/${dayjsLocale}.js`);
-    loadedLocales.add(dayjsLocale);
-    dayjs.locale(dayjsLocale);
-  } catch {
-    console.warn(`[yh-ui] Failed to load dayjs locale: ${dayjsLocale}, falling back to 'en'`);
+  if (dayjsLocale === "en") {
+    dayjs.locale("en");
+    return;
+  }
+  const path = `../../../../node_modules/dayjs/locale/${dayjsLocale}.js`;
+  const loader = dayjsLocales[path];
+  if (loader) {
+    try {
+      await loader();
+      loadedLocales.add(dayjsLocale);
+      dayjs.locale(dayjsLocale);
+    } catch {
+      dayjs.locale("en");
+    }
+  } else {
     dayjs.locale("en");
   }
 };
@@ -555,19 +563,622 @@ function useClickOutside(target, handler) {
   useEventListener(window, "touchstart", listener, true);
 }
 
+const openaiParser = (raw) => {
+  const lines = raw.split("\n");
+  let text = "";
+  for (const line of lines) {
+    if (!line.startsWith("data: ")) continue;
+    const data = line.slice(6).trim();
+    if (data === "[DONE]") break;
+    try {
+      const json = JSON.parse(data);
+      const delta = json?.choices?.[0]?.delta?.content;
+      if (delta) text += delta;
+    } catch {
+    }
+  }
+  return text || null;
+};
+const ernieParser = (raw) => {
+  const lines = raw.split("\n");
+  let text = "";
+  for (const line of lines) {
+    if (!line.startsWith("data: ")) continue;
+    const data = line.slice(6).trim();
+    try {
+      const json = JSON.parse(data);
+      if (json?.result) text += json.result;
+    } catch {
+    }
+  }
+  return text || null;
+};
+const qwenParser = (raw) => {
+  const lines = raw.split("\n");
+  let text = "";
+  for (const line of lines) {
+    if (!line.startsWith("data: ")) continue;
+    const data = line.slice(6).trim();
+    try {
+      const json = JSON.parse(data);
+      const t = json?.output?.text;
+      if (t) text += t;
+    } catch {
+    }
+  }
+  return text || null;
+};
+const plainTextParser = (raw) => raw || null;
+class TypewriterThrottle {
+  queue = [];
+  rafId = null;
+  onUpdate;
+  charsPerFrame;
+  constructor(onUpdate, charsPerFrame = 3) {
+    this.onUpdate = onUpdate;
+    this.charsPerFrame = charsPerFrame;
+  }
+  push(text) {
+    this.queue.push(...text.split(""));
+    if (this.rafId === null) {
+      this.schedule();
+    }
+  }
+  schedule() {
+    this.rafId = requestAnimationFrame(() => {
+      this.rafId = null;
+      if (this.queue.length === 0) return;
+      const batch = this.queue.splice(0, this.charsPerFrame).join("");
+      this.onUpdate(batch);
+      if (this.queue.length > 0) {
+        this.schedule();
+      }
+    });
+  }
+  flush() {
+    if (this.rafId !== null) {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+    if (this.queue.length > 0) {
+      const remaining = this.queue.splice(0).join("");
+      this.onUpdate(remaining);
+    }
+  }
+  cancel() {
+    if (this.rafId !== null) {
+      cancelAnimationFrame(this.rafId);
+      this.rafId = null;
+    }
+    this.queue = [];
+  }
+}
+function useAiStream(options) {
+  const isStreaming = vue.ref(false);
+  const currentContent = vue.ref("");
+  let abortController = new AbortController();
+  let typewriter = null;
+  const parser = options.parser ?? plainTextParser;
+  const enableTypewriter = options.typewriter !== false;
+  const charsPerFrame = options.charsPerFrame ?? 3;
+  const stop = () => {
+    if (isStreaming.value) {
+      abortController.abort();
+      isStreaming.value = false;
+      typewriter?.flush();
+    }
+  };
+  const fetchStream = async (query, ...args) => {
+    isStreaming.value = true;
+    currentContent.value = "";
+    abortController = new AbortController();
+    if (enableTypewriter) {
+      typewriter = new TypewriterThrottle((chunk) => {
+        currentContent.value += chunk;
+        options.onUpdate?.(chunk, currentContent.value);
+      }, charsPerFrame);
+    }
+    const pushText = (text) => {
+      if (!text) return;
+      if (enableTypewriter && typewriter) {
+        typewriter.push(text);
+      } else {
+        currentContent.value += text;
+        options.onUpdate?.(text, currentContent.value);
+      }
+    };
+    try {
+      const response = await options.request(query, ...args);
+      if (typeof response === "object" && response !== null && Symbol.asyncIterator in response) {
+        for await (const chunk of response) {
+          if (abortController.signal.aborted) break;
+          const parsed = parser(chunk);
+          if (parsed) pushText(parsed);
+        }
+      } else if (response instanceof Response && response.body) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder("utf-8");
+        while (true) {
+          if (abortController.signal.aborted) {
+            reader.cancel();
+            break;
+          }
+          const { done, value } = await reader.read();
+          if (done) break;
+          const chunkStr = decoder.decode(value, { stream: true });
+          const parsed = parser(chunkStr);
+          if (parsed) pushText(parsed);
+        }
+      }
+      if (!abortController.signal.aborted) {
+        if (enableTypewriter && typewriter) {
+          typewriter.flush();
+        }
+        isStreaming.value = false;
+        options.onFinish?.(currentContent.value);
+      }
+    } catch (e) {
+      if (e.name !== "AbortError") {
+        options.onError?.(e);
+      }
+      typewriter?.cancel();
+      isStreaming.value = false;
+    }
+  };
+  return {
+    isStreaming,
+    currentContent,
+    fetchStream,
+    stop,
+    // 暴露解析器供测试/自定义使用
+    parsers: { openaiParser, ernieParser, qwenParser, plainTextParser }
+  };
+}
+
+function createTypewriter(onChar, charsPerFrame) {
+  const queue = [];
+  let rafId = null;
+  const schedule = () => {
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      if (queue.length === 0) return;
+      const batch = queue.splice(0, charsPerFrame).join("");
+      onChar(batch);
+      if (queue.length > 0) schedule();
+    });
+  };
+  return {
+    push(text) {
+      queue.push(...text.split(""));
+      if (rafId === null) schedule();
+    },
+    flush() {
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+      if (queue.length > 0) {
+        onChar(queue.splice(0).join(""));
+      }
+    },
+    cancel() {
+      if (rafId !== null) {
+        cancelAnimationFrame(rafId);
+        rafId = null;
+      }
+      queue.length = 0;
+    }
+  };
+}
+function useAiChat(options = {}) {
+  const {
+    idGenerator = () => Math.random().toString(36).substring(2, 9),
+    parser = plainTextParser,
+    typewriter: enableTypewriter = true,
+    charsPerFrame = 3,
+    systemPrompt
+  } = options;
+  const messages = vue.ref(options.initialMessages ?? []);
+  const isGenerating = vue.ref(false);
+  const isSending = vue.computed(() => isGenerating.value);
+  let abortController = null;
+  const stop = () => {
+    if (abortController && isGenerating.value) {
+      abortController.abort();
+      isGenerating.value = false;
+      const lastMsg = messages.value[messages.value.length - 1];
+      if (lastMsg?.role === "assistant" && lastMsg.status === "generating") {
+        lastMsg.status = "stopped";
+      }
+    }
+  };
+  const clear = () => {
+    stop();
+    messages.value = [];
+  };
+  const removeMessage = (id) => {
+    const idx = messages.value.findIndex((m) => m.id === id);
+    if (idx !== -1) messages.value.splice(idx, 1);
+  };
+  const updateMessage = (id, patch) => {
+    const msg = messages.value.find((m) => m.id === id);
+    if (msg) Object.assign(msg, patch);
+  };
+  const sendMessage = async (content) => {
+    if (!content.trim() || isGenerating.value) return;
+    messages.value.push({
+      id: idGenerator(),
+      role: "user",
+      content,
+      createAt: Date.now(),
+      status: "success"
+    });
+    if (!options.request) return;
+    const assId = idGenerator();
+    const assistantMsg = {
+      id: assId,
+      role: "assistant",
+      content: "",
+      createAt: Date.now(),
+      status: "loading"
+    };
+    messages.value.push(assistantMsg);
+    isGenerating.value = true;
+    abortController = new AbortController();
+    const history = [];
+    if (systemPrompt) {
+      history.push({
+        id: "system",
+        role: "system",
+        content: systemPrompt,
+        createAt: 0,
+        status: "success"
+      });
+    }
+    history.push(...messages.value.slice(0, -2));
+    try {
+      const response = await options.request(content, history, abortController.signal);
+      const targetMsg = messages.value.find((m) => m.id === assId);
+      targetMsg.status = "generating";
+      let typewriterInstance = null;
+      if (enableTypewriter && typeof requestAnimationFrame !== "undefined") {
+        typewriterInstance = createTypewriter((chars) => {
+          targetMsg.content += chars;
+        }, charsPerFrame);
+      }
+      const pushChunk = (text) => {
+        if (!text) return;
+        if (typewriterInstance) {
+          typewriterInstance.push(text);
+        } else {
+          targetMsg.content += text;
+        }
+      };
+      if (typeof response === "object" && response !== null && Symbol.asyncIterator in response) {
+        for await (const chunk of response) {
+          if (abortController.signal.aborted) break;
+          const parsed = parser(chunk);
+          if (parsed) pushChunk(parsed);
+        }
+      } else if (response instanceof Response && response.body) {
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder("utf-8");
+        while (true) {
+          if (abortController.signal.aborted) {
+            reader.cancel();
+            break;
+          }
+          const { done, value } = await reader.read();
+          if (done) break;
+          const chunkStr = decoder.decode(value, { stream: true });
+          const parsed = parser(chunkStr);
+          if (parsed) pushChunk(parsed);
+        }
+      } else if (typeof response === "string") {
+        pushChunk(response);
+      }
+      if (typewriterInstance) {
+        typewriterInstance.flush();
+      }
+      if (!abortController.signal.aborted) {
+        targetMsg.status = "success";
+        options.onFinish?.(targetMsg);
+      }
+    } catch (e) {
+      if (e.name !== "AbortError") {
+        const targetMsg = messages.value.find((m) => m.id === assId);
+        if (targetMsg) targetMsg.status = "error";
+        options.onError?.(e);
+      }
+    } finally {
+      if (isGenerating.value) {
+        isGenerating.value = false;
+      }
+    }
+  };
+  return {
+    /** 会话历史 */
+    messages,
+    /** 是否正在生成（等同 isSending，别名友好） */
+    isGenerating,
+    /** 同 isGenerating，语义别名 */
+    isSending,
+    /** 触发发送（自动处理流、打字机） */
+    sendMessage,
+    /** 停止/中断当前生成 */
+    stop,
+    /** 移除单条消息 */
+    removeMessage,
+    /** 修改单条消息内容 */
+    updateMessage,
+    /** 重置清空所有会话 */
+    clear
+  };
+}
+
+const localStorageAdapter = {
+  getItem: (key) => {
+    try {
+      return localStorage.getItem(key);
+    } catch {
+      return null;
+    }
+  },
+  setItem: (key, value) => {
+    try {
+      localStorage.setItem(key, value);
+    } catch {
+    }
+  },
+  removeItem: (key) => {
+    try {
+      localStorage.removeItem(key);
+    } catch {
+    }
+  }
+};
+class IndexedDBAdapter {
+  db = null;
+  dbName;
+  storeName = "ai_conversations";
+  ready;
+  constructor(dbName = "yh-ui-ai") {
+    this.dbName = dbName;
+    this.ready = this.init();
+  }
+  init() {
+    return new Promise((resolve, reject) => {
+      if (typeof indexedDB === "undefined") {
+        resolve();
+        return;
+      }
+      const req = indexedDB.open(this.dbName, 1);
+      req.onupgradeneeded = () => {
+        req.result.createObjectStore(this.storeName);
+      };
+      req.onsuccess = () => {
+        this.db = req.result;
+        resolve();
+      };
+      req.onerror = () => reject(req.error);
+    });
+  }
+  async getItem(key) {
+    await this.ready;
+    if (!this.db) return null;
+    return new Promise((resolve) => {
+      const tx = this.db.transaction(this.storeName, "readonly");
+      const req = tx.objectStore(this.storeName).get(key);
+      req.onsuccess = () => resolve(req.result ?? null);
+      req.onerror = () => resolve(null);
+    });
+  }
+  async setItem(key, value) {
+    await this.ready;
+    if (!this.db) return;
+    return new Promise((resolve) => {
+      const tx = this.db.transaction(this.storeName, "readwrite");
+      tx.objectStore(this.storeName).put(value, key);
+      tx.oncomplete = () => resolve();
+    });
+  }
+  async removeItem(key) {
+    await this.ready;
+    if (!this.db) return;
+    return new Promise((resolve) => {
+      const tx = this.db.transaction(this.storeName, "readwrite");
+      tx.objectStore(this.storeName).delete(key);
+      tx.oncomplete = () => resolve();
+    });
+  }
+}
+function getGroupLabel(updatedAt) {
+  const now = Date.now();
+  const diff = now - updatedAt;
+  const oneDay = 864e5;
+  if (diff < oneDay) return "today";
+  if (diff < 7 * oneDay) return "last7Days";
+  if (diff < 30 * oneDay) return "last30Days";
+  return "earlier";
+}
+const GROUP_ORDER = ["today", "last7Days", "last30Days", "earlier"];
+function useAiConversations(options = {}) {
+  const {
+    idGenerator = () => Math.random().toString(36).substring(2, 9),
+    storage = "localStorage",
+    storageKey = "yh-ui-ai-conversations",
+    pageSize = 20
+  } = options;
+  let adapter = null;
+  if (storage === "localStorage") {
+    adapter = localStorageAdapter;
+  } else if (storage === "indexedDB") {
+    adapter = new IndexedDBAdapter();
+  } else if (storage && typeof storage === "object") {
+    adapter = storage;
+  }
+  const conversations = vue.ref([]);
+  const page = vue.ref(1);
+  const isLoadingMore = vue.ref(false);
+  const initPromise = (async () => {
+    let stored = [];
+    if (adapter) {
+      try {
+        const raw = await adapter.getItem(storageKey);
+        if (raw) stored = JSON.parse(raw);
+      } catch {
+        stored = [];
+      }
+    }
+    const init = options.initialConversations ?? [];
+    const merged = [...init];
+    for (const s of stored) {
+      if (!merged.find((c) => c.id === s.id)) {
+        merged.push(s);
+      }
+    }
+    conversations.value = merged.sort((a, b) => {
+      if (a.pinned !== b.pinned) return a.pinned ? -1 : 1;
+      return b.updatedAt - a.updatedAt;
+    });
+  })();
+  const persist = async () => {
+    if (!adapter) return;
+    try {
+      await adapter.setItem(storageKey, JSON.stringify(conversations.value));
+    } catch {
+    }
+  };
+  const groupedConversations = vue.computed(() => {
+    const groups = {
+      today: [],
+      last7Days: [],
+      last30Days: [],
+      earlier: []
+    };
+    for (const c of conversations.value) {
+      if (c.pinned) continue;
+      const key = getGroupLabel(c.updatedAt);
+      groups[key].push(c);
+    }
+    const result = [];
+    const pinned = conversations.value.filter((c) => c.pinned);
+    if (pinned.length > 0) {
+      result.push({ label: "pinned", items: pinned });
+    }
+    for (const key of GROUP_ORDER) {
+      if (groups[key].length > 0) {
+        result.push({ label: key, items: groups[key] });
+      }
+    }
+    return result;
+  });
+  const pagedConversations = vue.computed(() => {
+    return conversations.value.slice(0, page.value * pageSize);
+  });
+  const hasMore = vue.computed(() => {
+    return pagedConversations.value.length < conversations.value.length;
+  });
+  const loadMore = async () => {
+    if (!hasMore.value || isLoadingMore.value) return;
+    isLoadingMore.value = true;
+    await new Promise((r) => setTimeout(r, 300));
+    page.value++;
+    isLoadingMore.value = false;
+  };
+  const createConversation = async (title, meta) => {
+    const newConv = {
+      id: idGenerator(),
+      title,
+      updatedAt: Date.now(),
+      meta
+    };
+    conversations.value.unshift(newConv);
+    await persist();
+    return newConv;
+  };
+  const removeConversation = async (id) => {
+    const idx = conversations.value.findIndex((c) => c.id === id);
+    if (idx !== -1) {
+      conversations.value.splice(idx, 1);
+      await persist();
+    }
+  };
+  const updateConversation = async (id, updates) => {
+    const idx = conversations.value.findIndex((c) => c.id === id);
+    if (idx !== -1) {
+      conversations.value[idx] = {
+        ...conversations.value[idx],
+        ...updates,
+        updatedAt: Date.now()
+      };
+      await persist();
+    }
+  };
+  const pinConversation = async (id, pinned = true) => {
+    await updateConversation(id, { pinned });
+    conversations.value.sort((a, b) => {
+      if (a.pinned !== b.pinned) return a.pinned ? -1 : 1;
+      return b.updatedAt - a.updatedAt;
+    });
+    await persist();
+  };
+  const clear = async () => {
+    conversations.value = [];
+    if (adapter) {
+      await adapter.removeItem(storageKey);
+    }
+  };
+  return {
+    /** 完整会话列表 */
+    conversations,
+    /** 按时间分组后的列表（置顶 / 今天 / 最近 7 天 / 更早） */
+    groupedConversations,
+    /** 分页后的列表 */
+    pagedConversations,
+    /** 是否还有更多数据 */
+    hasMore,
+    /** 加载更多 */
+    loadMore,
+    /** 加载更多状态 */
+    isLoadingMore,
+    /** 等待初始化完成（SSR 场景使用） */
+    ready: initPromise,
+    /** 新建会话 */
+    createConversation,
+    /** 删除会话 */
+    removeConversation,
+    /** 更新会话属性 */
+    updateConversation,
+    /** 置顶/取消置顶 */
+    pinConversation,
+    /** 清空全部 */
+    clear
+  };
+}
+
 exports.FormContextKey = FormContextKey;
 exports.FormItemContextKey = FormItemContextKey;
+exports.IndexedDBAdapter = IndexedDBAdapter;
 exports.configProviderContextKey = configProviderContextKey;
 exports.createZIndexCounter = createZIndexCounter;
 exports.defaultNamespace = defaultNamespace;
+exports.ernieParser = ernieParser;
 exports.getDayjsLocale = getDayjsLocale;
 exports.getNextZIndex = getNextZIndex;
 exports.idInjectionKey = idInjectionKey;
+exports.localStorageAdapter = localStorageAdapter;
 exports.namespaceContextKey = namespaceContextKey;
+exports.openaiParser = openaiParser;
+exports.plainTextParser = plainTextParser;
+exports.qwenParser = qwenParser;
 exports.resetZIndex = resetZIndex;
 exports.setDayjsLocale = setDayjsLocale;
 exports.setDayjsLocaleSync = setDayjsLocaleSync;
 exports.updateDayjsMonths = updateDayjsMonths;
+exports.useAiChat = useAiChat;
+exports.useAiConversations = useAiConversations;
+exports.useAiStream = useAiStream;
 exports.useCache = useCache;
 exports.useClickOutside = useClickOutside;
 exports.useConfig = useConfig;