@movk/nuxt 1.1.1 → 1.2.0

package/dist/runtime/plugins/api.factory.js

@@ -1,157 +1,109 @@
-import { getPath, triggerDownload, extractFilename } from "@movk/core";
 import {
   showToast,
   isBusinessSuccess,
   extractMessage,
-  extractToastMessage
+  extractData,
+  createApiError,
+  extractToastMessage,
+  getAuthHeaders
 } from "../utils/api-utils.js";
 import { defineNuxtPlugin, navigateTo, useNuxtApp, useUserSession, useRuntimeConfig } from "#imports";
 import defu from "defu";
-function getUserSession() {
-  try {
-    const nuxtApp = useNuxtApp();
-    return nuxtApp.runWithContext(() => useUserSession());
-  } catch {
-    return null;
-  }
-}
-function getTokenFromSession(tokenPath) {
-  const userSession = getUserSession();
-  if (!userSession?.session?.value) return null;
-  const sessionData = userSession.session.value;
-  return getPath(sessionData, tokenPath) || null;
-}
-function buildAuthHeader(token, config) {
-  const tokenType = config.tokenType === "Custom" ? config.customTokenType || "" : config.tokenType || "Bearer";
-  return tokenType ? `${tokenType} ${token}` : token;
-}
-async function handleUnauthorized(config) {
-  const userSession = getUserSession();
+async function handleUnauthorized(config, nuxtApp) {
   const unauthorizedConfig = config.unauthorized;
-  if (unauthorizedConfig?.clearSession && userSession?.clear) {
-    await userSession.clear();
+  if (!unauthorizedConfig) return;
+  if (unauthorizedConfig.clearSession) {
+    try {
+      const userSession = nuxtApp.vueApp.runWithContext(() => useUserSession());
+      if (userSession?.clear) {
+        await userSession.clear();
+        await userSession.fetch();
+      }
+    } catch {
+    }
   }
-  if (unauthorizedConfig?.redirect) {
+  if (unauthorizedConfig.redirect) {
     const loginPath = unauthorizedConfig.loginPath || "/login";
-    const nuxtApp = useNuxtApp();
     await nuxtApp.runWithContext(() => navigateTo(loginPath));
   }
 }
-function getApiFetchContext(context) {
-  return context.options.context || {};
+function getApiFetchContext(options) {
+  return options.context || {};
 }
-function createBuiltinHooks(resolvedConfig, publicConfig) {
+function createEndpointFetch(resolvedConfig, publicConfig, nuxtApp) {
   const { auth: authConfig, toast: toastConfig, response: responseConfig } = resolvedConfig;
-  return {
-    onRequest(context) {
+  return $fetch.create({
+    baseURL: resolvedConfig.baseURL,
+    headers: resolvedConfig.headers,
+    async onRequest(context) {
       if (authConfig.enabled) {
-        const tokenPath = authConfig.sessionTokenPath || "token";
-        const token = getTokenFromSession(tokenPath);
-        if (token) {
-          const headerName = authConfig.headerName || "Authorization";
-          const headerValue = buildAuthHeader(token, authConfig);
-          context.options.headers = context.options.headers || new Headers();
-          if (context.options.headers instanceof Headers) {
-            context.options.headers.set(headerName, headerValue);
-          } else {
-            context.options.headers[headerName] = headerValue;
-          }
+        const authHeaders = getAuthHeaders({ auth: authConfig });
+        const headers = new Headers(context.options.headers);
+        for (const [key, value] of Object.entries(authHeaders)) {
+          headers.set(key, value);
         }
+        context.options.headers = headers;
       }
       if (publicConfig.debug) {
-        console.log(`[Movk API] Request: ${context.options.method || "GET"} ${resolvedConfig.baseURL}${context.request}`);
-      }
-    },
-    async onRequestError({ error }) {
-      if (publicConfig.debug) {
-        console.error("[Movk API] Request Error:", error);
+        const h = context.options.headers;
+        const headersLog = h instanceof Headers ? Object.fromEntries(h.entries()) : h;
+        console.log("[Movk API] Request:", {
+          method: context.options.method || "GET",
+          url: `${resolvedConfig.baseURL}${context.request}`,
+          headers: headersLog,
+          body: context.options.body ? "(body present)" : void 0
+        });
       }
+      await nuxtApp.callHook("movk:api:request", context);
     },
     async onResponse(context) {
-      const response = context.response;
-      const data = response._data;
+      const raw = context.response._data;
+      const { toast, skipBusinessCheck } = getApiFetchContext(context.options);
       if (publicConfig.debug) {
-        console.log("[Movk API] Response:", data);
+        console.log("[Movk API] Response:", raw);
       }
-      if (!import.meta.client) return;
-      const { toast, skipBusinessCheck } = getApiFetchContext(context);
-      const isSuccess = skipBusinessCheck || isBusinessSuccess(data, responseConfig);
-      const message = extractMessage(data, responseConfig);
-      if (isSuccess) {
-        const successMessage = toast !== false ? toast?.successMessage || message : void 0;
-        showToast("success", successMessage, toast, toastConfig);
+      if (skipBusinessCheck || isBusinessSuccess(raw, responseConfig)) {
+        context.response._data = extractData(raw, responseConfig);
+        await nuxtApp.callHook("movk:api:response", context);
+        if (import.meta.client) {
+          const message = toast !== false ? extractToastMessage(toast, "success", extractMessage(raw, responseConfig) || "") : void 0;
+          showToast("success", message, toast, toastConfig);
+        }
+      } else {
+        await nuxtApp.callHook("movk:api:error", context);
+        if (import.meta.client) {
+          const message = extractMessage(raw, responseConfig);
+          const errorMessage = toast !== false ? extractToastMessage(toast, "error", message || "\u8BF7\u6C42\u5931\u8D25") : void 0;
+          showToast("error", errorMessage, toast, toastConfig);
+        }
+        throw createApiError(raw, extractMessage(raw, responseConfig));
       }
     },
     async onResponseError(context) {
       const { response } = context;
+      const { toast } = getApiFetchContext(context.options);
       if (response.status === 401) {
-        await handleUnauthorized(authConfig);
+        const result = { handled: false };
+        await nuxtApp.callHook("movk:api:unauthorized", context, result);
+        if (!result.handled) {
+          await handleUnauthorized(authConfig, nuxtApp);
+        }
+      }
+      await nuxtApp.callHook("movk:api:error", context);
+      if (import.meta.client) {
+        const data = response._data;
+        const message = data ? extractMessage(data, responseConfig) : void 0;
+        const errorMessage = toast !== false ? extractToastMessage(toast, "error", message || `\u8BF7\u6C42\u5931\u8D25 (${response.status})`) : void 0;
+        showToast("error", errorMessage, toast, toastConfig);
       }
       if (publicConfig.debug) {
         console.error("[Movk API] Error:", response.status, response._data);
       }
-      if (!import.meta.client) return;
-      const { toast } = getApiFetchContext(context);
-      const data = response._data;
-      const message = data ? extractMessage(data, responseConfig) : void 0;
-      const errorMessage = toast !== false ? toast?.errorMessage || message || `\u8BF7\u6C42\u5931\u8D25 (${response.status})` : void 0;
-      showToast("error", errorMessage, toast, toastConfig);
     }
-  };
-}
-function createApiClient(resolvedConfig, publicConfig, getOrCreateEndpoint) {
-  const builtinHooks = createBuiltinHooks(resolvedConfig, publicConfig);
-  resolvedConfig.builtinHooks = builtinHooks;
-  const $fetchInstance = $fetch.create({
-    baseURL: resolvedConfig.baseURL,
-    headers: resolvedConfig.headers,
-    onRequest: builtinHooks.onRequest,
-    onRequestError: builtinHooks.onRequestError,
-    onResponse: builtinHooks.onResponse,
-    onResponseError: builtinHooks.onResponseError
   });
-  const download = async (url, filename, options = {}) => {
-    const { toast, ...fetchOptions } = options;
-    const response = await $fetchInstance.raw(url, {
-      ...fetchOptions,
-      method: "GET",
-      responseType: "blob",
-      context: { toast }
-    });
-    if (!response._data) {
-      throw new Error("\u4E0B\u8F7D\u5931\u8D25: \u672A\u63A5\u6536\u5230\u6570\u636E");
-    }
-    const finalFilename = filename || extractFilename(response.headers, url.split("/").pop() || "download");
-    triggerDownload(response._data, finalFilename);
-    if (import.meta.client && toast !== false) {
-      const message = extractToastMessage(toast, "success", `\u4E0B\u8F7D\u6210\u529F: ${finalFilename}`);
-      showToast("success", message, toast, resolvedConfig.toast);
-    }
-  };
-  const upload = async (url, file, options = {}) => {
-    const { toast, fieldName = "file", ...fetchOptions } = options;
-    const formData = file instanceof FormData ? file : (() => {
-      const fd = new FormData();
-      const files = Array.isArray(file) ? file : [file];
-      files.forEach((f) => fd.append(fieldName, f));
-      return fd;
-    })();
-    return $fetchInstance(url, {
-      ...fetchOptions,
-      method: "POST",
-      body: formData,
-      context: { toast }
-    });
-  };
-  return {
-    $fetch: $fetchInstance,
-    use: (endpoint) => getOrCreateEndpoint(endpoint),
-    download,
-    upload,
-    getConfig: () => resolvedConfig
-  };
 }
 export default defineNuxtPlugin(() => {
+  const nuxtApp = useNuxtApp();
   const runtimeConfig = useRuntimeConfig();
   const publicConfig = runtimeConfig.public.movkApi;
   const privateConfig = import.meta.server ? runtimeConfig.movkApi : void 0;
@@ -174,13 +126,18 @@ export default defineNuxtPlugin(() => {
       toast: defu(endpointConfig.toast, publicConfig.toast),
       response: defu(endpointConfig.response, publicConfig.response)
     };
-    const client = createApiClient(resolvedConfig, publicConfig, getOrCreateEndpoint);
-    endpointCache.set(endpointName, client);
-    return client;
+    const $fetchInstance = createEndpointFetch(resolvedConfig, publicConfig, nuxtApp);
+    const apiInstance = Object.assign($fetchInstance, {
+      use: (endpoint) => getOrCreateEndpoint(endpoint)
+    });
+    endpointCache.set(endpointName, apiInstance);
+    return apiInstance;
   };
   const defaultEndpoint = publicConfig.defaultEndpoint || "default";
   const api = getOrCreateEndpoint(defaultEndpoint);
   return {
-    provide: { api }
+    provide: {
+      api
+    }
   };
 });

package/dist/runtime/plugins/theme.js

@@ -1,98 +1,78 @@
-import { defineNuxtPlugin, onNuxtReady, useAppConfig, useHead, useSiteConfig } from "#imports";
+import { defineNuxtPlugin, useAppConfig, useHead, useSiteConfig } from "#imports";
+import { kebabCase } from "@movk/core";
 import { themeIcons } from "../utils/theme.js";
 export default defineNuxtPlugin({
   enforce: "post",
   setup() {
     const appConfig = useAppConfig();
     const site = useSiteConfig();
+    const name = kebabCase(site.name);
     if (import.meta.client) {
-      let updateColor = function(type) {
-        const color = localStorage.getItem(`${site.name}-ui-${type}`);
-        if (color) {
-          appConfig.ui.colors[type] = color;
-        }
-      }, updateRadius = function() {
-        const radius = localStorage.getItem(`${site.name}-ui-radius`);
-        if (radius) {
-          appConfig.theme.radius = Number.parseFloat(radius);
-        }
-      }, updateBlackAsPrimary = function() {
-        const blackAsPrimary = localStorage.getItem(`${site.name}-ui-black-as-primary`);
-        if (blackAsPrimary) {
-          appConfig.theme.blackAsPrimary = blackAsPrimary === "true";
-        }
-      }, updateFont = function() {
-        const font = localStorage.getItem(`${site.name}-ui-font`);
-        if (font) {
-          appConfig.theme.font = font;
-        }
-      };
-      updateColor("primary");
-      updateColor("neutral");
-      updateRadius();
-      updateBlackAsPrimary();
-      updateFont();
+      const primary = localStorage.getItem(`${name}-ui-primary`);
+      if (primary) appConfig.ui.colors.primary = primary;
+      const neutral = localStorage.getItem(`${name}-ui-neutral`);
+      if (neutral) appConfig.ui.colors.neutral = neutral;
+      const icons = localStorage.getItem(`${name}-ui-icons`);
+      if (icons) appConfig.ui.icons = themeIcons[icons];
     }
-    onNuxtReady(() => {
-      function updateIcons() {
-        const icons = localStorage.getItem(`${site.name}-ui-icons`);
-        if (icons) {
-          appConfig.theme.icons = icons;
-          appConfig.ui.icons = themeIcons[icons];
-        }
-      }
-      updateIcons();
-    });
     if (import.meta.server) {
       useHead({
         script: [{
           innerHTML: `
-            let html = document.querySelector('style#nuxt-ui-colors').innerHTML;
-
-            if (localStorage.getItem('${site.name}-ui-primary')) {
-              const primaryColor = localStorage.getItem('${site.name}-ui-primary');
-              if (primaryColor !== 'black') {
+            var colorsEl = document.querySelector('style#nuxt-ui-colors');
+            if (colorsEl) {
+              let html = colorsEl.innerHTML;
+              if (localStorage.getItem('${name}-ui-primary')) {
+                const primaryColor = localStorage.getItem('${name}-ui-primary');
+                if (primaryColor !== 'black') {
+                  html = html.replace(
+                    /(--ui-color-primary-\\d{2,3}:\\s*var\\(--color-)${appConfig.ui.colors.primary}(-\\d{2,3}.*?\\))/g,
+                    \`$1\${primaryColor}$2\`
+                  );
+                }
+              }
+              if (localStorage.getItem('${name}-ui-neutral')) {
+                let neutralColor = localStorage.getItem('${name}-ui-neutral');
                 html = html.replace(
-                  /(--ui-color-primary-\\d{2,3}:\\s*var\\(--color-)${appConfig.ui.colors.primary}(-\\d{2,3}.*?\\))/g,
-                  \`$1\${primaryColor}$2\`
+                  /(--ui-color-neutral-\\d{2,3}:\\s*var\\(--color-)${appConfig.ui.colors.neutral}(-\\d{2,3}.*?\\))/g,
+                  \`$1\${neutralColor === 'neutral' ? 'old-neutral' : neutralColor}$2\`
                 );
               }
-            }
-            if (localStorage.getItem('${site.name}-ui-neutral')) {
-              let neutralColor = localStorage.getItem('${site.name}-ui-neutral');
-              html = html.replace(
-                /(--ui-color-neutral-\\d{2,3}:\\s*var\\(--color-)${appConfig.ui.colors.neutral}(-\\d{2,3}.*?\\))/g,
-                \`$1\${neutralColor === 'neutral' ? 'old-neutral' : neutralColor}$2\`
-              );
-            }
 
-            document.querySelector('style#nuxt-ui-colors').innerHTML = html;
+              colorsEl.innerHTML = html;
+            }
             `.replace(/\s+/g, " "),
           type: "text/javascript",
           tagPriority: -1
         }, {
           innerHTML: `
-            if (localStorage.getItem('${site.name}-ui-radius')) {
-              document.querySelector('style#nuxt-ui-radius').innerHTML = ':root { --ui-radius: ' + localStorage.getItem('${site.name}-ui-radius') + 'rem; }';
+            if (localStorage.getItem('${name}-ui-radius')) {
+              document.getElementById('${name}-ui-radius').innerHTML = ':root { --ui-radius: ' + localStorage.getItem('${name}-ui-radius') + 'rem; }';
             }
           `.replace(/\s+/g, " "),
           type: "text/javascript",
           tagPriority: -1
         }, {
           innerHTML: `
-            if (localStorage.getItem('${site.name}-ui-black-as-primary') === 'true') {
-              document.querySelector('style#nuxt-ui-black-as-primary').innerHTML = ':root { --ui-primary: black; } .dark { --ui-primary: white; }';
+            if (localStorage.getItem('${name}-ui-black-as-primary') === 'true') {
+              document.getElementById('${name}-ui-black-as-primary').innerHTML = ':root { --ui-primary: black; } .dark { --ui-primary: white; }';
             } else {
-              document.querySelector('style#nuxt-ui-black-as-primary').innerHTML = '';
+              document.getElementById('${name}-ui-black-as-primary').innerHTML = '';
             }
           `.replace(/\s+/g, " ")
         }, {
-          innerHTML: `
-            if (localStorage.getItem('${site.name}-ui-font')) {
-              const font = localStorage.getItem('${site.name}-ui-font');
-              document.querySelector('style#nuxt-ui-font').innerHTML = ':root { --font-sans: \\'' + font + '\\', sans-serif; }';
-            }
-          `.replace(/\s+/g, " ")
+          innerHTML: [
+            `if (localStorage.getItem('${name}-ui-font')) {`,
+            `var font = localStorage.getItem('${name}-ui-font');`,
+            `document.getElementById('${name}-ui-font').innerHTML = ':root { --font-sans: \\'' + font + '\\', sans-serif; }';`,
+            `if (font !== 'Alibaba PuHuiTi' && ['Alibaba PuHuiTi', 'Public Sans', 'DM Sans', 'Geist', 'Inter', 'Poppins', 'Outfit', 'Raleway'].includes(font)) {`,
+            `var lnk = document.createElement('link');`,
+            `lnk.rel = 'stylesheet';`,
+            `lnk.href = 'https://fonts.googleapis.com/css2?family=' + encodeURIComponent(font) + ':wght@400;500;600;700&display=swap';`,
+            `lnk.id = 'font-' + font.toLowerCase().replace(/\\s+/g, '-');`,
+            `document.head.appendChild(lnk);`,
+            `}}`
+          ].join(" ")
         }]
       });
     }

package/dist/runtime/style.css

@@ -1 +1 @@
-@import "tailwindcss" theme(static);@import "@nuxt/ui";@source "./components";
+@import "tailwindcss" theme(static);@import "@nuxt/ui";@source "./components";@source "./constants";@theme static{--font-sans:"Alibaba PuHuiTi",sans-serif}