@vpmedia/simplify 1.74.0 → 1.76.0

package/src/logging/{const.js → const.ts}

@@ -12,7 +12,7 @@ export const LOG_LEVEL_NAME_WARNING = 'warning';
 export const LOG_LEVEL_NAME_INFO = 'info';
 export const LOG_LEVEL_NAME_DEBUG = 'debug';
 
-export const LOG_LEVEL_NAMES = [
+export const LOG_LEVEL_NAMES: readonly string[] = [
   LOG_LEVEL_NAME_SILENT,
   LOG_LEVEL_NAME_FATAL,
   LOG_LEVEL_NAME_ERROR,

package/src/logging/util.test.ts

@@ -0,0 +1,33 @@
+import {
+  LOG_LEVEL_DEBUG,
+  LOG_LEVEL_ERROR,
+  LOG_LEVEL_FATAL,
+  LOG_LEVEL_INFO,
+  LOG_LEVEL_NAME_DEBUG,
+  LOG_LEVEL_NAME_ERROR,
+  LOG_LEVEL_NAME_FATAL,
+  LOG_LEVEL_NAME_INFO,
+  LOG_LEVEL_NAME_SILENT,
+  LOG_LEVEL_NAME_WARNING,
+  LOG_LEVEL_SILENT,
+  LOG_LEVEL_WARNING,
+} from './const.js';
+import { Logger } from './Logger.js';
+import { formatLogMessage, getLogLevelName } from './util.js';
+
+test('formatLogMessage()', () => {
+  expect(
+    formatLogMessage(new Logger('loggerName'), Date.now(), LOG_LEVEL_INFO, 'logMessage').endsWith(
+      '[loggerName] logMessage'
+    )
+  ).toBe(true);
+});
+
+test('getLogLevelName()', () => {
+  expect(getLogLevelName(LOG_LEVEL_DEBUG)).toBe(LOG_LEVEL_NAME_DEBUG);
+  expect(getLogLevelName(LOG_LEVEL_INFO)).toBe(LOG_LEVEL_NAME_INFO);
+  expect(getLogLevelName(LOG_LEVEL_WARNING)).toBe(LOG_LEVEL_NAME_WARNING);
+  expect(getLogLevelName(LOG_LEVEL_ERROR)).toBe(LOG_LEVEL_NAME_ERROR);
+  expect(getLogLevelName(LOG_LEVEL_FATAL)).toBe(LOG_LEVEL_NAME_FATAL);
+  expect(getLogLevelName(LOG_LEVEL_SILENT)).toBe(LOG_LEVEL_NAME_SILENT);
+});

package/src/logging/util.ts

@@ -0,0 +1,36 @@
+import type { Logger } from './Logger.js';
+import { LOG_LEVEL_NAMES } from './const.js';
+
+/**
+ * Format log message.
+ */
+export const formatLogMessage = (logger: Logger, timestamp: number, _level: number, message: string): string =>
+  `${timestamp} [${logger.name}] ${message}`;
+
+/**
+ * Get log level name.
+ */
+export const getLogLevelName = (level: number): string | undefined => LOG_LEVEL_NAMES[level];
+
+/**
+ * Returns the application environment identifier.
+ */
+export const getAppEnvironment = (): string => {
+  let appEnvironment = 'local';
+  try {
+    const { env } = import.meta as unknown as { env?: Record<string, string | undefined> };
+    if (env?.['VITE_APP_ENVIRONMENT']) {
+      appEnvironment = env['VITE_APP_ENVIRONMENT'];
+    }
+  } catch {
+    // pass
+  }
+  try {
+    if (process.env['APP_ENVIRONMENT']) {
+      appEnvironment = process.env['APP_ENVIRONMENT'];
+    }
+  } catch {
+    // pass
+  }
+  return appEnvironment;
+};

package/src/pagelifecycle/{const.js → const.ts}

@@ -4,7 +4,7 @@ export const PAGE_LIFECYCLE_STATE_PASSIVE = 'passive';
 export const PAGE_LIFECYCLE_STATE_FROZEN = 'frozen';
 export const PAGE_LIFECYCLE_STATE_TERMINATED = 'terminated';
 
-export const PAGE_LIFECYCLE_STATES = new Set([
+export const PAGE_LIFECYCLE_STATES: ReadonlySet<string> = new Set([
   PAGE_LIFECYCLE_STATE_ACTIVE,
   PAGE_LIFECYCLE_STATE_FROZEN,
   PAGE_LIFECYCLE_STATE_HIDDEN,
@@ -18,7 +18,7 @@ export const DOCUMENT_STATE_COMPLETE = 'complete';
 export const DOCUMENT_STATE_INTERACTIVE = 'interactive';
 export const DOCUMENT_STATE_LOADING = 'loading';
 
-export const DOCUMENT_STATES = new Set([
+export const DOCUMENT_STATES: ReadonlySet<string> = new Set([
   DOCUMENT_STATE_COMPLETE,
   DOCUMENT_STATE_DOM_LOADED,
   DOCUMENT_STATE_FULLY_LOADED,

package/src/pagelifecycle/typedef.ts

@@ -0,0 +1,5 @@
+export const TYPEDEF = true;
+
+export type PageLifecycleState = 'hidden' | 'active' | 'passive' | 'frozen' | 'terminated';
+
+export type DocumentState = 'loading' | 'interactive' | 'complete' | 'domLoaded' | 'fullyLoaded';

package/src/pagelifecycle/util.test.ts

@@ -0,0 +1,99 @@
+import { beforeAll, describe, expect, it } from 'vitest';
+import {
+  DOCUMENT_STATE_CHANGE_EVENT,
+  DOCUMENT_STATES,
+  PAGE_LIFECYCLE_STATE_CHANGE_EVENT,
+  PAGE_LIFECYCLE_STATES,
+} from './const.js';
+import {
+  getDocumentState,
+  getPageLifecycleEventEmitter,
+  getPageLifecycleState,
+  initPageLifecycle,
+  isPageLifecycleInitialized,
+} from './util.js';
+
+describe('Page Lifecycle', () => {
+  beforeAll(() => {
+    initPageLifecycle();
+  });
+
+  it('should initialize page lifecycle', () => {
+    expect(isPageLifecycleInitialized()).toBe(true);
+  });
+
+  it('should return current page lifecycle state', () => {
+    const state = getPageLifecycleState();
+    expect(state).toBeOneOf([...PAGE_LIFECYCLE_STATES]);
+  });
+
+  it('should return current document state', () => {
+    const state = getDocumentState();
+    expect(state).toBeOneOf([...DOCUMENT_STATES]);
+  });
+
+  it('should return event emitter instance', () => {
+    const emitter = getPageLifecycleEventEmitter();
+    expect(emitter).toBeDefined();
+  });
+
+  it('should handle page lifecycle state changes', () => {
+    const emitter = getPageLifecycleEventEmitter();
+    let stateChanged = false;
+
+    emitter.on(PAGE_LIFECYCLE_STATE_CHANGE_EVENT, (data: unknown) => {
+      stateChanged = true;
+      expect(data).toHaveProperty('previousState');
+      expect(data).toHaveProperty('nextState');
+    });
+
+    // Trigger visibility change
+    const originalVisibilityState = document.visibilityState;
+    Object.defineProperty(document, 'visibilityState', {
+      value: originalVisibilityState === 'visible' ? 'hidden' : 'visible',
+      writable: true,
+      configurable: true,
+    });
+
+    document.dispatchEvent(new Event('visibilitychange'));
+
+    // Restore original state
+    Object.defineProperty(document, 'visibilityState', {
+      value: originalVisibilityState,
+      writable: true,
+      configurable: true,
+    });
+
+    expect(stateChanged).toBe(true);
+  });
+
+  it('should handle document state changes', () => {
+    const emitter = getPageLifecycleEventEmitter();
+    let stateChanged = false;
+
+    emitter.on(DOCUMENT_STATE_CHANGE_EVENT, (data: unknown) => {
+      stateChanged = true;
+      expect(data).toHaveProperty('previousState');
+      expect(data).toHaveProperty('nextState');
+    });
+
+    // Trigger ready state change
+    const originalReadyState = document.readyState;
+    Object.defineProperty(document, 'readyState', {
+      value: originalReadyState === 'complete' ? 'interactive' : 'complete',
+      writable: true,
+      configurable: true,
+    });
+
+    document.dispatchEvent(new Event('readystatechange'));
+
+    // Restore original state
+    Object.defineProperty(document, 'readyState', {
+      value: originalReadyState,
+      writable: true,
+      configurable: true,
+    });
+
+    expect(stateChanged).toBe(true);
+  });
+});

package/src/pagelifecycle/{util.js → util.ts}

@@ -16,27 +16,24 @@ import {
   PAGE_LIFECYCLE_STATE_PASSIVE,
   PAGE_LIFECYCLE_STATE_TERMINATED,
 } from './const.js';
+import type { DocumentState, PageLifecycleState } from './typedef.js';
 
 const logger = new Logger('pagelifecycle');
 
 const eventEmitter = new EventEmitter();
 
-/** @type {import('./typedef.js').PageLifecycleState | null | undefined} */
-let currentPageLifecycleState = null;
+let currentPageLifecycleState: PageLifecycleState | null | undefined = null;
 
-/** @type {import('./typedef.js').DocumentState | null | undefined} */
-let currentDocumentState = null;
+let currentDocumentState: DocumentState | null | undefined = null;
 
 let isInitialized = false;
 
-/** @type {Record<string, (() => void)[]>} */
-const callbacks = {};
+const callbacks: Record<string, (() => void)[]> = {};
 
 /**
  * Run callbacks for a specific state change.
- * @param {import('./typedef.js').DocumentState | import('./typedef.js').PageLifecycleState} state - Callback state condition.
  */
-const processCallbacks = (state) => {
+const processCallbacks = (state: DocumentState | PageLifecycleState): void => {
   const stateCallbacks = callbacks[state];
   if (!stateCallbacks) {
     return;
@@ -49,9 +46,8 @@ const processCallbacks = (state) => {
 
 /**
  * Detects the current page lifecycle state.
- * @returns {import('./typedef.js').PageLifecycleState} Current page lifecycle state.
  */
-const detectPageLifecycleState = () => {
+const detectPageLifecycleState = (): PageLifecycleState => {
   if (document.visibilityState === 'hidden') {
     return PAGE_LIFECYCLE_STATE_HIDDEN;
   }
@@ -63,9 +59,8 @@ const detectPageLifecycleState = () => {
 
 /**
  * Handles page lifecycle state change.
- * @param {import('./typedef.js').PageLifecycleState} nextState - Next page lifecycle state.
  */
-const onPageLifecycleStateChange = (nextState) => {
+const onPageLifecycleStateChange = (nextState: PageLifecycleState): void => {
   const previousState = currentPageLifecycleState;
   if (nextState !== previousState) {
     currentPageLifecycleState = nextState;
@@ -78,9 +73,8 @@ const onPageLifecycleStateChange = (nextState) => {
 
 /**
  * Handles document state change.
- * @param {import('./typedef.js').DocumentState} nextState - Next document state.
  */
-const onDocumentStateChange = (nextState) => {
+const onDocumentStateChange = (nextState: DocumentState): void => {
   const previousState = currentDocumentState;
   if (nextState !== previousState) {
     currentDocumentState = nextState;
@@ -94,7 +88,7 @@ const onDocumentStateChange = (nextState) => {
 /**
  * Initialize page lifecycle observer.
  */
-export const initPageLifecycle = () => {
+export const initPageLifecycle = (): void => {
   if (isInitialized) {
     return;
   }
@@ -103,7 +97,6 @@ export const initPageLifecycle = () => {
   onDocumentStateChange(document.readyState);
   const options = { capture: true };
   document.addEventListener('visibilitychange', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
-  // globalThis.addEventListener('popstate', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
   globalThis.addEventListener('pageshow', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
   globalThis.addEventListener('focus', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
   globalThis.addEventListener('blur', () => onPageLifecycleStateChange(detectPageLifecycleState()), options);
@@ -123,21 +116,18 @@ export const initPageLifecycle = () => {
 
 /**
  * Returns the current page lifecycle state.
- * @returns {string | null | undefined} Current page lifecycle state.
  */
-export const getPageLifecycleState = () => currentPageLifecycleState;
+export const getPageLifecycleState = (): PageLifecycleState | null | undefined => currentPageLifecycleState;
 
 /**
  * Returns the current document state.
- * @returns {import('./typedef.js').DocumentState | null | undefined} Current document state.
  */
-export const getDocumentState = () => currentDocumentState;
+export const getDocumentState = (): DocumentState | null | undefined => currentDocumentState;
 
 /**
  * Returns the event emitter instance.
- * @returns {EventEmitter} Event emitter instance.
  */
-export const getPageLifecycleEventEmitter = () => {
+export const getPageLifecycleEventEmitter = (): EventEmitter => {
   if (!isInitialized) {
     initPageLifecycle();
   }
@@ -146,16 +136,13 @@ export const getPageLifecycleEventEmitter = () => {
 
 /**
  * Returns the page lifecycle observer initialized state.
- * @returns {boolean} Page lifecycle observer initialized flag.
  */
-export const isPageLifecycleInitialized = () => isInitialized;
+export const isPageLifecycleInitialized = (): boolean => isInitialized;
 
 /**
  * Add callback for a specific state change.
- * @param {import('./typedef.js').DocumentState | import('./typedef.js').PageLifecycleState} state - Callback state condition.
- * @param {() => void} callback - Callback function.
  */
-export const addPageLifecycleCallback = (state, callback) => {
+export const addPageLifecycleCallback = (state: DocumentState | PageLifecycleState, callback: () => void): void => {
   const stateCallbacks = callbacks[state] ?? [];
   stateCallbacks.push(callback);
   callbacks[state] = stateCallbacks;

package/src/typecheck/{TypeCheckError.js → TypeCheckError.ts}

@@ -1,10 +1,14 @@
+export interface TypeCheckErrorOptions extends ErrorOptions {
+  value?: unknown;
+}
+
 export class TypeCheckError extends TypeError {
+  value: unknown;
+
   /**
    * Creates a new `TypeCheckError` instance.
-   * @param {string} message - Error message.
-   * @param {{ cause?: unknown, value?: unknown }} [options] - Error options.
    */
-  constructor(message, options) {
+  constructor(message: string, options?: TypeCheckErrorOptions) {
     super(message, options);
     this.name = 'TypeCheckError';
     this.value = options?.value;

package/src/typecheck/TypeChecker.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect } from 'vitest';
+import { typeChecker } from './TypeChecker.js';
+import { TypeCheckError } from './TypeCheckError.js';
+
+const stringValidator = (value: unknown): value is string => typeof value === 'string';
+
+describe('TypeChecker', () => {
+  it('should check value type correctly', () => {
+    const result = typeChecker.check('test', stringValidator);
+    expect(result).toBe('test');
+  });
+
+  it('should throw TypeCheckError for invalid type', () => {
+    expect(() => typeChecker.check(123, stringValidator)).toThrow(TypeCheckError);
+  });
+
+  it('should swallow errors when enabled', () => {
+    typeChecker.setSwallowErrors(true);
+    const result = typeChecker.check(123, stringValidator);
+    expect(result).toBe(123);
+    typeChecker.setSwallowErrors(false);
+  });
+
+  it('should check array type correctly', () => {
+    const result = typeChecker.checkArray(['a', 'b', 'c'], stringValidator);
+    expect(result).toEqual(['a', 'b', 'c']);
+  });
+
+  it('should throw TypeCheckError for invalid array type', () => {
+    expect(() => typeChecker.checkArray([1, 2, 3], stringValidator)).toThrow(TypeCheckError);
+  });
+
+  it('should swallow array errors when enabled', () => {
+    typeChecker.setSwallowErrors(true);
+    const result = typeChecker.checkArray([1, 2, 3], stringValidator);
+    expect(result).toEqual([1, 2, 3]);
+    typeChecker.setSwallowErrors(false);
+  });
+
+  it('should check enum value correctly', () => {
+    const choices = ['option1', 'option2', 'option3'];
+    const result = typeChecker.checkEnum('option2', choices);
+    expect(result).toBe('option2');
+  });
+
+  it('should throw TypeCheckError for invalid enum value', () => {
+    const choices = ['option1', 'option2', 'option3'];
+    expect(() => typeChecker.checkEnum('invalid', choices)).toThrow(TypeCheckError);
+  });
+
+  it('should swallow enum errors when enabled', () => {
+    typeChecker.setSwallowErrors(true);
+    const choices = ['option1', 'option2', 'option3'];
+    const result = typeChecker.checkEnum('invalid', choices);
+    expect(result).toBe('invalid');
+    typeChecker.setSwallowErrors(false);
+  });
+
+  it('should handle number enum values', () => {
+    const choices = [1, 2, 3];
+    const result = typeChecker.checkEnum(2, choices);
+    expect(result).toBe(2);
+  });
+
+  it('should handle mixed string and number enum values', () => {
+    const choices = ['option1', 2, 'option3'];
+    const result = typeChecker.checkEnum(2, choices);
+    expect(result).toBe(2);
+  });
+});

package/src/typecheck/{TypeChecker.js → TypeChecker.ts}

@@ -1,14 +1,12 @@
-import { TypeCheckError } from './TypeCheckError.js';
 import { Logger } from '../logging/Logger.js';
-import { typeCheck, typeCheckArray, typeCheckEnum } from './util.js';
+import { TypeCheckError } from './TypeCheckError.js';
+import { typeCheck, typeCheckArray, typeCheckEnum, type EnumChoices } from './util.js';
 
 const logger = new Logger('typechecker');
 
 class TypeChecker {
-  /** @type {TypeChecker} */
-  static #instance;
+  static #instance: TypeChecker | undefined;
 
-  /** @type {boolean} */
   #swallowErrors = false;
 
   constructor() {
@@ -19,27 +17,21 @@ class TypeChecker {
 
   /**
    * Enable or disable swallowing of TypeCheckErrors.
-   * @param {boolean} value - Swallow errors flag.
    */
-  setSwallowErrors(value) {
+  setSwallowErrors(value: boolean): void {
     this.#swallowErrors = Boolean(value);
   }
 
   /**
    * Type check a single value.
-   * @template T
-   * @param {unknown} value - The value to check.
-   * @param {(value: unknown) => value is T} validator - The validator to check with.
-   * @returns {T} - The type checked value.
    */
-  check(value, validator) {
+  check<T>(value: unknown, validator: (value: unknown) => value is T): T {
     try {
       return typeCheck(value, validator);
     } catch (error) {
       if (this.#swallowErrors && error instanceof TypeCheckError) {
         logger.exception('check', error);
-        // @ts-expect-error
-        return value;
+        return value as T;
       }
       throw error;
     }
@@ -47,32 +39,23 @@ class TypeChecker {
 
   /**
    * Type check an array of values.
-   * @template T
-   * @param {unknown[]} value - The value to check.
-   * @param {(value: unknown) => value is T} validator - The validator to check the array with.
-   * @returns {T[]} - The type checked value.
    */
-  checkArray(value, validator) {
+  checkArray<T>(value: unknown[], validator: (value: unknown) => value is T): T[] {
     try {
       return typeCheckArray(value, validator);
     } catch (error) {
       if (this.#swallowErrors && error instanceof TypeCheckError) {
         logger.exception('checkArray', error);
-        // @ts-expect-error
-        return value;
+        return value as T[];
       }
       throw error;
     }
   }
 
   /**
-   * Type check an array of values.
-   * @template T
-   * @param {string | number} value - The value to check.
-   * @param {(string | number)[] | Set<string | number> | Record<string | number, string | number>} choices - Enum list.
-   * @returns {string | number} - The type checked value.
+   * Type check an enum.
    */
-  checkEnum(value, choices) {
+  checkEnum(value: string | number, choices: EnumChoices): string | number {
     try {
       return typeCheckEnum(value, choices);
     } catch (error) {

package/src/typecheck/util.test.ts

@@ -0,0 +1,36 @@
+import { isNumber, isPositiveInteger } from '../util/validate.js';
+import { TypeCheckError } from './TypeCheckError.js';
+import { typeCheck, typeCheckArray, typeCheckEnum } from './util.js';
+
+describe('typecheck', () => {
+  test('typeCheck', () => {
+    expect(() => typeCheck(0.1, isNumber)).not.toThrowError(TypeCheckError);
+    expect(() => typeCheck(-0.1, isPositiveInteger)).toThrowError(TypeCheckError);
+    expect(() => typeCheck('string', isNumber)).toThrowError(TypeCheckError);
+  });
+
+  test('typeCheckArray', () => {
+    expect(() => typeCheckArray([0.1], isNumber)).not.toThrowError(TypeCheckError);
+    expect(() => typeCheckArray(['string'], isNumber)).toThrowError(TypeCheckError);
+    // @ts-expect-error
+    expect(() => typeCheckArray(-0.1, isPositiveInteger)).toThrowError(TypeCheckError);
+    // @ts-expect-error
+    expect(() => typeCheckArray('string', isNumber)).toThrowError(TypeCheckError);
+  });
+
+  test('typeCheckEnum', () => {
+    expect(() => typeCheckEnum('AA', ['AA'])).not.toThrowError(TypeCheckError);
+    expect(() => typeCheckEnum('AA', ['BB'])).toThrowError(TypeCheckError);
+    // @ts-expect-error
+    expect(() => typeCheckEnum(null, ['BB'])).toThrowError(TypeCheckError);
+    // @ts-expect-error
+    expect(() => typeCheckEnum(['AA'], null)).toThrowError(TypeCheckError);
+    try {
+      typeCheckEnum('AA', ['BB']);
+    } catch (error) {
+      if (error instanceof Error) {
+        expect(error.message).toBe('Validation failed: isEnum - "AA" (string)');
+      }
+    }
+  });
+});

package/src/typecheck/util.ts

@@ -0,0 +1,50 @@
+import { getDisplayValue, getTypeFromValue } from '../util/string.js';
+import { isArrayOf, isEnum } from '../util/validate.js';
+import { TypeCheckError } from './TypeCheckError.js';
+
+export type EnumChoices =
+  | ReadonlyArray<string | number>
+  | ReadonlySet<string | number>
+  | Readonly<Record<string | number, string | number>>;
+
+/**
+ * Get error message for validator exceptions.
+ */
+const getErrorMessage = (validatorName: string, value: unknown): never => {
+  const displayValue = getDisplayValue(value);
+  const displayType = getTypeFromValue(value);
+  throw new TypeCheckError(`Validation failed: ${validatorName || '<anonymous>'} - ${displayValue} (${displayType})`);
+};
+
+/**
+ * Type check a value using a validator.
+ * @throws {TypeCheckError}
+ */
+export const typeCheck = <T>(value: unknown, validator: (value: unknown) => value is T): T => {
+  if (!validator(value)) {
+    getErrorMessage(validator.name, value);
+  }
+  return value as T;
+};
+
+/**
+ * Type check an array of values using a validator.
+ * @throws {TypeCheckError}
+ */
+export const typeCheckArray = <T>(value: unknown[], validator: (value: unknown) => value is T): T[] => {
+  if (!isArrayOf(value, validator)) {
+    getErrorMessage(validator.name, value);
+  }
+  return value as T[];
+};
+
+/**
+ * Type check an enum.
+ * @throws {TypeCheckError}
+ */
+export const typeCheckEnum = (value: string | number, choices: EnumChoices): string | number => {
+  if (!isEnum(value, choices)) {
+    getErrorMessage('isEnum', value);
+  }
+  return value;
+};

package/src/util/async.test.ts

@@ -0,0 +1,74 @@
+import { delayPromise, loadJSON, retryAsync } from './async.js';
+
+describe('delayPromise', () => {
+  test('Returns a promise that resolves after specified delay', async () => {
+    const start = Date.now();
+    await delayPromise(10);
+    const end = Date.now();
+
+    expect(end - start).toBeGreaterThanOrEqual(9);
+  });
+
+  test('delayPromise with zero delay', async () => {
+    const start = Date.now();
+    await delayPromise(0);
+    const end = Date.now();
+
+    expect(end - start).toBeGreaterThanOrEqual(0);
+  });
+});
+
+describe('loadJSON', () => {
+  test('Load JSON data', async () => {
+    const data = await loadJSON('/test.json');
+    expect(data).toMatchObject({
+      method: 'GET',
+      success: true,
+    });
+  });
+});
+
+describe('retryAsync', () => {
+  beforeEach(() => {
+    vi.useFakeTimers({ shouldAdvanceTime: true });
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it('returns result when method succeeds immediately', async () => {
+    const method = vi.fn().mockResolvedValue('success');
+    const result = await retryAsync(method, 1, 100);
+    expect(result).toBe('success');
+    expect(method).toHaveBeenCalledTimes(1);
+  });
+
+  it('retries once and then succeeds', async () => {
+    const method = vi.fn().mockRejectedValueOnce(new Error('fail')).mockResolvedValueOnce('success');
+    const promise = retryAsync(method, 1, 100);
+    const result = await promise;
+    expect(result).toBe('success');
+    expect(method).toHaveBeenCalledTimes(2);
+  });
+
+  it('throws after exceeding retries', async () => {
+    const method = vi.fn().mockRejectedValue(new Error('fail'));
+    const promise = retryAsync(method, 1, 100);
+    await expect(promise).rejects.toThrow('fail');
+    expect(method).toHaveBeenCalledTimes(2);
+  });
+
+  it('does not retry when numTries is 0', async () => {
+    const method = vi.fn().mockRejectedValue(new Error('fail'));
+    await expect(retryAsync(method, 0, 100)).rejects.toThrow('fail');
+    expect(method).toHaveBeenCalledTimes(1);
+  });
+
+  it('does not wait when delayMs is 0', async () => {
+    const method = vi.fn().mockRejectedValueOnce(new Error('fail')).mockResolvedValueOnce('success');
+    const result = await retryAsync(method, 1, 0);
+    expect(result).toBe('success');
+    expect(method).toHaveBeenCalledTimes(2);
+  });
+});