Text Mask Addons

import { createNumberMask, emailMask, createAutoCorrectedDatePipe } from "text-mask-addons";

import createNumberMask from 'text-mask-addons/dist/createNumberMask';
import emailMask from 'text-mask-addons/dist/emailMask';
import createAutoCorrectedDatePipe from 'text-mask-addons/dist/createAutoCorrectedDatePipe';

const { createNumberMask, emailMask, createAutoCorrectedDatePipe } = require("text-mask-addons");

import { createNumberMask, emailMask, createAutoCorrectedDatePipe } from "text-mask-addons";

// Currency mask
const currencyMask = createNumberMask({
  prefix: '$',
  includeThousandsSeparator: true,
  allowDecimal: true,
  decimalLimit: 2
});

// Email mask (use directly)
const emailInputMask = emailMask;

// Date correction pipe
const datePipe = createAutoCorrectedDatePipe('mm/dd/yyyy', {
  minYear: 1900,
  maxYear: 2100
});

/**
 * Creates a number/currency formatting mask function
 * @param {NumberMaskConfig} config - Configuration options
 * @returns {MaskFunction} Mask function that takes rawValue and returns mask array
 */
function createNumberMask(config = {}): MaskFunction;

interface NumberMaskConfig {
  /** Text to display before the amount. Defaults to '$' */
  prefix?: string;
  /** Text to display after the amount. Defaults to '' */
  suffix?: string;
  /** Whether to separate thousands. Defaults to true */
  includeThousandsSeparator?: boolean;
  /** Character for thousands separation. Defaults to ',' */
  thousandsSeparatorSymbol?: string;
  /** Allow decimal fraction input. Defaults to false */
  allowDecimal?: boolean;
  /** Character for decimal point. Defaults to '.' */
  decimalSymbol?: string;
  /** Maximum digits after decimal. Defaults to 2 */
  decimalLimit?: number;
  /** Always include decimal point. Defaults to false */
  requireDecimal?: boolean;
  /** Allow negative numbers. Defaults to false */
  allowNegative?: boolean;
  /** Allow leading zeros. Defaults to false */
  allowLeadingZeroes?: boolean;
  /** Maximum length of integer part. Defaults to null (unlimited) */
  integerLimit?: number | null;
}

// Basic currency mask
const dollarMask = createNumberMask();
// Uses default: prefix '$', thousands separator, no decimals

// European currency format
const euroMask = createNumberMask({
  prefix: '€ ',
  thousandsSeparatorSymbol: '.',
  decimalSymbol: ',',
  allowDecimal: true
});

// Percentage input
const percentMask = createNumberMask({
  prefix: '',
  suffix: '%',
  allowDecimal: true,
  decimalLimit: 1
});

// Integer-only with custom limits
const integerMask = createNumberMask({
  prefix: '',
  includeThousandsSeparator: false,
  integerLimit: 6,
  allowNegative: true
});

/**
 * Email mask object containing both mask and pipe functions
 * Used directly with Text Mask - no configuration needed
 */
const emailMask: {
  /** 
   * Mask function for email input formatting
   * @param {string} rawValue - Current input value
   * @param {Object} config - Text Mask configuration object
   * @returns {Array} Mask array for input formatting
   */
  mask: (rawValue: string, config: MaskConfig) => Array<string | RegExp>;
  /** 
   * Pipe function for email input validation and correction
   * @param {string} conformedValue - Value after mask is applied
   * @param {Object} config - Text Mask configuration object
   * @returns {string | false} Corrected value or false to reject
   */  
  pipe: (conformedValue: string, config: PipeConfig) => string | false;
};

interface MaskConfig {
  placeholderChar: string;
  currentCaretPosition: number;
}

interface PipeConfig {
  currentCaretPosition: number;
  rawValue: string;
  previousConformedValue: string;
  placeholderChar: string;
}

import emailMask from 'text-mask-addons/dist/emailMask';

// Use directly with Text Mask component
// emailMask is a special object containing both mask and pipe functions
// Text Mask automatically separates them internally
// The mask handles @ and . positioning automatically
// The pipe validates email format and prevents invalid input

/**
 * Creates a date auto-correction pipe function
 * @param {string} dateFormat - Date format pattern. Defaults to 'mm dd yyyy'
 * @param {DatePipeConfig} config - Configuration options
 * @returns {DatePipeFunction} Pipe function for date correction
 */
function createAutoCorrectedDatePipe(dateFormat = 'mm dd yyyy', config = {}): DatePipeFunction;

interface DatePipeConfig {
  /** Minimum allowed year. Defaults to 1 */
  minYear?: number;
  /** Maximum allowed year. Defaults to 9999 */
  maxYear?: number;
}

interface DatePipeResult {
  /** Corrected date value */
  value: string;
  /** Array of character positions that were auto-corrected */
  indexesOfPipedChars: number[];
}

/** 
 * Date correction pipe function
 * @param {string} conformedValue - Date value after mask is applied
 * @returns {DatePipeResult | false} Corrected result or false if invalid
 */
type DatePipeFunction = (conformedValue: string) => DatePipeResult | false;

// Basic date pipe
const datePipe = createAutoCorrectedDatePipe('mm/dd/yyyy');

// Custom format with time
const dateTimePipe = createAutoCorrectedDatePipe('dd.mm.yyyy HH:MM');

// Limited year range
const modernDatePipe = createAutoCorrectedDatePipe('mm/dd/yyyy', {
  minYear: 1900,
  maxYear: 2030
});

// European format
const europeanDatePipe = createAutoCorrectedDatePipe('dd/mm/yyyy');

/** RegExp for matching single digits (/\d/) - used internally by mask functions */
const digitRegExp: RegExp;

/** Special character for caret positioning in masks ('[]') - used internally by mask functions */
const caretTrap: string;

/** 
 * Mask function type - takes raw input and returns formatting mask
 * @param {string} rawValue - Current input value
 * @returns {Array<string | RegExp>} Array of strings and RegExp patterns for masking
 */
type MaskFunction = (rawValue: string) => Array<string | RegExp>;

/**
 * Pipe function type - takes formatted value and returns corrected value
 * @param {string} conformedValue - Value after mask is applied
 * @param {PipeConfig} config - Text Mask configuration
 * @returns {string | false} Corrected value or false to reject input
 */  
type PipeFunction = (conformedValue: string, config: PipeConfig) => string | false;