@pubinfo-nightly/core 2025.11.14

package/src/built-in/pinia-plugin/plugins/persistedstate/types.ts

@@ -0,0 +1,162 @@
+import type { PiniaPluginContext, StateTree } from 'pinia';
+
+/**
+ * 存储区域类型：本地存储或会话存储
+ */
+export type StorageArea = 'local' | 'session';
+
+/**
+ * 类似 Storage 的接口，用于抽象存储操作
+ */
+export interface StorageLike {
+  /** 获取指定键的值 */
+  getItem: (key: string) => string | null
+  /** 设置指定键的值 */
+  setItem: (key: string, value: string) => void
+}
+
+/**
+ * 序列化器接口，用于状态的序列化和反序列化
+ */
+export interface Serializer {
+  /** 将状态对象序列化为字符串 */
+  serialize: (data: StateTree) => string
+  /** 将字符串反序列化为状态对象 */
+  deserialize: (data: string) => StateTree
+}
+
+/**
+ * 持久化配置接口
+ */
+export interface Persistence<State extends StateTree = StateTree> {
+  /** 存储键名 */
+  key: string
+  /** 是否开启调试模式 */
+  debug: boolean
+  /** 存储实例 */
+  storage: StorageLike
+  /** 序列化器 */
+  serializer: Serializer
+  /** 恢复数据前的钩子 */
+  beforeHydrate?: (context: PiniaPluginContext) => void
+  /** 恢复数据后的钩子 */
+  afterHydrate?: (context: PiniaPluginContext) => void
+  /** 要持久化的状态字段（白名单） */
+  pick?: string[]
+  /** 不需要持久化的状态字段（黑名单） */
+  omit?: string[]
+}
+
+/**
+ * 插件基础配置选项
+ */
+export interface BasePluginOptions {
+  /** 存储实例 */
+  storage?: StorageLike
+  /** 序列化器 */
+  serializer?: Serializer
+  /** 是否开启调试模式 */
+  debug?: boolean
+  /** 存储键名生成函数 */
+  key?: (storeKey: string) => string
+  /** 是否自动为所有 store 启用持久化 */
+  auto?: boolean
+}
+
+/**
+ * 持久化选项类型（提供给 store 使用）
+ */
+export type PersistenceOptions<State extends StateTree = StateTree> = Partial<Omit<Persistence<State>, 'key'>> & {
+  /** 自定义存储键名 */
+  key?: string
+};
+
+/**
+ * 扩展的持久化选项，包含存储区域配置
+ */
+export type ExtendedPersistenceOptions<State extends StateTree = StateTree> = PersistenceOptions<State> & {
+  /** 存储区域类型 */
+  storageArea?: StorageArea
+};
+
+/**
+ * 自定义存储事件详情
+ */
+export interface CustomStorageEventDetail {
+  /** 变化的键名，null 表示清空操作 */
+  key: string | null
+  /** 新值 */
+  newValue: string | null
+  /** 旧值 */
+  oldValue: string | null
+  /** 存储区域 */
+  storageArea: StorageArea
+}
+
+/**
+ * 标准化后的全局配置选项
+ */
+export interface NormalizedGlobalOptions {
+  /** 键名生成函数 */
+  key: (storeKey: string) => string
+  /** 序列化器 */
+  serializer: Serializer
+  /** 存储实例 */
+  storage?: StorageLike
+  /** 存储区域 */
+  storageArea?: StorageArea
+  /** 是否开启调试 */
+  debug: boolean
+  /** 是否自动持久化 */
+  auto: boolean
+}
+
+/**
+ * 持久化条目，包含完整的配置信息
+ */
+export interface PersistenceEntry<State extends StateTree = StateTree> {
+  /** 存储键名 */
+  key: string
+  /** 存储实例 */
+  storage: StorageLike
+  /** 序列化器 */
+  serializer: Serializer
+  /** 存储区域 */
+  storageArea?: StorageArea
+  /** 完整的存储键名（用于同步监听） */
+  fullKey?: string
+  /** 是否开启调试 */
+  debug: boolean
+  /** 恢复前钩子 */
+  beforeHydrate?: (context: PiniaPluginContext) => void
+  /** 恢复后钩子 */
+  afterHydrate?: (context: PiniaPluginContext) => void
+  /** 白名单字段 */
+  pick?: PersistenceOptions<State>['pick']
+  /** 黑名单字段 */
+  omit?: PersistenceOptions<State>['omit']
+}
+
+/**
+ * 存储绑定，关联 store 和持久化配置
+ */
+export interface StorageBinding<State extends StateTree = StateTree> {
+  /** Pinia 插件上下文 */
+  context: PiniaPluginContext
+  /** 持久化条目 */
+  entry: PersistenceEntry<State>
+  /** 跳过持久化次数（用于避免循环） */
+  skipPersist: number
+  /** 停止订阅的函数 */
+  stopSubscription: () => void
+  /** 初始状态快照 */
+  initialState: StateTree
+}
+
+/**
+ * 同步持久化状态插件的配置选项
+ */
+export interface SyncedPersistedStateOptions extends BasePluginOptions {
+  /** 存储区域 */
+  storageArea?: StorageArea
+}

package/src/built-in/pinia-plugin/plugins/persistedstate/utils.ts

@@ -0,0 +1,46 @@
+import type { CustomStorageEventDetail, StorageArea } from './types';
+
+/** 自定义事件名称，用于跨标签页通信 */
+export const CUSTOM_EVENT = 'pubinfo-nightly:persistedstate:local';
+
+/**
+ * 调度微任务，优先使用原生 queueMicrotask
+ */
+export const scheduleMicrotask = typeof queueMicrotask === 'function'
+  ? queueMicrotask
+  : (fn: () => void) => {
+      Promise.resolve().then(fn);
+    };
+
+/**
+ * 解析存储区域类型
+ * @param storage - Storage 实例
+ * @returns 存储区域类型或 undefined
+ */
+export function resolveStorageArea(storage: Storage | null | undefined): StorageArea | undefined {
+  if (!storage || typeof window === 'undefined') {
+    return undefined;
+  }
+  try {
+    if (storage === window.localStorage) {
+      return 'local';
+    }
+    if (storage === window.sessionStorage) {
+      return 'session';
+    }
+  }
+  catch {
+    return undefined;
+  }
+  return undefined;
+}
+
+/**
+ * 分发本地 storage 变更事件
+ */
+export function dispatchLocalMutation(detail: CustomStorageEventDetail) {
+  if (typeof window === 'undefined' || typeof window.CustomEvent !== 'function' || typeof window.dispatchEvent !== 'function') {
+    return;
+  }
+  window.dispatchEvent(new CustomEvent<CustomStorageEventDetail>(CUSTOM_EVENT, { detail }));
+}

package/src/built-in/pinia-plugin/plugins/tabbarStorage.ts

@@ -0,0 +1,97 @@
+import type { PiniaPluginContext } from 'pinia';
+import type { useTabbarStore } from '@/features/stores';
+import { cloneDeep } from 'lodash-es';
+import { GetAPITabbar, GetAPITabbarEdit } from '@/features/api/system/user';
+import { useSettingsStore, useUserStore } from '@/features/stores';
+import { storage } from '@/utils';
+import { STORE_NAME } from '../enum';
+import { getTabbarMemoryKey } from '../helper';
+
+/**
+ * 选项卡持久化插件
+ */
+export function createTabbarStoragePlugin({ store }: PiniaPluginContext) {
+  if (store.$id === STORE_NAME.TABBAR) {
+    const tabbarStore = store as ReturnType<typeof useTabbarStore>;
+    const tabbarId = computed(() => useUserStore().user.account);
+    const settingsStore = useSettingsStore();
+
+    // list 变化时更新存储
+    watch(
+      () => tabbarStore.list,
+      () => {
+        updateStorage();
+      },
+      { deep: true },
+    );
+
+    /**
+     * 更新存储
+     */
+    async function updateStorage() {
+      if (settingsStore.settings.tabbar.storageTo === 'local') {
+        const tabbarMemoryKey = getTabbarMemoryKey();
+        const pinData = storage.local.has(tabbarMemoryKey) ? JSON.parse(storage.local.get(tabbarMemoryKey) as string) : {};
+        pinData[tabbarId.value] = cloneDeep(tabbarStore.list.filter((item) => {
+          return item.isPin;
+        })).map((item) => {
+          // 不存储自定义标题
+          item.customTitleList = [];
+          return item;
+        });
+        storage.local.set(tabbarMemoryKey, JSON.stringify(pinData));
+      }
+      else if (settingsStore.settings.tabbar.storageTo === 'server') {
+        await GetAPITabbarEdit(JSON.stringify(cloneDeep(tabbarStore.list.filter((item) => {
+          return item.isPin;
+        })).map((item) => {
+          // 不存储自定义标题
+          item.customTitleList = [];
+          return item;
+        })));
+      }
+
+      if (settingsStore.settings.tabbar.enableMemory) {
+        // 将非固定和非常驻标签页记录到 sessionStorage
+        const tabbarMemoryKey = getTabbarMemoryKey();
+        const unpinData = storage.session.has(tabbarMemoryKey) ? JSON.parse(storage.session.get(tabbarMemoryKey) as string) : {};
+        unpinData[tabbarId.value] = cloneDeep(tabbarStore.list.filter((item) => {
+          return !item.isPin && !item.isPermanent;
+        })).map((item) => {
+          // 不存储自定义标题
+          item.customTitleList = [];
+          return item;
+        });
+        storage.session.set(tabbarMemoryKey, JSON.stringify(unpinData));
+      }
+    }
+
+    /**
+     * 从存储中恢复标签栏数据
+     */
+    async function recoveryStorage() {
+      if (!settingsStore.settings.tabbar.enable) {
+        return;
+      }
+
+      const tabbarMemoryKey = getTabbarMemoryKey();
+
+      if (settingsStore.settings.tabbar.storageTo === 'local') {
+        if (storage.local.has(tabbarMemoryKey)) {
+          tabbarStore.list.push(...(JSON.parse(storage.local.get(tabbarMemoryKey) as string)[tabbarId.value] || []));
+        }
+      }
+      else if (settingsStore.settings.tabbar.storageTo === 'server') {
+        const res = await GetAPITabbar();
+        tabbarStore.list.push(...(JSON.parse(res.data.tabbar || '[]')));
+      }
+
+      if (settingsStore.settings.tabbar.enableMemory && storage.session.has(tabbarMemoryKey)) {
+        tabbarStore.list.push(...(JSON.parse(storage.session.get(tabbarMemoryKey) as string)[tabbarId.value] || []));
+      }
+    }
+
+    // 给 tabbarStore 增加方法
+    store.recoveryStorage = recoveryStorage;
+  }
+}

package/src/built-in/pre-access/index.ts

@@ -0,0 +1,20 @@
+import type { ModuleOptions } from '@/core';
+import { basic as request } from '@/features/api/request';
+
+function validateIp() {
+  return request.Post<API.IsSuccess>('/validateIp', {}, { meta: { authRole: null } });
+}
+
+/**
+ * 入口访问控制 (系统级拦截)
+ *
+ * 例如，黑白名单检测、防火墙规则等
+ */
+export function PreAccess(): ModuleOptions {
+  return {
+    name: 'built-in:pre-access',
+    async setup() {
+      await validateIp();
+    },
+  };
+}

package/src/built-in/settings/index.ts

@@ -0,0 +1,15 @@
+import type { ModuleOptions } from '@/core';
+import { createRouterGuard } from './router';
+
+/**
+ * 配置项
+ */
+export function Settings(): ModuleOptions {
+  return {
+    name: 'built-in:settings',
+    setup(ctx) {
+      const { router } = ctx;
+      createRouterGuard(router);
+    },
+  };
+}

package/src/built-in/settings/router.ts

@@ -0,0 +1,138 @@
+import type { RouterMetaRawBaseOptions } from '#/vue-router';
+import type { Router } from 'vue-router';
+import { useError } from '@/features/composables';
+import {
+  useIframeStore,
+  useKeepAliveStore,
+  useMenuStore,
+  useSettingsStore,
+  useTabbarStore,
+  useUserStore,
+} from '@/features/stores';
+
+/** 配置路由守卫 */
+export function createRouterGuard(router: Router) {
+  const settingsStore = useSettingsStore();
+  const menuStore = useMenuStore();
+  const tabbarStore = useTabbarStore();
+  const iframeStore = useIframeStore();
+  const keepAliveStore = useKeepAliveStore();
+  const userStore = useUserStore();
+
+  router.beforeEach(async (to) => {
+    // 生成 iframe 列表
+    if (!iframeStore.isGenerate) {
+      await iframeStore.generateList(router.getRoutes(), userStore.user);
+    }
+
+    // 导航栏如果不是 single 模式，则需要根据 path 定位主导航的选中状态
+    if (settingsStore.settings.menu.menuMode !== 'single') {
+      menuStore.setActived(to.path);
+    }
+
+    // 如果未开启主页，但进入的是主页，则会进入第一个固定标签页或者侧边栏导航第一个模块
+    if (to.name === 'Home' && !settingsStore.settings.home.enable) {
+      const firstPin = tabbarStore.list.find(v => v.isPin);
+
+      if (settingsStore.settings.tabbar.enable && firstPin) {
+        return {
+          path: firstPin.fullPath,
+          replace: true,
+        };
+      }
+
+      if (menuStore.sidebarMenus.length > 0) {
+        return {
+          path: menuStore.sidebarMenusFirstDeepestPath,
+          replace: true,
+        };
+      }
+    }
+  });
+
+  router.afterEach(async (to, from) => {
+    // 记录页面auth
+    settingsStore.setAuth(to.meta.auth || '');
+
+    // 设置页面 title
+    settingsStore.setTitle(to.meta.breadcrumbNeste?.at(-1)?.title ?? to.meta.title);
+
+    if (to.fullPath === from.fullPath) {
+      return;
+    }
+
+    // 判断当前页面是否开启缓存，如果开启，则将当前页面的 name 信息存入 keep-alive 全局状态
+    if (to.meta.cache && !to.meta.iframe) {
+      const componentName = to.matched.at(-1)?.components?.default?.name;
+      if (componentName) {
+        keepAliveStore.add(componentName);
+      }
+      else {
+        useError(`路径 ${to.path} 对应的 SFC组件未设置组件名，会导致缓存失效(虽然 vue@3.2.34 之后会默认使用文件名,但是文件名判重的概率较大，故不采用)`);
+      }
+    }
+
+    // 判断离开页面是否开启缓存，如果开启，则根据缓存规则判断是否需要清空 keep-alive 全局状态里离开页面的 name 信息
+    if (from.meta.cache && !from.meta.iframe) {
+      const componentName = from.matched.at(-1)?.components?.default.name;
+      if (componentName) {
+        const isCache = hitCache(to.name as string, from.meta.cache, from.meta.noCache);
+        const toReload = to.name === 'Reload';
+
+        if (!isCache || toReload) {
+          keepAliveStore.remove(componentName);
+        }
+      }
+    }
+
+    if (to.meta.iframe) {
+      iframeStore.open(to.fullPath);
+    }
+
+    if (from.meta.iframe) {
+      // 判断是否启用 iframe 缓存（保留 DOM 实例）
+      const shouldCacheIframe = from.meta.iframeCache === true;
+
+      if (shouldCacheIframe) {
+        // 启用缓存：不销毁 iframe，仅标记为非激活（保留 DOM）
+        // 不调用 close，让 iframe 保持在 openedList 中
+      }
+      else {
+        // 未启用缓存：根据常规缓存规则判断是否销毁
+        const isCache = hitCache(to.name as string, from.meta.cache, from.meta.noCache);
+        const toReload = to.name === 'Reload';
+
+        if (!isCache || toReload) {
+          // 真正销毁 iframe（destroy = true）
+          iframeStore.close(from.fullPath, true);
+        }
+      }
+    }
+  });
+}
+
+/** 判断是否命中cache */
+function hitCache(
+  name?: string,
+  cache?: RouterMetaRawBaseOptions['cache'],
+  noCache?: RouterMetaRawBaseOptions['noCache'],
+) {
+  if (typeof cache === 'boolean') {
+    return cache && !matched(name, noCache);
+  }
+
+  return matched(name, cache) && !matched(name, noCache);
+}
+
+function matched(
+  name?: string,
+  condition?: RouterMetaRawBaseOptions['cache'] | RouterMetaRawBaseOptions['noCache'],
+) {
+  if (typeof condition === 'string') {
+    return condition === name;
+  }
+  if (Array.isArray(condition)) {
+    return condition.includes(name as string);
+  }
+  return false;
+}

package/src/built-in/system-info/components/SystemInfo.vue

@@ -0,0 +1,83 @@
+<script setup lang="ts">
+import { useToggle } from '@vueuse/core';
+import hotkeys from 'hotkeys-js';
+import HSlideover from '@/built-in/layout-component/components/ui/HSlideover.vue';
+
+const [visible, toggle] = useToggle(false);
+
+const { pkg, buildTime, git } = __SYSTEM_INFO__;
+hotkeys('alt+i', () => toggle());
+</script>
+
+<template>
+  <HSlideover v-model="visible" title="系统信息">
+    <div class="text-dark dark:text-light">
+      <div class="px-4">
+        <h2 class="m-0 text-lg font-bold">
+          最后编译时间
+        </h2>
+        <div class="my-4 text-center text-lg font-sans">
+          {{ buildTime }}
+        </div>
+      </div>
+      <div class="px-4">
+        <h2 class="m-0 text-lg font-bold">
+          生产环境依赖
+        </h2>
+        <ul class="list-none pl-0 text-sm">
+          <li v-for="(val, key) in (pkg.dependencies as object)" :key="key" class="flex items-center justify-between rounded px-2 py-1.5 hover:bg-stone-1 dark:hover:bg-stone-9">
+            <div class="font-bold">
+              {{ key }}
+            </div>
+            <div class="font-sans">
+              {{ val }}
+            </div>
+          </li>
+        </ul>
+      </div>
+      <div class="px-4">
+        <h2 class="m-0 text-lg font-bold">
+          开发环境依赖
+        </h2>
+        <ul class="list-none pl-0 text-sm">
+          <li v-for="(val, key) in (pkg.devDependencies as object)" :key="key" class="flex items-center justify-between rounded px-2 py-1.5 hover:bg-stone-1 dark:hover:bg-stone-9">
+            <div class="font-bold">
+              {{ key }}
+            </div>
+            <div class="font-sans">
+              {{ val }}
+            </div>
+          </li>
+        </ul>
+      </div>
+      <div v-if="git" class="px-4">
+        <h2 class="m-0 text-lg font-bold">
+          Git 信息
+        </h2>
+        <ul class="list-none pl-0 text-sm">
+          <li class="flex items-center justify-between rounded px-2 py-1.5 hover:bg-stone-1 dark:hover:bg-stone-9">
+            <div class="font-bold">
+              编译分支
+            </div>
+            <div class="font-sans">
+              {{ git.branch }}
+            </div>
+          </li>
+          <li class="flex items-center justify-between rounded px-2 py-1.5 hover:bg-stone-1 dark:hover:bg-stone-9">
+            <div class="font-bold">
+              最新提交提交哈希
+            </div>
+            <a-tooltip>
+              <template #title>
+                {{ git.commit }}
+              </template>
+              <div class="font-sans">
+                {{ git.commitShort }}
+              </div>
+            </a-tooltip>
+          </li>
+        </ul>
+      </div>
+    </div>
+  </HSlideover>
+</template>

package/src/built-in/system-info/index.ts

@@ -0,0 +1,16 @@
+import type { ModuleOptions } from '@/core';
+import SystemInfoComponent from './components/SystemInfo.vue';
+
+/**
+ * 系统信息
+ */
+export function SystemInfo(): ModuleOptions {
+  return {
+    name: 'built-in:system-info',
+    setup() {
+      const container = document.createElement('div');
+      document.body.appendChild(container);
+      createApp(SystemInfoComponent).mount(container);
+    },
+  };
+}

package/src/core/create.ts

@@ -0,0 +1,71 @@
+import type { Context, Options } from './interface';
+
+import { createPinia } from 'pinia';
+import { createApp as createVueApp } from 'vue';
+import { createRouter, createWebHashHistory } from 'vue-router';
+
+import { extractModules, resolveHooks, resolveModules } from './modules';
+import { loadProjectModules } from './resolver';
+
+export function createApp(options: Options) {
+  const {
+    app: App,
+    router: routerOptions,
+    setup,
+    rootContainer = '#app',
+    immediate = true,
+    modules = [],
+    hooks: _hooks = {},
+  } = options;
+
+  async function _createApp() {
+    await loadProjectModules();
+
+    const app = createVueApp(App);
+    const store = createPinia();
+    app.use(store);
+
+    const { base, ...restRouterOptions } = routerOptions;
+    const router = createRouter({
+      history: createWebHashHistory(base),
+      ...restRouterOptions,
+    });
+
+    const context: Context = {
+      app,
+      store,
+      router,
+    };
+
+    // 解析插件
+    const resolvedModules = extractModules(modules);
+
+    // 注册 hooks
+    resolveHooks([
+      ...resolvedModules.pre,
+      ...resolvedModules.default,
+      { hooks: _hooks },
+      ...resolvedModules.post,
+    ]);
+
+    await resolveModules(resolvedModules.pre, context);
+    await resolveModules(resolvedModules.default, context);
+    await setup?.(context);
+    await resolveModules(resolvedModules.post, context);
+
+    // router 必须放在最后注册
+    app.use(router);
+
+    return context;
+  }
+
+  if (immediate) {
+    (async () => {
+      const { app, router } = await _createApp();
+      await router.isReady();
+      app.mount(rootContainer, true);
+    })();
+  }
+
+  return _createApp;
+}

package/src/core/ctx.ts

@@ -0,0 +1,46 @@
+import { createHooks } from 'hookable';
+import { getPubinfoNamespace } from './utils';
+
+const HOOKS_KEY = '__pubinfo_core_hooks__';
+type HookStore = ReturnType<typeof createHooks>;
+
+const namespace = getPubinfoNamespace() as Record<string, HookStore | undefined>;
+
+export const hooks = namespace[HOOKS_KEY] || (namespace[HOOKS_KEY] = createHooks());
+
+export async function callHookAsync<T>(hookname: string, data: T) {
+  return await hooks.callHookWith(
+    async (hookFns, args) => {
+      let res = args[0];
+      for (const fn of hookFns) {
+        res = await fn(res);
+      }
+      return res as T;
+    },
+    hookname,
+    data,
+  );
+}
+
+export function callHookSync<T>(hookname: string, data: T) {
+  return hooks.callHookWith(
+    (hookFns, args) => {
+      let res = args[0] as T;
+      if (!hookFns.length) {
+        return res;
+      }
+      for (const fn of hookFns) {
+        const output = fn(res);
+        if (output && typeof (output as PromiseLike<unknown>).then === 'function') {
+          throw new Error(`[hooks] "${hookname}" 当前仅支持同步回调`);
+        }
+        if (typeof output !== 'undefined') {
+          res = output as T;
+        }
+      }
+      return res;
+    },
+    hookname,
+    data,
+  );
+}