use-mask-input 3.6.0 → 3.7.0

package/src/utils/flow.spec.ts

@@ -1,4 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unsafe-function-type */
 import {
   describe, expect, it,
 } from 'vitest';
@@ -11,50 +10,48 @@ describe('flow', () => {
     expect(typeof result).toBe('function');
   });
 
-  it('returns undefined value if no return funcion provided', () => {
-    const result = flow(() => {})(42);
-    expect(result).toBe(undefined);
+  it('returns undefined value if no return function provided', () => {
+    const result = flow(() => { });
+    expect(result(42)).toBe(undefined);
   });
 
   it('throws an error if any argument is not a function', () => {
     // @ts-expect-error - null is not a function
     expect(() => flow(null)).toThrow(TypeError);
     // @ts-expect-error - null is not a function
-    expect(() => flow(() => {}, null)).toThrow(TypeError);
+    expect(() => flow(() => { }, null)).toThrow(TypeError);
+    expect(() => {
+      flow(1 as unknown as () => void, () => { });
+    }).toThrow(TypeError);
   });
 
   it('returns the original value if no functions are provided', () => {
-    const result = flow()(42);
-    expect(result).toBe(42);
+    const result = flow();
+    expect(result(42)).toBe(42);
+    expect(result('test')).toBe('test');
   });
 
-  it.todo('binds the functions to the correct context', () => {
-    const context = { value: 42 };
-    const fn1 = function (this: { value: number }) {
-      return this.value;
-    };
-    const fn2 = function (this: { value: number }, n: number) {
-      return this.value + n;
-    };
-    const fn = flow(fn1, fn2).bind(context);
-    const result = fn(10);
-    expect(result).toBe(52);
-  });
+  it('composes functions correctly', () => {
+    const addOne = (x: number) => x + 1;
+    const multiplyByTwo = (x: number) => x * 2;
+    const subtractThree = (x: number) => x - 3;
 
-  it('should return a function', () => {
-    const result = flow();
-    expect(typeof result).toBe('function');
+    const composed = flow(addOne, multiplyByTwo, subtractThree);
+    expect(composed(5)).toBe(9); // (5 + 1) * 2 - 3 = 9
   });
 
-  it('should throw an error if any argument is not a function', () => {
-    expect(() => {
-      flow(1 as unknown as Function, () => {});
-    }).toThrow(TypeError);
+  it('works with single function', () => {
+    const double = (x: number) => x * 2;
+    const fn = flow(double);
+    expect(fn(5)).toBe(10);
   });
 
-  it('should return the input argument if no functions are provided', () => {
-    const input = 'test';
-    const result = flow()(input);
-    expect(result).toBe(input);
+  it('works with multiple functions', () => {
+    const fn1 = (n: number) => n + 1;
+    const fn2 = (n: number) => n * 2;
+    const fn3 = (n: number) => n - 1;
+
+    const composed = flow(fn1, fn2, fn3);
+    expect(composed(5)).toBe(11); // ((5 + 1) * 2) - 1 = 11
   });
 });

package/src/utils/flow.ts

@@ -11,10 +11,10 @@ export default function flow(...funcs: Function[]): Function {
   }
   return (...args: Function[]) => {
     let i = 0;
-    let result = length ? funcs[i].apply(this, args) : args[0];
+    let result = length ? funcs[i].apply(undefined, args) : args[0];
     while (i + 1 < length) {
       i += 1;
-      result = funcs[i].call(this, result);
+      result = funcs[i].call(undefined, result);
     }
     return result;
   };

package/src/utils/index.ts

@@ -1,3 +1,3 @@
 export { default as flow } from './flow';
 export { default as isServer } from './isServer';
-export { default as getMaskOptions } from './getMaskOptions';
+export { default as moduleInterop } from './moduleInterop';

package/src/utils/isServer.spec.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+
+describe('isServer', () => {
+  it('returns boolean value', async () => {
+    const { default: isServer } = await import('./isServer');
+    expect(typeof isServer).toBe('boolean');
+  });
+
+  it('returns false in browser environment', async () => {
+    // in jsdom environment, window and document exist
+    const { default: isServer } = await import('./isServer');
+    // in test environment with jsdom, it should be false
+    expect(isServer).toBe(false);
+  });
+});

package/src/utils/moduleInterop.spec.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest';
+
+import interopDefaultSync from './moduleInterop';
+
+describe('interopDefaultSync', () => {
+  it('returns module with default export', () => {
+    const module = { default: 'test' };
+    expect(interopDefaultSync(module)).toBe('test');
+  });
+
+  it('returns module without default export', () => {
+    const module = { foo: 'bar' };
+    expect(interopDefaultSync(module)).toBe(module);
+  });
+
+  it('returns non-object values as-is', () => {
+    expect(interopDefaultSync('string')).toBe('string');
+    expect(interopDefaultSync(123)).toBe(123);
+    expect(interopDefaultSync(null)).toBe(null);
+    // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+    expect(interopDefaultSync(undefined)).toBe(undefined);
+  });
+
+  it('handles null module', () => {
+    expect(interopDefaultSync(null)).toBe(null);
+  });
+
+  it('handles module with null default', () => {
+    const module = { default: null };
+    expect(interopDefaultSync(module)).toBe(null);
+  });
+
+  it('handles module with undefined default', () => {
+    const module = { default: undefined };
+    expect(interopDefaultSync(module)).toBe(undefined);
+  });
+});

package/src/useHookFormMask.ts

@@ -1,47 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable import-x/no-extraneous-dependencies */
-import inputmask from 'inputmask';
-
-import { flow, getMaskOptions } from './utils';
-import interopDefaultSync from './utils/moduleInterop';
-
-import type { RefCallback } from 'react';
-import type {
-  FieldValues, Path,
-  RegisterOptions,
-  UseFormRegister,
-  UseFormRegisterReturn,
-} from 'react-hook-form';
-
-import type { Mask, Options } from './types';
-
-export default function useHookFormMask<
-  T extends FieldValues, D extends RegisterOptions,
->(registerFn: UseFormRegister<T>) {
-  return (fieldName: Path<T>, mask: Mask, options?: (
-    D & Options) | Options | D): UseFormRegisterReturn<Path<T>> => {
-    if (!registerFn) throw new Error('registerFn is required');
-
-    const { ref, ...restRegister } = registerFn(fieldName, options as any);
-
-    const maskInput = interopDefaultSync(inputmask)(getMaskOptions(mask, options as any));
-
-    const newRef = flow((_ref: HTMLElement) => {
-      if (_ref) {
-        const { nodeName } = _ref;
-
-        if (nodeName !== 'INPUT') {
-          maskInput.mask(_ref.querySelector('input') as HTMLElement);
-        } else {
-          maskInput.mask(_ref);
-        }
-      }
-      return _ref;
-    }, ref) as RefCallback<HTMLElement>;
-
-    return {
-      ...restRegister,
-      ref: newRef,
-    };
-  };
-}

package/src/useMaskInput.ts

@@ -1,41 +0,0 @@
-/* eslint-disable import-x/no-extraneous-dependencies */
-import { useEffect, useRef } from 'react';
-
-import inputmask from 'inputmask';
-
-import { getMaskOptions } from './utils';
-import isServer from './utils/isServer';
-import interopDefaultSync from './utils/moduleInterop';
-
-import type { RefObject } from 'react';
-
-import type { Mask, Options } from './types';
-
-interface UseInputMaskOptions {
-  mask: Mask;
-  register?: (element: HTMLElement) => void;
-  options?: Options;
-}
-
-export default function useInputMask(props: UseInputMaskOptions): RefObject<HTMLInputElement> {
-  const { mask, register, options } = props;
-  const ref = useRef<HTMLInputElement>(null);
-  if (isServer) return ref;
-
-  // eslint-disable-next-line react-hooks/rules-of-hooks
-  useEffect(() => {
-    if (!isServer && ref.current) {
-      if (!ref.current) return;
-
-      const maskInput = interopDefaultSync(inputmask)(getMaskOptions(mask, options));
-
-      maskInput.mask(ref.current);
-
-      if (register && ref.current) {
-        register(ref.current);
-      }
-    }
-  }, [mask, register, options]);
-
-  return ref;
-}

package/src/utils/getMaskOptions.spec.ts

@@ -1,126 +0,0 @@
-import { describe, expect, it } from 'vitest';
-
-import getMaskOptions from './getMaskOptions';
-
-describe('getMaskOptions', () => {
-  it('returns default options when no mask is provided', () => {
-    const options = getMaskOptions();
-    expect(options).toEqual({
-      jitMasking: false,
-    });
-  });
-
-  it('returns options for datetime mask', () => {
-    const options = getMaskOptions('datetime');
-    expect(options).toEqual({
-      alias: 'datetime',
-      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 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 custom mask', () => {
-    const options = getMaskOptions('999-999');
-    expect(options).toEqual({
-      mask: '999-999',
-      jitMasking: false,
-    });
-  });
-});

package/src/utils/getMaskOptions.ts

@@ -1,94 +0,0 @@
-import type { Mask, Options } from '../types';
-
-export default function getMaskOptions(mask?: Mask, _options?: Options): Options {
-  const options: Options = {
-    jitMasking: false,
-    ..._options,
-  };
-  if (!mask) return options;
-
-  const masks: Record<string, Inputmask.Options> = {
-    datetime: {
-      alias: 'datetime',
-      ...options,
-    },
-    email: {
-      alias: 'email',
-      placeholder: '',
-      ...options,
-    },
-    numeric: {
-      alias: 'numeric',
-      placeholder: '',
-      ...options,
-    },
-    currency: {
-      alias: 'currency',
-      prefix: '$ ',
-      placeholder: '',
-      ...options,
-    },
-    decimal: {
-      alias: 'decimal',
-      placeholder: '',
-      ...options,
-    },
-    integer: {
-      alias: 'integer',
-      placeholder: '',
-      ...options,
-    },
-    percentage: {
-      alias: 'percentage',
-      placeholder: ' %',
-      suffix: ' %',
-      ...options,
-    },
-    url: {
-      alias: 'url',
-      placeholder: 'https://',
-      ...options,
-    },
-    ip: {
-      alias: 'ip',
-      ...options,
-    },
-    mac: {
-      alias: 'mac',
-      ...options,
-    },
-    ssn: {
-      alias: 'ssn',
-      ...options,
-    },
-
-    // alias for brazilians <3
-    // ty <3
-    'brl-currency': {
-      alias: 'currency',
-      prefix: 'R$ ',
-      placeholder: '0,00',
-      displayFormat: 'currency',
-      radixPoint: ',',
-      autoUnmask: true,
-      ...options,
-    },
-    cpf: {
-      mask: '999.999.999-99',
-      placeholder: '___.___.___-__',
-      ...options,
-    },
-    cnpj: {
-      mask: ['A|9{2}.A|9{3}.A|9{3}/A|9{4}-9{2}'],
-      placeholder: '__.___.___/____-__',
-      ...options,
-    },
-  };
-
-  if (typeof mask === 'string' && masks[mask]) return masks[mask];
-
-  return {
-    mask,
-    ...options,
-  };
-}

package/src/withHookFormMask.ts

@@ -1,34 +0,0 @@
-/* eslint-disable import-x/no-extraneous-dependencies */
-import inputmask from 'inputmask';
-
-import { flow, getMaskOptions } from './utils';
-import interopDefaultSync from './utils/moduleInterop';
-
-import type { RefCallback } from 'react';
-
-import type { Mask, Options, UseFormRegisterReturn } from './types';
-
-export default function withHookFormMask(
-  register: UseFormRegisterReturn,
-  mask: Mask,
-  options?: Options,
-): UseFormRegisterReturn {
-  //
-  let newRef;
-
-  if (register) {
-    const { ref } = register;
-
-    const maskInput = interopDefaultSync(inputmask)(getMaskOptions(mask, options));
-
-    newRef = flow((_ref: HTMLElement) => {
-      if (_ref) maskInput.mask(_ref);
-      return _ref;
-    }, ref) as RefCallback<HTMLElement>;
-  }
-
-  return {
-    ...register,
-    ref: newRef as RefCallback<HTMLElement>,
-  };
-}

package/src/withMask.ts

@@ -1,18 +0,0 @@
-/* eslint-disable import-x/no-extraneous-dependencies */
-import inputmask from 'inputmask';
-
-import { getMaskOptions } from './utils';
-import isServer from './utils/isServer';
-import interopDefaultSync from './utils/moduleInterop';
-
-import type { Input, Mask, Options } from './types';
-
-export default function withMask(mask: Mask, options?: Options) {
-  return (input: Input | null): void => {
-    if (isServer || mask === null || !input) return;
-
-    const maskInput = interopDefaultSync(inputmask)(getMaskOptions(mask, options));
-
-    maskInput.mask(input);
-  };
-}