flutter_masked_text.dart

library custom_flutter_masked_text;

import 'package:flutter/material.dart';

class MaskedTextController extends TextEditingController {
  MaskedTextController({
    required String text,
    required this.mask,
    Map<String, RegExp>? translator,
  }) : super(text: text) {
    translator = translator ?? MaskedTextController.getDefaultTranslator();

    addListener(() {
      var previous = _lastUpdatedText;
      if (beforeChange(previous, text)) {
        updateText(text);
        afterChange(previous, text);
      } else {
        updateText(_lastUpdatedText);
      }
    });

    updateText(this.text);
  }

  String mask;

  Map<String, RegExp>? translator;

  void afterChange(
    String? previous,
    String next,
  ) {}

  bool beforeChange(
    String? previous,
    String next,
  ) {
    return true;
  }

  String get rawText {
    String localMask = mask;
    String localText = text;
    for (int i = 0; i < localMask.length; i++) {
      var aux = localMask.substring(i, i + 1);
      if ((localMask.substring(i, i + 1) != '0') &&
          (localMask.substring(i, i + 1) != 'A') &&
          (localMask.substring(i, i + 1) != '@') &&
          (localMask.substring(i, i + 1) != '*')) {
        localText = localText.replaceFirst(aux, '|');
      }
    }
    return localText.replaceAll('|', '');
  }

  String get rawNumberValue {
    RegExp exp = RegExp(r'[^0-9]');
    return text.replaceAll(exp, '');
  }

  String get numberValue {
    String localMask = mask;
    for (int i = 0; i < localMask.length; i++) {
      var aux = localMask.substring(i, i + 1);
      if ((localMask.substring(i, i + 1) != '0') &&
          (localMask.substring(i, i + 1) != 'A') &&
          (localMask.substring(i, i + 1) != '@') &&
          (localMask.substring(i, i + 1) != '*')) {
        localMask = localMask.replaceFirst(aux, '0');
      }
    }
    return _applyMask(localMask, text);
  }

  String? _lastUpdatedText = '';

  void updateText(String? text) {
    if (text != null) {
      text = _applyMask(mask, text);
    } else {
      text = '';
    }

    _lastUpdatedText = text;
  }

  void updateMask(
    String mask, {
    bool moveCursorToEnd = true,
  }) {
    mask = mask;
    updateText(text);

    if (moveCursorToEnd) {
      this.moveCursorToEnd();
    }
  }

  void moveCursorToEnd() {
    String? text = _lastUpdatedText;
    selection = TextSelection.fromPosition(
      TextPosition(offset: (text ?? '').length),
    );
  }

  @override
  set text(String text) {
    if (super.text != text) {
      super.text = text;
      moveCursorToEnd();
    }
  }

  static Map<String, RegExp> getDefaultTranslator() {
    return {
      'A': RegExp(r'[A-Za-z]'),
      '0': RegExp(r'[0-9]'),
      '@': RegExp(r'[A-Za-z0-9]'),
      '*': RegExp(r'.*'),
    };
  }

  String _applyMask(String mask, String value) {
    String result = '';

    var maskCharIndex = 0;
    var valueCharIndex = 0;

    while (true) {
      // if mask is ended, break.
      if (maskCharIndex == mask.length) {
        break;
      }

      // if value is ended, break.
      if (valueCharIndex == value.length) {
        break;
      }

      var maskChar = mask[maskCharIndex];
      var valueChar = value[valueCharIndex];

      // value equals mask, just set
      if (maskChar == valueChar) {
        result += maskChar;
        valueCharIndex += 1;
        maskCharIndex += 1;
        continue;
      }

      // apply translator if match
      if (translator!.containsKey(maskChar)) {
        if (translator![maskChar]!.hasMatch(valueChar)) {
          result += valueChar;
          maskCharIndex += 1;
        }

        valueCharIndex += 1;
        continue;
      }

      // not masked value, fixed char on mask
      result += maskChar;
      maskCharIndex += 1;
      continue;
    }

    return result;
  }
}

//
// Mask for monetary values.
//

class CustomMoneyMaskedTextController extends TextEditingController {
  CustomMoneyMaskedTextController({
    double initialValue = 0.0,
    this.decimalSeparator = ',',
    this.thousandSeparator = '.',
    this.rightSymbol = '',
    this.leftSymbol = '',
    this.precision = 2,
  }) {
    _validateConfig();

    addListener(() {
      updateValue(numberValue);
      afterChange(text, numberValue);
    });

    updateValue(initialValue);
  }

  final String decimalSeparator;
  final String thousandSeparator;
  final String rightSymbol;
  final String leftSymbol;
  final int precision;

  void afterChange(
    String maskedValue,
    double rawValue,
  ) {}

  double _lastValue = 0.0;

  void updateValue(double value) {
    double valueToUse = value;

    if (value.toStringAsFixed(0).length > 12) {
      valueToUse = _lastValue;
    } else {
      _lastValue = value;
    }

    String masked = _applyMask(valueToUse);

    if (rightSymbol.isNotEmpty) {
      masked += rightSymbol;
    }

    if (leftSymbol.isNotEmpty) {
      masked = leftSymbol + masked;
    }

    if (masked != text) {
      text = masked;

      var cursorPosition = super.text.length - rightSymbol.length;
      selection = TextSelection.fromPosition(TextPosition(offset: cursorPosition));
    }
  }

  double get numberValue {
    List<String> parts = _getOnlyNumbers(text).split('').toList(growable: true);

    parts.insert(parts.length - precision, '.');

    return double.parse(parts.join());
  }

  _validateConfig() {
    bool rightSymbolHasNumbers = _getOnlyNumbers(rightSymbol).isNotEmpty;

    if (rightSymbolHasNumbers) {
      throw ArgumentError('rightSymbol must not have numbers.');
    }
  }

  String _getOnlyNumbers(String text) {
    String cleanedText = text;

    var onlyNumbersRegex = RegExp(r'[^\d]');

    cleanedText = cleanedText.replaceAll(onlyNumbersRegex, '');

    return cleanedText;
  }

  String _applyMask(double value) {
    List<String> textRepresentation =
        value.toStringAsFixed(precision).replaceAll('.', '').split('').reversed.toList(growable: true);

    textRepresentation.insert(precision, decimalSeparator);

    for (var i = precision + 4; true; i = i + 4) {
      if (textRepresentation.length > i) {
        textRepresentation.insert(i, thousandSeparator);
      } else {
        break;
      }
    }

    return textRepresentation.reversed.join('');
  }
}