@movk/nuxt 0.1.1 → 1.1.0

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

@@ -0,0 +1,52 @@
+import type { ApiResponse, RequestToastOptions } from '../types/api.js';
+/**
+ * 上传选项(带进度监控)
+ */
+export interface UploadWithProgressOptions {
+    /** 文件字段名 @defaultValue 'file' */
+    fieldName?: string;
+    /** 额外的表单字段 */
+    fields?: Record<string, string | Blob>;
+    /** 额外的请求头 */
+    headers?: Record<string, string>;
+    /** Toast 配置 */
+    toast?: RequestToastOptions | false;
+    /** 端点名称 */
+    endpoint?: string;
+    /** 上传成功回调 */
+    onSuccess?: (response: ApiResponse) => void;
+    /** 上传失败回调 */
+    onError?: (error: Error) => void;
+}
+/**
+ * 带进度监控的文件上传 composable
+ *
+ * 基于原生 XMLHttpRequest 实现，支持实时进度和取消上传
+ *
+ * @example
+ * ```ts
+ * const { progress, uploading, upload, abort } = useUploadWithProgress()
+ *
+ * const { data, error } = await upload('/api/upload', files, {
+ *   fieldName: 'files',
+ *   onSuccess: (res) => console.log('上传成功', res)
+ * })
+ * ```
+ */
+export declare function useUploadWithProgress<T = unknown>(): {
+    /** 上传进度 (0-100) */
+    progress: any;
+    /** 是否正在上传 */
+    uploading: any;
+    /** 上传结果 */
+    data: any;
+    /** 错误信息 */
+    error: any;
+    /** 执行上传 */
+    upload: (url: string, files: File | File[], options?: UploadWithProgressOptions) => Promise<{
+        data: ApiResponse<T> | null;
+        error: Error | null;
+    }>;
+    /** 中止上传 */
+    abort: () => void;
+};

package/dist/runtime/composables/useUploadWithProgress.js

@@ -0,0 +1,117 @@
+import { ref, useNuxtApp } from "#imports";
+import {
+  showToast,
+  isBusinessSuccess,
+  extractMessage,
+  extractToastMessage,
+  getAuthHeaders
+} from "../utils/api-utils.js";
+export function useUploadWithProgress() {
+  const { $api } = useNuxtApp();
+  const progress = ref(0);
+  const uploading = ref(false);
+  const data = ref(null);
+  const error = ref(null);
+  let currentXhr = null;
+  const abort = () => {
+    currentXhr?.abort();
+    currentXhr = null;
+    uploading.value = false;
+    progress.value = 0;
+  };
+  const upload = async (url, files, options = {}) => {
+    const { fieldName = "file", fields = {}, headers = {}, toast, endpoint, onSuccess, onError } = options;
+    const apiInstance = endpoint ? $api.use(endpoint) : $api;
+    const config = apiInstance.getConfig();
+    const fullUrl = `${config.baseURL || ""}${url}`;
+    const formData = new FormData();
+    const fileArray = Array.isArray(files) ? files : [files];
+    fileArray.forEach((file) => formData.append(fieldName, file));
+    Object.entries(fields).forEach(([key, value]) => formData.append(key, value));
+    progress.value = 0;
+    uploading.value = true;
+    data.value = null;
+    error.value = null;
+    return new Promise((resolve) => {
+      const xhr = new XMLHttpRequest();
+      currentXhr = xhr;
+      xhr.upload.addEventListener("progress", (e) => {
+        if (e.lengthComputable) {
+          progress.value = Math.round(e.loaded / e.total * 100);
+        }
+      });
+      xhr.addEventListener("load", () => {
+        uploading.value = false;
+        currentXhr = null;
+        try {
+          const response = JSON.parse(xhr.responseText);
+          const isSuccess = isBusinessSuccess(response, config.response);
+          const message = extractMessage(response, config.response);
+          if (isSuccess) {
+            data.value = response;
+            if (import.meta.client && toast !== false) {
+              const msg = extractToastMessage(toast, "success", message || "\u4E0A\u4F20\u6210\u529F");
+              showToast("success", msg, toast, config.toast);
+            }
+            onSuccess?.(response);
+            resolve({ data: response, error: null });
+          } else {
+            const err = new Error(message || "\u4E0A\u4F20\u5931\u8D25");
+            error.value = err;
+            if (import.meta.client && toast !== false) {
+              const msg = extractToastMessage(toast, "error", message || "\u4E0A\u4F20\u5931\u8D25");
+              showToast("error", msg, toast, config.toast);
+            }
+            onError?.(err);
+            resolve({ data: null, error: err });
+          }
+        } catch (err) {
+          const parseError = err instanceof Error ? err : new Error("\u54CD\u5E94\u89E3\u6790\u5931\u8D25");
+          error.value = parseError;
+          if (import.meta.client && toast !== false) {
+            showToast("error", "\u4E0A\u4F20\u5931\u8D25", toast, config.toast);
+          }
+          onError?.(parseError);
+          resolve({ data: null, error: parseError });
+        }
+      });
+      xhr.addEventListener("error", () => {
+        uploading.value = false;
+        currentXhr = null;
+        const err = new Error("\u7F51\u7EDC\u9519\u8BEF");
+        error.value = err;
+        if (import.meta.client && toast !== false) {
+          showToast("error", "\u4E0A\u4F20\u5931\u8D25", toast, config.toast);
+        }
+        onError?.(err);
+        resolve({ data: null, error: err });
+      });
+      xhr.addEventListener("abort", () => {
+        uploading.value = false;
+        currentXhr = null;
+        error.value = new Error("\u4E0A\u4F20\u5DF2\u53D6\u6D88");
+        resolve({ data: null, error: error.value });
+      });
+      xhr.open("POST", fullUrl);
+      const authHeaders = getAuthHeaders(config);
+      Object.entries({ ...headers, ...authHeaders }).forEach(([key, value]) => {
+        xhr.setRequestHeader(key, value);
+      });
+      xhr.send(formData);
+    });
+  };
+  return {
+    /** 上传进度 (0-100) */
+    progress,
+    /** 是否正在上传 */
+    uploading,
+    /** 上传结果 */
+    data,
+    /** 错误信息 */
+    error,
+    /** 执行上传 */
+    upload,
+    /** 中止上传 */
+    abort
+  };
+}

package/dist/runtime/internal/useAutoFormProvider.js

@@ -174,8 +174,8 @@ export function useAutoFormProvider(state, slots) {
       return defu(field, {
         meta: {
           fieldSlots: {
-            hint: ({ open }) => h(UIcon, {
-              name: open ? "i-lucide-chevron-down" : "i-lucide-chevron-right",
+            hint: (props) => h(UIcon, {
+              name: props.open ? "i-lucide-chevron-down" : "i-lucide-chevron-right",
               class: "shrink-0 size-5 transition-transform duration-200"
             })
           }

package/dist/runtime/plugins/api.factory.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

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

@@ -0,0 +1,186 @@
+import { getPath, triggerDownload, extractFilename } from "@movk/core";
+import {
+  showToast,
+  isBusinessSuccess,
+  extractMessage,
+  extractToastMessage
+} 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();
+  const unauthorizedConfig = config.unauthorized;
+  if (unauthorizedConfig?.clearSession && userSession?.clear) {
+    await userSession.clear();
+  }
+  if (unauthorizedConfig?.redirect) {
+    const loginPath = unauthorizedConfig.loginPath || "/login";
+    const nuxtApp = useNuxtApp();
+    await nuxtApp.runWithContext(() => navigateTo(loginPath));
+  }
+}
+function getApiFetchContext(context) {
+  return context.options.context || {};
+}
+function createBuiltinHooks(resolvedConfig, publicConfig) {
+  const { auth: authConfig, toast: toastConfig, response: responseConfig } = resolvedConfig;
+  return {
+    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;
+          }
+        }
+      }
+      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);
+      }
+    },
+    async onResponse(context) {
+      const response = context.response;
+      const data = response._data;
+      if (publicConfig.debug) {
+        console.log("[Movk API] Response:", data);
+      }
+      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);
+      }
+    },
+    async onResponseError(context) {
+      const { response } = context;
+      if (response.status === 401) {
+        await handleUnauthorized(authConfig);
+      }
+      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 runtimeConfig = useRuntimeConfig();
+  const publicConfig = runtimeConfig.public.movkApi;
+  const privateConfig = import.meta.server ? runtimeConfig.movkApi : void 0;
+  const endpointCache = /* @__PURE__ */ new Map();
+  const getOrCreateEndpoint = (endpointName) => {
+    if (endpointCache.has(endpointName)) {
+      return endpointCache.get(endpointName);
+    }
+    const endpoints = publicConfig.endpoints || {};
+    const endpointConfig = endpoints[endpointName];
+    if (!endpointConfig) {
+      console.warn(`[Movk API] Endpoint "${endpointName}" not found, using default`);
+      return getOrCreateEndpoint(publicConfig.defaultEndpoint || "default");
+    }
+    const privateEndpointConfig = privateConfig?.endpoints?.[endpointName];
+    const resolvedConfig = {
+      ...endpointConfig,
+      headers: privateEndpointConfig?.headers,
+      auth: defu(endpointConfig.auth, publicConfig.auth),
+      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 defaultEndpoint = publicConfig.defaultEndpoint || "default";
+  const api = getOrCreateEndpoint(defaultEndpoint);
+  return {
+    provide: { api }
+  };
+});

package/dist/runtime/plugins/theme.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugins/theme.js

@@ -0,0 +1,89 @@
+import { defineNuxtPlugin, useAppConfig, useHead, useSiteConfig } from "#imports";
+export default defineNuxtPlugin({
+  enforce: "post",
+  setup() {
+    const appConfig = useAppConfig();
+    const site = useSiteConfig();
+    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();
+    }
+    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') {
+                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('${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;
+            `.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; }';
+            }
+          `.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; }';
+            } else {
+              document.querySelector('style#nuxt-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, " ")
+        }]
+      });
+    }
+  }
+});