@pubinfo-nightly/core 2025.11.14

package/src/features/components/index.ts

@@ -0,0 +1,11 @@
+export { default as PageHeader } from './PageHeader/index.vue';
+export { default as PageMain } from './PageMain/index.vue';
+export { default as PartyLoginModal } from './PartyLogin/Modal.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'; ;

package/src/features/composables/auth.ts

@@ -0,0 +1,53 @@
+import { useSettingsStore, useUserStore } from '@/features/stores';
+
+/**
+ * 处理身份验证和权限检查的自定义钩子。
+ * @returns 包含 auth 和 authAll 函数的对象。
+ */
+export function useAuth() {
+  /**
+   * 判断用户是否具有指定权限
+   * @param permission 权限字符串
+   * @returns 如果用户具有指定权限，则返回true；否则返回false
+   */
+  function hasPermission(permission: string) {
+    const settingsStore = useSettingsStore();
+    const userStore = useUserStore();
+    if (settingsStore.settings.app.enablePermission) {
+      return userStore.user.permissions.includes(permission);
+    }
+    else {
+      return true;
+    }
+  }
+
+  /**
+   * 检查用户是否具有所需的权限。
+   * @param value - 要检查的权限，可以是单个权限或权限数组。
+   * @returns 一个布尔值，指示用户是否具有所需的权限。
+   */
+  function auth(value: string | string[]) {
+    let auth;
+    if (typeof value === 'string') {
+      auth = value !== '' ? hasPermission(value) : true;
+    }
+    else {
+      auth = value.length > 0 ? value.some(item => hasPermission(item)) : true;
+    }
+    return auth;
+  }
+
+  /**
+   * 检查用户是否具有所有指定的权限。
+   * @param value - 权限字符串的数组。
+   * @returns 如果用户具有所有指定的权限，则返回true；否则返回false。
+   */
+  function authAll(value: string[]) {
+    return value.length > 0 ? value.every(item => hasPermission(item)) : true;
+  }
+
+  return {
+    auth,
+    authAll,
+  };
+}

package/src/features/composables/index.ts

@@ -0,0 +1,5 @@
+export * from './auth';
+export * from './log';
+export * from './partyLogin';
+export * from './theme';
+export * from './watchDiff';

package/src/features/composables/log.ts

@@ -0,0 +1,42 @@
+import { logger } from '@pubinfo-nightly/shared';
+
+enum LOG_TYPE {
+  ERROR = 'error',
+  SUCCESS = 'success',
+  WARN = 'warn',
+  INFO = 'info',
+  START = 'start',
+  BOX = 'box',
+}
+enum EMOJI {
+  ERROR = '🔴',
+  SUCCESS = '🟢',
+  WARN = '🟡',
+  INFO = '🔵',
+  START = '🟩',
+  BOX = '🟧',
+}
+
+function createLog(type: LOG_TYPE, emoji: EMOJI) {
+  return (message: string | Error) => {
+    if (!import.meta.env.DEV) {
+      return;
+    }
+
+    if (typeof message === 'string') {
+      const msg = message.length > 0 ? `${emoji} ${message}` : '';
+      logger[type](msg);
+    }
+    else {
+      const msg = message instanceof Error ? message : new Error(message);
+      logger[type](msg);
+    }
+  };
+}
+
+export const useError = createLog(LOG_TYPE.ERROR, EMOJI.ERROR);
+export const useSuccess = createLog(LOG_TYPE.SUCCESS, EMOJI.SUCCESS);
+export const useWarn = createLog(LOG_TYPE.WARN, EMOJI.WARN);
+export const useInfo = createLog(LOG_TYPE.INFO, EMOJI.INFO);
+export const useStart = createLog(LOG_TYPE.START, EMOJI.START);
+export const useBox = createLog(LOG_TYPE.BOX, EMOJI.BOX);

package/src/features/composables/partyLogin.ts

@@ -0,0 +1,565 @@
+import type { Pinia } from 'pinia';
+import type { PartyLoginConfig, PartyLoginParamItem } from '../components/PartyLogin/type';
+import { getActivePinia } from 'pinia';
+import { ref } from 'vue';
+
+export {
+  PartyLoginConfig,
+};
+
+const SUPPORTED_STORE_IDS = new Set([
+  'user',
+  'settings',
+  'menu',
+  'route',
+  'tabbar',
+  'iframe',
+  'keepAlive',
+  'favorites',
+]);
+
+const missingPiniaWarnings = new Set<string>();
+
+function warnMissingPinia(storeName: string) {
+  if (missingPiniaWarnings.has(storeName)) {
+    return;
+  }
+  missingPiniaWarnings.add(storeName);
+  console.warn(
+    `[usePartyLogin] Pinia instance is not ready when trying to access the "${storeName}" store. `
+    + 'Provide a Pinia instance via usePartyLogin(..., { pinia }) or ensure Pinia is registered before calling this hook.',
+  );
+}
+
+/**
+ * 根据路径获取对象的嵌套值
+ * @param obj 目标对象
+ * @param path 路径字符串，用 . 分隔，如 'user.token'
+ */
+function getNestedValue(obj: any, path: string): any {
+  if (!obj || !path) {
+    return '';
+  }
+
+  const keys = path.split('.');
+  let result = obj;
+
+  for (const key of keys) {
+    if (result && typeof result === 'object' && key in result) {
+      result = result[key];
+    }
+    else {
+      return '';
+    }
+  }
+
+  return result ?? '';
+}
+
+function getStoreFromPinia(pinia: Pinia | undefined, storeName: string) {
+  const storeMap = (pinia as any)?._s as Map<string, any> | undefined;
+  return storeMap?.get(storeName);
+}
+
+/**
+ * 解析参数值
+ *
+ * @param item 参数项
+ * @param previousResponse 上一步请求的响应数据（仅用于 request 类型）
+ *
+ * @description
+ * 支持的参数类型：
+ *
+ * 1. **string/number**: 直接使用配置的值
+ *    - 示例: `{ key: "name", type: "string", value: "张三" }`
+ *
+ * 2. **boolean**: 值为 'true' 或 'false' 字符串
+ *    - 示例: `{ key: "enabled", type: "boolean", value: "true" }`
+ *
+ * 3. **system**: 从 Pinia Store 中获取值
+ *    - 格式: `"storeName:path.to.field"`
+ *    - 示例: `{ key: "authorization", type: "system", field: "user:user.token" }`
+ *      → 解析为: `userStore.user.token`
+ *    - 可用的 store 名称: user, settings, menu, route, tabbar, iframe, keepAlive, favorites
+ *
+ * 4. **request**: 从上一步请求响应中获取值
+ *    - 格式: `"path.to.field"`
+ *    - 示例: `{ key: "wd", type: "request", field: "data.name" }`
+ *      → 解析为: `previousResponse.data.name`
+ *
+ * @example
+ * // System 类型 - 从 userStore 获取 token
+ * const item1 = {
+ *   key: "authorization",
+ *   type: "system",
+ *   field: "user:user.token"
+ * };
+ * // 结果: userStore.user.token 的值
+ *
+ * @example
+ * // Request 类型 - 从响应数据获取
+ * const item2 = {
+ *   key: "name",
+ *   type: "request",
+ *   field: "data.result.userName"
+ * };
+ * // 结果: previousResponse.data.result.userName 的值
+ */
+function resolveParamValue(
+  item: PartyLoginParamItem,
+  previousResponse?: Record<string, any>,
+  pinia?: Pinia,
+): string | number | boolean {
+  switch (item.type) {
+    case 'string':
+    case 'number':
+      return item.value ?? '';
+    case 'boolean':
+      return item.value === 'true';
+    case 'system': {
+      // 从 pinia store 中获取系统数据
+      // 格式: "storeName:path.to.field"
+      // 例如: "user:user.token" -> userStore.user.token
+      if (!item.field) {
+        return '';
+      }
+
+      const [storeName, fieldPath] = item.field.split(':');
+      if (!storeName || !fieldPath) {
+        return '';
+      }
+
+      try {
+        if (!SUPPORTED_STORE_IDS.has(storeName)) {
+          console.warn(`Store "${storeName}" is not supported in usePartyLogin.`);
+          return '';
+        }
+
+        const activePinia = pinia ?? getActivePinia();
+        if (!activePinia) {
+          warnMissingPinia(storeName);
+          return '';
+        }
+
+        const store = getStoreFromPinia(activePinia, storeName);
+        if (!store) {
+          warnMissingStore(storeName);
+          return '';
+        }
+
+        return getNestedValue(store, fieldPath);
+      }
+      catch (error) {
+        console.error(`Error accessing store field ${item.field}:`, error);
+        return '';
+      }
+    }
+    case 'request':
+      // 从上一步请求响应中获取值
+      // 格式: "path.to.field"
+      // 例如: "data.name" -> previousResponse.data.name
+      if (!item.field || !previousResponse) {
+        return '';
+      }
+      return getNestedValue(previousResponse, item.field);
+    default:
+      return item.value ?? '';
+  }
+}
+
+/**
+ * 构建请求参数
+ * @param params 参数配置数组
+ * @param previousResponse 上一步请求的响应数据
+ */
+function buildParams(
+  params: PartyLoginParamItem[],
+  previousResponse?: Record<string, any>,
+  pinia?: Pinia,
+): Record<string, any> {
+  const result: Record<string, any> = {};
+
+  params.forEach((item) => {
+    if (item.key) {
+      result[item.key] = resolveParamValue(item, previousResponse, pinia);
+    }
+  });
+
+  return result;
+}
+
+/**
+ * 拼接 OAuth URL
+ * @param baseUrl OAuth 基础 URL
+ * @param params OAuth 参数配置
+ * @param previousResponse 上一步请求的响应数据
+ */
+function buildOAuthUrl(
+  baseUrl: string,
+  params: PartyLoginParamItem[],
+  previousResponse?: Record<string, any>,
+  pinia?: Pinia,
+): string {
+  const queryParams = buildParams(params, previousResponse, pinia);
+  const entries = Object.entries(queryParams);
+
+  if (entries.length === 0) {
+    return safeDecodeUrl(baseUrl);
+  }
+
+  const searchParams = new URLSearchParams();
+  entries.forEach(([key, value]) => {
+    searchParams.append(key, String(value));
+  });
+  const serializedParams = searchParams.toString();
+
+  const hashIndex = baseUrl.indexOf('#');
+  const hasHash = hashIndex >= 0;
+  const basePart = hasHash ? baseUrl.slice(0, hashIndex) : baseUrl;
+  const hashContent = hasHash ? baseUrl.slice(hashIndex + 1) : '';
+
+  if (hasHash && shouldAppendParamsToHash(hashContent)) {
+    const hashWithQuery = appendParamsToHash(hashContent, serializedParams);
+    const finalUrl = `${basePart}#${hashWithQuery}`;
+    return safeDecodeUrl(finalUrl);
+  }
+
+  const baseWithQuery = appendParamsToBaseUrl(basePart, searchParams, serializedParams);
+  const finalUrl = hasHash ? `${baseWithQuery}#${hashContent}` : baseWithQuery;
+
+  // 解码 URL,将编码的中文转换为可读形式
+  return safeDecodeUrl(finalUrl);
+}
+
+function shouldAppendParamsToHash(hashContent: string): boolean {
+  if (!hashContent) {
+    return false;
+  }
+
+  const trimmed = hashContent.trim();
+  if (!trimmed) {
+    return false;
+  }
+
+  return trimmed.startsWith('/')
+    || trimmed.startsWith('!/')
+    || trimmed.startsWith('?');
+}
+
+function appendParamsToHash(hashContent: string, serializedParams: string): string {
+  if (!serializedParams) {
+    return hashContent;
+  }
+
+  if (!hashContent) {
+    return `?${serializedParams}`;
+  }
+
+  const separator = resolveQuerySeparator(hashContent);
+  return `${hashContent}${separator}${serializedParams}`;
+}
+
+function appendParamsToBaseUrl(
+  baseUrl: string,
+  params: URLSearchParams,
+  serializedParams: string,
+): string {
+  if (!serializedParams) {
+    return baseUrl;
+  }
+
+  if (!baseUrl) {
+    return `?${serializedParams}`;
+  }
+
+  try {
+    const url = new URL(baseUrl);
+    params.forEach((value, key) => {
+      url.searchParams.append(key, value);
+    });
+    return url.toString();
+  }
+  catch {
+    const separator = resolveQuerySeparator(baseUrl);
+    return `${baseUrl}${separator}${serializedParams}`;
+  }
+}
+
+function resolveQuerySeparator(baseUrl: string): string {
+  if (!baseUrl) {
+    return '?';
+  }
+
+  if (!baseUrl.includes('?')) {
+    return '?';
+  }
+
+  return /[?&]$/.test(baseUrl) ? '' : '&';
+}
+
+function safeDecodeUrl(value: string): string {
+  try {
+    return decodeURIComponent(value);
+  }
+  catch {
+    return value;
+  }
+}
+
+/**
+ * 构建查询字符串
+ */
+function buildQueryString(queryObj: Record<string, any>): string {
+  const params = new URLSearchParams();
+  Object.entries(queryObj).forEach(([key, value]) => {
+    if (value != null) {
+      params.append(key, String(value));
+    }
+  });
+  return params.toString();
+}
+
+/**
+ * 序列化请求体
+ */
+function serializeBody(
+  bodyObj: Record<string, any>,
+  headers: Record<string, string>,
+): string | FormData | undefined {
+  const contentType = headers['Content-Type'] || headers['content-type'] || 'application/json';
+
+  if (!bodyObj || Object.keys(bodyObj).length === 0) {
+    return undefined;
+  }
+
+  const type = contentType.split(';')[0].trim().toLowerCase();
+
+  if (type === 'application/json') {
+    return JSON.stringify(bodyObj);
+  }
+
+  if (type === 'application/x-www-form-urlencoded') {
+    const params = new URLSearchParams();
+    Object.entries(bodyObj).forEach(([key, value]) => {
+      if (value != null) {
+        params.append(key, String(value));
+      }
+    });
+    return params.toString();
+  }
+
+  if (type === 'multipart/form-data') {
+    const formData = new FormData();
+    Object.entries(bodyObj).forEach(([key, value]) => {
+      if (value != null) {
+        formData.append(key, value as any);
+      }
+    });
+    // 移除 Content-Type，让浏览器自动设置
+    delete headers['Content-Type'];
+    delete headers['content-type'];
+    return formData;
+  }
+
+  return JSON.stringify(bodyObj);
+}
+
+/**
+ * 深度解析 JSON 字符串
+ */
+function deepParseJSON(obj: any): any {
+  if (obj === null || obj === undefined) {
+    return obj;
+  }
+
+  if (typeof obj === 'string') {
+    try {
+      const parsed = JSON.parse(obj);
+      return deepParseJSON(parsed);
+    }
+    catch {
+      return obj;
+    }
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(item => deepParseJSON(item));
+  }
+
+  if (typeof obj === 'object') {
+    const result: Record<string, any> = {};
+    for (const key in obj) {
+      if (Object.prototype.hasOwnProperty.call(obj, key)) {
+        result[key] = deepParseJSON(obj[key]);
+      }
+    }
+    return result;
+  }
+
+  return obj;
+}
+
+export interface UsePartyLoginOptions {
+  execute?: boolean
+  pinia?: Pinia
+}
+
+/**
+ * Party Login Hook
+ * 处理第三方登录的多步骤流程
+ * @param config Party Login 配置
+ * @param targetUrl 目标跳转 URL (来自 meta.link 或 meta.iframe)
+ */
+export async function usePartyLogin(
+  config: PartyLoginConfig,
+  targetUrl: string,
+  options: UsePartyLoginOptions = {},
+) {
+  const {
+    execute: shouldAutoExecute = true,
+    pinia: injectedPinia,
+  } = options;
+
+  const url = ref<string>('');
+  const loading = ref(false);
+  const error = ref<Error | null>(null);
+
+  /**
+   * 执行第一步请求并生成第二步 URL
+   */
+  async function execute() {
+    if (!config || config.length < 2) {
+      throw new Error('PartyLogin config must have at least 2 steps');
+    }
+
+    if (!targetUrl) {
+      throw new Error('Target URL is required for OAuth redirect');
+    }
+
+    const step1 = config.find(step => step.step === 1);
+    const step2 = config.find(step => step.step === 2);
+
+    if (!step1 || !step2) {
+      throw new Error('Step 1 and Step 2 configurations are required');
+    }
+
+    // 第一步必须有 request 配置
+    if (!step1.request) {
+      throw new Error('Step 1 must have request configuration');
+    }
+
+    // 第二步必须有 oauth 配置
+    if (!step2.oauth) {
+      throw new Error('Step 2 must have OAuth configuration');
+    }
+
+    const { url: requestUrl, method, params } = step1.request;
+    const activePinia = injectedPinia ?? getActivePinia();
+
+    // 构建第一步请求的各类参数（此时还没有 previousResponse，所以传 undefined）
+    const queryParams = params.query ? buildParams(params.query, undefined, activePinia) : {};
+    const bodyParams = params.body ? buildParams(params.body, undefined, activePinia) : {};
+    const headerParams = params.header ? buildParams(params.header, undefined, activePinia) : {};
+    const cookieParams = params.cookie ? buildParams(params.cookie, undefined, activePinia) : {};
+
+    // 构建请求头
+    const headers: Record<string, string> = {};
+    Object.entries(headerParams).forEach(([key, value]) => {
+      headers[key] = String(value);
+    });
+
+    // 处理 Cookie
+    const cookiePairs = Object.entries(cookieParams).map(([key, value]) => `${key}=${value}`);
+    if (cookiePairs.length > 0) {
+      headers.Cookie = cookiePairs.join('; ');
+    }
+
+    // 构建完整的 URL（带查询参数）
+    let finalUrl = requestUrl;
+    const queryString = buildQueryString(queryParams);
+    if (queryString) {
+      finalUrl = `${requestUrl}${requestUrl.includes('?') ? '&' : '?'}${queryString}`;
+    }
+
+    // 构建请求体
+    let requestBody: string | FormData | undefined;
+    if (!['GET', 'HEAD'].includes(method)) {
+      // 如果没有设置 Content-Type，默认使用 application/json
+      if (!headers['Content-Type'] && !headers['content-type']) {
+        headers['Content-Type'] = 'application/json';
+      }
+      requestBody = serializeBody(bodyParams, headers);
+    }
+
+    // 发送第一步请求
+    loading.value = true;
+    error.value = null;
+
+    try {
+      const response = await fetch(finalUrl, {
+        method,
+        headers,
+        body: requestBody,
+        credentials: cookiePairs.length > 0 ? 'include' : 'same-origin',
+        mode: 'cors',
+      });
+
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+
+      // 解析响应数据
+      const contentType = response.headers.get('content-type') || '';
+      let responseData: Record<string, any> = {};
+
+      if (contentType.includes('application/json')) {
+        const jsonData = await response.json();
+        responseData = deepParseJSON(jsonData);
+      }
+      else {
+        const text = await response.text();
+        try {
+          const jsonData = JSON.parse(text);
+          responseData = deepParseJSON(jsonData);
+        }
+        catch {
+          // 如果不是 JSON，将文本作为 data 字段
+          responseData = { data: text };
+        }
+      }
+
+      // 拼接第二步的 OAuth URL
+      const oauthUrl = buildOAuthUrl(
+        targetUrl,
+        step2.oauth.params,
+        responseData,
+        activePinia,
+      );
+
+      url.value = oauthUrl;
+      return oauthUrl;
+    }
+    catch (err: any) {
+      error.value = new Error(`第一步请求失败: ${err?.message || String(err)}`);
+      throw error.value;
+    }
+    finally {
+      loading.value = false;
+    }
+  }
+
+  if (shouldAutoExecute) {
+    // 自动执行
+    await execute();
+  }
+
+  return {
+    url,
+    loading,
+    error,
+    execute,
+  };
+}
+function warnMissingStore(storeName: string) {
+  console.warn(`[usePartyLogin] Store "${storeName}" is not registered in Pinia.`);
+}

package/src/features/composables/theme.ts

@@ -0,0 +1,16 @@
+import { useSettingsStore } from '@/features/stores';
+
+export function useTheme() {
+  const settingsStore = useSettingsStore();
+
+  const isDark = computed({
+    get() {
+      return settingsStore.settings.app.colorScheme === 'dark';
+    },
+    set(value) {
+      settingsStore.settings.app.colorScheme = (value ? 'dark' : 'light');
+    },
+  });
+
+  return { isDark };
+}