@bbki.ng/site 5.8.11 → 6.0.1

package/src/core/plugin-system/pluginManager.ts

@@ -1,126 +0,0 @@
-import { IHostContext } from '#/types/hostApi';
-import { IPlugin, PluginID, PluginPerm } from '#/types/plugin';
-
-import { AdminPluginIDSet } from '../const';
-import { ServiceRegistry } from '../shared-service/service-registry';
-
-import { PluginStore } from './pluginStore';
-import { CoreService } from './services/coreService';
-import { SystemUIService } from './services/systemUIService';
-
-const pluginModules = import.meta.glob('../../plugins/*/index.ts');
-
-class PluginManager {
-  private activePlugins: Map<string, IPlugin> = new Map();
-
-  private constructor() {
-    ServiceRegistry.getInstance().register('core:baseService', CoreService.getInstance());
-    ServiceRegistry.getInstance().register('core:uiService', SystemUIService.getInstance());
-  }
-
-  private static instance: PluginManager;
-
-  private createHostContext(perm: PluginPerm = 'guest'): IHostContext {
-    const adminCtx =
-      perm === 'admin'
-        ? {
-            store: PluginStore.getInstance(),
-          }
-        : {};
-    return {
-      ...adminCtx,
-      service: ServiceRegistry.getInstance(),
-    };
-  }
-
-  private loading = new Set<string>();
-
-  static getInstance() {
-    if (!PluginManager.instance) {
-      PluginManager.instance = new PluginManager();
-    }
-    return PluginManager.instance;
-  }
-
-  // enable abort ctrl
-  async loadPlugin(pluginId: PluginID): Promise<IPlugin | undefined> {
-    if (this.activePlugins.has(pluginId)) {
-      console.warn(`Plugin ${pluginId} is already loaded.`);
-      return;
-    }
-
-    if (this.loading.has(pluginId)) {
-      console.warn(`Plugin ${pluginId} is loading...`);
-      return;
-    }
-
-    // try load plugin
-    this.loading.add(pluginId);
-    CoreService.getInstance().setLoading(pluginId, true);
-
-    const modulePath = `../../plugins/${pluginId}/index.ts`;
-    const moduleLoader = pluginModules[modulePath];
-    if (!moduleLoader) {
-      console.error(`Plugin ${pluginId} not found in registry`);
-
-      this.loading.delete(pluginId);
-      CoreService.getInstance().setLoading(pluginId, false);
-
-      return;
-    }
-
-    try {
-      const module = (await moduleLoader()) as {
-        default: IPlugin;
-      };
-
-      const p: IPlugin = module.default;
-
-      const perm = p.getMeta().perm || 'guest';
-      if (perm === 'admin' && !AdminPluginIDSet.has(pluginId)) {
-        throw new Error(`Plugin ${pluginId} requires admin permission, but it's not trusted.`);
-      }
-
-      const ctx = this.createHostContext(perm);
-
-      if (p.onInstall) {
-        await p.onInstall(ctx);
-      }
-
-      this.activePlugins.set(pluginId, p);
-      return p;
-    } catch (error) {
-      console.error(`Failed to load plugin ${pluginId}:`, error);
-    } finally {
-      this.loading.delete(pluginId);
-      CoreService.getInstance().setLoading(pluginId, false);
-    }
-  }
-
-  getPlugin(pluginId: PluginID): IPlugin | undefined {
-    return this.activePlugins.get(pluginId);
-  }
-
-  async disablePlugin(pluginId: PluginID) {
-    const plugin = this.activePlugins.get(pluginId);
-    if (!plugin) {
-      console.warn(`Plugin ${pluginId} is not loaded.`);
-      return;
-    }
-
-    if (plugin.onDisable) {
-      await plugin.onDisable();
-    }
-
-    if (plugin.onDestroy) {
-      plugin.onDestroy();
-    }
-
-    this.activePlugins.delete(pluginId);
-
-    SystemUIService.getInstance().unregisterAllByPluginId(plugin.id);
-    CoreService.getInstance().notifyPluginUninstall(plugin.id);
-  }
-}
-
-export const pluginManager = PluginManager.getInstance();

package/src/core/plugin-system/pluginManifestService.ts

@@ -1,97 +0,0 @@
-import { cfApiFetcher } from '#/app/utils';
-import { FALLBACK_MANIFEST } from '#/core/plugin-system/manifest';
-import { IPluginManifestEntry, PluginID } from '#/types/plugin';
-
-// const KnownPluginIDSet = new Set<string>(FALLBACK_MANIFEST.map(entry => entry.id));
-
-interface PluginsApiResponse {
-  status: string;
-  data: Array<{
-    id: string;
-    name: string;
-    version: string;
-    description?: string;
-    perm?: string;
-    icon?: string;
-    dependencies?: Array<PluginID>;
-  }>;
-}
-
-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 => {
-              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: item.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/plugin-system/pluginStore.ts

@@ -1,200 +0,0 @@
-import { IPluginStoreEntry, PluginID } from '#/types/plugin';
-
-import { pluginManager } from './pluginManager';
-import { PluginManifestService } from './pluginManifestService';
-
-export class PluginStore {
-  private static instance: PluginStore;
-
-  private installedSet: Set<PluginID> = new Set();
-
-  private constructor() {
-    this.parse();
-  }
-
-  // TODO: check circular dependency when install plugin, and also check if all dependencies are installed before install a plugin
-  private checkDep = (id: PluginID): boolean => {
-    const manifest = PluginManifestService.getInstance().getPlugin(id);
-    if (!manifest) {
-      console.warn(`[PluginStore] Manifest not found for plugin: ${id}`);
-      return false;
-    }
-
-    if (!manifest.dependencies || manifest.dependencies.length === 0) {
-      return true;
-    }
-
-    for (const depId of manifest.dependencies) {
-      if (!this.isPluginInstalled(depId)) {
-        console.warn(`[PluginStore] Dependency ${depId} for plugin ${id} is not installed`);
-        return false;
-      }
-    }
-
-    return true;
-  };
-
-  private parse = () => {
-    this.installedSet.clear();
-    const installedPluginsStr = localStorage.getItem('installed_plugins');
-    if (installedPluginsStr) {
-      try {
-        const entries = JSON.parse(installedPluginsStr) as Array<PluginID>;
-        entries.forEach(id => this.installedSet.add(id));
-      } catch (e) {
-        console.error('Failed to parse installed plugins from localStorage', e);
-      }
-    }
-
-    try {
-      this.ensureRightOrder(this.installedSet);
-    } catch (error) {
-      console.error('Failed to ensure correct plugin load order:', error);
-    }
-
-    return this.installedSet;
-  };
-
-  private buildDependencyGraph = (ids: Set<PluginID>): Map<PluginID, PluginID[]> => {
-    const graph = new Map<PluginID, PluginID[]>();
-    const manifest = PluginManifestService.getInstance().getAllPlugins();
-
-    ids.forEach(id => {
-      graph.set(id, []);
-    });
-
-    manifest.forEach(plugin => {
-      if (ids.has(plugin.id)) {
-        const deps = plugin.dependencies || [];
-        deps.forEach(dep => {
-          if (ids.has(dep)) {
-            if (!graph.has(dep)) {
-              graph.set(dep, []);
-            }
-            graph.get(dep)!.push(plugin.id);
-          }
-        });
-      }
-    });
-
-    return graph;
-  };
-
-  private topologicalSortKahn = (graph: Map<PluginID, PluginID[]>): PluginID[] => {
-    const inDegree = new Map<PluginID, number>();
-    graph.forEach((deps, plugin) => {
-      if (!inDegree.has(plugin)) {
-        inDegree.set(plugin, 0);
-      }
-      deps.forEach(dep => {
-        inDegree.set(dep, (inDegree.get(dep) || 0) + 1);
-      });
-    });
-
-    const queue: PluginID[] = [];
-    inDegree.forEach((degree, plugin) => {
-      if (degree === 0) {
-        queue.push(plugin);
-      }
-    });
-
-    const loadOrder: PluginID[] = [];
-    while (queue.length > 0) {
-      const current = queue.shift()!;
-      loadOrder.push(current);
-
-      const deps = graph.get(current) || [];
-      deps.forEach(dep => {
-        inDegree.set(dep, inDegree.get(dep)! - 1);
-        if (inDegree.get(dep) === 0) {
-          queue.push(dep);
-        }
-      });
-    }
-
-    if (loadOrder.length !== graph.size) {
-      throw new Error('Circular dependency detected among plugins');
-    }
-
-    return loadOrder;
-  };
-
-  private ensureRightOrder = (ids: Set<PluginID>) => {
-    const graph = this.buildDependencyGraph(ids);
-    const loadOrder = this.topologicalSortKahn(graph);
-
-    // write back to installedSet in the correct order without create a new Set to preserve reference
-    if (loadOrder.length === ids.size) {
-      this.installedSet.clear();
-      loadOrder.forEach(id => this.installedSet.add(id));
-    }
-  };
-
-  private stringify = () => {
-    localStorage.setItem('installed_plugins', JSON.stringify(Array.from(this.installedSet)));
-  };
-
-  getInstalledPlugins: () => Set<PluginID> = () => {
-    return this.parse();
-  };
-
-  async getAllPlugins(): Promise<Array<IPluginStoreEntry>> {
-    const installedPlugins = this.getInstalledPlugins();
-    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);
-  };
-
-  getPlugin: (id: PluginID) => IPluginStoreEntry | undefined = id => {
-    const manifest = PluginManifestService.getInstance().getPlugin(id);
-    if (!manifest) {
-      return undefined;
-    }
-
-    return {
-      ...manifest,
-      enabled: this.isPluginInstalled(id),
-    };
-  };
-
-  installPlugin: (id: PluginID, manual?: boolean) => Promise<boolean> = async (id, manual) => {
-    if (!this.checkDep(id)) {
-      // throw new Error(`Cannot install plugin ${id} due to missing dependencies`);
-      console.warn(`Cannot install plugin ${id} due to missing dependencies`);
-      return false;
-    }
-
-    try {
-      const plugin = await pluginManager.loadPlugin(id);
-      if (manual && plugin?.onManualInstall) {
-        plugin.onManualInstall();
-      }
-      this.installedSet.add(id);
-      this.stringify();
-      return true;
-    } catch (error) {
-      console.error(`Failed to install plugin ${id}:`, error);
-      return false;
-    }
-  };
-
-  disablePlugin: (id: PluginID) => Promise<void> = async id => {
-    await pluginManager.disablePlugin(id);
-    this.installedSet.delete(id);
-    this.stringify();
-  };
-
-  static getInstance() {
-    if (!PluginStore.instance) {
-      PluginStore.instance = new PluginStore();
-    }
-    return PluginStore.instance;
-  }
-}

package/src/core/plugin-system/registry.ts

@@ -1,17 +0,0 @@
-import React from 'react';
-
-import type { IComPropsRegisteredToSlot } from '#/types/slots';
-
-export interface ISlotEntry {
-  id: string;
-  component: React.ComponentType<IComPropsRegisteredToSlot>;
-  pluginId: string;
-  weight: number;
-}
-
-export interface IMiddlewareEntry<T> {
-  id: string;
-  fn: (data: T) => Promise<T> | T;
-  pluginId: string;
-  weight?: number;
-}

package/src/core/plugin-system/services/coreService.ts

@@ -1,75 +0,0 @@
-import { Fetcher } from 'swr';
-import { NavigateFunction } from 'react-router-dom';
-
-import { getStableDeviceId } from '#/app/utils/fingerprints';
-import { cfApiFetcher } from '#/app/utils';
-import { PluginEvents, PluginID } from '#/types/plugin';
-
-import { ICoreService } from '../../shared-service/contract/ICoreService';
-import { createEventBus } from '../../utils/eventBus';
-
-export class CoreService implements ICoreService {
-  private static instance: CoreService;
-
-  private constructor() {}
-
-  private bus = createEventBus<PluginEvents>();
-  private navigate?: NavigateFunction;
-
-  getDeviceId = getStableDeviceId;
-
-  injectNavigate(nav: NavigateFunction) {
-    this.navigate = nav;
-  }
-
-  open = (url: string, options?: { newTab?: boolean }) => {
-    // use navigate
-    if (this.navigate) {
-      this.navigate(url);
-    } else {
-      if (options?.newTab) {
-        window.open(url, '_blank');
-      } else {
-        window.location.href = url;
-      }
-    }
-  };
-
-  getVersionHash() {
-    const hashStr: string = typeof GLOBAL_COMMIT_HASH === 'string' ? GLOBAL_COMMIT_HASH : '0000000';
-    return hashStr;
-  }
-
-  setLoading(id: PluginID, loading: boolean): void {
-    this.bus.emit('plugin:loading:changed', { id, loading });
-  }
-
-  subscribePluginLoading(listener: (payload: PluginEvents['plugin:loading:changed']) => void) {
-    return this.bus.on('plugin:loading:changed', listener);
-  }
-
-  subscribePluginUninstall(listener: (payload: PluginEvents['plugin:uninstall']) => void) {
-    return this.bus.on('plugin:uninstall', listener);
-  }
-
-  notifyPluginUninstall(id: PluginID): void {
-    this.bus.emit('plugin:uninstall', id);
-  }
-
-  subscribeLoadingChange(listener: (payload: boolean) => void): () => void {
-    return this.bus.on('site:loading:changed', listener);
-  }
-
-  setSiteLoading(loading: boolean) {
-    this.bus.emit('site:loading:changed', loading);
-  }
-
-  fetch: Fetcher = cfApiFetcher;
-
-  static getInstance(): CoreService {
-    if (!CoreService.instance) {
-      CoreService.instance = new CoreService();
-    }
-    return CoreService.instance;
-  }
-}

package/src/core/plugin-system/services/systemUIService.ts

@@ -1,64 +0,0 @@
-import { createUIService } from '#/core/shared-service/factory/createUIService';
-import { createEventBus } from '#/core/utils/eventBus';
-import {
-  ISystemUIService,
-  SystemDataHookPoint,
-  SystemSlotName,
-} from '#/core/shared-service/contract/IUIService';
-import { IPluginEntry, PluginID } from '#/types/plugin';
-
-const baseService = createUIService<SystemSlotName, SystemDataHookPoint>('system');
-
-export class SystemUIService implements ISystemUIService {
-  private static instance: SystemUIService;
-
-  private pluginEntries = new Map<string, IPluginEntry & { pluginId: PluginID }>();
-
-  private entryBus = createEventBus<{ pluginEntriesChanged: void }>();
-
-  private constructor() {}
-
-  static getInstance(): SystemUIService {
-    if (!SystemUIService.instance) {
-      SystemUIService.instance = new SystemUIService();
-    }
-    return SystemUIService.instance;
-  }
-
-  registerSlot = baseService.registerSlot.bind(baseService);
-  registerMiddleware = baseService.registerMiddleware.bind(baseService);
-  getSlotEntries = baseService.getSlotEntries.bind(baseService);
-  getComponents = baseService.getComponents.bind(baseService);
-  subscribeSlotChange = baseService.subscribeSlotChange.bind(baseService);
-  subscribeMiddlewareChange = baseService.subscribeMiddlewareChange.bind(baseService);
-  runMiddlewares = baseService.runMiddlewares.bind(baseService);
-
-  registerPluginEntry: (entry: IPluginEntry, id: PluginID) => void = (entry, id) => {
-    this.pluginEntries.set(entry.path, { ...entry, pluginId: id });
-    this.entryBus.emit('pluginEntriesChanged', undefined);
-  };
-
-  getPluginEntries = (): Array<IPluginEntry & { pluginId: PluginID }> => {
-    return Array.from(this.pluginEntries.values());
-  };
-
-  subscribePluginEntryChange = (listener: () => void): (() => void) => {
-    return this.entryBus.on('pluginEntriesChanged', listener);
-  };
-
-  unregisterAllByPluginId: (pluginId: string) => void = pluginId => {
-    baseService.unregisterAllByPluginId(pluginId);
-
-    let changed = false;
-    this.pluginEntries.forEach((entry, path) => {
-      if (entry.pluginId === pluginId) {
-        this.pluginEntries.delete(path);
-        changed = true;
-      }
-    });
-
-    if (changed) {
-      this.entryBus.emit('pluginEntriesChanged', undefined);
-    }
-  };
-}

package/src/core/shared-service/contract/ICoreService.ts

@@ -1,28 +0,0 @@
-import { Fetcher } from 'swr';
-import { NavigateFunction } from 'react-router-dom';
-
-import { FingerprintData } from '#/app/utils/fingerprints';
-import { PluginID } from '#/types/plugin';
-
-declare module '#/core/shared-service/service-registry' {
-  interface ServiceIdentifierMap {
-    'core:baseService': ICoreService;
-  }
-}
-
-export interface ICoreService {
-  getVersionHash(): Promise<string> | string;
-  getDeviceId(): Promise<{ id: string; fp: FingerprintData }>;
-
-  setLoading(id: string, loading: boolean): void;
-  subscribeLoadingChange(listener: (payload: boolean) => void): () => void;
-
-  subscribePluginUninstall(listener: (payload: PluginID) => void): () => void;
-  notifyPluginUninstall(id: PluginID): void;
-
-  injectNavigate: (nav: NavigateFunction) => void;
-
-  open: (url: string, options?: { newTab?: boolean }) => void;
-
-  fetch: Fetcher;
-}

package/src/core/shared-service/contract/IUIService.ts

@@ -1,53 +0,0 @@
-import type React from 'react';
-
-import type { ISlotEntry } from '#/core/plugin-system/registry';
-import { IPluginEntry, PluginID } from '#/types/plugin';
-import { IComPropsRegisteredToSlot } from '#/types/slots';
-
-declare module '#/core/shared-service/service-registry' {
-  interface ServiceIdentifierMap {
-    'core:uiService': ISystemUIService;
-  }
-}
-
-export interface IBaseUIService<T extends string, K extends string> {
-  registerMiddleware: <S>(
-    hookPoint: K,
-    fn: (data: S) => Promise<S> | S,
-    pluginId: PluginID,
-    weight?: number
-  ) => void;
-
-  registerSlot: (
-    slotName: T,
-    component: React.ComponentType<IComPropsRegisteredToSlot>,
-    pluginId: PluginID,
-    weight?: number
-  ) => void;
-
-  unregisterAllByPluginId(pluginId: string): void;
-
-  getSlotEntries(slotName: T): ISlotEntry[];
-
-  getComponents(slotName: T): React.ComponentType<IComPropsRegisteredToSlot>[];
-
-  subscribeSlotChange(listener: () => void): () => void;
-
-  subscribeMiddlewareChange(listener: (point: K) => void): () => void;
-
-  runMiddlewares: <S>(point: K, data: S) => Promise<S>;
-}
-
-export type SystemSlotName =
-  | 'leftCol'
-  | 'rightCol'
-  | 'logo'
-  | 'pageFooter'
-  | 'nav-right'
-  | 'centerEntryArea';
-
-export type SystemDataHookPoint = 'transformBreadcrumbPath' | 'transformEntryLink';
-
-export interface ISystemUIService extends IBaseUIService<SystemSlotName, SystemDataHookPoint> {
-  registerPluginEntry: (entry: IPluginEntry, id: PluginID) => void;
-}