@bbki.ng/site 5.6.3 → 5.6.5

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @bbki.ng/site
 
+## 5.6.5
+
+### Patch Changes
+
+- fdefcf5: fix btn font
+- Updated dependencies [fdefcf5]
+  - @bbki.ng/ui@0.2.19
+
+## 5.6.4
+
+### Patch Changes
+
+- d1b95ed: add api to fetch manifest
+
 ## 5.6.3
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbki.ng/site",
-  "version": "5.6.3",
+  "version": "5.6.5",
   "description": "code behind bbki.ng",
   "main": "index.js",
   "type": "module",
@@ -14,7 +14,7 @@
     "react-dom": "^18.0.0",
     "react-router-dom": "6",
     "swr": "^2.2.5",
-    "@bbki.ng/ui": "0.2.18"
+    "@bbki.ng/ui": "0.2.19"
   },
   "devDependencies": {
     "@eslint/compat": "^1.0.0",

package/src/blog/utils/fingerprints.ts

@@ -9,6 +9,8 @@ export interface FingerprintData {
   generatedAt: number;
 }
 
+type GLenum = number;
+
 export interface FingerprintComponents {
   // 基础环境
   userAgent: string;
@@ -143,7 +145,7 @@ function getWebGLInfo(): WebGLInfo {
 
     params.forEach(p => {
       try {
-        const val = gl.getParameter((gl as any)[p]);
+        const val = gl.getParameter((gl as unknown as Record<string, GLenum>)[p] as GLenum);
         result.params[p] = Array.isArray(val) ? val.join(',') : String(val);
       } catch {
         result.params[p] = 'unsupported';
@@ -220,7 +222,10 @@ function getFontList(): string[] {
 // 音频指纹（频率响应差异）
 async function getAudioFingerprint(): Promise<string | undefined> {
   try {
-    const AudioContext = window.OfflineAudioContext || (window as any).webkitOfflineAudioContext;
+    const AudioContext =
+      window.OfflineAudioContext ||
+      (window as unknown as { webkitOfflineAudioContext?: typeof OfflineAudioContext })
+        .webkitOfflineAudioContext;
     if (!AudioContext) return undefined;
 
     const ctx = new AudioContext(1, 44100, 44100);
@@ -271,7 +276,7 @@ async function getFingerprint(): Promise<FingerprintData> {
     platform: navigator.platform,
     cookieEnabled: navigator.cookieEnabled,
     hardwareConcurrency: navigator.hardwareConcurrency || 0,
-    deviceMemory: (navigator as any).deviceMemory,
+    deviceMemory: (navigator as unknown as { deviceMemory?: number }).deviceMemory,
     maxTouchPoints: navigator.maxTouchPoints || 0,
     screenResolution: `${screen.width}x${screen.height}`,
     screenColorDepth: screen.colorDepth,

package/src/core/bbplugin.ts

@@ -1,13 +1,14 @@
-import { ManifestMap } from '#/plugins/manifest';
 import { IHostContext } from '#/types/hostApi';
 import { IPlugin, IPluginManifestEntry, PluginID } from '#/types/plugin';
 
+import { PluginManifestService } from './pluginManifestService';
+
 export class BBPlugin implements IPlugin {
   id: PluginID = 'default';
   onInstall?: ((ctx: IHostContext) => void | Promise<void>) | undefined;
   onDisable?: (() => Promise<void> | void) | undefined;
   onDestroy?: (() => void) | undefined;
   getMeta(): IPluginManifestEntry {
-    return ManifestMap.get(this.id) as IPluginManifestEntry;
+    return PluginManifestService.getInstance().getPlugin(this.id) as IPluginManifestEntry;
   }
 }

package/src/core/hooks/use_plugins.ts

@@ -1,9 +1,10 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 
 import { useGlobalLoading } from '@/hooks';
 import { pluginManager } from '#/core/pluginManager';
 import { PluginID } from '#/types/plugin';
 
+import { PluginManifestService } from '../pluginManifestService';
 import { PluginStore } from '../pluginStore';
 
 const usePluginsLoading = () => {
@@ -46,26 +47,41 @@ export const usePlugins = () => {
 
   usePluginsLoading();
 
-  const loadAllPlugins = useCallback(async () => {
-    try {
-      await Promise.all(pluginIds.map(id => pluginManager.loadPlugin(id)));
-      setDone(true);
-    } catch (error) {
-      console.error('Error loading plugins:', error);
-    }
-  }, [pluginIds]);
-
   useEffect(() => {
-    // 加载指定的插件
-    loadAllPlugins();
+    let cancelled = false;
+
+    PluginManifestService.getInstance()
+      .fetch()
+      .then(() => {
+        if (cancelled) {
+          return;
+        }
+        Promise.all(pluginIds.map(id => pluginManager.loadPlugin(id)))
+          .then(() => {
+            if (!cancelled) {
+              setDone(true);
+            }
+          })
+          .catch(error => {
+            if (!cancelled) {
+              console.error('Error loading plugins:', error);
+            }
+          });
+      })
+      .catch(error => {
+        if (!cancelled) {
+          console.error('Error fetching plugin manifest:', error);
+        }
+      });
 
     return () => {
+      cancelled = true;
       // 卸载所有指定的插件
       pluginIds.forEach(id => {
         pluginManager.disablePlugin(id);
       });
     };
-  }, [loadAllPlugins, pluginIds]);
+  }, [pluginIds]);
 
   return done;
 };

package/src/core/pluginManager.ts

@@ -4,6 +4,7 @@ import { IHostContext } from '#/types/hostApi';
 import type { SlotName, HookPoint, IComPropsRegisteredToSlot } from '#/types/slots';
 import { IPlugin, PluginEvents, PluginID, PluginPerm } from '#/types/plugin';
 import { getStableDeviceId } from '@/utils/fingerprints';
+import { cfApiFetcher } from '@/utils';
 
 import { registry } from './registry';
 import { createEventBus } from './utils/eventBus';
@@ -27,6 +28,7 @@ class PluginManager {
     return {
       ...adminCtx,
       api: {
+        fetch: cfApiFetcher,
         setLoading: (id: PluginID, loading: boolean) => {
           this.bus.emit('plugin:loading:changed', { id, loading });
         },

package/src/core/pluginManifestService.ts

@@ -0,0 +1,123 @@
+import { cfApiFetcher } from '@/utils';
+import { FALLBACK_MANIFEST } from '#/plugins/manifest';
+import { IPluginManifestEntry, PluginID } from '#/types/plugin';
+
+const KnownPluginIDSet = new Set<string>([
+  'sticker',
+  'xwy',
+  'extra-cd',
+  'extra-entry',
+  'store',
+  'now',
+  'default',
+  'fx',
+]);
+
+interface PluginsApiResponse {
+  status: string;
+  data: Array<{
+    id: string;
+    name: string;
+    version: string;
+    description?: string;
+    perm?: string;
+    icon?: string;
+    dependencies?: string;
+  }>;
+}
+
+class PluginManifestService {
+  private static instance: PluginManifestService;
+
+  private manifestMap: Map<string, IPluginManifestEntry> = new Map();
+
+  private fetched = false;
+
+  private fetchPromise: Promise<void> | null = null;
+
+  private constructor() {
+    this.initWithFallback();
+  }
+
+  private initWithFallback = () => {
+    this.manifestMap = new Map(FALLBACK_MANIFEST.map(entry => [entry.id, entry]));
+  };
+
+  async fetch(): Promise<void> {
+    if (this.fetched) {
+      return;
+    }
+    if (this.fetchPromise) {
+      return this.fetchPromise;
+    }
+
+    this.fetchPromise = (async () => {
+      try {
+        const res = await cfApiFetcher<PluginsApiResponse>('plugins');
+        if (res.status === 'success' && Array.isArray(res.data)) {
+          const validated = res.data
+            .map((item): IPluginManifestEntry | null => {
+              if (!KnownPluginIDSet.has(item.id)) {
+                console.warn(`[PluginManifestService] Unknown plugin id from server: ${item.id}`);
+                return null;
+              }
+
+              let dependencies: PluginID[] | undefined;
+              if (item.dependencies) {
+                try {
+                  const parsed = JSON.parse(item.dependencies) as string[];
+                  dependencies = parsed.filter((id): id is PluginID => KnownPluginIDSet.has(id));
+                } catch {
+                  console.warn(
+                    `[PluginManifestService] Failed to parse dependencies for plugin: ${item.id}`
+                  );
+                }
+              }
+
+              return {
+                id: item.id as PluginID,
+                name: item.name,
+                version: item.version,
+                description: item.description,
+                perm: (item.perm as 'guest' | 'admin' | undefined) || 'guest',
+                icon: item.icon,
+                dependencies,
+              };
+            })
+            .filter((item): item is IPluginManifestEntry => item !== null);
+
+          this.manifestMap = new Map(validated.map(entry => [entry.id, entry]));
+        }
+        this.fetched = true;
+      } catch (error) {
+        console.error('[PluginManifestService] Failed to fetch manifest:', error);
+        // Keep fallback data
+      }
+    })();
+
+    return this.fetchPromise;
+  }
+
+  getPlugin(id: string): IPluginManifestEntry | undefined {
+    return this.manifestMap.get(id);
+  }
+
+  getAllPlugins(): IPluginManifestEntry[] {
+    return Array.from(this.manifestMap.values());
+  }
+
+  reset(): void {
+    this.fetched = false;
+    this.fetchPromise = null;
+    this.initWithFallback();
+  }
+
+  static getInstance() {
+    if (!PluginManifestService.instance) {
+      PluginManifestService.instance = new PluginManifestService();
+    }
+    return PluginManifestService.instance;
+  }
+}
+
+export { PluginManifestService };

package/src/core/pluginStore.ts

@@ -1,7 +1,7 @@
-import { PLUGIN_MANIFEST } from '#/plugins/manifest';
 import { IPluginStoreEntry, PluginID } from '#/types/plugin';
 
 import { pluginManager } from './pluginManager';
+import { PluginManifestService } from './pluginManifestService';
 
 export class PluginStore {
   private static instance: PluginStore;
@@ -35,13 +35,15 @@ export class PluginStore {
     return this.parse();
   };
 
-  getAllPlugins: () => Array<IPluginStoreEntry> = () => {
+  async getAllPlugins(): Promise<Array<IPluginStoreEntry>> {
     const installedPlugins = this.getInstalledPlugins();
-    return PLUGIN_MANIFEST.map(plugin => ({
+    await PluginManifestService.getInstance().fetch();
+    const manifest = PluginManifestService.getInstance().getAllPlugins();
+    return manifest.map(plugin => ({
       ...plugin,
       enabled: installedPlugins.has(plugin.id),
     }));
-  };
+  }
 
   isPluginInstalled: (id: PluginID) => boolean = id => {
     return this.getInstalledPlugins().has(id);

package/src/plugins/manifest.ts

@@ -1,6 +1,6 @@
 import { IPluginManifestEntry } from '#/types/plugin';
 
-export const PLUGIN_MANIFEST: Array<IPluginManifestEntry> = [
+export const FALLBACK_MANIFEST: Array<IPluginManifestEntry> = [
   {
     name: '贴纸',
     id: 'sticker',
@@ -46,8 +46,3 @@ export const PLUGIN_MANIFEST: Array<IPluginManifestEntry> = [
     description: '为小乌鸦合集实现定制功能或者样式的插件',
   },
 ];
-
-export const ManifestMap = PLUGIN_MANIFEST.reduce((map, entry) => {
-  map.set(entry.id, entry);
-  return map;
-}, new Map<string, IPluginManifestEntry>());

package/src/plugins/now/context/index.ts

@@ -1,7 +1,10 @@
+import { Fetcher } from 'swr';
+
 import { createPluginCtx } from '#/core/context';
 
 export interface INowCtx {
   setLoading: (loading: boolean) => void;
+  fetch: Fetcher;
 }
 
 export const NowCtx = createPluginCtx<INowCtx>();

package/src/plugins/now/hooks/use_streaming.ts

@@ -1,15 +1,8 @@
-import useSWR from 'swr';
+import useSWR, { type BareFetcher } from 'swr';
 import { useEffect, useState } from 'react';
 
-import { baseFetcher } from '@/utils';
-
 import { NowCtx } from '../context';
 
-// In dev, use /api prefix to leverage Vite proxy to localhost:8787
-// const isProd = typeof window !== 'undefined' && /^https:\/\/bbki.ng/.test(window.location.href);
-const isProd = true;
-const API_BASE = !isProd ? '/api' : 'https://cf.bbki.ng';
-
 export type StreamingItem = {
   id: string;
   author: string;
@@ -32,41 +25,13 @@ export interface StreamingQueryParams {
   offset?: number;
 }
 
-/**
- * Build streaming API URL with query parameters
- */
-function buildStreamingUrl(params: StreamingQueryParams = {}): string {
-  const url = new URL(`${API_BASE}/streaming`, !isProd ? window.location.origin : undefined);
-
-  if (params.before) {
-    url.searchParams.set('before', params.before);
-  }
-  if (params.after) {
-    url.searchParams.set('after', params.after);
-  }
-  if (params.offset) {
-    url.searchParams.set('offset', params.offset.toString());
-  }
-
-  return !isProd ? url.pathname + url.search : url.toString();
-}
-
-/**
- * Fetch streaming data from API
- */
-async function fetchStreaming(params: StreamingQueryParams = {}): Promise<StreamingResponse> {
-  const url = buildStreamingUrl(params);
-  const response = await baseFetcher(url);
-  return response as StreamingResponse;
-}
-
 // SWR key generator for streaming queries
 const getStreamingKey = (params: StreamingQueryParams) => {
   const parts = ['streaming'];
   if (params.before) parts.push(`before=${params.before}`);
   if (params.after) parts.push(`after=${params.after}`);
   if (params.offset) parts.push(`offset=${params.offset}`);
-  return parts.join('?');
+  return parts;
 };
 
 interface UseStreamingOptions {
@@ -83,12 +48,18 @@ interface UseStreamingOptions {
 export function useStreaming(options: UseStreamingOptions = {}) {
   const { refreshInterval = 1000, offset = 8 } = options;
 
+  const { fetch } = NowCtx.useCtx();
+
   const key = getStreamingKey({ offset });
 
-  const { data, error, mutate } = useSWR(key, () => fetchStreaming({ offset }), {
-    revalidateOnFocus: true,
-    refreshInterval,
-  });
+  const { data, error, mutate } = useSWR<StreamingResponse>(
+    key,
+    fetch as BareFetcher<StreamingResponse>,
+    {
+      revalidateOnFocus: true,
+      refreshInterval,
+    }
+  );
 
   const isLoading = !data && !error;
 

package/src/plugins/now/index.ts

@@ -22,6 +22,7 @@ export class NowPlugin extends BBPlugin {
             setLoading: loading => {
               ctx.api.setLoading('now', loading);
             },
+            fetch: ctx.api.fetch,
           },
           pageNow
         ),

package/src/plugins/store/index.ts

@@ -6,7 +6,7 @@ import { buildEntryCreator } from '#/utils';
 import { StorePage } from './components/storePage';
 import { StoreCtx } from './context';
 
-export class PluginStore extends BBPlugin {
+export class StorePlugin extends BBPlugin {
   id: PluginID = 'store';
   override onInstall = async (ctx: IHostContext): Promise<void> => {
     const entryCreator = buildEntryCreator(ctx);
@@ -19,9 +19,11 @@ export class PluginStore extends BBPlugin {
             install: ctx.store?.installPlugin || (async () => {}),
             uninstall: ctx.store?.disablePlugin || (async () => {}),
             isInstalled: ctx.store?.isPluginInstalled || ((_: PluginID) => false),
-            list: () => {
-              const installed = Array.from(ctx.store?.getAllPlugins() || []);
-              return installed.filter(({ id }) => id !== this.id);
+            list: async () => {
+              ctx.api.setLoading('store', true);
+              const all = Array.from((await ctx.store?.getAllPlugins()) || []);
+              ctx.api.setLoading('store', false);
+              return all.filter(({ id }) => id !== this.id);
             },
             setLoading: (loading: boolean) => {
               ctx.api.setLoading('store', loading);
@@ -35,4 +37,4 @@ export class PluginStore extends BBPlugin {
   };
 }
 
-export default new PluginStore();
+export default new StorePlugin();

package/src/types/hostApi.ts

@@ -1,4 +1,5 @@
 import React from 'react';
+import { Fetcher } from 'swr';
 
 import { type FingerprintData } from '@/utils/fingerprints';
 import { PluginStore } from '#/core/pluginStore';
@@ -25,6 +26,7 @@ export interface IHostApi {
     pluginId: string,
     weight?: number
   ) => void;
+  fetch: Fetcher;
 }
 
 export type PluginInitializer = (api: IHostApi) => void;

package/src/types/plugin.ts

@@ -47,6 +47,8 @@ export interface IPluginManifestEntry {
   version: string;
   description?: string;
   perm?: PluginPerm;
+  icon?: string;
+  dependencies?: PluginID[];
 }
 
 export interface IPluginStoreEntry extends IPluginManifestEntry {