use-mask-input 3.10.0 → 3.10.2

package/src/api/withMask.spec.ts

@@ -1,137 +0,0 @@
-import inputmask from 'inputmask';
-import {
-  beforeEach, describe, expect, it, vi,
-} from 'vitest';
-
-import withMask from './withMask';
-
-vi.mock('inputmask', () => ({
-  default: vi.fn((options) => ({
-    mask: vi.fn(),
-    options,
-  })),
-}));
-
-vi.mock('../utils/isServer', () => ({
-  default: false,
-}));
-
-describe('withMask', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('returns a function', () => {
-    const result = withMask('999-999');
-    expect(typeof result).toBe('function');
-    expect(typeof result.unmaskedValue).toBe('function');
-  });
-
-  it('applies mask to input element', () => {
-    const input = document.createElement('input');
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const refCallback = withMask('999-999');
-    refCallback(input);
-
-    expect(maskFn).toHaveBeenCalledWith(input);
-  });
-
-  it('exposes the unmasked value from the masked input', () => {
-    const input = document.createElement('input');
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const refCallback = withMask('999-999');
-    refCallback(input);
-
-    input.inputmask = {
-      unmaskedvalue: vi.fn(() => '2026-04-01'),
-    } as any;
-
-    expect(refCallback.unmaskedValue()).toBe('2026-04-01');
-  });
-
-  it('does nothing if input is null', () => {
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const refCallback = withMask('999-999');
-    refCallback(null);
-
-    expect(maskFn).not.toHaveBeenCalled();
-  });
-
-  it('does nothing if mask is null', () => {
-    const input = document.createElement('input');
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const refCallback = withMask(null);
-    refCallback(input);
-
-    expect(maskFn).not.toHaveBeenCalled();
-  });
-
-  it('applies mask with custom options', () => {
-    const input = document.createElement('input');
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const refCallback = withMask('999-999', { placeholder: '_' });
-    refCallback(input);
-
-    expect(maskFn).toHaveBeenCalledWith(input);
-  });
-
-  it('works with alias masks', () => {
-    const input = document.createElement('input');
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const refCallback = withMask('cpf');
-    refCallback(input);
-
-    expect(maskFn).toHaveBeenCalledWith(input);
-  });
-
-  it('works with array masks', () => {
-    const input = document.createElement('input');
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const refCallback = withMask(['999-999', '9999-9999']);
-    refCallback(input);
-
-    expect(maskFn).toHaveBeenCalledWith(input);
-  });
-
-  it('returns the same callback reference for the same mask (stable identity)', () => {
-    const first = withMask('999-999');
-    const second = withMask('999-999');
-
-    expect(first).toBe(second);
-  });
-
-  it('returns the same callback reference for the same array mask', () => {
-    const first = withMask(['999-999', '9999-9999']);
-    const second = withMask(['999-999', '9999-9999']);
-
-    expect(first).toBe(second);
-  });
-
-  it('returns different callbacks for different masks', () => {
-    const phone = withMask('999-999');
-    const cpf = withMask('cpf');
-
-    expect(phone).not.toBe(cpf);
-  });
-
-  it('always returns a new callback when options are provided', () => {
-    const first = withMask('999-999', { placeholder: '_' });
-    const second = withMask('999-999', { placeholder: '_' });
-
-    expect(first).not.toBe(second);
-  });
-});

package/src/api/withTanStackFormMask.spec.ts

@@ -1,76 +0,0 @@
-import inputmask from 'inputmask';
-import {
-  beforeEach,
-  describe, expect, it, vi,
-} from 'vitest';
-
-import withTanStackFormMask from './withTanStackFormMask';
-
-import type { TanStackFormInputProps } from '../types';
-
-vi.mock('inputmask', () => ({
-  default: vi.fn((options) => ({
-    mask: vi.fn(),
-    options,
-  })),
-}));
-
-describe('withTanStackFormMask', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('returns masked input props with stable structure', () => {
-    const inputProps: TanStackFormInputProps = {
-      name: 'cpf',
-      ref: vi.fn(),
-      onBlur: vi.fn(),
-      onChange: vi.fn(),
-      value: '',
-    };
-
-    const result = withTanStackFormMask(inputProps, 'cpf');
-
-    expect(typeof result.ref).toBe('function');
-    expect(result.onBlur).toBe(inputProps.onBlur);
-    expect(result.onChange).toBe(inputProps.onChange);
-    expect(result.name).toBe('cpf');
-  });
-
-  it('applies mask when ref callback receives an input', () => {
-    const maskFn = vi.fn();
-    vi.mocked(inputmask).mockReturnValue({ mask: maskFn } as any);
-
-    const input = document.createElement('input');
-    const originalRef = vi.fn();
-    const inputProps: TanStackFormInputProps = {
-      name: 'phone',
-      ref: originalRef,
-      onBlur: vi.fn(),
-      onChange: vi.fn(),
-      value: '',
-    };
-
-    const result = withTanStackFormMask(inputProps, '(99) 99999-9999');
-    result.ref(input);
-
-    expect(maskFn).toHaveBeenCalled();
-    expect(originalRef).toHaveBeenCalledWith(input);
-  });
-
-  it('keeps ref cache stable for same ref and mask', () => {
-    const originalRef = vi.fn();
-    const inputProps: TanStackFormInputProps = {
-      name: 'cpf',
-      ref: originalRef,
-      onBlur: vi.fn(),
-      onChange: vi.fn(),
-      value: '',
-    };
-
-    const first = withTanStackFormMask(inputProps, 'cpf');
-    const second = withTanStackFormMask(inputProps, 'cpf');
-
-    expect(first.ref).toBe(second.ref);
-  });
-});

package/src/core/elementResolver.spec.ts

@@ -1,175 +0,0 @@
-import {
-  describe, expect, it, vi,
-} from 'vitest';
-
-import { findInputElement, isHTMLElement, resolveInputRef } from './elementResolver';
-
-import type { Input } from '..';
-
-describe('elementResolver', () => {
-  describe('isHTMLElement', () => {
-    it('returns true for valid HTMLElement', () => {
-      const element = document.createElement('div');
-      expect(isHTMLElement(element)).toBe(true);
-    });
-
-    it('returns false for null', () => {
-      expect(isHTMLElement(null)).toBe(false);
-    });
-
-    it('returns false for undefined', () => {
-      expect(isHTMLElement(undefined)).toBe(false);
-    });
-
-    it('returns false for string', () => {
-      expect(isHTMLElement('string')).toBe(false);
-    });
-
-    it('returns false for number', () => {
-      expect(isHTMLElement(123)).toBe(false);
-    });
-
-    it('returns false for object without nodeType', () => {
-      expect(isHTMLElement({})).toBe(false);
-    });
-
-    it('returns false for object without querySelector', () => {
-      expect(isHTMLElement({ nodeType: 1 })).toBe(false);
-    });
-
-    it('returns false for object with non-function querySelector', () => {
-      expect(isHTMLElement({ nodeType: 1, querySelector: 'not a function' })).toBe(false);
-    });
-  });
-
-  describe('findInputElement', () => {
-    it('returns null for null', () => {
-      expect(findInputElement(null)).toBe(null);
-    });
-
-    it('returns null for undefined', () => {
-      expect(findInputElement(undefined)).toBe(null);
-    });
-
-    it('returns input element directly if it is an INPUT', () => {
-      const input = document.createElement('input');
-      expect(findInputElement(input)).toBe(input);
-    });
-
-    it('returns textarea element directly if it is a TEXTAREA', () => {
-      const textarea = document.createElement('textarea');
-      expect(findInputElement(textarea)).toBe(textarea);
-    });
-
-    it('finds input inside wrapper element', () => {
-      const wrapper = document.createElement('div');
-      const input = document.createElement('input');
-      wrapper.appendChild(input);
-      expect(findInputElement(wrapper)).toBe(input);
-    });
-
-    it('finds textarea inside wrapper element', () => {
-      const wrapper = document.createElement('div');
-      const textarea = document.createElement('textarea');
-      wrapper.appendChild(textarea);
-      expect(findInputElement(wrapper)).toBe(textarea);
-    });
-
-    it('returns null if no input found inside wrapper', () => {
-      const wrapper = document.createElement('div');
-      const span = document.createElement('span');
-      wrapper.appendChild(span);
-      expect(findInputElement(wrapper)).toBe(null);
-    });
-
-    it('returns null for invalid element', () => {
-      expect(findInputElement('not an element')).toBe(null);
-    });
-
-    it('handles querySelector error gracefully', () => {
-      const element = {
-        nodeType: 1,
-        nodeName: 'DIV',
-        querySelector: vi.fn(() => {
-          throw new Error('querySelector error');
-        }),
-      };
-      expect(findInputElement(element)).toBe(null);
-    });
-
-    it('handles element without querySelector method', () => {
-      const element = {
-        nodeType: 1,
-        nodeName: 'DIV',
-      };
-      expect(findInputElement(element)).toBe(null);
-    });
-
-    it('handles element with non-function querySelector', () => {
-      const element = {
-        nodeType: 1,
-        nodeName: 'DIV',
-        querySelector: 'not a function',
-      };
-      expect(findInputElement(element)).toBe(null);
-    });
-
-    it('handles element where querySelector is not in element', () => {
-      const element = {
-        nodeType: 1,
-        nodeName: 'DIV',
-      };
-      // element doesn't have querySelector property
-      expect(findInputElement(element)).toBe(null);
-    });
-
-    it('handles querySelector returning null', () => {
-      const element = {
-        nodeType: 1,
-        nodeName: 'DIV',
-        querySelector: vi.fn(() => null),
-      };
-      expect(findInputElement(element)).toBe(null);
-    });
-
-    it('handles querySelector returning non-HTMLElement', () => {
-      const element = {
-        nodeType: 1,
-        nodeName: 'DIV',
-        querySelector: vi.fn(() => 'not an element'),
-      };
-      expect(findInputElement(element)).toBe(null);
-    });
-  });
-
-  describe('resolveInputRef', () => {
-    it('returns null for null', () => {
-      expect(resolveInputRef(null)).toBe(null);
-    });
-
-    it('returns element for direct HTMLElement', () => {
-      const input = document.createElement('input');
-      expect(resolveInputRef(input)).toBe(input);
-    });
-
-    it('returns element from ref object with current', () => {
-      const input = document.createElement('input');
-      const ref = { current: input };
-      expect(resolveInputRef(ref as unknown as Input)).toBe(input);
-    });
-
-    it('returns null for ref object with null current', () => {
-      const ref = { current: null } as unknown as Input;
-      expect(resolveInputRef(ref)).toBe(null);
-    });
-
-    it('returns null for ref object with invalid current', () => {
-      const ref = { current: 'not an element' } as unknown as Input;
-      expect(resolveInputRef(ref)).toBe(null);
-    });
-
-    it('returns null for invalid input type', () => {
-      expect(resolveInputRef('not an element' as unknown as Input)).toBe(null);
-    });
-  });
-});

package/src/core/maskConfig.spec.ts

@@ -1,208 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import { getMaskOptions } from './maskConfig';
-
-describe('maskConfig', () => {
-  describe('getMaskOptions', () => {
-    it('returns default options when no mask is provided', () => {
-      const options = getMaskOptions();
-      expect(options).toEqual({
-        jitMasking: false,
-      });
-    });
-
-    it('merges custom options with defaults', () => {
-      const options = getMaskOptions(undefined, { placeholder: '_' });
-      expect(options).toEqual({
-        jitMasking: false,
-        placeholder: '_',
-      });
-    });
-
-    it('returns options for datetime mask', () => {
-      const options = getMaskOptions('datetime');
-      expect(options).toEqual({
-        alias: 'datetime',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for email mask', () => {
-      const options = getMaskOptions('email');
-      expect(options).toEqual({
-        alias: 'email',
-        placeholder: '',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for numeric mask', () => {
-      const options = getMaskOptions('numeric');
-      expect(options).toEqual({
-        alias: 'numeric',
-        placeholder: '',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for currency mask', () => {
-      const options = getMaskOptions('currency');
-      expect(options).toEqual({
-        alias: 'currency',
-        prefix: '$ ',
-        placeholder: '',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for decimal mask', () => {
-      const options = getMaskOptions('decimal');
-      expect(options).toEqual({
-        alias: 'decimal',
-        placeholder: '',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for integer mask', () => {
-      const options = getMaskOptions('integer');
-      expect(options).toEqual({
-        alias: 'integer',
-        placeholder: '',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for percentage mask', () => {
-      const options = getMaskOptions('percentage');
-      expect(options).toEqual({
-        alias: 'percentage',
-        placeholder: ' %',
-        suffix: ' %',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for url mask', () => {
-      const options = getMaskOptions('url');
-      expect(options).toEqual({
-        alias: 'url',
-        placeholder: 'https://',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for ip mask', () => {
-      const options = getMaskOptions('ip');
-      expect(options).toEqual({
-        alias: 'ip',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for mac mask', () => {
-      const options = getMaskOptions('mac');
-      expect(options).toEqual({
-        alias: 'mac',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for ssn mask', () => {
-      const options = getMaskOptions('ssn');
-      expect(options).toEqual({
-        alias: 'ssn',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for brl-currency mask', () => {
-      const options = getMaskOptions('brl-currency');
-      expect(options).toEqual({
-        alias: 'currency',
-        prefix: 'R$ ',
-        placeholder: '0,00',
-        displayFormat: 'currency',
-        radixPoint: ',',
-        groupSeparator: '.',
-        autoUnmask: true,
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for cpf mask', () => {
-      const options = getMaskOptions('cpf');
-      expect(options).toEqual({
-        mask: '999.999.999-99',
-        placeholder: '___.___.___-__',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for cnpj mask', () => {
-      const options = getMaskOptions('cnpj');
-      expect(options).toEqual({
-        mask: ['A|9{2}.A|9{3}.A|9{3}/A|9{4}-9{2}'],
-        placeholder: '__.___.___/____-__',
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for br-bank-account mask', () => {
-      const options = getMaskOptions('br-bank-account');
-      expect(options).toEqual({
-        mask: [
-          '9{4,10}[-]9',
-          '999999[-][9]',
-          '[999]9{7,8}[-]9',
-          '[9999]9{8}[-]9',
-        ],
-        placeholder: '',
-        greedy: false,
-        jitMasking: false,
-      });
-    });
-
-    it('returns options for br-bank-agency mask', () => {
-      const options = getMaskOptions('br-bank-agency');
-      expect(options).toEqual({
-        mask: '9{1,5}[-][9]',
-        placeholder: '',
-        jitMasking: false,
-      });
-    });
-
-    it('returns custom mask string', () => {
-      const options = getMaskOptions('999-999');
-      expect(options).toEqual({
-        mask: '999-999',
-        jitMasking: false,
-      });
-    });
-
-    it('returns custom mask array', () => {
-      const mask = ['999-999', '9999-9999'];
-      const options = getMaskOptions(mask);
-      expect(options).toEqual({
-        mask,
-        jitMasking: false,
-      });
-    });
-
-    it('merges custom options with alias options', () => {
-      const options = getMaskOptions('cpf', { placeholder: '___' });
-      expect(options).toEqual({
-        mask: '999.999.999-99',
-        placeholder: '___',
-        jitMasking: false,
-      });
-    });
-
-    it('handles null mask', () => {
-      const options = getMaskOptions(null);
-      expect(options).toEqual({
-        jitMasking: false,
-      });
-    });
-  });
-});

package/src/core/maskEngine.spec.ts

@@ -1,114 +0,0 @@
-import inputmask from 'inputmask';
-import {
-  beforeEach, describe, expect, it, vi,
-} from 'vitest';
-
-import { applyMaskToElement, createMaskInstance } from './maskEngine';
-
-type MaskInstance = ReturnType<typeof createMaskInstance>;
-
-function stubMaskInstance(maskFn: ReturnType<typeof vi.fn>): MaskInstance {
-  return { mask: maskFn } as unknown as MaskInstance;
-}
-
-vi.mock('inputmask', () => ({
-  default: vi.fn((options) => ({
-    mask: vi.fn(),
-    options,
-  })),
-}));
-
-describe('maskEngine', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('createMaskInstance', () => {
-    it('creates mask instance with string mask', () => {
-      const instance = createMaskInstance('999-999');
-      expect(inputmask).toHaveBeenCalled();
-      expect(instance).toBeDefined();
-    });
-
-    it('creates mask instance with alias', () => {
-      const instance = createMaskInstance('cpf');
-      expect(inputmask).toHaveBeenCalled();
-      expect(instance).toBeDefined();
-    });
-
-    it('creates mask instance with options', () => {
-      const instance = createMaskInstance('999-999', { placeholder: '_' });
-      expect(inputmask).toHaveBeenCalled();
-      expect(instance).toBeDefined();
-    });
-
-    it('creates mask instance with array mask', () => {
-      const instance = createMaskInstance(['999-999', '9999-9999']);
-      expect(inputmask).toHaveBeenCalled();
-      expect(instance).toBeDefined();
-    });
-  });
-
-  describe('applyMaskToElement', () => {
-    it('applies mask to input element', () => {
-      const input = document.createElement('input');
-      const maskFn = vi.fn();
-      vi.mocked(inputmask).mockImplementation(() => stubMaskInstance(maskFn));
-
-      applyMaskToElement(input, '999-999');
-
-      expect(maskFn).toHaveBeenCalledWith(input);
-    });
-
-    it('applies mask to textarea element', () => {
-      const textarea = document.createElement('textarea');
-      const maskFn = vi.fn();
-      vi.mocked(inputmask).mockImplementation(() => stubMaskInstance(maskFn));
-
-      applyMaskToElement(textarea, '999-999');
-
-      expect(maskFn).toHaveBeenCalledWith(textarea);
-    });
-
-    it('finds and applies mask to input inside wrapper', () => {
-      const wrapper = document.createElement('div');
-      const input = document.createElement('input');
-      wrapper.appendChild(input);
-      const maskFn = vi.fn();
-      vi.mocked(inputmask).mockImplementation(() => stubMaskInstance(maskFn));
-
-      applyMaskToElement(wrapper, '999-999');
-
-      expect(maskFn).toHaveBeenCalledWith(input);
-    });
-
-    it('applies mask to wrapper if no input found inside', () => {
-      const wrapper = document.createElement('div');
-      const maskFn = vi.fn();
-      vi.mocked(inputmask).mockImplementation(() => stubMaskInstance(maskFn));
-
-      applyMaskToElement(wrapper, '999-999');
-
-      expect(maskFn).toHaveBeenCalledWith(wrapper);
-    });
-
-    it('does nothing if element is null', () => {
-      const maskFn = vi.fn();
-      vi.mocked(inputmask).mockImplementation(() => stubMaskInstance(maskFn));
-
-      applyMaskToElement(null as unknown as HTMLElement, '999-999');
-
-      expect(maskFn).not.toHaveBeenCalled();
-    });
-
-    it('applies mask with custom options', () => {
-      const input = document.createElement('input');
-      const maskFn = vi.fn();
-      vi.mocked(inputmask).mockImplementation(() => stubMaskInstance(maskFn));
-
-      applyMaskToElement(input, '999-999', { placeholder: '_' });
-
-      expect(maskFn).toHaveBeenCalledWith(input);
-    });
-  });
-});