use-mask-input 3.10.1 → 3.10.2

package/src/api/useHookFormMask.spec.ts

@@ -1,259 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import inputmask from '../core/inputmask';
-import {
-  beforeEach,
-  describe, expect, it, vi,
-} from 'vitest';
-
-import useHookFormMask from './useHookFormMask';
-
-import type { FieldValues, UseFormRegister } from 'react-hook-form';
-
-vi.mock('../core/inputmask', () => ({
-  default: vi.fn((options) => ({
-    mask: vi.fn(),
-    options,
-  })),
-}));
-
-function makeRegisterFn(name = 'test') {
-  return vi.fn(() => ({
-    ref: vi.fn(),
-    prevRef: vi.fn(),
-    onChange: vi.fn(),
-    onBlur: vi.fn(),
-    name,
-  }));
-}
-
-describe('useHookFormMask', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('returns a function', () => {
-    const registerFn = makeRegisterFn();
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as UseFormRegister<FieldValues>),
-    );
-    expect(typeof result.current).toBe('function');
-  });
-
-  it('registers field with mask', () => {
-    const input = document.createElement('input');
-    const refCallback = vi.fn();
-    const registerFn = vi.fn(() => ({
-      ref: refCallback,
-      prevRef: vi.fn(),
-      onChange: vi.fn(),
-      onBlur: vi.fn(),
-      name: 'phone',
-    }));
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as UseFormRegister<FieldValues>),
-    );
-    const registration = result.current('phone', '999-999');
-
-    expect(registerFn).toHaveBeenCalledWith('phone', undefined);
-    expect(registration.ref).toBeDefined();
-    expect(typeof registration.ref).toBe('function');
-
-    registration.ref?.(input);
-
-    expect(maskFn).toHaveBeenCalled();
-  });
-
-  it('merges register options with mask options', () => {
-    const registerFn = makeRegisterFn('phone');
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as UseFormRegister<FieldValues>),
-    );
-    result.current('phone', '999-999', { required: true });
-
-    expect(registerFn).toHaveBeenCalledWith('phone', { required: true });
-  });
-
-  it('works with alias masks', () => {
-    const registerFn = makeRegisterFn('cpf');
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as UseFormRegister<FieldValues>),
-    );
-    const registration = result.current('cpf', 'cpf');
-
-    expect(registration.ref).toBeDefined();
-  });
-
-  it('works with array masks', () => {
-    const registerFn = makeRegisterFn('phone');
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as UseFormRegister<FieldValues>),
-    );
-    const registration = result.current('phone', ['999-999', '9999-9999']);
-
-    expect(registration.ref).toBeDefined();
-  });
-
-  it('preserves all register return properties', () => {
-    const onChange = vi.fn();
-    const onBlur = vi.fn();
-    const registerFn = vi.fn(() => ({
-      ref: vi.fn(),
-      prevRef: vi.fn(),
-      onChange,
-      onBlur,
-      name: 'phone',
-    }));
-
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as UseFormRegister<FieldValues>),
-    );
-    const registration = result.current('phone', '999-999');
-
-    expect(registration.onChange).toBe(onChange);
-    expect(registration.onBlur).toBe(onBlur);
-    expect(registration.name).toBe('phone');
-  });
-
-  it('handles null ref from register', () => {
-    const registerFn = vi.fn(() => ({
-      ref: undefined,
-      prevRef: vi.fn(),
-      onChange: vi.fn(),
-      onBlur: vi.fn(),
-      name: 'phone',
-    }));
-
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as unknown as UseFormRegister<FieldValues>),
-    );
-    const registration = result.current('phone', '999-999');
-
-    expect(registration.ref).toBeDefined();
-  });
-
-  it('returns the same ref callback reference across multiple calls (stable identity)', () => {
-    const registerFn = makeRegisterFn('phone');
-
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as UseFormRegister<FieldValues>),
-    );
-
-    const first = result.current('phone', '999-999');
-    const second = result.current('phone', '999-999');
-
-    expect(first.ref).toBe(second.ref);
-  });
-
-  it('returns different ref callbacks for different field/mask combinations', () => {
-    const registerFn = vi.fn((name: string) => ({
-      ref: vi.fn(),
-      prevRef: vi.fn(),
-      onChange: vi.fn(),
-      onBlur: vi.fn(),
-      name,
-    }));
-
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as unknown as UseFormRegister<FieldValues>),
-    );
-
-    const phone = result.current('phone', '999-999');
-    const cpf = result.current('cpf', 'cpf');
-
-    expect(phone.ref).not.toBe(cpf.ref);
-  });
-
-  it('invalidates the ref cache when registerFn changes (rerender with new registerFn)', () => {
-    const registerFn1 = makeRegisterFn('phone');
-    const registerFn2 = makeRegisterFn('phone');
-
-    const { result, rerender } = renderHook(
-      ({ fn }) => useHookFormMask(fn as UseFormRegister<FieldValues>),
-      { initialProps: { fn: registerFn1 } },
-    );
-
-    const refBefore = result.current('phone', '999-999').ref;
-
-    rerender({ fn: registerFn2 });
-
-    const refAfter = result.current('phone', '999-999').ref;
-
-    expect(refBefore).not.toBe(refAfter);
-  });
-
-  it('calls the latest RHF ref with the element after re-render (reset() regression)', async () => {
-    // Simulate react-hook-form's reset() behaviour: it clears _fields and
-    // returns a brand-new ref callback from register() on the next render.
-    // The cached stable ref must still forward to the new RHF ref so that
-    // RHF's internal T()/Z() logic can sync the DOM value to the reset value.
-    const input = document.createElement('input');
-    const refFn1 = vi.fn();
-    const refFn2 = vi.fn(); // "new" ref returned after reset()
-
-    const makeRegisterReturn = (ref: ReturnType<typeof vi.fn>) => ({
-      ref,
-      prevRef: vi.fn(),
-      onChange: vi.fn(),
-      onBlur: vi.fn(),
-      name: 'phone',
-    });
-
-    let currentRef = refFn1;
-    const registerFn = vi.fn(() => makeRegisterReturn(currentRef));
-
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    // Mimic a real component: the registration function is called on every
-    // render (which is what triggers the queue-push logic for reset support).
-    const { result, rerender } = renderHook(
-      () => {
-        const registerWithMask = useHookFormMask(registerFn as UseFormRegister<FieldValues>);
-        return registerWithMask('phone', '999-999');
-      },
-    );
-
-    // Mount the element – stable cached ref is called once
-    result.current.ref?.(input);
-    expect(refFn1).toHaveBeenCalledWith(input);
-
-    // Simulate reset(): register() now returns a different ref (refFn2)
-    currentRef = refFn2;
-
-    await act(async () => {
-      rerender();
-    });
-
-    // After the re-render + useLayoutEffect, the new RHF ref must have been
-    // called with the stored element so RHF can re-register it and sync values.
-    expect(refFn2).toHaveBeenCalledWith(input);
-  });
-
-  it('defines prevRef as a non-enumerable property', () => {
-    const prevRef = vi.fn();
-    const registerFn = vi.fn(() => ({
-      ref: prevRef,
-      prevRef: vi.fn(),
-      onChange: vi.fn(),
-      onBlur: vi.fn(),
-      name: 'phone',
-    }));
-
-    const { result } = renderHook(
-      () => useHookFormMask(registerFn as UseFormRegister<FieldValues>),
-    );
-    const registration = result.current('phone', '999-999');
-
-    const descriptor = Object.getOwnPropertyDescriptor(registration, 'prevRef');
-    expect(descriptor?.enumerable).toBe(false);
-    expect((registration as unknown as { prevRef: typeof prevRef }).prevRef).toBe(prevRef);
-  });
-});

package/src/api/useMaskInput-server.spec.tsx

@@ -1,30 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import {
-  beforeEach,
-  describe, expect, it, vi,
-} from 'vitest';
-
-vi.mock('../utils/isServer', () => ({
-  default: true,
-}));
-
-describe('useMaskInput server-side', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.resetModules();
-  });
-
-  it('returns no-op function on server', async () => {
-    const { default: useMaskInput } = await import('./useMaskInput');
-    const { result } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    expect(typeof result.current).toBe('function');
-
-    act(() => {
-      result.current(document.createElement('input'));
-    });
-
-    // should do nothing on server
-    expect(result.current).toBeDefined();
-  });
-});

package/src/api/useMaskInput.spec.tsx

@@ -1,238 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import inputmask from '../core/inputmask';
-import {
-  beforeEach,
-  describe, expect, it, vi,
-} from 'vitest';
-
-import useMaskInput from './useMaskInput';
-import * as core from '../core';
-
-import type { Input } from '../types';
-
-vi.mock('../core/inputmask', () => ({
-  default: vi.fn((options) => ({
-    mask: vi.fn(),
-    options,
-  })),
-}));
-
-vi.mock('../utils/isServer', () => ({
-  default: false,
-}));
-
-describe('useMaskInput', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('returns a ref callback function', () => {
-    const { result } = renderHook(() => useMaskInput({ mask: '999-999' }));
-    expect(typeof result.current).toBe('function');
-    expect(typeof result.current.unmaskedValue).toBe('function');
-  });
-
-  it('handles null input', () => {
-    const { result } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(null);
-    });
-
-    expect(result.current).toBeDefined();
-  });
-
-  it('handles direct input element', () => {
-    const input = document.createElement('input');
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(input);
-    });
-
-    rerender();
-
-    expect(inputmask).toHaveBeenCalled();
-  });
-
-  it('exposes the unmasked value from the masked input', () => {
-    const input = document.createElement('input');
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(input);
-    });
-
-    input.inputmask = {
-      unmaskedvalue: vi.fn(() => '2026-04-01'),
-    } as any;
-
-    expect(result.current.unmaskedValue()).toBe('2026-04-01');
-  });
-
-  it('handles ref object', () => {
-    const input = document.createElement('input');
-    const ref = { current: input };
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(ref as unknown as Input);
-    });
-
-    rerender();
-
-    expect(inputmask).toHaveBeenCalled();
-  });
-
-  it('handles wrapper element with input inside', () => {
-    const wrapper = document.createElement('div');
-    const input = document.createElement('input');
-    wrapper.appendChild(input);
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(wrapper);
-    });
-
-    rerender();
-
-    expect(inputmask).toHaveBeenCalled();
-  });
-
-  it('handles invalid element in ref', () => {
-    const invalidRef = { current: 'not an element' };
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(invalidRef as unknown as Input);
-    });
-
-    expect(result.current).toBeDefined();
-  });
-
-  it('handles element that is not HTMLElement in useEffect', () => {
-    vi.spyOn(core, 'isHTMLElement').mockReturnValueOnce(false);
-
-    const invalidElement = { nodeType: 1 } as unknown as Input;
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(invalidElement as unknown as Input);
-    });
-
-    rerender();
-
-    expect(result.current).toBeDefined();
-  });
-
-  it('handles wrapper without input inside', () => {
-    const wrapper = document.createElement('div');
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(wrapper);
-    });
-
-    rerender();
-
-    expect(inputmask).toHaveBeenCalled();
-  });
-
-  it('works with custom options', () => {
-    const input = document.createElement('input');
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({
-      mask: '999-999',
-      options: { placeholder: '_' },
-    }));
-
-    act(() => {
-      result.current(input);
-    });
-
-    rerender();
-
-    expect(inputmask).toHaveBeenCalled();
-  });
-
-  it('works with alias masks', () => {
-    const input = document.createElement('input');
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({ mask: 'cpf' }));
-
-    act(() => {
-      result.current(input);
-    });
-
-    rerender();
-
-    expect(inputmask).toHaveBeenCalled();
-  });
-
-  it('calls register callback when provided', () => {
-    const input = document.createElement('input');
-    const register = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({
-      mask: '999-999',
-      register,
-    }));
-
-    act(() => {
-      result.current(input);
-    });
-
-    rerender();
-
-    expect(inputmask).toHaveBeenCalled();
-  });
-
-  it('handles textarea element', () => {
-    const textarea = document.createElement('textarea');
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(textarea);
-    });
-
-    rerender();
-
-    expect(inputmask).toHaveBeenCalled();
-  });
-
-  it('handles case where findInputElement returns valid element', () => {
-    const wrapper = document.createElement('div');
-    const input = document.createElement('input');
-    wrapper.appendChild(input);
-    vi.mocked(inputmask).mockReturnValue({ mask: vi.fn() } as any);
-
-    const { result, rerender } = renderHook(() => useMaskInput({ mask: '999-999' }));
-
-    act(() => {
-      result.current(wrapper);
-    });
-
-    rerender();
-
-    expect(inputmask).toHaveBeenCalled();
-  });
-});

package/src/api/withHookFormMask.spec.ts

@@ -1,179 +0,0 @@
-import inputmask from '../core/inputmask';
-import {
-  beforeEach,
-  describe, expect, it, vi,
-} from 'vitest';
-
-import withHookFormMask from './withHookFormMask';
-
-import type { RefCallback } from 'react';
-import type { FieldValues } from 'react-hook-form';
-
-import type { UseHookFormMaskReturn } from '../types';
-
-vi.mock('../core/inputmask', () => ({
-  default: vi.fn((options) => ({
-    mask: vi.fn(),
-    options,
-  })),
-}));
-
-const createRegister = (
-  overrides: Partial<UseHookFormMaskReturn<FieldValues>> = {},
-): UseHookFormMaskReturn<FieldValues> => ({
-  prevRef: vi.fn(),
-  ref: vi.fn(),
-  onChange: vi.fn(),
-  onBlur: vi.fn(),
-  name: 'phone',
-  unmaskedValue: vi.fn(() => ''),
-  ...overrides,
-});
-
-describe('withHookFormMask', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('returns register object with masked ref', () => {
-    const originalRef = vi.fn();
-    const register = createRegister({ ref: originalRef });
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const result = withHookFormMask(register, '999-999');
-
-    expect(result.ref).toBeDefined();
-    expect(typeof result.ref).toBe('function');
-    expect(result.onChange).toBe(register.onChange);
-    expect(result.onBlur).toBe(register.onBlur);
-    expect(result.name).toBe(register.name);
-    expect(typeof result.unmaskedValue).toBe('function');
-  });
-
-  it('applies mask when ref is called', () => {
-    const input = document.createElement('input');
-    const originalRef = vi.fn();
-    const register = createRegister({ ref: originalRef });
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const result = withHookFormMask(register, '999-999');
-    result.ref?.(input);
-
-    expect(maskFn).toHaveBeenCalled();
-  });
-
-  it('exposes the unmasked value from the masked input', () => {
-    const input = document.createElement('input');
-    const originalRef = vi.fn();
-    const register = createRegister({ ref: originalRef });
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const result = withHookFormMask(register, '999-999');
-    result.ref?.(input);
-
-    input.inputmask = {
-      unmaskedvalue: vi.fn(() => '2026-04-01'),
-    } as any;
-
-    expect(result.unmaskedValue()).toBe('2026-04-01');
-  });
-
-  it('calls original ref after applying mask', () => {
-    const input = document.createElement('input');
-    const originalRef = vi.fn();
-    const register = createRegister({ ref: originalRef });
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const result = withHookFormMask(register, '999-999');
-    result.ref?.(input);
-
-    expect(originalRef).toHaveBeenCalled();
-  });
-
-  it('works with alias masks', () => {
-    const input = document.createElement('input');
-    const originalRef = vi.fn();
-    const register = createRegister({ ref: originalRef, name: 'cpf' });
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const result = withHookFormMask(register, 'cpf');
-    result.ref?.(input);
-
-    expect(maskFn).toHaveBeenCalled();
-  });
-
-  it('works with custom options', () => {
-    const input = document.createElement('input');
-    const originalRef = vi.fn();
-    const register = createRegister({ ref: originalRef });
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const result = withHookFormMask(register, '999-999', { placeholder: '_' });
-    result.ref?.(input);
-
-    expect(maskFn).toHaveBeenCalled();
-  });
-
-  it('handles null ref gracefully', () => {
-    const register = createRegister({
-      prevRef: null as unknown as RefCallback<HTMLElement | null>,
-      ref: null as unknown as RefCallback<HTMLElement | null>,
-    });
-
-    const result = withHookFormMask(register, '999-999');
-    expect(result.ref).toBeNull();
-    expect(result.onChange).toBe(register.onChange);
-    expect(result.onBlur).toBe(register.onBlur);
-  });
-
-  it('handles null input in ref callback', () => {
-    const originalRef = vi.fn();
-    const register = createRegister({ ref: originalRef });
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const result = withHookFormMask(register, '999-999');
-    result.ref?.(null as unknown as HTMLElement);
-
-    expect(maskFn).not.toHaveBeenCalled();
-  });
-
-  it('returns the same ref callback reference across multiple calls (stable identity)', () => {
-    const originalRef = vi.fn();
-    const register = createRegister({ ref: originalRef });
-
-    const first = withHookFormMask(register, '999-999');
-    const second = withHookFormMask(register, '999-999');
-
-    expect(first.ref).toBe(second.ref);
-  });
-
-  it('returns different ref callbacks for different field/mask combinations', () => {
-    const originalRef = vi.fn();
-    const registerPhone = createRegister({ ref: originalRef, name: 'phone' });
-    const registerCpf = createRegister({ ref: originalRef, name: 'cpf' });
-
-    const phone = withHookFormMask(registerPhone, '999-999');
-    const cpf = withHookFormMask(registerCpf, 'cpf');
-
-    expect(phone.ref).not.toBe(cpf.ref);
-  });
-
-  it('returns a new ref callback when the original ref changes', () => {
-    const ref1 = vi.fn();
-    const ref2 = vi.fn();
-    const register1 = createRegister({ prevRef: vi.fn(), ref: ref1 });
-    const register2 = createRegister({ prevRef: vi.fn(), ref: ref2 });
-
-    const result1 = withHookFormMask(register1, '999-999');
-    const result2 = withHookFormMask(register2, '999-999');
-
-    expect(result1.ref).not.toBe(result2.ref);
-  });
-});