@cloudcome/utils-vue 1.3.0 → 1.3.1

package/src/request.ts

@@ -1,200 +0,0 @@
-import { MemoryCache, type TCache, type TCacheOptions, type TCached } from '@cloudcome/utils-core/cache';
-import type { TDateValue } from '@cloudcome/utils-core/date';
-import { isFunction, isObject } from '@cloudcome/utils-core/type';
-import type { AnyArray, MaybeCallable, MaybePromise } from '@cloudcome/utils-core/types';
-import type { ComputedRef, Ref } from 'vue';
-import { computed, ref } from 'vue';
-import { type TUseAsyncOptions, type TUseAsyncReturns, type TUseAsyncState, useAsync } from './async';
-
-/**
- * 请求缓存配置选项。
- * @template T 缓存数据的类型。
- */
-export type TRequestCacheOptions<T> = TCacheOptions & {
-  /**
-   * 是否禁用缓存，默认为 false。
-   * 如果设置为 true，则不会使用缓存。
-   */
-  disabled?: boolean;
-
-  /**
-   * 自定义缓存存储实现。
-   * 可以传入自定义的缓存类来替代默认的内存缓存。
-   */
-  storage?: TCache<T>;
-};
-
-export type TRequestShareOptions = {
-  /**
-   * 是否禁用共享请求，默认为 false。
-   * 如果设置为 true，则不会共享请求结果。
-   */
-  disabled?: boolean;
-
-  /**
-   * 共享的最大时长（毫秒），为 0 时表示永久共享。
-   * 超过该时长后，共享的请求结果将被清除。
-   */
-  maxAge?: number;
-
-  /**
-   * 共享的过期时间（时间戳、日期字符串、日期对象等）。
-   * 优先级比 maxAge 更高，指定具体的过期时间。
-   */
-  expiredAt?: TDateValue;
-};
-
-export type TRetryOptions = {
-  /**
-   * 是否禁用共享请求，默认为 false。
-   * 如果设置为 true，则不会重试。
-   */
-  disabled?: boolean;
-};
-
-/**
- * 请求选项，扩展了异步操作的选项。
- * @template T 请求返回的数据类型。
- * @template I 请求参数的类型。
- */
-export type TRequestOptions<I extends AnyArray, O> = TUseAsyncOptions<I, O> & {
-  /**
-   * 请求的唯一标识符，可以是字符串或函数返回的字符串。
-   * 用于缓存和共享的键值。
-   */
-  id?: MaybeCallable<string>;
-
-  /**
-   * 缓存配置，可以是布尔值或完整的缓存选项。
-   * 如果为 true，则启用默认缓存；如果为对象，则可以自定义缓存行为。
-   */
-  cache?: boolean | TRequestCacheOptions<O>;
-
-  /**
-   * 共享配置，可以是布尔值或完整的共享选项。
-   * 共享时，相同的请求 ID 会复用第一次发出且没有响应完成的请求。
-   *
-   * 例如，10 组件同时或先后发起 10 次请求用于获取用户信息，
-   * 那么这 10 个组件会共同等待第一次发起的请求，直到完成。
-   *
-   * 共享与缓存是不同的概念，共享是进行时，缓存是过去时，即：
-   * - 共享是共享**正在发送**的请求
-   * - 缓存是缓存**已经发送**的请求
-   *
-   * 如果为 true，则启用默认共享；如果为对象，则可以自定义共享行为。
-   */
-  share?: boolean | TRequestShareOptions;
-
-  /**
-   * 当命中缓存时的回调函数。
-   * 在缓存命中时触发，接收缓存的数据作为参数。
-   */
-  onCacheHit?: (cached: TCached<O>) => unknown;
-};
-
-export type TUseRequestState<O> = TUseAsyncState<O> & {
-  /**
-   * 是否命中共享数据
-   */
-  hitShare: boolean;
-
-  /**
-   * 是否命中缓存
-   */
-  hitCache: boolean;
-};
-export type TUseRequestReturns<I extends AnyArray, O> = Omit<TUseAsyncReturns<I, O>, 'run' | 'runAsync' | 'state'> & {
-  state: ComputedRef<TUseRequestState<O>>;
-  send: (...inputs: I) => void;
-  sendAsync: (...inputs: I) => Promise<O>;
-  hitShare: Ref<boolean>;
-  hitCache: Ref<boolean>;
-};
-
-const defaultCacheStorage = new MemoryCache();
-const defaultShareStorage = new MemoryCache();
-
-/**
- * 使用请求功能的组合式函数。
- * 支持缓存和异步操作的封装。
- *
- * @template O 请求返回的数据类型。
- * @template I 请求参数的类型。
- * @param {() => Promise<O>} fn 实际的请求函数，返回一个 Promise。
- * @param {TRequestOptions<I, O>} [options] 请求选项，包括缓存和回调配置。
- * @returns 返回一个对象，包含以下内容：
- * - 异步操作的状态（如 loading、error 等）。
- * - 是否命中缓存（hitCache）。
- * - 是否命中共享请求（hitShare）。
- */
-export function useRequest<I extends AnyArray, O>(
-  fn: (...inputs: I) => Promise<O>,
-  options?: TRequestOptions<I, O>,
-): TUseRequestReturns<I, O> {
-  const { id, cache, share, onCacheHit, onSuccess } = options || {};
-
-  const shareStorage = defaultShareStorage as MemoryCache<Promise<O>>;
-  const shareAble = isObject(share) ? !share.disabled : share;
-  const shareOptions = isObject(share) ? share : {};
-  const hitShare = ref(false);
-
-  const _cached = defaultCacheStorage as TCache<O>;
-  const cacheStorage = isObject(cache) ? cache.storage || _cached : _cached;
-  const cacheAble = isObject(cache) ? !cache.disabled : cache;
-  const cacheOptions = isObject(cache) ? cache : {};
-  const hitCache = ref(false);
-
-  const cacheableFn = async (...inputs: I) => {
-    const requestId = isFunction(id) ? id() : id;
-
-    if (requestId && shareAble) {
-      const shared = shareStorage.get(requestId);
-      if (shared) {
-        hitShare.value = true;
-        return await shared.data;
-      }
-    }
-
-    if (requestId && cacheAble) {
-      const cached = await cacheStorage.get(requestId);
-
-      if (cached) {
-        const data = cached.data;
-        hitCache.value = true;
-        onCacheHit?.(cached);
-        onSuccess?.(data, ...inputs);
-        return data;
-      }
-    }
-
-    const promise = fn(...inputs);
-
-    if (requestId && shareAble) {
-      shareStorage.set(requestId, promise, shareOptions);
-    }
-
-    const data = await promise;
-
-    if (requestId && cacheAble) {
-      cacheStorage.set(requestId, data, cacheOptions);
-    }
-
-    return data;
-  };
-  const { state: asyncState, run: send, runAsync: sendAsync, ...async } = useAsync(cacheableFn, options);
-
-  const state = computed(() => ({
-    ...asyncState.value,
-    hitShare: hitShare.value,
-    hitCache: hitCache.value,
-  }));
-
-  return {
-    ...async,
-    state,
-    send,
-    sendAsync,
-    hitShare,
-    hitCache,
-  };
-}

package/test/async.test.ts

@@ -1,104 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,109 +0,0 @@
-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

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

package/test/page.test.ts

@@ -1,63 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,31 +0,0 @@
-{
-  "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": []
-}