@movk/nuxt 1.0.0 → 1.1.1

package/dist/runtime/composables/useAutoForm.js

@@ -6,6 +6,7 @@ import WithCharacterLimit from "../components/input/WithCharacterLimit.vue";
 import DatePicker from "../components/DatePicker.vue";
 import ColorChooser from "../components/ColorChooser.vue";
 import StarRating from "../components/StarRating.vue";
+import SlideVerify from "../components/SlideVerify.vue";
 import {
   UInput,
   UInputNumber,
@@ -193,7 +194,8 @@ const DEFAULT_CONTROLS = {
   withCopy: defineControl({ component: WithCopy, controlProps: DEFAULT_CONTROL_PROPS }),
   withCharacterLimit: defineControl({ component: WithCharacterLimit, controlProps: DEFAULT_CONTROL_PROPS }),
   colorChooser: defineControl({ component: ColorChooser, controlProps: DEFAULT_CONTROL_PROPS }),
-  starRating: defineControl({ component: StarRating, controlProps: DEFAULT_CONTROL_PROPS })
+  starRating: defineControl({ component: StarRating, controlProps: DEFAULT_CONTROL_PROPS }),
+  slideVerify: defineControl({ component: SlideVerify, controlProps: DEFAULT_CONTROL_PROPS })
 };
 export function useAutoForm(controls) {
   function createZodFactory(_controls) {

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

@@ -0,0 +1,27 @@
+export declare function useTheme(): {
+    neutralColors: readonly ["slate", "gray", "zinc", "neutral", "stone"];
+    neutral: import("vue").WritableComputedRef<any, any>;
+    primaryColors: string[];
+    primary: import("vue").WritableComputedRef<any, any>;
+    setBlackAsPrimary: (value: boolean) => void;
+    radiuses: number[];
+    radius: import("vue").WritableComputedRef<any, any>;
+    fonts: string[];
+    font: import("vue").WritableComputedRef<any, any>;
+    icon: import("vue").WritableComputedRef<any, any>;
+    icons: {
+        label: string;
+        icon: string;
+        value: string;
+    }[];
+    modes: {
+        label: string;
+        icon: any;
+    }[];
+    mode: import("vue").WritableComputedRef<any, any>;
+    hasCSSChanges: import("vue").ComputedRef<any>;
+    hasAppConfigChanges: import("vue").ComputedRef<boolean>;
+    exportCSS: () => string;
+    exportAppConfig: () => string;
+    resetTheme: () => void;
+};

package/dist/runtime/composables/useTheme.js

@@ -0,0 +1,180 @@
+import { useAppConfig, useColorMode, useSiteConfig } from "#imports";
+import { omit } from "@movk/core";
+import colors from "tailwindcss/colors";
+import { computed } from "vue";
+import { themeIcons } from "../utils/theme.js";
+export function useTheme() {
+  const appConfig = useAppConfig();
+  const colorMode = useColorMode();
+  const site = useSiteConfig();
+  const neutralColors = ["slate", "gray", "zinc", "neutral", "stone"];
+  const neutral = computed({
+    get() {
+      return appConfig.ui.colors.neutral;
+    },
+    set(option) {
+      appConfig.ui.colors.neutral = option;
+      window.localStorage.setItem(`${site.name}-ui-neutral`, appConfig.ui.colors.neutral);
+    }
+  });
+  const colorsToOmit = ["inherit", "current", "transparent", "black", "white", ...neutralColors];
+  const primaryColors = Object.keys(omit(colors, [...colorsToOmit]));
+  const primary = computed({
+    get() {
+      return appConfig.ui.colors.primary;
+    },
+    set(option) {
+      appConfig.ui.colors.primary = option;
+      window.localStorage.setItem(`${site.name}-ui-primary`, appConfig.ui.colors.primary);
+      setBlackAsPrimary(false);
+    }
+  });
+  const radiuses = [0, 0.125, 0.25, 0.375, 0.5];
+  const radius = computed({
+    get() {
+      return appConfig.theme.radius;
+    },
+    set(option) {
+      appConfig.theme.radius = option;
+      window.localStorage.setItem(`${site.name}-ui-radius`, String(appConfig.theme.radius));
+    }
+  });
+  const fonts = ["Public Sans", "DM Sans", "Geist", "Inter", "Poppins", "Outfit", "Raleway"];
+  const font = computed({
+    get() {
+      return appConfig.theme.font;
+    },
+    set(option) {
+      appConfig.theme.font = option;
+      if (appConfig.theme.font) {
+        window.localStorage.setItem(`${site.name}-ui-font`, appConfig.theme.font);
+      }
+    }
+  });
+  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;
+    },
+    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);
+      }
+    }
+  });
+  const modes = [
+    { label: "light", icon: appConfig.ui.icons.light },
+    { label: "dark", icon: appConfig.ui.icons.dark },
+    { label: "system", icon: appConfig.ui.icons.system }
+  ];
+  const mode = computed({
+    get() {
+      return colorMode.value;
+    },
+    set(option) {
+      colorMode.preference = option;
+    }
+  });
+  function setBlackAsPrimary(value) {
+    appConfig.theme.blackAsPrimary = value;
+    window.localStorage.setItem(`${site.name}-ui-black-as-primary`, String(value));
+  }
+  const hasCSSChanges = computed(() => {
+    return appConfig.theme.radius !== 0.25 || appConfig.theme.blackAsPrimary || appConfig.theme.font !== "Public Sans" || appConfig.theme.icons !== "lucide";
+  });
+  const hasAppConfigChanges = computed(() => {
+    return appConfig.ui.colors.primary !== "green" || appConfig.ui.colors.neutral !== "slate";
+  });
+  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;`, "}");
+    }
+    const rootLines = [];
+    if (appConfig.theme.radius !== 0.25) {
+      rootLines.push(`  --ui-radius: ${appConfig.theme.radius}rem;`);
+    }
+    if (appConfig.theme.blackAsPrimary) {
+      rootLines.push("  --ui-primary: black;");
+    }
+    if (rootLines.length) {
+      lines.push("", ":root {", ...rootLines, "}");
+    }
+    if (appConfig.theme.blackAsPrimary) {
+      lines.push("", ".dark {", "  --ui-primary: white;", "}");
+    }
+    return lines.join("\n");
+  }
+  function exportAppConfig() {
+    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;
+      }
+    }
+    if (appConfig.theme.icons !== "lucide") {
+      const iconSet = appConfig.theme.icons;
+      const icons2 = themeIcons[iconSet];
+      config.ui = config.ui || {};
+      config.ui.icons = icons2;
+    }
+    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`);
+  }
+  return {
+    neutralColors,
+    neutral,
+    primaryColors,
+    primary,
+    setBlackAsPrimary,
+    radiuses,
+    radius,
+    fonts,
+    font,
+    icon,
+    icons,
+    modes,
+    mode,
+    hasCSSChanges,
+    hasAppConfigChanges,
+    exportCSS,
+    exportAppConfig,
+    resetTheme
+  };
+}

package/dist/runtime/composables/useUploadWithProgress.js

@@ -45,8 +45,8 @@ export function useUploadWithProgress() {
         currentXhr = null;
         try {
           const response = JSON.parse(xhr.responseText);
-          const isSuccess = isBusinessSuccess(response, config.success);
-          const message = extractMessage(response, config.success);
+          const isSuccess = isBusinessSuccess(response, config.response);
+          const message = extractMessage(response, config.response);
           if (isSuccess) {
             data.value = response;
             if (import.meta.client && toast !== false) {

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.js

@@ -5,7 +5,7 @@ import {
   extractMessage,
   extractToastMessage
 } from "../utils/api-utils.js";
-import { defineNuxtPlugin, useRuntimeConfig, navigateTo, useNuxtApp, useUserSession } from "#imports";
+import { defineNuxtPlugin, navigateTo, useNuxtApp, useUserSession, useRuntimeConfig } from "#imports";
 import defu from "defu";
 function getUserSession() {
   try {
@@ -27,11 +27,12 @@ function buildAuthHeader(token, config) {
 }
 async function handleUnauthorized(config) {
   const userSession = getUserSession();
-  if (config.clearSessionOnUnauthorized && userSession?.clear) {
+  const unauthorizedConfig = config.unauthorized;
+  if (unauthorizedConfig?.clearSession && userSession?.clear) {
     await userSession.clear();
   }
-  if (config.redirectOnUnauthorized) {
-    const loginPath = config.loginPath || "/login";
+  if (unauthorizedConfig?.redirect) {
+    const loginPath = unauthorizedConfig.loginPath || "/login";
     const nuxtApp = useNuxtApp();
     await nuxtApp.runWithContext(() => navigateTo(loginPath));
   }
@@ -39,8 +40,8 @@ async function handleUnauthorized(config) {
 function getApiFetchContext(context) {
   return context.options.context || {};
 }
-function createBuiltinHooks(resolvedConfig, moduleConfig) {
-  const { auth: authConfig, toast: toastConfig, success: successConfig } = resolvedConfig;
+function createBuiltinHooks(resolvedConfig, publicConfig) {
+  const { auth: authConfig, toast: toastConfig, response: responseConfig } = resolvedConfig;
   return {
     onRequest(context) {
       if (authConfig.enabled) {
@@ -57,25 +58,25 @@ function createBuiltinHooks(resolvedConfig, moduleConfig) {
           }
         }
       }
-      if (moduleConfig.debug) {
+      if (publicConfig.debug) {
         console.log(`[Movk API] Request: ${context.options.method || "GET"} ${resolvedConfig.baseURL}${context.request}`);
       }
     },
     async onRequestError({ error }) {
-      if (moduleConfig.debug) {
+      if (publicConfig.debug) {
         console.error("[Movk API] Request Error:", error);
       }
     },
     async onResponse(context) {
       const response = context.response;
       const data = response._data;
-      if (moduleConfig.debug) {
+      if (publicConfig.debug) {
         console.log("[Movk API] Response:", data);
       }
       if (!import.meta.client) return;
       const { toast, skipBusinessCheck } = getApiFetchContext(context);
-      const isSuccess = skipBusinessCheck || isBusinessSuccess(data, successConfig);
-      const message = extractMessage(data, successConfig);
+      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);
@@ -86,20 +87,20 @@ function createBuiltinHooks(resolvedConfig, moduleConfig) {
       if (response.status === 401) {
         await handleUnauthorized(authConfig);
       }
-      if (moduleConfig.debug) {
+      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, successConfig) : void 0;
+      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, moduleConfig, getOrCreateEndpoint) {
-  const builtinHooks = createBuiltinHooks(resolvedConfig, moduleConfig);
+function createApiClient(resolvedConfig, publicConfig, getOrCreateEndpoint) {
+  const builtinHooks = createBuiltinHooks(resolvedConfig, publicConfig);
   resolvedConfig.builtinHooks = builtinHooks;
   const $fetchInstance = $fetch.create({
     baseURL: resolvedConfig.baseURL,
@@ -151,36 +152,33 @@ function createApiClient(resolvedConfig, moduleConfig, getOrCreateEndpoint) {
   };
 }
 export default defineNuxtPlugin(() => {
-  const moduleConfig = useRuntimeConfig().public.movkApi;
-  if (!moduleConfig.enabled) {
-    return;
-  }
+  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 = moduleConfig.endpoints || {};
+    const endpoints = publicConfig.endpoints || {};
     const endpointConfig = endpoints[endpointName];
     if (!endpointConfig) {
       console.warn(`[Movk API] Endpoint "${endpointName}" not found, using default`);
-      return getOrCreateEndpoint(moduleConfig.defaultEndpoint || "default");
+      return getOrCreateEndpoint(publicConfig.defaultEndpoint || "default");
     }
+    const privateEndpointConfig = privateConfig?.endpoints?.[endpointName];
     const resolvedConfig = {
       ...endpointConfig,
-      auth: defu(endpointConfig.auth, moduleConfig.auth),
-      toast: defu(endpointConfig.toast, moduleConfig.toast),
-      success: defu(endpointConfig.success, moduleConfig.success)
+      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,
-      moduleConfig,
-      getOrCreateEndpoint
-    );
+    const client = createApiClient(resolvedConfig, publicConfig, getOrCreateEndpoint);
     endpointCache.set(endpointName, client);
     return client;
   };
-  const defaultEndpoint = moduleConfig.defaultEndpoint || "default";
+  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,100 @@
+import { defineNuxtPlugin, onNuxtReady, useAppConfig, useHead, useSiteConfig } from "#imports";
+import { themeIcons } from "../utils/theme.js";
+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();
+    }
+    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') {
+                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, " ")
+        }]
+      });
+    }
+  }
+});