@pubinfo/core 2.0.0-rc.4 → 2.0.0-rc.5

package/src/features/components/PubinfoIcon/props.ts

@@ -0,0 +1,54 @@
+/**
+ * 不带盒子外观的图标配置。
+ * 当未显式设置 `box` 时将使用该形状；并且此时不允许传入 `background` / `radius`。
+ */
+export interface PubinfoIconNotBoxOptions {
+  /** 图标名称 */
+  name: string
+  /** 是否异步加载 */
+  async?: boolean
+  /** 翻转方向 */
+  flip?: 'horizontal' | 'vertical' | 'both'
+  /** 旋转角度 */
+  rotate?: number
+  /** 颜色 */
+  color?: string
+  /** 尺寸 */
+  size?: string | number
+}
+
+/**
+ * 带盒子外观的图标配置。判定条件：存在 `box` 字段。
+ * 这里将 `box` 设为必填，用作判别式属性。
+ */
+export interface PubinfoIconBoxOptions extends PubinfoIconNotBoxOptions {
+  /** 盒子类型（存在该字段即可触发 Box 选项） */
+  box: 'square' | 'prism'
+  /** 背景：纯色或渐变 */
+  background?: string | {
+    from: string
+    to: string
+  }
+  /** 圆角 */
+  radius?: number | string
+  /** 背景渐变的角度 */
+  angle?: number | string
+  /** 是否是小 logo */
+  small?: boolean
+}
+
+/**
+ * 根据是否提供 `box` 自动区分两类配置：
+ * - 未提供 `box`：禁止出现 `background` 与 `radius`（否则 TS 报错）
+ * - 提供 `box`：允许使用盒子相关属性
+ */
+export type PubinfoIconOptions
+  = | PubinfoIconBoxOptions
+    | (PubinfoIconNotBoxOptions & { box?: undefined, background?: never, radius?: never, angle?: never, small?: false });
+
+/**
+ * 可用于泛型推断的条件类型：传入的对象类型若含有 `box` 字段，则推断为 Box 版本，否则为普通版本。
+ * 一般情况下直接使用 `PubinfoIconOptions` 联合类型即可。
+ */
+export type InferPubinfoIconOptions<T extends { box?: any } | undefined>
+  = T extends { box: PubinfoIconBoxOptions['box'] } ? PubinfoIconBoxOptions : PubinfoIconNotBoxOptions;

package/src/features/components/index.ts

@@ -4,5 +4,8 @@ export { default as PageMain } from './PageMain/index.vue';
 export { default as PassStrengthValidator } from './PassStrengthValidator/index.vue';
 export { default as PubinfoApp } from './PubinfoApp/index.vue';
 export { default as PubinfoIcon } from './PubinfoIcon/index.vue';
+export { default as PubinfoIconPrismBox } from './PubinfoIcon/PrismBox.vue';
+export { default as PubinfoIconSquareBox } from './PubinfoIcon/SquareBox.vue';
 export { default as PubinfoProvider } from './PubinfoProvider';
-export { createPubinfoProvider, pubinfoInjectionKey } from './PubinfoProvider';
+
+export { createPubinfoProvider, pubinfoInjectionKey } from './PubinfoProvider'; ;

package/src/features/context/index.ts

@@ -9,26 +9,11 @@ interface InternalContext {
   requestBasic: RequestInstance
 }
 
-// 持久化全局上下文，支持 HMR 后恢复
-const g = globalThis as any;
-g.__PUBINFO__ = g.__PUBINFO__ || {};
-if (!g.__PUBINFO__.ctx) {
-  g.__PUBINFO__.ctx = createContext<InternalContext>();
-}
-const ctx = g.__PUBINFO__.ctx as ReturnType<typeof createContext<InternalContext>>;
-
-// 旧 state 恢复
-if (g.__PUBINFO__.state) {
-  try {
-    ctx.set(g.__PUBINFO__.state);
-  }
-  catch {}
-}
+const ctx = createContext<InternalContext>('ctx', { stateKey: 'state' });
 
 /** 初始化全局 context */
 export function createPubinfoContext(newState: InternalContext) {
   // 缓存用于 wrapProxy 兜底
-  g.__PUBINFO__.state = newState;
   ctx.set(newState);
   // 立即激活 use()
   ctx.use();

package/src/features/settings/index.ts

@@ -52,7 +52,6 @@ let globalSettings: RequiredDeep<Settings.all> = {
   },
   toolbar: {
     enableNotification: true,
-    enableI18n: true,
     enableFullscreen: true,
     enablePageReload: true,
     enableColorScheme: true,

package/src/index.ts

@@ -7,6 +7,7 @@ import {
   PiniaPlugin,
   PreAccess,
   Settings,
+  SystemInfo,
 } from './built-in';
 import { createApp } from './core';
 import { createPubinfoContext } from './features/context/index.ts';
@@ -71,6 +72,7 @@ export function createPubinfo(options: PubinfoOptions) {
       LayoutComponent(),
       Settings(),
       NProgress(),
+      SystemInfo(),
       ...(options.modules ?? []),
     ],
   });
@@ -107,7 +109,12 @@ export * from './features';
 export {
   cleanup,
   cleanupWithoutUser,
+  clearPersistedState,
   createContext,
+  createRawContext,
+  getPersistedState,
+  getPubinfoNamespace,
+  setPersistedState,
   storage,
   wrapProxy,
 } from './utils';

package/src/utils/global.ts

@@ -0,0 +1,161 @@
+import type { UseContext } from 'unctx';
+import { createContext as createRawContext } from 'unctx';
+
+type PubinfoNamespace = Record<string, unknown>;
+
+function ensureNamespace(): PubinfoNamespace {
+  const g = globalThis as typeof globalThis & { __PUBINFO__?: PubinfoNamespace };
+  if (!g.__PUBINFO__) {
+    g.__PUBINFO__ = {};
+  }
+  return g.__PUBINFO__;
+}
+
+/**
+ * Return the shared __PUBINFO__ namespace, creating it if necessary.
+ */
+export function getPubinfoNamespace(): PubinfoNamespace {
+  return ensureNamespace();
+}
+
+interface PersistedContextOptions {
+  /**
+   * Optional key used to hydrate persisted state.
+   * Defaults to transforming `FooCtx` into `FooState`.
+   */
+  stateKey?: string
+  /**
+   * Toggle hydration behaviour. Enabled by default.
+   */
+  hydrate?: boolean
+  /**
+   * Automatically persist whenever ctx.set() is called.
+   */
+  persistOnSet?: boolean
+}
+
+/**
+ * Create (or reuse) a context stored on the global namespace and
+ * hydrate it from a persisted state if available.
+ */
+export function createContext<T>(
+  contextKey: string,
+  options: PersistedContextOptions = {},
+): UseContext<T> {
+  const namespace = ensureNamespace();
+
+  const normalized = normalizeKeys(contextKey, options.stateKey);
+
+  if (!namespace[normalized.contextKey]) {
+    const existing = normalized.aliasKey ? namespace[normalized.aliasKey] : undefined;
+    namespace[normalized.contextKey] = (existing as UseContext<T> | undefined) ?? createRawContext<T>();
+  }
+
+  const ctx = namespace[normalized.contextKey] as UseContext<T> & { __pubinfo_persisted?: boolean };
+
+  if (normalized.aliasKey) {
+    namespace[normalized.aliasKey] = ctx;
+  }
+
+  const { hydrate = true, persistOnSet = true } = options;
+  const hydrateKey = normalized.stateKey;
+
+  if (hydrateKey && persistOnSet && !ctx.__pubinfo_persisted) {
+    const originalSet = ctx.set.bind(ctx);
+    const originalUnset = ctx.unset.bind(ctx);
+
+    ctx.set = (instance?: T, replace?: boolean) => {
+      originalSet(instance, replace);
+      if (instance !== undefined) {
+        setPersistedState(hydrateKey, instance);
+      }
+      else {
+        clearPersistedState(hydrateKey);
+      }
+    };
+
+    ctx.unset = () => {
+      clearPersistedState(hydrateKey);
+      originalUnset();
+    };
+
+    ctx.__pubinfo_persisted = true;
+  }
+
+  if (hydrate && hydrateKey) {
+    const savedState = namespace[hydrateKey];
+    if (savedState !== undefined) {
+      try {
+        ctx.set(savedState as T);
+      }
+      catch {
+        // ignore hydration failures; callers can recover manually
+      }
+    }
+  }
+
+  return ctx;
+}
+
+/** Persist a value inside the __PUBINFO__ namespace. */
+export function setPersistedState<T>(stateKey: string, state: T) {
+  const namespace = ensureNamespace();
+  namespace[stateKey] = state;
+}
+
+/** Retrieve a value from the __PUBINFO__ namespace. */
+export function getPersistedState<T>(stateKey: string): T | undefined {
+  const namespace = ensureNamespace();
+  return namespace[stateKey] as T | undefined;
+}
+
+/** Remove a value from the __PUBINFO__ namespace. */
+export function clearPersistedState(stateKey: string) {
+  const namespace = ensureNamespace();
+  if (stateKey in namespace) {
+    delete namespace[stateKey];
+  }
+}
+
+interface NormalizedKeys {
+  contextKey: string
+  stateKey?: string
+  aliasKey?: string
+}
+
+function normalizeKeys(contextKey: string, explicitStateKey?: string): NormalizedKeys {
+  if (explicitStateKey) {
+    return { contextKey, stateKey: explicitStateKey };
+  }
+
+  if (contextKey.endsWith('Ctx')) {
+    const base = contextKey.slice(0, -3);
+    return {
+      contextKey,
+      stateKey: base ? `${base}State` : undefined,
+    };
+  }
+
+  if (contextKey.endsWith('Context')) {
+    const base = contextKey.slice(0, -7);
+    if (base) {
+      return {
+        contextKey: `${base}Ctx`,
+        stateKey: `${base}State`,
+        aliasKey: contextKey,
+      };
+    }
+  }
+
+  const base = contextKey;
+  if (!base) {
+    return { contextKey, stateKey: undefined };
+  }
+
+  const normalizedContextKey = `${base}Ctx`;
+  return {
+    contextKey: normalizedContextKey,
+    stateKey: `${base}State`,
+    aliasKey: normalizedContextKey !== contextKey ? contextKey : undefined,
+  };
+}

package/src/utils/index.ts

@@ -1,5 +1,6 @@
 export * from './cleanup';
+export * from './global';
 export * from './path';
 export * from './proxy';
 export * from './storage';
-export { createContext } from 'unctx';
+export { createContext as createRawContext } from 'unctx';

package/src/utils/proxy.ts

@@ -1,3 +1,5 @@
+import { getPersistedState } from './global';
+
 export function wrapProxy<T extends Record<K, any>, K extends keyof T>(
   fn: () => T,
   key: K,
@@ -10,14 +12,11 @@ export function wrapProxy<T extends Record<K, any>, K extends keyof T>(
       }
       catch (e) {
         // 1. 从全局缓存读取
-        const g: any = globalThis as any;
-        if (g.__PUBINFO__?.state) {
-          const cached = g.__PUBINFO__.state as T;
-          if (cached && cached[key]) {
-            const inst = cached[key];
-            const val = (inst as any)[prop];
-            return typeof val === 'function' ? val.bind(inst) : val;
-          }
+        const cached = getPersistedState<T>('state');
+        if (cached && cached[key]) {
+          const inst = cached[key];
+          const val = (inst as any)[prop];
+          return typeof val === 'function' ? val.bind(inst) : val;
         }
         throw e;
       }

package/types/global.d.ts

@@ -0,0 +1,7 @@
+declare const __SYSTEM_INFO__: {
+  pkg: {
+    dependencies: Record<string, string>
+    devDependencies: Record<string, string>
+  }
+  buildTime: string
+};

package/types/menu.d.ts

@@ -24,6 +24,16 @@ export declare namespace Menu {
       icon?: string
       activeIcon?: string
       auth?: string | string[]
+      iconOptions?: {
+        angle?: number | string
+        background?: string | {
+          from: string
+          to: string
+        }
+        boxType?: 'square' | 'prism'
+        iconColor?: string
+        radius?: number | string
+      }
       sidebar?: boolean
       isDev?: boolean
       devText?: string

package/types/settings.d.ts

@@ -314,13 +314,6 @@ declare namespace Settings {
      */
     enableNotification?: boolean
 
-    /**
-     * 是否开启国际化
-     *
-     * @默认值 `true`
-     */
-    enableI18n?: boolean
-
     /**
      * 是否开启全屏
      *

package/dist/SettingHome-K4Iel0Hr.js

@@ -1,55 +0,0 @@
-import { _ as f } from "./HDivider.vue_vue_type_script_setup_true_lang-DIHR-9Yv.js";
-import { _ as b } from "./HInput.vue_vue_type_script_setup_true_lang-DBqCXRnn.js";
-import { _ as g } from "./HToggle-DxdWLgp-.js";
-import { bL as V, bN as x } from "./index-IAYhIBQH.js";
-import { defineComponent as H, toRefs as v, createBlock as N, openBlock as C, withCtx as i, createElementVNode as s, createVNode as o, createTextVNode as a, unref as t } from "vue";
-import { R as _ } from "./question-line-CfkciTFq.js";
-const R = { class: "setting-item" }, S = { class: "label" }, T = { class: "setting-item" }, $ = { class: "label" }, Q = /* @__PURE__ */ H({
-  name: "SettingHome",
-  __name: "SettingHome",
-  setup(k) {
-    const { settingsStore: d } = V(), { home: n, toolbar: r } = v(d.settings);
-    return (B, e) => {
-      const m = x, p = g, u = b, c = f;
-      return C(), N(c, { title: "主页" }, {
-        default: i(() => [
-          s("div", R, [
-            s("div", S, [
-              e[2] || (e[2] = a(" 是否启用 ")),
-              o(m, { text: "该功能开启时，登录成功默认进入主页，反之则默认进入导航栏里第一个导航页面" }, {
-                default: i(() => [
-                  o(t(_))
-                ]),
-                _: 1
-              })
-            ]),
-            o(p, {
-              modelValue: t(n).enable,
-              "onUpdate:modelValue": e[0] || (e[0] = (l) => t(n).enable = l)
-            }, null, 8, ["modelValue"])
-          ]),
-          s("div", T, [
-            s("div", $, [
-              e[3] || (e[3] = a(" 主页名称 ")),
-              o(m, { text: "开启国际化时，该设置无效" }, {
-                default: i(() => [
-                  o(t(_))
-                ]),
-                _: 1
-              })
-            ]),
-            o(u, {
-              modelValue: t(n).title,
-              "onUpdate:modelValue": e[1] || (e[1] = (l) => t(n).title = l),
-              disabled: t(r).enableI18n
-            }, null, 8, ["modelValue", "disabled"])
-          ])
-        ]),
-        _: 1
-      });
-    };
-  }
-});
-export {
-  Q as default
-};