@cloudcome/utils-vue 1.1.0 → 1.3.0

package/test/async.test.ts

@@ -0,0 +1,104 @@
+import { promiseDelay } from '@cloudcome/utils-core/promise';
+import { describe, expect, it, vi } from 'vitest';
+import { ref } from 'vue';
+import { useAsync } from '../src/async';
+
+describe('useAsync 组合式函数', () => {
+  const mockAsyncFn = vi.fn();
+  const mockOptions = {
+    onBefore: vi.fn(),
+    onSuccess: vi.fn(),
+    onError: vi.fn(),
+    onAfter: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+  });
+
+  it('应该正确处理异步操作', async () => {
+    const mockData = { id: 1 };
+    mockAsyncFn.mockResolvedValue(mockData);
+    const { loading, data, error, runAsync } = useAsync(mockAsyncFn, mockOptions);
+
+    const promise = runAsync('test');
+    expect(loading.value).toBe(true);
+    expect(mockOptions.onBefore).toHaveBeenCalled();
+
+    await promise;
+    expect(loading.value).toBe(false);
+    expect(data.value).toEqual(mockData);
+    expect(error.value).toBeNull();
+    expect(mockOptions.onSuccess).toHaveBeenCalledWith(mockData, 'test');
+    expect(mockOptions.onAfter).toHaveBeenCalled();
+  });
+
+  it('应该处理异步操作失败', async () => {
+    const mockError = new Error('test error');
+    mockAsyncFn.mockRejectedValue(mockError);
+    const { loading, error, runAsync } = useAsync(mockAsyncFn, mockOptions);
+
+    await expect(runAsync('test1', 'test2')).rejects.toThrow(mockError);
+    expect(loading.value).toBe(false);
+    expect(error.value).toEqual(mockError);
+    expect(mockOptions.onError).toHaveBeenCalledWith(mockError, 'test1', 'test2');
+    expect(mockOptions.onAfter).toHaveBeenCalled();
+  });
+
+  it('应该支持 run 方法', async () => {
+    const mockData = { id: 1 };
+    mockAsyncFn.mockResolvedValue(mockData);
+    const { run } = useAsync(mockAsyncFn);
+
+    run('test');
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(mockAsyncFn).toHaveBeenCalledWith('test');
+  });
+
+  it('应该正确处理run方法的返回值', async () => {
+    const mockData = { id: 1 };
+    mockAsyncFn.mockResolvedValue(mockData);
+    const { run } = useAsync(mockAsyncFn);
+
+    const result = await new Promise((resolve) => {
+      run('test');
+      setTimeout(() => resolve(mockAsyncFn.mock.results[0].value), 0);
+    });
+
+    expect(result).toEqual(mockData);
+  });
+
+  it('应该正确处理空options的情况', async () => {
+    const mockData = { id: 1 };
+    mockAsyncFn.mockResolvedValue(mockData);
+    const { loading, data, runAsync } = useAsync(mockAsyncFn);
+
+    await runAsync('test');
+    expect(loading.value).toBe(false);
+    expect(data.value).toEqual(mockData);
+  });
+
+  it('应该正确处理参数传递', async () => {
+    const mockData = { id: 1 };
+    mockAsyncFn.mockResolvedValue(mockData);
+    const { runAsync } = useAsync(mockAsyncFn);
+
+    const args = ['arg1', 2, { key: 'value' }];
+    await runAsync(...args);
+    expect(mockAsyncFn).toHaveBeenCalledWith(...args);
+  });
+
+  it('应该正确处理多次调用', async () => {
+    const mockData1 = { id: 1 };
+    const mockData2 = { id: 2 };
+    mockAsyncFn.mockResolvedValueOnce(mockData1).mockResolvedValueOnce(mockData2);
+    const { data, runAsync } = useAsync(mockAsyncFn);
+
+    await runAsync('first');
+    expect(data.value).toEqual(mockData1);
+
+    await runAsync('second');
+    expect(data.value).toEqual(mockData2);
+  });
+});

package/test/component.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest';
+import { ref } from 'vue';
+import { useEmit, useExpose } from '../src/component';
+
+describe('组件工具函数', () => {
+  describe('useExpose', () => {
+    it('应该创建一个可响应式访问的组件实例引用', () => {
+      const TestComponent = {
+        setup() {
+          defineExpose({
+            testMethod() {
+              return 'test';
+            },
+          });
+        },
+      };
+
+      const compRef = useExpose(TestComponent);
+      expect(compRef.value).toBeNull();
+
+      compRef.value = { testMethod: () => 'mocked' };
+      // @ts-ignore
+      expect(compRef.value?.testMethod()).toBe('mocked');
+    });
+  });
+
+  describe('useEmit', () => {
+    it('应该正确返回事件监听函数', () => {
+      const TestComponent = {
+        props: {
+          onClick: Function,
+        },
+      };
+
+      const mockListener = vi.fn();
+      // @ts-ignore
+      const result = useEmit(TestComponent, 'click', mockListener);
+
+      expect(result).toBe(mockListener);
+      // @ts-ignore
+      result();
+      expect(mockListener).toHaveBeenCalledTimes(1);
+    });
+
+    it('应该正确处理带参数的emit事件', () => {
+      const TestComponent = {
+        props: {
+          onChange: Function,
+        },
+      };
+
+      const mockListener = vi.fn();
+      // @ts-ignore
+      const result = useEmit(TestComponent, 'change', mockListener);
+
+      // @ts-ignore
+      result(1, 'test');
+      expect(mockListener).toHaveBeenCalledWith(1, 'test');
+    });
+  });
+});

package/test/event.test.ts

@@ -0,0 +1,109 @@
+import { mount } from '@vue/test-utils';
+import { describe, expect, it, vi } from 'vitest';
+import { createEventHook } from '../src/event';
+
+describe('createEventCenter 事件中心', () => {
+  // 定义测试事件类型
+  type TestEvents = {
+    'test-event': [string, number];
+    'another-event': [boolean];
+  };
+
+  it('应该正确创建事件中心实例', () => {
+    const eventCenter = createEventHook<TestEvents>();
+
+    expect(eventCenter).toBeDefined();
+    expect(typeof eventCenter.on).toBe('function');
+    expect(typeof eventCenter.off).toBe('function');
+    expect(typeof eventCenter.emit).toBe('function');
+    expect(typeof eventCenter.useEvent).toBe('function');
+  });
+
+  it('应该正确注册和触发事件', () => {
+    const eventCenter = createEventHook<TestEvents>();
+    const mockListener = vi.fn();
+
+    eventCenter.on('test-event', mockListener);
+    eventCenter.emit('test-event', 'hello', 123);
+
+    expect(mockListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).toHaveBeenCalledWith('hello', 123);
+  });
+
+  it('应该正确取消事件监听', () => {
+    const eventCenter = createEventHook<TestEvents>();
+    const mockListener = vi.fn();
+
+    eventCenter.on('test-event', mockListener);
+    eventCenter.off('test-event', mockListener);
+    eventCenter.emit('test-event', 'hello', 123);
+
+    expect(mockListener).not.toHaveBeenCalled();
+  });
+
+  it('应该正确处理 useEventCenter 在 mount 阶段', async () => {
+    const eventCenter = createEventHook<TestEvents>({ stage: 'mount' });
+    const mockListener = vi.fn();
+    const wrapper = mount({
+      template: '<div>test</div>',
+      setup() {
+        eventCenter.useEvent('another-event', mockListener);
+      },
+    });
+
+    await wrapper.vm.$nextTick();
+
+    eventCenter.emit('another-event', true);
+
+    expect(mockListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).toHaveBeenCalledWith(true);
+
+    wrapper.unmount();
+
+    eventCenter.emit('another-event', false);
+    expect(mockListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).toHaveBeenCalledWith(true);
+  });
+
+  it('应该正确处理 useEventCenter 在 mounted 阶段', async () => {
+    const eventCenter = createEventHook<TestEvents>({ stage: 'mounted' });
+    const mockListener = vi.fn();
+    const wrapper = mount({
+      template: '<div>test</div>',
+      setup() {
+        eventCenter.useEvent('another-event', mockListener);
+      },
+    });
+
+    await wrapper.vm.$nextTick();
+
+    eventCenter.emit('another-event', true);
+
+    expect(mockListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).toHaveBeenCalledWith(true);
+
+    wrapper.unmount();
+
+    eventCenter.emit('another-event', false);
+    expect(mockListener).toHaveBeenCalledTimes(1);
+    expect(mockListener).toHaveBeenCalledWith(true);
+  });
+
+  it('应该支持自定义事件发射器', () => {
+    const customEmitter = {
+      on: vi.fn(),
+      off: vi.fn(),
+      emit: vi.fn(),
+    };
+    const eventCenter = createEventHook<TestEvents>({ emitter: customEmitter });
+
+    const mockListener = vi.fn();
+    eventCenter.on('test-event', mockListener);
+    eventCenter.emit('test-event', 'hello', 123);
+    eventCenter.off('test-event', mockListener);
+
+    expect(customEmitter.on).toHaveBeenCalled();
+    expect(customEmitter.emit).toHaveBeenCalled();
+    expect(customEmitter.off).toHaveBeenCalled();
+  });
+});

package/test/index.test.ts

@@ -0,0 +1,6 @@
+import { VERSION } from '@/index';
+import { expect, it } from 'vitest';
+
+it('version', () => {
+  expect(VERSION).toEqual(PKG_VERSION);
+});

package/test/page.test.ts

@@ -0,0 +1,63 @@
+import { mount } from '@vue/test-utils';
+import { describe, expect, it, vi } from 'vitest';
+import { onBeforeMount, onBeforeUnmount, onMounted } from 'vue';
+import { usePageMount, usePageMounted } from '../src/page';
+
+describe('hook-page', () => {
+  it('应该正确触发 usePageMount 生命周期', async () => {
+    const fn = vi.fn();
+    const cleanup = vi.fn();
+    const beforeMountFn = vi.fn(() => cleanup);
+    const wrapper = mount({
+      template: '<div>test</div>',
+      setup() {
+        onBeforeMount(fn);
+        onBeforeUnmount(fn);
+        usePageMount(beforeMountFn);
+      },
+    });
+
+    await wrapper.vm.$nextTick();
+    expect(beforeMountFn).toHaveBeenCalledTimes(1);
+    wrapper.unmount();
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(cleanup).toHaveBeenCalledTimes(1);
+  });
+
+  it('应该正确触发 usePageMounted 生命周期', async () => {
+    const fn = vi.fn();
+    const cleanup = vi.fn();
+    const mountedFn = vi.fn(() => cleanup);
+    const wrapper = mount({
+      template: '<div>test</div>',
+      setup() {
+        onMounted(fn);
+        onBeforeUnmount(fn);
+        usePageMounted(mountedFn);
+      },
+    });
+
+    await wrapper.vm.$nextTick();
+    expect(mountedFn).toHaveBeenCalledTimes(1);
+    wrapper.unmount();
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(cleanup).toHaveBeenCalledTimes(1);
+  });
+
+  it('应该支持异步回调函数', async () => {
+    const cleanup = vi.fn();
+    const asyncFn = vi.fn(async () => cleanup);
+
+    const wrapper = mount({
+      template: '<div>test</div>',
+      setup() {
+        usePageMount(asyncFn);
+      },
+    });
+
+    await wrapper.vm.$nextTick();
+    expect(asyncFn).toHaveBeenCalledTimes(1);
+    wrapper.unmount();
+    expect(cleanup).toHaveBeenCalledTimes(1);
+  });
+});

package/test/request.test.ts

@@ -0,0 +1,123 @@
+import { useRequest } from '@/request';
+import { MemoryCache } from '@cloudcome/utils-core/cache';
+import { describe, expect, it, vi } from 'vitest';
+
+describe('useRequest 组合式函数', () => {
+  const mockRequestFn = vi.fn();
+  const mockOptions = {
+    onSuccess: vi.fn(),
+    onCacheHit: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    (new MemoryCache() as MemoryCache<unknown>).clear();
+  });
+
+  it('应该正确处理基本请求', async () => {
+    const mockData = { id: 1 };
+    mockRequestFn.mockResolvedValue(mockData);
+    const { loading, data, error, sendAsync } = useRequest(mockRequestFn, mockOptions);
+
+    const promise = sendAsync('test');
+    expect(loading.value).toBe(true);
+
+    await promise;
+    expect(loading.value).toBe(false);
+    expect(data.value).toEqual(mockData);
+    expect(error.value).toBeNull();
+    expect(mockOptions.onSuccess).toHaveBeenCalledWith(mockData, 'test');
+  });
+
+  it('应该处理请求失败', async () => {
+    const mockError = new Error('test error');
+    mockRequestFn.mockRejectedValue(mockError);
+    const { loading, error, sendAsync } = useRequest(mockRequestFn);
+
+    await expect(sendAsync('test')).rejects.toThrow(mockError);
+    expect(loading.value).toBe(false);
+    expect(error.value).toEqual(mockError);
+  });
+
+  it('应该支持缓存功能', async () => {
+    const mockData = { id: 1 };
+    mockRequestFn.mockResolvedValue(mockData);
+    const { hitCache, sendAsync } = useRequest(mockRequestFn, {
+      id: 'test-cache',
+      cache: true,
+      onCacheHit: mockOptions.onCacheHit,
+    });
+
+    await sendAsync('test');
+    expect(hitCache.value).toBe(false);
+    expect(mockOptions.onCacheHit).not.toHaveBeenCalled();
+
+    await sendAsync('test');
+    expect(hitCache.value).toBe(true);
+    expect(mockOptions.onCacheHit).toHaveBeenCalled();
+  });
+
+  it('应该支持共享请求功能', async () => {
+    const mockData = { id: 1 };
+    const fn = vi.fn().mockImplementation(async () => mockData);
+
+    const id = 'test-share';
+    const {
+      hitShare: hs1,
+      sendAsync: sendAsync1,
+      data: data1,
+    } = useRequest(fn, {
+      id,
+      share: true,
+    });
+    const {
+      hitShare: hs2,
+      sendAsync: sendAsync2,
+      data: data2,
+    } = useRequest(fn, {
+      id,
+      share: true,
+    });
+
+    await sendAsync1(1);
+    await sendAsync2(1);
+
+    expect(hs1.value).toBe(false);
+    expect(hs2.value).toBe(true);
+
+    expect(data1.value).toEqual(mockData);
+    expect(data2.value).toEqual(mockData);
+
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('应该支持禁用缓存', async () => {
+    const mockData = { id: 1 };
+    mockRequestFn.mockResolvedValue(mockData);
+    const { hitCache, sendAsync } = useRequest(mockRequestFn, {
+      id: 'test-cache',
+      cache: { disabled: true },
+    });
+
+    await sendAsync('test');
+    await sendAsync('test');
+    expect(hitCache.value).toBe(false);
+    expect(mockRequestFn).toHaveBeenCalledTimes(2);
+  });
+
+  it('应该支持禁用共享请求', async () => {
+    const mockData = { id: 1 };
+    mockRequestFn.mockResolvedValue(mockData);
+    const { hitShare, sendAsync } = useRequest(mockRequestFn, {
+      id: 'test-share',
+      share: { disabled: true },
+    });
+
+    const promise1 = sendAsync('test');
+    const promise2 = sendAsync('test');
+    await Promise.all([promise1, promise2]);
+
+    expect(hitShare.value).toBe(false);
+    expect(mockRequestFn).toHaveBeenCalledTimes(2);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "jsx": "preserve",
+    "jsxImportSource": "vue",
+    "target": "ES2024",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+
+    "strict": true,
+    "noEmit": true,
+    "allowJs": true,
+    "sourceMap": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": false,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+
+    "lib": ["ES2024"],
+    "types": ["node", "vite/client", "vitest/globals"],
+    "plugins": [],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+
+  "include": ["**/*.ts", "**/.*.ts", "**/*.mts", "**/*.tsx", "**/*.vue"],
+  "exclude": []
+}

package/vite.config.mts

@@ -0,0 +1,95 @@
+/**
+ * @file vite.config.mts
+ * @ref https://vitejs.dev/
+ */
+
+import dts from 'vite-plugin-dts';
+import { externalizeDeps } from 'vite-plugin-externalize-deps';
+import tsconfigPaths from 'vite-tsconfig-paths';
+import { defineConfig } from 'vitest/config';
+import pkg from './package.json';
+
+export default defineConfig((env) => {
+  const isProd = env.mode === 'production';
+  const isTest = env.mode === 'test';
+
+  return {
+    base: '/',
+    server: {
+      port: 15170,
+    },
+    preview: {
+      port: 15171,
+    },
+    define: {
+      PKG_NAME: JSON.stringify(isTest ? 'pkg-name-for-test' : pkg.name),
+      PKG_VERSION: JSON.stringify(isTest ? 'pkg-version-for-test' : pkg.version),
+      PKG_DESCRIPTION: JSON.stringify(isTest ? 'pkg-description-for-test' : pkg.description),
+      IS_TEST: JSON.stringify(isTest),
+    },
+    build: {
+      minify: false,
+      sourcemap: true,
+      copyPublicDir: false,
+      reportCompressedSize: false,
+      lib: {
+        entry:
+          // expose-start
+          {
+            index: 'src/index.ts',
+            async: './src/async.ts',
+            component: './src/component.ts',
+            event: './src/event.ts',
+            page: './src/page.ts',
+            request: './src/request.ts',
+          },
+        // expose-end
+      },
+      rollupOptions: {
+        output: [
+          {
+            format: 'esm',
+            entryFileNames: '[name].mjs',
+            chunkFileNames: '[name].mjs',
+          },
+          {
+            format: 'cjs',
+            entryFileNames: '[name].cjs',
+            chunkFileNames: '[name].cjs',
+          },
+        ],
+      },
+    },
+    test: {
+      globals: true,
+      environment: 'jsdom',
+      environmentOptions: {
+        jsdom: {
+          // 加载外部资源
+          resources: 'usable',
+        },
+      },
+      coverage: {
+        all: true,
+        include: ['src/**/*.ts'],
+        reporter: ['lcov', 'text'],
+      },
+    },
+    // esbuild: {
+    //   drop: isProd ? ['console', 'debugger'] : [],
+    // },
+    plugins: [
+      tsconfigPaths(),
+      externalizeDeps({
+        deps: true,
+        devDeps: true,
+        peerDeps: true,
+        optionalDeps: true,
+        nodeBuiltins: true,
+      }),
+      dts({
+        include: 'src',
+      }),
+    ],
+  };
+});

package/dist/async.cjs

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("@cloudcome/utils-core/type");
-const vue = require("vue");
-function useAsync(fn, options) {
-  const loading = vue.ref(false);
-  const data = vue.ref(null);
-  const error = vue.ref(null);
-  const runAsync = async (...inputs) => {
-    var _a, _b, _c, _d;
-    loading.value = true;
-    error.value = null;
-    try {
-      (_a = options == null ? void 0 : options.onBefore) == null ? void 0 : _a.call(options, ...inputs);
-      data.value = await fn(...inputs);
-      (_b = options == null ? void 0 : options.onSuccess) == null ? void 0 : _b.call(options, data.value);
-      return data.value;
-    } catch (err) {
-      error.value = err;
-      (_c = options == null ? void 0 : options.onError) == null ? void 0 : _c.call(options, err);
-      throw err;
-    } finally {
-      loading.value = false;
-      (_d = options == null ? void 0 : options.onAfter) == null ? void 0 : _d.call(options, ...inputs);
-    }
-  };
-  const run = (...inputs) => {
-    runAsync(...inputs).then();
-  };
-  return {
-    /**
-     * 是否正在加载。
-     */
-    loading,
-    /**
-     * 异步操作返回的数据。
-     */
-    data,
-    /**
-     * 异步操作抛出的错误。
-     */
-    error,
-    /**
-     * 执行异步操作并返回 Promise。
-     * @param inputs 异步函数的参数。
-     * @returns 异步操作的结果。
-     */
-    runAsync,
-    /**
-     * 执行异步操作但不返回 Promise。
-     * @param inputs 异步函数的参数。
-     */
-    run
-  };
-}
-exports.useAsync = useAsync;
-//# sourceMappingURL=async.cjs.map

package/dist/async.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"async.cjs","sources":["../src/async.ts"],"sourcesContent":["import { isFunction, isNullish } from '@cloudcome/utils-core/type';\nimport type { AnyArray, MaybeCallable } from '@cloudcome/utils-core/types';\nimport { type Ref, nextTick } from 'vue';\nimport { onMounted, ref } from 'vue';\n\n/**\n * 异步操作的配置选项\n * @template T 异步操作返回的数据类型\n * @template P 异步操作的参数类型\n */\nexport type TUseAsyncOptions<I extends AnyArray, O> = {\n  /**\n   * 异步操作开始前的回调函数。\n   * 可用于执行初始化逻辑或显示加载状态。\n   */\n  onBefore?: (...inputs: I) => unknown;\n\n  /**\n   * 异步操作成功后的回调函数。\n   * @param data 异步操作返回的数据。\n   * 可用于处理成功后的数据更新或通知。\n   */\n  onSuccess?: (data: O) => unknown;\n\n  /**\n   * 异步操作失败后的回调函数。\n   * @param err 异步操作抛出的错误。\n   * 可用于记录错误日志或显示错误提示。\n   */\n  onError?: (err: unknown) => unknown;\n\n  /**\n   * 异步操作结束后的回调函数（无论成功或失败）。\n   * 可用于清理操作或触发后续逻辑。\n   */\n  onAfter?: (...inputs: I) => unknown;\n};\n\nexport type TUseAsyncReturns<I extends AnyArray, O> = {\n  loading: Ref<boolean>;\n  data: Ref<O | null>;\n  error: Ref<unknown>;\n  run: (...inputs: I) => void;\n  runAsync: (...inputs: I) => Promise<O>;\n};\n\n/**\n * 用于处理异步操作的组合式函数。\n * 提供加载状态、数据、错误信息以及执行方法。\n * @template O 异步函数返回的数据类型\n * @template I 异步函数的入参类型\n * @param fn 异步函数，接收参数并返回 Promise。\n * @param options 异步操作的配置选项。\n * @returns 包含状态和操作方法的对象：\n * - loading: 是否正在加载。\n * - data: 异步操作返回的数据。\n * - error: 异步操作抛出的错误。\n * - runAsync: 执行异步操作并返回 Promise。\n * - run: 执行异步操作但不返回 Promise。\n * @example\n * const { loading, data, error, runAsync, run } = useAsync(async (id: number) => {\n *   const response = await fetch(`/api/user/${id}`);\n *   return response.json();\n * }, {\n *   onBefore: () => console.log('Fetching user data...'),\n *   onSuccess: (data) => console.log('User data fetched:', data),\n *   onError: (err) => console.error('Failed to fetch user data:', err),\n *   onFinally: () => console.log('Fetch operation completed.'),\n * });\n */\nexport function useAsync<I extends AnyArray, O>(\n  fn: (...inputs: I) => Promise<O>,\n  options?: TUseAsyncOptions<I, O>,\n): TUseAsyncReturns<I, O> {\n  const loading = ref(false);\n  const data = ref<O | null>(null) as Ref<O | null>;\n  const error = ref<unknown>(null);\n\n  const runAsync = async (...inputs: I): Promise<O> => {\n    loading.value = true;\n    error.value = null;\n\n    try {\n      options?.onBefore?.(...inputs);\n      data.value = await fn(...inputs);\n      options?.onSuccess?.(data.value);\n      return data.value;\n    } catch (err) {\n      error.value = err;\n      options?.onError?.(err);\n      throw err;\n    } finally {\n      loading.value = false;\n      options?.onAfter?.(...inputs);\n    }\n  };\n\n  const run = (...inputs: I) => {\n    runAsync(...inputs).then();\n  };\n\n  return {\n    /**\n     * 是否正在加载。\n     */\n    loading,\n\n    /**\n     * 异步操作返回的数据。\n     */\n    data,\n\n    /**\n     * 异步操作抛出的错误。\n     */\n    error,\n\n    /**\n     * 执行异步操作并返回 Promise。\n     * @param inputs 异步函数的参数。\n     * @returns 异步操作的结果。\n     */\n    runAsync,\n\n    /**\n     * 执行异步操作但不返回 Promise。\n     * @param inputs 异步函数的参数。\n     */\n    run,\n  };\n}\n\n// const { run: run1 } = useAsync(() => Promise.resolve(1));\n// run1();\n\n// const { run: run2 } = useAsync((a: number) => Promise.resolve(1));\n// run2(2);\n\n// const { run: run3 } = useAsync((a: number, b: string) => Promise.resolve(1));\n// run3(2, '2');\n"],"names":["ref"],"mappings":";;;;AAsEgB,SAAA,SACd,IACA,SACwB;AAClB,QAAA,UAAUA,QAAI,KAAK;AACnB,QAAA,OAAOA,QAAc,IAAI;AACzB,QAAA,QAAQA,QAAa,IAAI;AAEzB,QAAA,WAAW,UAAU,WAA0B;;AACnD,YAAQ,QAAQ;AAChB,UAAM,QAAQ;AAEV,QAAA;AACO,+CAAA,aAAA,iCAAW,GAAG;AACvB,WAAK,QAAQ,MAAM,GAAG,GAAG,MAAM;AACtB,+CAAA,cAAA,iCAAY,KAAK;AAC1B,aAAO,KAAK;AAAA,aACL,KAAK;AACZ,YAAM,QAAQ;AACd,+CAAS,YAAT,iCAAmB;AACb,YAAA;AAAA,IAAA,UACN;AACA,cAAQ,QAAQ;AACP,+CAAA,YAAA,iCAAU,GAAG;AAAA,IAAM;AAAA,EAEhC;AAEM,QAAA,MAAM,IAAI,WAAc;AACnB,aAAA,GAAG,MAAM,EAAE,KAAK;AAAA,EAC3B;AAEO,SAAA;AAAA;AAAA;AAAA;AAAA,IAIL;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA,IAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAOA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMA;AAAA,EACF;AACF;;"}