@flecblog/core-nuxt 0.1.0

package/composables/useDarkMode.ts

@@ -0,0 +1,29 @@
+import { ref, watch } from 'vue';
+
+export const isDark = ref(false);
+
+let initialized = false;
+
+export function initDarkMode(): void {
+  if (initialized || !import.meta.client) return;
+  initialized = true;
+
+  const currentTheme = document.documentElement.getAttribute('data-theme');
+  isDark.value = currentTheme === 'dark';
+
+  watch(isDark, dark => {
+    document.documentElement.setAttribute('data-theme', dark ? 'dark' : 'light');
+    localStorage.setItem('theme', dark ? 'dark' : 'light');
+  });
+
+  const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)');
+  mediaQuery.addEventListener('change', e => {
+    if (!localStorage.getItem('theme')) {
+      isDark.value = e.matches;
+    }
+  });
+}
+
+export function toggleDarkMode(): void {
+  isDark.value = !isDark.value;
+}

package/composables/useEmoji.ts

@@ -0,0 +1,39 @@
+import type { EmojiGroup } from '@@/types/emoji';
+import { loadAllEmojiGroups, getAllEmojiGroupsSync } from '@/utils/emoji';
+
+export function useEmoji() {
+  const { basicConfig } = useSysConfig();
+
+  const emojiGroups = ref<EmojiGroup[]>([]);
+  const loading = ref(true);
+  const error = ref('');
+
+  const load = async () => {
+    // 优先读取已有缓存（app.vue 初始化时已加载）
+    const cached = getAllEmojiGroupsSync();
+    if (cached && cached.length > 0) {
+      emojiGroups.value = cached;
+      loading.value = false;
+      return;
+    }
+
+    const emojisUrl = basicConfig.value.emojis;
+    if (!emojisUrl) {
+      error.value = '未配置表情包';
+      loading.value = false;
+      return;
+    }
+
+    try {
+      const groups = await loadAllEmojiGroups(emojisUrl);
+      if (groups.length === 0) throw new Error('加载表情包失败');
+      emojiGroups.value = groups;
+    } catch (err: unknown) {
+      error.value = (err as Error).message || '加载表情包失败';
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  return { emojiGroups, loading, error, load };
+}

package/composables/useFeedback.ts

@@ -0,0 +1,38 @@
+import {
+  submitFeedback as submitFeedbackApi,
+  getFeedbackByTicketNo as getFeedbackApi,
+} from '@/composables/api/feedback';
+import type { SubmitFeedbackParams, Feedback } from '@@/types/feedback';
+
+export function useFeedback() {
+  const loading = ref(false);
+  const error = ref<Error | null>(null);
+
+  async function submitFeedback(params: SubmitFeedbackParams): Promise<Feedback> {
+    loading.value = true;
+    error.value = null;
+    try {
+      return await submitFeedbackApi(params);
+    } catch (e) {
+      error.value = e instanceof Error ? e : new Error(String(e));
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function getFeedbackByTicketNo(ticketNo: string): Promise<Feedback> {
+    loading.value = true;
+    error.value = null;
+    try {
+      return await getFeedbackApi(ticketNo);
+    } catch (e) {
+      error.value = e instanceof Error ? e : new Error(String(e));
+      throw e;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  return { submitFeedback, getFeedbackByTicketNo, loading, error };
+}

package/composables/useFriendList.ts

@@ -0,0 +1,100 @@
+import { getFriends, applyFriend as applyFriendApi } from '@/composables/api/friend';
+import type { Friend, FriendGroup, FriendApplyRequest } from '@@/types/friend';
+
+export function useFriendList() {
+  const friends = useState<Friend[]>('friends', () => []);
+  const allGroups = useState<FriendGroup[]>('friend-groups', () => []);
+  const loading = ref(false);
+  const error = ref<Error | null>(null);
+
+  async function fetchFriends() {
+    loading.value = true;
+    error.value = null;
+    try {
+      const data = await getFriends();
+      const all: Friend[] = [];
+      data.groups?.forEach(group => {
+        group.friends.forEach(friend => {
+          if (!friend.is_invalid) {
+            all.push(friend);
+          }
+        });
+      });
+      friends.value = all;
+      allGroups.value = data.groups || [];
+    } catch (e) {
+      console.error('获取友链失败:', e);
+      error.value = e instanceof Error ? e : new Error(String(e));
+      friends.value = [];
+      allGroups.value = [];
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  const { data: initialData } = useAsyncData(
+    'footer-friends',
+    async () => {
+      try {
+        const data = await getFriends();
+        const all: Friend[] = [];
+        data.groups?.forEach(group => {
+          group.friends.forEach(friend => {
+            if (!friend.is_invalid) {
+              all.push(friend);
+            }
+          });
+        });
+        return { friends: all, groups: data.groups || [] };
+      } catch {
+        return { friends: [], groups: [] };
+      }
+    },
+    { lazy: true }
+  );
+  watchEffect(() => {
+    if (initialData.value) {
+      friends.value = initialData.value.friends;
+      allGroups.value = initialData.value.groups;
+    }
+  });
+
+  function getRandom(count: number): Friend[] {
+    if (friends.value.length <= count) return friends.value;
+    return [...friends.value].sort(() => Math.random() - 0.5).slice(0, count);
+  }
+
+  const friendGroups = computed(() =>
+    allGroups.value
+      .map(g => ({ ...g, friends: g.friends.filter(f => !f.is_invalid) }))
+      .filter(g => g.friends.length > 0)
+  );
+
+  const invalidFriendGroups = computed(() =>
+    allGroups.value
+      .map(g => ({ ...g, friends: g.friends.filter(f => f.is_invalid) }))
+      .filter(g => g.friends.length > 0)
+  );
+
+  const isEmpty = computed(
+    () => allGroups.value.length === 0 || allGroups.value.every(g => g.friends.length === 0)
+  );
+
+  async function applyFriend(data: FriendApplyRequest): Promise<void> {
+    await applyFriendApi(data);
+    await fetchFriends();
+  }
+
+  return {
+    friends,
+    allGroups,
+    friendGroups,
+    invalidFriendGroups,
+    isEmpty,
+    loading,
+    error,
+    fetchFriends,
+    getRandom,
+    applyFriend,
+  };
+}

package/composables/useMermaid.ts

@@ -0,0 +1,30 @@
+import mermaid from 'mermaid';
+
+let initialized = false;
+
+export function useMermaid() {
+  const init = () => {
+    if (initialized) return;
+    mermaid.initialize({
+      startOnLoad: false,
+      theme: 'default',
+      securityLevel: 'loose',
+    });
+    initialized = true;
+  };
+
+  const renderDiagrams = async () => {
+    const elements = document.querySelectorAll('.mermaid:not(:has(svg))');
+
+    for (const element of elements) {
+      try {
+        const { svg } = await mermaid.render(`mermaid-${Date.now()}`, element.textContent || '');
+        element.innerHTML = svg;
+      } catch (error) {
+        console.error('Mermaid 渲染失败:', error);
+      }
+    }
+  };
+
+  return { init, renderDiagrams };
+}

package/composables/useMoment.ts

@@ -0,0 +1,86 @@
+import { getMoments } from '@/composables/api/moment';
+import type { Moment } from '@@/types/moment';
+
+export function useMoments() {
+  const moments = useState<Moment[]>('moments', () => []);
+  const total = useState<number>('moments-total', () => 0);
+  const currentPage = useState<number>('moments-currentPage', () => 1);
+  const pageSize = useState<number>('moments-pageSize', () => 30);
+  const loading = ref(false);
+  const error = ref<Error | null>(null);
+
+  const fetchMoments = async (page: number = 1, forceRefresh = false) => {
+    if (page) currentPage.value = page;
+    if (!forceRefresh && moments.value.length) return;
+
+    loading.value = true;
+    error.value = null;
+    try {
+      const {
+        list,
+        total: resTotal,
+        page: resPage,
+        page_size: resPageSize,
+      } = await getMoments({
+        page: currentPage.value,
+        page_size: pageSize.value,
+      });
+      moments.value = list || [];
+      total.value = resTotal || 0;
+      currentPage.value = resPage || 1;
+      pageSize.value = resPageSize || 30;
+    } catch (e) {
+      console.error('获取动态列表失败:', e);
+      error.value = e instanceof Error ? e : new Error(String(e));
+      moments.value = [];
+      total.value = 0;
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  async function useSSR(key: string, pageSizeOverride?: number) {
+    const { data } = await useAsyncData(key, () =>
+      getMoments({ page: 1, page_size: pageSizeOverride || pageSize.value })
+    );
+    if (data.value) {
+      moments.value = data.value.list || [];
+      total.value = data.value.total || 0;
+      pageSize.value = data.value.page_size || pageSizeOverride || pageSize.value;
+      currentPage.value = 1;
+    }
+    return { data };
+  }
+
+  /**
+   * 供小组件/侧边栏使用，不会污染全局 moments state
+   */
+  async function fetchWidgetMoments(pageSize: number): Promise<Moment[]> {
+    try {
+      const { list } = await getMoments({ page: 1, page_size: pageSize });
+      return list || [];
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * 小组件 SSR 数据获取（不污染全局 state）
+   */
+  async function useWidgetSSR(key: string, pageSize: number) {
+    return useAsyncData(key, () => fetchWidgetMoments(pageSize));
+  }
+
+  return {
+    moments,
+    total,
+    currentPage,
+    pageSize,
+    loading,
+    error,
+    fetchMoments,
+    useSSR,
+    fetchWidgetMoments,
+    useWidgetSSR,
+  };
+}

package/composables/useMusic.ts

@@ -0,0 +1,37 @@
+import type { MusicTrack, LyricLine } from '@@/types/moment';
+import { fetchMetingMusic, fetchLyricsText } from '@/composables/api/music';
+
+export function useMusic() {
+  const fetchTracks = async (
+    apiUrl: string,
+    params: { server: string; type: string; id: string }
+  ): Promise<MusicTrack[]> => {
+    return fetchMetingMusic(apiUrl, params);
+  };
+
+  const fetchLyrics = async (lrcUrl: string): Promise<string> => {
+    return fetchLyricsText(lrcUrl);
+  };
+
+  const parseLyrics = (lrcText: string): LyricLine[] => {
+    if (!lrcText) return [];
+    const lines = lrcText.split('\n');
+    const lyricLines: LyricLine[] = [];
+
+    for (const line of lines) {
+      const match = line.match(/\[(\d{2}):(\d{2})(?:\.(\d{2,3}))?\](.*)/);
+      if (match && match[1] && match[2] && match[4]) {
+        const minutes = parseInt(match[1]);
+        const seconds = parseInt(match[2]);
+        const milliseconds = match[3] ? parseInt(match[3].padEnd(3, '0')) : 0;
+        const text = match[4].trim();
+        if (text) {
+          lyricLines.push({ time: minutes * 60 + seconds + milliseconds / 1000, text });
+        }
+      }
+    }
+    return lyricLines.sort((a, b) => a.time - b.time);
+  };
+
+  return { fetchTracks, fetchLyrics, parseLyrics };
+}

package/composables/useSearchState.ts

@@ -0,0 +1,90 @@
+import { searchArticles } from '@/composables/api/article';
+import type { Article } from '@@/types/article';
+
+export function useSearchState() {
+  const keyword = ref('');
+  const articles = ref<Article[]>([]);
+  const total = ref(0);
+  const page = ref(1);
+  const pageSize = 5;
+  const loading = ref(false);
+  const error = ref<Error | null>(null);
+
+  const totalPages = computed(() => Math.ceil(total.value / pageSize));
+  const hasSearched = computed(() => keyword.value.trim().length > 0);
+
+  function highlight(text: string): string {
+    const kw = keyword.value.trim();
+    if (!kw || !text) return text;
+    const escaped = kw.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const regex = new RegExp(`(${escaped})`, 'gi');
+    return text.replace(regex, '<mark>$1</mark>');
+  }
+
+  function reset() {
+    keyword.value = '';
+    articles.value = [];
+    total.value = 0;
+    page.value = 1;
+  }
+
+  async function search(newPage = 1) {
+    const searchTerm = keyword.value.trim();
+    if (!searchTerm) {
+      articles.value = [];
+      total.value = 0;
+      return;
+    }
+
+    loading.value = true;
+    error.value = null;
+    page.value = newPage;
+
+    try {
+      const data = await searchArticles(searchTerm, { page: newPage, page_size: pageSize });
+      articles.value = data.list;
+      total.value = data.total;
+    } catch (e) {
+      console.error('搜索失败:', e);
+      error.value = e instanceof Error ? e : new Error(String(e));
+      articles.value = [];
+      total.value = 0;
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  const debouncedSearch = useDebounceFn(() => search(1), 500);
+
+  function onKeywordChange() {
+    page.value = 1;
+    debouncedSearch();
+  }
+
+  function prevPage() {
+    if (page.value > 1) search(page.value - 1);
+  }
+
+  function nextPage() {
+    if (page.value < totalPages.value) search(page.value + 1);
+  }
+
+  return {
+    keyword,
+    articles,
+    total,
+    page,
+    pageSize,
+    loading,
+    error,
+    totalPages,
+    hasSearched,
+    highlight,
+    reset,
+    search,
+    debouncedSearch,
+    onKeywordChange,
+    prevPage,
+    nextPage,
+  };
+}