befly-admin 3.12.17 → 3.13.0

package/src/plugins/{http.ts → http.js}

@@ -1,30 +1,14 @@
-import axios, { AxiosHeaders, type AxiosRequestConfig, type AxiosResponse, type InternalAxiosRequestConfig } from "axios";
-import { cleanParams } from "befly-shared/utils/cleanParams";
+import axios, { AxiosHeaders } from "axios";
+import { cleanParams } from "befly-admin-ui/utils/cleanParams";
 
 import { $Storage } from "./storage";
 
-export type HttpApiResponse<TData> = {
-    code: number;
-    msg?: string;
-    data?: TData;
-};
-
-export type HttpCleanParamsOptions = {
-    dropValues?: readonly unknown[];
-    dropKeyValue?: Record<string, readonly unknown[]>;
-};
-
-export type HttpClientOptions = AxiosRequestConfig & HttpCleanParamsOptions;
-
-export type HttpGetData = Record<string, unknown>;
-export type HttpPostData = Record<string, unknown> | FormData;
-
-function toAxiosRequestConfig(options: HttpClientOptions | undefined): AxiosRequestConfig | undefined {
+function toAxiosRequestConfig(options) {
     if (!options) {
         return undefined;
     }
 
-    const out = Object.assign({}, options) as Record<string, unknown>;
+    const out = Object.assign({}, options);
     delete out["dropValues"];
     delete out["dropKeyValue"];
 
@@ -32,17 +16,17 @@ function toAxiosRequestConfig(options: HttpClientOptions | undefined): AxiosRequ
         return undefined;
     }
 
-    return out as AxiosRequestConfig;
+    return out;
 }
 
-function isPlainRecord(value: unknown): value is Record<string, unknown> {
+function isPlainRecord(value) {
     if (typeof value !== "object" || value === null) return false;
     if (Array.isArray(value)) return false;
     if (value instanceof FormData) return false;
     return true;
 }
 
-function maybeCleanRequestData(data: Record<string, unknown>, cleanOptions: HttpCleanParamsOptions | undefined): Record<string, unknown> {
+function maybeCleanRequestData(data, cleanOptions) {
     if (!isPlainRecord(data)) {
         return data;
     }
@@ -53,11 +37,7 @@ function maybeCleanRequestData(data: Record<string, unknown>, cleanOptions: Http
 }
 
 class HttpError extends Error {
-    public code: number;
-    public data?: unknown;
-    public rawError?: unknown;
-
-    public constructor(code: number, msg: string, data?: unknown, rawError?: unknown) {
+    constructor(code, msg, data, rawError) {
         super(msg);
         this.name = "HttpError";
         this.code = code;
@@ -66,11 +46,11 @@ class HttpError extends Error {
     }
 }
 
-function isNormalizedHttpError(value: unknown): value is HttpError {
+function isNormalizedHttpError(value) {
     return value instanceof HttpError;
 }
 
-async function showNetworkErrorToast(): Promise<void> {
+async function showNetworkErrorToast() {
     try {
         // 在测试/非浏览器环境下，提示组件可能不可用；仅在需要展示提示时再加载。
         MessagePlugin.error("网络连接失败");
@@ -79,7 +59,7 @@ async function showNetworkErrorToast(): Promise<void> {
     }
 }
 
-async function unwrapApiResponse<TData>(promise: Promise<AxiosResponse<HttpApiResponse<TData>>>): Promise<HttpApiResponse<TData>> {
+async function unwrapApiResponse(promise) {
     try {
         const response = await promise;
         const res = response.data;
@@ -102,7 +82,7 @@ async function unwrapApiResponse<TData>(promise: Promise<AxiosResponse<HttpApiRe
 
 // 创建 axios 实例
 const request = axios.create({
-    baseURL: (import.meta as unknown as { env?: Record<string, string> }).env?.["VITE_API_BASE_URL"] || "",
+    baseURL: import.meta.env["VITE_API_BASE_URL"] || "",
     timeout: 10000,
     headers: {
         "Content-Type": "application/json"
@@ -111,7 +91,7 @@ const request = axios.create({
 
 // 请求拦截器
 request.interceptors.request.use(
-    (config: InternalAxiosRequestConfig) => {
+    (config) => {
         const token = $Storage.local.get("token");
         if (token) {
             const headers = new AxiosHeaders(config.headers);
@@ -120,41 +100,41 @@ request.interceptors.request.use(
         }
         return config;
     },
-    (error: unknown) => {
+    (error) => {
         return Promise.reject(error);
     }
 );
 
-async function httpGet<TData>(url: string, data?: HttpGetData, options?: HttpClientOptions): Promise<HttpApiResponse<TData>> {
+async function httpGet(url, data, options) {
     const axiosConfig = toAxiosRequestConfig(options);
     const inputData = data ?? {};
     const cleanedData = maybeCleanRequestData(inputData, options);
 
     // 规则：GET 必须传 params；为空也传空对象
     const finalConfig = Object.assign({}, axiosConfig);
-    (finalConfig as { params?: unknown }).params = cleanedData;
+    finalConfig.params = cleanedData;
 
-    return unwrapApiResponse<TData>(request.get<HttpApiResponse<TData>>(url, finalConfig));
+    return unwrapApiResponse(request.get(url, finalConfig));
 }
 
-async function httpPost<TData>(url: string, data?: HttpPostData, options?: HttpClientOptions): Promise<HttpApiResponse<TData>> {
+async function httpPost(url, data, options) {
     const axiosConfig = toAxiosRequestConfig(options);
     if (data === undefined) {
         // 规则：POST 必须传 body；为空也传空对象
-        return unwrapApiResponse<TData>(request.post<HttpApiResponse<TData>>(url, {}, axiosConfig));
+        return unwrapApiResponse(request.post(url, {}, axiosConfig));
     }
 
     if (data instanceof FormData) {
-        return unwrapApiResponse<TData>(request.post<HttpApiResponse<TData>>(url, data, axiosConfig));
+        return unwrapApiResponse(request.post(url, data, axiosConfig));
     }
 
     const cleanedData = maybeCleanRequestData(data, options);
     if (Object.keys(cleanedData).length === 0) {
         // 规则：POST 必须传 body；清洗为空则传空对象
-        return unwrapApiResponse<TData>(request.post<HttpApiResponse<TData>>(url, {}, axiosConfig));
+        return unwrapApiResponse(request.post(url, {}, axiosConfig));
     }
 
-    return unwrapApiResponse<TData>(request.post<HttpApiResponse<TData>>(url, cleanedData, axiosConfig));
+    return unwrapApiResponse(request.post(url, cleanedData, axiosConfig));
 }
 
 /**
@@ -177,5 +157,3 @@ export const $Http = {
     get: httpGet,
     post: httpPost
 };
-
-export type HttpClient = typeof $Http;

package/src/plugins/{router.ts → router.js}

@@ -5,7 +5,7 @@ import { routes } from "vue-router/auto-routes";
 import { $Storage } from "./storage";
 
 // 应用自定义布局系统（同时可选注入根路径重定向）
-const finalRoutes = Layouts(routes, $Config.homePath, (layoutName: string) => {
+const finalRoutes = Layouts(routes, $Config.homePath, (layoutName) => {
     if (layoutName === "default") {
         return () => import("../layouts/default.vue");
     }
@@ -15,7 +15,7 @@ const finalRoutes = Layouts(routes, $Config.homePath, (layoutName: string) => {
 
 /**
  * 创建并导出路由实例
- * 可直接在 main.ts 中使用 app.use($Router)
+ * 可直接在 main.js 中使用 app.use($Router)
  */
 export const $Router = createRouter({
     history: createWebHashHistory(import.meta.env.BASE_URL),

package/src/plugins/{storage.ts → storage.js}

@@ -4,48 +4,46 @@
  */
 
 // 获取命名空间
-const NAMESPACE = (import.meta as unknown as { env?: Record<string, string> }).env?.["VITE_STORAGE_NAMESPACE"] || "befly";
+const NAMESPACE = import.meta.env["VITE_STORAGE_NAMESPACE"] || "befly";
 
-class MemoryStorage implements Storage {
-    private map: Map<string, string>;
-
-    public constructor() {
-        this.map = new Map<string, string>();
+class MemoryStorage {
+    constructor() {
+        this.map = new Map();
     }
 
-    public get length(): number {
+    get length() {
         return this.map.size;
     }
 
-    public clear(): void {
+    clear() {
         for (const key of this.map.keys()) {
-            delete (this as unknown as Record<string, unknown>)[key];
+            delete this[key];
         }
         this.map.clear();
     }
 
-    public getItem(key: string): string | null {
+    getItem(key) {
         return this.map.get(key) ?? null;
     }
 
-    public key(index: number): string | null {
+    key(index) {
         const keys = Array.from(this.map.keys());
         return keys[index] ?? null;
     }
 
-    public removeItem(key: string): void {
+    removeItem(key) {
         this.map.delete(key);
-        delete (this as unknown as Record<string, unknown>)[key];
+        delete this[key];
     }
 
-    public setItem(key: string, value: string): void {
+    setItem(key, value) {
         this.map.set(key, value);
-        (this as unknown as Record<string, unknown>)[key] = value;
+        this[key] = value;
     }
 }
 
-function getBrowserStorage(kind: "localStorage" | "sessionStorage"): Storage {
-    const win = globalThis as unknown as { window?: { localStorage?: Storage; sessionStorage?: Storage } };
+function getBrowserStorage(kind) {
+    const win = globalThis;
     const storage = win.window?.[kind];
     if (storage) {
         return storage;
@@ -53,40 +51,23 @@ function getBrowserStorage(kind: "localStorage" | "sessionStorage"): Storage {
     return new MemoryStorage();
 }
 
-type StorageOps = {
-    set: (key: string, value: unknown) => void;
-    get: {
-        (key: string): string | null;
-        (key: string, defaultValue: string | null): string | null;
-        <T>(key: string, defaultValue: T): T;
-    };
-    remove: (key: string) => void;
-    clear: () => void;
-    has: (key: string) => boolean;
-    keys: () => string[];
-};
-
 /**
  * 存储操作类
  */
 class StorageManager {
-    private localStorage: Storage;
-    private sessionStorage: Storage;
-    private namespace: string;
-
-    public constructor(namespace: string = NAMESPACE) {
+    constructor(namespace = NAMESPACE) {
         this.localStorage = getBrowserStorage("localStorage");
         this.sessionStorage = getBrowserStorage("sessionStorage");
         this.namespace = namespace;
     }
 
-    private getKey(key: string): string {
+    getKey(key) {
         return `${this.namespace}:${key}`;
     }
 
-    private createStorageOps(storage: Storage): StorageOps {
+    createStorageOps(storage) {
         return {
-            set: (key: string, value: unknown) => {
+            set: (key, value) => {
                 try {
                     const fullKey = this.getKey(key);
                     const serializedValue = JSON.stringify(value);
@@ -96,20 +77,20 @@ class StorageManager {
                 }
             },
 
-            get: ((key: string, defaultValue?: unknown) => {
+            get: (key, defaultValue) => {
                 try {
                     const fullKey = this.getKey(key);
                     const value = storage.getItem(fullKey);
                     if (value === null) {
                         return defaultValue ?? null;
                     }
-                    return JSON.parse(value) as unknown;
+                    return JSON.parse(value);
                 } catch {
                     return defaultValue ?? null;
                 }
-            }) as StorageOps["get"],
+            },
 
-            remove: (key: string) => {
+            remove: (key) => {
                 try {
                     const fullKey = this.getKey(key);
                     storage.removeItem(fullKey);
@@ -132,7 +113,7 @@ class StorageManager {
                 }
             },
 
-            has: (key: string) => {
+            has: (key) => {
                 const fullKey = this.getKey(key);
                 return storage.getItem(fullKey) !== null;
             },
@@ -145,11 +126,11 @@ class StorageManager {
         };
     }
 
-    public get local(): StorageOps {
+    get local() {
         return this.createStorageOps(this.localStorage);
     }
 
-    public get session(): StorageOps {
+    get session() {
         return this.createStorageOps(this.sessionStorage);
     }
 }

package/src/utils/is.js

@@ -0,0 +1,6 @@
+/**
+ * 判断值是否为字符串。
+ */
+export function isString(value) {
+    return Object.prototype.toString.call(value) === "[object String]";
+}

package/src/views/index2.vue

@@ -57,7 +57,20 @@
                     <div class="line-chart">
                         <div class="chart-line"></div>
                         <div class="chart-grid"></div>
-                        <div class="chart-labels"><span>1月</span><span>2月</span><span>3月</span><span>4月</span><span>5月</span><span>6月</span><span>7月</span><span>8月</span><span>9月</span><span>10月</span><span>11月</span><span>12月</span></div>
+                        <div class="chart-labels">
+                            <span>1月</span>
+                            <span>2月</span>
+                            <span>3月</span>
+                            <span>4月</span>
+                            <span>5月</span>
+                            <span>6月</span>
+                            <span>7月</span>
+                            <span>8月</span>
+                            <span>9月</span>
+                            <span>10月</span>
+                            <span>11月</span>
+                            <span>12月</span>
+                        </div>
                     </div>
                 </div>
             </div>
@@ -142,7 +155,7 @@
     </div>
 </template>
 
-<script setup lang="ts"></script>
+<script setup></script>
 
 <style lang="scss" scoped>
 .dashboard {

package/vite.config.js

@@ -3,6 +3,5 @@ import { fileURLToPath } from "node:url";
 import { createBeflyViteConfig } from "befly-vite";
 
 export default createBeflyViteConfig({
-    root: fileURLToPath(new URL(".", import.meta.url)),
-    addonView: "adminViews"
+    root: fileURLToPath(new URL(".", import.meta.url))
 });

package/src/types/auto-imports.d.ts

@@ -1,191 +0,0 @@
-/* eslint-disable */
-/* prettier-ignore */
-// @ts-nocheck
-// noinspection JSUnusedGlobalSymbols
-// Generated by unplugin-auto-import
-// biome-ignore lint: disable
-export {}
-declare global {
-  const $Config: typeof import('../plugins/config').$Config
-  const $Http: typeof import('../plugins/http').$Http
-  const $Router: typeof import('../plugins/router').$Router
-  const $Storage: typeof import('../plugins/storage').$Storage
-  const DialogPlugin: typeof import('tdesign-vue-next').DialogPlugin
-  const EffectScope: typeof import('vue').EffectScope
-  const MessagePlugin: typeof import('tdesign-vue-next').MessagePlugin
-  const acceptHMRUpdate: typeof import('pinia').acceptHMRUpdate
-  const computed: typeof import('vue').computed
-  const createApp: typeof import('vue').createApp
-  const createPinia: typeof import('pinia').createPinia
-  const customRef: typeof import('vue').customRef
-  const defineAsyncComponent: typeof import('vue').defineAsyncComponent
-  const defineComponent: typeof import('vue').defineComponent
-  const definePage: typeof import('vue-router/experimental').definePage
-  const defineStore: typeof import('pinia').defineStore
-  const effectScope: typeof import('vue').effectScope
-  const getActivePinia: typeof import('pinia').getActivePinia
-  const getCurrentInstance: typeof import('vue').getCurrentInstance
-  const getCurrentScope: typeof import('vue').getCurrentScope
-  const getCurrentWatcher: typeof import('vue').getCurrentWatcher
-  const h: typeof import('vue').h
-  const inject: typeof import('vue').inject
-  const isProxy: typeof import('vue').isProxy
-  const isReactive: typeof import('vue').isReactive
-  const isReadonly: typeof import('vue').isReadonly
-  const isRef: typeof import('vue').isRef
-  const isShallow: typeof import('vue').isShallow
-  const mapActions: typeof import('pinia').mapActions
-  const mapGetters: typeof import('pinia').mapGetters
-  const mapState: typeof import('pinia').mapState
-  const mapStores: typeof import('pinia').mapStores
-  const mapWritableState: typeof import('pinia').mapWritableState
-  const markRaw: typeof import('vue').markRaw
-  const nextTick: typeof import('vue').nextTick
-  const onActivated: typeof import('vue').onActivated
-  const onBeforeMount: typeof import('vue').onBeforeMount
-  const onBeforeRouteLeave: typeof import('vue-router').onBeforeRouteLeave
-  const onBeforeRouteUpdate: typeof import('vue-router').onBeforeRouteUpdate
-  const onBeforeUnmount: typeof import('vue').onBeforeUnmount
-  const onBeforeUpdate: typeof import('vue').onBeforeUpdate
-  const onDeactivated: typeof import('vue').onDeactivated
-  const onErrorCaptured: typeof import('vue').onErrorCaptured
-  const onMounted: typeof import('vue').onMounted
-  const onRenderTracked: typeof import('vue').onRenderTracked
-  const onRenderTriggered: typeof import('vue').onRenderTriggered
-  const onScopeDispose: typeof import('vue').onScopeDispose
-  const onServerPrefetch: typeof import('vue').onServerPrefetch
-  const onUnmounted: typeof import('vue').onUnmounted
-  const onUpdated: typeof import('vue').onUpdated
-  const onWatcherCleanup: typeof import('vue').onWatcherCleanup
-  const provide: typeof import('vue').provide
-  const reactive: typeof import('vue').reactive
-  const readonly: typeof import('vue').readonly
-  const ref: typeof import('vue').ref
-  const resolveComponent: typeof import('vue').resolveComponent
-  const setActivePinia: typeof import('pinia').setActivePinia
-  const setMapStoreSuffix: typeof import('pinia').setMapStoreSuffix
-  const shallowReactive: typeof import('vue').shallowReactive
-  const shallowReadonly: typeof import('vue').shallowReadonly
-  const shallowRef: typeof import('vue').shallowRef
-  const storeToRefs: typeof import('pinia').storeToRefs
-  const toRaw: typeof import('vue').toRaw
-  const toRef: typeof import('vue').toRef
-  const toRefs: typeof import('vue').toRefs
-  const toValue: typeof import('vue').toValue
-  const triggerRef: typeof import('vue').triggerRef
-  const unref: typeof import('vue').unref
-  const useAttrs: typeof import('vue').useAttrs
-  const useCssModule: typeof import('vue').useCssModule
-  const useCssVars: typeof import('vue').useCssVars
-  const useGlobal: typeof import('../plugins/global').useGlobal
-  const useId: typeof import('vue').useId
-  const useModel: typeof import('vue').useModel
-  const useRoute: typeof import('vue-router').useRoute
-  const useRouter: typeof import('vue-router').useRouter
-  const useSlots: typeof import('vue').useSlots
-  const useTemplateRef: typeof import('vue').useTemplateRef
-  const watch: typeof import('vue').watch
-  const watchEffect: typeof import('vue').watchEffect
-  const watchPostEffect: typeof import('vue').watchPostEffect
-  const watchSyncEffect: typeof import('vue').watchSyncEffect
-}
-// for type re-export
-declare global {
-  // @ts-ignore
-  export type { Component, Slot, Slots, ComponentPublicInstance, ComputedRef, DirectiveBinding, ExtractDefaultPropTypes, ExtractPropTypes, ExtractPublicPropTypes, InjectionKey, PropType, Ref, ShallowRef, MaybeRef, MaybeRefOrGetter, VNode, WritableComputedRef } from 'vue'
-  import('vue')
-  // @ts-ignore
-  export type { BeflyAdminConfig } from '../plugins/config'
-  import('../plugins/config')
-  // @ts-ignore
-  export type { HttpApiResponse, HttpCleanParamsOptions, HttpClientOptions, HttpGetData, HttpPostData } from '../plugins/http'
-  import('../plugins/http')
-}
-
-// for vue template auto import
-import { UnwrapRef } from 'vue'
-declare module 'vue' {
-  interface GlobalComponents {}
-  interface ComponentCustomProperties {
-    readonly $Config: UnwrapRef<typeof import('../plugins/config')['$Config']>
-    readonly $Http: UnwrapRef<typeof import('../plugins/http')['$Http']>
-    readonly $Router: UnwrapRef<typeof import('../plugins/router')['$Router']>
-    readonly $Storage: UnwrapRef<typeof import('../plugins/storage')['$Storage']>
-    readonly EffectScope: UnwrapRef<typeof import('vue')['EffectScope']>
-    readonly acceptHMRUpdate: UnwrapRef<typeof import('pinia')['acceptHMRUpdate']>
-    readonly computed: UnwrapRef<typeof import('vue')['computed']>
-    readonly createApp: UnwrapRef<typeof import('vue')['createApp']>
-    readonly createPinia: UnwrapRef<typeof import('pinia')['createPinia']>
-    readonly customRef: UnwrapRef<typeof import('vue')['customRef']>
-    readonly defineAsyncComponent: UnwrapRef<typeof import('vue')['defineAsyncComponent']>
-    readonly defineComponent: UnwrapRef<typeof import('vue')['defineComponent']>
-    readonly definePage: UnwrapRef<typeof import('vue-router/experimental')['definePage']>
-    readonly defineStore: UnwrapRef<typeof import('pinia')['defineStore']>
-    readonly effectScope: UnwrapRef<typeof import('vue')['effectScope']>
-    readonly getActivePinia: UnwrapRef<typeof import('pinia')['getActivePinia']>
-    readonly getCurrentInstance: UnwrapRef<typeof import('vue')['getCurrentInstance']>
-    readonly getCurrentScope: UnwrapRef<typeof import('vue')['getCurrentScope']>
-    readonly getCurrentWatcher: UnwrapRef<typeof import('vue')['getCurrentWatcher']>
-    readonly h: UnwrapRef<typeof import('vue')['h']>
-    readonly inject: UnwrapRef<typeof import('vue')['inject']>
-    readonly isProxy: UnwrapRef<typeof import('vue')['isProxy']>
-    readonly isReactive: UnwrapRef<typeof import('vue')['isReactive']>
-    readonly isReadonly: UnwrapRef<typeof import('vue')['isReadonly']>
-    readonly isRef: UnwrapRef<typeof import('vue')['isRef']>
-    readonly isShallow: UnwrapRef<typeof import('vue')['isShallow']>
-    readonly mapActions: UnwrapRef<typeof import('pinia')['mapActions']>
-    readonly mapGetters: UnwrapRef<typeof import('pinia')['mapGetters']>
-    readonly mapState: UnwrapRef<typeof import('pinia')['mapState']>
-    readonly mapStores: UnwrapRef<typeof import('pinia')['mapStores']>
-    readonly mapWritableState: UnwrapRef<typeof import('pinia')['mapWritableState']>
-    readonly markRaw: UnwrapRef<typeof import('vue')['markRaw']>
-    readonly nextTick: UnwrapRef<typeof import('vue')['nextTick']>
-    readonly onActivated: UnwrapRef<typeof import('vue')['onActivated']>
-    readonly onBeforeMount: UnwrapRef<typeof import('vue')['onBeforeMount']>
-    readonly onBeforeRouteLeave: UnwrapRef<typeof import('vue-router')['onBeforeRouteLeave']>
-    readonly onBeforeRouteUpdate: UnwrapRef<typeof import('vue-router')['onBeforeRouteUpdate']>
-    readonly onBeforeUnmount: UnwrapRef<typeof import('vue')['onBeforeUnmount']>
-    readonly onBeforeUpdate: UnwrapRef<typeof import('vue')['onBeforeUpdate']>
-    readonly onDeactivated: UnwrapRef<typeof import('vue')['onDeactivated']>
-    readonly onErrorCaptured: UnwrapRef<typeof import('vue')['onErrorCaptured']>
-    readonly onMounted: UnwrapRef<typeof import('vue')['onMounted']>
-    readonly onRenderTracked: UnwrapRef<typeof import('vue')['onRenderTracked']>
-    readonly onRenderTriggered: UnwrapRef<typeof import('vue')['onRenderTriggered']>
-    readonly onScopeDispose: UnwrapRef<typeof import('vue')['onScopeDispose']>
-    readonly onServerPrefetch: UnwrapRef<typeof import('vue')['onServerPrefetch']>
-    readonly onUnmounted: UnwrapRef<typeof import('vue')['onUnmounted']>
-    readonly onUpdated: UnwrapRef<typeof import('vue')['onUpdated']>
-    readonly onWatcherCleanup: UnwrapRef<typeof import('vue')['onWatcherCleanup']>
-    readonly provide: UnwrapRef<typeof import('vue')['provide']>
-    readonly reactive: UnwrapRef<typeof import('vue')['reactive']>
-    readonly readonly: UnwrapRef<typeof import('vue')['readonly']>
-    readonly ref: UnwrapRef<typeof import('vue')['ref']>
-    readonly resolveComponent: UnwrapRef<typeof import('vue')['resolveComponent']>
-    readonly setActivePinia: UnwrapRef<typeof import('pinia')['setActivePinia']>
-    readonly setMapStoreSuffix: UnwrapRef<typeof import('pinia')['setMapStoreSuffix']>
-    readonly shallowReactive: UnwrapRef<typeof import('vue')['shallowReactive']>
-    readonly shallowReadonly: UnwrapRef<typeof import('vue')['shallowReadonly']>
-    readonly shallowRef: UnwrapRef<typeof import('vue')['shallowRef']>
-    readonly storeToRefs: UnwrapRef<typeof import('pinia')['storeToRefs']>
-    readonly toRaw: UnwrapRef<typeof import('vue')['toRaw']>
-    readonly toRef: UnwrapRef<typeof import('vue')['toRef']>
-    readonly toRefs: UnwrapRef<typeof import('vue')['toRefs']>
-    readonly toValue: UnwrapRef<typeof import('vue')['toValue']>
-    readonly triggerRef: UnwrapRef<typeof import('vue')['triggerRef']>
-    readonly unref: UnwrapRef<typeof import('vue')['unref']>
-    readonly useAttrs: UnwrapRef<typeof import('vue')['useAttrs']>
-    readonly useCssModule: UnwrapRef<typeof import('vue')['useCssModule']>
-    readonly useCssVars: UnwrapRef<typeof import('vue')['useCssVars']>
-    readonly useGlobal: UnwrapRef<typeof import('../plugins/global')['useGlobal']>
-    readonly useId: UnwrapRef<typeof import('vue')['useId']>
-    readonly useModel: UnwrapRef<typeof import('vue')['useModel']>
-    readonly useRoute: UnwrapRef<typeof import('vue-router')['useRoute']>
-    readonly useRouter: UnwrapRef<typeof import('vue-router')['useRouter']>
-    readonly useSlots: UnwrapRef<typeof import('vue')['useSlots']>
-    readonly useTemplateRef: UnwrapRef<typeof import('vue')['useTemplateRef']>
-    readonly watch: UnwrapRef<typeof import('vue')['watch']>
-    readonly watchEffect: UnwrapRef<typeof import('vue')['watchEffect']>
-    readonly watchPostEffect: UnwrapRef<typeof import('vue')['watchPostEffect']>
-    readonly watchSyncEffect: UnwrapRef<typeof import('vue')['watchSyncEffect']>
-  }
-}

package/src/types/components.d.ts

@@ -1,20 +0,0 @@
-/* eslint-disable */
-// @ts-nocheck
-// biome-ignore lint: disable
-// oxlint-disable
-// ------
-// Generated by unplugin-vue-components
-// Read more: https://github.com/vuejs/core/pull/3399
-
-export {}
-
-/* prettier-ignore */
-declare module 'vue' {
-  export interface GlobalComponents {
-    DetailPanel: typeof import('./../components/detailPanel.vue')['default']
-    PageDialog: typeof import('./../components/pageDialog.vue')['default']
-    PagedTableDetail: typeof import('./../components/pagedTableDetail.vue')['default']
-    RouterLink: typeof import('vue-router')['RouterLink']
-    RouterView: typeof import('vue-router')['RouterView']
-  }
-}