@movk/nuxt 1.1.2 → 1.3.0

package/dist/runtime/composables/useDownloadWithProgress.js

@@ -1,42 +1,135 @@
-import { ref, useNuxtApp } from "#imports";
-import { extractFilename, triggerDownload } from "@movk/core";
-import { showToast, extractToastMessage, getAuthHeaders } from "../utils/api-utils.js";
+import { ref, useNuxtApp, useRuntimeConfig } from "#imports";
+import { triggerDownload } from "@movk/core";
+import {
+  buildFetchContext,
+  finalizeTransfer,
+  prepareTransfer,
+  resolveFilename,
+  tryParseJsonResponse
+} from "../domains/api/transfer.js";
 export function useDownloadWithProgress() {
-  const { $api } = useNuxtApp();
+  const publicConfig = useRuntimeConfig().public.movkApi;
+  const nuxtApp = useNuxtApp();
   const progress = ref(0);
-  const downloading = ref(false);
+  const status = ref("idle");
+  const data = ref(null);
   const error = ref(null);
-  let abortController = null;
+  let controller = null;
   const abort = () => {
-    abortController?.abort();
-    abortController = null;
-    downloading.value = false;
+    controller?.abort();
+    controller = null;
+    status.value = "aborted";
     progress.value = 0;
   };
   const download = async (url, options = {}) => {
-    const { filename, headers = {}, toast, endpoint, onSuccess, onError } = options;
-    const apiInstance = endpoint ? $api.use(endpoint) : $api;
-    const config = apiInstance.getConfig();
-    const fullUrl = `${config.baseURL || ""}${url}`;
+    const {
+      method = "GET",
+      body,
+      filename,
+      headers: userHeaders,
+      toast,
+      endpoint,
+      skipBusinessCheck,
+      onSuccess,
+      onError
+    } = options;
+    const urlStr = typeof url === "string" ? url : url.url;
+    const { fullUrl, headers, config } = prepareTransfer(publicConfig, urlStr, {
+      endpoint,
+      headers: userHeaders,
+      toast,
+      skipBusinessCheck
+    });
     progress.value = 0;
-    downloading.value = true;
+    status.value = "pending";
+    data.value = null;
     error.value = null;
-    abortController = new AbortController();
+    controller = new AbortController();
+    const fetchInit = {
+      method,
+      headers,
+      signal: controller.signal
+    };
+    if (method && method !== "GET" && body !== void 0 && body !== null) {
+      const isBodyInit = typeof body === "string" || body instanceof Blob || body instanceof FormData || body instanceof URLSearchParams || body instanceof ArrayBuffer || body instanceof ReadableStream || ArrayBuffer.isView(body);
+      if (isBodyInit) {
+        fetchInit.body = body;
+      } else {
+        fetchInit.body = JSON.stringify(body);
+        if (!("content-type" in headers) && !("Content-Type" in headers)) {
+          fetchInit.headers["Content-Type"] = "application/json";
+        }
+      }
+    }
     try {
-      const authHeaders = getAuthHeaders(config);
-      const response = await fetch(fullUrl, {
-        method: "GET",
-        headers: { ...headers, ...authHeaders },
-        signal: abortController.signal
+      const response = await fetch(fullUrl, fetchInit);
+      const fetchContext = buildFetchContext(fullUrl, { context: { toast, skipBusinessCheck } }, {
+        status: response.status,
+        headers: response.headers
       });
+      const contentType = response.headers.get("content-type") || "";
+      const isJson = contentType.toLowerCase().includes("application/json");
       if (!response.ok) {
-        throw new Error(`\u4E0B\u8F7D\u5931\u8D25: ${response.status} ${response.statusText}`);
+        if (isJson) {
+          const text = await response.text();
+          const raw = tryParseJsonResponse(response.headers, text);
+          const result3 = await finalizeTransfer(nuxtApp, {
+            raw,
+            fallback: { isSuccess: false, data: null, message: `HTTP ${response.status}` },
+            config,
+            publicConfig,
+            requestToast: toast,
+            skipBusinessCheck,
+            fetchContext
+          });
+          status.value = "error";
+          error.value = result3.error;
+          onError?.(result3.error);
+          return result3;
+        }
+        const result2 = await finalizeTransfer(nuxtApp, {
+          raw: null,
+          fallback: { isSuccess: false, data: null, message: `HTTP ${response.status} ${response.statusText}` },
+          config,
+          publicConfig,
+          requestToast: toast,
+          fetchContext
+        });
+        status.value = "error";
+        error.value = result2.error;
+        onError?.(result2.error);
+        return result2;
+      }
+      if (isJson) {
+        const text = await response.text();
+        const raw = tryParseJsonResponse(response.headers, text);
+        const result2 = await finalizeTransfer(nuxtApp, {
+          raw,
+          fallback: { isSuccess: false, data: null, message: "\u54CD\u5E94\u89E3\u6790\u5931\u8D25" },
+          config,
+          publicConfig,
+          requestToast: toast,
+          skipBusinessCheck,
+          fetchContext
+        });
+        if (result2.error) {
+          status.value = "error";
+          error.value = result2.error;
+          onError?.(result2.error);
+        } else {
+          status.value = "success";
+          data.value = result2.data;
+          progress.value = 100;
+        }
+        controller = null;
+        return result2;
       }
       const contentLength = response.headers.get("content-length");
       const total = contentLength ? Number.parseInt(contentLength, 10) : 0;
-      const finalFilename = filename || extractFilename(response.headers, url.split("/").pop() || "download");
+      const finalFilename = resolveFilename(response.headers, urlStr, filename);
       const reader = response.body?.getReader();
       if (!reader) throw new Error("\u65E0\u6CD5\u8BFB\u53D6\u54CD\u5E94\u6D41");
+      if (total <= 0) progress.value = null;
       const chunks = [];
       let received = 0;
       while (true) {
@@ -46,35 +139,43 @@ export function useDownloadWithProgress() {
         received += value.length;
         if (total > 0) progress.value = Math.round(received / total * 100);
       }
-      triggerDownload(new Blob(chunks), finalFilename);
-      downloading.value = false;
-      abortController = null;
+      const blob = new Blob(chunks);
+      triggerDownload(blob, finalFilename);
+      const result = await finalizeTransfer(nuxtApp, {
+        raw: null,
+        fallback: { isSuccess: true, data: blob, message: `\u4E0B\u8F7D\u6210\u529F: ${finalFilename}` },
+        config,
+        publicConfig,
+        requestToast: toast,
+        fetchContext
+      });
+      status.value = "success";
+      data.value = result.data;
       progress.value = 100;
-      if (import.meta.client && toast !== false) {
-        const message = extractToastMessage(toast, "success", `\u4E0B\u8F7D\u6210\u529F: ${finalFilename}`);
-        showToast("success", message, toast, config.toast);
-      }
+      controller = null;
       onSuccess?.(finalFilename);
-      return { success: true, error: null };
+      return result;
     } catch (err) {
-      downloading.value = false;
-      abortController = null;
+      controller = null;
+      const isAborted = err instanceof DOMException && err.name === "AbortError";
+      if (isAborted) {
+        status.value = "aborted";
+        return { data: null, error: null, aborted: true };
+      }
       const downloadError = err instanceof Error ? err : new Error("\u4E0B\u8F7D\u5931\u8D25");
+      status.value = "error";
       error.value = downloadError;
-      const isAborted = downloadError.name === "AbortError";
-      if (import.meta.client && !isAborted && toast !== false) {
-        const message = extractToastMessage(toast, "error", downloadError.message || "\u4E0B\u8F7D\u5931\u8D25");
-        showToast("error", message, toast, config.toast);
-      }
-      if (!isAborted) onError?.(downloadError);
-      return { success: false, error: downloadError };
+      onError?.(downloadError);
+      return { data: null, error: downloadError, aborted: false };
     }
   };
   return {
-    /** 下载进度 (0-100) */
+    /** 下载进度 0-100；后端未返回 content-length 时为 null（不确定） */
     progress,
-    /** 是否正在下载 */
-    downloading,
+    /** 传输状态 */
+    status,
+    /** 业务数据（默认 Blob；JSON 响应时为解包后的业务数据） */
+    data,
     /** 错误信息 */
     error,
     /** 执行下载 */

package/dist/runtime/composables/useLazyApiFetch.d.ts

@@ -0,0 +1,19 @@
+import type { NitroFetchRequest } from 'nitropack/types';
+import type { UseApiFetchOptions, UseApiFetchReturn } from '../types/api';
+/**
+ * 懒加载版 useApiFetch
+ *
+ * 等价于 `useApiFetch(url, { lazy: true, ...options })`
+ * 不阻塞客户端导航，页面立即显示，数据在后台加载
+ *
+ * @typeParam T - 业务数据类型（已由 $api 自动解包）
+ *
+ * @example
+ * ```ts
+ * const { data, status } = useLazyApiFetch<Post[]>('/posts')
+ *
+ * // 需要手动处理 loading 状态
+ * // <div v-if="status === 'pending'">Loading...</div>
+ * ```
+ */
+export declare function useLazyApiFetch<T = unknown, DataT = T>(url: NitroFetchRequest | (() => NitroFetchRequest), options?: UseApiFetchOptions<T, DataT>): UseApiFetchReturn<DataT>;

package/dist/runtime/composables/useLazyApiFetch.js

@@ -0,0 +1,4 @@
+import { useApiFetch } from "./useApiFetch.js";
+export function useLazyApiFetch(url, options = {}) {
+  return useApiFetch(url, { ...options, lazy: true });
+}

package/dist/runtime/composables/useMessageBox.d.ts

@@ -0,0 +1,6 @@
+import type { MessageBoxProps } from '../types/components/message-box';
+import type { OmitByKey } from '@movk/core';
+export declare function useMessageBox(): {
+    alert: (options: OmitByKey<MessageBoxProps, "mode">) => Promise<void>;
+    confirm: (options: OmitByKey<MessageBoxProps, "mode">) => Promise<boolean>;
+};

package/dist/runtime/composables/useMessageBox.js

@@ -0,0 +1,16 @@
+import { useOverlay } from "#imports";
+import { LazyMMessageBox } from "#components";
+export function useMessageBox() {
+  const overlay = useOverlay();
+  function createInstance() {
+    return overlay.create(LazyMMessageBox, { destroyOnClose: true });
+  }
+  async function alert(options) {
+    await createInstance().open({ ...options, mode: "alert" });
+  }
+  async function confirm(options) {
+    const result = await createInstance().open({ ...options, mode: "confirm" });
+    return result ?? false;
+  }
+  return { alert, confirm };
+}

package/dist/runtime/composables/useTheme.d.ts

@@ -1,12 +1,24 @@
 export declare function useTheme(): {
-    neutralColors: readonly ["slate", "gray", "zinc", "neutral", "stone"];
+    color: import("vue").ComputedRef<any>;
+    style: {
+        innerHTML: import("vue").ComputedRef<string>;
+        id: string;
+        tagPriority: number;
+    }[];
+    link: import("vue").ComputedRef<{
+        rel: "stylesheet";
+        href: any;
+        id: string;
+    }[]>;
+    neutralColors: any;
     neutral: import("vue").WritableComputedRef<any, any>;
     primaryColors: string[];
     primary: import("vue").WritableComputedRef<any, any>;
+    blackAsPrimary: import("vue").ComputedRef<boolean>;
     setBlackAsPrimary: (value: boolean) => void;
-    radiuses: number[];
+    radiuses: any;
     radius: import("vue").WritableComputedRef<any, any>;
-    fonts: string[];
+    fonts: any;
     font: import("vue").WritableComputedRef<any, any>;
     icon: import("vue").WritableComputedRef<any, any>;
     icons: {
@@ -14,14 +26,15 @@ export declare function useTheme(): {
         icon: string;
         value: string;
     }[];
-    modes: {
+    modes: import("vue").ComputedRef<{
         label: string;
         icon: any;
-    }[];
+    }[]>;
     mode: import("vue").WritableComputedRef<any, any>;
-    hasCSSChanges: import("vue").ComputedRef<any>;
-    hasAppConfigChanges: import("vue").ComputedRef<boolean>;
+    hasCSSChanges: import("vue").ComputedRef<boolean>;
+    hasConfigChanges: import("vue").ComputedRef<boolean>;
+    configLabel: string;
     exportCSS: () => string;
-    exportAppConfig: () => string;
+    exportConfig: () => string;
     resetTheme: () => void;
 };

package/dist/runtime/composables/useTheme.js

@@ -1,86 +1,80 @@
 import { useAppConfig, useColorMode, useSiteConfig } from "#imports";
-import { omit } from "@movk/core";
+import { themeIcons } from "../domains/theme/theme-icons.js";
+import { omit, kebabCase } from "@movk/core";
+import { useLocalStorage } from "@vueuse/core";
 import colors from "tailwindcss/colors";
 import { computed } from "vue";
-import { themeIcons } from "../utils/theme.js";
+import { getDefaultConfig } from "../utils/theme-defaults.js";
 export function useTheme() {
-  const appConfig = useAppConfig();
+  const { movk, ui } = useAppConfig();
   const colorMode = useColorMode();
-  const site = useSiteConfig();
-  const neutralColors = ["slate", "gray", "zinc", "neutral", "stone"];
+  const name = kebabCase(useSiteConfig().name);
+  const color = computed(() => colorMode.value === "dark" ? colors[ui.colors.neutral][900] : "white");
+  const defaultConfig = getDefaultConfig();
+  const _radius = useLocalStorage(`${name}-ui-radius`, movk?.radius ?? defaultConfig.radius);
+  const _font = useLocalStorage(`${name}-ui-font`, movk?.font ?? defaultConfig.font);
+  const _iconSet = useLocalStorage(`${name}-ui-icons`, movk?.icons ?? defaultConfig.icons);
+  const _blackAsPrimary = useLocalStorage(`${name}-ui-black-as-primary`, defaultConfig.blackAsPrimary);
+  const pickerFonts = movk?.picker?.fonts ?? [];
+  const neutralColors = movk?.picker?.neutralColors ?? [];
   const neutral = computed({
     get() {
-      return appConfig.ui.colors.neutral;
+      return ui.colors.neutral;
     },
     set(option) {
-      appConfig.ui.colors.neutral = option;
-      window.localStorage.setItem(`${site.name}-ui-neutral`, appConfig.ui.colors.neutral);
+      ui.colors.neutral = option;
+      window.localStorage.setItem(`${name}-ui-neutral`, ui.colors.neutral);
     }
   });
   const colorsToOmit = ["inherit", "current", "transparent", "black", "white", ...neutralColors];
-  const primaryColors = Object.keys(omit(colors, [...colorsToOmit]));
+  const primaryColors = Object.keys(omit(colors, colorsToOmit));
   const primary = computed({
     get() {
-      return appConfig.ui.colors.primary;
+      return ui.colors.primary;
     },
     set(option) {
-      appConfig.ui.colors.primary = option;
-      window.localStorage.setItem(`${site.name}-ui-primary`, appConfig.ui.colors.primary);
+      ui.colors.primary = option;
+      window.localStorage.setItem(`${name}-ui-primary`, ui.colors.primary);
       setBlackAsPrimary(false);
     }
   });
-  const radiuses = [0, 0.125, 0.25, 0.375, 0.5];
+  const radiuses = movk?.picker?.radiuses ?? [];
   const radius = computed({
     get() {
-      return appConfig.theme.radius;
+      return _radius.value;
     },
     set(option) {
-      appConfig.theme.radius = option;
-      window.localStorage.setItem(`${site.name}-ui-radius`, String(appConfig.theme.radius));
+      _radius.value = option;
     }
   });
-  const fonts = ["Public Sans", "DM Sans", "Geist", "Inter", "Poppins", "Outfit", "Raleway"];
+  const fonts = pickerFonts.map((f) => f.name);
   const font = computed({
     get() {
-      return appConfig.theme.font;
+      return _font.value;
     },
     set(option) {
-      appConfig.theme.font = option;
-      if (appConfig.theme.font) {
-        window.localStorage.setItem(`${site.name}-ui-font`, appConfig.theme.font);
-      }
+      _font.value = option;
     }
   });
-  const icons = [{
-    label: "Lucide",
-    icon: "i-lucide-feather",
-    value: "lucide"
-  }, {
-    label: "Phosphor",
-    icon: "i-ph-phosphor-logo",
-    value: "phosphor"
-  }, {
-    label: "Tabler",
-    icon: "i-tabler-brand-tabler",
-    value: "tabler"
-  }];
+  const icons = [
+    { label: "Lucide", icon: "i-lucide-feather", value: "lucide" },
+    { label: "Phosphor", icon: "i-ph-phosphor-logo", value: "phosphor" },
+    { label: "Tabler", icon: "i-tabler-brand-tabler", value: "tabler" }
+  ];
   const icon = computed({
     get() {
-      return appConfig.theme.icons;
+      return _iconSet.value;
     },
     set(option) {
-      appConfig.theme.icons = option;
-      appConfig.ui.icons = themeIcons[option];
-      if (appConfig.theme.icons) {
-        window.localStorage.setItem(`${site.name}-ui-icons`, appConfig.theme.icons);
-      }
+      _iconSet.value = option;
+      ui.icons = themeIcons[option];
     }
   });
-  const modes = [
-    { label: "light", icon: appConfig.ui.icons.light },
-    { label: "dark", icon: appConfig.ui.icons.dark },
-    { label: "system", icon: appConfig.ui.icons.system }
-  ];
+  const modes = computed(() => [
+    { label: "light", icon: ui.icons.light },
+    { label: "dark", icon: ui.icons.dark },
+    { label: "system", icon: ui.icons.system }
+  ]);
   const mode = computed({
     get() {
       return colorMode.value;
@@ -89,79 +83,107 @@ export function useTheme() {
       colorMode.preference = option;
     }
   });
+  const blackAsPrimary = computed(() => _blackAsPrimary.value);
   function setBlackAsPrimary(value) {
-    appConfig.theme.blackAsPrimary = value;
-    window.localStorage.setItem(`${site.name}-ui-black-as-primary`, String(value));
+    _blackAsPrimary.value = value;
   }
+  const radiusStyle = computed(() => `:root { --ui-radius: ${_radius.value}rem; }`);
+  const blackAsPrimaryStyle = computed(() => _blackAsPrimary.value ? `:root { --ui-primary: black; } .dark { --ui-primary: white; }` : ":root {}");
+  const fontStyle = computed(() => `:root { --font-sans: '${_font.value}', sans-serif; }`);
+  const link = computed(() => {
+    const fontName = _font.value;
+    const fontConfig = pickerFonts.find((f) => f.name === fontName);
+    const href = fontConfig?.href ?? `https://fonts.googleapis.com/css2?family=${encodeURIComponent(fontName)}:wght@400;500;600;700&display=swap`;
+    return [{
+      rel: "stylesheet",
+      href,
+      id: `font-${fontName.toLowerCase().replace(/\s+/g, "-")}`
+    }];
+  });
+  const style = [
+    { innerHTML: radiusStyle, id: `nuxt-ui-radius`, tagPriority: -2 },
+    { innerHTML: blackAsPrimaryStyle, id: `nuxt-ui-black-as-primary`, tagPriority: -2 },
+    { innerHTML: fontStyle, id: `nuxt-ui-font`, tagPriority: -2 }
+  ];
   const hasCSSChanges = computed(() => {
-    return appConfig.theme.radius !== 0.25 || appConfig.theme.blackAsPrimary || appConfig.theme.font !== "Public Sans" || appConfig.theme.icons !== "lucide";
+    return _radius.value !== (movk?.radius ?? defaultConfig.radius) || _blackAsPrimary.value || _font.value !== (movk?.font ?? defaultConfig.font);
   });
-  const hasAppConfigChanges = computed(() => {
-    return appConfig.ui.colors.primary !== "green" || appConfig.ui.colors.neutral !== "slate";
+  const hasConfigChanges = computed(() => {
+    return ui.colors.primary !== "blue" || ui.colors.neutral !== "slate" || _iconSet.value !== (movk?.icons ?? defaultConfig.icons);
   });
   function exportCSS() {
     const lines = [
       '@import "tailwindcss";',
       '@import "@nuxt/ui";'
     ];
-    if (appConfig.theme.font !== "Public Sans") {
-      lines.push("", "@theme {", `  --font-sans: '${appConfig.theme.font}', sans-serif;`, "}");
+    if (_font.value !== defaultConfig.font) {
+      lines.push("", "@theme {", `  --font-sans: '${_font.value}', sans-serif;`, "}");
     }
     const rootLines = [];
-    if (appConfig.theme.radius !== 0.25) {
-      rootLines.push(`  --ui-radius: ${appConfig.theme.radius}rem;`);
+    if (_radius.value !== defaultConfig.radius) {
+      rootLines.push(`  --ui-radius: ${_radius.value}rem;`);
     }
-    if (appConfig.theme.blackAsPrimary) {
+    if (_blackAsPrimary.value) {
       rootLines.push("  --ui-primary: black;");
     }
     if (rootLines.length) {
       lines.push("", ":root {", ...rootLines, "}");
     }
-    if (appConfig.theme.blackAsPrimary) {
-      lines.push("", ".dark {", "  --ui-primary: white;", "}");
+    const darkLines = [];
+    if (_blackAsPrimary.value) {
+      darkLines.push("  --ui-primary: white;");
+    }
+    if (darkLines.length) {
+      lines.push("", ".dark {", ...darkLines, "}");
     }
     return lines.join("\n");
   }
-  function exportAppConfig() {
+  function exportConfig() {
     const config = {};
-    if (appConfig.ui.colors.primary !== "green" || appConfig.ui.colors.neutral !== "slate") {
-      config.ui = { colors: {} };
-      if (appConfig.ui.colors.primary !== "green") {
-        config.ui.colors.primary = appConfig.ui.colors.primary;
-      }
-      if (appConfig.ui.colors.neutral !== "slate") {
-        config.ui.colors.neutral = appConfig.ui.colors.neutral;
-      }
+    const defaultColors = {
+      primary: "blue",
+      neutral: "slate",
+      secondary: "blue",
+      success: "green",
+      info: "blue",
+      warning: "yellow",
+      error: "red"
+    };
+    const colorEntries = Object.entries(defaultColors).filter(([key, def]) => ui.colors[key] !== def);
+    if (colorEntries.length) {
+      config.ui = { colors: Object.fromEntries(colorEntries.map(([key]) => [key, ui.colors[key]])) };
     }
-    if (appConfig.theme.icons !== "lucide") {
-      const iconSet = appConfig.theme.icons;
-      const icons2 = themeIcons[iconSet];
+    if (_iconSet.value !== defaultConfig.icons) {
+      const iconMapping = themeIcons[_iconSet.value];
       config.ui = config.ui || {};
-      config.ui.icons = icons2;
+      config.ui.icons = iconMapping;
     }
     const configString = JSON.stringify(config, null, 2).replace(/"([^"]+)":/g, "$1:").replace(/"/g, "'");
     return `export default defineAppConfig(${configString})`;
   }
   function resetTheme() {
-    appConfig.ui.colors.primary = "green";
-    window.localStorage.removeItem(`${site.name}-ui-primary`);
-    appConfig.ui.colors.neutral = "slate";
-    window.localStorage.removeItem(`${site.name}-ui-neutral`);
-    appConfig.theme.radius = 0.25;
-    window.localStorage.removeItem(`${site.name}-ui-radius`);
-    appConfig.theme.font = "Public Sans";
-    window.localStorage.removeItem(`${site.name}-ui-font`);
-    appConfig.theme.icons = "lucide";
-    appConfig.ui.icons = themeIcons.lucide;
-    window.localStorage.removeItem(`${site.name}-ui-icons`);
-    appConfig.theme.blackAsPrimary = false;
-    window.localStorage.removeItem(`${site.name}-ui-black-as-primary`);
+    const defaultPrimary = "blue";
+    const defaultNeutral = "slate";
+    const defaultIcon = movk?.icons ?? defaultConfig.icons;
+    ui.colors.primary = defaultPrimary;
+    window.localStorage.removeItem(`${name}-ui-primary`);
+    ui.colors.neutral = defaultNeutral;
+    window.localStorage.removeItem(`${name}-ui-neutral`);
+    _radius.value = movk?.radius ?? defaultConfig.radius;
+    _font.value = movk?.font ?? defaultConfig.font;
+    _iconSet.value = defaultIcon;
+    ui.icons = themeIcons[defaultIcon];
+    _blackAsPrimary.value = movk?.blackAsPrimary ?? defaultConfig.blackAsPrimary;
   }
   return {
+    color,
+    style,
+    link,
     neutralColors,
     neutral,
     primaryColors,
     primary,
+    blackAsPrimary,
     setBlackAsPrimary,
     radiuses,
     radius,
@@ -172,9 +194,10 @@ export function useTheme() {
     modes,
     mode,
     hasCSSChanges,
-    hasAppConfigChanges,
+    hasConfigChanges,
+    configLabel: "app.config.ts",
     exportCSS,
-    exportAppConfig,
+    exportConfig,
     resetTheme
   };
 }