Function createDebouncedAsyncValidator

packages/core/src/forms/validation.ts:106–159

(
  validateAsync: (values: T) => Promise<ValidationResult<T>>,
  debounceMs: number,
  onResult: (errors: ValidationResult<T>) => void,
  onError?: (error: unknown) => void,
)

 * @returns Object with run and cancel methods
 */
export function createDebouncedAsyncValidator<T extends Record<string, unknown>>(
  validateAsync: (values: T) => Promise<ValidationResult<T>>,
  debounceMs: number,
  onResult: (errors: ValidationResult<T>) => void,
  onError?: (error: unknown) => void,
): Readonly<{
  run: (values: T) => void;
  cancel: () => void;
}> {
  let timeoutId: ReturnType<typeof setTimeout> | undefined;
  let cancelled = false;
  // Monotonic token used to ignore stale debounced callbacks and in-flight promises.
  let token = 0;

  return Object.freeze({
    run(values: T): void {
      // Cancel any pending validation
      if (timeoutId !== undefined) {
        clearTimeout(timeoutId);
      }
      cancelled = false;
      token++;
      const myToken = token;

      timeoutId = setTimeout(() => {
        if (cancelled || myToken !== token) return;

        validateAsync(values)
          .then((errors) => {
            if (!cancelled && myToken === token) {
              onResult(errors);
            }
          })
          .catch((e) => {
            if (cancelled || myToken !== token) return;
            if (onError) {
              onError(e);
            } else {
              onResult({});
            }
          });
      }, debounceMs);
    },

    cancel(): void {
      cancelled = true;
      token++;
      if (timeoutId !== undefined) {
        clearTimeout(timeoutId);
        timeoutId = undefined;
      }
    },
  });
}

/**
 * Run async validation immediately (without debounce).