@pubinfo-nightly/core 2025.11.14

package/src/core/index.ts

@@ -0,0 +1,4 @@
+export * from './create';
+export * from './interface';
+export * from './request';
+export * from './resolver';

package/src/core/interface.ts

@@ -0,0 +1,142 @@
+import type { AdapterCreateOptions, AlovaAxiosRequestConfig } from '@alova/adapter-axios';
+import type { Alova, AlovaGenerics, AlovaOptions, Method, ResponseCompleteHandler, ResponseErrorHandler } from 'alova';
+import type { AxiosResponse, AxiosResponseHeaders } from 'axios';
+import type { Pinia, StateTree } from 'pinia';
+import type { App, Component } from 'vue';
+import type { Router, RouterOptions as VueRouterOptions } from 'vue-router';
+import type { MenuData, RouteData } from '@/features';
+
+type PartialKeys<T, Keys extends keyof T> = Omit<T, Keys> & Partial<Pick<T, Keys>>;
+
+export type RouterOptions = PartialKeys<VueRouterOptions, 'history'> & { base?: string };
+
+export interface Options {
+  /**
+   * 根组件
+   */
+  app: Component
+
+  /**
+   * vue-router 配置
+   */
+  router: RouterOptions
+
+  /**
+   * 初始化函数
+   */
+  setup?: Setup
+
+  /**
+   * 根节点
+   * @default "#app"
+   */
+  rootContainer?: string | Element
+
+  /**
+   * 立即执行
+   * @default true
+   */
+  immediate?: boolean
+
+  /** 模块插件注册 */
+  modules?: ModuleOptions[]
+
+  /** 生命周期 */
+  hooks?: Partial<Hooks>
+}
+
+export interface Context {
+  app: App<Element>
+  store: Pinia
+  router: Router
+}
+
+export type Setup = (ctx: Pick<Context, 'app' | 'router' | 'store'>) => Promise<void> | void;
+
+export interface Module {
+  /** 唯一值 */
+  name: string
+
+  /** 初始化内容 */
+  setup?: Setup
+
+  /**
+   * 插件调用顺序:
+   * - `enforce: pre` 插件
+   * - 内置核心插件（即路由守卫、状态管理等）
+   * - 普通插件
+   * - 初始化函数（即setup）
+   * - `enforce: post` 插件
+   */
+  enforce?: 'pre' | 'post'
+
+  /** 钩子函数 */
+  hooks?: Partial<Hooks>
+}
+
+export type FalsyModule = false | null | undefined;
+
+export type ModuleOptions = Module | ModuleOptions[] | FalsyModule;
+
+export type AG = AlovaGenerics<any, any, AlovaAxiosRequestConfig, AxiosResponse<any, any>, AxiosResponseHeaders, any, any, any>;
+
+export type RequestOptions = Omit<AlovaOptions<AG>, 'statesHook' | 'requestAdapter' | 'beforeRequest' | 'responded'> & {
+  axios?: AdapterCreateOptions
+  beforeRequest?: Hooks['http:request']
+  responded?: Hooks['http:response']
+};
+export type RequestInstance = Alova<AG>;
+export type RequestMethod = Method<AG>;
+
+export interface Hooks {
+  /** http 请求拦截器 */
+  'http:request': (method: Method<AG>) => void | Promise<void>
+
+  /** http 响应拦截器 */
+  'http:response': RespondedHandler<AG> | RespondedHandlerRecord<AG>
+
+  /** 菜单数据转换 */
+  'menu:transform': (menuData: MenuData[]) => MenuData[] | Promise<MenuData[]>
+
+  /** 路由数据转换 */
+  'route:transform': (routeData: RouteData[]) => RouteData[] | Promise<RouteData[]>
+
+  /** Pinia 持久化写入前处理（需同步返回） */
+  'pinia:persist:write': (payload: PiniaPersistWriteHookPayload) => PiniaPersistWriteHookPayload
+
+  /** Pinia 持久化读取前处理（需同步返回） */
+  'pinia:persist:read': (payload: PiniaPersistReadHookPayload) => PiniaPersistReadHookPayload
+}
+
+// overwrite alova
+type Fn = () => void;
+export type RespondedHandler<AG extends AlovaGenerics> = (response: AG['Response'], methodInstance: Method<AG>, stop: Fn) => any;
+export interface RespondedHandlerRecord<AG extends AlovaGenerics> {
+  onSuccess?: RespondedHandler<AG>
+  onError?: ResponseErrorHandler<AG>
+  onComplete?: ResponseCompleteHandler<AG>
+}
+
+export interface PiniaPersistHookBasePayload {
+  storeId: string
+  /** 实际存储键 */
+  key: string
+  /** local 或 session */
+  storageArea?: 'local' | 'session'
+  /** 仅在 localStorage 同步时可用 */
+  fullKey?: string
+}
+
+export interface PiniaPersistWriteHookPayload extends PiniaPersistHookBasePayload {
+  /** 序列化后的字符串 */
+  value: string
+  /** 过滤后的状态对象 */
+  state: StateTree
+}
+
+export interface PiniaPersistReadHookPayload extends PiniaPersistHookBasePayload {
+  /** 从存储读取的原始字符串 */
+  value: string
+  /** 实际读取数据的键 */
+  sourceKey?: string
+}

package/src/core/modules.ts

@@ -0,0 +1,63 @@
+import type { Context, FalsyModule, Module, ModuleOptions } from './interface';
+import { hooks } from './ctx';
+import { asyncFlatten } from './utils';
+
+/**
+ * 注册所有模块插件的setup
+ */
+export async function resolveModules(modules: ModuleOptions[] = [], context: Context) {
+  const filterModules = (m: Module | FalsyModule): m is Module => Boolean(m);
+
+  const rawModules = (await asyncFlatten(modules)).filter(filterModules);
+
+  for (const m of rawModules) {
+    if (m.setup) {
+      await m.setup(context);
+    }
+  }
+}
+
+/**
+ * @desc: 根据 `enforce` 区分 `pre/post`
+ * @param {ModuleOptions} modules
+ */
+export function extractModules(modules: ModuleOptions[] = []) {
+  const result = {
+    pre: [] as Module[],
+    post: [] as Module[],
+    default: [] as Module[],
+  };
+
+  function traverse(options: ModuleOptions) {
+    if (!options) {
+      return;
+    }
+
+    if (Array.isArray(options)) {
+      options.forEach(traverse);
+    }
+    else if (typeof options === 'object' && options.name) {
+      if (options.enforce === 'pre') {
+        result.pre.push(options);
+      }
+      else if (options.enforce === 'post') {
+        result.post.push(options);
+      }
+      else {
+        result.default.push(options);
+      }
+    }
+  }
+
+  modules?.forEach(traverse);
+  return result;
+}
+
+/**
+ * 注册所有模块插件的hook
+ */
+export function resolveHooks(modules: { hooks?: Module['hooks'] }[]) {
+  modules.forEach((m) => {
+    hooks.addHooks(m?.hooks ?? {});
+  });
+}

package/src/core/request.ts

@@ -0,0 +1,71 @@
+import type { AxiosResponse } from 'axios';
+import type { RequestOptions } from './interface';
+import { axiosRequestAdapter } from '@alova/adapter-axios';
+import { createAlova } from 'alova';
+import vueHook from 'alova/vue';
+import { hooks } from './ctx';
+
+function normalizedResponded(handler: RequestOptions['responded']) {
+  if (typeof handler === 'function') {
+    return { onSuccess: handler };
+  }
+  return handler;
+}
+
+export function createRequest(options: RequestOptions = {}) {
+  const {
+    axios,
+    beforeRequest,
+    responded: _responded,
+    ...restOptions
+  } = options;
+
+  const responded = normalizedResponded(_responded);
+
+  const instance = createAlova({
+    statesHook: vueHook,
+    requestAdapter: axiosRequestAdapter(axios),
+    cacheFor: null,
+    timeout: 60 * 1000,
+    ...restOptions,
+
+    beforeRequest: async (method) => {
+      await hooks.callHook('http:request', method);
+      await beforeRequest?.(method);
+    },
+
+    responded: {
+      onSuccess: async (response, method) => {
+        let stopped = false;
+        const res = await hooks.callHookWith(
+          async (hookFns, args) => {
+            let _response = args[0];
+            for (const fn of hookFns) {
+              if (stopped) {
+                break;
+              }
+              _response = await fn(_response, method, () => stopped = true);
+            }
+            return _response;
+          },
+          'http:response:onSuccess',
+          response,
+        ) as AxiosResponse<any, any>;
+
+        return stopped ? res : (responded?.onSuccess?.(res, method, () => stopped = true) ?? res);
+      },
+      onError: async (err, method) => {
+        await hooks.callHook('http:response:onError', err, method);
+        return responded?.onError?.(err, method);
+      },
+      onComplete: async (method) => {
+        await hooks.callHook('http:response:onComplete', method);
+        responded?.onComplete?.(method);
+      },
+    },
+  });
+
+  return instance;
+}
+
+export * from './interface';

package/src/core/resolver/icon.ts

@@ -0,0 +1,115 @@
+import type { ModuleRecord } from './resolver';
+import { getPubinfoNamespace } from '../utils';
+import { loadProjectModules, readProjectModules } from './resolver';
+
+// 持久化图标模块，支持 HMR 后恢复
+const namespace = getPubinfoNamespace();
+namespace.iconModules = namespace.iconModules || new Map<string, ModuleRecord>();
+const iconModuleMap = namespace.iconModules as Map<string, ModuleRecord>;
+
+namespace.iconCache = namespace.iconCache || new Map<string, string>();
+const iconCache = namespace.iconCache as Map<string, string>;
+
+function getCacheKey(name: string, id?: string) {
+  return `${id ?? 'default'}:${name}`;
+}
+
+export function getCachedIcon(name: string, id?: string) {
+  return iconCache.get(getCacheKey(name, id));
+}
+
+export function setCachedIcon(name: string, id: string | undefined, value?: string) {
+  const key = getCacheKey(name, id);
+  if (value) {
+    iconCache.set(key, value);
+  }
+  else {
+    iconCache.delete(key);
+  }
+}
+
+export function defineIconModule(id: string, map: ModuleRecord) {
+  if (iconModuleMap.has(id)) {
+    return;
+  }
+  iconModuleMap.set(id, map);
+}
+
+export function getIconModule(id: string) {
+  return iconModuleMap.get(id);
+}
+
+export function getAllIconModules(): Map<string, ModuleRecord> {
+  const merged = new Map<string, ModuleRecord>(iconModuleMap);
+  const projectIcons = readProjectModules()?.icons;
+  if (projectIcons && Object.keys(projectIcons).length) {
+    if (!merged.has('local')) {
+      merged.set('local', projectIcons);
+    }
+  }
+  return merged;
+}
+
+export async function setupIcon(name: string, id?: string) {
+  const cached = getCachedIcon(name, id);
+  if (cached) {
+    return cached;
+  }
+
+  if (!readProjectModules()) {
+    await loadProjectModules().catch(() => {});
+  }
+
+  const modules = readProjectModules();
+  const iconMap = modules?.icons ?? {};
+  const moduleMap = id ? (getIconModule(id) ?? {}) : {};
+
+  let result = await findFile(moduleMap, name);
+  if (result) {
+    setCachedIcon(name, id, result);
+    if (id) {
+      setCachedIcon(name, undefined, result);
+    }
+    return result;
+  }
+
+  result = await findFile(iconMap, name);
+  if (result) {
+    setCachedIcon(name, id, result);
+    if (id) {
+      setCachedIcon(name, undefined, result);
+    }
+    return result;
+  }
+
+  const allModules = getAllIconModules();
+  for (const [moduleId, modulePages] of allModules) {
+    // 跳过已经搜索过的模块
+    if (moduleId === id) {
+      continue;
+    }
+
+    result = await findFile(modulePages, name);
+    if (result) {
+      const targetId = moduleId === 'default' ? undefined : moduleId;
+      setCachedIcon(name, targetId, result);
+      setCachedIcon(name, undefined, result);
+      return result;
+    }
+  }
+
+  return undefined;
+}
+
+async function findFile(map: ModuleRecord, component: string) {
+  const entries = Object.entries(map);
+  const icon = entries.find(([path]) => path.endsWith(component));
+
+  if (icon?.[1]) {
+    // 执行函数并等待 Promise 解析
+    const result = await icon[1]();
+    return result.default;
+  }
+
+  return undefined;
+}

package/src/core/resolver/index.ts

@@ -0,0 +1,4 @@
+export * from './icon';
+export * from './layout';
+export * from './page';
+export * from './resolver';

package/src/core/resolver/layout.ts

@@ -0,0 +1,33 @@
+import type { ProjectModules } from './resolver';
+import { readProjectModules } from './resolver';
+
+/** 选择默认的布局组件 */
+function selectDefaultLayout(layouts: ProjectModules['layouts'], name?: string): (() => Promise<any>) | null {
+  const entries = Object.entries(layouts ?? {});
+  if (entries.length === 0) {
+    return null;
+  }
+
+  if (name) {
+    const match = entries.find(([path]) => {
+      const filename = path.split('/').pop()?.replace(/\.vue$/, '');
+      return filename === name;
+    });
+    if (match) {
+      return match[1];
+    }
+  }
+
+  if (entries.length === 1) {
+    return entries[0][1];
+  }
+
+  const indexEntry = entries.find(([path]) => path.endsWith('/index.vue'));
+  return indexEntry?.[1] || entries[0][1];
+}
+
+/** 设置默认布局组件 */
+export function setupDefaultLayout(name?: string) {
+  const modules = readProjectModules();
+  return selectDefaultLayout(modules?.layouts, name);
+}

package/src/core/resolver/page.ts

@@ -0,0 +1,88 @@
+import type { ModuleRecord } from './resolver';
+import { readProjectModules } from './resolver';
+
+// #region --- 文件模块路由
+const routeModuleMap = new Map<string, ModuleRecord>();
+
+export function defineRouteModule(id: string, map: ModuleRecord) {
+  if (routeModuleMap.has(id)) {
+    return;
+  }
+  routeModuleMap.set(id, map);
+}
+
+export function getRouteModule(id: string) {
+  return routeModuleMap.get(id);
+}
+
+export function getAllRouteModules(): Map<string, ModuleRecord> {
+  return routeModuleMap;
+}
+
+export interface ModulePageInfo {
+  path: string
+  component: () => Promise<any>
+  moduleName: string
+}
+
+export function getAllRouteModulesPages(): ModulePageInfo[] {
+  const allPages: ModulePageInfo[] = [];
+  for (const [id, moduleMap] of routeModuleMap) {
+    Object.entries(moduleMap).forEach(([path, component]) => {
+      allPages.push({
+        path,
+        component,
+        moduleName: id,
+      });
+    });
+  }
+  return allPages;
+}
+
+/**
+ * 设置页面组件
+ * @param component 组件路径
+ * @param id 路由模块 ID
+ * @returns 页面组件
+ */
+export function setupPage(component: string, id?: string) {
+  const modules = readProjectModules();
+  const pageMap = modules?.pages ?? {};
+  const moduleMap = id ? (getRouteModule(id) ?? {}) : {};
+
+  // 1. 首先在指定的路由模块中查找
+  let result = findPageFile(moduleMap, component);
+  if (result) {
+    return result;
+  }
+
+  // 2. 然后在主项目的 pages 中查找
+  result = findPageFile(pageMap, component);
+  if (result) {
+    return result;
+  }
+
+  // 3. 最后在所有其他模块中查找
+  const allModules = getAllRouteModules();
+  for (const [moduleId, modulePages] of allModules) {
+    // 跳过已经搜索过的模块
+    if (moduleId === id) {
+      continue;
+    }
+
+    result = findPageFile(modulePages, component);
+    if (result) {
+      return result;
+    }
+  }
+
+  return undefined;
+}
+
+function findPageFile(map: ModuleRecord, component: string) {
+  const entries = Object.entries(map);
+  const page = entries.find(([path]) => path.endsWith(component));
+
+  return page?.[1];
+}
+// #endregion

package/src/core/resolver/resolver.ts

@@ -0,0 +1,25 @@
+export type ModuleRecord = Record<string, () => Promise<any>>;
+
+export interface ProjectModules {
+  icons?: ModuleRecord
+  layouts?: ModuleRecord
+  pages?: ModuleRecord
+}
+
+let modules: ProjectModules | undefined;
+
+/** 加载项目中的约定式目录结构 */
+export async function loadProjectModules() {
+  try {
+    modules = (await import('virtual:pubinfo-resolver')).default as ProjectModules;
+  }
+  catch (err) {
+    console.warn('[PUBINFO] virtual:pubinfo-resolver not available.');
+    modules = {};
+  }
+}
+
+/** 读取项目中的约定式目录结构 */
+export function readProjectModules() {
+  return modules;
+}