@ubean/integrations 0.2.0

package/dist/runtime-C_0lCtWE.js

@@ -0,0 +1,349 @@
+import { hash } from "ohash";
+//#region src/fonts/core.ts
+const defaultFontWeights = [400];
+const defaultFontStyles = ["normal"];
+const defaultFontSubsets = ["latin"];
+const defaultFontDisplay = "swap";
+const fallbackFonts = {
+	sans: [
+		"system-ui",
+		"-apple-system",
+		"BlinkMacSystemFont",
+		"\"Segoe UI\"",
+		"Roboto",
+		"\"Helvetica Neue\"",
+		"Arial",
+		"sans-serif"
+	],
+	serif: [
+		"Georgia",
+		"Cambria",
+		"\"Times New Roman\"",
+		"Times",
+		"serif"
+	],
+	mono: [
+		"Menlo",
+		"Monaco",
+		"Consolas",
+		"\"Liberation Mono\"",
+		"\"Courier New\"",
+		"monospace"
+	],
+	cursive: ["cursive"],
+	fantasy: ["fantasy"]
+};
+function normalizeFontName(name) {
+	return name.replace(/\s+/g, "+");
+}
+function weightsToString(weights) {
+	return weights.map((w) => String(w)).sort((a, b) => Number(a) - Number(b)).join(";");
+}
+function getGoogleFontsUrl(options) {
+	const { family, weights = defaultFontWeights, styles = defaultFontStyles, display = defaultFontDisplay } = options;
+	const familyName = normalizeFontName(family);
+	const weightList = weights.map((w) => String(w)).sort((a, b) => Number(a) - Number(b));
+	const italParams = [];
+	for (const style of styles) {
+		const ital = style === "italic" ? "1" : "0";
+		for (const w of weightList) italParams.push(`${ital},${w}`);
+	}
+	const variants = italParams.length > 0 ? italParams.join(";") : weightList.join(";");
+	let url = `https://fonts.googleapis.com/css2?family=${familyName}`;
+	if (variants) url += `:ital,wght@${variants}`;
+	const paramParts = [];
+	if (options.subsets && options.subsets.length > 0) paramParts.push(`subset=${options.subsets.join(",")}`);
+	paramParts.push(`display=${display}`);
+	if (paramParts.length > 0) url += `&${paramParts.join("&")}`;
+	return url;
+}
+function getBunnyFontsUrl(options) {
+	const { family, weights = defaultFontWeights, styles = defaultFontStyles, display = defaultFontDisplay } = options;
+	const familyName = normalizeFontName(family);
+	const weightList = weights.map((w) => String(w)).sort((a, b) => Number(a) - Number(b));
+	const italParams = [];
+	for (const style of styles) {
+		const ital = style === "italic" ? "1" : "0";
+		for (const w of weightList) italParams.push(`${ital},${w}`);
+	}
+	const variants = italParams.length > 0 ? italParams.join(";") : weightList.join(";");
+	let url = `https://fonts.bunny.net/css?family=${familyName.toLowerCase()}`;
+	if (variants) url += `:ital,wght@${variants}`;
+	const params = new URLSearchParams();
+	if (options.subsets && options.subsets.length > 0) params.set("subset", options.subsets.join(","));
+	params.set("display", display);
+	const paramStr = params.toString();
+	if (paramStr) url += `&${paramStr}`;
+	return url;
+}
+function getFontshareUrl(family, _format = "css") {
+	return `https://api.fontshare.com/v2/css?f[]=${family.toLowerCase().replace(/\s+/g, "-")}@400,500,600,700&display=swap`;
+}
+function generateFontFace(face) {
+	const props = [];
+	props.push(`font-family: '${face.fontFamily}'`);
+	props.push(`src: ${face.src}`);
+	if (face.weight) props.push(`font-weight: ${face.weight}`);
+	if (face.style) props.push(`font-style: ${face.style}`);
+	if (face.display) props.push(`font-display: ${face.display}`);
+	if (face.unicodeRange) props.push(`unicode-range: ${face.unicodeRange}`);
+	if (face.fontStretch) props.push(`font-stretch: ${face.fontStretch}`);
+	if (face.ascentOverride) props.push(`ascent-override: ${face.ascentOverride}`);
+	if (face.descentOverride) props.push(`descent-override: ${face.descentOverride}`);
+	if (face.lineGapOverride) props.push(`line-gap-override: ${face.lineGapOverride}`);
+	if (face.sizeAdjust) props.push(`size-adjust: ${face.sizeAdjust}`);
+	return `@font-face {\n  ${props.join(";\n  ")};\n}`;
+}
+function generateFontFallbackCSS(familyName, metric, fallbackName, isItalic = false) {
+	return `@font-face {
+  font-family: '${familyName} fallback';
+  src: local('${fallbackName}');
+  ascent-override: ${`${metric.ascent / metric.unitsPerEm * 100}%`};
+  descent-override: ${`${Math.abs(metric.descent) / metric.unitsPerEm * 100}%`};
+  line-gap-override: ${`${metric.lineGap / metric.unitsPerEm * 100}%`};
+  size-adjust: 100%;
+  font-style: ${isItalic ? "italic" : "normal"};
+}`;
+}
+function generatePreloadLink(url, type = "font", crossorigin = true) {
+	const attrs = [
+		"rel=\"preload\"",
+		`href="${url}"`,
+		"as=\"font\"",
+		`type="${type}"`
+	];
+	if (crossorigin) attrs.push("crossorigin");
+	return `<link ${attrs.join(" ")}>`;
+}
+function generatePreconnectLink(href, crossorigin = true) {
+	const attrs = ["rel=\"preconnect\"", `href="${href}"`];
+	if (crossorigin) attrs.push("crossorigin");
+	return `<link ${attrs.join(" ")}>`;
+}
+function generateFontCSSVariable(name, family) {
+	return `${name.startsWith("--") ? name : `--font-${name.toLowerCase().replace(/\s+/g, "-")}`}: '${family}', ${fallbackFonts.sans.join(", ")};`;
+}
+function parseFontFamilyCSS(css) {
+	const faces = [];
+	const regex = /@font-face\s*\{([^}]+)\}/g;
+	let match;
+	while ((match = regex.exec(css)) !== null) {
+		const body = match[1];
+		const face = {
+			fontFamily: "",
+			src: ""
+		};
+		const familyMatch = body.match(/font-family:\s*['"]?([^'";]+)['"]?/);
+		if (familyMatch) face.fontFamily = familyMatch[1].trim();
+		const srcMatch = body.match(/src:\s*([^;]+)/);
+		if (srcMatch) face.src = srcMatch[1].trim();
+		const weightMatch = body.match(/font-weight:\s*([^;]+)/);
+		if (weightMatch) face.weight = weightMatch[1].trim();
+		const styleMatch = body.match(/font-style:\s*([^;]+)/);
+		if (styleMatch) face.style = styleMatch[1].trim();
+		const displayMatch = body.match(/font-display:\s*([^;]+)/);
+		if (displayMatch) face.display = displayMatch[1].trim();
+		const unicodeMatch = body.match(/unicode-range:\s*([^;]+)/);
+		if (unicodeMatch) face.unicodeRange = unicodeMatch[1].trim();
+		faces.push(face);
+	}
+	return faces;
+}
+function extractFontUrlsFromCSS(css) {
+	const urls = [];
+	const regex = /url\(['"]?([^'")]+\.(?:woff2?|ttf|otf|eot))['"]?\)/g;
+	let match;
+	while ((match = regex.exec(css)) !== null) urls.push(match[1]);
+	return [...new Set(urls)];
+}
+function createFontHash(config) {
+	return hash({
+		name: config.name,
+		weights: config.weights,
+		styles: config.styles,
+		subsets: config.subsets,
+		provider: config.provider
+	}).slice(0, 10);
+}
+function normalizeFontFamily(family, defaults) {
+	return {
+		name: family.name,
+		provider: family.provider || "google",
+		weights: family.weights || defaults.weights,
+		styles: family.styles || defaults.styles,
+		subsets: family.subsets || defaults.subsets,
+		display: family.display || defaults.display,
+		preload: family.preload ?? true,
+		fallback: family.fallback || [],
+		unicodeRange: family.unicodeRange || "",
+		selector: family.selector || "",
+		src: family.src || "",
+		cssVariable: family.cssVariable ?? false
+	};
+}
+const googleFontMetrics = {
+	Inter: {
+		familyName: "Inter",
+		category: "sans-serif",
+		capHeight: 2048,
+		ascent: 2728,
+		descent: -680,
+		lineGap: 0,
+		unitsPerEm: 2816,
+		xHeight: 1536,
+		xWidthAvg: 1352,
+		subsets: { latin: { xWidthAvg: 1352 } }
+	},
+	Roboto: {
+		familyName: "Roboto",
+		category: "sans-serif",
+		capHeight: 1456,
+		ascent: 1900,
+		descent: -500,
+		lineGap: 0,
+		unitsPerEm: 2048,
+		xHeight: 1082,
+		xWidthAvg: 1061,
+		subsets: { latin: { xWidthAvg: 1061 } }
+	}
+};
+//#endregion
+//#region src/fonts/runtime.ts
+let fontsConfig;
+function configureFontsRuntime(options = {}) {
+	fontsConfig = {
+		families: options.families || [],
+		google: options.google || {},
+		local: options.local || {},
+		custom: options.custom || {},
+		defaults: {
+			weights: options.defaults?.weights || defaultFontWeights,
+			styles: options.defaults?.styles || defaultFontStyles,
+			subsets: options.defaults?.subsets || defaultFontSubsets,
+			display: options.defaults?.display || "swap",
+			preload: options.defaults?.preload ?? true,
+			preconnect: options.defaults?.preconnect ?? true,
+			download: options.defaults?.download ?? false,
+			fallback: options.defaults?.fallback || fallbackFonts
+		},
+		assets: {
+			baseURL: options.assets?.baseURL || "/_fonts",
+			prefix: options.assets?.prefix || "_fonts"
+		},
+		metrics: options.metrics ?? true,
+		experimental: { inline: options.experimental?.inline ?? false }
+	};
+	return fontsConfig;
+}
+function getFontsConfig() {
+	if (!fontsConfig) configureFontsRuntime();
+	return fontsConfig;
+}
+function defineFontFamily(options) {
+	if (!fontsConfig) configureFontsRuntime();
+	const normalized = normalizeFontFamily(options, fontsConfig.defaults);
+	fontsConfig.families.push(normalized);
+	return normalized;
+}
+function defineLocalFont(options) {
+	if (!fontsConfig) configureFontsRuntime();
+	fontsConfig.local[options.name] = options;
+	const family = {
+		name: options.name,
+		provider: "local",
+		src: options.src,
+		weights: options.weights?.length ? options.weights : [400],
+		styles: options.styles?.length ? options.styles : ["normal"],
+		preload: options.preload ?? true
+	};
+	fontsConfig.families.push(family);
+	return options;
+}
+function defineGoogleFont(options) {
+	if (!fontsConfig) configureFontsRuntime();
+	fontsConfig.google = {
+		...fontsConfig.google,
+		...options
+	};
+	return options;
+}
+function generateFontLinks() {
+	const config = getFontsConfig();
+	const preconnect = [];
+	const styles = [];
+	const preload = [];
+	if (config.defaults.preconnect && (config.families.some((f) => f.provider === "google") || Object.keys(config.google?.families || {}).length > 0)) {
+		preconnect.push(generatePreconnectLink("https://fonts.googleapis.com"));
+		preconnect.push(generatePreconnectLink("https://fonts.gstatic.com"));
+	}
+	for (const family of config.families) {
+		const normalized = normalizeFontFamily(family, config.defaults);
+		let url = "";
+		switch (normalized.provider) {
+			case "google":
+				url = getGoogleFontsUrl({
+					family: normalized.name,
+					weights: normalized.weights,
+					styles: normalized.styles,
+					subsets: normalized.subsets,
+					display: normalized.display
+				});
+				if (config.defaults.preconnect && !preconnect.some((l) => l.includes("fonts.googleapis"))) {
+					preconnect.push(generatePreconnectLink("https://fonts.googleapis.com"));
+					preconnect.push(generatePreconnectLink("https://fonts.gstatic.com"));
+				}
+				styles.push(`<link rel="stylesheet" href="${url}">`);
+				break;
+			case "bunny":
+				url = getBunnyFontsUrl({
+					family: normalized.name,
+					weights: normalized.weights,
+					styles: normalized.styles,
+					subsets: normalized.subsets,
+					display: normalized.display
+				});
+				if (config.defaults.preconnect) preconnect.push(generatePreconnectLink("https://fonts.bunny.net"));
+				styles.push(`<link rel="stylesheet" href="${url}">`);
+				break;
+			case "local": if (normalized.src) {
+				const srcs = Array.isArray(normalized.src) ? normalized.src : [normalized.src];
+				for (const src of srcs) {
+					const face = {
+						fontFamily: normalized.name,
+						src: `url('${src}') format('woff2')`,
+						weight: normalized.weights[0],
+						style: normalized.styles[0],
+						display: normalized.display
+					};
+					styles.push(`<style>${generateFontFace(face)}</style>`);
+					if (normalized.preload) preload.push(generatePreloadLink(src));
+				}
+			}
+		}
+	}
+	return {
+		preconnect,
+		styles,
+		preload
+	};
+}
+function generateFontCSS() {
+	const config = getFontsConfig();
+	const css = [];
+	const variables = [];
+	for (const family of config.families) if (family.cssVariable) {
+		const varName = typeof family.cssVariable === "string" ? family.cssVariable : family.name;
+		variables.push(generateFontCSSVariable(varName, family.name));
+	}
+	if (variables.length > 0) css.push(`:root { ${variables.join(" ")} }`);
+	return css.join("\n");
+}
+function getFontFamilies() {
+	const config = getFontsConfig();
+	return config.families.map((f) => normalizeFontFamily(f, config.defaults));
+}
+function getFontHash(family) {
+	return createFontHash(family);
+}
+//#endregion
+export { getFontshareUrl as C, normalizeFontName as D, normalizeFontFamily as E, parseFontFamilyCSS as O, getBunnyFontsUrl as S, googleFontMetrics as T, generateFontCSSVariable as _, generateFontCSS as a, generatePreconnectLink as b, getFontHash as c, defaultFontDisplay as d, defaultFontStyles as f, fallbackFonts as g, extractFontUrlsFromCSS as h, defineLocalFont as i, weightsToString as k, getFontsConfig as l, defaultFontWeights as m, defineFontFamily as n, generateFontLinks as o, defaultFontSubsets as p, defineGoogleFont as r, getFontFamilies as s, configureFontsRuntime as t, createFontHash as u, generateFontFace as v, getGoogleFontsUrl as w, generatePreloadLink as x, generateFontFallbackCSS as y };

package/dist/types-BXiJV3cm.d.ts

@@ -0,0 +1,37 @@
+//#region src/ui/types.d.ts
+/**
+ * @ubean/integrations/ui 类型定义
+ *
+ * ubean UI 模块的配置选项。
+ * 底层组件库为 @soybeanjs/ui，本模块负责：
+ * 1. 注入 UiResolver 到 unplugin-vue-components（组件自动导入）
+ * 2. 可选注入 @soybeanjs/ui/styles.css（预构建样式）
+ */
+/**
+ * UI 模块配置选项
+ *
+ * 用户在 ubean.config.ts 中通过 `ui: true | UiOptions` 配置。
+ * `ui: true` 即可启用，默认自动注入 styles.css。
+ *
+ * @example
+ * ```ts
+ * // 最简启用（含 styles.css）
+ * export default defineConfig({ ui: true });
+ *
+ * // 使用 UnoCSS 模式（不注入 styles.css，由用户自行配置 @soybeanjs/unocss-shadcn）
+ * export default defineConfig({ ui: { css: false } });
+ * ```
+ */
+interface UiOptions {
+  /** 是否启用，默认 true */
+  enabled?: boolean;
+  /**
+   * 是否自动注入 `@soybeanjs/ui/styles.css`，默认 true。
+   *
+   * - `true`（默认）：自动注入预构建样式，零配置开箱即用
+   * - `false`：不注入样式，用户需自行配置 UnoCSS + `@soybeanjs/unocss-shadcn` preset
+   */
+  css?: boolean;
+}
+//#endregion
+export { UiOptions as t };

package/dist/types-BsgAJnWk.d.ts

@@ -0,0 +1,40 @@
+import { InlineConfig } from "vite";
+//#region src/electron/types.d.ts
+/** main 进程配置 */
+interface ElectronMainOptions {
+  /** main 进程入口文件路径，默认 'electron/main.ts' */
+  entry?: string;
+  /** 传递给 Vite 的额外配置 */
+  vite?: InlineConfig;
+}
+/** preload 脚本配置 */
+interface ElectronPreloadOptions {
+  /** preload 脚本入口文件路径，默认 'electron/preload.ts' */
+  input?: string;
+  /** 传递给 Vite 的额外配置 */
+  vite?: InlineConfig;
+}
+/** renderer 进程配置（可选，用于在 renderer 中使用 Node.js API） */
+interface ElectronRendererOptions {
+  /** 是否在 renderer 中启用 Node.js API */
+  nodeIntegration?: boolean;
+}
+/**
+ * ubean Electron 配置选项
+ *
+ * 用户在 ubean.config.ts 中通过 `electron: true | ElectronOptions` 配置。
+ * main/preload 有默认值，`electron: true` 即可启用。
+ * 内部由 ubeanElectronPlugin 转换为 vite-plugin-electron/simple 的配置。
+ */
+interface ElectronOptions {
+  /** 是否启用，默认 true */
+  enabled?: boolean;
+  /** main 进程配置（默认 entry: 'electron/main.ts'） */
+  main?: ElectronMainOptions;
+  /** preload 脚本配置（默认 input: 'electron/preload.ts'） */
+  preload?: ElectronPreloadOptions;
+  /** renderer 进程配置（可选） */
+  renderer?: ElectronRendererOptions;
+}
+//#endregion
+export { ElectronRendererOptions as i, ElectronOptions as n, ElectronPreloadOptions as r, ElectronMainOptions as t };

package/dist/types-CpVZH81i.d.ts

@@ -0,0 +1,106 @@
+//#region src/fonts/types.d.ts
+type FontProvider = 'google' | 'local' | 'bunny' | 'fontshare' | 'custom';
+type FontDisplay = 'auto' | 'block' | 'swap' | 'fallback' | 'optional';
+type FontSubset = 'cyrillic' | 'cyrillic-ext' | 'greek' | 'greek-ext' | 'latin' | 'latin-ext' | 'vietnamese' | 'hebrew' | 'arabic' | 'devanagari' | 'thai' | 'chinese-simplified' | 'chinese-traditional' | 'japanese' | 'korean';
+type FontStyle = 'normal' | 'italic' | 'oblique';
+type FontWeight = 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900' | 'normal' | 'bold';
+interface FontFamilyOptions {
+  name: string;
+  provider?: FontProvider;
+  weights?: (FontWeight | number)[];
+  styles?: FontStyle[];
+  subsets?: FontSubset[];
+  display?: FontDisplay;
+  preload?: boolean;
+  fallback?: string[];
+  unicodeRange?: string;
+  selector?: string;
+  src?: string | string[];
+  cssVariable?: string | boolean;
+}
+interface ResolvedFontFace {
+  fontFamily: string;
+  src: string;
+  weight?: string | number;
+  style?: FontStyle;
+  display?: FontDisplay;
+  unicodeRange?: string;
+  fontStretch?: string;
+  fontVariant?: string;
+  fontFeatureSettings?: string;
+  fontVariationSettings?: string;
+  ascentOverride?: string;
+  descentOverride?: string;
+  lineGapOverride?: string;
+  sizeAdjust?: string;
+}
+interface FontMetric {
+  familyName: string;
+  category: string;
+  capHeight: number;
+  ascent: number;
+  descent: number;
+  lineGap: number;
+  unitsPerEm: number;
+  xHeight: number;
+  xWidthAvg: number;
+  subsets: Record<string, {
+    xWidthAvg: number;
+  }>;
+  weights?: Record<string, any>;
+}
+interface FontFaceDeclaration {
+  css: string;
+  url?: string;
+  preload?: boolean;
+}
+interface FontProviderOptions {
+  name: FontProvider | string;
+  prefix?: string;
+  baseUrl?: string;
+}
+interface GoogleFontsOptions {
+  families: Record<string, FontFamilyOptions>;
+  display?: FontDisplay;
+  subsets?: FontSubset[];
+  preload?: boolean;
+  preconnect?: boolean;
+  download?: boolean;
+  baseUrl?: string;
+  inject?: boolean;
+}
+interface LocalFontOptions {
+  name: string;
+  src: string | string[];
+  weights?: (FontWeight | number)[];
+  styles?: FontStyle[];
+  display?: FontDisplay;
+  preload?: boolean;
+  fallback?: string[];
+}
+interface FontModuleOptions {
+  google?: Partial<GoogleFontsOptions>;
+  local?: Record<string, LocalFontOptions>;
+  custom?: Record<string, FontFamilyOptions>;
+  families: FontFamilyOptions[];
+  defaults: {
+    weights: number[];
+    styles: FontStyle[];
+    subsets: FontSubset[];
+    display: FontDisplay;
+    preload: boolean;
+    preconnect: boolean;
+    download: boolean;
+    fallback: Record<string, string[]>;
+  };
+  assets: {
+    baseURL: string;
+    prefix: string;
+  };
+  metrics: boolean;
+  experimental: {
+    inline: boolean;
+  };
+}
+//#endregion
+export { FontModuleOptions as a, FontStyle as c, GoogleFontsOptions as d, LocalFontOptions as f, FontMetric as i, FontSubset as l, FontFaceDeclaration as n, FontProvider as o, ResolvedFontFace as p, FontFamilyOptions as r, FontProviderOptions as s, FontDisplay as t, FontWeight as u };

package/dist/types-D94CeRo-.d.ts

@@ -0,0 +1,130 @@
+//#region src/pwa/types.d.ts
+/**
+ * PWA 类型定义
+ *
+ * 这些类型面向 ubean 用户配置,PWA 底层实现由 vite-plugin-pwa 提供。
+ * ubean PwaOptions 在 ubeanPwaPlugin 内部转换为 vite-plugin-pwa 的 VitePluginPWOptions。
+ */
+type DisplayMode = 'fullscreen' | 'standalone' | 'minimal-ui' | 'browser';
+type ManifestOrientation = 'any' | 'natural' | 'landscape' | 'portrait' | 'portrait-primary' | 'portrait-secondary' | 'landscape-primary' | 'landscape-secondary';
+interface ManifestIcon {
+  src: string;
+  sizes: string;
+  type?: string;
+  purpose?: string;
+}
+interface ManifestScreenshot {
+  src: string;
+  sizes: string;
+  type?: string;
+  form_factor?: 'narrow' | 'wide';
+}
+interface WebAppManifest {
+  name: string;
+  short_name?: string;
+  description?: string;
+  start_url?: string;
+  scope?: string;
+  display?: DisplayMode;
+  orientation?: ManifestOrientation;
+  background_color?: string;
+  theme_color?: string;
+  lang?: string;
+  dir?: 'ltr' | 'rtl' | 'auto';
+  icons?: ManifestIcon[];
+  screenshots?: ManifestScreenshot[];
+  categories?: string[];
+  shortcuts?: Array<{
+    name: string;
+    short_name?: string;
+    description?: string;
+    url: string;
+    icons?: ManifestIcon[];
+  }>;
+}
+type CachingStrategy = 'cache-first' | 'network-first' | 'stale-while-revalidate' | 'network-only' | 'cache-only';
+interface RuntimeCachingRule {
+  urlPattern: string | RegExp | ((ctx: {
+    request: Request;
+  }) => boolean);
+  handler: CachingStrategy;
+  method?: string;
+  options?: {
+    cacheName?: string;
+    expiration?: {
+      maxEntries?: number;
+      maxAgeSeconds?: number;
+    };
+    cacheableResponse?: {
+      statuses?: number[];
+      headers?: Record<string, string>;
+    };
+  };
+}
+/**
+ * ubean PWA 配置选项
+ *
+ * 用户在 ubean.config.ts 中通过 `pwa: true | PwaOptions` 配置。
+ * 内部由 ubeanPwaPlugin 转换为 vite-plugin-pwa 的 VitePluginPWOptions。
+ */
+interface PwaOptions {
+  /** 是否启用 PWA,默认 true */
+  enabled?: boolean;
+  /** Web App Manifest 配置 */
+  manifest?: Partial<WebAppManifest> & {
+    name: string;
+  };
+  /** 注册类型:autoUpdate(自动更新)| prompt(提示用户)| manual(手动),默认 autoUpdate */
+  registerType?: 'autoUpdate' | 'prompt' | 'manual';
+  /** 自动注入 SW 注册脚本:auto | script | inline | null(禁用),默认 auto */
+  injectRegister?: 'auto' | 'script' | 'inline' | null;
+  /** dev 模式选项 */
+  devOptions?: {
+    enabled?: boolean;
+    suppressWarnings?: boolean;
+  };
+  /**
+   * 按资源类型配置默认缓存策略,会转换为 workbox runtimeCaching 规则。
+   * 与 runtimeCaching 合并:默认规则在前,用户自定义规则在后。
+   */
+  strategies?: {
+    assets?: CachingStrategy;
+    pages?: CachingStrategy;
+    images?: CachingStrategy;
+    fonts?: CachingStrategy;
+    crossOrigin?: CachingStrategy;
+  };
+  /** 自定义 workbox runtimeCaching 规则(追加到默认规则之后) */
+  runtimeCaching?: RuntimeCachingRule[];
+  /** workbox.skipWaiting,默认 true */
+  skipWaiting?: boolean;
+  /** workbox.clientsClaim,默认 true */
+  clientsClaim?: boolean;
+  /** workbox.cleanupOutdatedCaches,默认 true */
+  cleanupOutdatedCaches?: boolean;
+  /**
+   * 是否使用 injectManifest 策略(自定义 SW 源文件)。
+   * - false(默认):使用 generateSW,vite-plugin-pwa 自动生成 sw.js
+   * - true:使用 injectManifest,需提供 swSrc 自定义 SW 源
+   */
+  injectManifest?: boolean;
+  /** injectManifest 模式下的自定义 SW 源文件路径 */
+  swSrc?: string;
+}
+interface UsePwaOptions {
+  immediate?: boolean;
+  onNeedRefresh?: () => void;
+  onOfflineReady?: () => void;
+  onRegistered?: (swUrl: string) => void;
+  onRegisterError?: (error: Error) => void;
+  onUpdateFound?: () => void;
+}
+interface PwaState {
+  isInstalled: boolean;
+  isUpdateAvailable: boolean;
+  isOfflineReady: boolean;
+  needRefresh: boolean;
+  registration: ServiceWorkerRegistration | null;
+}
+//#endregion
+export { ManifestScreenshot as a, RuntimeCachingRule as c, ManifestOrientation as i, UsePwaOptions as l, DisplayMode as n, PwaOptions as o, ManifestIcon as r, PwaState as s, CachingStrategy as t, WebAppManifest as u };