@ubean/integrations 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soybean
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/electron/index.d.ts

@@ -0,0 +1,37 @@
+import { i as ElectronRendererOptions, n as ElectronOptions, r as ElectronPreloadOptions, t as ElectronMainOptions } from "../types-BsgAJnWk.js";
+import { Plugin } from "vite";
+//#region src/electron/constants.d.ts
+/** main 进程入口默认值 */
+declare const DEFAULT_MAIN_ENTRY = "electron/main.ts";
+/** preload 脚本入口默认值 */
+declare const DEFAULT_PRELOAD_INPUT = "electron/preload.ts";
+//#endregion
+//#region src/electron/index.d.ts
+/**
+ * ubean Electron Vite 插件（基于 vite-plugin-electron）
+ *
+ * main/preload 有默认值，最简配置只需 `electron: true`。
+ *
+ * @example
+ * ```ts
+ * // ubean.config.ts — 最简启用
+ * export default defineConfig({ electron: true });
+ *
+ * // ubean.config.ts — 自定义入口
+ * export default defineConfig({
+ *   electron: {
+ *     main: { entry: 'electron/main.ts' },
+ *     preload: { input: 'electron/preload.ts' }
+ *   }
+ * });
+ * ```
+ *
+ * 通常由 ubean module 系统自动加载，无需在 vite.config.ts 中手动调用。
+ */
+declare function ubeanElectronPlugin(options?: ElectronOptions): Promise<Plugin[]>;
+/**
+ * 类型安全的 Electron 配置定义辅助函数（透传）
+ */
+declare function defineElectronConfig(options: ElectronOptions): ElectronOptions;
+//#endregion
+export { DEFAULT_MAIN_ENTRY, DEFAULT_PRELOAD_INPUT, type ElectronMainOptions, type ElectronOptions, type ElectronPreloadOptions, type ElectronRendererOptions, ubeanElectronPlugin as default, ubeanElectronPlugin, defineElectronConfig };

package/dist/electron/index.js

@@ -0,0 +1,61 @@
+import electron from "vite-plugin-electron/simple";
+//#region src/electron/constants.ts
+/** main 进程入口默认值 */
+const DEFAULT_MAIN_ENTRY = "electron/main.ts";
+/** preload 脚本入口默认值 */
+const DEFAULT_PRELOAD_INPUT = "electron/preload.ts";
+//#endregion
+//#region src/electron/index.ts
+/**
+* ubean Electron Vite 插件（基于 vite-plugin-electron）
+*
+* main/preload 有默认值，最简配置只需 `electron: true`。
+*
+* @example
+* ```ts
+* // ubean.config.ts — 最简启用
+* export default defineConfig({ electron: true });
+*
+* // ubean.config.ts — 自定义入口
+* export default defineConfig({
+*   electron: {
+*     main: { entry: 'electron/main.ts' },
+*     preload: { input: 'electron/preload.ts' }
+*   }
+* });
+* ```
+*
+* 通常由 ubean module 系统自动加载，无需在 vite.config.ts 中手动调用。
+*/
+async function ubeanElectronPlugin(options = {}) {
+	if (options.enabled === false) return [{
+		name: "ubean:electron:noop",
+		enforce: "post"
+	}];
+	const mainEntry = options.main?.entry ?? "electron/main.ts";
+	const preloadInput = options.preload?.input ?? "electron/preload.ts";
+	const electronConfig = {
+		main: {
+			entry: mainEntry,
+			...options.main?.vite
+		},
+		preload: {
+			input: preloadInput,
+			...options.preload?.vite
+		}
+	};
+	if (options.renderer) electronConfig.renderer = options.renderer;
+	const plugins = await electron(electronConfig);
+	return (Array.isArray(plugins) ? plugins : [plugins]).map((p) => ({
+		...p,
+		name: p.name?.startsWith("ubean:") ? p.name : `ubean:electron(${p.name ?? "unknown"})`
+	}));
+}
+/**
+* 类型安全的 Electron 配置定义辅助函数（透传）
+*/
+function defineElectronConfig(options) {
+	return options;
+}
+//#endregion
+export { DEFAULT_MAIN_ENTRY, DEFAULT_PRELOAD_INPUT, ubeanElectronPlugin as default, ubeanElectronPlugin, defineElectronConfig };

package/dist/fonts/index.d.ts

@@ -0,0 +1,43 @@
+import { a as FontModuleOptions, c as FontStyle, d as GoogleFontsOptions, f as LocalFontOptions, i as FontMetric, l as FontSubset, n as FontFaceDeclaration, o as FontProvider, p as ResolvedFontFace, r as FontFamilyOptions, t as FontDisplay, u as FontWeight } from "../types-CpVZH81i.js";
+import { Plugin } from "vite";
+//#region src/fonts/index.d.ts
+interface UbeanFontsOptions {
+  families?: Array<{
+    name: string;
+    provider?: 'google' | 'bunny' | 'local' | 'custom';
+    weights?: number[];
+    styles?: Array<'normal' | 'italic'>;
+    subsets?: string[];
+    display?: 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+    preload?: boolean;
+    cssVariable?: string | boolean;
+  }>;
+  google?: {
+    families?: Record<string, {
+      weights?: number[];
+      styles?: string[];
+      subsets?: string[];
+    }>;
+    display?: string;
+    preconnect?: boolean;
+    download?: boolean;
+  };
+  local?: Record<string, {
+    src: string | string[];
+    weight?: number;
+    style?: string;
+    preload?: boolean;
+  }>;
+  defaults?: {
+    weights?: number[];
+    styles?: string[];
+    subsets?: string[];
+    display?: string;
+    preload?: boolean;
+  };
+  inject?: boolean;
+  devtools?: boolean;
+}
+declare function ubeanFontsPlugin(userOptions?: UbeanFontsOptions): Plugin;
+//#endregion
+export { type FontDisplay, type FontFaceDeclaration, type FontFamilyOptions, type FontMetric, type FontModuleOptions, type FontProvider, type FontStyle, type FontSubset, type FontWeight, type GoogleFontsOptions, type LocalFontOptions, type ResolvedFontFace, UbeanFontsOptions, ubeanFontsPlugin as default, ubeanFontsPlugin };

package/dist/fonts/index.js

@@ -0,0 +1,103 @@
+import { a as generateFontCSS, o as generateFontLinks, t as configureFontsRuntime } from "../runtime-C_0lCtWE.js";
+import { defu } from "defu";
+//#region src/fonts/index.ts
+const defaultOptions = {
+	families: [],
+	google: {
+		preconnect: true,
+		download: false
+	},
+	defaults: {
+		weights: [400],
+		styles: ["normal"],
+		subsets: ["latin"],
+		display: "swap",
+		preload: true
+	},
+	inject: true,
+	devtools: true
+};
+const VIRTUAL_FONTS = "virtual:ubean-fonts";
+const RESOLVED_VIRTUAL_FONTS = `\0${VIRTUAL_FONTS}`;
+function ubeanFontsPlugin(userOptions = {}) {
+	const options = defu(userOptions, defaultOptions);
+	return {
+		name: "ubean:fonts",
+		enforce: "pre",
+		configResolved() {
+			configureFontsRuntime({
+				families: options.families,
+				google: options.google,
+				local: options.local,
+				defaults: options.defaults
+			});
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_FONTS) return RESOLVED_VIRTUAL_FONTS;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_VIRTUAL_FONTS) {
+				const { preconnect, styles, preload } = generateFontLinks();
+				const cssVariables = generateFontCSS();
+				return `
+export const preconnectLinks = ${JSON.stringify(preconnect)};
+export const stylesheetLinks = ${JSON.stringify(styles)};
+export const preloadLinks = ${JSON.stringify(preload)};
+export const fontCSS = ${JSON.stringify(cssVariables)};
+
+export function useFonts() {
+  return {
+    preconnect: preconnectLinks,
+    styles: stylesheetLinks,
+    preload: preloadLinks,
+    css: fontCSS,
+    all: [...preconnectLinks, ...preloadLinks, ...stylesheetLinks].join('\\n')
+  };
+}
+
+export default useFonts;
+`;
+			}
+			return null;
+		},
+		transformIndexHtml(html) {
+			if (!options.inject) return html;
+			const { preconnect, styles, preload } = generateFontLinks();
+			return {
+				html,
+				tags: [
+					...preconnect.map((href) => ({
+						tag: "link",
+						attrs: {
+							rel: "preconnect",
+							href: href.match(/href="([^"]+)"/)?.[1],
+							crossorigin: true
+						}
+					})),
+					...preload.map((href) => ({
+						tag: "link",
+						attrs: {
+							rel: "preload",
+							as: "font",
+							type: "font/woff2",
+							href: href.match(/href="([^"]+)"/)?.[1],
+							crossorigin: true
+						}
+					})),
+					...styles.map((href) => {
+						return {
+							tag: "link",
+							attrs: {
+								rel: "stylesheet",
+								href: href.match(/href="([^"]+)"/)?.[1]
+							}
+						};
+					})
+				]
+			};
+		}
+	};
+}
+//#endregion
+export { ubeanFontsPlugin as default, ubeanFontsPlugin };

package/dist/index.d.ts

@@ -0,0 +1,301 @@
+import { i as ElectronRendererOptions, n as ElectronOptions, r as ElectronPreloadOptions, t as ElectronMainOptions } from "./types-BsgAJnWk.js";
+import { a as FontModuleOptions, c as FontStyle, d as GoogleFontsOptions, f as LocalFontOptions, i as FontMetric, l as FontSubset, n as FontFaceDeclaration, o as FontProvider, p as ResolvedFontFace, r as FontFamilyOptions, s as FontProviderOptions, t as FontDisplay, u as FontWeight } from "./types-CpVZH81i.js";
+import { a as ManifestScreenshot, c as RuntimeCachingRule, i as ManifestOrientation, l as UsePwaOptions, n as DisplayMode, o as PwaOptions, r as ManifestIcon, s as PwaState, t as CachingStrategy, u as WebAppManifest } from "./types-D94CeRo-.js";
+import { n as UbeanPiniaOptions, t as PiniaSerializedState } from "./types-Qd7x9Fbj.js";
+import { t as UiOptions } from "./types-BXiJV3cm.js";
+import { App } from "vue";
+//#region src/pwa/runtime.d.ts
+declare function registerSW(swUrl?: string, options?: UsePwaOptions): Promise<ServiceWorkerRegistration | null>;
+declare function updateSW(): void;
+declare function getSWRegistration(): ServiceWorkerRegistration | null;
+declare function usePwa(options?: UsePwaOptions & {
+  swUrl?: string;
+}): {
+  state: import("vue").ComputedRef<PwaState>;
+  isInstalled: import("vue").Ref<boolean, boolean>;
+  isUpdateAvailable: import("vue").Ref<boolean, boolean>;
+  isOfflineReady: import("vue").Ref<boolean, boolean>;
+  needRefresh: import("vue").Ref<boolean, boolean>;
+  registration: import("vue").Ref<{
+    readonly active: {
+      onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
+      readonly scriptURL: string;
+      readonly state: ServiceWorkerState;
+      postMessage: {
+        (message: any, transfer: Transferable[]): void;
+        (message: any, options?: StructuredSerializeOptions): void;
+      };
+      addEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+      };
+      removeEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+      };
+      dispatchEvent: (event: Event) => boolean;
+      onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+    } | null;
+    readonly cookies: {
+      getSubscriptions: () => Promise<CookieStoreGetOptions[]>;
+      subscribe: {
+        (subscriptions: CookieStoreGetOptions[]): Promise<void>;
+        (subscriptions: Iterable<CookieStoreGetOptions>): Promise<void>;
+      };
+      unsubscribe: {
+        (subscriptions: CookieStoreGetOptions[]): Promise<void>;
+        (subscriptions: Iterable<CookieStoreGetOptions>): Promise<void>;
+      };
+    };
+    readonly installing: {
+      onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
+      readonly scriptURL: string;
+      readonly state: ServiceWorkerState;
+      postMessage: {
+        (message: any, transfer: Transferable[]): void;
+        (message: any, options?: StructuredSerializeOptions): void;
+      };
+      addEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+      };
+      removeEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+      };
+      dispatchEvent: (event: Event) => boolean;
+      onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+    } | null;
+    readonly navigationPreload: {
+      disable: () => Promise<void>;
+      enable: () => Promise<void>;
+      getState: () => Promise<NavigationPreloadState>;
+      setHeaderValue: (value: string) => Promise<void>;
+    };
+    onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
+    readonly scope: string;
+    readonly updateViaCache: ServiceWorkerUpdateViaCache;
+    readonly waiting: {
+      onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
+      readonly scriptURL: string;
+      readonly state: ServiceWorkerState;
+      postMessage: {
+        (message: any, transfer: Transferable[]): void;
+        (message: any, options?: StructuredSerializeOptions): void;
+      };
+      addEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+      };
+      removeEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+      };
+      dispatchEvent: (event: Event) => boolean;
+      onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+    } | null;
+    getNotifications: (filter?: GetNotificationOptions) => Promise<Notification[]>;
+    showNotification: (title: string, options?: NotificationOptions) => Promise<void>;
+    unregister: () => Promise<boolean>;
+    update: () => Promise<ServiceWorkerRegistration>;
+    addEventListener: {
+      <K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+      (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    };
+    removeEventListener: {
+      <K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+      (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    };
+    dispatchEvent: (event: Event) => boolean;
+    readonly pushManager: {
+      getSubscription: () => Promise<PushSubscription | null>;
+      permissionState: (options?: PushSubscriptionOptionsInit) => Promise<PermissionState>;
+      subscribe: (options?: PushSubscriptionOptionsInit) => Promise<PushSubscription>;
+    };
+  } | null, ServiceWorkerRegistration | {
+    readonly active: {
+      onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
+      readonly scriptURL: string;
+      readonly state: ServiceWorkerState;
+      postMessage: {
+        (message: any, transfer: Transferable[]): void;
+        (message: any, options?: StructuredSerializeOptions): void;
+      };
+      addEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+      };
+      removeEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+      };
+      dispatchEvent: (event: Event) => boolean;
+      onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+    } | null;
+    readonly cookies: {
+      getSubscriptions: () => Promise<CookieStoreGetOptions[]>;
+      subscribe: {
+        (subscriptions: CookieStoreGetOptions[]): Promise<void>;
+        (subscriptions: Iterable<CookieStoreGetOptions>): Promise<void>;
+      };
+      unsubscribe: {
+        (subscriptions: CookieStoreGetOptions[]): Promise<void>;
+        (subscriptions: Iterable<CookieStoreGetOptions>): Promise<void>;
+      };
+    };
+    readonly installing: {
+      onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
+      readonly scriptURL: string;
+      readonly state: ServiceWorkerState;
+      postMessage: {
+        (message: any, transfer: Transferable[]): void;
+        (message: any, options?: StructuredSerializeOptions): void;
+      };
+      addEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+      };
+      removeEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+      };
+      dispatchEvent: (event: Event) => boolean;
+      onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+    } | null;
+    readonly navigationPreload: {
+      disable: () => Promise<void>;
+      enable: () => Promise<void>;
+      getState: () => Promise<NavigationPreloadState>;
+      setHeaderValue: (value: string) => Promise<void>;
+    };
+    onupdatefound: ((this: ServiceWorkerRegistration, ev: Event) => any) | null;
+    readonly scope: string;
+    readonly updateViaCache: ServiceWorkerUpdateViaCache;
+    readonly waiting: {
+      onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
+      readonly scriptURL: string;
+      readonly state: ServiceWorkerState;
+      postMessage: {
+        (message: any, transfer: Transferable[]): void;
+        (message: any, options?: StructuredSerializeOptions): void;
+      };
+      addEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+      };
+      removeEventListener: {
+        <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+        (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+      };
+      dispatchEvent: (event: Event) => boolean;
+      onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+    } | null;
+    getNotifications: (filter?: GetNotificationOptions) => Promise<Notification[]>;
+    showNotification: (title: string, options?: NotificationOptions) => Promise<void>;
+    unregister: () => Promise<boolean>;
+    update: () => Promise<ServiceWorkerRegistration>;
+    addEventListener: {
+      <K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+      (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    };
+    removeEventListener: {
+      <K extends keyof ServiceWorkerRegistrationEventMap>(type: K, listener: (this: ServiceWorkerRegistration, ev: ServiceWorkerRegistrationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+      (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    };
+    dispatchEvent: (event: Event) => boolean;
+    readonly pushManager: {
+      getSubscription: () => Promise<PushSubscription | null>;
+      permissionState: (options?: PushSubscriptionOptionsInit) => Promise<PermissionState>;
+      subscribe: (options?: PushSubscriptionOptionsInit) => Promise<PushSubscription>;
+    };
+  } | null>;
+  register: () => Promise<void>;
+  updateServiceWorker: () => void;
+  skipWaiting: () => void;
+  closePrompt: () => void;
+};
+//#endregion
+//#region src/pinia/runtime.d.ts
+/**
+ * SSR 序列化:从 Vue app 实例提取 Pinia 的 root state。
+ *
+ * 在服务端 `renderToString(app)` 完成后由 ubean SSR 渲染器调用。
+ * 返回的 `{ pinia }` 会被序列化到 HTML 的 `__UBEAN_STATE__` script 标签中。
+ *
+ * 若 app 上未检测到 `$pinia`(未安装 pinia 插件),返回空对象,
+ * 不会抛出错误(允许在部分页面不使用 pinia)。
+ *
+ * @param app Vue app 实例(SSR 渲染用的 app)
+ * @returns 序列化后的状态对象,包含 `pinia.state.value`
+ */
+declare function serializePiniaState(app: App): PiniaSerializedState;
+/**
+ * 客户端水合:将 SSR 序列化的 state 注入到 Pinia 实例。
+ *
+ * 在 `applyAppConfig`(注册 `createPinia()` 插件)之后、`app.mount()` 之前调用。
+ * 必须在 mount 前执行,否则 store 已用默认 state 初始化,水合无效。
+ *
+ * 若 `state` 为 `null` 或不含 `pinia` 字段,直接返回(no-op),
+ * 允许在 CSR 模式或无 SSR state 时安全调用。
+ *
+ * @param app Vue app 实例(客户端 app,已 install pinia 插件)
+ * @param state 从 `__UBEAN_STATE__` 反序列化的状态对象,或 null
+ */
+declare function hydratePiniaState(app: App, state: Record<string, unknown> | null): void;
+//#endregion
+//#region src/fonts/core.d.ts
+declare const defaultFontWeights: number[];
+declare const defaultFontStyles: FontStyle[];
+declare const defaultFontSubsets: FontSubset[];
+declare const defaultFontDisplay: FontDisplay;
+declare const fallbackFonts: Record<string, string[]>;
+declare function normalizeFontName(name: string): string;
+declare function weightsToString(weights: (FontWeight | number)[]): string;
+declare function getGoogleFontsUrl(options: {
+  family: string;
+  weights?: (FontWeight | number)[];
+  styles?: FontStyle[];
+  subsets?: FontSubset[];
+  display?: FontDisplay;
+  text?: string;
+}): string;
+declare function getBunnyFontsUrl(options: {
+  family: string;
+  weights?: (FontWeight | number)[];
+  styles?: FontStyle[];
+  subsets?: FontSubset[];
+  display?: FontDisplay;
+}): string;
+declare function getFontshareUrl(family: string, _format?: 'css' | 'json'): string;
+declare function generateFontFace(face: ResolvedFontFace): string;
+declare function generateFontFallbackCSS(familyName: string, metric: FontMetric, fallbackName: string, isItalic?: boolean): string;
+declare function generatePreloadLink(url: string, type?: string, crossorigin?: boolean): string;
+declare function generatePreconnectLink(href: string, crossorigin?: boolean): string;
+declare function generateFontCSSVariable(name: string, family: string): string;
+declare function parseFontFamilyCSS(css: string): ResolvedFontFace[];
+declare function extractFontUrlsFromCSS(css: string): string[];
+declare function createFontHash(config: FontFamilyOptions): string;
+declare function normalizeFontFamily(family: FontFamilyOptions, defaults: {
+  weights: number[];
+  styles: FontStyle[];
+  subsets: FontSubset[];
+  display: FontDisplay;
+}): Required<FontFamilyOptions>;
+declare const googleFontMetrics: Record<string, FontMetric>;
+//#endregion
+//#region src/fonts/runtime.d.ts
+declare function configureFontsRuntime(options?: Partial<FontModuleOptions>): FontModuleOptions;
+declare function getFontsConfig(): FontModuleOptions;
+declare function defineFontFamily(options: FontFamilyOptions): FontFamilyOptions;
+declare function defineLocalFont(options: LocalFontOptions): LocalFontOptions;
+declare function defineGoogleFont(options: GoogleFontsOptions): GoogleFontsOptions;
+declare function generateFontLinks(): {
+  preconnect: string[];
+  styles: string[];
+  preload: string[];
+};
+declare function generateFontCSS(): string;
+declare function getFontFamilies(): Required<FontFamilyOptions>[];
+declare function getFontHash(family: FontFamilyOptions): string;
+//#endregion
+export { CachingStrategy, DisplayMode, ElectronMainOptions, ElectronOptions, ElectronPreloadOptions, ElectronRendererOptions, FontDisplay, FontFaceDeclaration, FontFamilyOptions, FontMetric, FontModuleOptions, FontProvider, FontProviderOptions, FontStyle, FontSubset, FontWeight, GoogleFontsOptions, LocalFontOptions, ManifestIcon, ManifestOrientation, ManifestScreenshot, PiniaSerializedState, PwaOptions, PwaState, ResolvedFontFace, RuntimeCachingRule, UbeanPiniaOptions, UiOptions, UsePwaOptions, WebAppManifest, configureFontsRuntime, createFontHash, defaultFontDisplay, defaultFontStyles, defaultFontSubsets, defaultFontWeights, defineFontFamily, defineGoogleFont, defineLocalFont, extractFontUrlsFromCSS, fallbackFonts, generateFontCSS, generateFontCSSVariable, generateFontFace, generateFontFallbackCSS, generateFontLinks, generatePreconnectLink, generatePreloadLink, getBunnyFontsUrl, getFontFamilies, getFontHash, getFontsConfig, getFontshareUrl, getGoogleFontsUrl, getSWRegistration, googleFontMetrics, hydratePiniaState, normalizeFontFamily, normalizeFontName, parseFontFamilyCSS, registerSW, serializePiniaState, updateSW, usePwa, weightsToString };